summaryrefslogtreecommitdiff
path: root/libjava/classpath/gnu/java/awt/font
diff options
context:
space:
mode:
authorupstream source tree <ports@midipix.org>2015-03-15 20:14:05 -0400
committerupstream source tree <ports@midipix.org>2015-03-15 20:14:05 -0400
commit554fd8c5195424bdbcabf5de30fdc183aba391bd (patch)
tree976dc5ab7fddf506dadce60ae936f43f58787092 /libjava/classpath/gnu/java/awt/font
downloadcbb-gcc-4.6.4-554fd8c5195424bdbcabf5de30fdc183aba391bd.tar.bz2
cbb-gcc-4.6.4-554fd8c5195424bdbcabf5de30fdc183aba391bd.tar.xz
obtained gcc-4.6.4.tar.bz2 from upstream website;upstream
verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository.
Diffstat (limited to 'libjava/classpath/gnu/java/awt/font')
-rw-r--r--libjava/classpath/gnu/java/awt/font/FontDelegate.java329
-rw-r--r--libjava/classpath/gnu/java/awt/font/FontFactory.java90
-rw-r--r--libjava/classpath/gnu/java/awt/font/GNUGlyphVector.java663
-rw-r--r--libjava/classpath/gnu/java/awt/font/OpenTypeFontPeer.java565
-rw-r--r--libjava/classpath/gnu/java/awt/font/autofit/AutoHinter.java83
-rw-r--r--libjava/classpath/gnu/java/awt/font/autofit/AxisHints.java112
-rw-r--r--libjava/classpath/gnu/java/awt/font/autofit/Constants.java86
-rw-r--r--libjava/classpath/gnu/java/awt/font/autofit/Edge.java82
-rw-r--r--libjava/classpath/gnu/java/awt/font/autofit/GlyphHints.java640
-rw-r--r--libjava/classpath/gnu/java/awt/font/autofit/HintScaler.java53
-rw-r--r--libjava/classpath/gnu/java/awt/font/autofit/Latin.java1363
-rw-r--r--libjava/classpath/gnu/java/awt/font/autofit/LatinAxis.java62
-rw-r--r--libjava/classpath/gnu/java/awt/font/autofit/LatinBlue.java61
-rw-r--r--libjava/classpath/gnu/java/awt/font/autofit/LatinMetrics.java66
-rw-r--r--libjava/classpath/gnu/java/awt/font/autofit/Script.java62
-rw-r--r--libjava/classpath/gnu/java/awt/font/autofit/ScriptMetrics.java53
-rw-r--r--libjava/classpath/gnu/java/awt/font/autofit/Segment.java97
-rw-r--r--libjava/classpath/gnu/java/awt/font/autofit/Utils.java255
-rw-r--r--libjava/classpath/gnu/java/awt/font/autofit/Width.java64
-rw-r--r--libjava/classpath/gnu/java/awt/font/opentype/CharGlyphMap.java1027
-rw-r--r--libjava/classpath/gnu/java/awt/font/opentype/GlyphNamer.java1135
-rw-r--r--libjava/classpath/gnu/java/awt/font/opentype/Hinter.java63
-rw-r--r--libjava/classpath/gnu/java/awt/font/opentype/MacResourceFork.java235
-rw-r--r--libjava/classpath/gnu/java/awt/font/opentype/NameDecoder.java702
-rw-r--r--libjava/classpath/gnu/java/awt/font/opentype/OpenTypeFont.java882
-rw-r--r--libjava/classpath/gnu/java/awt/font/opentype/OpenTypeFontFactory.java140
-rw-r--r--libjava/classpath/gnu/java/awt/font/opentype/Scaler.java205
-rw-r--r--libjava/classpath/gnu/java/awt/font/opentype/truetype/Fixed.java176
-rw-r--r--libjava/classpath/gnu/java/awt/font/opentype/truetype/GlyphLoader.java447
-rw-r--r--libjava/classpath/gnu/java/awt/font/opentype/truetype/GlyphLocator.java187
-rw-r--r--libjava/classpath/gnu/java/awt/font/opentype/truetype/GlyphMeasurer.java228
-rw-r--r--libjava/classpath/gnu/java/awt/font/opentype/truetype/Point.java287
-rw-r--r--libjava/classpath/gnu/java/awt/font/opentype/truetype/TrueTypeScaler.java380
-rw-r--r--libjava/classpath/gnu/java/awt/font/opentype/truetype/VirtualMachine.java1815
-rw-r--r--libjava/classpath/gnu/java/awt/font/opentype/truetype/Zone.java291
-rw-r--r--libjava/classpath/gnu/java/awt/font/opentype/truetype/ZonePathIterator.java393
-rw-r--r--libjava/classpath/gnu/java/awt/font/opentype/truetype/doc-files/ZonePathIterator-1.diabin0 -> 1572 bytes
-rw-r--r--libjava/classpath/gnu/java/awt/font/opentype/truetype/doc-files/ZonePathIterator-1.pngbin0 -> 11278 bytes
38 files changed, 13379 insertions, 0 deletions
diff --git a/libjava/classpath/gnu/java/awt/font/FontDelegate.java b/libjava/classpath/gnu/java/awt/font/FontDelegate.java
new file mode 100644
index 000000000..e5c03a10f
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/FontDelegate.java
@@ -0,0 +1,329 @@
+/* FontDelegate.java -- Interface implemented by all font delegates.
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.font;
+
+import java.awt.Font;
+import java.awt.font.FontRenderContext;
+import java.awt.font.GlyphVector;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.GeneralPath;
+import java.awt.geom.Point2D;
+import java.text.CharacterIterator;
+import java.util.Locale;
+
+
+/**
+ * The interface that all font delegate objects implement,
+ * irrespective of where they get their information from.
+ *
+ * <p><b>Thread Safety:</b> All classes that implement the
+ * <code>FontDelegate</code> interface must allow calling these
+ * methods from multiple concurrent threads. The delegates are
+ * responsible for performing the necessary synchronization.
+ *
+ * @author Sascha Brawer (brawer@dandelis.ch)
+ */
+public interface FontDelegate
+{
+ public static final int FLAG_FITTED = 1 << 0;
+ public static final int FLAG_NO_HINT_HORIZONTAL = 1 << 1;
+ public static final int FLAG_NO_HINT_VERTICAL = 1 << 2;
+ public static final int FLAG_NO_HINT_EDGE_POINTS = 1 << 3;
+ public static final int FLAG_NO_HINT_STRONG_POINTS = 1 << 4;
+ public static final int FLAG_NO_HINT_WEAK_POINTS = 1 << 5;
+
+ /**
+ * Returns the full name of this font face in the specified
+ * locale, for example <i>&#x201c;Univers Light&#x201d;</i>.
+ *
+ * @param locale the locale for which to localize the name.
+ *
+ * @return the face name.
+ */
+ public String getFullName(Locale locale);
+
+
+ /**
+ * Returns the name of the family to which this font face belongs,
+ * for example <i>&#x201c;Univers&#x201d;</i>.
+ *
+ * @param locale the locale for which to localize the name.
+ *
+ * @return the family name.
+ */
+ public String getFamilyName(Locale locale);
+
+
+ /**
+ * Returns the name of this font face inside the family, for example
+ * <i>&#x201c;Light&#x201d;</i>.
+ *
+ * @param locale the locale for which to localize the name.
+ *
+ * @return the name of the face inside its family.
+ */
+ public String getSubFamilyName(Locale locale);
+
+
+ /**
+ * Returns the PostScript name of this font face, for example
+ * <i>&#x201c;Helvetica-Bold&#x201d;</i>.
+ *
+ * @return the PostScript name, or <code>null</code> if the font
+ * does not provide a PostScript name.
+ */
+ public String getPostScriptName();
+
+
+ /**
+ * Returns the number of glyphs in this font face.
+ */
+ public int getNumGlyphs();
+
+ /**
+ * Returns the glyph code for the specified character.
+ *
+ * @param c the character to map
+ *
+ * @return the glyph code
+ */
+ public int getGlyphIndex(int c);
+
+ /**
+ * Returns the index of the glyph which gets displayed if the font
+ * cannot map a Unicode code point to a glyph. Many fonts show this
+ * glyph as an empty box.
+ */
+ public int getMissingGlyphCode();
+
+
+ /**
+ * Creates a GlyphVector by mapping each character in a
+ * CharacterIterator to the corresponding glyph.
+ *
+ * <p>The mapping takes only the font&#x2019;s <code>cmap</code>
+ * tables into consideration. No other operations (such as glyph
+ * re-ordering, composition, or ligature substitution) are
+ * performed. This means that the resulting GlyphVector will not be
+ * correct for text in languages that have complex
+ * character-to-glyph mappings, such as Arabic, Hebrew, Hindi, or
+ * Thai.
+ *
+ * @param font the font object that the created GlyphVector
+ * will return when it gets asked for its font. This argument is
+ * needed because the public API works with java.awt.Font,
+ * not with some private delegate like OpenTypeFont.
+ *
+ * @param frc the font rendering parameters that are used for
+ * measuring glyphs. The exact placement of text slightly depends on
+ * device-specific characteristics, for instance the device
+ * resolution or anti-aliasing. For this reason, any measurements
+ * will only be accurate if the passed
+ * <code>FontRenderContext</code> correctly reflects the relevant
+ * parameters. Hence, <code>frc</code> should be obtained from the
+ * same <code>Graphics2D</code> that will be used for drawing, and
+ * any rendering hints should be set to the desired values before
+ * obtaining <code>frc</code>.
+ *
+ * @param ci a CharacterIterator for iterating over the
+ * characters to be displayed.
+ */
+ public GlyphVector createGlyphVector(Font font,
+ FontRenderContext frc,
+ CharacterIterator ci);
+
+
+ /**
+ * Determines the advance width and height for a glyph.
+ *
+ * @param glyphIndex the glyph whose advance width is to be
+ * determined.
+ *
+ * @param pointSize the point size of the font.
+ *
+ * @param transform a transform that is applied in addition to
+ * scaling to the specified point size. This is often used for
+ * scaling according to the device resolution. Those who lack any
+ * aesthetic sense may also use the transform to slant or stretch
+ * glyphs.
+ *
+ * @param antialias <code>true</code> for anti-aliased rendering,
+ * <code>false</code> for normal rendering. For hinted fonts,
+ * this parameter may indeed affect the result.
+ *
+ * @param fractionalMetrics <code>true</code> for fractional metrics,
+ * <code>false</code> for rounding the result to a pixel boundary.
+ *
+ * @param horizontal <code>true</code> for horizontal line layout,
+ * <code>false</code> for vertical line layout.
+ *
+ * @param advance a point whose <code>x</code> and <code>y</code>
+ * fields will hold the advance in each direction. It is well
+ * possible that both values are non-zero, for example for rotated
+ * text or for Urdu fonts.
+ */
+ public void getAdvance(int glyphIndex,
+ float pointSize,
+ AffineTransform transform,
+ boolean antialias,
+ boolean fractionalMetrics,
+ boolean horizontal,
+ Point2D advance);
+
+
+ /**
+ * Returns the shape of a glyph.
+ *
+ * @param glyphIndex the glyph whose advance width is to be
+ * determined.
+ *
+ * @param pointSize the point size of the font.
+ *
+ * @param transform a transform that is applied in addition to
+ * scaling to the specified point size. This is often used for
+ * scaling according to the device resolution. Those who lack any
+ * aesthetic sense may also use the transform to slant or stretch
+ * glyphs.
+ *
+ * @param antialias <code>true</code> for anti-aliased rendering,
+ * <code>false</code> for normal rendering. For hinted fonts, this
+ * parameter may indeed affect the result.
+ *
+ * @param fractionalMetrics <code>true</code> for fractional
+ * metrics, <code>false</code> for rounding the result to a pixel
+ * boundary.
+ *
+ * @return the scaled and grid-fitted outline of the specified
+ * glyph, or <code>null</code> for bitmap fonts.
+ */
+ public GeneralPath getGlyphOutline(int glyphIndex,
+ float pointSize,
+ AffineTransform transform,
+ boolean antialias,
+ boolean fractionalMetrics,
+ int type);
+
+
+ /**
+ * Returns a name for the specified glyph. This is useful for
+ * generating PostScript or PDF files that embed some glyphs of a
+ * font.
+ *
+ * <p><b>Names are not unique:</b> Under some rare circumstances,
+ * the same name can be returned for different glyphs. It is
+ * therefore recommended that printer drivers check whether the same
+ * name has already been returned for antoher glyph, and make the
+ * name unique by adding the string ".alt" followed by the glyph
+ * index.</p>
+ *
+ * <p>This situation would occur for an OpenType or TrueType font
+ * that has a <code>post</code> table of format 3 and provides a
+ * mapping from glyph IDs to Unicode sequences through a
+ * <code>Zapf</code> table. If the same sequence of Unicode
+ * codepoints leads to different glyphs (depending on contextual
+ * position, for example, or on typographic sophistication level),
+ * the same name would get synthesized for those glyphs.
+ *
+ * @param glyphIndex the glyph whose name the caller wants to
+ * retrieve.
+ */
+ public String getGlyphName(int glyphIndex);
+
+
+ /**
+ * Determines the distance between the base line and the highest
+ * ascender.
+ *
+ * @param pointSize the point size of the font.
+ *
+ * @param transform a transform that is applied in addition to
+ * scaling to the specified point size. This is often used for
+ * scaling according to the device resolution. Those who lack any
+ * aesthetic sense may also use the transform to slant or stretch
+ * glyphs.
+ *
+ * @param antialiased <code>true</code> for anti-aliased rendering,
+ * <code>false</code> for normal rendering. For hinted fonts,
+ * this parameter may indeed affect the result.
+ *
+ * @param fractionalMetrics <code>true</code> for fractional metrics,
+ * <code>false</code> for rounding the result to a pixel boundary.
+ *
+ * @param horizontal <code>true</code> for horizontal line layout,
+ * <code>false</code> for vertical line layout.
+ *
+ * @return the ascent, which usually is a positive number.
+ */
+ public float getAscent(float pointSize,
+ AffineTransform transform,
+ boolean antialiased,
+ boolean fractionalMetrics,
+ boolean horizontal);
+
+
+ /**
+ * Determines the distance between the base line and the lowest
+ * descender.
+ *
+ * @param pointSize the point size of the font.
+ *
+ * @param transform a transform that is applied in addition to
+ * scaling to the specified point size. This is often used for
+ * scaling according to the device resolution. Those who lack any
+ * aesthetic sense may also use the transform to slant or stretch
+ * glyphs.
+ *
+ * @param antialiased <code>true</code> for anti-aliased rendering,
+ * <code>false</code> for normal rendering. For hinted fonts,
+ * this parameter may indeed affect the result.
+ *
+ * @param fractionalMetrics <code>true</code> for fractional metrics,
+ * <code>false</code> for rounding the result to a pixel boundary.
+ *
+ * @param horizontal <code>true</code> for horizontal line layout,
+ * <code>false</code> for vertical line layout.
+ *
+ * @return the descent, which usually is a nagative number.
+ */
+ public float getDescent(float pointSize,
+ AffineTransform transform,
+ boolean antialiased,
+ boolean fractionalMetrics,
+ boolean horizontal);
+}
diff --git a/libjava/classpath/gnu/java/awt/font/FontFactory.java b/libjava/classpath/gnu/java/awt/font/FontFactory.java
new file mode 100644
index 000000000..53eb5df5f
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/FontFactory.java
@@ -0,0 +1,90 @@
+/* FontFactory.java -- Factory for font delegates.
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.font;
+
+import java.nio.ByteBuffer;
+
+import java.awt.FontFormatException;
+import gnu.java.awt.font.opentype.OpenTypeFontFactory;
+
+
+/**
+ * A factory for creating font delegate objects.
+ *
+ * @author Sascha Brawer (brawer@dandelis.ch)
+ */
+public final class FontFactory
+{
+ /**
+ * The constructor is private so nobody can construct an instance
+ */
+ private FontFactory()
+ {
+ }
+
+
+ /**
+ * Creates FontDelegate objects for the fonts in the specified buffer.
+ * The following font formats are currently recognized:
+ * recognized font formats are:
+ *
+ * <p><ul>
+ * <li>OpenType (*.otf);</li>
+ * <li>TrueType (*.ttf);</li>
+ * <li>TrueType Collections (*.ttc);</li>
+ * <li>Apple MacOS X data-fork font (*.dfont).</li></ul>
+ *
+ * <p>Some formats may contain more than a single font, for example
+ * *.ttc and *.dfont files. This is the reason why this function
+ * returns an array.
+ *
+ * <p>The implementation reads data from the buffer only when
+ * needed. Therefore, it greatly increases efficiency if
+ * <code>buf</code> has been obtained through mapping a file into
+ * the virtual address space.
+ *
+ * @throws FontFormatException if the font data is not in one of the
+ * known formats.
+ */
+ public static FontDelegate[] createFonts(ByteBuffer buf)
+ throws FontFormatException
+ {
+ return OpenTypeFontFactory.createFonts(buf);
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/GNUGlyphVector.java b/libjava/classpath/gnu/java/awt/font/GNUGlyphVector.java
new file mode 100644
index 000000000..9fd80e79e
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/GNUGlyphVector.java
@@ -0,0 +1,663 @@
+/* GNUGlyphVector.java -- The GNU implementation of GlyphVector.
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.awt.font;
+
+import gnu.java.awt.java2d.ShapeWrapper;
+
+import java.awt.Font;
+import java.awt.font.FontRenderContext;
+import java.awt.font.GlyphMetrics;
+import java.awt.font.GlyphJustificationInfo;
+import java.awt.font.GlyphVector;
+
+import java.awt.Shape;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.GeneralPath;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+
+
+/**
+ * The GNU implementation of the abstract GlyphVector class, which
+ * uses the services provided by a FontDelegate for its functionality.
+ *
+ * @author Sascha Brawer (brawer@dandelis.ch)
+ */
+public class GNUGlyphVector
+ extends GlyphVector
+{
+ private FontDelegate fontDelegate;
+ private Font font;
+ private FontRenderContext renderContext;
+ private int[] glyphs;
+ private float fontSize;
+ private AffineTransform transform;
+ private boolean valid;
+
+
+ /**
+ * The position of each glyph. The horizontal position of the
+ * <code>i</code>-th glyph is at <code>pos[i * 2]</code>, its
+ * vertical position at <code>pos[i * 2 + 1]</code>. The total
+ * advance width of the entire vector is stored at
+ * <code>pos[numGlyphs]</code>, the total advance height at
+ * <code>pos[numGlyphs + 1]</code>.
+ */
+ private float[] pos;
+
+
+ private AffineTransform[] transforms;
+ private int layoutFlags;
+
+ /**
+ * The cached non-transformed outline of this glyph vector.
+ */
+ private Shape cleanOutline;
+
+ /**
+ * Constructs a new GNUGlyphVector.
+ *
+ * @param fontDelegate the FontDelegate that creates this vector.
+ *
+ * @param font the Font that this GlyphVector will return for {@link
+ * #getFont()}. That object is also used to determine the point
+ * size, which affects the affine transformation used by the font
+ * scaler.
+ *
+ * @param renderContext an object with parameters for font
+ * rendering, such as whether anti-aliasing is enabled.
+ *
+ * @param glyphs the glyphs in this vector.
+ */
+ public GNUGlyphVector(FontDelegate fontDelegate,
+ Font font,
+ FontRenderContext renderContext,
+ int[] glyphs)
+ {
+ this.fontDelegate = fontDelegate;
+ this.font = font;
+ this.renderContext = renderContext;
+ this.glyphs = glyphs;
+
+ fontSize = font.getSize2D();
+ transform = font.getTransform(); // returns a modifiable copy
+ //transform.concatenate(renderContext.getTransform());
+ }
+
+
+
+ /**
+ * Returns the font of the glyphs in this GlyphVector.
+ */
+ public Font getFont()
+ {
+ return font;
+ }
+
+
+ /**
+ * Returns the FontRenderContext that is used to calculate the
+ * extent and position of the glyphs.
+ */
+ public FontRenderContext getFontRenderContext()
+ {
+ return renderContext;
+ }
+
+
+ /**
+ * Moves each glyph in the vector to its default position.
+ */
+ public void performDefaultLayout()
+ {
+ float x, y, advanceWidth, advanceHeight;
+ int i, p;
+ AffineTransform tx;
+ Point2D.Float advance = new Point2D.Float();
+
+ pos = new float[(glyphs.length + 1) * 2];
+ x = y = 0.0f;
+ p = 0;
+ for (i = p = 0; i < glyphs.length; i++)
+ {
+ p += 2;
+
+ if ((transforms == null) || (tx = transforms[i]) == null)
+ tx = this.transform;
+ else
+ {
+ tx = new AffineTransform(tx);
+ tx.concatenate(this.transform);
+ }
+
+ fontDelegate.getAdvance(glyphs[i], fontSize, tx,
+ renderContext.isAntiAliased(),
+ renderContext.usesFractionalMetrics(),
+ /* horizontal */ true,
+ advance);
+ // FIXME: We shouldn't round here, but instead hint the metrics
+ // correctly.
+ pos[p] = x += Math.round(advance.x);
+ pos[p + 1] = y += advance.y;
+ }
+ valid = true;
+ }
+
+
+ /**
+ * Determines the number of glyphs in this GlyphVector.
+ */
+ public int getNumGlyphs()
+ {
+ return glyphs.length;
+ }
+
+
+ /**
+ * Determines the glyph number by index in this vector.
+ * Glyph numbers are specific to each font, so two fonts
+ * will likely assign different numbers to the same glyph.
+ *
+ * @param glyphIndex the index of the glyph whose glyph number is to
+ * be retrieved.
+ *
+ * @throws IndexOutOfBoundsException if <code>glyphIndex</code>
+ * is not in the range <code[0 .. getNumGlyphs() - 1]</code>.
+ */
+ public int getGlyphCode(int glyphIndex)
+ {
+ /* The exception is thrown automatically if the index is out
+ * of the valid bounds.
+ */
+ return glyphs[glyphIndex];
+ }
+
+
+ /**
+ * Returns a slice of this GlyphVector.
+ *
+ * @param firstGlyphIndex the index of the first glyph in the
+ * returned slice.
+ *
+ * @param numEntries the size of the returned slice.
+ *
+ * @param outCodes a pre-allocated array for storing the slice,
+ * or <code>null</code> to cause allocation of a new array.
+ *
+ * @return a slice of this GlyphVector. If <code>outCodes</code>
+ * is <code>null</code>, the slice will be stored into a freshly
+ * allocated array; otherwise, the result will be stored into
+ * <code>outCodes</code>.
+ */
+ public int[] getGlyphCodes(int firstGlyphIndex,
+ int numEntries,
+ int[] outCodes)
+ {
+ if (numEntries < 0)
+ throw new IllegalArgumentException();
+ if (outCodes == null)
+ outCodes = new int[numEntries];
+ System.arraycopy(glyphs, firstGlyphIndex, outCodes, 0, numEntries);
+ return outCodes;
+ }
+
+
+ public Rectangle2D getLogicalBounds()
+ {
+ float ascent, descent;
+
+ validate();
+
+ return new Rectangle2D.Float(0, 0,
+ pos[pos.length - 2],
+ getAscent() - getDescent());
+ }
+
+
+ public Rectangle2D getVisualBounds()
+ {
+ validate();
+
+ // FIXME: Not yet implemented.
+ return getLogicalBounds();
+ }
+
+
+ /**
+ * Returns the shape of this GlyphVector.
+ */
+ public Shape getOutline()
+ {
+ return getOutline(0.0f, 0.0f);
+ }
+
+
+ /**
+ * Returns the shape of this GlyphVector, translated to the
+ * specified position.
+ *
+ * @param x the horizontal position for rendering this vector.
+ * @param y the vertical position for rendering this vector.
+ */
+ public Shape getOutline(float x, float y)
+ {
+ validate();
+
+ Shape outline;
+ if (cleanOutline == null)
+ {
+ GeneralPath path = new GeneralPath();
+ int len = glyphs.length;
+ for (int i = 0; i < len; i++)
+ {
+ GeneralPath p = new GeneralPath(getGlyphOutline(i));
+ path.append(p, false);
+ }
+ // Protect the cached instance from beeing modified by application
+ // code.
+ cleanOutline = new ShapeWrapper(path);
+ outline = cleanOutline;
+ }
+ else
+ {
+ outline = cleanOutline;
+ }
+ if (x != 0 || y != 0)
+ {
+ GeneralPath path = new GeneralPath(outline);
+ AffineTransform t = new AffineTransform();
+ t.translate(x, y);
+ path.transform(t);
+ outline = path;
+ }
+ return outline;
+ }
+
+ public Shape getOutline(float x, float y, int type)
+ {
+ validate();
+
+ GeneralPath outline = new GeneralPath();
+ int len = glyphs.length;
+ for (int i = 0; i < len; i++)
+ {
+ GeneralPath p = new GeneralPath(getGlyphOutline(i, type));
+ outline.append(p, false);
+ }
+ AffineTransform t = new AffineTransform();
+ t.translate(x, y);
+ outline.transform(t);
+ return outline;
+ }
+
+ /**
+ * Determines the shape of the specified glyph.
+ *
+ * @throws IndexOutOfBoundsException if <code>glyphIndex</code> is
+ * not in the range <code[0 .. getNumGlyphs()]</code>.
+ */
+ public Shape getGlyphOutline(int glyphIndex)
+ {
+ AffineTransform tx, glyphTx;
+ GeneralPath path;
+
+ validate();
+
+ if ((transforms != null)
+ && ((glyphTx = transforms[glyphIndex]) != null))
+ {
+ tx = new AffineTransform(transform);
+ tx.concatenate(glyphTx);
+ }
+ else
+ tx = transform;
+
+ path = fontDelegate.getGlyphOutline(glyphs[glyphIndex], fontSize, tx,
+ renderContext.isAntiAliased(),
+ renderContext.usesFractionalMetrics(),
+ FontDelegate.FLAG_FITTED);
+
+ tx = new AffineTransform();
+ tx.translate(pos[glyphIndex * 2], pos[glyphIndex * 2 + 1]);
+ path.transform(tx);
+ return path;
+ }
+
+ public Shape getGlyphOutline(int glyphIndex, int type)
+ {
+ AffineTransform tx, glyphTx;
+ GeneralPath path;
+
+ validate();
+
+ if ((transforms != null)
+ && ((glyphTx = transforms[glyphIndex]) != null))
+ {
+ tx = new AffineTransform(transform);
+ tx.concatenate(glyphTx);
+ }
+ else
+ tx = transform;
+
+ path = fontDelegate.getGlyphOutline(glyphs[glyphIndex], fontSize, tx,
+ renderContext.isAntiAliased(),
+ renderContext.usesFractionalMetrics(),
+ type);
+
+ tx = new AffineTransform();
+ tx.translate(pos[glyphIndex * 2], pos[glyphIndex * 2 + 1]);
+ path.transform(tx);
+ return path;
+ }
+
+ /**
+ * Determines the position of the specified glyph, or the
+ * total advance width and height of the vector.
+ *
+ * @param glyphIndex the index of the glyph in question.
+ * If this value equals <code>getNumGlyphs()</code>, the
+ * position <i>after</i> the last glyph will be returned,
+ * which is the total advance width and height of the vector.
+ *
+ * @throws IndexOutOfBoundsException if <code>glyphIndex</code> is
+ * not in the range <code[0 .. getNumGlyphs()]</code>.
+ */
+ public Point2D getGlyphPosition(int glyphIndex)
+ {
+ validate();
+ return new Point2D.Float(pos[glyphIndex * 2],
+ pos[glyphIndex * 2 + 1]);
+ }
+
+
+ /**
+ * Moves the specified glyph to a new position, or changes the
+ * advance width and height of the entire glyph vector.
+ *
+ * <p>Note that the position of an individual glyph may also
+ * affected by its affine transformation.
+ *
+ * @param glyphIndex the index of the moved glyph. If
+ * <code>glyphIndex</code> equals the total number of glyphs in this
+ * vector, the advance width and height of the vector is changed.
+ *
+ * @param position the new position of the glyph.
+ *
+ * @throws IndexOutOfBoundsException if <code>glyphIndex</code> is
+ * not in the range <code[0 .. getNumGlyphs()]</code>.
+ */
+ public void setGlyphPosition(int glyphIndex, Point2D position)
+ {
+ validate();
+ pos[glyphIndex * 2] = (float) position.getX();
+ pos[glyphIndex * 2 + 1] = (float) position.getY();
+ }
+
+
+ /**
+ * Returns the affine transformation that is applied to the
+ * glyph at the specified index.
+ *
+ * @param glyphIndex the index of the glyph whose transformation
+ * is to be retrieved.
+ *
+ * @return an affine transformation, or <code>null</code>
+ * for the identity transformation.
+ *
+ * @throws IndexOutOfBoundsException if <code>glyphIndex</code> is
+ * not in the range <code[0 .. getNumGlyphs() - 1]</code>.
+ */
+ public AffineTransform getGlyphTransform(int glyphIndex)
+ {
+ if (transforms == null)
+ return null;
+ else
+ return transforms[glyphIndex];
+ }
+
+
+ /**
+ * Applies an affine transformation to the glyph at the specified
+ * index.
+ *
+ * @param glyphIndex the index of the glyph to which the
+ * transformation is applied.
+ *
+ * @param transform the affine transformation for the glyph, or
+ * <code>null</code> for an identity transformation.
+ */
+ public void setGlyphTransform(int glyphIndex,
+ AffineTransform transform)
+ {
+ if (transforms == null)
+ transforms = new AffineTransform[glyphs.length];
+ transforms[glyphIndex] = transform;
+
+ /* If the GlyphVector has only a transform for a single glyph, and
+ * the caller clears its transform, the FLAG_HAS_TRANSFORMS bit
+ * should be cleared in layoutFlags. However, this would require
+ * that we keep track of the number of transformed glyphs, or that
+ * we count them when a transform is cleared. This would
+ * complicate the code quite a bit. Note that the only drawback of
+ * wrongly setting FLAG_HAS_TRANSFORMS is that a slower code path
+ * might be taken for rendering the vector. Right now, we never
+ * really look at the flag, so it does not make any difference.
+ */
+ if (transform != null)
+ layoutFlags |= FLAG_HAS_TRANSFORMS;
+ valid = false;
+ }
+
+
+ /**
+ * Returns flags that can be used for optimizing the rendering
+ * of this GlyphVector.
+ *
+ * @return a bit mask with the applicable flags set.
+ *
+ * @since 1.4
+ *
+ * @see GlyphVector#FLAG_HAS_POSITION_ADJUSTMENTS
+ * @see GlyphVector#FLAG_HAS_TRANSFORMS
+ * @see GlyphVector#FLAG_RUN_RTL
+ * @see GlyphVector#FLAG_COMPLEX_GLYPHS
+ * @see GlyphVector#FLAG_MASK
+ */
+ public int getLayoutFlags()
+ {
+ return layoutFlags;
+ }
+
+
+ /**
+ * Returns the positions of a range of glyphs in this vector.
+ *
+ * @param firstGlyphIndex the index of the first glyph whose
+ * position is retrieved.
+ *
+ * @param numGlyphs the number of glyphs whose positions
+ * are retrieved.
+ *
+ * @param outPositions an array for storing the results
+ * (the length must be at least twice <code>numGlyphs</code>),
+ * or <code>null</code> for freshly allocating an array.
+ *
+ * @return an array with the glyph positions. The horizontal
+ * position of the <code>i</code>-th glyph is at index <code>2 *
+ * i</code>, the vertical position at index <code>2 * i + 1</code>.
+ *
+ * @throws IllegalArgumentException if <code>numGlyphs</code>
+ * is less than zero.
+ *
+ * @throws IndexOutOfBoundsException if either
+ * <code>firstGlyphIndex</code> or <code>(firstGlyphIndex +
+ * numGlyphs)</code> is not in the range <code>[0 .. getNumGlyphs() -
+ * 1]</code>.
+ */
+ public float[] getGlyphPositions(int firstGlyphIndex,
+ int numGlyphs,
+ float[] outPositions)
+ {
+ if (numGlyphs < 0)
+ throw new IllegalArgumentException();
+
+ validate();
+ if (outPositions == null)
+ outPositions = new float[numGlyphs * 2];
+
+ System.arraycopy(/*src */ pos, /* srcStart */ firstGlyphIndex * 2,
+ /* dest */ outPositions, /* destStart */ 0,
+ /* length */ numGlyphs * 2);
+ return outPositions;
+ }
+
+
+ private float getAscent()
+ {
+ return fontDelegate.getAscent(fontSize, transform,
+ renderContext.isAntiAliased(),
+ renderContext.usesFractionalMetrics(),
+ /* horizontal */ true);
+ }
+
+
+ private float getDescent()
+ {
+ return fontDelegate.getDescent(fontSize, transform,
+ renderContext.isAntiAliased(),
+ renderContext.usesFractionalMetrics(),
+ /* horizontal */ true);
+ }
+
+
+ public Shape getGlyphLogicalBounds(int glyphIndex)
+ {
+ float x, y, ascent;
+
+ validate();
+ ascent = getAscent();
+ x = pos[glyphIndex * 2];
+ y = pos[glyphIndex * 2 + 1];
+
+ return new Rectangle2D.Float(x, y - ascent,
+ pos[(glyphIndex + 1) * 2] - x,
+ ascent - getDescent());
+ }
+
+
+ public Shape getGlyphVisualBounds(int glyphIndex)
+ {
+ return getGlyphOutline(glyphIndex).getBounds2D();
+ }
+
+
+ /**
+ * Determines the metrics of the glyph at the specified index.
+ *
+ * @param glyphIndex the index of the glyph whose metrics is to be
+ * retrieved.
+ *
+ * @throws IndexOutOfBoundsException if <code>glyphIndex</code> is
+ * not in the range <code[0 .. getNumGlyphs() - 1]</code>.
+ */
+ public GlyphMetrics getGlyphMetrics(int glyphIndex)
+ {
+ // FIXME: Not yet implemented.
+ throw new UnsupportedOperationException();
+ }
+
+
+ /**
+ * Determines the justification information for the glyph at the
+ * specified index.
+ *
+ * @param glyphIndex the index of the glyph whose justification
+ * information is to be retrieved.
+ *
+ * @throws IndexOutOfBoundsException if <code>glyphIndex</code> is
+ * not in the range <code[0 .. getNumGlyphs() - 1]</code>.
+ */
+ public GlyphJustificationInfo getGlyphJustificationInfo(int glyphIndex)
+ {
+ // FIXME: Not yet implemented.
+ throw new UnsupportedOperationException();
+ }
+
+
+ /**
+ * Determines whether another GlyphVector is for the same font and
+ * rendering context, uses the same glyphs and positions them to the
+ * same location.
+ *
+ * @param other the GlyphVector to compare with.
+ *
+ * @return <code>true</code> if the two vectors are equal,
+ * <code>false</code> otherwise.
+ */
+ public boolean equals(GlyphVector other)
+ {
+ GNUGlyphVector o;
+ if (!(other instanceof GNUGlyphVector))
+ return false;
+
+ o = (GNUGlyphVector) other;
+ if ((this.font != o.font)
+ || (this.fontDelegate != o.fontDelegate)
+ || (this.renderContext != o.renderContext)
+ || (this.glyphs.length != o.glyphs.length))
+ return false;
+
+ for (int i = 0; i < glyphs.length; i++)
+ if (this.glyphs[i] != o.glyphs[i])
+ return false;
+
+ validate();
+ o.validate();
+ for (int i = 0; i < pos.length; i++)
+ if (this.pos[i] != o.pos[i])
+ return false;
+
+ return true;
+ }
+
+ private void validate()
+ {
+ if (!valid)
+ performDefaultLayout();
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/OpenTypeFontPeer.java b/libjava/classpath/gnu/java/awt/font/OpenTypeFontPeer.java
new file mode 100644
index 000000000..d8bff1199
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/OpenTypeFontPeer.java
@@ -0,0 +1,565 @@
+/* XFontPeer2.java -- A Java based TTF font peer for X
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.awt.font;
+
+
+import gnu.java.awt.peer.ClasspathFontPeer;
+import gnu.java.lang.CPStringBuilder;
+
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.font.FontRenderContext;
+import java.awt.font.GlyphVector;
+import java.awt.font.LineMetrics;
+import java.awt.font.TextAttribute;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.text.CharacterIterator;
+import java.text.StringCharacterIterator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+
+public class OpenTypeFontPeer
+ extends ClasspathFontPeer
+{
+
+ /**
+ * The font mapping as specified in the file fonts.properties.
+ */
+ private static Properties fontProperties;
+
+ /**
+ * The available font family names.
+ */
+ private static Set<String> availableFontNames;
+
+ /**
+ * Font spec to file mapping.
+ */
+ private static Map<String,Map<String,String>> fontToFileMap;
+
+ static
+ {
+ fontProperties = new Properties();
+ InputStream in = OpenTypeFontPeer.class.getResourceAsStream("fonts.properties");
+ try
+ {
+ fontProperties.load(in);
+ }
+ catch (IOException e)
+ {
+ e.printStackTrace();
+ }
+ }
+
+ private class XLineMetrics
+ extends LineMetrics
+ {
+
+ private Font font;
+ private GlyphVector glyphVector;
+// private CharacterIterator characterIterator;
+// private int begin;
+// private int limit;
+ private FontRenderContext fontRenderContext;
+ XLineMetrics(Font f, CharacterIterator ci, int b, int l,
+ FontRenderContext rc)
+ {
+ font = f;
+// characterIterator = ci;
+// begin = b;
+// limit = l;
+ fontRenderContext = rc;
+ glyphVector = fontDelegate.createGlyphVector(font, fontRenderContext,
+ ci);
+ }
+
+ public float getAscent()
+ {
+ return fontDelegate.getAscent(font.getSize(), fontRenderContext.getTransform(),
+ fontRenderContext.isAntiAliased(),
+ fontRenderContext.usesFractionalMetrics(), true);
+ }
+
+ public int getBaselineIndex()
+ {
+ // FIXME: Implement this.
+ throw new UnsupportedOperationException("Not yet implemented");
+ }
+
+ public float[] getBaselineOffsets()
+ {
+ // FIXME: Implement this.
+ throw new UnsupportedOperationException("Not yet implemented");
+ }
+
+ public float getDescent()
+ {
+ return (int) fontDelegate.getDescent(font.getSize(), IDENDITY, false,
+ false, false);
+ }
+
+ public float getHeight()
+ {
+ return (float) glyphVector.getLogicalBounds().getHeight();
+ }
+
+ public float getLeading()
+ {
+ return getHeight() - getAscent() - getDescent();
+ }
+
+ public int getNumChars()
+ {
+ // FIXME: Implement this.
+ throw new UnsupportedOperationException("Not yet implemented");
+ }
+
+ public float getStrikethroughOffset()
+ {
+ return 0.F;
+ }
+
+ public float getStrikethroughThickness()
+ {
+ return 0.F;
+ }
+
+ public float getUnderlineOffset()
+ {
+ return 0.F;
+ }
+
+ public float getUnderlineThickness()
+ {
+ return 0.F;
+ }
+
+ }
+
+ private class XFontMetrics
+ extends FontMetrics
+ {
+ /**
+ * A cached point instance, to be used in #charWidth().
+ */
+ private Point2D cachedPoint = new Point2D.Double();
+
+ XFontMetrics(Font f)
+ {
+ super(f);
+ }
+
+ public int getAscent()
+ {
+ return (int) fontDelegate.getAscent(getFont().getSize(), IDENDITY,
+ false, false, false);
+ }
+
+ public int getDescent()
+ {
+ return (int) fontDelegate.getDescent(getFont().getSize(), IDENDITY,
+ false, false, false);
+ }
+
+ public int getHeight()
+ {
+ GlyphVector gv = fontDelegate.createGlyphVector(getFont(),
+ new FontRenderContext(IDENDITY, false, false),
+ new StringCharacterIterator("m"));
+ Rectangle2D b = gv.getVisualBounds();
+ return (int) b.getHeight();
+ }
+
+ public int charWidth(char c)
+ {
+ int code = fontDelegate.getGlyphIndex(c);
+ Point2D advance = cachedPoint;
+ fontDelegate.getAdvance(code, font.getSize2D(), IDENDITY,
+ false, false, true, advance);
+ return (int) advance.getX();
+ }
+
+ public int charsWidth(char[] chars, int offs, int len)
+ {
+ return stringWidth(new String(chars, offs, len));
+ }
+
+ public int stringWidth(String s)
+ {
+ GlyphVector gv = fontDelegate.createGlyphVector(getFont(),
+ new FontRenderContext(IDENDITY, false, false),
+ new StringCharacterIterator(s));
+ Rectangle2D b = gv.getVisualBounds();
+ return (int) b.getWidth();
+ }
+ }
+
+ /**
+ * The indendity transform, to be used in several methods.
+ */
+ private static final AffineTransform IDENDITY = new AffineTransform();
+
+ private FontDelegate fontDelegate;
+
+ public OpenTypeFontPeer(String name, int style, int size)
+ {
+ super(name, style, size);
+ try
+ {
+ String fontSpec = encodeFont(name, style);
+ String filename = mapFontToFilename(fontSpec);
+ File fontfile = new File(filename);
+ FileInputStream in = new FileInputStream(fontfile);
+ FileChannel ch = in.getChannel();
+ ByteBuffer buffer = ch.map(FileChannel.MapMode.READ_ONLY, 0,
+ fontfile.length());
+ fontDelegate = FontFactory.createFonts(buffer)[0];
+ }
+ catch (Exception ex)
+ {
+ ex.printStackTrace();
+ }
+ }
+
+ public OpenTypeFontPeer(String name, Map atts)
+ {
+ super(name, atts);
+ try
+ {
+ String fontSpec = encodeFont(name, atts);
+ String filename = mapFontToFilename(fontSpec);
+ File fontfile = new File(filename);
+ FileInputStream in = new FileInputStream(fontfile);
+ FileChannel ch = in.getChannel();
+ ByteBuffer buffer = ch.map(FileChannel.MapMode.READ_ONLY, 0,
+ fontfile.length());
+ fontDelegate = FontFactory.createFonts(buffer)[0];
+ }
+ catch (Exception ex)
+ {
+ ex.printStackTrace();
+ }
+ }
+
+ public boolean canDisplay(Font font, int c)
+ {
+ // FIXME: Implement this.
+ throw new UnsupportedOperationException("Not yet implemented");
+ }
+
+ public int canDisplayUpTo(Font font, CharacterIterator i, int start, int limit)
+ {
+ // FIXME: Implement this.
+ throw new UnsupportedOperationException("Not yet implemented");
+ }
+
+ public String getSubFamilyName(Font font, Locale locale)
+ {
+ // FIXME: Implement this.
+ throw new UnsupportedOperationException("Not yet implemented");
+ }
+
+ public String getPostScriptName(Font font)
+ {
+ // FIXME: Implement this.
+ throw new UnsupportedOperationException("Not yet implemented");
+ }
+
+ public int getNumGlyphs(Font font)
+ {
+ // FIXME: Implement this.
+ throw new UnsupportedOperationException("Not yet implemented");
+ }
+
+ public int getMissingGlyphCode(Font font)
+ {
+ // FIXME: Implement this.
+ throw new UnsupportedOperationException("Not yet implemented");
+ }
+
+ public byte getBaselineFor(Font font, char c)
+ {
+ // FIXME: Implement this.
+ throw new UnsupportedOperationException("Not yet implemented");
+ }
+
+ public String getGlyphName(Font font, int glyphIndex)
+ {
+ // FIXME: Implement this.
+ throw new UnsupportedOperationException("Not yet implemented");
+ }
+
+ public GlyphVector createGlyphVector(Font font, FontRenderContext frc, CharacterIterator ci)
+ {
+ return fontDelegate.createGlyphVector(font, frc, ci);
+ }
+
+ public GlyphVector createGlyphVector(Font font, FontRenderContext ctx, int[] glyphCodes)
+ {
+ // FIXME: Implement this.
+ throw new UnsupportedOperationException("Not yet implemented");
+ }
+
+ public GlyphVector layoutGlyphVector(Font font, FontRenderContext frc, char[] chars, int start, int limit, int flags)
+ {
+ StringCharacterIterator i = new StringCharacterIterator(new String(chars), start, limit, 0);
+ return fontDelegate.createGlyphVector(font, frc, i);
+ }
+
+ public FontMetrics getFontMetrics(Font font)
+ {
+ return new XFontMetrics(font);
+ }
+
+ public boolean hasUniformLineMetrics(Font font)
+ {
+ // FIXME: Implement this.
+ throw new UnsupportedOperationException("Not yet implemented");
+ }
+
+ public LineMetrics getLineMetrics(Font font, CharacterIterator ci, int begin, int limit, FontRenderContext rc)
+ {
+ return new XLineMetrics(font, ci, begin, limit, rc);
+ }
+
+ public Rectangle2D getMaxCharBounds(Font font, FontRenderContext rc)
+ {
+ // FIXME: Implement this.
+ throw new UnsupportedOperationException("Not yet implemented");
+ }
+
+ /**
+ * Encodes a font name + style + size specification into a X logical font
+ * description (XLFD) as described here:
+ *
+ * http://www.meretrx.com/e93/docs/xlfd.html
+ *
+ * This is implemented to look up the font description in the
+ * fonts.properties of this package.
+ *
+ * @param name the font name
+ * @param atts the text attributes
+ *
+ * @return the encoded font description
+ */
+ public static String encodeFont(String name, Map atts)
+ {
+ String family = name;
+ if (family == null || family.equals(""))
+ family = (String) atts.get(TextAttribute.FAMILY);
+ if (family == null)
+ family = "SansSerif";
+
+ int style = 0;
+ // Detect italic attribute.
+ Float posture = (Float) atts.get(TextAttribute.POSTURE);
+ if (posture != null && !posture.equals(TextAttribute.POSTURE_REGULAR))
+ style |= Font.ITALIC;
+
+ // Detect bold attribute.
+ Float weight = (Float) atts.get(TextAttribute.WEIGHT);
+ if (weight != null && weight.compareTo(TextAttribute.WEIGHT_REGULAR) > 0)
+ style |= Font.BOLD;
+
+ return encodeFont(name, style);
+ }
+
+ /**
+ * Encodes a font name + style into a combined string.
+ *
+ * This is implemented to look up the font description in the
+ * fonts.properties of this package.
+ *
+ * @param name the font name
+ * @param style the font style
+ *
+ * @return the encoded font description
+ */
+ static String encodeFont(String name, int style)
+ {
+ CPStringBuilder key = new CPStringBuilder();
+ key.append(validName(name));
+ key.append('/');
+ switch (style)
+ {
+ case Font.BOLD:
+ key.append("b");
+ break;
+ case Font.ITALIC:
+ key.append("i");
+ break;
+ case (Font.BOLD | Font.ITALIC):
+ key.append("bi");
+ break;
+ case Font.PLAIN:
+ default:
+ key.append("p");
+
+ }
+
+ return key.toString();
+ }
+
+ /**
+ * Checks the specified font name for a valid font name. If the font name
+ * is not known, then this returns 'sansserif' as fallback.
+ *
+ * @param name the font name to check
+ *
+ * @return a valid font name
+ */
+ static String validName(String name)
+ {
+ String retVal;
+ Set<String> fontNames = getFontNames();
+ if (fontNames.contains(name))
+ {
+ retVal = name;
+ }
+ else
+ {
+ retVal = "SansSerif";
+ }
+ return retVal;
+ }
+
+ public static String[] getAvailableFontFamilyNames(Locale l)
+ {
+ Set<String> fontNames = getFontNames();
+ int numNames = fontNames.size();
+ String[] ret = fontNames.toArray(new String[numNames]);
+ return ret;
+ }
+
+ private static synchronized Set<String> getFontNames()
+ {
+ if (availableFontNames == null)
+ {
+ HashSet<String> familyNames = new HashSet<String>();
+ for (Object o : fontProperties.keySet())
+ {
+ if (o instanceof String)
+ {
+ String key = (String) o;
+ int slashIndex = key.indexOf('/');
+ String name = key.substring(0, slashIndex);
+ familyNames.add(name);
+ }
+ }
+ availableFontNames = familyNames;
+ }
+ return availableFontNames;
+ }
+
+ /**
+ * Takes a font spec as returned by {@link #encodeFont(String, int)},
+ * and returns the corresponding font file, or <code>null</code> if no such
+ * font mapping exists.
+ *
+ * @param fontSpec font name and style as returned by
+ * {@link #encodeFont(String, int)}
+ *
+ * @return filename of the corresponding font file
+ */
+ private synchronized String mapFontToFilename(String fontSpec)
+ {
+ if (fontToFileMap == null)
+ {
+ fontToFileMap = new HashMap<String,Map<String,String>>();
+
+ // Initialize font spec to file mapping according to the
+ // font.properties.
+ for (Object o : fontProperties.keySet())
+ {
+ if (o instanceof String)
+ {
+ String key = (String) o;
+ int slashIndex = key.indexOf('/');
+ String name = key.substring(0, slashIndex);
+ String spec = key.substring(slashIndex + 1);
+ // Handle aliases in the 2nd pass below.
+ if (! spec.equals("a"))
+ {
+ Map<String,String> specToFileMap = fontToFileMap.get(name);
+ if (specToFileMap == null)
+ {
+ specToFileMap = new HashMap<String,String>();
+ fontToFileMap.put(name, specToFileMap);
+ }
+ specToFileMap.put(spec, fontProperties.getProperty(key));
+ }
+ }
+ }
+ // 2nd pass for handling aliases.
+ for (Object o : fontProperties.keySet())
+ {
+ if (o instanceof String)
+ {
+ String key = (String) o;
+ int slashIndex = key.indexOf('/');
+ String name = key.substring(0, slashIndex);
+ String spec = key.substring(slashIndex + 1);
+ // Handle aliases in the 2nd pass below.
+ if (spec.equals("a"))
+ {
+ String alias = fontProperties.getProperty(key);
+ Map<String,String> specToFileMap = fontToFileMap.get(alias);
+ fontToFileMap.put(name, specToFileMap);
+ }
+ }
+ }
+ }
+ // Look up font file.
+ int slashIndex = fontSpec.indexOf('/');
+ String name = fontSpec.substring(0, slashIndex);
+ String spec = fontSpec.substring(slashIndex + 1);
+ return fontToFileMap.get(name).get(spec);
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/autofit/AutoHinter.java b/libjava/classpath/gnu/java/awt/font/autofit/AutoHinter.java
new file mode 100644
index 000000000..b0420ab7a
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/autofit/AutoHinter.java
@@ -0,0 +1,83 @@
+/* AutoHinter.java -- The entry point into the hinter implementation.
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.font.autofit;
+
+import gnu.java.awt.font.opentype.Hinter;
+import gnu.java.awt.font.opentype.OpenTypeFont;
+import gnu.java.awt.font.opentype.truetype.Fixed;
+import gnu.java.awt.font.opentype.truetype.Zone;
+
+/**
+ * The public interface to the automatic gridfitter.
+ */
+public class AutoHinter
+ implements Hinter
+{
+ Latin latinScript;
+ LatinMetrics metrics;
+ GlyphHints hints;
+
+ HintScaler scaler = new HintScaler();
+ public void init(OpenTypeFont font)
+ {
+ // TODO: Should support other scripts too.
+ latinScript = new Latin();
+ metrics = new LatinMetrics(font);
+ latinScript.initMetrics(metrics, font);
+ scaler.face = font;
+ }
+
+ public void applyHints(Zone outline)
+ {
+ if (hints == null)
+ hints = new GlyphHints();
+ scaler.xScale = Fixed.valueOf16(outline.scaleX * 64);
+ scaler.yScale = Fixed.valueOf16(outline.scaleY * 64);
+ latinScript.scaleMetrics(metrics, scaler);
+ latinScript.applyHints(hints, outline, metrics);
+ }
+
+ public void setFlags(int flags)
+ {
+ if (hints == null)
+ hints = new GlyphHints();
+ hints.flags = flags;
+ }
+
+}
diff --git a/libjava/classpath/gnu/java/awt/font/autofit/AxisHints.java b/libjava/classpath/gnu/java/awt/font/autofit/AxisHints.java
new file mode 100644
index 000000000..87f2abcc3
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/autofit/AxisHints.java
@@ -0,0 +1,112 @@
+/* AxisHints.java -- Hints specific to an axis
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.font.autofit;
+
+class AxisHints
+{
+
+ Segment[] segments;
+ int majorDir;
+ int numSegments;
+ int numEdges;
+ Edge[] edges;
+
+ AxisHints()
+ {
+ segments = new Segment[4];
+ edges = new Edge[4];
+ }
+
+ Segment newSegment()
+ {
+ if (numSegments >= segments.length)
+ {
+ // Grow array.
+ int newMax = segments.length;
+ newMax += (newMax >> 2) + 4; // From FreeType.
+ Segment[] newSegs = new Segment[newMax];
+ System.arraycopy(segments, 0, newSegs, 0, numSegments);
+ segments = newSegs;
+ }
+ Segment seg = new Segment();
+ segments[numSegments] = seg;
+ numSegments++;
+ return seg;
+ }
+
+ public Edge newEdge(int pos)
+ {
+ if (numEdges >= edges.length)
+ {
+ // Grow array.
+ int newMax = edges.length;
+ newMax += (newMax >> 2) + 4; // From FreeType.
+ Edge[] newEdges = new Edge[newMax];
+ System.arraycopy(edges, 0, newEdges, 0, numEdges);
+ edges = newEdges;
+ }
+ int edgeIndex = numEdges;
+ Edge edge = edges[edgeIndex] = new Edge();
+ while (edgeIndex > 0 && edges[edgeIndex - 1].fpos > pos)
+ {
+ edges[edgeIndex] = edges[edgeIndex - 1];
+ edgeIndex--;
+ }
+ edges[edgeIndex] = edge;
+ numEdges++;
+ edge.fpos = pos;
+
+ return edge;
+
+ }
+
+ int getEdgeIndex(Edge edge2)
+ {
+ int idx = -1;
+ for (int i = 0; i < numEdges; i++)
+ {
+ if (edges[i] == edge2)
+ {
+ idx = i;
+ break;
+ }
+ }
+ return idx;
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/autofit/Constants.java b/libjava/classpath/gnu/java/awt/font/autofit/Constants.java
new file mode 100644
index 000000000..c5b90fa54
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/autofit/Constants.java
@@ -0,0 +1,86 @@
+/* Constants.java -- Some constants used in the autofitter
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.font.autofit;
+
+/**
+ * Some constants used in the autofitter.
+ */
+interface Constants
+{
+
+ /**
+ * The horizontal dimension.
+ */
+ static final int DIMENSION_HORZ = 0;
+
+ /**
+ * The vertical dimension.
+ */
+ static final int DIMENSION_VERT = 1;
+
+ /**
+ * The number of dimensions.
+ */
+ static final int DIMENSION_MAX = 2;
+
+ /**
+ * Indicates a vector with no specific direction.
+ */
+ static final int DIR_NONE = 0;
+
+ /**
+ * Right direction.
+ */
+ static final int DIR_RIGHT = 1;
+
+ /**
+ * Left direction.
+ */
+ static final int DIR_LEFT = -1;
+
+ /**
+ * Up direction.
+ */
+ static final int DIR_UP = 2;
+
+ /**
+ * Down direction.
+ */
+ static final int DIR_DOWN = -2;
+}
diff --git a/libjava/classpath/gnu/java/awt/font/autofit/Edge.java b/libjava/classpath/gnu/java/awt/font/autofit/Edge.java
new file mode 100644
index 000000000..6420fa1cb
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/autofit/Edge.java
@@ -0,0 +1,82 @@
+/* Edge.java -- An edge of segments
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.font.autofit;
+
+import gnu.java.lang.CPStringBuilder;
+
+class Edge
+{
+ int fpos;
+ Segment first;
+ Segment last;
+ int opos;
+ Edge link;
+ Edge serif;
+ int flags;
+ int dir;
+ Width blueEdge;
+ int pos;
+ int scale;
+
+ public String toString()
+ {
+ CPStringBuilder s = new CPStringBuilder();
+ s.append("[Edge] id");
+ s.append(hashCode());
+ s.append(", fpos: ");
+ s.append(fpos);
+ s.append(", opos: ");
+ s.append(opos);
+ s.append(", pos: ");
+ s.append(pos);
+ s.append(", dir: ");
+ s.append(dir);
+ s.append(", serif: ");
+ s.append(serif != null ? serif.hashCode() : "null");
+ s.append(", link: ");
+ s.append(link != null ? link.hashCode() : "null");
+ s.append(", flags: " + flags);
+ s.append(", blue: " + blueEdge);
+ s.append(", first: ");
+ s.append(first == null ? "null" : first.hashCode());
+ s.append(", last: ");
+ s.append(last == null ? "null" : last.hashCode());
+ return s.toString();
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/autofit/GlyphHints.java b/libjava/classpath/gnu/java/awt/font/autofit/GlyphHints.java
new file mode 100644
index 000000000..033d63fa4
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/autofit/GlyphHints.java
@@ -0,0 +1,640 @@
+/* GlyphHints.java -- Data and methods for actual hinting
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.font.autofit;
+
+import gnu.java.awt.font.FontDelegate;
+import gnu.java.awt.font.opentype.truetype.Fixed;
+import gnu.java.awt.font.opentype.truetype.Point;
+import gnu.java.awt.font.opentype.truetype.Zone;
+
+/**
+ * The data and methods used for the actual hinting process.
+ */
+class GlyphHints
+ implements Constants
+{
+
+ int xScale;
+ int xDelta;
+ int yScale;
+ int yDelta;
+
+ AxisHints[] axis;
+
+ Point[] points;
+ int numPoints;
+ int maxPoints;
+
+ Point[] contours;
+ int numContours;
+ int maxContours;
+
+ ScriptMetrics metrics;
+
+ int flags;
+
+ GlyphHints()
+ {
+ axis = new AxisHints[Constants.DIMENSION_MAX];
+ axis[Constants.DIMENSION_VERT] = new AxisHints();
+ axis[Constants.DIMENSION_HORZ] = new AxisHints();
+
+ xScale = Fixed.ONE;
+ yScale = Fixed.ONE;
+ }
+
+ void rescale(ScriptMetrics m)
+ {
+ metrics = m;
+ // TODO: Copy scalerFlags.
+ }
+
+ void reload(Zone outline)
+ {
+ numPoints = 0;
+ numContours = 0;
+ axis[0].numSegments = 0;
+ axis[0].numEdges = 0;
+ axis[1].numSegments = 0;
+ axis[1].numEdges = 0;
+
+ // Create/reallocate the contours array.
+ int newMax = outline.getNumContours();
+ if (newMax > maxContours || contours == null)
+ {
+ newMax = (newMax + 3) & ~3; // Taken from afhints.c .
+ Point[] newContours = new Point[newMax];
+ if (contours != null)
+ {
+ System.arraycopy(contours, 0, newContours, 0, maxContours);
+ }
+ contours = newContours;
+ maxContours = newMax;
+ }
+
+ // Create/reallocate the points array.
+ newMax = outline.getSize() + 2;
+ if (newMax > maxPoints || points == null)
+ {
+ newMax = (newMax + 2 + 7) & ~7; // Taken from afhints.c .
+ Point[] newPoints = new Point[newMax];
+ if (points != null)
+ {
+ System.arraycopy(points, 0, newPoints, 0, maxPoints);
+ }
+ points = newPoints;
+ maxPoints = newMax;
+ }
+
+ numPoints = outline.getSize() - 4; // 4 phantom points.
+ numContours = outline.getNumContours();
+
+ // Set major direction. We don't handle Type 1 fonts yet.
+ axis[DIMENSION_HORZ].majorDir = DIR_UP;
+ axis[DIMENSION_VERT].majorDir = DIR_LEFT;
+
+ // TODO: Freetype seems to scale and translate the glyph at that point.
+ // I suppose that this is not really needed.
+ // The scales are scaling from font units to 1/64 device pixels.
+ xScale = Fixed.valueOf16(outline.scaleX * 64);
+ yScale = Fixed.valueOf16(outline.scaleY * 64);
+
+ // FIXME: What is that xDelta and yDelta used for?
+ System.arraycopy(outline.getPoints(), 0, points, 0, numPoints);
+
+ // Setup prev and next and contours array.
+ // TODO: Probably cache this.
+ contours = new Point[numContours];
+ Point currentContour = points[0];
+ for (int i = 0, cIndex = 0; i < numPoints; i++)
+ {
+ // Start new contour when the last point has been a contour end.
+ if (outline.isContourEnd(i))
+ {
+ // Connect the contour end point to the start point.
+ points[i].setNext(currentContour);
+ currentContour.setPrev(points[i]);
+ contours[cIndex] = currentContour;
+ cIndex++;
+ currentContour = i < numPoints - 1 ? points[i + 1] : null;
+ }
+ else
+ {
+ // Connect the current and the previous point.
+ points[i].setNext(points[i + 1]);
+ points[i + 1].setPrev(points[i]);
+ }
+ }
+ // Compute directions of in and out vectors of all points as well
+ // as the weak point flag.
+ for (int i = 0; i < numPoints; i++)
+ {
+ // Compute in and out dir.
+ Point p = points[i];
+ Point prev = p.getPrev();
+ int inX = p.getOrigX() - prev.getOrigX();
+ int inY = p.getOrigY() - prev.getOrigY();
+ p.setInDir(Utils.computeDirection(inX, inY));
+ Point next = p.getNext();
+ int outX = next.getOrigX() - p.getOrigX();
+ int outY = next.getOrigY() - p.getOrigY();
+ p.setOutDir(Utils.computeDirection(outX, outY));
+
+ if (p.isControlPoint())
+ {
+ setWeakPoint(p);
+ }
+ else if (p.getOutDir() == p.getInDir())
+ {
+ if (p.getOutDir() != DIR_NONE)
+ setWeakPoint(p);
+ else
+ {
+ int angleIn = Utils.atan(inY, inX);
+ int angleOut = Utils.atan(outY, outX);
+ int delta = Utils.angleDiff(angleIn, angleOut);
+ if (delta < 2 && delta > -2)
+ setWeakPoint(p);
+ }
+ }
+ else if (p.getInDir() == - p.getOutDir())
+ {
+ setWeakPoint(p);
+ }
+ }
+ computeInflectionPoints();
+ }
+
+ private void setWeakPoint(Point p)
+ {
+ p.setFlags((byte) (p.getFlags() | Point.FLAG_WEAK_INTERPOLATION));
+ }
+
+ /**
+ * Computes the inflection points for a glyph.
+ */
+ private void computeInflectionPoints()
+ {
+ // Do each contour separately.
+ contours : for (int c = 0; c < contours.length; c++)
+ {
+ Point point = contours[c];
+ Point first = point;
+ Point start = point;
+ Point end = point;
+ do
+ {
+ end = end.getNext();
+ if (end == first)
+ continue contours;
+ } while (end.getOrigX() == first.getOrigX()
+ && end.getOrigY() == first.getOrigY());
+
+ // Extend segment start whenever possible.
+ Point before = start;
+ int angleIn;
+ int angleSeg = Utils.atan(end.getOrigX() - start.getOrigX(),
+ end.getOrigY() - start.getOrigY());
+ do
+ {
+ do
+ {
+ start = before;
+ before = before.getPrev();
+ if (before == first)
+ continue contours;
+ } while (before.getOrigX() == start.getOrigX()
+ && before.getOrigY() == start.getOrigY());
+ angleIn = Utils.atan(start.getOrigX() - before.getOrigX(),
+ start.getOrigY() - before.getOrigY());
+ } while (angleIn == angleSeg);
+
+ first = start;
+ int diffIn = Utils.angleDiff(angleIn, angleSeg);
+ // Now, process all segments in the contour.
+ Point after;
+ boolean finished = false;
+ int angleOut, diffOut;
+ do
+ {
+ // First, extend the current segment's end whenever possible.
+ after = end;
+ do
+ {
+ do
+ {
+ end = after;
+ after = after.getNext();
+ if (after == first)
+ finished = true;
+ } while (end.getOrigX() == after.getOrigX()
+ && end.getOrigY() == after.getOrigY());
+ angleOut = Utils.atan(after.getOrigX() - end.getOrigX(),
+ after.getOrigY() - end.getOrigY());
+ } while (angleOut == angleSeg);
+ diffOut = Utils.angleDiff(angleSeg, angleOut);
+ if ((diffIn ^ diffOut) < 0)
+ {
+ // diffIn and diffOut have different signs, we have
+ // inflection points here.
+ do
+ {
+ start.addFlags(Point.FLAG_INFLECTION);
+ start = start.getNext();
+ } while (start != end);
+ start.addFlags(Point.FLAG_INFLECTION);
+ }
+ start = end;
+ end = after;
+ angleSeg = angleOut;
+ diffIn = diffOut;
+ } while (! finished);
+ }
+ }
+
+ boolean doHorizontal()
+ {
+ return (flags & FontDelegate.FLAG_NO_HINT_HORIZONTAL) == 0;
+ }
+
+ boolean doVertical()
+ {
+ return (flags & FontDelegate.FLAG_NO_HINT_VERTICAL) == 0;
+ }
+
+ void alignWeakPoints(int dim)
+ {
+ short touchFlag;
+ Point point;
+ // PASS 1 : Move segments to edge positions.
+ if (dim == DIMENSION_HORZ)
+ {
+ touchFlag = Point.FLAG_DONE_X;
+ for (int p = 0; p < numPoints; p++)
+ {
+ point = points[p];
+ point.setU(point.getX());
+ point.setV(point.getScaledX());
+ }
+ }
+ else
+ {
+ touchFlag = Point.FLAG_DONE_Y;
+ for (int p = 0; p < numPoints; p++)
+ {
+ point = points[p];
+ point.setU(point.getY());
+ point.setV(point.getScaledY());
+ }
+ }
+ point = points[0];
+ for (int c = 0; c < numContours; c++)
+ {
+ point = contours[c];
+ int idx = getPointIndex(point);
+ Point endPoint = point.getPrev();
+ int endIdx = getPointIndex(endPoint);
+ int firstIdx = idx;
+ while (idx <= endIdx
+ && (point.getFlags() & touchFlag) == 0)
+ {
+ idx++;
+ point = points[idx];
+ }
+ if (idx <= endIdx)
+ {
+ int firstTouched = idx;
+ int curTouched = idx;
+ idx++;
+ point = points[idx];
+ while (idx <= endIdx)
+ {
+ if ((point.getFlags() & touchFlag) != 0)
+ {
+ // We found two successive touch points. We interpolate
+ // all contour points between them.
+ iupInterp(curTouched + 1, idx - 1, curTouched, idx);
+ curTouched = idx;
+ }
+ idx++;
+ point = points[idx];
+ }
+ if (curTouched == firstTouched)
+ {
+ // This is a special case: Only one point was touched in the
+ // contour. We thus simply shift the whole contour.
+ iupShift(firstIdx, endIdx, curTouched);
+ }
+ else
+ {
+ // Now interpolate after the last touched point to the end
+ // of the contour.
+ iupInterp(curTouched + 1, endIdx, curTouched, firstTouched);
+ // If the first contour point isn't touched, interpolate
+ // from the contour start to the first touched point.
+ if (firstTouched > 0)
+ {
+ iupInterp(firstIdx, firstTouched - 1, curTouched,
+ firstTouched);
+ }
+ }
+ }
+ }
+ // Now store the values back.
+ if (dim == DIMENSION_HORZ)
+ {
+ for (int p = 0; p < numPoints; p++)
+ {
+ point = points[p];
+ point.setX(point.getU());
+ }
+ }
+ else
+ {
+ for (int p = 0; p < numPoints; p++)
+ {
+ point = points[p];
+ point.setY(point.getU());
+ }
+ }
+ }
+
+ private void iupShift(int p1, int p2, int ref)
+ {
+ int delta = points[ref].getU() - points[ref].getV();
+ for (int p = p1; p < ref; p++)
+ {
+ points[p].setU(points[p].getV() + delta);
+ }
+ for (int p = ref + 1; p <= p2; p++)
+ {
+ points[p].setU(points[p].getV() + delta);
+ }
+ }
+
+ private void iupInterp(int p1, int p2, int ref1, int ref2)
+ {
+ int v1 = points[ref1].getV();
+ int v2 = points[ref2].getV();
+ int d1 = points[ref1].getU() - v1;
+ int d2 = points[ref2].getU() - v2;
+ if (p1 > p2)
+ return;
+ if (v1 == v2)
+ {
+ for (int p = p1; p <= p2; p++)
+ {
+ int u = points[p].getV();
+ if (u <= v1)
+ u += d1;
+ else
+ u += d2;
+ points[p].setU(u);
+ }
+ }
+ else if (v1 < v2)
+ {
+ for (int p = p1; p <= p2; p++)
+ {
+ int u = points[p].getV();
+ if (u <= v1)
+ u += d1;
+ else if (u >= v2)
+ u += d2;
+ else
+ {
+ u = points[ref1].getU() + Utils.mulDiv(u - v1,
+ points[ref2].getU()
+ - points[ref1].getU(),
+ v2 - v1);
+ }
+ points[p].setU(u);
+ }
+ }
+ else
+ {
+ for (int p = p1; p <= p2; p++)
+ {
+ int u = points[p].getV();
+ if (u <= v2)
+ u += d2;
+ else if (u >= v1)
+ u += d1;
+ else
+ {
+ u = points[ref1].getU() + Utils.mulDiv(u - v1,
+ points[ref2].getU()
+ - points[ref1].getU(),
+ v2 - v1);
+ }
+ points[p].setU(u);
+ }
+ }
+ }
+
+ void alignStrongPoints(int dim)
+ {
+ AxisHints ax = axis[dim];
+ Edge[] edges = ax.edges;
+ int numEdges = ax.numEdges;
+ short touchFlag;
+ if (dim == DIMENSION_HORZ)
+ touchFlag = Point.FLAG_DONE_X;
+ else
+ touchFlag = Point.FLAG_DONE_Y;
+
+ if (numEdges > 0)
+ {
+ for (int p = 0; p < numPoints; p++)
+ {
+ Point point = points[p];
+ if ((point.getFlags() & touchFlag) != 0)
+ continue;
+ // If this point is a candidate for weak interpolation, we
+ // interpolate it after all strong points have been processed.
+ if ((point.getFlags() & Point.FLAG_WEAK_INTERPOLATION) != 0
+ && (point.getFlags() & Point.FLAG_INFLECTION) == 0)
+ continue;
+
+ int u, ou, fu, delta;
+ if (dim == DIMENSION_VERT)
+ {
+ u = point.getOrigY();
+ ou = point.getScaledY();
+ }
+ else
+ {
+ u = point.getOrigX();
+ ou = point.getScaledX();
+ }
+ fu = u;
+ // Is the point before the first edge?
+ Edge edge = edges[0];
+ // Inversed vertical dimension.
+ delta = edge.fpos - u;
+ if (delta >= 0)
+ {
+ u = edge.pos - (edge.opos - ou);
+ storePoint(point, u, dim, touchFlag);
+ }
+ else
+ {
+ // Is the point after the last edge?
+ edge = edges[numEdges - 1];
+ delta = u - edge.fpos;
+ if (delta >= 0)
+ {
+ u = edge.pos + (ou - edge.opos);
+ storePoint(point, u, dim, touchFlag);
+ }
+ else
+ {
+ // Find enclosing edges.
+ int min = 0;
+ int max = numEdges;
+ int mid, fpos;
+ boolean found = false;
+ while (min < max)
+ {
+ mid = (max + min) / 2;
+ edge = edges[mid];
+ fpos = edge.fpos;
+ if (u < fpos)
+ max = mid;
+ else if (u > fpos)
+ min = mid + 1;
+ else
+ {
+ // Directly on the edge.
+ u = edge.pos;
+ storePoint(point, u, dim, touchFlag);
+ found = true;
+ break;
+ }
+ }
+ if (! found)
+ {
+ Edge before = edges[min - 1];
+ Edge after = edges[min];
+ if (before.scale == 0)
+ {
+ before.scale = Fixed.div16(after.pos - before.pos,
+ after.fpos - before.fpos);
+ }
+ u = before.pos + Fixed.mul16(fu - before.fpos,
+ before.scale);
+ }
+ storePoint(point, u, dim, touchFlag);
+ }
+ }
+ }
+ }
+ }
+
+ private void storePoint(Point p, int u, int dim, short touchFlag)
+ {
+ if (dim == DIMENSION_HORZ)
+ p.setX(u);
+ else
+ p.setY(u);
+ p.addFlags(touchFlag);
+ }
+
+ void alignEdgePoints(int dim)
+ {
+ AxisHints ax = axis[dim];
+ Edge[] edges = ax.edges;
+ int numEdges = ax.numEdges;
+ for (int e = 0; e < numEdges; e++)
+ {
+ Edge edge = edges[e];
+ Segment seg = edge.first;
+ do
+ {
+ Point point = seg.first;
+ while (true)
+ {
+ if (dim == DIMENSION_HORZ)
+ {
+ point.setX(edge.pos);
+ point.addFlags(Point.FLAG_DONE_X);
+ }
+ else
+ {
+ point.setY(edge.pos);
+ point.addFlags(Point.FLAG_DONE_Y);
+ }
+ if (point == seg.last)
+ break;
+ point = point.getNext();
+ }
+ seg = seg.edgeNext;
+ } while (seg != edge.first);
+ }
+ }
+
+ private int getPointIndex(Point p)
+ {
+ int idx = -1;
+ for (int i = 0; i < numPoints; i++)
+ {
+ if (p == points[i])
+ {
+ idx = i;
+ break;
+ }
+ }
+ return idx;
+ }
+
+ public boolean doAlignEdgePoints()
+ {
+ return (flags & FontDelegate.FLAG_NO_HINT_EDGE_POINTS) == 0;
+ }
+
+ public boolean doAlignStrongPoints()
+ {
+ return (flags & FontDelegate.FLAG_NO_HINT_STRONG_POINTS) == 0;
+ }
+
+ public boolean doAlignWeakPoints()
+ {
+ return (flags & FontDelegate.FLAG_NO_HINT_WEAK_POINTS) == 0;
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/autofit/HintScaler.java b/libjava/classpath/gnu/java/awt/font/autofit/HintScaler.java
new file mode 100644
index 000000000..01276b4db
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/autofit/HintScaler.java
@@ -0,0 +1,53 @@
+/* Scaler.java -- FIXME: briefly describe file purpose
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.font.autofit;
+
+import gnu.java.awt.font.opentype.OpenTypeFont;
+
+class HintScaler
+{
+
+ int xScale;
+ int xDelta;
+ int yScale;
+ int yDelta;
+ OpenTypeFont face;
+ int renderMode;
+
+}
diff --git a/libjava/classpath/gnu/java/awt/font/autofit/Latin.java b/libjava/classpath/gnu/java/awt/font/autofit/Latin.java
new file mode 100644
index 000000000..c132c2cdc
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/autofit/Latin.java
@@ -0,0 +1,1363 @@
+/* Latin.java -- Latin specific glyph handling
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.font.autofit;
+
+import java.awt.geom.AffineTransform;
+import java.util.HashSet;
+
+import gnu.java.awt.font.opentype.OpenTypeFont;
+import gnu.java.awt.font.opentype.truetype.Fixed;
+import gnu.java.awt.font.opentype.truetype.Point;
+import gnu.java.awt.font.opentype.truetype.Zone;
+
+/**
+ * Implements Latin specific glyph handling.
+ */
+class Latin
+ implements Script, Constants
+{
+
+ static final int MAX_WIDTHS = 16;
+
+ private final static int MAX_TEST_CHARS = 12;
+
+ /**
+ * The types of the 6 blue zones.
+ */
+ private static final int CAPITAL_TOP = 0;
+ private static final int CAPITAL_BOTTOM = 1;
+ private static final int SMALL_F_TOP = 2;
+ private static final int SMALL_TOP = 3;
+ private static final int SMALL_BOTTOM = 4;
+ private static final int SMALL_MINOR = 5;
+ static final int BLUE_MAX = 6;
+
+ /**
+ * The test chars for the blue zones.
+ *
+ * @see #initBlues(LatinMetrics, OpenTypeFont)
+ */
+ private static final String[] TEST_CHARS =
+ new String[]{"THEZOCQS", "HEZLOCUS", "fijkdbh",
+ "xzroesc", "xzroesc", "pqgjy"};
+
+ public void applyHints(GlyphHints hints, Zone outline, ScriptMetrics metrics)
+ {
+ hints.reload(outline);
+ hints.rescale(metrics);
+ if (hints.doHorizontal())
+ {
+ detectFeatures(hints, DIMENSION_HORZ);
+ }
+ if (hints.doVertical())
+ {
+ detectFeatures(hints, DIMENSION_VERT);
+ computeBlueEdges(hints, (LatinMetrics) metrics);
+ }
+ // Grid-fit the outline.
+ for (int dim = 0; dim < DIMENSION_MAX; dim++)
+ {
+ if (dim == DIMENSION_HORZ && hints.doHorizontal()
+ || dim == DIMENSION_VERT && hints.doVertical())
+ {
+ hintEdges(hints, dim);
+ if (hints.doAlignEdgePoints())
+ hints.alignEdgePoints(dim);
+ if (hints.doAlignStrongPoints())
+ hints.alignStrongPoints(dim);
+ if (hints.doAlignWeakPoints())
+ hints.alignWeakPoints(dim);
+
+ }
+ }
+ // FreeType does a save call here. I guess that's not needed as we operate
+ // on the live glyph data anyway.
+ }
+
+ private void hintEdges(GlyphHints hints, int dim)
+ {
+ AxisHints axis = hints.axis[dim];
+ Edge[] edges = axis.edges;
+ int numEdges = axis.numEdges;
+ Edge anchor = null;
+ int hasSerifs = 0;
+
+ // We begin by aligning all stems relative to the blue zone if
+ // needed -- that's only for horizontal edges.
+ if (dim == DIMENSION_VERT)
+ {
+ for (int e = 0; e < numEdges; e++)
+ {
+ Edge edge = edges[e];
+ if ((edge.flags & Segment.FLAG_EDGE_DONE) != 0)
+ continue;
+
+ Width blue = edge.blueEdge;
+ Edge edge1 = null;
+ Edge edge2 = edge.link;
+ if (blue != null)
+ {
+ edge1 = edge;
+ }
+ else if (edge2 != null && edge2.blueEdge != null)
+ {
+ blue = edge2.blueEdge;
+ edge1 = edge2;
+ edge2 = edge;
+ }
+ if (edge1 == null)
+ continue;
+
+ edge1.pos = blue.fit;
+ edge1.flags |= Segment.FLAG_EDGE_DONE;
+
+ if (edge2 != null && edge2.blueEdge == null)
+ {
+ alignLinkedEdge(hints, dim, edge1, edge2);
+ edge2.flags |= Segment.FLAG_EDGE_DONE;
+ }
+ if (anchor == null)
+ anchor = edge;
+ }
+ }
+
+ // Now we will align all stem edges, trying to maintain the
+ // relative order of stems in the glyph.
+ for (int e = 0; e < numEdges; e++)
+ {
+ Edge edge = edges[e];
+ if ((edge.flags & Segment.FLAG_EDGE_DONE) != 0)
+ continue;
+ Edge edge2 = edge.link;
+ if (edge2 == null)
+ {
+ hasSerifs++;
+ continue;
+ }
+ // Now align the stem.
+ // This should not happen, but it's better to be safe.
+ if (edge2.blueEdge != null || axis.getEdgeIndex(edge2) < e)
+ {
+ alignLinkedEdge(hints, dim, edge2, edge);
+ edge.flags |= Segment.FLAG_EDGE_DONE;
+ continue;
+ }
+
+ if (anchor == null)
+ {
+ int orgLen = edge2.opos - edge.opos;
+ int curLen = computeStemWidth(hints, dim, orgLen, edge.flags,
+ edge2.flags);
+ int uOff, dOff, orgCenter, curPos1, error1, error2;
+ if (curLen <= 64) // < 1 Pixel.
+ {
+ uOff = 32;
+ dOff = 32;
+ }
+ else
+ {
+ uOff = 38;
+ dOff = 26;
+ }
+ if (curLen < 96)
+ {
+ orgCenter = edge.opos + (orgLen >> 1);
+ curPos1 = Utils.pixRound(orgCenter);
+ error1 = orgCenter - (curPos1 - uOff);
+ if (error1 < 0)
+ error1 = -error1;
+ error2 = orgCenter - (curPos1 + dOff);
+ if (error2 < 0)
+ error2 = -error2;
+ if (error1 < error2)
+ {
+ curPos1 -= uOff;
+ }
+ else
+ {
+ curPos1 += dOff;
+ }
+ edge.pos = curPos1 - curLen / 2;
+ edge2.pos = curPos1 + curLen / 2;
+ }
+ else
+ {
+ edge.pos = Utils.pixRound(edge.opos);
+ }
+ anchor = edge;
+ edge.flags |= Segment.FLAG_EDGE_DONE;
+ alignLinkedEdge(hints, dim, edge, edge2);
+ }
+ else
+ {
+ int aDiff = edge.opos - anchor.opos;
+ int orgPos = anchor.pos + aDiff;
+ int orgLen = edge2.opos - edge.opos;
+ int orgCenter = orgPos + (orgLen >> 1);
+ int curLen = computeStemWidth(hints, dim, orgLen, edge.flags,
+ edge2.flags);
+ //System.err.println("stem width: " + curLen);
+ if (curLen < 96)
+ {
+ int uOff, dOff;
+ int curPos1 = Utils.pixRound(orgCenter);
+ if (curLen <= 64)
+ {
+ uOff = 32;
+ dOff = 32;
+ }
+ else
+ {
+ uOff = 38;
+ dOff = 26;
+ }
+ int delta1 = orgCenter - (curPos1 - uOff);
+ if (delta1 < 0)
+ delta1 = -delta1;
+ int delta2 = orgCenter - (curPos1 + dOff);
+ if (delta2 < 0)
+ delta2 = -delta2;
+ if (delta1 < delta2)
+ {
+ curPos1 -= uOff;
+ }
+ else
+ {
+ curPos1 += dOff;
+ }
+ edge.pos = curPos1 - curLen / 2;
+ edge2.pos = curPos1 + curLen / 2;
+ }
+ else
+ {
+ orgPos = anchor.pos + (edge.opos - anchor.opos);
+ orgLen = edge2.opos - edge.opos;
+ orgCenter = orgPos + (orgLen >> 1);
+ curLen = computeStemWidth(hints, dim, orgLen, edge.flags,
+ edge2.flags);
+ int curPos1 = Utils.pixRound(orgPos);
+ int delta1 = curPos1 + (curLen >> 1) - orgCenter;
+ if (delta1 < 0)
+ delta1 = -delta1;
+ int curPos2 = Utils.pixRound(orgPos + orgLen) - curLen;
+ int delta2 = curPos2 + (curLen >> 1) - orgCenter;
+ if (delta2 < 0)
+ delta2 = -delta2;
+ edge.pos = (delta1 < delta2) ? curPos1 : curPos2;
+ edge2.pos = edge.pos + curLen;
+ }
+ edge.flags |= Segment.FLAG_EDGE_DONE;
+ edge2.flags |= Segment.FLAG_EDGE_DONE;
+
+ if (e > 0 && edge.pos < edges[e - 1].pos)
+ {
+ edge.pos = edges[e - 1].pos;
+ }
+ }
+ }
+ // TODO: Implement the lowercase m symmetry thing.
+
+ // Now we hint the remaining edges (serifs and singles) in order
+ // to complete our processing.
+ if (hasSerifs > 0 || anchor == null)
+ {
+ for (int e = 0; e < numEdges; e++)
+ {
+ Edge edge = edges[e];
+ if ((edge.flags & Segment.FLAG_EDGE_DONE) != 0)
+ continue;
+ if (edge.serif != null)
+ {
+ alignSerifEdge(hints, edge.serif, edge);
+ }
+ else if (anchor == null)
+ {
+ edge.pos = Utils.pixRound(edge.opos);
+ anchor = edge;
+ }
+ else
+ {
+ edge.pos = anchor.pos
+ + Utils.pixRound(edge.opos - anchor.opos);
+ }
+ edge.flags |= Segment.FLAG_EDGE_DONE;
+
+ if (e > 0 && edge.pos < edges[e - 1].pos)
+ {
+ edge.pos = edges[e - 1].pos;
+ }
+ if (e + 1 < numEdges
+ && (edges[e + 1].flags & Segment.FLAG_EDGE_DONE) != 0
+ && edge.pos > edges[e + 1].pos)
+ {
+ edge.pos = edges[e + 1].pos;
+ }
+ }
+ }
+
+ // Debug: print all hinted edges.
+ // System.err.println("hinted edges: " );
+ // for (int i = 0; i < numEdges; i++)
+ // {
+ // System.err.println("edge#" + i + ": " + edges[i]);
+ // }
+ }
+
+ private void alignSerifEdge(GlyphHints hints, Edge base, Edge serif)
+ {
+ serif.pos = base.pos + (serif.opos - base.opos);
+ }
+
+ private int computeStemWidth(GlyphHints hints, int dim, int width,
+ int baseFlags, int stemFlags)
+ {
+ LatinMetrics metrics = (LatinMetrics) hints.metrics;
+ LatinAxis axis = metrics.axis[dim];
+ int dist = width;
+ int sign = 0;
+ boolean vertical = dim == DIMENSION_VERT;
+ if (! doStemAdjust(hints))
+ return width;
+ if (dist < 0)
+ {
+ dist = -width;
+ sign = 1;
+ }
+ if ((vertical && ! doVertSnap(hints)) || ! vertical && ! doHorzSnap(hints))
+ {
+ // Smooth hinting process. Very lightly quantize the stem width.
+ // Leave the widths of serifs alone.
+ if ((stemFlags & Segment.FLAG_EDGE_SERIF) != 0 && vertical
+ && dist < 3 * 64)
+ {
+ return doneWidth(dist, sign);
+ }
+ else if ((baseFlags & Segment.FLAG_EDGE_ROUND) != 0)
+ {
+ if (dist < 80)
+ dist = 64;
+ }
+ else if (dist < 56)
+ {
+ dist = 56;
+ }
+ if (axis.widthCount > 0)
+ {
+ int delta;
+ if (axis.widthCount > 0)
+ {
+ delta = dist - axis.widths[0].cur;
+ if (delta < 0)
+ {
+ delta = -delta;
+ }
+ if (delta < 40)
+ {
+ dist = axis.widths[0].cur;
+ if (dist < 48)
+ dist = 48;
+ return doneWidth(dist, sign);
+ }
+ }
+ if (dist < 3 * 64) // < 3 pixels.
+ {
+ delta = dist & 63;
+ dist &= -64;
+ if (delta < 10)
+ dist += delta;
+ else if (delta < 32)
+ dist += 10;
+ else if (delta < 54)
+ dist += 54;
+ else
+ dist += delta;
+
+ }
+ else
+ {
+ dist = (dist + 32) & ~63;
+ }
+ }
+ }
+ else
+ {
+ // Strong hinting process: Snap the stem width to integer pixels.
+ dist = snapWidth(axis.widths, axis.widthCount, dist);
+ if (vertical)
+ {
+ // In the case of vertical hinting, always round
+ // the stem heights to integer pixels.
+ if (dist >= 64)
+ dist = (dist + 16) & ~63;
+ else
+ dist = 64;
+ }
+ else
+ {
+ if (doMono(hints))
+ {
+ // Monochrome horizontal hinting: Snap widths to integer pixels
+ // with a different threshold.
+ if (dist < 64)
+ dist = 64;
+ else
+ dist = (dist + 32) & ~63;
+ }
+ else
+ {
+ // For anti-aliased hinting, we adopt a more subtle
+ // approach: We strengthen small stems, round those stems
+ // whose size is between 1 and 2 pixels to an integer,
+ // otherwise nothing.
+ if (dist < 48)
+ dist = (dist + 64) >> 1;
+ else if (dist < 128)
+ dist = (dist + 22) & ~63;
+ else
+ // Round otherwise to prevent color fringes in LCD mode.
+ dist = (dist + 32) & ~63;
+ }
+ }
+ }
+ return doneWidth(dist, sign);
+ }
+
+ private boolean doMono(GlyphHints hints)
+ {
+ return true;
+ }
+
+ private int snapWidth(Width[] widths, int count, int width)
+ {
+ int best = 64 + 32 + 2;
+ int reference = width;
+ for (int n = 0; n < count; n++)
+ {
+ int w = widths[n].cur;
+ int dist = width - w;
+ if (dist < 0)
+ dist = -dist;
+ if (dist < best)
+ {
+ best = dist;
+ reference = w;
+ }
+ }
+ int scaled = Utils.pixRound(reference);
+ if (width >= reference)
+ {
+ if (width < scaled + 48)
+ width = reference;
+ }
+ else
+ {
+ if (width > scaled + 48)
+ width = reference;
+ }
+ return width;
+ }
+
+ private int doneWidth(int w, int s)
+ {
+ if (s == 1)
+ w = -w;
+ return w;
+ }
+
+ private boolean doVertSnap(GlyphHints hints)
+ {
+ // TODO Auto-generated method stub
+ return true;
+ }
+
+ private boolean doHorzSnap(GlyphHints hints)
+ {
+ // TODO Auto-generated method stub
+ return true;
+ }
+
+ private boolean doStemAdjust(GlyphHints hints)
+ {
+ // TODO Auto-generated method stub
+ return true;
+ }
+
+ private void alignLinkedEdge(GlyphHints hints, int dim, Edge base, Edge stem)
+ {
+ int dist = stem.opos - base.opos;
+ int fitted = computeStemWidth(hints, dim, dist, base.flags, stem.flags);
+ stem.pos = base.pos + fitted;
+ }
+
+ public void doneMetrics(ScriptMetrics metrics)
+ {
+ // TODO Auto-generated method stub
+
+ }
+
+ /**
+ * Initializes the <code>hints</code> object.
+ *
+ * @param hints the hints to initialize
+ * @param metrics the metrics to use
+ */
+ public void initHints(GlyphHints hints, ScriptMetrics metrics)
+ {
+ hints.rescale(metrics);
+ LatinMetrics lm = (LatinMetrics) metrics;
+ hints.xScale = lm.axis[DIMENSION_HORZ].scale;
+ hints.xDelta = lm.axis[DIMENSION_HORZ].delta;
+ hints.yScale = lm.axis[DIMENSION_VERT].scale;
+ hints.yDelta = lm.axis[DIMENSION_VERT].delta;
+ // TODO: Set the scaler and other flags.
+ }
+
+ /**
+ * Initializes the script metrics.
+ *
+ * @param metrics the script metrics to initialize
+ * @param face the font
+ */
+ public void initMetrics(ScriptMetrics metrics, OpenTypeFont face)
+ {
+ assert metrics instanceof LatinMetrics;
+ LatinMetrics lm = (LatinMetrics) metrics;
+ lm.unitsPerEm = face.unitsPerEm;
+
+ // TODO: Check for latin charmap.
+
+ initWidths(lm, face, 'o');
+ initBlues(lm, face);
+ }
+
+ public void scaleMetrics(ScriptMetrics metrics, HintScaler scaler)
+ {
+ LatinMetrics lm = (LatinMetrics) metrics;
+ lm.scaler.renderMode = scaler.renderMode;
+ lm.scaler.face = scaler.face;
+ scaleMetricsDim(lm, scaler, DIMENSION_HORZ);
+ scaleMetricsDim(lm, scaler, DIMENSION_VERT);
+ }
+
+ private void scaleMetricsDim(LatinMetrics lm, HintScaler scaler, int dim)
+ {
+ int scale;
+ int delta;
+ if (dim == DIMENSION_HORZ)
+ {
+ scale = scaler.xScale;
+ delta = scaler.xDelta;
+ }
+ else
+ {
+ scale = scaler.yScale;
+ delta = scaler.yDelta;
+ }
+ LatinAxis axis = lm.axis[dim];
+ if (axis.orgScale == scale && axis.orgDelta == delta)
+ // No change, no need to adjust.
+ return;
+ axis.orgScale = scale;
+ axis.orgDelta = delta;
+
+ // Correct X and Y scale to optimize the alignment of the top small
+ // letters to the pixel grid.
+ LatinAxis axis2 = lm.axis[DIMENSION_VERT];
+ LatinBlue blue = null;
+// for (int nn = 0; nn < axis2.blueCount; nn++)
+// {
+// if ((axis2.blues[nn].flags & LatinBlue.FLAG_ADJUSTMENT) != 0)
+// {
+// blue = axis2.blues[nn];
+// break;
+// }
+// }
+// if (blue != null)
+// {
+// int scaled = Fixed.mul16(blue.shoot.org, scaler.yScale);
+// int fitted = Utils.pixRound(scaled);
+// if (scaled != fitted)
+// {
+// if (dim == DIMENSION_HORZ)
+// {
+// if (fitted < scaled)
+// {
+// scale -= scale / 50;
+// }
+// }
+// else
+// {
+// scale = Utils.mulDiv(scale, fitted, scaled);
+// }
+// }
+// }
+ axis.scale = scale;
+ axis.delta = delta;
+ if (dim == DIMENSION_HORZ)
+ {
+ lm.scaler.xScale = scale;
+ lm.scaler.xDelta = delta;
+ }
+ else
+ {
+ lm.scaler.yScale = scale;
+ lm.scaler.yDelta = delta;
+ }
+ // Scale the standard widths.
+ for (int nn = 0; nn < axis.widthCount; nn++)
+ {
+ Width w = axis.widths[nn];
+ w.cur = Fixed.mul16(w.org, scale);
+ w.fit = w.cur;
+ }
+ // Scale blue zones.
+ if (dim == DIMENSION_VERT)
+ {
+ for (int nn = 0; nn < axis.blueCount; nn++)
+ {
+ blue = axis.blues[nn];
+ blue.ref.cur = Fixed.mul16(blue.ref.org, scale) + delta;
+ blue.ref.fit = blue.ref.cur;
+ blue.shoot.cur = Fixed.mul16(blue.ref.org, scale) + delta;
+ blue.flags &= ~LatinBlue.FLAG_BLUE_ACTIVE;
+ // A blue zone is only active if it is less than 3/4 pixels tall.
+ int dist = Fixed.mul16(blue.ref.org - blue.shoot.org, scale);
+ if (dist <= 48 && dist >= -48)
+ {
+ int delta1 = blue.shoot.org - blue.ref.org;
+ int delta2 = delta1;
+ if (delta1 < 0)
+ delta2 = -delta2;
+ delta2 = Fixed.mul16(delta2, scale);
+ if (delta2 < 32)
+ delta2 = 0;
+ else if (delta2 < 64)
+ delta2 = 32 + (((delta2 - 32) + 16) & ~31);
+ else
+ delta2 = Utils.pixRound(delta2);
+ if (delta1 < 0)
+ delta2 = -delta2;
+ blue.ref.fit = Utils.pixRound(blue.ref.cur);
+ blue.shoot.fit = blue.ref.fit + delta2;
+ blue.flags |= LatinBlue.FLAG_BLUE_ACTIVE;
+ }
+ }
+ }
+ }
+
+ /**
+ * Determines the standard stem widths.
+ *
+ * @param metrics the metrics to use
+ * @param face the font face
+ * @param ch the character that is used for getting the widths
+ */
+ private void initWidths(LatinMetrics metrics, OpenTypeFont face, char ch)
+ {
+ GlyphHints hints = new GlyphHints();
+ metrics.axis[DIMENSION_HORZ].widthCount = 0;
+ metrics.axis[DIMENSION_VERT].widthCount = 0;
+ int glyphIndex = face.getGlyph(ch);
+ Zone outline = face.getRawGlyphOutline(glyphIndex, IDENTITY);
+ LatinMetrics dummy = new LatinMetrics();
+ HintScaler scaler = dummy.scaler;
+ dummy.unitsPerEm = metrics.unitsPerEm;
+ scaler.xScale = scaler.yScale = 10000;
+ scaler.xDelta = scaler.yDelta = 0;
+ scaler.face = face;
+ hints.rescale(dummy);
+ hints.reload(outline);
+ for (int dim = 0; dim < DIMENSION_MAX; dim++)
+ {
+ LatinAxis axis = metrics.axis[dim];
+ AxisHints axHints = hints.axis[dim];
+ int numWidths = 0;
+ computeSegments(hints, dim);
+ linkSegments(hints, dim);
+ Segment[] segs = axHints.segments;
+ HashSet<Segment> touched = new HashSet<Segment>();
+ for (int i = 0; i < segs.length; i++)
+ {
+ Segment seg = segs[i];
+ Segment link = seg.link;
+ if (link != null && link.link == seg && ! touched.contains(link))
+ {
+ int dist = Math.abs(seg.pos - link.pos);
+ if (numWidths < MAX_WIDTHS)
+ axis.widths[numWidths++] = new Width(dist);
+ }
+ touched.add(seg);
+ }
+ Utils.sort(numWidths, axis.widths);
+ axis.widthCount = numWidths;
+ }
+ for (int dim = 0; dim < DIMENSION_MAX; dim++)
+ {
+ LatinAxis axis = metrics.axis[dim];
+ int stdw = axis.widthCount > 0 ? axis.widths[0].org
+ : constant(metrics, 50);
+ axis.edgeDistanceTreshold= stdw / 5;
+ }
+ }
+
+ void linkSegments(GlyphHints hints, int dim)
+ {
+ AxisHints axis = hints.axis[dim];
+ Segment[] segments = axis.segments;
+ int numSegs = axis.numSegments;
+ int majorDir = axis.majorDir;
+ int lenThreshold = constant((LatinMetrics) hints.metrics, 8);
+ lenThreshold = Math.min(1, lenThreshold);
+ int lenScore = constant((LatinMetrics) hints.metrics, 3000);
+ for (int i1 = 0; i1 < numSegs; i1++)
+ {
+ Segment seg1 = segments[i1];
+ // The fake segments are introduced to hint the metrics.
+ // Never link them to anything.
+ if (seg1.first == seg1.last || seg1.dir != majorDir)
+ continue;
+ for (int i2 = 0; i2 < numSegs; i2++)
+ {
+ Segment seg2 = segments[i2];
+ if (seg2 != seg1 && seg1.dir + seg2.dir == 0)
+ {
+ int pos1 = seg1.pos;
+ int pos2 = seg2.pos;
+ // The vertical coords are swapped compared to how FT handles
+ // this.
+ int dist = dim == DIMENSION_VERT ? pos1 - pos2 : pos2 - pos1;
+ if (dist >= 0)
+ {
+ int min = seg1.minPos;
+ int max = seg1.maxPos;
+ int len, score;
+ if (min < seg2.minPos)
+ min = seg2.minPos;
+ if (max > seg2.maxPos)
+ max = seg2.maxPos;
+ len = max - min;
+ if (len > lenThreshold)
+ {
+ score = dist + lenScore / len;
+ if (score < seg1.score)
+ {
+ seg1.score = score;
+ seg1.link = seg2;
+ }
+ if (score < seg2.score)
+ {
+ seg2.score = score;
+ seg2.link = seg1;
+ }
+ }
+ }
+ }
+ }
+ }
+ for (int i1 = 0; i1 < numSegs; i1++)
+ {
+ Segment seg1 = segments[i1];
+ Segment seg2 = seg1.link;
+ if (seg2 != null)
+ {
+ seg2.numLinked++;
+ if (seg2.link != seg1)
+ {
+ seg1.link = null;
+ seg1.serif = seg2.link;
+ }
+ }
+ // Uncomment to show all segments.
+ // System.err.println("segment#" + i1 + ": " + seg1);
+ }
+ }
+
+ /**
+ * Initializes the blue zones of the font.
+ *
+ * @param metrics the metrics to use
+ * @param face the font face to analyze
+ */
+ private void initBlues(LatinMetrics metrics, OpenTypeFont face)
+ {
+ int[] flats = new int[MAX_TEST_CHARS];
+ int[] rounds = new int[MAX_TEST_CHARS];
+ int numFlats;
+ int numRounds;
+ LatinBlue blue;
+ LatinAxis axis = metrics.axis[DIMENSION_VERT];
+ // We compute the blues simply by loading each character in the test
+ // strings, then compute its topmost or bottommost points.
+ for (int bb = 0; bb < BLUE_MAX; bb++)
+ {
+ String p = TEST_CHARS[bb];
+ int blueRef;
+ int blueShoot;
+ numFlats = 0;
+ numRounds = 0;
+ for (int i = 0; i < p.length(); i++)
+ {
+ // Load the character.
+ int glyphIndex = face.getGlyph(p.charAt(i));
+ Zone glyph =
+ face.getRawGlyphOutline(glyphIndex, IDENTITY);
+
+ // Now compute the min and max points.
+ int numPoints = glyph.getSize() - 4; // 4 phantom points.
+ Point[] points = glyph.getPoints();
+ Point point = points[0];
+ int extremum = 0;
+ int index = 1;
+ if (isTopBlue(bb))
+ {
+ for (; index < numPoints; index++)
+ {
+ point = points[index];
+ // We have the vertical direction swapped. The higher
+ // points have smaller (negative) Y.
+ if (point.getOrigY() < points[extremum].getOrigY())
+ extremum = index;
+ }
+ }
+ else
+ {
+ for (; index < numPoints; index++)
+ {
+ point = points[index];
+ // We have the vertical direction swapped. The higher
+ // points have smaller (negative) Y.
+ if (point.getOrigY() > points[extremum].getOrigY())
+ extremum = index;
+ }
+ }
+ // Debug, prints out the maxima.
+ // System.err.println("extremum for " + bb + " / "+ p.charAt(i)
+ // + ": " + points[extremum]);
+
+ // Now determine if the point is part of a straight or round
+ // segment.
+ boolean round;
+ int idx = extremum;
+ int first, last, prev, next, end;
+ int dist;
+ last = -1;
+ first = 0;
+ for (int n = 0; n < glyph.getNumContours(); n++)
+ {
+ end = glyph.getContourEnd(n);
+ // System.err.println("contour end for " + n + ": " + end);
+ if (end >= idx)
+ {
+ last = end;
+ break;
+ }
+ first = end + 1;
+ }
+ // Should never happen.
+ assert last >= 0;
+
+ // Now look for the previous and next points that are not on the
+ // same Y coordinate. Threshold the 'closeness'.
+ prev = idx;
+ next = prev;
+ do
+ {
+ if (prev > first)
+ prev--;
+ else
+ prev = last;
+ dist = points[prev].getOrigY() - points[extremum].getOrigY();
+ if (dist < -5 || dist > 5)
+ break;
+ } while (prev != idx);
+ do
+ {
+ if (next < last)
+ next++;
+ else
+ next = first;
+ dist = points[next].getOrigY() - points[extremum].getOrigY();
+ if (dist < -5 || dist > 5)
+ break;
+ } while (next != idx);
+ round = points[prev].isControlPoint()
+ || points[next].isControlPoint();
+
+ if (round)
+ {
+ rounds[numRounds++] = points[extremum].getOrigY();
+ // System.err.println("new round extremum: " + bb + ": "
+ // + points[extremum].getOrigY());
+ }
+ else
+ {
+ flats[numFlats++] = points[extremum].getOrigY();
+ // System.err.println("new flat extremum: " + bb + ": "
+ // + points[extremum].getOrigY());
+ }
+ }
+ // We have computed the contents of the rounds and flats tables.
+ // Now determine the reference and overshoot position of the blues --
+ // we simply take the median after a simple sort.
+ Utils.sort(numRounds, rounds);
+ Utils.sort(numFlats, flats);
+ blue = axis.blues[axis.blueCount] = new LatinBlue();
+ axis.blueCount++;
+ if (numFlats == 0)
+ {
+ blue.ref = blue.shoot = new Width(rounds[numRounds / 2]);
+ }
+ else if (numRounds == 0)
+ {
+ blue.ref = blue.shoot = new Width(flats[numFlats / 2]);
+ }
+ else
+ {
+ blue.ref = new Width(flats[numFlats / 2]);
+ blue.shoot = new Width(rounds[numRounds / 2]);
+ }
+ // There are sometimes problems: if the overshoot position of top
+ // zones is under its reference position, or the opposite for bottom
+ // zones. We must check everything there and correct problems.
+ if (blue.shoot != blue.ref)
+ {
+ int ref = blue.ref.org;
+ int shoot = blue.shoot.org;
+ // Inversed vertical coordinates!
+ boolean overRef = shoot < ref;
+ if (isTopBlue(bb) ^ overRef)
+ {
+ blue.shoot = blue.ref = new Width((shoot + ref) / 2);
+ }
+ }
+ blue.flags = 0;
+ if (isTopBlue(bb))
+ blue.flags |= LatinBlue.FLAG_TOP;
+ // The following flag is used later to adjust y and x scales in
+ // order to optimize the pixel grid alignment of the top small
+ // letters.
+ if (bb == SMALL_TOP)
+ {
+ blue.flags |= LatinBlue.FLAG_ADJUSTMENT;
+ }
+ // Debug: print out the blue zones.
+ // System.err.println("blue zone #" + bb + ": " + blue);
+ }
+ }
+
+ private static final AffineTransform IDENTITY = new AffineTransform();
+
+ private int constant(LatinMetrics metrics, int c)
+ {
+ return c * (metrics.unitsPerEm / 2048);
+ }
+
+ private void computeSegments(GlyphHints hints, int dim)
+ {
+ Point[] points = hints.points;
+ if (dim == DIMENSION_HORZ)
+ {
+ for (int i = 0; i < hints.numPoints; i++)
+ {
+ points[i].setU(points[i].getOrigX());
+ points[i].setV(points[i].getOrigY());
+ }
+ }
+ else
+ {
+ for (int i = 0; i < hints.numPoints; i++)
+ {
+ points[i].setU(points[i].getOrigY());
+ points[i].setV(points[i].getOrigX());
+ }
+ }
+ // Now look at each contour.
+ AxisHints axis = hints.axis[dim];
+ int majorDir = Math.abs(axis.majorDir);
+ int segmentDir = majorDir;
+ Point[] contours = hints.contours;
+ int numContours = hints.numContours;
+ Segment segment = null;
+ for (int i = 0; i < numContours; i++)
+ {
+ int minPos = 32000;
+ int maxPos = -32000;
+
+ Point point = contours[i];
+ Point last = point.getPrev();
+ if (point == last) // Skip singletons.
+ continue;
+ if (Math.abs(last.getOutDir()) == majorDir
+ && Math.abs(point.getOutDir()) == majorDir)
+ {
+ // We are already on an edge. Locate its start.
+ last = point;
+ while (true)
+ {
+ point = point.getPrev();
+ if (Math.abs(point.getOutDir()) != majorDir)
+ {
+ point = point.getNext();
+ break;
+ }
+ if (point == last)
+ break;
+ }
+ }
+ last = point;
+ boolean passed = false;
+ boolean onEdge = false;
+ while (true)
+ {
+ int u, v;
+ if (onEdge)
+ {
+ u = point.getU();
+ if (u < minPos)
+ minPos = u;
+ if (u > maxPos)
+ maxPos = u;
+ if (point.getOutDir() != segmentDir || point == last)
+ {
+ // Leaving an edge. Record new segment.
+ segment.last = point;
+ // (minPos + maxPos) / 2.
+ segment.pos = (minPos + maxPos) >> 1;
+ if (segment.first.isControlPoint()
+ || point.isControlPoint())
+ segment.flags |= Segment.FLAG_EDGE_ROUND;
+ minPos = maxPos = point.getV();
+ v = segment.first.getV();
+ if (v < minPos)
+ minPos = v;
+ if (v > maxPos)
+ maxPos = v;
+ segment.minPos = minPos;
+ segment.maxPos = maxPos;
+ onEdge = false;
+ segment = null;
+ }
+ }
+ if (point == last)
+ {
+ if (passed)
+ break;
+ passed = true;
+ }
+ if (! onEdge && Math.abs(point.getOutDir()) == majorDir)
+ {
+ // This is the start of a new segment.
+ segmentDir = point.getOutDir();
+ segment = axis.newSegment();
+ segment.dir = segmentDir;
+ segment.flags = Segment.FLAG_EDGE_NORMAL;
+ minPos = maxPos = point.getU();
+ segment.first = point;
+ segment.last = point;
+ segment.contour = contours[i];
+ segment.score = 32000;
+ segment.len = 0;
+ segment.link = null;
+ onEdge = true;
+ }
+ point = point.getNext();
+ }
+ }
+
+ }
+
+ private boolean isTopBlue(int b)
+ {
+ return b == CAPITAL_TOP || b == SMALL_F_TOP || b == SMALL_TOP;
+ }
+
+ private void detectFeatures(GlyphHints hints, int dim)
+ {
+ computeSegments(hints, dim);
+ linkSegments(hints, dim);
+ computeEdges(hints, dim);
+ }
+
+ private void computeEdges(GlyphHints hints, int dim)
+ {
+ AxisHints axis = hints.axis[dim];
+ LatinAxis laxis = ((LatinMetrics) hints.metrics).axis[dim];
+ Segment[] segments = axis.segments;
+ int numSegments = axis.numSegments;
+ Segment seg;
+ int upDir;
+ int scale;
+ int edgeDistanceThreshold;
+ axis.numEdges = 0;
+ scale = dim == DIMENSION_HORZ ? hints.xScale : hints.yScale;
+ upDir = dim == DIMENSION_HORZ ? DIR_UP : DIR_RIGHT;
+
+ // We will begin by generating a sorted table of edges for the
+ // current direction. To do so, we simply scan each segment and try
+ // to find an edge in our table that corresponds to its position.
+ //
+ // If no edge is found, we create one and insert a new edge in the
+ // sorted table. Otherwise, we simply add the segment to the egde's
+ // list which will be processed in the second step to compute the
+ // edge's properties.
+ //
+ // Note that the edge table is sorted along the segment/edge
+ // position.
+
+ edgeDistanceThreshold = Fixed.mul16(laxis.edgeDistanceTreshold, scale);
+ if (edgeDistanceThreshold > 64 / 4)
+ edgeDistanceThreshold = 64 / 4;
+ edgeDistanceThreshold = Fixed.div16(edgeDistanceThreshold, scale);
+ for (int i = 0; i < numSegments; i++)
+ {
+ seg = segments[i];
+ Edge found = null;
+ for (int ee = 0; ee < axis.numEdges; ee++)
+ {
+ Edge edge = axis.edges[ee];
+ int dist = seg.pos - edge.fpos;
+ if (dist < 0)
+ dist = -dist;
+ if (dist < edgeDistanceThreshold)
+ {
+ found = edge;
+ break;
+ }
+ }
+ if (found == null)
+ {
+ // Insert new edge in the list and sort according to
+ // the position.
+ Edge edge = axis.newEdge(seg.pos);
+ edge.first = seg;
+ edge.last = seg;
+ edge.fpos = seg.pos;
+ edge.opos = edge.pos = Fixed.mul16(seg.pos, scale);
+ seg.edgeNext = seg;
+ seg.edge = edge;
+ }
+ else
+ {
+ seg.edgeNext = found.first;
+ found.last.edgeNext = seg;
+ found.last = seg;
+ seg.edge = found;
+ }
+ }
+ // Good. We will now compute each edge's properties according to
+ // segments found on its position. Basically these are:
+ // - Edge's main direction.
+ // - Stem edge, serif edge, or both (which defaults to stem edge).
+ // - Rounded edge, straight or both (which defaults to straight).
+ // - Link for edge.
+
+ // Now, compute each edge properties.
+ for (int e = 0; e < axis.numEdges; e++)
+ {
+ Edge edge = axis.edges[e];
+ // Does it contain round segments?
+ int isRound = 0;
+ // Does it contain straight segments?
+ int isStraight = 0;
+ // Number of upward segments.
+ int ups = 0;
+ // Number of downward segments.
+ int downs = 0;
+
+ seg = edge.first;
+ do
+ {
+ // Check for roundness of segment.
+ if ((seg.flags & Segment.FLAG_EDGE_ROUND) != 0)
+ isRound++;
+ else
+ isStraight++;
+
+ // Check for segment direction.
+ if (seg.dir == upDir)
+ ups += seg.maxPos - seg.minPos;
+ else
+ downs += seg.maxPos - seg.minPos;
+
+ // Check for links. If seg.serif is set, then seg.link must
+ // be ignored.
+ boolean isSerif = seg.serif != null && seg.serif.edge != edge;
+ if (seg.link != null || isSerif)
+ {
+ Edge edge2 = edge.link;
+ Segment seg2 = seg.link;
+ if (isSerif)
+ {
+ seg2 = seg.serif;
+ edge2 = edge.serif;
+ }
+ if (edge2 != null)
+ {
+ int edgeDelta = edge.fpos - edge2.fpos;
+ if (edgeDelta < 0)
+ edgeDelta = -edgeDelta;
+ int segDelta = seg.pos - seg2.pos;
+ if (segDelta < 0)
+ segDelta = -segDelta;
+ if (segDelta < edgeDelta)
+ edge2 = seg2.edge;
+ }
+ else
+ {
+ edge2 = seg2.edge;
+ }
+ if (isSerif)
+ {
+ edge.serif = edge2;
+ edge2.flags |= Segment.FLAG_EDGE_SERIF;
+ }
+ else
+ {
+ edge.link = edge2;
+ }
+ }
+ seg = seg.edgeNext;
+ } while (seg != edge.first);
+ edge.flags = Segment.FLAG_EDGE_NORMAL;
+ if (isRound > 0 && isRound > isStraight)
+ edge.flags |= Segment.FLAG_EDGE_ROUND;
+
+ // Set the edge's main direction.
+ edge.dir = DIR_NONE;
+ if (ups > downs)
+ edge.dir = upDir;
+ else if (ups < downs)
+ edge.dir = -upDir;
+ else if (ups == downs)
+ edge.dir = 0;
+
+ // Gets rid of serif if link is set. This gets rid of many
+ // unpleasant artifacts.
+ if (edge.serif != null && edge.link != null)
+ {
+ edge.serif = null;
+ }
+
+ // Debug: Print out all edges.
+ // System.err.println("edge# " + e + ": " + edge);
+ }
+ }
+
+ private void computeBlueEdges(GlyphHints hints, LatinMetrics metrics)
+ {
+ AxisHints axis = hints.axis[DIMENSION_VERT];
+ Edge[] edges = axis.edges;
+ int numEdges = axis.numEdges;
+ LatinAxis latin = metrics.axis[DIMENSION_VERT];
+ int scale = latin.scale;
+
+ // Compute which blue zones are active. I.e. have their scaled
+ // size < 3/4 pixels.
+
+ // For each horizontal edge search the blue zone that is closest.
+ for (int e = 0; e < numEdges; e++)
+ {
+ Edge edge = edges[e];
+ // System.err.println("checking edge: " + edge);
+ Width bestBlue = null;
+ int bestDist = Fixed.mul16(metrics.unitsPerEm / 40, scale);
+
+ if (bestDist > 64 / 2)
+ bestDist = 64 / 2;
+ for (int bb = 0; bb < BLUE_MAX; bb++)
+ {
+ LatinBlue blue = latin.blues[bb];
+ // System.err.println("checking blue: " + blue);
+ // Skip inactive blue zones, i.e. those that are too small.
+ if ((blue.flags & LatinBlue.FLAG_BLUE_ACTIVE) == 0)
+ continue;
+ // If it is a top zone, check for right edges. If it is a bottom
+ // zone, check for left edges.
+ boolean isTopBlue = (blue.flags & LatinBlue.FLAG_TOP) != 0;
+ boolean isMajorDir = edge.dir == axis.majorDir;
+
+ // If it is a top zone, the edge must be against the major
+ // direction. If it is a bottom zone it must be in the major
+ // direction.
+ if (isTopBlue ^ isMajorDir)
+ {
+ int dist = edge.fpos - blue.ref.org;
+ if (dist < 0)
+ dist = -dist;
+ dist = Fixed.mul16(dist, scale);
+ if (dist < bestDist)
+ {
+ bestDist = dist;
+ bestBlue = blue.ref;
+ }
+
+ // Now, compare it to the overshoot position if the edge is
+ // rounded, and if the edge is over the reference position of
+ // a top zone, or under the reference position of a bottom
+ // zone.
+ if ((edge.flags & Segment.FLAG_EDGE_ROUND) != 0 && dist != 0)
+ {
+ // Inversed vertical coordinates!
+ boolean isUnderRef = edge.fpos > blue.ref.org;
+ if (isTopBlue ^ isUnderRef)
+ {
+ blue = latin.blues[bb]; // Needed?
+ dist = edge.fpos - blue.shoot.org;
+ if (dist < 0)
+ dist = -dist;
+ dist = Fixed.mul16(dist, scale);
+ if (dist < bestDist)
+ {
+ bestDist = dist;
+ bestBlue = blue.shoot;
+ }
+ }
+ }
+
+ }
+ }
+ if (bestBlue != null)
+ {
+ edge.blueEdge = bestBlue;
+ // Debug: Print out the blue edges.
+ // System.err.println("blue edge for: " + edge + ": " + bestBlue);
+ }
+ }
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/autofit/LatinAxis.java b/libjava/classpath/gnu/java/awt/font/autofit/LatinAxis.java
new file mode 100644
index 000000000..9237d0ee5
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/autofit/LatinAxis.java
@@ -0,0 +1,62 @@
+/* LatinAxis.java -- Axis specific data
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.font.autofit;
+
+/**
+ * Some axis specific data.
+ */
+class LatinAxis
+{
+
+ int scale;
+ int delta;
+
+ int widthCount;
+ Width[] widths;
+ int edgeDistanceTreshold;
+ LatinBlue[] blues;
+ int blueCount;
+ int orgDelta;
+ int orgScale;
+ LatinAxis()
+ {
+ widths = new Width[Latin.MAX_WIDTHS];
+ blues = new LatinBlue[Latin.BLUE_MAX];
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/autofit/LatinBlue.java b/libjava/classpath/gnu/java/awt/font/autofit/LatinBlue.java
new file mode 100644
index 000000000..2cf68b75c
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/autofit/LatinBlue.java
@@ -0,0 +1,61 @@
+/* LatinBlue.java -- FIXME: briefly describe file purpose
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.font.autofit;
+
+import gnu.java.lang.CPStringBuilder;
+
+public class LatinBlue
+{
+ static final int FLAG_BLUE_ACTIVE = 1 << 0;
+ static final int FLAG_TOP = 1 << 1;
+ static final int FLAG_ADJUSTMENT = 1 << 2;
+ Width ref;
+ Width shoot;
+ int flags;
+ public String toString()
+ {
+ CPStringBuilder s = new CPStringBuilder();
+ s.append("[BlueZone]");
+ s.append(" ref: ");
+ s.append(ref.org);
+ s.append(", shoot: ");
+ s.append(shoot.org);
+ return s.toString();
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/autofit/LatinMetrics.java b/libjava/classpath/gnu/java/awt/font/autofit/LatinMetrics.java
new file mode 100644
index 000000000..33fc63ad4
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/autofit/LatinMetrics.java
@@ -0,0 +1,66 @@
+/* LatinMetrics.java -- Latin specific metrics data
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.font.autofit;
+
+import gnu.java.awt.font.opentype.OpenTypeFont;
+
+/**
+ * Latin specific metrics data.
+ */
+class LatinMetrics
+ extends ScriptMetrics
+{
+
+ LatinAxis[] axis;
+
+ int unitsPerEm;
+
+ LatinMetrics()
+ {
+ super();
+ axis = new LatinAxis[Constants.DIMENSION_MAX];
+ axis[Constants.DIMENSION_HORZ] = new LatinAxis();
+ axis[Constants.DIMENSION_VERT] = new LatinAxis();
+ }
+ LatinMetrics(OpenTypeFont face)
+ {
+ this();
+ unitsPerEm = face.unitsPerEm;
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/autofit/Script.java b/libjava/classpath/gnu/java/awt/font/autofit/Script.java
new file mode 100644
index 000000000..c223f0a26
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/autofit/Script.java
@@ -0,0 +1,62 @@
+/* Script.java -- Defines script specific interface to the autofitter
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.font.autofit;
+
+import gnu.java.awt.font.opentype.OpenTypeFont;
+import gnu.java.awt.font.opentype.truetype.Zone;
+
+/**
+ * Defines script specific methods for the auto fitter.
+ */
+interface Script
+{
+
+ /**
+ * Initializes the metrics.
+ */
+ void initMetrics(ScriptMetrics metrics, OpenTypeFont face);
+
+ void scaleMetrics(ScriptMetrics metrics , HintScaler scaler);
+
+ void doneMetrics(ScriptMetrics metrics);
+
+ void initHints(GlyphHints hints, ScriptMetrics metrics);
+
+ void applyHints(GlyphHints hints, Zone outline, ScriptMetrics metrics);
+}
diff --git a/libjava/classpath/gnu/java/awt/font/autofit/ScriptMetrics.java b/libjava/classpath/gnu/java/awt/font/autofit/ScriptMetrics.java
new file mode 100644
index 000000000..984a06dae
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/autofit/ScriptMetrics.java
@@ -0,0 +1,53 @@
+/* ScriptMetrics.java -- Script specific metrics data
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.font.autofit;
+
+/**
+ * Script specific metrics data.
+ */
+class ScriptMetrics
+{
+
+ Script script;
+ HintScaler scaler;
+ ScriptMetrics()
+ {
+ scaler = new HintScaler();
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/autofit/Segment.java b/libjava/classpath/gnu/java/awt/font/autofit/Segment.java
new file mode 100644
index 000000000..9f9da6792
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/autofit/Segment.java
@@ -0,0 +1,97 @@
+/* Segment.java -- FIXME: briefly describe file purpose
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.font.autofit;
+
+import gnu.java.awt.font.opentype.truetype.Point;
+
+import gnu.java.lang.CPStringBuilder;
+
+class Segment
+{
+
+ static final int FLAG_EDGE_NORMAL = 0;
+ static final int FLAG_EDGE_ROUND = 1;
+ static final int FLAG_EDGE_SERIF = 2;
+ static final int FLAG_EDGE_DONE = 4;
+ int dir;
+ int flags;
+ Segment link;
+ Segment serif;
+ int numLinked;
+ int pos;
+ Point first;
+ Point last;
+ Point contour;
+ int minPos;
+ int maxPos;
+ int score;
+ int len;
+ Segment edgeNext;
+ Edge edge;
+
+ public String toString()
+ {
+ CPStringBuilder s = new CPStringBuilder();
+ s.append("[Segment] id: ");
+ s.append(hashCode());
+ s.append(", len:");
+ s.append(len);
+ s.append(", round: ");
+ s.append(((flags & FLAG_EDGE_ROUND) != 0));
+ s.append(", dir: ");
+ s.append(dir);
+ s.append(", pos: ");
+ s.append(pos);
+ s.append(", minPos: ");
+ s.append(minPos);
+ s.append(", maxPos: ");
+ s.append(maxPos);
+ s.append(", first: ");
+ s.append(first);
+ s.append(", last: ");
+ s.append(last);
+ s.append(", contour: ");
+ s.append(contour);
+ s.append(", link: ");
+ s.append(link == null ? "null" : link.hashCode());
+ s.append(", serif: ");
+ s.append(serif == null ? "null" : serif.hashCode());
+ return s.toString();
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/autofit/Utils.java b/libjava/classpath/gnu/java/awt/font/autofit/Utils.java
new file mode 100644
index 000000000..ca45bb2e4
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/autofit/Utils.java
@@ -0,0 +1,255 @@
+/* Utils.java -- A collection of utility functions for the autofitter
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.font.autofit;
+
+import gnu.java.awt.font.opentype.truetype.Fixed;
+
+/**
+ * A collection of utility methods used all around the auto fitter.
+ */
+class Utils
+ implements Constants
+{
+
+ private static final int ATAN_BITS = 8;
+ private static final byte[] ATAN = new byte[]
+ {
+ 0, 0, 1, 1, 1, 2, 2, 2,
+ 3, 3, 3, 3, 4, 4, 4, 5,
+ 5, 5, 6, 6, 6, 7, 7, 7,
+ 8, 8, 8, 9, 9, 9, 10, 10,
+ 10, 10, 11, 11, 11, 12, 12, 12,
+ 13, 13, 13, 14, 14, 14, 14, 15,
+ 15, 15, 16, 16, 16, 17, 17, 17,
+ 18, 18, 18, 18, 19, 19, 19, 20,
+ 20, 20, 21, 21, 21, 21, 22, 22,
+ 22, 23, 23, 23, 24, 24, 24, 24,
+ 25, 25, 25, 26, 26, 26, 26, 27,
+ 27, 27, 28, 28, 28, 28, 29, 29,
+ 29, 30, 30, 30, 30, 31, 31, 31,
+ 31, 32, 32, 32, 33, 33, 33, 33,
+ 34, 34, 34, 34, 35, 35, 35, 35,
+ 36, 36, 36, 36, 37, 37, 37, 38,
+ 38, 38, 38, 39, 39, 39, 39, 40,
+ 40, 40, 40, 41, 41, 41, 41, 42,
+ 42, 42, 42, 42, 43, 43, 43, 43,
+ 44, 44, 44, 44, 45, 45, 45, 45,
+ 46, 46, 46, 46, 46, 47, 47, 47,
+ 47, 48, 48, 48, 48, 48, 49, 49,
+ 49, 49, 50, 50, 50, 50, 50, 51,
+ 51, 51, 51, 51, 52, 52, 52, 52,
+ 52, 53, 53, 53, 53, 53, 54, 54,
+ 54, 54, 54, 55, 55, 55, 55, 55,
+ 56, 56, 56, 56, 56, 57, 57, 57,
+ 57, 57, 57, 58, 58, 58, 58, 58,
+ 59, 59, 59, 59, 59, 59, 60, 60,
+ 60, 60, 60, 61, 61, 61, 61, 61,
+ 61, 62, 62, 62, 62, 62, 62, 63,
+ 63, 63, 63, 63, 63, 64, 64, 64
+ };
+
+ private static final int ANGLE_PI = 256;
+ private static final int ANGLE_PI2 = ANGLE_PI / 2;
+ private static final int ANGLE_PI4 = ANGLE_PI / 4;
+ private static final int ANGLE_2PI = ANGLE_PI * 2;
+
+ /**
+ * Computes the direction constant for the specified vector. The vector is
+ * given as differential value already.
+ *
+ * @param dx the x vector
+ * @param dy the y vector
+ *
+ * @return the direction of that vector, or DIR_NONE, if that vector is not
+ * approximating against one of the major axises
+ */
+ static int computeDirection(int dx, int dy)
+ {
+ int dir = DIR_NONE;
+ if (dx < 0)
+ {
+ if (dy < 0)
+ {
+ if (-dx * 12 < -dy)
+ dir = DIR_UP;
+ else if (-dy * 12 < -dx)
+ dir = DIR_LEFT;
+ }
+ else // dy >= 0 .
+ {
+ if (-dx * 12 < dy)
+ dir = DIR_DOWN;
+ else if (dy * 12 < -dx)
+ dir = DIR_LEFT;
+ }
+ }
+ else // dx >= 0 .
+ {
+ if (dy < 0)
+ {
+ if (dx * 12 < -dy)
+ dir = DIR_UP;
+ else if (-dy * 12 < dx)
+ dir = DIR_RIGHT;
+ }
+ else // dy >= 0 .
+ {
+ if (dx * 12 < dy)
+ dir = DIR_DOWN;
+ else if (dy * 12 < dx)
+ dir = DIR_RIGHT;
+ }
+ }
+ return dir;
+ }
+
+ public static int atan(int dx, int dy)
+ {
+ int angle;
+ // Trivial cases.
+ if (dy == 0)
+ {
+ angle = 0;
+ if (dx < 0)
+ angle = ANGLE_PI;
+ return angle;
+ }
+ else if (dx == 0)
+ {
+ angle = ANGLE_PI2;
+ if (dy < 0)
+ angle = - ANGLE_PI2;
+ return angle;
+ }
+
+
+ angle = 0;
+ if (dx < 0)
+ {
+ dx = -dx;
+ dy = -dy;
+ angle = ANGLE_PI;
+ }
+ if (dy < 0)
+ {
+ int tmp = dx;
+ dx = -dy;
+ dy = tmp;
+ angle -= ANGLE_PI2;
+ }
+ if (dx == 0 && dy == 0)
+ return 0;
+
+ if (dx == dy)
+ angle += ANGLE_PI4;
+ else if (dx > dy)
+ {
+ angle += ATAN[Fixed.div(dy, dx) << (ATAN_BITS - 6)];
+ }
+ else
+ {
+ angle += ANGLE_PI2 - ATAN[Fixed.div(dx, dy) << (ATAN_BITS - 6)];
+ }
+
+ if (angle > ANGLE_PI)
+ angle -= ANGLE_2PI;
+ return angle;
+ }
+
+ public static int angleDiff(int ang1, int ang2)
+ {
+ int delta = ang2 - ang1;
+ delta %= ANGLE_2PI;
+ if (delta < 0)
+ delta += ANGLE_2PI;
+ if (delta > ANGLE_PI)
+ delta -= ANGLE_2PI;
+ return delta;
+ }
+
+ static void sort(int num, int[] array)
+ {
+ int swap;
+ for (int i = 1; i < num; i++)
+ {
+ for (int j = i; j > 0; j--)
+ {
+ if (array[j] > array[j - 1])
+ break;
+ swap = array[j];
+ array[j] = array[j - 1];
+ array[j - 1] = swap;
+ }
+ }
+ }
+
+ static void sort(int num, Width[] array)
+ {
+ Width swap;
+ for (int i = 1; i < num; i++)
+ {
+ for (int j = 1; j > 0; j--)
+ {
+ if (array[j].org > array[j - 1].org)
+ break;
+ swap = array[j];
+ array[j] = array[j - 1];
+ array[j - 1] = swap;
+ }
+ }
+ }
+
+ static int pixRound(int val)
+ {
+ return pixFloor(val + 32);
+ }
+
+ static int pixFloor(int val)
+ {
+ return val & ~63;
+ }
+
+ public static int mulDiv(int a, int b, int c)
+ {
+ long prod = a * b;
+ long div = (prod / c);
+ return (int) div;
+ }
+
+}
diff --git a/libjava/classpath/gnu/java/awt/font/autofit/Width.java b/libjava/classpath/gnu/java/awt/font/autofit/Width.java
new file mode 100644
index 000000000..079f7b396
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/autofit/Width.java
@@ -0,0 +1,64 @@
+/* Width.java -- FIXME: briefly describe file purpose
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.font.autofit;
+
+import gnu.java.lang.CPStringBuilder;
+
+public class Width
+{
+ int org;
+ int cur;
+ int fit;
+ Width(int dist)
+ {
+ org = dist;
+ }
+
+ public String toString()
+ {
+ CPStringBuilder s = new CPStringBuilder();
+ s.append("[Width] org: ");
+ s.append(org);
+ s.append(", cur: ");
+ s.append(cur);
+ s.append(", fit: ");
+ s.append(fit);
+ return s.toString();
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/opentype/CharGlyphMap.java b/libjava/classpath/gnu/java/awt/font/opentype/CharGlyphMap.java
new file mode 100644
index 000000000..8529f7e47
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/opentype/CharGlyphMap.java
@@ -0,0 +1,1027 @@
+/* CharGlyphMap.java -- Manages the 'cmap' table of TrueType fonts
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.font.opentype;
+
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.ShortBuffer;
+import java.nio.IntBuffer;
+
+
+/**
+ * A mapping from Unicode codepoints to glyphs. This mapping
+ * does not perform any re-ordering or decomposition, so it
+ * is not everything that is needed to support Unicode.
+ *
+ * <p>This class manages the <code>cmap</code> table of
+ * OpenType and TrueType fonts.
+ *
+ * @see <a href="http://partners.adobe.com/asn/tech/type/opentype/cmap.jsp">
+ * the <code>cmap</code> part of Adobe&#x2019; OpenType Specification</a>
+ *
+ * @see <a href="http://developer.apple.com/fonts/TTRefMan/RM06/Chap6cmap.html">
+ * the <code>cmap</code> section of Apple&#x2019;s TrueType Reference
+ * Manual</a>
+ *
+ * @author Sascha Brawer (brawer@dandelis.ch)
+ */
+public abstract class CharGlyphMap
+{
+ private static final int PLATFORM_UNICODE = 0;
+ private static final int PLATFORM_MACINTOSH = 1;
+ private static final int PLATFORM_MICROSOFT = 3;
+
+
+ /**
+ * Determines the glyph index for a given Unicode codepoint. Users
+ * should be aware that the character-to-glyph mapping not not
+ * everything that is needed for full Unicode support. For example,
+ * the <code>cmap</code> table is not able to synthesize accented
+ * glyphs from the canonical decomposition sequence, even if the
+ * font would contain a glyph for the composed form.
+ *
+ * @param ucs4 the Unicode codepoint in UCS-4 encoding. Surrogates
+ * (U+D800 to U+DFFF) cannot be passed, they must be mapped to
+ * UCS-4 first.
+ *
+ * @return the glyph index, or 0 if the font does not contain
+ * a glyph for this codepoint.
+ */
+ public abstract int getGlyph(int ucs4);
+
+
+ /**
+ * Reads a CharGlyphMap from an OpenType or TrueType <code>cmap</code>
+ * table. The current implementation works as follows:
+ *
+ * <p><ol><li>If the font has a type 4 cmap for the Unicode platform
+ * (encoding 0, 1, 2, 3 or 4), or a type 4 cmap for the Microsoft
+ * platform (encodings 1 or 10), that table is used to map Unicode
+ * codepoints to glyphs. Most recent fonts, both for Macintosh and
+ * Windows, should provide such a table.</li>
+ *
+ * <li>Otherwise, if the font has any type 0 cmap for the Macintosh
+ * platform, a Unicode-to-glyph mapping is synthesized from certain
+ * type 0 cmaps. The current implementation collects mappings from
+ * Roman, Icelandic, Turkish, Croatian, Romanian, Eastern European,
+ * Cyrillic, Greek, Hebrew, Arabic and Farsi cmaps.</li>.</ol>
+ *
+ * @param buf a buffer whose position is right at the start
+ * of the entire <code>cmap</code> table, and whose limit
+ * is at its end.
+ *
+ * @return a concrete subclass of <code>CharGlyphMap</code>
+ * that performs the mapping.
+ *
+ * @see <a href=
+ * "http://partners.adobe.com/asn/tech/type/opentype/cmap.jsp"
+ * >the <code>cmap</code> part of Adobe&#x2019; OpenType Specification</a>
+ *
+ * @see <a href=
+ * "http://developer.apple.com/fonts/TTRefMan/RM06/Chap6cmap.html"
+ * >the <code>cmap</code> section of Apple&#x2019;s TrueType Reference
+ * Manual</a>
+ */
+ public static CharGlyphMap forTable(ByteBuffer buf)
+ {
+ boolean hasType0 = false;
+ int start4 = -1, platform4 = 0, encoding4 = 0;
+ int start12 = -1, platform12 = 0, encoding12 = 0;
+ int version;
+ int numTables;
+ int tableStart = buf.position();
+ int limit = buf.limit();
+ int format, platform, language, encoding, length, offset;
+
+ version = buf.getChar();
+ if (version != 0)
+ return null;
+
+ numTables = buf.getChar();
+ for (int i = 0; i < numTables; i++)
+ {
+ buf.limit(limit).position(tableStart + 4 + i * 8);
+ platform = buf.getChar();
+ encoding = buf.getChar();
+ offset = tableStart + buf.getInt();
+
+ buf.position(offset);
+ format = buf.getChar();
+
+ switch (format)
+ {
+ case 0:
+ hasType0 = true;
+ break;
+
+ case 4:
+ length = buf.getChar();
+ language = buf.getChar();
+ if ((start4 == -1)
+ && Type4.isSupported(platform, language, encoding))
+ {
+ start4 = offset;
+ platform4 = platform;
+ encoding4 = encoding;
+ }
+ break;
+
+ case 12:
+ if ((start12 == -1) && Type12.isSupported(platform, encoding))
+ {
+ start12 = offset;
+ platform12 = platform;
+ encoding12 = encoding;
+ }
+ break;
+ }
+ }
+
+
+ if (start12 >= 0)
+ {
+ try
+ {
+ buf.limit(limit).position(start12);
+ return new Type12(buf, platform12, encoding12);
+ }
+ catch (Exception ex)
+ {
+ ex.printStackTrace();
+ }
+ }
+
+ if (start4 >= 0)
+ {
+ try
+ {
+ buf.limit(limit).position(start4);
+ return Type4.readTable(buf, platform4, encoding4);
+ }
+ catch (Exception ex)
+ {
+ }
+ }
+
+ if (hasType0)
+ {
+ try
+ {
+ buf.limit(limit).position(tableStart);
+ return new Type0(buf);
+ }
+ catch (Exception ex)
+ {
+ }
+ }
+
+ return new Dummy();
+ }
+
+
+ /**
+ * A dummy mapping that maps anything to the undefined glyph.
+ * Used if no other cmap is understood in a font.
+ *
+ * @author Sascha Brawer (brawer@dandelis.ch)
+ */
+ private static final class Dummy
+ extends CharGlyphMap
+ {
+ public int getGlyph(int ucs4)
+ {
+ return 0;
+ }
+ }
+
+
+ /**
+ * A mapping from Unicode code points to glyph IDs through CMAP Type
+ * 0 tables. These tables have serious limitations: Only the first
+ * 256 glyphs can be addressed, and the source of the mapping is not
+ * Unicode, but an encoding used on the Macintosh.
+ *
+ * <p>However, some fonts have only a Type 0 cmap. In this case, we
+ * process all the Type 0 tables we understand, and establish
+ * a reversed glyph-to-Unicode mapping. When a glyph is requested
+ * for a given Unicode character, we perform a linear search on the
+ * reversed table to find the glyph which maps to the requested
+ * character. While not blazingly fast, this gives a reasonable
+ * fallback for old fonts.
+ *
+ * @author Sascha Brawer (brawer@dandelis.ch)
+ */
+ private static final class Type0
+ extends CharGlyphMap
+ {
+ /**
+ * An array whose <code>i</code>-th element indicates the
+ * Unicode code point of glyph <code>i</code> in the font.
+ */
+ private char[] glyphToUCS2 = new char[256];
+
+
+ /**
+ * A String whose <code>charAt(i)</code> is the Unicode character
+ * that corresponds to the codepoint <code>i + 127</code> in the
+ * MacOS Arabic encoding.
+ *
+ * @see <a href=
+ * "http://www.unicode.org/Public/MAPPINGS/VENDORS/APPLE/ARABIC.TXT"
+ * >the Unicode mapping table for the MacOS Arabic encoding</a>
+ */
+ private static final String UPPER_ARABIC
+ = "\u007e\u0000\u00c4\u00a0\u00c7\u00c9\u00d1\u00d6\u00dc\u00e1"
+ + "\u00e0\u00e2\u00e4\u06ba\u00ab\u00e7\u00e9\u00e8\u00ea\u00eb"
+ + "\u00ed\u2026\u00ee\u00ef\u00f1\u00f3\u00bb\u00f4\u00f6\u00f7"
+ + "\u00fa\u00f9\u00fb\u00fc\u0020\u0021\"\u0023\u0024\u066a"
+ + "\u0026\u0027\u0028\u0029\u002a\u002b\u060c\u002d\u002e\u002f"
+ + "\u0660\u0661\u0662\u0663\u0664\u0665\u0666\u0667\u0668\u0669"
+ + "\u003a\u061b\u003c\u003d\u003e\u061f\u274a\u0621\u0622\u0623"
+ + "\u0624\u0625\u0626\u0627\u0628\u0629\u062a\u062b\u062c\u062d"
+ + "\u062e\u062f\u0630\u0631\u0632\u0633\u0634\u0635\u0636\u0637"
+ + "\u0638\u0639\u063a\u005b\\\u005d\u005e\u005f\u0640\u0641"
+ + "\u0642\u0643\u0644\u0645\u0646\u0647\u0648\u0649\u064a\u064b"
+ + "\u064c\u064d\u064e\u064f\u0650\u0651\u0652\u067e\u0679\u0686"
+ + "\u06d5\u06a4\u06af\u0688\u0691\u007b\u007c\u007d\u0698\u06d2";
+
+
+ /**
+ * A String whose <code>charAt(i)</code> is the Unicode character
+ * that corresponds to the codepoint <code>i + 127</code> in the
+ * MacOS East European Roman encoding.
+ *
+ * @see <a href=
+ * "http://www.unicode.org/Public/MAPPINGS/VENDORS/APPLE/CENTEURO.TXT"
+ * >the Unicode mapping table for the MacOS Central European
+ * encoding</a>
+ */
+ private static final String UPPER_EAST_EUROPEAN_ROMAN
+ = "\u007e\u0000\u00c4\u0100\u0101\u00c9\u0104\u00d6\u00dc\u00e1"
+ + "\u0105\u010c\u00e4\u010d\u0106\u0107\u00e9\u0179\u017a\u010e"
+ + "\u00ed\u010f\u0112\u0113\u0116\u00f3\u0117\u00f4\u00f6\u00f5"
+ + "\u00fa\u011a\u011b\u00fc\u2020\u00b0\u0118\u00a3\u00a7\u2022"
+ + "\u00b6\u00df\u00ae\u00a9\u2122\u0119\u00a8\u2260\u0123\u012e"
+ + "\u012f\u012a\u2264\u2265\u012b\u0136\u2202\u2211\u0142\u013b"
+ + "\u013c\u013d\u013e\u0139\u013a\u0145\u0146\u0143\u00ac\u221a"
+ + "\u0144\u0147\u2206\u00ab\u00bb\u2026\u00a0\u0148\u0150\u00d5"
+ + "\u0151\u014c\u2013\u2014\u201c\u201d\u2018\u2019\u00f7\u25ca"
+ + "\u014d\u0154\u0155\u0158\u2039\u203a\u0159\u0156\u0157\u0160"
+ + "\u201a\u201e\u0161\u015a\u015b\u00c1\u0164\u0165\u00cd\u017d"
+ + "\u017e\u016a\u00d3\u00d4\u016b\u016e\u00da\u016f\u0170\u0171"
+ + "\u0172\u0173\u00dd\u00fd\u0137\u017b\u0141\u017c\u0122\u02c7";
+
+
+ /**
+ * A String whose <code>charAt(i)</code> is the Unicode character
+ * that corresponds to the codepoint <code>i + 127</code> in the
+ * MacOS Roman encoding for the Croatian language.
+ *
+ * @see <a href=
+ * "http://www.unicode.org/Public/MAPPINGS/VENDORS/APPLE/CROATIAN.TXT"
+ * >the Unicode mapping table for the MacOS Croatian encoding</a>
+ */
+ private static final String UPPER_CROATIAN
+ = "\u007e\u0000\u00c4\u00c5\u00c7\u00c9\u00d1\u00d6\u00dc\u00e1"
+ + "\u00e0\u00e2\u00e4\u00e3\u00e5\u00e7\u00e9\u00e8\u00ea\u00eb"
+ + "\u00ed\u00ec\u00ee\u00ef\u00f1\u00f3\u00f2\u00f4\u00f6\u00f5"
+ + "\u00fa\u00f9\u00fb\u00fc\u2020\u00b0\u00a2\u00a3\u00a7\u2022"
+ + "\u00b6\u00df\u00ae\u0160\u2122\u00b4\u00a8\u2260\u017d\u00d8"
+ + "\u221e\u00b1\u2264\u2265\u2206\u00b5\u2202\u2211\u220f\u0161"
+ + "\u222b\u00aa\u00ba\u03a9\u017e\u00f8\u00bf\u00a1\u00ac\u221a"
+ + "\u0192\u2248\u0106\u00ab\u010c\u2026\u00a0\u00c0\u00c3\u00d5"
+ + "\u0152\u0153\u0110\u2014\u201c\u201d\u2018\u2019\u00f7\u25ca"
+ + "\uf8ff\u00a9\u2044\u20ac\u2039\u203a\u00c6\u00bb\u2013\u00b7"
+ + "\u201a\u201e\u2030\u00c2\u0107\u00c1\u010d\u00c8\u00cd\u00ce"
+ + "\u00cf\u00cc\u00d3\u00d4\u0111\u00d2\u00da\u00db\u00d9\u0131"
+ + "\u02c6\u02dc\u00af\u03c0\u00cb\u02da\u00b8\u00ca\u00e6\u02c7";
+
+
+ /**
+ * A String whose <code>charAt(i)</code> is the Unicode character
+ * that corresponds to the codepoint <code>i + 127</code> in the
+ * MacOS Cyrillic encoding.
+ *
+ * @see <a href=
+ * "http://www.unicode.org/Public/MAPPINGS/VENDORS/APPLE/CYRILLIC.TXT"
+ * >the Unicode mapping table for the MacOS Cyrillic encoding</a>
+ */
+ private static final String UPPER_CYRILLIC
+ = "\u007e\u0000\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417"
+ + "\u0418\u0419\u041a\u041b\u041c\u041d\u041e\u041f\u0420\u0421"
+ + "\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042a\u042b"
+ + "\u042c\u042d\u042e\u042f\u2020\u00b0\u0490\u00a3\u00a7\u2022"
+ + "\u00b6\u0406\u00ae\u00a9\u2122\u0402\u0452\u2260\u0403\u0453"
+ + "\u221e\u00b1\u2264\u2265\u0456\u00b5\u0491\u0408\u0404\u0454"
+ + "\u0407\u0457\u0409\u0459\u040a\u045a\u0458\u0405\u00ac\u221a"
+ + "\u0192\u2248\u2206\u00ab\u00bb\u2026\u00a0\u040b\u045b\u040c"
+ + "\u045c\u0455\u2013\u2014\u201c\u201d\u2018\u2019\u00f7\u201e"
+ + "\u040e\u045e\u040f\u045f\u2116\u0401\u0451\u044f\u0430\u0431"
+ + "\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043a\u043b"
+ + "\u043c\u043d\u043e\u043f\u0440\u0441\u0442\u0443\u0444\u0445"
+ + "\u0446\u0447\u0448\u0449\u044a\u044b\u044c\u044d\u044e\u20ac";
+
+
+ /**
+ * A String whose <code>charAt(i)</code> is the Unicode character
+ * that corresponds to the codepoint <code>i + 127</code> in the
+ * MacOS Arabic encoding with the Farsi language.
+ *
+ * @see <a href=
+ * "http://www.unicode.org/Public/MAPPINGS/VENDORS/APPLE/FARSI.TXT"
+ * >the Unicode mapping table for the MacOS Farsi encoding</a>
+ */
+ private static final String UPPER_FARSI
+ = "\u007e\u0000\u00c4\u00a0\u00c7\u00c9\u00d1\u00d6\u00dc\u00e1"
+ + "\u00e0\u00e2\u00e4\u06ba\u00ab\u00e7\u00e9\u00e8\u00ea\u00eb"
+ + "\u00ed\u2026\u00ee\u00ef\u00f1\u00f3\u00bb\u00f4\u00f6\u00f7"
+ + "\u00fa\u00f9\u00fb\u00fc\u0020\u0021\"\u0023\u0024\u066a"
+ + "\u0026\u0027\u0028\u0029\u002a\u002b\u060c\u002d\u002e\u002f"
+ + "\u06f0\u06f1\u06f2\u06f3\u06f4\u06f5\u06f6\u06f7\u06f8\u06f9"
+ + "\u003a\u061b\u003c\u003d\u003e\u061f\u274a\u0621\u0622\u0623"
+ + "\u0624\u0625\u0626\u0627\u0628\u0629\u062a\u062b\u062c\u062d"
+ + "\u062e\u062f\u0630\u0631\u0632\u0633\u0634\u0635\u0636\u0637"
+ + "\u0638\u0639\u063a\u005b\\\u005d\u005e\u005f\u0640\u0641"
+ + "\u0642\u0643\u0644\u0645\u0646\u0647\u0648\u0649\u064a\u064b"
+ + "\u064c\u064d\u064e\u064f\u0650\u0651\u0652\u067e\u0679\u0686"
+ + "\u06d5\u06a4\u06af\u0688\u0691\u007b\u007c\u007d\u0698\u06d2";
+
+
+ /**
+ * A String whose <code>charAt(i)</code> is the Unicode character
+ * that corresponds to the codepoint <code>i + 127</code> in the
+ * MacOS Greek encoding.
+ *
+ * @see <a
+ * href="http://www.unicode.org/Public/MAPPINGS/VENDORS/APPLE/GREEK.TXT"
+ * >the Unicode mapping table for the MacOS Greek encoding</a>
+ */
+ private static final String UPPER_GREEK
+ = "\u007e\u0000\u00c4\u00b9\u00b2\u00c9\u00b3\u00d6\u00dc\u0385"
+ + "\u00e0\u00e2\u00e4\u0384\u00a8\u00e7\u00e9\u00e8\u00ea\u00eb"
+ + "\u00a3\u2122\u00ee\u00ef\u2022\u00bd\u2030\u00f4\u00f6\u00a6"
+ + "\u20ac\u00f9\u00fb\u00fc\u2020\u0393\u0394\u0398\u039b\u039e"
+ + "\u03a0\u00df\u00ae\u00a9\u03a3\u03aa\u00a7\u2260\u00b0\u00b7"
+ + "\u0391\u00b1\u2264\u2265\u00a5\u0392\u0395\u0396\u0397\u0399"
+ + "\u039a\u039c\u03a6\u03ab\u03a8\u03a9\u03ac\u039d\u00ac\u039f"
+ + "\u03a1\u2248\u03a4\u00ab\u00bb\u2026\u00a0\u03a5\u03a7\u0386"
+ + "\u0388\u0153\u2013\u2015\u201c\u201d\u2018\u2019\u00f7\u0389"
+ + "\u038a\u038c\u038e\u03ad\u03ae\u03af\u03cc\u038f\u03cd\u03b1"
+ + "\u03b2\u03c8\u03b4\u03b5\u03c6\u03b3\u03b7\u03b9\u03be\u03ba"
+ + "\u03bb\u03bc\u03bd\u03bf\u03c0\u03ce\u03c1\u03c3\u03c4\u03b8"
+ + "\u03c9\u03c2\u03c7\u03c5\u03b6\u03ca\u03cb\u0390\u03b0\u00ad";
+
+
+ /**
+ * A String whose <code>charAt(i)</code> is the Unicode character
+ * that corresponds to the codepoint <code>i + 127</code> in the
+ * MacOS Hebrew encoding.
+ *
+ * <p>The codepoint 0x81 (HEBREW LIGATURE YIDDISH YOD YOD PATAH)
+ * has no composed Unicode equivalent, but is expressed as the
+ * sequence U+05F2 U+05B7 in Unicode. A similar situation exists
+ * with the codepoint 0xC0 (HEBREW LIGATURE LAMED HOLAM), which
+ * MacOS converts to U+F86A U+05DC U+05B9. To correctly deal
+ * with these sequences, we probably should synthesize a ligature
+ * table if a Hebrew font only provides a Type 0 CMAP.
+ *
+ * @see <a href=
+ * "http://www.unicode.org/Public/MAPPINGS/VENDORS/APPLE/HEBREW.TXT"
+ * >the Unicode mapping table for the MacOS Hebrew encoding</a>
+ */
+ private static final String UPPER_HEBREW
+ = "\u007e\u0000\u00c4\u0000\u00c7\u00c9\u00d1\u00d6\u00dc\u00e1"
+ + "\u00e0\u00e2\u00e4\u00e3\u00e5\u00e7\u00e9\u00e8\u00ea\u00eb"
+ + "\u00ed\u00ec\u00ee\u00ef\u00f1\u00f3\u00f2\u00f4\u00f6\u00f5"
+ + "\u00fa\u00f9\u00fb\u00fc\u0020\u0021\"\u0023\u0024\u0025"
+ + "\u20aa\u0027\u0029\u0028\u002a\u002b\u002c\u002d\u002e\u002f"
+ + "\u0030\u0031\u0032\u0033\u0034\u0035\u0036\u0037\u0038\u0039"
+ + "\u003a\u003b\u003c\u003d\u003e\u003f\u0000\u201e\uf89b\uf89c"
+ + "\uf89d\uf89e\u05bc\ufb4b\ufb35\u2026\u00a0\u05b8\u05b7\u05b5"
+ + "\u05b6\u05b4\u2013\u2014\u201c\u201d\u2018\u2019\ufb2a\ufb2b"
+ + "\u05bf\u05b0\u05b2\u05b1\u05bb\u05b9\u0000\u05b3\u05d0\u05d1"
+ + "\u05d2\u05d3\u05d4\u05d5\u05d6\u05d7\u05d8\u05d9\u05da\u05db"
+ + "\u05dc\u05dd\u05de\u05df\u05e0\u05e1\u05e2\u05e3\u05e4\u05e5"
+ + "\u05e6\u05e7\u05e8\u05e9\u05ea\u007d\u005d\u007b\u005b\u007c";
+
+
+ /**
+ * A String whose <code>charAt(i)</code> is the Unicode character
+ * that corresponds to the codepoint <code>i + 127</code> in the
+ * MacOS Roman encoding with the Icelandic language.
+ *
+ * @see <a href=
+ * "http://www.unicode.org/Public/MAPPINGS/VENDORS/APPLE/ICELAND.TXT"
+ * >the Unicode mapping table for the MacOS Icelandic encoding</a>
+ */
+ private static final String UPPER_ICELANDIC
+ = "\u007e\u0000\u00c4\u00c5\u00c7\u00c9\u00d1\u00d6\u00dc\u00e1"
+ + "\u00e0\u00e2\u00e4\u00e3\u00e5\u00e7\u00e9\u00e8\u00ea\u00eb"
+ + "\u00ed\u00ec\u00ee\u00ef\u00f1\u00f3\u00f2\u00f4\u00f6\u00f5"
+ + "\u00fa\u00f9\u00fb\u00fc\u00dd\u00b0\u00a2\u00a3\u00a7\u2022"
+ + "\u00b6\u00df\u00ae\u00a9\u2122\u00b4\u00a8\u2260\u00c6\u00d8"
+ + "\u221e\u00b1\u2264\u2265\u00a5\u00b5\u2202\u2211\u220f\u03c0"
+ + "\u222b\u00aa\u00ba\u03a9\u00e6\u00f8\u00bf\u00a1\u00ac\u221a"
+ + "\u0192\u2248\u2206\u00ab\u00bb\u2026\u00a0\u00c0\u00c3\u00d5"
+ + "\u0152\u0153\u2013\u2014\u201c\u201d\u2018\u2019\u00f7\u25ca"
+ + "\u00ff\u0178\u2044\u20ac\u00d0\u00f0\u00de\u00fe\u00fd\u00b7"
+ + "\u201a\u201e\u2030\u00c2\u00ca\u00c1\u00cb\u00c8\u00cd\u00ce"
+ + "\u00cf\u00cc\u00d3\u00d4\uf8ff\u00d2\u00da\u00db\u00d9\u0131"
+ + "\u02c6\u02dc\u00af\u02d8\u02d9\u02da\u00b8\u02dd\u02db\u02c7";
+
+
+ /**
+ * A String whose <code>charAt(i)</code> is the Unicode character
+ * that corresponds to the codepoint <code>i + 127</code> in the
+ * MacOS Roman encoding for most languages. Exceptions include
+ * Croatian, Icelandic, Romanian, and Turkish.
+ *
+ * @see <a
+ * href="http://www.unicode.org/Public/MAPPINGS/VENDORS/APPLE/ROMAN.TXT"
+ * >the Unicode mapping table for the MacOS Roman encoding</a>
+ */
+ private static final String UPPER_ROMAN
+ = "\u007e\u0000\u00c4\u00c5\u00c7\u00c9\u00d1\u00d6\u00dc\u00e1"
+ + "\u00e0\u00e2\u00e4\u00e3\u00e5\u00e7\u00e9\u00e8\u00ea\u00eb"
+ + "\u00ed\u00ec\u00ee\u00ef\u00f1\u00f3\u00f2\u00f4\u00f6\u00f5"
+ + "\u00fa\u00f9\u00fb\u00fc\u2020\u00b0\u00a2\u00a3\u00a7\u2022"
+ + "\u00b6\u00df\u00ae\u00a9\u2122\u00b4\u00a8\u2260\u00c6\u00d8"
+ + "\u221e\u00b1\u2264\u2265\u00a5\u00b5\u2202\u2211\u220f\u03c0"
+ + "\u222b\u00aa\u00ba\u03a9\u00e6\u00f8\u00bf\u00a1\u00ac\u221a"
+ + "\u0192\u2248\u2206\u00ab\u00bb\u2026\u00a0\u00c0\u00c3\u00d5"
+ + "\u0152\u0153\u2013\u2014\u201c\u201d\u2018\u2019\u00f7\u25ca"
+ + "\u00ff\u0178\u2044\u20ac\u2039\u203a\ufb01\ufb02\u2021\u00b7"
+ + "\u201a\u201e\u2030\u00c2\u00ca\u00c1\u00cb\u00c8\u00cd\u00ce"
+ + "\u00cf\u00cc\u00d3\u00d4\uf8ff\u00d2\u00da\u00db\u00d9\u0131"
+ + "\u02c6\u02dc\u00af\u02d8\u02d9\u02da\u00b8\u02dd\u02db\u02c7";
+
+
+ /**
+ * A String whose <code>charAt(i)</code> is the Unicode character
+ * that corresponds to the codepoint <code>i + 127</code> in the
+ * MacOS Roman encoding with the Romanian language.
+ *
+ * @see <a href=
+ * "http://www.unicode.org/Public/MAPPINGS/VENDORS/APPLE/ROMANIAN.TXT"
+ * >the Unicode mapping table for the MacOS Romanian encoding</a>
+ */
+ private static final String UPPER_ROMANIAN
+ = "\u007e\u0000\u00c4\u00c5\u00c7\u00c9\u00d1\u00d6\u00dc\u00e1"
+ + "\u00e0\u00e2\u00e4\u00e3\u00e5\u00e7\u00e9\u00e8\u00ea\u00eb"
+ + "\u00ed\u00ec\u00ee\u00ef\u00f1\u00f3\u00f2\u00f4\u00f6\u00f5"
+ + "\u00fa\u00f9\u00fb\u00fc\u2020\u00b0\u00a2\u00a3\u00a7\u2022"
+ + "\u00b6\u00df\u00ae\u00a9\u2122\u00b4\u00a8\u2260\u0102\u0218"
+ + "\u221e\u00b1\u2264\u2265\u00a5\u00b5\u2202\u2211\u220f\u03c0"
+ + "\u222b\u00aa\u00ba\u03a9\u0103\u0219\u00bf\u00a1\u00ac\u221a"
+ + "\u0192\u2248\u2206\u00ab\u00bb\u2026\u00a0\u00c0\u00c3\u00d5"
+ + "\u0152\u0153\u2013\u2014\u201c\u201d\u2018\u2019\u00f7\u25ca"
+ + "\u00ff\u0178\u2044\u20ac\u2039\u203a\u021a\u021b\u2021\u00b7"
+ + "\u201a\u201e\u2030\u00c2\u00ca\u00c1\u00cb\u00c8\u00cd\u00ce"
+ + "\u00cf\u00cc\u00d3\u00d4\uf8ff\u00d2\u00da\u00db\u00d9\u0131"
+ + "\u02c6\u02dc\u00af\u02d8\u02d9\u02da\u00b8\u02dd\u02db\u02c7";
+
+
+ /**
+ * A String whose <code>charAt(i)</code> is the Unicode character
+ * that corresponds to the codepoint <code>i + 127</code> in the
+ * MacOS Roman encoding with the Turkish language.
+ *
+ * @see <a href=
+ * "http://www.unicode.org/Public/MAPPINGS/VENDORS/APPLE/TURKISH.TXT"
+ * >the Unicode mapping table for the MacOS Turkish encoding</a>
+ */
+ private static final String UPPER_TURKISH
+ = "\u007e\u0000\u00c4\u00c5\u00c7\u00c9\u00d1\u00d6\u00dc\u00e1"
+ + "\u00e0\u00e2\u00e4\u00e3\u00e5\u00e7\u00e9\u00e8\u00ea\u00eb"
+ + "\u00ed\u00ec\u00ee\u00ef\u00f1\u00f3\u00f2\u00f4\u00f6\u00f5"
+ + "\u00fa\u00f9\u00fb\u00fc\u2020\u00b0\u00a2\u00a3\u00a7\u2022"
+ + "\u00b6\u00df\u00ae\u00a9\u2122\u00b4\u00a8\u2260\u00c6\u00d8"
+ + "\u221e\u00b1\u2264\u2265\u00a5\u00b5\u2202\u2211\u220f\u03c0"
+ + "\u222b\u00aa\u00ba\u03a9\u00e6\u00f8\u00bf\u00a1\u00ac\u221a"
+ + "\u0192\u2248\u2206\u00ab\u00bb\u2026\u00a0\u00c0\u00c3\u00d5"
+ + "\u0152\u0153\u2013\u2014\u201c\u201d\u2018\u2019\u00f7\u25ca"
+ + "\u00ff\u0178\u011e\u011f\u0130\u0131\u015e\u015f\u2021\u00b7"
+ + "\u201a\u201e\u2030\u00c2\u00ca\u00c1\u00cb\u00c8\u00cd\u00ce"
+ + "\u00cf\u00cc\u00d3\u00d4\uf8ff\u00d2\u00da\u00db\u00d9\uf8a0"
+ + "\u02c6\u02dc\u00af\u02d8\u02d9\u02da\u00b8\u02dd\u02db\u02c7";
+
+
+ /**
+ * Constructs a CharGlyphMap.Type0 from all type 0 cmaps provided
+ * by the font. The implementation is able to fuse multiple type
+ * 0 cmaps, such as the MacRoman, Turkish, Icelandic and Croatian
+ * encoding, into a single map from Unicode characters to glyph
+ * indices.
+ *
+ * @param buf a ByteBuffer whose position is right at the
+ * beginning of the entire cmap table of the font (<i>not</i>
+ * at some subtable).
+ */
+ public Type0(ByteBuffer buf)
+ {
+ int numTables;
+ int tableStart = buf.position();
+ int limit = buf.limit();
+
+ /* The CMAP version must be 0. */
+ if (buf.getChar() != 0)
+ throw new IllegalStateException();
+
+ numTables = buf.getChar();
+ for (int i = 0; i < numTables; i++)
+ {
+ buf.limit(limit).position(tableStart + 4 + i * 8);
+ int platform = buf.getChar();
+ int encoding = buf.getChar();
+ int offset = tableStart + buf.getInt();
+
+ buf.position(offset);
+ int format = buf.getChar();
+ int length = buf.getChar();
+ buf.limit(offset + length);
+ int language = buf.getChar();
+
+ if (format == 0)
+ readSingleTable(buf, platform, language, encoding);
+ }
+ }
+
+
+ /**
+ * Processes a CMAP Type 0 table whose platform, encoding and
+ * language are already known.
+ *
+ * @param buf the buffer to read the table from, positioned
+ * right after the language tag.
+ */
+ private void readSingleTable(ByteBuffer buf,
+ int platform, int language,
+ int encoding)
+ {
+ String upper = getUpper129(platform, encoding, language);
+ if (upper == null)
+ return;
+
+ /* Skip the MacOS codepoints [0 .. 31] because they do not
+ * correspond to any Unicode codepoint.
+ */
+ buf.position(buf.position() + 32);
+
+ /* Irrespective of script and language, the MacOS codepoints
+ * [32 .. 126] correspond to the same Unicode codepoint.
+ */
+ for (int i = 32; i < 126; i++)
+ glyphToUCS2[buf.get() & 0xff] = (char) i;
+
+ for (int i = 127; i < 256; i++)
+ glyphToUCS2[buf.get() & 0xff] = upper.charAt(i - 127);
+
+ /* Glyph 0 is always the undefined character, which has
+ * no codepoint in Unicode.
+ */
+ glyphToUCS2[0] = 0;
+ }
+
+
+ /**
+ * Determines the glyph index for a given Unicode codepoint.
+ *
+ * @param ucs4 the Unicode codepoint in UCS-4 encoding.
+ *
+ * @return the glyph index, or 0 if the font does not contain
+ * a glyph for this codepoint.
+ */
+ public int getGlyph(int ucs4)
+ {
+ /* This linear search is not exactly super fast. However,
+ * only really ancient fonts have only a type 0 cmap,
+ * so it should not hurt in very many cases. If it shows
+ * to be a performance problem, one could do a binary search
+ * on a 256-entry table sorted by Unicode codepoint. The
+ * matching index of that table could then be used to look
+ * up the glyph ID at that position.
+ */
+ for (int i = 0; i < 256; i++)
+ if (glyphToUCS2[i] == ucs4)
+ return i;
+ return 0;
+ }
+
+
+ /**
+ * Returns a String whose <code>charAt(i)</code> is the Unicode
+ * character that corresponds to the codepoint <code>i +
+ * 127</code> in the encoding specified by the platform, script
+ * and language tag of a Type 0 CMAP.
+ *
+ * @param language the language tag in the cmap subtable. For the
+ * Macintosh platform, this is 0 to indicate language-neutral
+ * encoding, or the MacOS language code <i>plus one.</i> The
+ * Apple documentation does not mention that one needs to be
+ * added, but the Adobe OpenType specification does.
+ *
+ * @return a String for mapping the top 129 characters to
+ * UCS-2. If <code>platform</code> is not <code>1</code>
+ * (indicating Macintosh), or if the combination of
+ * <code>script</code> and <code>language</code> is not
+ * recognized, <code>null</code> will be returned.
+ */
+ private static String getUpper129(int platform, int script, int language)
+ {
+ if (platform != PLATFORM_MACINTOSH)
+ return null;
+
+ switch (script)
+ {
+ case 0: /* smRoman */
+ if (language == /* langIcelandic+1 */ 16)
+ return UPPER_ICELANDIC;
+ else if (language == /* langTurkish+1 */ 18)
+ return UPPER_TURKISH;
+ else if (language == /* langCroatian+1 */ 19)
+ return UPPER_CROATIAN;
+ else if (language == /* langRomanian+1 */ 38)
+ return UPPER_ROMANIAN;
+ else if (language == /* language-neutral */ 0)
+ return UPPER_ROMAN;
+ else
+ return null;
+
+ case 4: /* smArabic */
+ if (language == /* langFarsi+1 */ 32)
+ return UPPER_FARSI;
+ else
+ return UPPER_ARABIC;
+
+ case 5: /* smHebrew */
+ return UPPER_HEBREW;
+
+ case 6: /* smGreek */
+ return UPPER_GREEK;
+
+ case 7: /* smCyrillic */
+ return UPPER_CYRILLIC;
+
+ case 29: /* smSlavic == smEastEurRoman */
+ return UPPER_EAST_EUROPEAN_ROMAN;
+ }
+
+ return null;
+ }
+ }
+
+
+ /**
+ * A mapping from Unicode code points to glyph IDs through CMAP Type
+ * 4 tables. These tables are able to map two-byte encoded text
+ * to glyph IDs, such as Unicode Basic Multilingual Plane which
+ * contains U+0000 .. U+FFFE without surrogates.
+ *
+ * @author Sascha Brawer (brawer@dandelis.ch)
+ */
+ private static final class Type4
+ extends CharGlyphMap
+ {
+ /**
+ * Determines whether this implementation supports a combination
+ * of platform, language and encoding is supported for a type 4
+ * <code>cmap</code> table.
+ *
+ * <p>Currently, we support the following combinations:
+ *
+ * <ul><li>the Unicode platform in encodings 0, 1, 2, 3 and
+ * 4;</li>
+ *
+ * <li>the Microsoft platform in encodings 1 (Basic Multilingual
+ * Plane) and 10 (full Unicode).</li></ul>
+ *
+ * <p>Most recent Macintosh fonts provide a type 4
+ * <code>cmap</code> for Unicode. Microsoft recommends providing a
+ * type 4 <code>cmap</code> for encoding 1 of the Microsoft
+ * platform. The implementation of GNU Classpath supports both
+ * variants.
+ *
+ * <p>Not supported are ShiftJIS, Big5, Wansung, Johab, and other
+ * non-Unicode encodings. Text can easily be converted to Unicode
+ * using the java.nio.charset package.
+ */
+ static boolean isSupported(int platform, int language, int encoding)
+ {
+ switch (platform)
+ {
+ case PLATFORM_UNICODE:
+ return (encoding >= 0) && (encoding <= 4);
+
+ case PLATFORM_MICROSOFT:
+ return (encoding == /* Basic Multilingual Plane */ 1)
+ || (encoding == /* Full Unicode */ 10);
+ }
+
+ return false;
+ }
+
+
+ /**
+ * Processes a CMAP Type 4 table whose platform, encoding and
+ * language are already known. We understand the Unicode platform
+ * with encodings 0, 1, 2, 3 and 4, and the Microsoft platform
+ * with encodings 1 (Unicode BMP) and 10 (UCS-4).
+ *
+ * @param buf the buffer to read the table from, positioned at
+ * its beginning.
+ *
+ * @return a Type4 table, or <code>null</code> if the combination
+ * of platform and encoding is not understood.
+ */
+ static Type4 readTable(ByteBuffer buf,
+ int platform, int encoding)
+ {
+ int tableStart = buf.position();
+ char format = buf.getChar();
+ int length = buf.getChar();
+ int language = buf.getChar();
+
+ if ((format != 4) || !isSupported(platform, language, encoding))
+ throw new IllegalArgumentException();
+
+ buf.limit(tableStart + length);
+
+ int segCountX2 = buf.getChar();
+ int segCount = segCountX2 / 2;
+ int searchRange = buf.getChar();
+ int entrySelector = buf.getChar();
+ int rangeShift = buf.getChar();
+
+ CharBuffer endCode, startCode, idRangeOffset_glyphID;
+ ShortBuffer idDelta;
+
+ int pos = buf.position();
+ endCode = buf.asCharBuffer();
+ pos += segCountX2 + /* reservedPad */ 2;
+
+ buf.position(pos);
+ startCode = buf.asCharBuffer();
+ pos += segCountX2;
+
+ buf.position(pos);
+ idDelta = buf.asShortBuffer();
+ pos += segCountX2;
+
+ buf.position(pos);
+ idRangeOffset_glyphID = buf.asCharBuffer();
+
+ endCode.limit(segCount);
+ startCode.limit(segCount);
+ idDelta.limit(segCount);
+ idRangeOffset_glyphID.limit((buf.limit() - pos) / 2);
+
+ return new Type4(segCount,
+ endCode, startCode, idDelta,
+ idRangeOffset_glyphID);
+ }
+
+
+ private CharBuffer lastChar;
+ private CharBuffer firstChar;
+ private ShortBuffer idDelta;
+ private CharBuffer rangeID;
+ private int numSegments;
+
+ private Type4(int numSegments,
+ CharBuffer lastChar, CharBuffer firstChar,
+ ShortBuffer idDelta, CharBuffer rangeID)
+ {
+ this.numSegments = numSegments;
+ this.lastChar = lastChar;
+ this.firstChar = firstChar;
+ this.idDelta = idDelta;
+ this.rangeID = rangeID;
+ }
+
+
+ /**
+ * Determines the glyph index for a given Unicode codepoint.
+ *
+ * @param ucs4 the Unicode codepoint in UCS-4 encoding.
+ *
+ * @return the glyph index, or 0 if the font does not contain
+ * a glyph for this codepoint.
+ */
+ public int getGlyph(int ucs4)
+ {
+ char c, segStart;
+ int segment, idRangeOffset;
+
+ if (ucs4 > 0xffff)
+ return 0;
+
+ c = (char) ucs4;
+ segment = find(c);
+ segStart = firstChar.get(segment);
+ if ((c < segStart) || (c > lastChar.get(segment)))
+ return 0;
+
+ /*
+ * System.out.println("seg " + segment
+ * + ", range=" + (int) rangeID[segment]
+ * + ", delta=" + delta[segment]);
+ */
+
+ idRangeOffset = rangeID.get(segment);
+ if (idRangeOffset == 0)
+ return (int) (char) (((int) c) + idDelta.get(segment));
+ int result = rangeID.get((idRangeOffset >> 1)
+ + (c - segStart) + segment);
+ if (result == 0)
+ return 0;
+ return (int) (char) (result + idDelta.get(segment));
+ }
+
+
+ private int find(char c)
+ {
+ int min, max, mid;
+
+ min = 0;
+ max = numSegments - 1;
+ mid = max >> 1;
+
+ while (min < max)
+ {
+ // System.out.println("(" + min + "," + max + ") " + mid);
+ char val = lastChar.get(mid);
+ if (val == c)
+ break;
+ else if (val < c)
+ min = mid + 1;
+ else if (val > c)
+ max = mid;
+ mid = (min + max) >> 1;
+ }
+
+ return mid;
+ }
+ }
+
+
+ /**
+ * A mapping from Unicode code points to glyph IDs through CMAP Type
+ * 12 tables. These tables are able to map four-byte encoded text
+ * to glyph IDs, such as Unicode UCS-4.
+ *
+ * @author Sascha Brawer (brawer@dandelis.ch)
+ */
+ private static final class Type12
+ extends CharGlyphMap
+ {
+ int numGroups;
+ IntBuffer data;
+
+
+ /**
+ * Determines whether this implementation supports a combination
+ * of platform and encoding for a type 12 <code>cmap</code> table.
+ *
+ * <p>Currently, we support the following combinations:
+ *
+ * <ul><li>the Unicode platform in encodings 0, 1, 2, 3 and
+ * 4;</li>
+ *
+ * <li>the Microsoft platform in encodings 1 (Basic Multilingual
+ * Plane) and 10 (full Unicode).</li></ul>
+ */
+ static boolean isSupported(int platform, int encoding)
+ {
+ switch (platform)
+ {
+ case PLATFORM_UNICODE:
+ return (encoding >= 0) && (encoding <= 4);
+
+ case PLATFORM_MICROSOFT:
+ return (encoding == /* Basic Multilingual Plane */ 1)
+ || (encoding == /* Full Unicode */ 10);
+ }
+
+ return false;
+ }
+
+
+ /**
+ * Constructs a <code>cmap</code> type 12 table whose platform and
+ * encoding are already known. We understand the Unicode platform
+ * with encodings 0, 1, 2, 3 and 4, and the Microsoft platform
+ * with encodings 1 (Unicode BMP) and 10 (UCS-4).
+ *
+ * @param buf the buffer to read the table from, positioned at
+ * its beginning.
+ */
+ Type12(ByteBuffer buf, int platform, int encoding)
+ {
+ int tableStart = buf.position();
+ int format = buf.getChar();
+ if ((format != 12) || !isSupported(platform, encoding))
+ throw new IllegalStateException();
+
+ buf.getChar(); // skip reserved field
+ buf.limit(tableStart + buf.getInt());
+ int language = buf.getInt();
+ numGroups = buf.getInt();
+ data = buf.asIntBuffer();
+ }
+
+
+ /**
+ * Determines the glyph index for a given Unicode codepoint. Users
+ * should be aware that the character-to-glyph mapping not not
+ * everything that is needed for full Unicode support. For example,
+ * the <code>cmap</code> table is not able to synthesize accented
+ * glyphs from the canonical decomposition sequence, even if the
+ * font would contain a glyph for the composed form.
+ *
+ * @param ucs4 the Unicode codepoint in UCS-4 encoding. Surrogates
+ * (U+D800 to U+DFFF) cannot be passed, they must be mapped to
+ * UCS-4 first.
+ *
+ * @return the glyph index, or 0 if the font does not contain
+ * a glyph for this codepoint.
+ */
+ public int getGlyph(int ucs4)
+ {
+ int min, max, mid, startCharCode, endCharCode;
+
+ min = 0;
+ max = numGroups - 1;
+ mid = max >> 1;
+ do
+ {
+ startCharCode = data.get(3 * mid);
+ endCharCode = data.get(3 * mid + 1);
+
+
+ /*
+ System.out.println("group " + mid + " (U+"
+ + Integer.toHexString(startCharCode)
+ + " .. U+" + Integer.toHexString(endCharCode)
+ + "): glyph " + (int) data.get(mid*3+2));
+ */
+
+ if ((startCharCode <= ucs4) && (ucs4 <= endCharCode))
+ return ucs4
+ - startCharCode
+ + /* startGlyphID */ data.get(mid * 3 + 2);
+
+ if (endCharCode < ucs4)
+ min = mid + 1;
+ else
+ max = mid;
+ mid = (min + max) >> 1;
+ }
+ while (min < max);
+
+ startCharCode = data.get(3 * mid);
+ endCharCode = data.get(3 * mid + 1);
+ if ((startCharCode <= ucs4) && (ucs4 <= endCharCode))
+ return ucs4
+ - startCharCode
+ + /* startGlyphID */ data.get(mid * 3 + 2);
+
+ return 0;
+ }
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/opentype/GlyphNamer.java b/libjava/classpath/gnu/java/awt/font/opentype/GlyphNamer.java
new file mode 100644
index 000000000..72cecb542
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/opentype/GlyphNamer.java
@@ -0,0 +1,1135 @@
+/* GlyphNamer.java -- Provides glyph names.
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.awt.font.opentype;
+
+import gnu.java.lang.CPStringBuilder;
+
+import java.nio.ByteBuffer;
+import java.nio.IntBuffer;
+import java.nio.CharBuffer;
+
+
+/**
+ * Provides names for glyphs, which is useful when embedding fonts
+ * in PostScript or PDF documents.
+ *
+ * <p>If the font has a <code>Zapf</code> table, it is used to map
+ * glyph IDs back to a sequence of Unicode codepoints, which then
+ * makes it possible to look up or synthesize a PostScript glyph name
+ * according to Adobe&#x2019;s conventions. This allows to extract the
+ * original text from the generated PDF or PostScript file, which is
+ * important for indexing, searching and extracting.
+ *
+ * <p>Otherwise, glyph names are taken from the <a href=
+ * "http://developer.apple.com/fonts/TTRefMan/RM06/Chap6post.html"
+ * ><code>post</code> table</a>. All known formats (1, 2, 2.5, 3 and
+ * 4) are supported.
+ *
+ * <p><b>Open Tasks:</b> The code could be cleaner structured by
+ * having separate sub-classes for each variant of the POST table.
+ * Also, the implementation should not read in all glyph names if a
+ * font provides them in a POST table of type 2. It would be
+ * sufficient to just read in the offsets and delay the String
+ * fetching and conversion to the time when the glyph name is actually
+ * requested.
+ *
+ * <p><b>Lack of Thread Safety:</b> The GlyphNamer class is
+ * intentionally <i>not</i> safe to access from multiple concurrent
+ * threads. Synchronization needs to be performed externally. Usually,
+ * the font has already obtained a lock before calling the GlyphNamer.
+ * It would thus be wasteful to acquire additional locks for the
+ * GlyphNamer.
+ *
+ * @author Sascha Brawer (brawer@dandelis.ch)
+ */
+final class GlyphNamer
+{
+ /**
+ * The 'post' table of the font.
+ */
+ private ByteBuffer postTable;
+
+
+ /**
+ * The 'Zapf' table of the font, or null if the font has no
+ * such table.
+ */
+ private ByteBuffer zapfTable;
+
+
+ /**
+ * The offset of each glyph relative to the Zapf table,
+ * or null if the font does not have a Zapf table.
+ */
+ private IntBuffer zapfOffsets;
+
+
+ /**
+ * The offset from the start of the Zapf table to the start
+ * of the extra info area.
+ */
+ private int zapfExtraInfo;
+
+
+ /**
+ * The format of the post table, a Fixed 16.16 number.
+ */
+ private int postFormat;
+
+
+ /**
+ * An array of glyph names. Used for table formats 1, 2, 2.5.
+ */
+ private String[] glyphNames;
+
+
+ /**
+ * An array from glyph to character codes. Similar to the
+ * workings of a Zapf table, but maps to CID instead of
+ * Unicode. Used for table format 4.
+ */
+ private CharBuffer glyphCharacterCodes;
+
+
+ /**
+ * The PostScript names of the 258 standard Macintosh glyphs. Note
+ * that some of these glyphs are not in the Adobe Standard Glyph
+ * List for New Fonts, namely .notdef, .null, nonmarkingreturn,
+ * nonbreakingspace, apple, onesuperior, twosuperior, and
+ * threesuperior.
+ */
+ private static final String[] STANDARD_POSTSCRIPT_GLYPH_NAMES =
+ {
+ ".notdef", // glyph #0
+ ".null", // glyph #1
+ "nonmarkingreturn", // glyph #2
+ "space", // glyph #3
+ "exclam", // glyph #4
+ "quotedbl", // glyph #5
+ "numbersign", // glyph #6
+ "dollar", // glyph #7
+ "percent", // glyph #8
+ "ampersand", // glyph #9
+ "quotesingle", // glyph #10
+ "parenleft", // glyph #11
+ "parenright", // glyph #12
+ "asterisk", // glyph #13
+ "plus", // glyph #14
+ "comma", // glyph #15
+ "hyphen", // glyph #16
+ "period", // glyph #17
+ "slash", // glyph #18
+ "zero", // glyph #19
+ "one", // glyph #20
+ "two", // glyph #21
+ "three", // glyph #22
+ "four", // glyph #23
+ "five", // glyph #24
+ "six", // glyph #25
+ "seven", // glyph #26
+ "eight", // glyph #27
+ "nine", // glyph #28
+ "colon", // glyph #29
+ "semicolon", // glyph #30
+ "less", // glyph #31
+ "equal", // glyph #32
+ "greater", // glyph #33
+ "question", // glyph #34
+ "at", // glyph #35
+ "A", // glyph #36
+ "B", // glyph #37
+ "C", // glyph #38
+ "D", // glyph #39
+ "E", // glyph #40
+ "F", // glyph #41
+ "G", // glyph #42
+ "H", // glyph #43
+ "I", // glyph #44
+ "J", // glyph #45
+ "K", // glyph #46
+ "L", // glyph #47
+ "M", // glyph #48
+ "N", // glyph #49
+ "O", // glyph #50
+ "P", // glyph #51
+ "Q", // glyph #52
+ "R", // glyph #53
+ "S", // glyph #54
+ "T", // glyph #55
+ "U", // glyph #56
+ "V", // glyph #57
+ "W", // glyph #58
+ "X", // glyph #59
+ "Y", // glyph #60
+ "Z", // glyph #61
+ "bracketleft", // glyph #62
+ "backslash", // glyph #63
+ "bracketright", // glyph #64
+ "asciicircum", // glyph #65
+ "underscore", // glyph #66
+ "grave", // glyph #67
+ "a", // glyph #68
+ "b", // glyph #69
+ "c", // glyph #70
+ "d", // glyph #71
+ "e", // glyph #72
+ "f", // glyph #73
+ "g", // glyph #74
+ "h", // glyph #75
+ "i", // glyph #76
+ "j", // glyph #77
+ "k", // glyph #78
+ "l", // glyph #79
+ "m", // glyph #80
+ "n", // glyph #81
+ "o", // glyph #82
+ "p", // glyph #83
+ "q", // glyph #84
+ "r", // glyph #85
+ "s", // glyph #86
+ "t", // glyph #87
+ "u", // glyph #88
+ "v", // glyph #89
+ "w", // glyph #90
+ "x", // glyph #91
+ "y", // glyph #92
+ "z", // glyph #93
+ "braceleft", // glyph #94
+ "bar", // glyph #95
+ "braceright", // glyph #96
+ "asciitilde", // glyph #97
+ "Adieresis", // glyph #98
+ "Aring", // glyph #99
+ "Ccedilla", // glyph #100
+ "Eacute", // glyph #101
+ "Ntilde", // glyph #102
+ "Odieresis", // glyph #103
+ "Udieresis", // glyph #104
+ "aacute", // glyph #105
+ "agrave", // glyph #106
+ "acircumflex", // glyph #107
+ "adieresis", // glyph #108
+ "atilde", // glyph #109
+ "aring", // glyph #110
+ "ccedilla", // glyph #111
+ "eacute", // glyph #112
+ "egrave", // glyph #113
+ "ecircumflex", // glyph #114
+ "edieresis", // glyph #115
+ "iacute", // glyph #116
+ "igrave", // glyph #117
+ "icircumflex", // glyph #118
+ "idieresis", // glyph #119
+ "ntilde", // glyph #120
+ "oacute", // glyph #121
+ "ograve", // glyph #122
+ "ocircumflex", // glyph #123
+ "odieresis", // glyph #124
+ "otilde", // glyph #125
+ "uacute", // glyph #126
+ "ugrave", // glyph #127
+ "ucircumflex", // glyph #128
+ "udieresis", // glyph #129
+ "dagger", // glyph #130
+ "degree", // glyph #131
+ "cent", // glyph #132
+ "sterling", // glyph #133
+ "section", // glyph #134
+ "bullet", // glyph #135
+ "paragraph", // glyph #136
+ "germandbls", // glyph #137
+ "registered", // glyph #138
+ "copyright", // glyph #139
+ "trademark", // glyph #140
+ "acute", // glyph #141
+ "dieresis", // glyph #142
+ "notequal", // glyph #143
+ "AE", // glyph #144
+ "Oslash", // glyph #145
+ "infinity", // glyph #146
+ "plusminus", // glyph #147
+ "lessequal", // glyph #148
+ "greaterequal", // glyph #149
+ "yen", // glyph #150
+ "mu", // glyph #151
+ "partialdiff", // glyph #152
+ "summation", // glyph #153
+ "product", // glyph #154
+ "pi", // glyph #155
+ "integral", // glyph #156
+ "ordfeminine", // glyph #157
+ "ordmasculine", // glyph #158
+ "Omega", // glyph #159
+ "ae", // glyph #160
+ "oslash", // glyph #161
+ "questiondown", // glyph #162
+ "exclamdown", // glyph #163
+ "logicalnot", // glyph #164
+ "radical", // glyph #165
+ "florin", // glyph #166
+ "approxequal", // glyph #167
+ "Delta", // glyph #168
+ "guillemotleft", // glyph #169
+ "guillemotright", // glyph #170
+ "ellipsis", // glyph #171
+ "nonbreakingspace", // glyph #172
+ "Agrave", // glyph #173
+ "Atilde", // glyph #174
+ "Otilde", // glyph #175
+ "OE", // glyph #176
+ "oe", // glyph #177
+ "endash", // glyph #178
+ "emdash", // glyph #179
+ "quotedblleft", // glyph #180
+ "quotedblright", // glyph #181
+ "quoteleft", // glyph #182
+ "quoteright", // glyph #183
+ "divide", // glyph #184
+ "lozenge", // glyph #185
+ "ydieresis", // glyph #186
+ "Ydieresis", // glyph #187
+ "fraction", // glyph #188
+ "currency", // glyph #189
+ "guilsinglleft", // glyph #190
+ "guilsinglright", // glyph #191
+ "fi", // glyph #192
+ "fl", // glyph #193
+ "daggerdbl", // glyph #194
+ "periodcentered", // glyph #195
+ "quotesinglbase", // glyph #196
+ "quotedblbase", // glyph #197
+ "perthousand", // glyph #198
+ "Acircumflex", // glyph #199
+ "Ecircumflex", // glyph #200
+ "Aacute", // glyph #201
+ "Edieresis", // glyph #202
+ "Egrave", // glyph #203
+ "Iacute", // glyph #204
+ "Icircumflex", // glyph #205
+ "Idieresis", // glyph #206
+ "Igrave", // glyph #207
+ "Oacute", // glyph #208
+ "Ocircumflex", // glyph #209
+ "apple", // glyph #210
+ "Ograve", // glyph #211
+ "Uacute", // glyph #212
+ "Ucircumflex", // glyph #213
+ "Ugrave", // glyph #214
+ "dotlessi", // glyph #215
+ "circumflex", // glyph #216
+ "tilde", // glyph #217
+ "macron", // glyph #218
+ "breve", // glyph #219
+ "dotaccent", // glyph #220
+ "ring", // glyph #221
+ "cedilla", // glyph #222
+ "hungarumlaut", // glyph #223
+ "ogonek", // glyph #224
+ "caron", // glyph #225
+ "Lslash", // glyph #226
+ "lslash", // glyph #227
+ "Scaron", // glyph #228
+ "scaron", // glyph #229
+ "Zcaron", // glyph #230
+ "zcaron", // glyph #231
+ "brokenbar", // glyph #232
+ "Eth", // glyph #233
+ "eth", // glyph #234
+ "Yacute", // glyph #235
+ "yacute", // glyph #236
+ "Thorn", // glyph #237
+ "thorn", // glyph #238
+ "minus", // glyph #239
+ "multiply", // glyph #240
+ "onesuperior", // glyph #241
+ "twosuperior", // glyph #242
+ "threesuperior", // glyph #243
+ "onehalf", // glyph #244
+ "onequarter", // glyph #245
+ "threequarters", // glyph #246
+ "franc", // glyph #247
+ "Gbreve", // glyph #248
+ "gbreve", // glyph #249
+ "Idotaccent", // glyph #250
+ "Scedilla", // glyph #251
+ "scedilla", // glyph #252
+ "Cacute", // glyph #253
+ "cacute", // glyph #254
+ "Ccaron", // glyph #255
+ "ccaron", // glyph #256
+ "dcroat" // glyph #257
+ };
+
+
+ private GlyphNamer(int numGlyphs,
+ ByteBuffer postTable,
+ ByteBuffer zapfTable)
+ {
+ this.postTable = postTable;
+ this.zapfTable = zapfTable;
+
+ if ((zapfTable != null) && (zapfTable.getInt(0) == 0x00010000))
+ {
+ readZapf(numGlyphs);
+ return;
+ }
+
+ readPost();
+ }
+
+
+ /**
+ * Sets up the information which allows to retrieve the information
+ * on demand.
+ *
+ * @param numGlyphs the number of glyphs in the font. This value
+ * comes from the <code>maxp</code> table.
+ */
+ public static GlyphNamer forTables(int numGlyphs,
+ ByteBuffer postTable,
+ ByteBuffer zapfTable)
+ {
+ return new GlyphNamer(numGlyphs, postTable, zapfTable);
+ }
+
+
+ /**
+ * Retrieves or synthesizes a PostScript name for the glyph.
+ * Although the code is reasonably fast, it is recommended
+ * to cache the results in the printer driver.
+ *
+ * <p>If a font provides a 'Zapf' table, the reverse mapping
+ * from glyph to UTF-16 sequence is performed, and a glyph
+ * name is synthesized following the recommendations by Adobe.
+ * This allows to extract the original text from the generated
+ * PostScript or PDF, which is a requirement for indexing
+ * and searching.
+ *
+ * <p>If a font does not provide a 'Zapf' table, the glyph name
+ * is taken from the 'post' table. Note that some fonts have
+ * wrong data in their post data, in which case the resulting
+ * name will be garbage. Usually, this does not hurt, unless
+ * the user wants to extract text from the generated PostScript
+ * or PDF file. The GNU implementation understands all known
+ * formats of the post table (1, 2, 2.5, 3 and 4).
+ *
+ * @param glyph the index of the glyph whose name is to be
+ * retrieved.
+ *
+ * @return the glyph name, such as <code>A</code>,
+ * <code>gcircumflex</code>, <code>z_uni0302</code>, or
+ * <code>u11C42</code>.</li>
+ */
+ String getGlyphName(int glyph)
+ {
+ if (zapfOffsets != null)
+ {
+ zapfTable.position(zapfOffsets.get(glyph) + 8);
+ int numChars = zapfTable.getChar();
+ char[] chars = new char[numChars];
+ for (int i = 0; i < numChars; i++)
+ chars[i] = zapfTable.getChar();
+ return getGlyphName(chars);
+ }
+
+
+ /* Type 1, Type 2, Type 2.5 */
+ if (glyphNames != null)
+ return glyphNames[glyph];
+
+ /* Type 4: Synthesized glyph name. */
+ if (glyphCharacterCodes != null)
+ return "a" + glyphCharacterCodes.get(glyph);
+
+ /* Type 3: Arbitrary, but unique name for the glyph.
+ *
+ * To find out what a good naming scheme would be, we have printed
+ * a document containing the character U+201C in the font
+ * "Hiragino Kaku Gothic Pro W3" (by Dainippon Screen Mfg. Co.,
+ * Ltd.) on Apple MacOS X 10.1.5. This font has a type 3 'post'
+ * table, and its 'cmap' maps U+201C to glyph #108. The generated
+ * PostScript file defined a character whose name was "g108".
+ *
+ * Therefore, we use 'g' as name prefix. According to the
+ * TrueType/OpenType specification, it should not matter what
+ * prefix we use. On the other hand, it does not hurt either to be
+ * compatible with a good printer driver.
+ *
+ * Actually, that specific font also contains a 'Zapf' table,
+ * which allows to generate glyph names according to Adobe's
+ * conventions, so that extracting text from and searching in the
+ * generated PostScript or PDF becomes possible. While the Apple
+ * PostScript printer driver does not seem to use the 'Zapf' table
+ * for this purpose, we do.
+ */
+ return "g" + glyph;
+ }
+
+
+ /**
+ * Sets up some buffers which allow to quickly read information from
+ * the Zapf table.
+ *
+ * @see <a href=
+ * "http://developer.apple.com/fonts/TTRefMan/RM06/Chap6Zapf.html">
+ * Apple&#x2019;s documentation of the <code>Zapf</code> table</a>
+ */
+ private void readZapf(int numGlyphs)
+ {
+ zapfExtraInfo = zapfTable.getInt(4);
+ zapfTable.position(8);
+ zapfOffsets = zapfTable.asIntBuffer();
+ zapfOffsets.limit(numGlyphs);
+ }
+
+
+ /**
+ * Reads in the PostScript data from a <code>post</code> table of a
+ * TrueType or OpenType font. The implementation currently
+ * understands the table formats 1, 2, 2.5, 3, and 4.
+ */
+ private void readPost()
+ {
+ int numGlyphs, nameIndex, maxNameIndex;
+ char[] nameIndices;
+ String[] names;
+ byte[] pascalName;
+
+ postTable.position(0);
+ postFormat = postTable.getInt();
+ switch (postFormat)
+ {
+ case 0x00010000:
+ glyphNames = STANDARD_POSTSCRIPT_GLYPH_NAMES;
+ return;
+
+ case 0x00020000:
+ postTable.position(32);
+ numGlyphs = postTable.getChar();
+ glyphNames = new String[numGlyphs];
+ pascalName = new byte[255];
+ nameIndices = new char[numGlyphs];
+ maxNameIndex = 0;
+ for (int i = 0; i < numGlyphs; i++)
+ maxNameIndex = Math.max(maxNameIndex,
+ nameIndices[i] = postTable.getChar());
+
+ names = new String[Math.max(maxNameIndex - 258 + 1, 0)];
+ for (int i = 258; i <= maxNameIndex; i++)
+ {
+ int nameLen = (postTable.get() & 0xff);
+ postTable.get(pascalName, 0, nameLen);
+ names[i - 258] = new String(pascalName, 0, nameLen);
+ }
+ for (int i = 0; i < numGlyphs; i++)
+ {
+ nameIndex = nameIndices[i];
+ if (nameIndex < 258)
+ glyphNames[i] = STANDARD_POSTSCRIPT_GLYPH_NAMES[nameIndex];
+ else
+ glyphNames[i] = names[nameIndex - 258];
+ }
+ return;
+
+ case 0x00025000: // in case some font has a wrong representation of 2.5
+ case 0x00028000:
+ /* Format 2.5 is a re-ordering of the standard names. It has
+ * been deprecated in February 2000, but might still occasionally
+ * float around. Since it can be supported with so little code,
+ * we do so.
+ */
+ postTable.position(32);
+ numGlyphs = postTable.getChar();
+ glyphNames = new String[numGlyphs];
+ for (int i = 0; i < numGlyphs; i++)
+ glyphNames[i] = STANDARD_POSTSCRIPT_GLYPH_NAMES[i + postTable.get()];
+ return;
+
+ case 0x00030000:
+ /* Format 3 leaves it to the printer driver to choose whatever
+ * name it wants to.
+ */
+ return;
+
+ case 0x00040000:
+ /* Format 4 is used by Apple for composite fonts that have
+ * synthetic glyph names. The name of a glyph is "a" plus
+ * the integer (in decimal notation) that follows the table
+ * after numGlyphs.
+ */
+ postTable.position(32);
+ numGlyphs = postTable.getChar();
+ glyphCharacterCodes = postTable.asCharBuffer();
+ glyphCharacterCodes.limit(numGlyphs);
+ return;
+ }
+ }
+
+
+
+ /* For generating the following tables, a quick-and-dirty Python
+ * script was used. It is unlikely that we ever need to run it
+ * again, but for information and convenient access, it is included
+ * below. Initial '#' characters need to be removed from the generated
+ * strings, they are present so that the lines not break in the middle
+ * of Java escape sequences (no, this is not very clean).
+ *
+ * import string
+ *
+ * javaEscapes = {0x22:'\\"', 0x5c:'\\\\'}
+ * def escape(c):
+ * if javaEscapes.has_key(c):
+ * return javaEscapes[c]
+ * elif 0x20 <= c <= 0x7e:
+ * return chr(c)
+ * else:
+ * return '\\u%04x' % c
+ *
+ * def dump(name, s, stride):
+ * s = ('#' * stride) + s
+ * print " private static final String %s" % name
+ * for i in range(0, len(s), 60):
+ * print ' + "%s"' % s[i:i+60]
+ *
+ * glyphs = {}
+ * for line in open('aglfn13.txt', 'r').readlines():
+ * if line[0] == '#': continue
+ * [ucs, glyphName, desc] = line.split(';')
+ * glyph = int('0x' + ucs, 0)
+ * assert (not glyphs.has_key(glyph)) or (glyphs[glyph] == glyphName)
+ * glyphs[glyph] = glyphName
+ * del glyphs[0] # arrowvertex
+ * k = glyphs.keys()
+ * k.sort()
+ * numGlyphs = len(k)
+ * names = ''
+ * pos = []
+ * for glyph in k:
+ * pos.append(len(names) + 1)
+ * names = names + '/' + glyphs[glyph]
+ * dump('AGLFN_GLYPHS', string.join(map(escape, k), ''), 5)
+ * dump('AGLFN_NAME_OFFSET', string.join(map(escape, pos), ''), 4)
+ * dump('AGLFN_NAMES', names + '/', 0)
+ */
+
+
+ /**
+ * A String that contains the Unicode codepoint for each glyph
+ * in the Adobe Glyph List. The characters are in sorted order.
+ *
+ * Generated from the Adobe Glyph List for New Fonts, version 1.1
+ * of 17 April 2003.
+ *
+ * @see <a href=
+ * "http://partners.adobe.com/asn/tech/type/aglfn13.txt" >Adobe
+ * Glyph List for New Fonts</a>
+ */
+ private static final String AGLFN_GLYPHS
+ = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTU"
+ + "VWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\u00a1\u00a2\u00a3"
+ + "\u00a4\u00a5\u00a6\u00a7\u00a8\u00a9\u00aa\u00ab\u00ac\u00ae"
+ + "\u00af\u00b0\u00b1\u00b4\u00b5\u00b6\u00b7\u00b8\u00ba\u00bb"
+ + "\u00bc\u00bd\u00be\u00bf\u00c0\u00c1\u00c2\u00c3\u00c4\u00c5"
+ + "\u00c6\u00c7\u00c8\u00c9\u00ca\u00cb\u00cc\u00cd\u00ce\u00cf"
+ + "\u00d0\u00d1\u00d2\u00d3\u00d4\u00d5\u00d6\u00d7\u00d8\u00d9"
+ + "\u00da\u00db\u00dc\u00dd\u00de\u00df\u00e0\u00e1\u00e2\u00e3"
+ + "\u00e4\u00e5\u00e6\u00e7\u00e8\u00e9\u00ea\u00eb\u00ec\u00ed"
+ + "\u00ee\u00ef\u00f0\u00f1\u00f2\u00f3\u00f4\u00f5\u00f6\u00f7"
+ + "\u00f8\u00f9\u00fa\u00fb\u00fc\u00fd\u00fe\u00ff\u0100\u0101"
+ + "\u0102\u0103\u0104\u0105\u0106\u0107\u0108\u0109\u010a\u010b"
+ + "\u010c\u010d\u010e\u010f\u0110\u0111\u0112\u0113\u0114\u0115"
+ + "\u0116\u0117\u0118\u0119\u011a\u011b\u011c\u011d\u011e\u011f"
+ + "\u0120\u0121\u0122\u0123\u0124\u0125\u0126\u0127\u0128\u0129"
+ + "\u012a\u012b\u012c\u012d\u012e\u012f\u0130\u0131\u0132\u0133"
+ + "\u0134\u0135\u0136\u0137\u0138\u0139\u013a\u013b\u013c\u013d"
+ + "\u013e\u013f\u0140\u0141\u0142\u0143\u0144\u0145\u0146\u0147"
+ + "\u0148\u0149\u014a\u014b\u014c\u014d\u014e\u014f\u0150\u0151"
+ + "\u0152\u0153\u0154\u0155\u0156\u0157\u0158\u0159\u015a\u015b"
+ + "\u015c\u015d\u015e\u015f\u0160\u0161\u0162\u0163\u0164\u0165"
+ + "\u0166\u0167\u0168\u0169\u016a\u016b\u016c\u016d\u016e\u016f"
+ + "\u0170\u0171\u0172\u0173\u0174\u0175\u0176\u0177\u0178\u0179"
+ + "\u017a\u017b\u017c\u017d\u017e\u017f\u0192\u01a0\u01a1\u01af"
+ + "\u01b0\u01e6\u01e7\u01fa\u01fb\u01fc\u01fd\u01fe\u01ff\u0218"
+ + "\u0219\u02bc\u02bd\u02c6\u02c7\u02d8\u02d9\u02da\u02db\u02dc"
+ + "\u02dd\u0300\u0301\u0303\u0309\u0323\u0384\u0385\u0386\u0387"
+ + "\u0388\u0389\u038a\u038c\u038e\u038f\u0390\u0391\u0392\u0393"
+ + "\u0395\u0396\u0397\u0398\u0399\u039a\u039b\u039c\u039d\u039e"
+ + "\u039f\u03a0\u03a1\u03a3\u03a4\u03a5\u03a6\u03a7\u03a8\u03aa"
+ + "\u03ab\u03ac\u03ad\u03ae\u03af\u03b0\u03b1\u03b2\u03b3\u03b4"
+ + "\u03b5\u03b6\u03b7\u03b8\u03b9\u03ba\u03bb\u03bd\u03be\u03bf"
+ + "\u03c0\u03c1\u03c2\u03c3\u03c4\u03c5\u03c6\u03c7\u03c8\u03c9"
+ + "\u03ca\u03cb\u03cc\u03cd\u03ce\u03d1\u03d2\u03d5\u03d6\u0401"
+ + "\u0402\u0403\u0404\u0405\u0406\u0407\u0408\u0409\u040a\u040b"
+ + "\u040c\u040e\u040f\u0410\u0411\u0412\u0413\u0414\u0415\u0416"
+ + "\u0417\u0418\u0419\u041a\u041b\u041c\u041d\u041e\u041f\u0420"
+ + "\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042a"
+ + "\u042b\u042c\u042d\u042e\u042f\u0430\u0431\u0432\u0433\u0434"
+ + "\u0435\u0436\u0437\u0438\u0439\u043a\u043b\u043c\u043d\u043e"
+ + "\u043f\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448"
+ + "\u0449\u044a\u044b\u044c\u044d\u044e\u044f\u0451\u0452\u0453"
+ + "\u0454\u0455\u0456\u0457\u0458\u0459\u045a\u045b\u045c\u045e"
+ + "\u045f\u0462\u0463\u0472\u0473\u0474\u0475\u0490\u0491\u04d9"
+ + "\u05b0\u05b1\u05b2\u05b3\u05b4\u05b5\u05b6\u05b7\u05b8\u05b9"
+ + "\u05bb\u05bc\u05bd\u05be\u05bf\u05c0\u05c1\u05c2\u05c3\u05d0"
+ + "\u05d1\u05d2\u05d3\u05d4\u05d5\u05d6\u05d7\u05d8\u05d9\u05da"
+ + "\u05db\u05dc\u05dd\u05de\u05df\u05e0\u05e1\u05e2\u05e3\u05e4"
+ + "\u05e5\u05e6\u05e7\u05e8\u05e9\u05ea\u05f0\u05f1\u05f2\u060c"
+ + "\u061b\u061f\u0621\u0622\u0623\u0624\u0625\u0626\u0627\u0628"
+ + "\u0629\u062a\u062b\u062c\u062d\u062e\u062f\u0630\u0631\u0632"
+ + "\u0633\u0634\u0635\u0636\u0637\u0638\u0639\u063a\u0640\u0641"
+ + "\u0642\u0643\u0644\u0645\u0646\u0647\u0648\u0649\u064a\u064b"
+ + "\u064c\u064d\u064e\u064f\u0650\u0651\u0652\u0660\u0661\u0662"
+ + "\u0663\u0664\u0665\u0666\u0667\u0668\u0669\u066a\u066d\u0679"
+ + "\u067e\u0686\u0688\u0691\u0698\u06a4\u06af\u06ba\u06d2\u06d5"
+ + "\u1e80\u1e81\u1e82\u1e83\u1e84\u1e85\u1ef2\u1ef3\u200c\u200d"
+ + "\u200e\u200f\u2012\u2013\u2014\u2015\u2017\u2018\u2019\u201a"
+ + "\u201b\u201c\u201d\u201e\u2020\u2021\u2022\u2024\u2025\u2026"
+ + "\u202c\u202d\u202e\u2030\u2032\u2033\u2039\u203a\u203c\u2044"
+ + "\u20a1\u20a3\u20a4\u20a7\u20aa\u20ab\u20ac\u2105\u2111\u2113"
+ + "\u2116\u2118\u211c\u211e\u2122\u2126\u212e\u2135\u2153\u2154"
+ + "\u215b\u215c\u215d\u215e\u2190\u2191\u2192\u2193\u2194\u2195"
+ + "\u21a8\u21b5\u21d0\u21d1\u21d2\u21d3\u21d4\u2200\u2202\u2203"
+ + "\u2205\u2206\u2207\u2208\u2209\u220b\u220f\u2211\u2212\u2217"
+ + "\u221a\u221d\u221e\u221f\u2220\u2227\u2228\u2229\u222a\u222b"
+ + "\u2234\u223c\u2245\u2248\u2260\u2261\u2264\u2265\u2282\u2283"
+ + "\u2284\u2286\u2287\u2295\u2297\u22a5\u22c5\u2302\u2310\u2320"
+ + "\u2321\u2329\u232a\u2500\u2502\u250c\u2510\u2514\u2518\u251c"
+ + "\u2524\u252c\u2534\u253c\u2550\u2551\u2552\u2553\u2554\u2555"
+ + "\u2556\u2557\u2558\u2559\u255a\u255b\u255c\u255d\u255e\u255f"
+ + "\u2560\u2561\u2562\u2563\u2564\u2565\u2566\u2567\u2568\u2569"
+ + "\u256a\u256b\u256c\u2580\u2584\u2588\u258c\u2590\u2591\u2592"
+ + "\u2593\u25a0\u25a1\u25aa\u25ab\u25ac\u25b2\u25ba\u25bc\u25c4"
+ + "\u25ca\u25cb\u25cf\u25d8\u25d9\u25e6\u263a\u263b\u263c\u2640"
+ + "\u2642\u2660\u2663\u2665\u2666\u266a\u266b";
+
+
+ /**
+ * The offset of each glyph name in AGLFN_NAMES.
+ *
+ * Generated from the Adobe Glyph List for New Fonts, version 1.1
+ * of 17 April 2003.
+ *
+ * @see <a href=
+ * "http://partners.adobe.com/asn/tech/type/aglfn13.txt" >Adobe
+ * Glyph List for New Fonts</a>
+ */
+ private static final String AGLFN_NAME_OFFSET
+ = "\u0001\u0007\u000e\u0017\")1;GQ\\ejpw~\u0084\u0089\u008d"
+ + "\u0091\u0097\u009c\u00a1\u00a5\u00ab\u00b1\u00b6\u00bc\u00c6"
+ + "\u00cb\u00d1\u00d9\u00e2\u00e5\u00e7\u00e9\u00eb\u00ed\u00ef"
+ + "\u00f1\u00f3\u00f5\u00f7\u00f9\u00fb\u00fd\u00ff\u0101\u0103"
+ + "\u0105\u0107\u0109\u010b\u010d\u010f\u0111\u0113\u0115\u0117"
+ + "\u0119\u0125\u012f\u013c\u0148\u0153\u0159\u015b\u015d\u015f"
+ + "\u0161\u0163\u0165\u0167\u0169\u016b\u016d\u016f\u0171\u0173"
+ + "\u0175\u0177\u0179\u017b\u017d\u017f\u0181\u0183\u0185\u0187"
+ + "\u0189\u018b\u018d\u0197\u019b\u01a6\u01b1\u01bc\u01c1\u01ca"
+ + "\u01d3\u01d7\u01e1\u01e9\u01f2\u01fc\u0208\u0216\u0221\u022c"
+ + "\u0233\u023a\u0244\u024a\u024d\u0257\u0266\u026e\u027b\u028a"
+ + "\u0295\u029d\u02ab\u02b8\u02bf\u02c6\u02d2\u02d9\u02e3\u02e9"
+ + "\u02ec\u02f5\u02fc\u0303\u030f\u0319\u0320\u0327\u0333\u033d"
+ + "\u0341\u0348\u034f\u0356\u0362\u0369\u0373\u037c\u0383\u038a"
+ + "\u0391\u039d\u03a7\u03ae\u03b4\u03bf\u03c6\u03cd\u03d9\u03e0"
+ + "\u03ea\u03f0\u03f3\u03fc\u0403\u040a\u0416\u0420\u0427\u042e"
+ + "\u043a\u0444\u0448\u044f\u0456\u045d\u0469\u0470\u047a\u0481"
+ + "\u0488\u048f\u0496\u04a2\u04ac\u04b3\u04b9\u04c3\u04cb\u04d3"
+ + "\u04da\u04e1\u04e9\u04f1\u04f8\u04ff\u050b\u0517\u0522\u052d"
+ + "\u0534\u053b\u0542\u0549\u0550\u0557\u055f\u0567\u056e\u0575"
+ + "\u0580\u058b\u0593\u059b\u05a2\u05a9\u05b5\u05c1\u05c8\u05cf"
+ + "\u05da\u05e5\u05f2\u05ff\u060b\u0617\u061c\u0621\u0628\u062f"
+ + "\u0637\u063f\u0646\u064d\u0655\u065d\u0668\u0671\u0674\u0677"
+ + "\u0683\u068f\u069c\u06a9\u06b6\u06bd\u06c4\u06d1\u06de\u06e5"
+ + "\u06ec\u06f1\u06f6\u06fd\u0704\u070b\u0712\u071f\u072c\u0733"
+ + "\u073a\u0746\u074a\u074e\u0756\u075e\u0765\u076c\u077a\u0788"
+ + "\u078b\u078e\u0795\u079c\u07a9\u07b6\u07bd\u07c4\u07cb\u07d2"
+ + "\u07de\u07ea\u07f3\u07fc\u0803\u080a\u0817\u0824\u082b\u0832"
+ + "\u0837\u083c\u0843\u084a\u0852\u085a\u0861\u0868\u086e\u0874"
+ + "\u0882\u0890\u0898\u08a0\u08ac\u08b8\u08c4\u08d0\u08da\u08e1"
+ + "\u08e8\u08f3\u08fe\u0905\u090c\u0912\u0919\u091f\u0925\u092b"
+ + "\u0931\u0938\u093f\u094a\u0955\u095d\u0965\u0971\u097d\u098a"
+ + "\u0997\u09a1\u09ab\u09b6\u09bc\u09c2\u09cc\u09d1\u09d8\u09de"
+ + "\u09eb\u09f5\u09ff\u0a09\u0a17\u0a24\u0a2a\u0a38\u0a43\u0a4d"
+ + "\u0a5a\u0a63\u0a6d\u0a7a\u0a87\u0a92\u0aa4\u0aaa\u0aaf\u0ab5"
+ + "\u0abd\u0ac2\u0ac6\u0acc\u0ad1\u0ad7\u0ade\u0ae1\u0ae4\u0ae7"
+ + "\u0aef\u0af2\u0af6\u0afc\u0b00\u0b08\u0b0c\u0b10\u0b14\u0b21"
+ + "\u0b31\u0b3c\u0b49\u0b52\u0b5c\u0b71\u0b77\u0b7c\u0b82\u0b88"
+ + "\u0b90\u0b95\u0b99\u0b9f\u0ba4\u0baa\u0bb1\u0bb4\u0bb7\u0bbf"
+ + "\u0bc2\u0bc6\u0bcd\u0bd3\u0bd7\u0bdf\u0be3\u0be7\u0beb\u0bf1"
+ + "\u0bfe\u0c0e\u0c1b\u0c28\u0c33\u0c3a\u0c43\u0c48\u0c4f\u0c59"
+ + "\u0c63\u0c6d\u0c77\u0c81\u0c8b\u0c95\u0c9f\u0ca9\u0cb3\u0cbd"
+ + "\u0cc7\u0cd1\u0cdb\u0ce5\u0cef\u0cf9\u0d03\u0d0d\u0d17\u0d21"
+ + "\u0d2b\u0d35\u0d3f\u0d49\u0d53\u0d5d\u0d67\u0d71\u0d7b\u0d85"
+ + "\u0d8f\u0d99\u0da3\u0dad\u0db7\u0dc1\u0dcb\u0dd5\u0ddf\u0de9"
+ + "\u0df3\u0dfd\u0e07\u0e11\u0e1b\u0e25\u0e2f\u0e39\u0e43\u0e4d"
+ + "\u0e57\u0e61\u0e6b\u0e75\u0e7f\u0e89\u0e93\u0e9d\u0ea7\u0eb1"
+ + "\u0ebb\u0ec5\u0ecf\u0ed9\u0ee3\u0eed\u0ef7\u0f01\u0f0b\u0f15"
+ + "\u0f1f\u0f29\u0f33\u0f3d\u0f47\u0f51\u0f5b\u0f65\u0f6f\u0f79"
+ + "\u0f83\u0f8d\u0f97\u0fa1\u0fab\u0fb5\u0fbf\u0fc9\u0fd3\u0fdd"
+ + "\u0fe7\u0ff1\u0ffb\u1005\u100f\u1019\u1023\u102d\u1037\u1041"
+ + "\u104b\u1055\u105f\u1069\u1073\u107d\u1087\u1091\u109b\u10a5"
+ + "\u10af\u10b9\u10c3\u10cd\u10d7\u10e1\u10eb\u10f5\u10ff\u1109"
+ + "\u1113\u111d\u1127\u1131\u113b\u1145\u114f\u1159\u1163\u116d"
+ + "\u1177\u1181\u118b\u1195\u119f\u11a9\u11b3\u11bd\u11c7\u11d1"
+ + "\u11db\u11e5\u11ef\u11f9\u1203\u120d\u1217\u1221\u122b\u1235"
+ + "\u123f\u1249\u1253\u125d\u1267\u1271\u127b\u1285\u128f\u1299"
+ + "\u12a3\u12ad\u12b7\u12c1\u12cb\u12d5\u12df\u12e9\u12f3\u12fd"
+ + "\u1307\u1311\u131b\u1325\u132f\u1339\u1343\u134d\u1357\u1361"
+ + "\u136b\u1375\u137f\u1389\u1393\u139d\u13a7\u13b1\u13bb\u13c5"
+ + "\u13cf\u13d9\u13e3\u13ed\u13f7\u1401\u140b\u1415\u141f\u1429"
+ + "\u1433\u143d\u1447\u1451\u145b\u1465\u146f\u1479\u1483\u148d"
+ + "\u1497\u14a1\u14ab\u14b5\u14bf\u14c9\u14d3\u14dd\u14e7\u14f1"
+ + "\u14f8\u14ff\u1506\u150d\u1517\u1521\u1528\u152f\u1539\u1541"
+ + "\u1549\u1551\u155c\u1563\u156a\u1574\u1582\u158c\u1597\u15a6"
+ + "\u15b4\u15c1\u15cf\u15dc\u15e3\u15ed\u15f4\u1603\u1612\u161b"
+ + "\u1625\u162f\u1639\u1645\u164c\u1653\u1661\u1670\u167a\u1683"
+ + "\u1691\u1697\u169c\u16a3\u16ad\u16b2\u16b7\u16c1\u16ca\u16d4"
+ + "\u16de\u16ea\u16f3\u1700\u170a\u1710\u171a\u1720\u1729\u1733"
+ + "\u173d\u174a\u1756\u1763\u176d\u1775\u1780\u178a\u1794\u179e"
+ + "\u17ab\u17ba\u17c7\u17d2\u17e0\u17ed\u17fa\u1804\u1810\u181c"
+ + "\u1825\u182b\u1834\u183c\u1847\u1850\u1858\u1862\u1868\u1875"
+ + "\u187d\u188a\u1893\u189e\u18a4\u18af\u18b9\u18c6\u18cc\u18d5"
+ + "\u18df\u18e7\u18f1\u18fd\u1906\u1912\u191c\u1929\u1936\u1945"
+ + "\u194f\u195c\u196b\u1976\u1985\u1993\u199b\u19a1\u19af\u19ba"
+ + "\u19c5\u19cf\u19da\u19e3\u19ec\u19f5\u19fe\u1a07\u1a10\u1a19"
+ + "\u1a22\u1a2b\u1a34\u1a3d\u1a46\u1a4f\u1a58\u1a61\u1a6a\u1a73"
+ + "\u1a7c\u1a85\u1a8e\u1a97\u1aa0\u1aa9\u1ab2\u1abb\u1ac4\u1acd"
+ + "\u1ad6\u1adf\u1ae8\u1af1\u1afa\u1b03\u1b0c\u1b15\u1b1e\u1b27"
+ + "\u1b30\u1b39\u1b42\u1b4a\u1b52\u1b58\u1b60\u1b68\u1b70\u1b76"
+ + "\u1b7e\u1b88\u1b8f\u1b96\u1b9d\u1ba8\u1bb0\u1bb8\u1bc0\u1bc8"
+ + "\u1bd0\u1bd7\u1bde\u1be8\u1bf2\u1bfd\u1c07\u1c14\u1c18\u1c1f"
+ + "\u1c24\u1c2a\u1c2f\u1c35\u1c3d\u1c49";
+
+
+ /**
+ * The name of each glyph in the Adobe Glyph List for New Fonts
+ * (AGLFN). The name of the n-th glyph starts at position
+ * AGLFN_NAME_OFFSET.charAt(n). It ends before the following
+ * slash (slashes cannot be part of a PostScript name, which
+ * is why we use it for separation).
+ *
+ * <p>Generated from the Adobe Glyph List for New Fonts, version 1.1
+ * of 17 April 2003.
+ *
+ * @see <a href=
+ * "http://partners.adobe.com/asn/tech/type/aglfn13.txt" >Adobe
+ * Glyph List for New Fonts</a>
+ */
+ private static final String AGLFN_NAMES
+ = "/space/exclam/quotedbl/numbersign/dollar/percent/ampersand/q"
+ + "uotesingle/parenleft/parenright/asterisk/plus/comma/hyphen/p"
+ + "eriod/slash/zero/one/two/three/four/five/six/seven/eight/nin"
+ + "e/colon/semicolon/less/equal/greater/question/at/A/B/C/D/E/F"
+ + "/G/H/I/J/K/L/M/N/O/P/Q/R/S/T/U/V/W/X/Y/Z/bracketleft/backsla"
+ + "sh/bracketright/asciicircum/underscore/grave/a/b/c/d/e/f/g/h"
+ + "/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z/braceleft/bar/bracerigh"
+ + "t/asciitilde/exclamdown/cent/sterling/currency/yen/brokenbar"
+ + "/section/dieresis/copyright/ordfeminine/guillemotleft/logica"
+ + "lnot/registered/macron/degree/plusminus/acute/mu/paragraph/p"
+ + "eriodcentered/cedilla/ordmasculine/guillemotright/onequarter"
+ + "/onehalf/threequarters/questiondown/Agrave/Aacute/Acircumfle"
+ + "x/Atilde/Adieresis/Aring/AE/Ccedilla/Egrave/Eacute/Ecircumfl"
+ + "ex/Edieresis/Igrave/Iacute/Icircumflex/Idieresis/Eth/Ntilde/"
+ + "Ograve/Oacute/Ocircumflex/Otilde/Odieresis/multiply/Oslash/U"
+ + "grave/Uacute/Ucircumflex/Udieresis/Yacute/Thorn/germandbls/a"
+ + "grave/aacute/acircumflex/atilde/adieresis/aring/ae/ccedilla/"
+ + "egrave/eacute/ecircumflex/edieresis/igrave/iacute/icircumfle"
+ + "x/idieresis/eth/ntilde/ograve/oacute/ocircumflex/otilde/odie"
+ + "resis/divide/oslash/ugrave/uacute/ucircumflex/udieresis/yacu"
+ + "te/thorn/ydieresis/Amacron/amacron/Abreve/abreve/Aogonek/aog"
+ + "onek/Cacute/cacute/Ccircumflex/ccircumflex/Cdotaccent/cdotac"
+ + "cent/Ccaron/ccaron/Dcaron/dcaron/Dcroat/dcroat/Emacron/emacr"
+ + "on/Ebreve/ebreve/Edotaccent/edotaccent/Eogonek/eogonek/Ecaro"
+ + "n/ecaron/Gcircumflex/gcircumflex/Gbreve/gbreve/Gdotaccent/gd"
+ + "otaccent/Gcommaaccent/gcommaaccent/Hcircumflex/hcircumflex/H"
+ + "bar/hbar/Itilde/itilde/Imacron/imacron/Ibreve/ibreve/Iogonek"
+ + "/iogonek/Idotaccent/dotlessi/IJ/ij/Jcircumflex/jcircumflex/K"
+ + "commaaccent/kcommaaccent/kgreenlandic/Lacute/lacute/Lcommaac"
+ + "cent/lcommaaccent/Lcaron/lcaron/Ldot/ldot/Lslash/lslash/Nacu"
+ + "te/nacute/Ncommaaccent/ncommaaccent/Ncaron/ncaron/napostroph"
+ + "e/Eng/eng/Omacron/omacron/Obreve/obreve/Ohungarumlaut/ohunga"
+ + "rumlaut/OE/oe/Racute/racute/Rcommaaccent/rcommaaccent/Rcaron"
+ + "/rcaron/Sacute/sacute/Scircumflex/scircumflex/Scedilla/scedi"
+ + "lla/Scaron/scaron/Tcommaaccent/tcommaaccent/Tcaron/tcaron/Tb"
+ + "ar/tbar/Utilde/utilde/Umacron/umacron/Ubreve/ubreve/Uring/ur"
+ + "ing/Uhungarumlaut/uhungarumlaut/Uogonek/uogonek/Wcircumflex/"
+ + "wcircumflex/Ycircumflex/ycircumflex/Ydieresis/Zacute/zacute/"
+ + "Zdotaccent/zdotaccent/Zcaron/zcaron/longs/florin/Ohorn/ohorn"
+ + "/Uhorn/uhorn/Gcaron/gcaron/Aringacute/aringacute/AEacute/aea"
+ + "cute/Oslashacute/oslashacute/Scommaaccent/scommaaccent/afii5"
+ + "7929/afii64937/circumflex/caron/breve/dotaccent/ring/ogonek/"
+ + "tilde/hungarumlaut/gravecomb/acutecomb/tildecomb/hookaboveco"
+ + "mb/dotbelowcomb/tonos/dieresistonos/Alphatonos/anoteleia/Eps"
+ + "ilontonos/Etatonos/Iotatonos/Omicrontonos/Upsilontonos/Omega"
+ + "tonos/iotadieresistonos/Alpha/Beta/Gamma/Epsilon/Zeta/Eta/Th"
+ + "eta/Iota/Kappa/Lambda/Mu/Nu/Xi/Omicron/Pi/Rho/Sigma/Tau/Upsi"
+ + "lon/Phi/Chi/Psi/Iotadieresis/Upsilondieresis/alphatonos/epsi"
+ + "lontonos/etatonos/iotatonos/upsilondieresistonos/alpha/beta/"
+ + "gamma/delta/epsilon/zeta/eta/theta/iota/kappa/lambda/nu/xi/o"
+ + "micron/pi/rho/sigma1/sigma/tau/upsilon/phi/chi/psi/omega/iot"
+ + "adieresis/upsilondieresis/omicrontonos/upsilontonos/omegaton"
+ + "os/theta1/Upsilon1/phi1/omega1/afii10023/afii10051/afii10052"
+ + "/afii10053/afii10054/afii10055/afii10056/afii10057/afii10058"
+ + "/afii10059/afii10060/afii10061/afii10062/afii10145/afii10017"
+ + "/afii10018/afii10019/afii10020/afii10021/afii10022/afii10024"
+ + "/afii10025/afii10026/afii10027/afii10028/afii10029/afii10030"
+ + "/afii10031/afii10032/afii10033/afii10034/afii10035/afii10036"
+ + "/afii10037/afii10038/afii10039/afii10040/afii10041/afii10042"
+ + "/afii10043/afii10044/afii10045/afii10046/afii10047/afii10048"
+ + "/afii10049/afii10065/afii10066/afii10067/afii10068/afii10069"
+ + "/afii10070/afii10072/afii10073/afii10074/afii10075/afii10076"
+ + "/afii10077/afii10078/afii10079/afii10080/afii10081/afii10082"
+ + "/afii10083/afii10084/afii10085/afii10086/afii10087/afii10088"
+ + "/afii10089/afii10090/afii10091/afii10092/afii10093/afii10094"
+ + "/afii10095/afii10096/afii10097/afii10071/afii10099/afii10100"
+ + "/afii10101/afii10102/afii10103/afii10104/afii10105/afii10106"
+ + "/afii10107/afii10108/afii10109/afii10110/afii10193/afii10146"
+ + "/afii10194/afii10147/afii10195/afii10148/afii10196/afii10050"
+ + "/afii10098/afii10846/afii57799/afii57801/afii57800/afii57802"
+ + "/afii57793/afii57794/afii57795/afii57798/afii57797/afii57806"
+ + "/afii57796/afii57807/afii57839/afii57645/afii57841/afii57842"
+ + "/afii57804/afii57803/afii57658/afii57664/afii57665/afii57666"
+ + "/afii57667/afii57668/afii57669/afii57670/afii57671/afii57672"
+ + "/afii57673/afii57674/afii57675/afii57676/afii57677/afii57678"
+ + "/afii57679/afii57680/afii57681/afii57682/afii57683/afii57684"
+ + "/afii57685/afii57686/afii57687/afii57688/afii57689/afii57690"
+ + "/afii57716/afii57717/afii57718/afii57388/afii57403/afii57407"
+ + "/afii57409/afii57410/afii57411/afii57412/afii57413/afii57414"
+ + "/afii57415/afii57416/afii57417/afii57418/afii57419/afii57420"
+ + "/afii57421/afii57422/afii57423/afii57424/afii57425/afii57426"
+ + "/afii57427/afii57428/afii57429/afii57430/afii57431/afii57432"
+ + "/afii57433/afii57434/afii57440/afii57441/afii57442/afii57443"
+ + "/afii57444/afii57445/afii57446/afii57470/afii57448/afii57449"
+ + "/afii57450/afii57451/afii57452/afii57453/afii57454/afii57455"
+ + "/afii57456/afii57457/afii57458/afii57392/afii57393/afii57394"
+ + "/afii57395/afii57396/afii57397/afii57398/afii57399/afii57400"
+ + "/afii57401/afii57381/afii63167/afii57511/afii57506/afii57507"
+ + "/afii57512/afii57513/afii57508/afii57505/afii57509/afii57514"
+ + "/afii57519/afii57534/Wgrave/wgrave/Wacute/wacute/Wdieresis/w"
+ + "dieresis/Ygrave/ygrave/afii61664/afii301/afii299/afii300/fig"
+ + "uredash/endash/emdash/afii00208/underscoredbl/quoteleft/quot"
+ + "eright/quotesinglbase/quotereversed/quotedblleft/quotedblrig"
+ + "ht/quotedblbase/dagger/daggerdbl/bullet/onedotenleader/twodo"
+ + "tenleader/ellipsis/afii61573/afii61574/afii61575/perthousand"
+ + "/minute/second/guilsinglleft/guilsinglright/exclamdbl/fracti"
+ + "on/colonmonetary/franc/lira/peseta/afii57636/dong/Euro/afii6"
+ + "1248/Ifraktur/afii61289/afii61352/weierstrass/Rfraktur/presc"
+ + "ription/trademark/Omega/estimated/aleph/onethird/twothirds/o"
+ + "neeighth/threeeighths/fiveeighths/seveneighths/arrowleft/arr"
+ + "owup/arrowright/arrowdown/arrowboth/arrowupdn/arrowupdnbse/c"
+ + "arriagereturn/arrowdblleft/arrowdblup/arrowdblright/arrowdbl"
+ + "down/arrowdblboth/universal/partialdiff/existential/emptyset"
+ + "/Delta/gradient/element/notelement/suchthat/product/summatio"
+ + "n/minus/asteriskmath/radical/proportional/infinity/orthogona"
+ + "l/angle/logicaland/logicalor/intersection/union/integral/the"
+ + "refore/similar/congruent/approxequal/notequal/equivalence/le"
+ + "ssequal/greaterequal/propersubset/propersuperset/notsubset/r"
+ + "eflexsubset/reflexsuperset/circleplus/circlemultiply/perpend"
+ + "icular/dotmath/house/revlogicalnot/integraltp/integralbt/ang"
+ + "leleft/angleright/SF100000/SF110000/SF010000/SF030000/SF0200"
+ + "00/SF040000/SF080000/SF090000/SF060000/SF070000/SF050000/SF4"
+ + "30000/SF240000/SF510000/SF520000/SF390000/SF220000/SF210000/"
+ + "SF250000/SF500000/SF490000/SF380000/SF280000/SF270000/SF2600"
+ + "00/SF360000/SF370000/SF420000/SF190000/SF200000/SF230000/SF4"
+ + "70000/SF480000/SF410000/SF450000/SF460000/SF400000/SF540000/"
+ + "SF530000/SF440000/upblock/dnblock/block/lfblock/rtblock/ltsh"
+ + "ade/shade/dkshade/filledbox/H22073/H18543/H18551/filledrect/"
+ + "triagup/triagrt/triagdn/triaglf/lozenge/circle/H18533/invbul"
+ + "let/invcircle/openbullet/smileface/invsmileface/sun/female/m"
+ + "ale/spade/club/heart/diamond/musicalnote/musicalnotedbl/";
+
+
+ /**
+ * Determines the name of a glyph according to the Adobe Glyph List
+ * for New Fonts (AGLFN). Because all glyphs in AGLFN correspond to
+ * a precomposed Unicode codepoint, the mismatch between characters
+ * and glyphs is not an issue here.
+ *
+ * @param c the Unicode codepoint that corresponds to the glyph, for
+ * example <code>0x010a</code> for <code>LATIN CAPITAL LETTER C WITH
+ * DOT ABOVE</code>.
+ *
+ * @return the glyph name, for example <code>Cdotaccent</code>. If
+ * the glyph is not in the <i>Adobe Glyph List for New Fonts</i>,
+ * <code>null</code> is returned.
+ *
+ * @see <a href=
+ * "http://partners.adobe.com/asn/tech/type/aglfn13.txt" >Adobe
+ * Glyph List for New Fonts (AGLFN), version 1.1 of April 17,
+ * 2003</a>
+ *
+ * @see <a href=
+ * "http://partners.adobe.com/asn/developer/type/unicodegn.html#6"
+ * >Adobe&#x2019;s guidelines related to Unicode</a>
+ */
+ private static String getAGLFNName(char c)
+ {
+ int min, max, mid;
+ char midChar;
+
+ /* Performs a binary search in the sorted array (actually, a
+ * String) of glyphs in the Adobe Glyph List for New Fonts.
+ *
+ * A good compiler might be able to optimize a call to charAt for
+ * a static final String, but this routine is probably not that
+ * critical to performance.
+ */
+ min = 0;
+ max = AGLFN_GLYPHS.length() - 1;
+ mid = max >> 1;
+ midChar = AGLFN_GLYPHS.charAt(mid);
+ do
+ {
+ if (midChar == c)
+ break;
+ else if (midChar < c)
+ min = mid + 1;
+ else
+ max = mid;
+ mid = (min + max) >> 1;
+ midChar = AGLFN_GLYPHS.charAt(mid);
+ }
+ while (min < max);
+
+ if (midChar != c)
+ return null;
+
+ int pos = AGLFN_NAME_OFFSET.charAt(mid);
+ return AGLFN_NAMES.substring(pos, AGLFN_NAMES.indexOf('/', pos));
+ }
+
+
+ /**
+ * Returns the PostScript name of a glyph, given the sequence of
+ * Unicode characters that is required to produce the glyph. The
+ * returned name follows Adobe&#x2019;s glyph naming recommendations
+ * in order to allow searching and indexing of the produced
+ * PostScript and PDF.
+ *
+ * <p>Some examples:
+ * <ul><li><code>U+0041</code> gives <code>A</code>;</li>
+ * <li><code>U+011D</code> gives <code>gcircumflex</code>;</li>
+ * <li><code>U+007A U+0302</code> gives <code>z_uni0302</code>;</li>
+ * <li><code>U+D807 U+DC42</code> (an UTF-16 escape sequence)
+ * gives <code>u11C42</code>;</li>
+ * </ul>.
+ *
+ * <p>The routine does <i>not</i> bring sequences in any canonical
+ * form. Therefore, the result for <code>U+0067 U+0302</code> (the
+ * decomposition of <code>U+011D</code>) will be
+ * <code>g_uni0302</code>, not <code>gcircumflex</code>.
+ *
+ * @see <a href=
+ * "http://partners.adobe.com/asn/tech/type/unicodegn.jsp" >Unicode
+ * and Glyph Names</a> and <a href=
+ * "http://partners.adobe.com/asn/tech/type/glyphnamelimits.jsp"
+ * >Glyph Names and Current Implementations</a>
+ */
+ private static String getGlyphName(char[] chars)
+ {
+ char c;
+ String name;
+ int numChars;
+ boolean hasSurrogates = false;
+
+ if ((chars == null) || ((numChars = chars.length) == 0))
+ return ".notdef";
+
+ /* The vast majority of cases will be just a single character.
+ * Therefore, we have a special code path for this case.
+ */
+ if (numChars == 1)
+ {
+ c = chars[0];
+ name = getAGLFNName(c);
+ if (name != null)
+ return name;
+ }
+
+ CPStringBuilder buf = new CPStringBuilder(numChars * 8);
+ for (int i = 0; i < numChars; i++)
+ {
+ if (i > 0)
+ buf.append('_');
+ c = chars[i];
+
+ /* handle surrogate pairs */
+ if (c >> 10 == 0x36) // U+D800 .. U+DBFF: High surrogate
+ {
+ /* Adobe recommends using the 'u' prefix only for
+ * characters outside the Unicode Basic Multilingual Plane,
+ * because Acrobat 4 and 5 understand only the "uni" prefix.
+ * The 'u' prefix will be supported by Acrobat 6 and later.
+ *
+ * For further information, please refer to this page:
+ * http://partners.adobe.com/asn/tech/type/glyphnamelimits.jsp#3
+ */
+ int ucs4 = (((c & 0x3ff) << 10) | (chars[++i] & 0x3ff)) + 0x10000;
+ buf.append('u');
+ buf.append(Integer.toHexString(ucs4).toUpperCase());
+ }
+ else
+ {
+ /* Try the Adobe Glyph List. */
+ name = getAGLFNName(c);
+ if (name != null)
+ buf.append(name);
+ else
+ {
+ char nibble;
+ buf.append("uni");
+ nibble = (char) (((c >> 12) & 0xf) + 0x30);
+ if (nibble > 0x39)
+ nibble += 7;
+ buf.append(nibble);
+ nibble = (char) (((c >> 8) & 0xf) + 0x30);
+ if (nibble > 0x39)
+ nibble += 7;
+ buf.append(nibble);
+ nibble = (char) (((c >> 4) & 0xf) + 0x30);
+ if (nibble > 0x39)
+ nibble += 7;
+ buf.append(nibble);
+ nibble = (char) (((c >> 0) & 0xf) + 0x30);
+ if (nibble > 0x39)
+ nibble += 7;
+ buf.append(nibble);
+ }
+ }
+ }
+ return buf.toString();
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/opentype/Hinter.java b/libjava/classpath/gnu/java/awt/font/opentype/Hinter.java
new file mode 100644
index 000000000..9758a2896
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/opentype/Hinter.java
@@ -0,0 +1,63 @@
+/* Hinter.java -- The interface to a hinting implementation
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.font.opentype;
+
+import gnu.java.awt.font.opentype.truetype.Zone;
+
+/**
+ * The interface to a hinting implementation.
+ */
+public interface Hinter
+{
+ /**
+ * Initializes the hinter.
+ *
+ * @param face the font for which the hinter should be used
+ */
+ void init(OpenTypeFont face);
+
+ /**
+ * Hints the specified outline.
+ *
+ * @param outline the outline to hint
+ */
+ void applyHints(Zone outline);
+
+ void setFlags(int flags);
+}
diff --git a/libjava/classpath/gnu/java/awt/font/opentype/MacResourceFork.java b/libjava/classpath/gnu/java/awt/font/opentype/MacResourceFork.java
new file mode 100644
index 000000000..c0f3de80e
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/opentype/MacResourceFork.java
@@ -0,0 +1,235 @@
+/* MacResourceFork.java -- Parses MacOS resource forks.
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.font.opentype;
+
+import java.nio.ByteBuffer;
+
+
+/**
+ * A class for accessing data that is stored in the resource fork of
+ * Macintosh files. Writing resource forks is currently not supported.
+ *
+ * <p>The gnu.java.awt.font package uses this class for accessing
+ * fonts in the MacOS X ".dfont" format, which is is a file in the
+ * format of a Macintosh resource fork, but stored in the normal data
+ * fork of the file.
+ *
+ * <p>The implementation has been designed to work efficiently with
+ * the virtual memory subsystem. It is recommended to pass an
+ * instance of {@link java.nio.MappedByteBuffer} to the constructor.
+ *
+ * <p>Thread Safety: All access is synchronized on the ByteBuffer
+ * that is passed to the constructor.
+ *
+ * @see <a href=
+ * "http://developer.apple.com/documentation/mac/MoreToolbox/MoreToolbox-99.html"
+ * >Apple&#x2019; developer documentation about the Resource File
+ * Format</a>
+ *
+ * @author Sascha Brawer (brawer@dandelis.ch)
+ */
+final class MacResourceFork
+{
+ int[] types;
+ Resource[][] resources;
+ ByteBuffer buf;
+
+ public MacResourceFork(ByteBuffer buf)
+ {
+ int typeListOffset;
+ int refListOffset;
+ int nameListOffset;
+ int mapOffset, mapLen;
+ int dataOffset, dataLen;
+ int numTypes;
+
+ synchronized (buf)
+ {
+ buf = buf.duplicate();
+ this.buf = buf;
+ buf.position(0);
+ dataOffset = buf.getInt();
+ mapOffset = buf.getInt();
+ dataLen = buf.getInt();
+ mapLen = buf.getInt();
+ buf.position(mapOffset + 24);
+ refListOffset = mapOffset + buf.getChar();
+ nameListOffset = mapOffset + buf.getChar();
+ numTypes = buf.getChar() + 1;
+ types = new int[numTypes];
+ resources = new Resource[numTypes][];
+
+ /* Parse resource type list. */
+ typeListOffset = buf.position();
+ for (int i = 0; i < numTypes; i++)
+ {
+ buf.position(typeListOffset + 8 * i);
+ int resType = buf.getInt();
+ int numRes = buf.getChar() + 1;
+
+ types[i] = resType;
+ resources[i] = new Resource[numRes];
+
+ buf.position(refListOffset + buf.getChar());
+ for (int j = 0; j < numRes; j++)
+ {
+ short resID = buf.getShort();
+ int resNameOffset = nameListOffset + buf.getChar();
+ int resDataOffset = buf.getInt();
+ byte resAttr = (byte) (resDataOffset >> 24);
+ resDataOffset = dataOffset + (resDataOffset & 0x00ffffff);
+ buf.getInt(); /* skip four reserved bytes */
+
+ Resource rsrc = new Resource(buf, resType, resID, resDataOffset,
+ resNameOffset);
+ resources[i][j] = rsrc;
+ }
+ }
+ }
+ }
+
+
+ public Resource[] getResources(int type)
+ {
+ synchronized (buf)
+ {
+ for (int i = 0; i < types.length; i++)
+ {
+ if (types[i] == type)
+ return resources[i];
+ }
+ }
+ return null;
+ }
+
+
+ public Resource getResource(int type, short id)
+ {
+ Resource[] res;
+
+ synchronized (buf)
+ {
+ for (int i = 0; i < types.length; i++)
+ {
+ if (types[i] != type)
+ continue;
+
+ res = resources[i];
+ for (int j = 0; j < res.length; j++)
+ if (res[j].getID() == id)
+ return res[j];
+ }
+ }
+
+ return null;
+ }
+
+
+ /**
+ * A single resource that is contained in a resource fork.
+ */
+ public static final class Resource
+ {
+ int type;
+ short id;
+ byte attribute;
+ int nameOffset;
+ int dataOffset;
+ ByteBuffer buf;
+
+ private Resource(ByteBuffer buf,
+ int type, short id, int dataOffset, int nameOffset)
+ {
+ this.buf = buf;
+ this.type = type;
+ this.id = id;
+ this.dataOffset = dataOffset;
+ this.nameOffset = nameOffset;
+ }
+
+
+ /**
+ * Returns the type of this resource.
+ *
+ * @return an <code>int</code> encoding a four-byte type tag,
+ * such as <code>0x464f4e54</code> for <code>'FONT'</code>.
+ */
+ public int getType()
+ {
+ return type;
+ }
+
+
+ /**
+ * Returns the ID of this resource.
+ */
+ public short getID()
+ {
+ return id;
+ }
+
+
+ /**
+ * Retrieves the content of the resource. Only one page of memory
+ * is touched, irrespective of the actual size of the resource.
+ */
+ public ByteBuffer getContent()
+ {
+ synchronized (buf)
+ {
+ buf.limit(buf.capacity());
+ int len = buf.getInt(dataOffset);
+ buf.position(dataOffset + 4).limit(dataOffset + 4 + len);
+ return buf.slice();
+ }
+ }
+
+
+ /**
+ * Determines the length of the resource in bytes.
+ */
+ public int getLength()
+ {
+ synchronized (buf)
+ {
+ return buf.getInt(dataOffset);
+ }
+ }
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/opentype/NameDecoder.java b/libjava/classpath/gnu/java/awt/font/opentype/NameDecoder.java
new file mode 100644
index 000000000..1f1d50ac1
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/opentype/NameDecoder.java
@@ -0,0 +1,702 @@
+/* NameDecoder.java -- Decodes names of OpenType and TrueType fonts.
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.awt.font.opentype;
+
+import java.io.UnsupportedEncodingException;
+import java.nio.ByteBuffer;
+import java.util.Locale;
+
+
+/**
+ * A utility class that helps with decoding the names of OpenType
+ * and TrueType fonts.
+ *
+ * @author Sascha Brawer (brawer@dandelis.ch)
+ */
+public class NameDecoder
+{
+ public static final int NAME_COPYRIGHT = 0;
+
+
+ /**
+ * Specifies the name of the family to which a font belongs, for
+ * example &#x201c;Univers&#x201d;.
+ */
+ public static final int NAME_FAMILY = 1;
+
+
+ /**
+ * Specified the name of the font inside its family, for
+ * example &#x201c;Light&#x201d;.
+ */
+ public static final int NAME_SUBFAMILY = 2;
+
+
+ public static final int NAME_UNIQUE = 3;
+
+
+ /**
+ * Specifies the full human-readable name of a font, for example
+ * &#x201c;Univers Light&#x201d;
+ */
+ public static final int NAME_FULL = 4;
+
+
+ public static final int NAME_VERSION = 5;
+
+
+ /**
+ * Specifies the PostScript name of a font, for example
+ * &#x201c;Univers-Light&#x201d;.
+ */
+ public static final int NAME_POSTSCRIPT = 6;
+
+
+ public static final int NAME_TRADEMARK = 7;
+ public static final int NAME_MANUFACTURER = 8;
+ public static final int NAME_DESIGNER = 9;
+ public static final int NAME_DESCRIPTION = 10;
+ public static final int NAME_VENDOR_URL = 11;
+ public static final int NAME_DESIGNER_URL = 12;
+ public static final int NAME_LICENSE = 13;
+ public static final int NAME_LICENSE_URL = 14;
+ public static final int NAME_PREFERRED_FAMILY = 16;
+ public static final int NAME_PREFERRED_SUBFAMILY = 17;
+ public static final int NAME_FULL_MACCOMPATIBLE = 18;
+ public static final int NAME_SAMPLE_TEXT = 19;
+ public static final int NAME_POSTSCRIPT_CID = 20;
+
+
+ private static final int PLATFORM_MACINTOSH = 1;
+ private static final int PLATFORM_MICROSOFT = 3;
+
+
+ public static String getName(ByteBuffer nameTable,
+ int name, Locale locale)
+ {
+ int numRecords;
+ int macLanguage, msLanguage;
+ int offset;
+ int namePlatform, nameEncoding, nameLanguage, nameID, nameLen;
+ int nameStart;
+ String result;
+ boolean match;
+
+ if (nameTable == null)
+ return null;
+
+ nameTable.position(0);
+ /* We understand only format 0 of the name table. */
+ if (nameTable.getShort() != 0)
+ return null;
+
+ macLanguage = getMacLanguageCode(locale);
+ msLanguage = getMicrosoftLanguageCode(locale);
+ numRecords = nameTable.getShort();
+ offset = nameTable.getShort();
+
+ for (int i = 0; i < numRecords; i++)
+ {
+ namePlatform = nameTable.getShort();
+ nameEncoding = nameTable.getShort();
+ nameLanguage = nameTable.getShort();
+ nameID = nameTable.getShort();
+ nameLen = nameTable.getShort();
+ nameStart = offset + nameTable.getShort();
+
+
+ if (nameID != name)
+ continue;
+
+ // Handle PS seperately as it can be only ASCII, although
+ // possibly encoded as UTF-16BE
+ if ( name == NAME_POSTSCRIPT )
+ {
+ if( nameTable.get(nameStart) == 0 ) // Peek at top byte
+ result = decodeName("UTF-16BE", nameTable, nameStart, nameLen);
+ else
+ result = decodeName("ASCII", nameTable, nameStart, nameLen);
+ return result;
+ }
+
+ match = false;
+ switch (namePlatform)
+ {
+ case PLATFORM_MACINTOSH:
+ if ((nameLanguage == macLanguage) || (locale == null))
+ match = true;
+ else
+ {
+ switch (macLanguage)
+ {
+ case 49: /* Azerbaijani/Cyrillic */
+ match = (nameLanguage == /* Azerbaijani/Arabic */ 50)
+ || (nameLanguage == /* Azerbaijani/Roman */ 150);
+ break;
+
+ case 57: /* Mongolian/Mongolian */
+ match = (nameLanguage == /* Mongolian/Cyrillic */ 58);
+ break;
+
+ case 83: /* Malay/Roman */
+ match = (nameLanguage == /* Malay/Arabic */ 84);
+ break;
+ }
+ }
+ break;
+
+ case PLATFORM_MICROSOFT:
+ if (((nameLanguage & 0xff) == msLanguage) || (locale == null))
+ match = true;
+ break;
+ }
+
+
+ if (match)
+ {
+ result = decodeName(namePlatform, nameEncoding, nameLanguage,
+ nameTable, nameStart, nameLen);
+ if (result != null)
+ return result;
+ }
+ }
+
+ return null;
+ }
+
+
+ /**
+ * The language codes used by the Macintosh operating system. MacOS
+ * defines numeric language identifiers in the range [0 .. 95] and
+ * [128 .. 150]. To map this numeric identifier into an ISO 639
+ * language code, multiply it by two and take the substring at that
+ * position.
+ *
+ * <p>ISO 639 has revised the code for some languages, namely
+ * <code>he</code> for Hebrew (formerly <code>iw</code>),
+ * <code>yi</code> (formerly <code>ji</code>), and <code>id</code>
+ * for Indonesian (formerly <code>in</code>). In those cases, this
+ * table intentionally contains the older, obsolete code. The
+ * reason is that this is the code which
+ * java.util.Locale.getLanguage() is specified to return. The
+ * implementation of {@link #getMacLanguageCode} depends on this.
+ *
+ * @see <a href=
+ * "http://www.unicode.org/unicode/onlinedat/languages.html"
+ * >Language Codes: ISO 639, Microsoft and Macintosh</a>
+ */
+ private static final String macLanguageCodes
+ // 0 1 2
+ // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
+ = "enfrdeitnlsvesdaptnoiwjaarfielismttrhrzhurhithkoltplhuetlv "
+
+ // 3 4 5
+ // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
+ + "fofaruzhnlgdsqrocssksljisrmkbgukbeuzkkazazhykamokytgtkmnmnps"
+
+ // 6 7 8
+ // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
+ + "kukssdbonesamrbnasgupaormlkntatesimykmloviintlmsmsamti sosw"
+
+ // 9 10 11
+ // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
+ + "rwrn mgeo "
+
+ // 12 13 14
+ // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
+ + " cyeucalaqugnayttugtsjwsuglafbriugdgvgatoelkl"
+
+ // 15
+ // 0
+ + "az";
+
+
+ /**
+ * The primary language IDs used by the Microsoft operating systems.
+ *
+ * <p>ISO 639 has revised the code for some languages, namely
+ * <code>he</code> for Hebrew (formerly <code>iw</code>),
+ * <code>yi</code> (formerly <code>ji</code>), and <code>id</code>
+ * for Indonesian (formerly <code>in</code>). In those cases, this
+ * table intentionally contains the older, obsolete code. The
+ * reason is that this is the code which
+ * java.util.Locale.getLanguage() is specified to return. The
+ * implementation of {@link #getMicrosoftLanguageCode} depends on
+ * this.
+ *
+ * @see <a href=
+ * "http://www.unicode.org/unicode/onlinedat/languages.html"
+ * >Language Codes: ISO 639, Microsoft and Macintosh</a>
+ */
+ private static final String microsoftLanguageCodes
+ // 0 1 2
+ // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
+ = " arbgcazhcsdadeelenesfifriwhuisitjakonlnoplptrmrorushsksqsv"
+
+ // 3 4 5
+ // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
+ + "thtrurinukbesletlvlttgfavihyazeu mk ts xhzuafkafohimt "
+
+ // 6 7 8
+ // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
+ + "gajimskkkyswtkuzttbnpaguortateknmlasmrsamnbocykmlomygl sd"
+
+ // 9 10 11
+ // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
+ + " si iuam ksnefypstl ha yo omtign laso";
+
+
+ /**
+ * Maps a Java Locale into a MacOS language code.
+ *
+ * <p>For languages that are written in several script systems,
+ * MacOS defines multiple language codes. Java Locales have a
+ * variant which could be used for that purpose, but a small
+ * test program revealed that with Sun's JDK 1.4.1_01, only two
+ * of 134 available Locales have a variant tag (namely no_NO_NY
+ * and th_TH_TH).</p>
+ *
+ * <p>The following cases are problematic:
+ *
+ * <ul> <li>Azerbaijani (az): The MacOS language code is 49 if
+ * Azerbaijani is written in the Cyrillic script; 50 if written in
+ * the Arabic script; 150 if written in the Roman script. This
+ * method will always return 49 for the Azerbaijani locale.</li>
+ *
+ * <li>Mongolian (mn): The MacOS language code is 57 if Mongolian is
+ * written in the Mongolian script; 58 if written in the Cyrillic
+ * script. This method will always return 57 for the Mongolian
+ * locale.</li>
+ *
+ * <li>Malay (ms): The MacOS language code is 83 if Malay is written
+ * in the Roman script; 84 if written in the Arabic script. This
+ * method will always return 83 for the Malay locale.</li> </ul>
+ *
+ * @return a MacOS language code, or -1 if there is no such code for
+ * <code>loc</code>&#x2019;s language.
+ */
+ private static int getMacLanguageCode(Locale loc)
+ {
+ int code;
+
+ if (loc == null)
+ return -1;
+
+ code = findLanguageCode(loc.getLanguage(), macLanguageCodes);
+ switch (code)
+ {
+ case 19:
+ /* Traditional Chinese (MacOS language #19) and and Simplified
+ * Chinese (MacOS language #33) both have "zh" as their ISO 639
+ * code.
+ */
+ if (loc.equals(Locale.SIMPLIFIED_CHINESE))
+ code = 33;
+ break;
+
+ // Other special cases would be 49, 57 and 83, but we do not
+ // know what do do about them. See the method documentation for
+ // details.
+ }
+
+ return code;
+ }
+
+
+ /**
+ * Maps a Java Locale into a Microsoft language code.
+ */
+ private static int getMicrosoftLanguageCode(Locale locale)
+ {
+ String isoCode;
+ int code;
+
+ if (locale == null)
+ return -1;
+
+ isoCode = locale.getLanguage();
+ code = findLanguageCode(isoCode, microsoftLanguageCodes);
+ if (code == -1)
+ {
+ if (isoCode.equals("hr") || isoCode.equals("sr"))
+ {
+ /* Microsoft uses code 26 for "sh" (Serbo-Croatian),
+ * "hr" (Croatian) and "sr" (Serbian). Our table contains
+ * "sh".
+ */
+ code = 26;
+ }
+ else if (isoCode.equals("gd"))
+ {
+ /* Microsoft uses code 60 for "gd" (Scottish Gaelic) and
+ * "ga" (Irish Gaelic). Out table contains "ga".
+ */
+ code = 60;
+ }
+ }
+ return code;
+ }
+
+
+ private static int findLanguageCode(String lang, String langCodes)
+ {
+ int index;
+ if (lang == null)
+ return -1;
+
+ if (lang.length() != 2)
+ return -1;
+
+ index = 0;
+ do
+ {
+ index = langCodes.indexOf(lang, index);
+
+ /* The index must be even to be considered a match. Otherwise, we
+ * could match with the second letter of one language and the
+ * first of antoher one.
+ */
+ }
+ while (!((index < 0) || ((index & 1) == 0)));
+ if (index < 0)
+ return -1;
+
+ index = index / 2;
+ return index;
+ }
+
+
+ private static String decodeName(int platform, int encoding, int language,
+ ByteBuffer buffer, int offset, int len)
+ {
+ String charsetName = getCharsetName(platform, language, encoding);
+ if (charsetName == null)
+ return null;
+
+ return decodeName(charsetName, buffer, offset, len);
+ }
+
+ private static String decodeName(String charsetName,
+ ByteBuffer buffer, int offset, int len)
+ {
+ byte[] byteBuf;
+ int oldPosition;
+
+ byteBuf = new byte[len];
+ oldPosition = buffer.position();
+ try
+ {
+ buffer.position(offset);
+ buffer.get(byteBuf);
+ try
+ {
+ return new String(byteBuf, charsetName);
+ }
+ catch (UnsupportedEncodingException uex)
+ {
+ }
+ }
+ finally
+ {
+ buffer.position(oldPosition);
+ }
+
+ return null;
+ }
+
+
+ /**
+ * Maps a MacOS language code into a Java Locale.
+ *
+ * @param macLanguageCode the MacOS language code for
+ * the language whose Java locale is to be retrieved.
+ *
+ * @return an suitable Locale, or <code>null</code> if
+ * the mapping cannot be performed.
+ */
+ private static Locale getMacLocale(int macLanguageCode)
+ {
+ String isoCode;
+
+ switch (macLanguageCode)
+ {
+ case 0: return Locale.ENGLISH;
+ case 1: return Locale.FRENCH;
+ case 2: return Locale.GERMAN;
+ case 3: return Locale.ITALIAN;
+ case 11: return Locale.JAPANESE;
+ case 23: return Locale.KOREAN;
+ case 19: return Locale.TRADITIONAL_CHINESE;
+ case 33: return Locale.SIMPLIFIED_CHINESE;
+ }
+
+ if ((macLanguageCode < 0) || (macLanguageCode > 150))
+ return null;
+
+ isoCode = macLanguageCodes.substring(macLanguageCode << 1,
+ (macLanguageCode + 1) << 1);
+ if (isoCode.charAt(0) == ' ')
+ return null;
+
+ return new Locale(isoCode);
+ }
+
+
+
+ /**
+ * Maps a Windows LCID into a Java Locale.
+ *
+ * @param lcid the Windows language ID whose Java locale
+ * is to be retrieved.
+ *
+ * @return an suitable Locale, or <code>null</code> if
+ * the mapping cannot be performed.
+ */
+ private static Locale getWindowsLocale(int lcid)
+ {
+ /* FIXME: This is grossly incomplete. */
+ switch (lcid)
+ {
+ case 0x0407: return Locale.GERMAN;
+ case 0x0408: return new Locale("el", "GR");
+ case 0x0409: return Locale.ENGLISH;
+ case 0x040b: return new Locale("fi");
+ case 0x040c: return Locale.FRENCH;
+ case 0x0416: return new Locale("pt");
+ case 0x0807: return new Locale("de", "CH");
+ case 0x0809: return new Locale("en", "UK");
+ case 0x080c: return new Locale("fr", "BE");
+ case 0x0816: return new Locale("pt", "BR");
+ case 0x0c07: return new Locale("de", "AT");
+ case 0x0c09: return new Locale("en", "AU");
+ case 0x0c0c: return new Locale("fr", "CA");
+ case 0x1007: return new Locale("de", "LU");
+ case 0x1009: return new Locale("en", "CA");
+ case 0x100c: return new Locale("fr", "CH");
+ case 0x1407: return new Locale("de", "LI");
+ case 0x1409: return new Locale("en", "NZ");
+ case 0x140c: return new Locale("fr", "LU");
+ case 0x1809: return new Locale("en", "IE");
+
+ default:
+ return null;
+ }
+ }
+
+
+ /**
+ * Maps a Macintosh Script Manager code to the name of the
+ * corresponding Java Charset.
+ *
+ * @param macScript a MacOS ScriptCode, for example
+ * 6 for <code>smGreek</code>.
+ *
+ * @return a String that can be used to retrieve a Java
+ * CharsetDecorder, for example <code>MacGreek</code>, or
+ * <code>null</code> if <code>macScript</code> has an
+ * unsupported value.
+ */
+ private static String getMacCharsetName(int macScript)
+ {
+ switch (macScript)
+ {
+ case 0: return "MacRoman";
+ case 1: return "MacJapanese";
+ case 2: return "MacKorean";
+ case 3: return "MacTradChinese";
+ case 4: return "MacArabic";
+ case 5: return "MacHebrew";
+ case 6: return "MacGreek";
+ case 7: return "MacCyrillic";
+ case 8: return "MacRSymbol";
+ case 9: return "MacDevanagari";
+ case 10: return "MacGurmukhi";
+ case 11: return "MacGujarati";
+ case 12: return "MacOriya";
+ case 13: return "MacBengali";
+ case 14: return "MacTamil";
+ case 15: return "MacTelugu";
+ case 16: return "MacKannada";
+ case 17: return "MacMalayalam";
+ case 18: return "MacSinhalese";
+ case 19: return "MacBurmese";
+ case 20: return "MacKhmer";
+ case 21: return "MacThai";
+ case 22: return "MacLao";
+ case 23: return "MacGeorgian";
+ case 24: return "MacArmenian";
+ case 25: return "MacSimpChinese";
+ case 26: return "MacTibetan";
+ case 27: return "MacMongolian";
+ case 28: return "MacEthiopic";
+ case 29: return "MacCentralEurope";
+ case 30: return "MacVietnamese";
+ case 31: return "MacExtArabic";
+
+ default: return null;
+ }
+ }
+
+
+ /**
+ * Maps a Microsoft locale ID (LCID) to the name of the
+ * corresponding Java Charset.
+ *
+ * @param lcid the Microsoft locale ID.
+ *
+ * @return a String that can be used to retrieve a Java
+ * CharsetDecorder, for example <code>windows-1252</code>, or
+ * <code>null</code> if <code>lcid</code> has an unsupported value.
+ */
+ private static String getMicrosoftCharsetName(int lcid)
+ {
+ int lang;
+ char codePage = '?';
+
+ /* Extract the language code from the LCID. */
+ lang = lcid & 0x3ff;
+
+ /* In the majority of cases, the language alone determines the
+ * codepage.
+ */
+ if (lang < 100)
+ codePage = (" 612D022322225022EC2202201?002A462110777 68 ?2 1 "
+ + " 2 2 2112 ?1 1 2 2 ")
+ .charAt(lang);
+
+ /* There are a few exceptions, however, where multiple code pages
+ * are used for the same language. */
+ if (codePage == '?')
+ {
+ switch (lcid)
+ {
+ case 0x041a: // Croatian --> Windows-1250 (Central Europe)
+ case 0x081a: // Serbian (Latin) --> Windows-1250 (Central Europe)
+ codePage = '0';
+ break;
+
+ case 0x42c: // Azeri (Latin) --> Windows-1254 (Turkish)
+ case 0x443: // Uzbek (Latin) --> Windows-1254 (Turkish)
+ codePage = '4';
+ break;
+
+ case 0x82c: // Azeri (Cyrillic) --> Windows-1251 (Cyrillic)
+ case 0x843: // Uzbek (Cyrillic) --> Windows-1251 (Cyrillic)
+ case 0xc1a: // Serbian (Cyrillic) --> Windows-1251 (Cyrillic)
+ codePage = '1';
+ break;
+ }
+ }
+
+ switch (codePage)
+ {
+ case '0': return "windows-1250"; // Central Europe
+ case '1': return "windows-1251"; // Cyrillic
+ case '2': return "windows-1252"; // Latin 1
+ case '3': return "windows-1253"; // Greek
+ case '4': return "windows-1254"; // Turkish
+ case '5': return "windows-1255"; // Hebrew
+ case '6': return "windows-1256"; // Arabic
+ case '7': return "windows-1257"; // Baltic
+ case '8': return "windows-1258"; // Vietnam
+ case 'A': return "windows-874"; // Thai
+ case 'B': return "windows-936"; // Simplified Chinese, GBK
+ case 'C': return "windows-949"; // Korean
+ case 'D': return "windows-950"; // Traditional Chinese, Big5
+ case 'E': return "windows-932"; // Japanese Shift-JIS
+ default: return null;
+ }
+ }
+
+
+ /**
+ * Returns the Locale of an OpenType name.
+ *
+ * @param platform the OpenType platform ID.
+ *
+ * @param language the language tag of the OpenType name. If
+ * <code>platform</code> is 1, this is the MacOS language code.
+ *
+ * @param encoding the encoding tag of the OpenType name. If
+ * <code>platform</code> is 1, this is the MacOS script code.
+ */
+ public static Locale getLocale(int platform, int language, int encoding)
+ {
+ switch (platform)
+ {
+ case 1: /* Apple Macintosh */
+ return getMacLocale(language);
+
+ case 3: /* Microsoft Windows */
+ return getWindowsLocale(language);
+
+ default:
+ return null;
+ }
+ }
+
+
+ /**
+ * Determines the name of the charset for an OpenType font name.
+ *
+ * @param platform the OpenType platform ID.
+ *
+ * @param language the language tag of the OpenType name. If
+ * <code>platform</code> is 1, this is the MacOS language code.
+ *
+ * @param encoding the encoding tag of the OpenType name. If
+ * <code>platform</code> is 1, this is the MacOS script code.
+ *
+ * @return a charset name such as <code>&quot;MacRoman&quot;</code>,
+ * or <code>null</code> if the combination is not known.
+ */
+ public static String getCharsetName(int platform, int language, int encoding)
+ {
+ switch (platform)
+ {
+ case 1: /* Apple Macintosh */
+ return getMacCharsetName(encoding);
+
+ case 3: /* Microsoft Windows */
+ return getMicrosoftCharsetName(language);
+
+ default:
+ return null;
+ }
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/opentype/OpenTypeFont.java b/libjava/classpath/gnu/java/awt/font/opentype/OpenTypeFont.java
new file mode 100644
index 000000000..f46addc3c
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/opentype/OpenTypeFont.java
@@ -0,0 +1,882 @@
+/* OpenTypeFont.java -- Manages OpenType and TrueType fonts.
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.awt.font.opentype;
+
+import java.awt.Font;
+import java.awt.FontFormatException;
+import java.awt.font.FontRenderContext;
+import java.awt.font.GlyphVector;
+import java.awt.font.OpenType;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.GeneralPath;
+import java.awt.geom.Point2D;
+import java.nio.ByteBuffer;
+import java.text.CharacterIterator;
+import java.util.Locale;
+
+import gnu.java.awt.font.FontDelegate;
+import gnu.java.awt.font.GNUGlyphVector;
+import gnu.java.awt.font.autofit.AutoHinter;
+import gnu.java.awt.font.opentype.truetype.TrueTypeScaler;
+import gnu.java.awt.font.opentype.truetype.Zone;
+
+
+/**
+ * A font that takes its data from OpenType or TrueType font tables.
+ *
+ * <p>OpenType is an extension of the TrueType font format. In addition
+ * to tables for names, kerning or layout, it also stores the shapes
+ * of individual glyphs. Three formats are recognized for glyphs:
+ * Quadratic splines (classic TrueType), cubic splines (PostScript),
+ * and bitmaps.
+ *
+ * @see <a
+ * href="http://partners.adobe.com/asn/tech/type/opentype/">Adobe&#x2019;s
+ * OpenType specification</a>
+ *
+ * @see <a
+ * href="http://developer.apple.com/fonts/TTRefMan/">Apple&#x2019;s</code>
+ * TrueType specification</a>
+ *
+ * @author Sascha Brawer (brawer@dandelis.ch)
+ */
+public final class OpenTypeFont
+ implements FontDelegate
+{
+ static final int TAG_OTTO = 0x4f54544f; // 'OTTO'
+ static final int TAG_SFNT = 0x73666e74; // 'sfnt'
+ static final int TAG_TRUE = 0x74727565; // 'true'
+ static final int TAG_TTCF = 0x74746366; // 'ttcf'
+ static final int TAG_ZAPF = 0x5a617066; // 'Zapf'
+
+
+ /**
+ * A buffer containing the font data. Note that this may well be an
+ * instance of the subclass MappedByteBuffer, in which case the
+ * virtual memory subsystem can more efficiently handle requests for
+ * font data. This is especially recommended for large font files
+ * that contain many glyphs that are rarely accessed.
+ */
+ ByteBuffer buf;
+
+
+ /**
+ * The number of glyphs in this font.
+ */
+ final int numGlyphs;
+
+ int[] tableTag, tableStart, tableLength;
+
+
+ /**
+ * The version of the font in 16.16 fixed-point encoding, for
+ * example 0x00010000 for version 1.0. There are also two special
+ * version IDs used by fonts for Apple Macintosh, namely 'true'
+ * (0x74727565) and 'typ1'. OpenType fonts sometimes have 'OTTO' as
+ * their version.
+ */
+ private int version;
+
+
+ /**
+ * The number of font units per em. For fonts with TrueType
+ * outlines, this is usually a power of two (such as 2048). For
+ * OpenType fonts with PostScript outlines, other values are
+ * acceptable (such as 1000).
+ */
+ public int unitsPerEm;
+
+
+ /**
+ * A factor to convert font units into ems. This value is <code>1 /
+ * unitsPerEm</code>.
+ */
+ private float emsPerUnit;
+
+
+ /**
+ * The scaler to which the actual scaling work is delegated.
+ */
+ private Scaler scaler;
+
+
+ /**
+ * A delegate object for mapping Unicode UCS-4 codepoints to glyph
+ * IDs.
+ */
+ private CharGlyphMap cmap;
+
+
+ /**
+ * A delegate object for providing a name for each glyph.
+ */
+ private GlyphNamer glyphNamer;
+
+ private Hinter hinter;
+
+ /**
+ * Constructs an OpenType or TrueType font.
+ *
+ * @param buf a buffer with the contents of the font file. It is
+ * recommended to use a <code>MappedByteBuffer</code> for very
+ * large font files.
+ *
+ * @param offsetTablePosition the position of the OpenType offset
+ * table in the font file. The offset table of most OpenType and
+ * TrueType fonts starts at position 0. However, so-called TrueType
+ * Collections support multiple OpenType fonts in a single file,
+ * which allows sharing some glyphs between fonts. If many glyphs
+ * are shared (for example all the Kanji glyphs between multiple
+ * Japanese fonts), the space savings can be considerable. In that
+ * case, the offset table of each individual font would start at its
+ * own position.
+ *
+ * @throws java.awt.FontFormatException if the font data is
+ * not in OpenType or TrueType format.
+ */
+ OpenTypeFont(ByteBuffer buf, int offsetTablePosition)
+ throws FontFormatException
+ {
+ int numTables, searchRange, entrySelector, rangeShift;
+
+ //buf = buf.duplicate();
+ this.buf = buf;
+ buf.limit(buf.capacity());
+ buf.position(offsetTablePosition);
+
+ /* Check that the font data is in a supported format. */
+ version = buf.getInt();
+ switch (version)
+ {
+ case 0x00010000: // Microsoft TrueType
+ case OpenType.TAG_TYP1: // Adobe PostScript embeded in Apple SFNT ('typ1')
+ case TAG_SFNT: // Apple TrueType
+ case TAG_TRUE: // Apple TrueType
+ case TAG_OTTO: // OpenType
+ break;
+
+ default:
+ throw new FontFormatException("not in OpenType or TrueType format");
+ }
+
+ numTables = buf.getShort();
+ searchRange = buf.getShort();
+ entrySelector = buf.getShort();
+ rangeShift = buf.getShort();
+
+ tableTag = new int[numTables];
+ tableStart = new int[numTables];
+ tableLength = new int[numTables];
+ int lastTag = 0;
+ for (int i = 0; i < numTables; i++)
+ {
+ tableTag[i] = buf.getInt();
+ if (lastTag >= tableTag[i])
+ throw new FontFormatException("unordered OpenType table");
+
+ buf.getInt(); // ignore checksum
+ tableStart[i] = buf.getInt();
+ tableLength[i] = buf.getInt();
+
+ //System.out.println(tagToString(tableTag[i]) + ", " + tableLength[i]);
+ }
+
+ ByteBuffer head = getFontTable(OpenType.TAG_HEAD);
+ if ((head.getInt(0) != 0x00010000)
+ || (head.getInt(12) != 0x5f0f3cf5))
+ throw new FontFormatException("unsupported head version");
+
+ unitsPerEm = head.getChar(18);
+ emsPerUnit = 1.0f / (float) unitsPerEm;
+
+
+ ByteBuffer maxp = getFontTable(OpenType.TAG_MAXP);
+ int maxpVersion = maxp.getInt(0);
+ switch (maxpVersion)
+ {
+ case 0x00005000: /* version 0.5, with wrong fractional part */
+ numGlyphs = maxp.getChar(4);
+ break;
+
+ case 0x00010000: /* version 1.0 */
+ numGlyphs = maxp.getChar(4);
+ scaler = new TrueTypeScaler(unitsPerEm,
+ getFontTable(OpenType.TAG_HHEA),
+ getFontTable(OpenType.TAG_HMTX),
+ getFontTable(OpenType.TAG_VHEA),
+ getFontTable(OpenType.TAG_VMTX),
+ maxp,
+ getFontTable(OpenType.TAG_CVT),
+ getFontTable(OpenType.TAG_FPGM),
+ /* loca format */ head.getShort(50),
+ getFontTable(OpenType.TAG_LOCA),
+ getFontTable(OpenType.TAG_GLYF),
+ getFontTable(OpenType.TAG_PREP));
+ break;
+
+ default:
+ throw new FontFormatException("unsupported maxp version");
+ }
+ }
+
+
+ /**
+ * Determines the index of a table into the offset table. The
+ * result can be used to find the offset and length of a table, as
+ * in <code>tableStart[getTableIndex(TAG_NAME)]</code>.
+ *
+ * @param tag the table identifier, for instance
+ * <code>OpenType.TAG_NAME</code>.
+ *
+ * @return the index of that table into the offset table, or
+ * -1 if the font does not contain the table specified by
+ * <code>tag</code>.
+ */
+ private int getTableIndex(int tag)
+ {
+ /* FIXME: Since the font specification requires tableTag[] to be
+ * ordered, one should do binary search here.
+ */
+ for (int i = 0; i < tableTag.length; i++)
+ if (tableTag[i] == tag)
+ return i;
+ return -1;
+ }
+
+
+
+ /**
+ * Returns the name of the family to which this font face belongs,
+ * for example <i>&#x201c;Univers&#x201d;</i>.
+ *
+ * @param locale the locale for which to localize the name.
+ *
+ * @return the family name.
+ */
+ public synchronized String getFamilyName(Locale locale)
+ {
+ String name;
+
+ if (locale == null)
+ locale = Locale.getDefault();
+
+ name = getName(NameDecoder.NAME_FAMILY, locale);
+ if (name == null)
+ name = getName(NameDecoder.NAME_FAMILY, Locale.ENGLISH);
+ if (name == null)
+ name = getName(NameDecoder.NAME_FAMILY, /* any language */ null);
+ if (name == null)
+ name = getName(NameDecoder.NAME_FULL, locale);
+ if (name == null)
+ name = getName(NameDecoder.NAME_FULL, /* any language */ null);
+ return name;
+ }
+
+
+ /**
+ * Returns the name of this font face inside the family, for example
+ * <i>&#x201c;Light&#x201d;</i>.
+ *
+ * @param locale the locale for which to localize the name.
+ *
+ * @return the name of the face inside its family.
+ */
+ public synchronized String getSubFamilyName(Locale locale)
+ {
+ String name;
+
+ if (locale == null)
+ locale = Locale.getDefault();
+
+ name = getName(NameDecoder.NAME_SUBFAMILY, locale);
+ if (name == null)
+ {
+ name = getName(NameDecoder.NAME_SUBFAMILY, Locale.ENGLISH);
+ if ("Regular".equals(name))
+ name = null;
+ }
+
+ if (name == null)
+ {
+ String lang = locale.getLanguage();
+ if ("de".equals(lang))
+ name = "Standard";
+ else if ("fr".equals(lang))
+ name = "Standard";
+ else if ("it".equals(lang))
+ name = "Normale";
+ else if ("nl".equals(lang))
+ name = "Normaal";
+ else if ("fi".equals(lang))
+ name = "Normaali";
+ else if ("sv".equals(lang))
+ name = "Normal";
+ else
+ name = "Regular";
+ }
+
+ return name;
+ }
+
+
+
+ /**
+ * Returns the full name of this font face, for example
+ * <i>&#x201c;Univers Light&#x201d;</i>.
+ *
+ * @param locale the locale for which to localize the name.
+ *
+ * @return the face name.
+ */
+ public synchronized String getFullName(Locale locale)
+ {
+ String name;
+
+ if (locale == null)
+ locale = Locale.getDefault();
+
+ name = getName(NameDecoder.NAME_FULL, locale);
+ if (name == null)
+ name = getName(NameDecoder.NAME_FULL, Locale.ENGLISH);
+ if (name == null)
+ name = getName(NameDecoder.NAME_FULL, /* any language */ null);
+
+ return name;
+ }
+
+
+ /**
+ * Returns the PostScript name of this font face, for example
+ * <i>&#x201c;Univers-Light&#x201d;</i>.
+ *
+ * @return the PostScript name, or <code>null</code> if the font
+ * does not provide a PostScript name.
+ */
+ public synchronized String getPostScriptName()
+ {
+ return getName(NameDecoder.NAME_POSTSCRIPT, /* any language */ null);
+ }
+
+
+ /**
+ * Returns the number of glyphs in this font face.
+ */
+ public int getNumGlyphs()
+ {
+ /* No synchronization is needed because the number of glyphs is
+ * set in the constructor, and it cannot change during the
+ * lifetime of the object.
+ */
+ return numGlyphs;
+ }
+
+
+ /**
+ * Returns the index of the glyph which gets displayed if the font
+ * cannot map a Unicode code point to a glyph. Many fonts show this
+ * glyph as an empty box.
+ */
+ public int getMissingGlyphCode()
+ {
+ /* No synchronization is needed because the result is constant. */
+ return 0;
+ }
+
+
+ /**
+ * The font&#x2019;s name table, or <code>null</code> if this
+ * table has not yet been accessed.
+ */
+ private ByteBuffer nameTable;
+
+
+ /**
+ * Extracts a String from the font&#x2019;s name table.
+ *
+ * @param name the numeric TrueType or OpenType name ID.
+ *
+ * @param locale the locale for which names shall be localized, or
+ * <code>null</code> if the locale does mot matter because the name
+ * is known to be language-independent (for example, because it is
+ * the PostScript name).
+ */
+ private String getName(int name, Locale locale)
+ {
+ if (nameTable == null)
+ nameTable = getFontTable(OpenType.TAG_NAME);
+ return NameDecoder.getName(nameTable, name, locale);
+ }
+
+
+ /**
+ * Returns the version of the font.
+ *
+ * @see java.awt.font.OpenType#getVersion
+ *
+ * @return the version in 16.16 fixed-point encoding, for example
+ * 0x00010000 for version 1.0.
+ */
+ public int getVersion()
+ {
+ /* No synchronization is needed because the version is set in the
+ * constructor, and it cannot change during the lifetime of the
+ * object.
+ */
+ return version;
+ }
+
+
+ /**
+ * Creates a view buffer for an OpenType table. The caller can
+ * access the returned buffer without needing to synchronize access
+ * from multiple threads.
+ *
+ * @param tag the table identifier, for example
+ * <code>OpenType.GLYF</code>.
+ *
+ * @return a slice of the underlying buffer containing the table, or
+ * <code>null</code> if the font does not contain the requested
+ * table.
+ */
+ public synchronized ByteBuffer getFontTable(int tag)
+ {
+ int index, start, len;
+ ByteBuffer result;
+
+ index = getTableIndex(tag);
+ if (index < 0)
+ return null;
+
+ start = tableStart[index];
+ len = tableLength[index];
+ buf.limit(start + len).position(start);
+ result = buf.slice();
+ result.limit(len);
+ return result;
+ }
+
+
+ /**
+ * Returns the size of one of the tables in the font,
+ * or -1 if the table does not exist.
+ */
+ public int getFontTableSize(int tag)
+ {
+ int index = getTableIndex(tag);
+ if (index == -1)
+ return index;
+ return tableLength[index];
+ }
+
+
+ private CharGlyphMap getCharGlyphMap()
+ {
+ if (cmap != null)
+ return cmap;
+
+ synchronized (this)
+ {
+ if (cmap == null)
+ {
+ int index = getTableIndex(OpenType.TAG_CMAP);
+ int start = tableStart[index];
+ buf.limit(start + tableLength[index]).position(start);
+ cmap = CharGlyphMap.forTable(buf);
+ }
+ return cmap;
+ }
+ }
+
+
+
+ /**
+ * Looks up a glyph in the font&#x2019;s <code>cmap</code> tables,
+ * without performing any glyph substitution or reordering. Because
+ * of this limitation, this method cannot be used for script systems
+ * that need advanced glyph mapping, such as Arabic, Korean, or even
+ * Latin with exotic accents.
+ *
+ * <p>It is safe to call this method from any thread.
+ *
+ * @param ucs4 the Unicode codepoint in the 32-bit Unicode character
+ * set UCS-4. Because UTF-16 surrogates do not correspond to a single
+ * glyph, it does not make sense to pass them here.
+ *
+ * @return the glyph index, or zero if the font does not contain
+ * a glyph for the specified codepoint.
+ */
+ public int getGlyph(int ucs4)
+ {
+ return getCharGlyphMap().getGlyph(ucs4);
+ }
+
+
+ /**
+ * Creates a GlyphVector by mapping each character in a
+ * CharacterIterator to the corresponding glyph.
+ *
+ * <p>The mapping takes only the font&#x2019;s <code>cmap</code>
+ * tables into consideration. No other operations (such as glyph
+ * re-ordering, composition, or ligature substitution) are
+ * performed. This means that the resulting GlyphVector will not be
+ * correct for text in languages that have complex
+ * character-to-glyph mappings, such as Arabic, Hebrew, Hindi, or
+ * Thai.
+ *
+ * @param font the font object that the created GlyphVector
+ * will return when it gets asked for its font. This argument is
+ * needed because the public API works with java.awt.Font,
+ * not with some private delegate like OpenTypeFont.
+ *
+ * @param frc the font rendering parameters that are used for
+ * measuring glyphs. The exact placement of text slightly depends on
+ * device-specific characteristics, for instance the device
+ * resolution or anti-aliasing. For this reason, any measurements
+ * will only be accurate if the passed
+ * <code>FontRenderContext</code> correctly reflects the relevant
+ * parameters. Hence, <code>frc</code> should be obtained from the
+ * same <code>Graphics2D</code> that will be used for drawing, and
+ * any rendering hints should be set to the desired values before
+ * obtaining <code>frc</code>.
+ *
+ * @param ci a CharacterIterator for iterating over the
+ * characters to be displayed.
+ */
+ public synchronized GlyphVector createGlyphVector(Font font,
+ FontRenderContext frc,
+ CharacterIterator ci)
+ {
+ // Initialize hinter if necessary.
+ checkHinter(FontDelegate.FLAG_FITTED);
+
+ CharGlyphMap cmap;
+ int numGlyphs;
+ int[] glyphs;
+ int glyph;
+ int c;
+
+ cmap = getCharGlyphMap();
+ numGlyphs = ci.getEndIndex() - ci.getBeginIndex();
+ glyphs = new int[numGlyphs];
+ glyph = 0;
+ for (c = ci.first(); c != CharacterIterator.DONE; c = ci.next())
+ {
+ /* handle surrogate pairs */
+ if (c >> 10 == 0x36) // U+D800 .. U+DBFF: High surrogate
+ c = (((c & 0x3ff) << 10) | (ci.next() & 0x3ff)) + 0x10000;
+ glyphs[glyph] = cmap.getGlyph(c);
+ glyph += 1;
+ }
+
+ /* If we had surrogates, the allocated array is too large.
+ * Because this will occur very rarely, it seems acceptable to
+ * re-allocate a shorter array and copy the contents around.
+ */
+ if (glyph != numGlyphs)
+ {
+ int[] newGlyphs = new int[glyph];
+ System.arraycopy(glyphs, 0, newGlyphs, 0, glyph);
+ glyphs = newGlyphs;
+ }
+
+ return new GNUGlyphVector(this, font, frc, glyphs);
+ }
+
+ /**
+ * Returns the glyph code for the specified character.
+ *
+ * @param c the character to map
+ *
+ * @return the glyph code
+ */
+ public int getGlyphIndex(int c)
+ {
+ return getCharGlyphMap().getGlyph(c);
+ }
+
+ /**
+ * Determines the advance width for a glyph.
+ *
+ * @param glyphIndex the glyph whose advance width is to be
+ * determined.
+ *
+ * @param pointSize the point size of the font.
+ *
+ * @param transform a transform that is applied in addition to
+ * scaling to the specified point size. This is often used for
+ * scaling according to the device resolution. Those who lack any
+ * aesthetic sense may also use the transform to slant or stretch
+ * glyphs.
+ *
+ * @param antialias <code>true</code> for anti-aliased rendering,
+ * <code>false</code> for normal rendering. For hinted fonts,
+ * this parameter may indeed affect the result.
+ *
+ * @param fractionalMetrics <code>true</code> for fractional metrics,
+ * <code>false</code> for rounding the result to a pixel boundary.
+ *
+ * @param horizontal <code>true</code> for horizontal line layout,
+ * <code>false</code> for vertical line layout.
+ *
+ * @param advance a point whose <code>x</code> and <code>y</code>
+ * fields will hold the advance in each direction. It is possible
+ * that both values are non-zero, for example if
+ * <code>transform</code> is a rotation, or in the case of Urdu
+ * fonts.
+ */
+ public synchronized void getAdvance(int glyphIndex,
+ float pointSize,
+ AffineTransform transform,
+ boolean antialias,
+ boolean fractionalMetrics,
+ boolean horizontal,
+ Point2D advance)
+ {
+ /* Delegate the measurement to the scaler. The synchronization is
+ * needed because the scaler is not synchronized.
+ */
+ scaler.getAdvance(glyphIndex, pointSize, transform,
+ antialias, fractionalMetrics, horizontal,
+ advance);
+ }
+
+
+ /**
+ * Returns the shape of a glyph.
+ *
+ * @param glyph the glyph whose advance width is to be determined
+ *
+ * @param pointSize the point size of the font.
+ *
+ * @param transform a transform that is applied in addition to
+ * scaling to the specified point size. This is often used for
+ * scaling according to the device resolution. Those who lack any
+ * aesthetic sense may also use the transform to slant or stretch
+ * glyphs.
+ *
+ * @param antialias <code>true</code> for anti-aliased rendering,
+ * <code>false</code> for normal rendering. For hinted fonts, this
+ * parameter may indeed affect the result.
+ *
+ * @param fractionalMetrics <code>true</code> for fractional
+ * metrics, <code>false</code> for rounding the result to a pixel
+ * boundary.
+ *
+ * @return the scaled and grid-fitted outline of the specified
+ * glyph, or <code>null</code> for bitmap fonts.
+ */
+ public synchronized GeneralPath getGlyphOutline(int glyph,
+ float pointSize,
+ AffineTransform transform,
+ boolean antialias,
+ boolean fractionalMetrics,
+ int flags)
+ {
+ /* The synchronization is needed because the scaler is not
+ * synchronized.
+ */
+ checkHinter(flags);
+ return scaler.getOutline(glyph, pointSize, transform,
+ antialias, fractionalMetrics, hinter, flags);
+ }
+
+ /**
+ * Fetches the raw glyph outline for the specified glyph index. This is used
+ * for the autofitter only ATM and is otherwise not usable for outside code.
+ *
+ * @param glyph the glyph index to fetch
+ * @param transform the transform to apply
+ *
+ * @return the raw outline of that glyph
+ */
+ public synchronized Zone getRawGlyphOutline(int glyph,
+ AffineTransform transform)
+ {
+ return scaler.getRawOutline(glyph, transform);
+ }
+
+ /**
+ * Returns a name for the specified glyph. This is useful for
+ * generating PostScript or PDF files that embed some glyphs of a
+ * font.
+ *
+ * <p><b>Names are not unique:</b> Under some rare circumstances,
+ * the same name can be returned for different glyphs. It is
+ * therefore recommended that printer drivers check whether the same
+ * name has already been returned for antoher glyph, and make the
+ * name unique by adding the string ".alt" followed by the glyph
+ * index.</p>
+ *
+ * <p>This situation would occur for an OpenType or TrueType font
+ * that has a <code>post</code> table of format 3 and provides a
+ * mapping from glyph IDs to Unicode sequences through a
+ * <code>Zapf</code> table. If the same sequence of Unicode
+ * codepoints leads to different glyphs (depending on contextual
+ * position, for example, or on typographic sophistication level),
+ * the same name would get synthesized for those glyphs.
+ *
+ * @param glyphIndex the glyph whose name the caller wants to
+ * retrieve.
+ */
+ public synchronized String getGlyphName(int glyphIndex)
+ {
+ if (glyphNamer == null)
+ glyphNamer = GlyphNamer.forTables(numGlyphs,
+ getFontTable(OpenType.TAG_POST),
+ getFontTable(TAG_ZAPF));
+
+ return glyphNamer.getGlyphName(glyphIndex);
+ }
+
+
+ /**
+ * Determines the distance between the base line and the highest
+ * ascender.
+ *
+ * @param pointSize the point size of the font.
+ *
+ * @param transform a transform that is applied in addition to
+ * scaling to the specified point size. This is often used for
+ * scaling according to the device resolution. Those who lack any
+ * aesthetic sense may also use the transform to slant or stretch
+ * glyphs.
+ *
+ * @param antialiased <code>true</code> for anti-aliased rendering,
+ * <code>false</code> for normal rendering. For hinted fonts,
+ * this parameter may indeed affect the result.
+ *
+ * @param fractionalMetrics <code>true</code> for fractional metrics,
+ * <code>false</code> for rounding the result to a pixel boundary.
+ *
+ * @param horizontal <code>true</code> for horizontal line layout,
+ * <code>false</code> for vertical line layout.
+ *
+ * @return the ascent, which usually is a positive number.
+ */
+ public synchronized float getAscent(float pointSize,
+ AffineTransform transform,
+ boolean antialiased,
+ boolean fractionalMetrics,
+ boolean horizontal)
+ {
+ return scaler.getAscent(pointSize, transform,
+ antialiased, fractionalMetrics,
+ horizontal);
+ }
+
+
+ /**
+ * Determines the distance between the base line and the lowest
+ * descender.
+ *
+ * @param pointSize the point size of the font.
+ *
+ * @param transform a transform that is applied in addition to
+ * scaling to the specified point size. This is often used for
+ * scaling according to the device resolution. Those who lack any
+ * aesthetic sense may also use the transform to slant or stretch
+ * glyphs.
+ *
+ * @param antialiased <code>true</code> for anti-aliased rendering,
+ * <code>false</code> for normal rendering. For hinted fonts,
+ * this parameter may indeed affect the result.
+ *
+ * @param fractionalMetrics <code>true</code> for fractional metrics,
+ * <code>false</code> for rounding the result to a pixel boundary.
+ *
+ * @param horizontal <code>true</code> for horizontal line layout,
+ * <code>false</code> for vertical line layout.
+ *
+ * @return the descent, which usually is a nagative number.
+ */
+ public synchronized float getDescent(float pointSize,
+ AffineTransform transform,
+ boolean antialiased,
+ boolean fractionalMetrics,
+ boolean horizontal)
+ {
+ return scaler.getDescent(pointSize, transform,
+ antialiased, fractionalMetrics,
+ horizontal);
+ }
+
+
+ /**
+ * Converts a four-byte tag identifier into a String that can be
+ * displayed when debugging this class.
+ *
+ * @param tag the tag as an <code>int</code>.
+ *
+ * @return the tag in human-readable form, for example
+ * <code>name</code> or <code>glyf</code>.
+ */
+ static String tagToString(int tag)
+ {
+ char[] c = new char[4];
+ c[0] = (char) ((tag >> 24) & 0xff);
+ c[1] = (char) ((tag >> 16) & 0xff);
+ c[2] = (char) ((tag >> 8) & 0xff);
+ c[3] = (char) (tag & 0xff);
+ return new String(c);
+ }
+
+ /**
+ * Checks if a hinter is installed and installs one when not.
+ */
+ private void checkHinter(int flags)
+ {
+ // When another hinting impl gets added (maybe a true TrueType hinter)
+ // then add some options here. The Hinter interface might need to be
+ // tweaked.
+ if (hinter == null)
+ {
+ try
+ {
+ hinter = new AutoHinter();
+ hinter.init(this);
+ }
+ catch (Exception ex)
+ {
+ // Protect from problems inside hinter.
+ hinter = null;
+ ex.printStackTrace();
+ }
+ }
+ hinter.setFlags(flags);
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/opentype/OpenTypeFontFactory.java b/libjava/classpath/gnu/java/awt/font/opentype/OpenTypeFontFactory.java
new file mode 100644
index 000000000..32c4828c9
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/opentype/OpenTypeFontFactory.java
@@ -0,0 +1,140 @@
+/* OpenTypeFontFactory.java -- Creates OpenType and TrueType fonts.
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.awt.font.opentype;
+
+import gnu.java.awt.font.FontDelegate;
+import java.awt.FontFormatException;
+import java.awt.font.OpenType;
+import java.nio.ByteBuffer;
+
+
+/**
+ * A factory for creating fonts that are stored in an
+ * <i>sfnt</i>-housed format, for example OpenType or TrueType.
+ *
+ * @author Sascha Brawer (brawer@dandelis.ch)
+ */
+public final class OpenTypeFontFactory
+{
+ /**
+ * The constructor is private so nobody can construct an instance
+ * of this class.
+ */
+ private OpenTypeFontFactory()
+ {
+ }
+
+
+ /**
+ * Creates FontDelegate objects for the fonts in the specified
+ * buffer. The following font formats are currently recognized:
+ *
+ * <p><ul>
+ * <li>OpenType (*.otf);</li>
+ * <li>TrueType (*.ttf);</li>
+ * <li>TrueType Collections (*.ttc);</li>
+ * <li>Apple MacOS X data-fork font (*.dfont).</li></ul>
+ *
+ * <p>Some formats may contain more than a single font, for example
+ * *.ttc and *.dfont files. This is the reason why this function
+ * returns an array.
+ *
+ * <p>The implementation reads data from the buffer only when
+ * needed. Therefore, it greatly increases efficiency if
+ * <code>buf</code> has been obtained through mapping a file into
+ * the virtual address space.
+ *
+ * @throws FontFormatException if the font data is not in one of the
+ * known formats.
+ */
+ public static FontDelegate[] createFonts(ByteBuffer buf)
+ throws FontFormatException
+ {
+ OpenTypeFont[] fonts;
+ int version;
+
+ version = buf.getInt(0);
+ switch (version)
+ {
+ case 0x00010000: // Microsoft Windows TrueType
+ case OpenType.TAG_TYP1: // Apple MacOS PostScript ('typ1')
+ case OpenTypeFont.TAG_SFNT: // Apple MacOS TrueType ('sfnt')
+ case OpenTypeFont.TAG_TRUE: // Apple MacOS TrueType ('true')
+ case OpenTypeFont.TAG_OTTO: // OpenType
+ return new OpenTypeFont[] { new OpenTypeFont(buf, 0) };
+ }
+
+
+ /* TrueType Collection, see "TrueType Collections" in
+ * http://partners.adobe.com/asn/tech/type/opentype/otff.html
+ */
+ if (version == OpenTypeFont.TAG_TTCF)
+ {
+ // This code has never been tested.
+ fonts = new OpenTypeFont[buf.getInt(8)];
+ for (int i = 0; i < fonts.length; i++)
+ fonts[i] = new OpenTypeFont(buf, buf.getInt(16 + 4 * i));
+ return fonts;
+ }
+
+
+ /* The MacOS X .dfont format is a Macintosh resource fork in
+ * a normal file, contaning one or several 'sfnt' resources.
+ * Unfortunately, MacOS resource forks have no magic code
+ * that could be used for identification. Instead, we just try
+ * to extract at least one 'sfnt'.
+ */
+ try
+ {
+ MacResourceFork fork = new MacResourceFork(buf);
+ MacResourceFork.Resource[] rsrc;
+
+ rsrc = fork.getResources(OpenTypeFont.TAG_SFNT);
+ fonts = new OpenTypeFont[rsrc.length];
+ for (int i = 0; i < fonts.length; i++)
+ fonts[i] = new OpenTypeFont(rsrc[i].getContent(), 0);
+
+ return fonts;
+ }
+ catch (Exception ex)
+ {
+ }
+
+ throw new FontFormatException("not in OpenType or TrueType format");
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/opentype/Scaler.java b/libjava/classpath/gnu/java/awt/font/opentype/Scaler.java
new file mode 100644
index 000000000..c7582b666
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/opentype/Scaler.java
@@ -0,0 +1,205 @@
+/* Scaler.java -- Common superclass for font scalers.
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.awt.font.opentype;
+
+import gnu.java.awt.font.opentype.truetype.Zone;
+
+import java.awt.geom.AffineTransform;
+import java.awt.geom.GeneralPath;
+import java.awt.geom.Point2D;
+
+
+/**
+ * An common superclass for all font scalers. The main task of font
+ * scaler is to retrieve a scaled and hinted outline for a glyph.
+ *
+ * <p>To make text more legible, high-quality fonts contain
+ * instructions (sometimes also called &#x201c;hints&#x201d;) for
+ * moving the scaled control points towards the coordinate grid of the
+ * display device.
+ *
+ * <p><b>Lack of Thread Safety:</b> Font scalers are intentionally
+ * <i>not</i> safe to access from multiple concurrent
+ * threads. Synchronization needs to be performed externally. Usually,
+ * the font that uses this scaler already has obtained a lock before
+ * calling the scaler.
+ *
+ * @author Sascha Brawer (brawer@dandelis.ch)
+ */
+public abstract class Scaler
+{
+ /**
+ * Retrieves the scaled outline of a glyph, adjusting control points
+ * to the raster grid if necessary.
+ *
+ * @param glyph the glyph number whose outline is retrieved.
+ *
+ * @param pointSize the point size of the font.
+ *
+ * @param transform a transform that is applied in addition to
+ * scaling to the specified point size. This is often used for
+ * scaling according to the device resolution. Those who lack any
+ * aesthetic sense may also use the transform to slant or stretch
+ * glyphs.
+ *
+ * @param antialias whether or not the rasterizer will perform
+ * anti-aliasing on the returned path.
+ *
+ * @param fractionalMetrics <code>false</code> for adjusting glyph
+ * positions to the raster grid of device space.
+ *
+ * @return the scaled and grid-fitted outline of the specified
+ * glyph, or <code>null</code> for bitmap fonts.
+ */
+ public abstract GeneralPath getOutline(int glyph,
+ float pointSize,
+ AffineTransform transform,
+ boolean antialias,
+ boolean fractionalMetrics,
+ Hinter hinter, int type);
+
+
+ /**
+ * Determines the advance width and height for a glyph.
+ *
+ * @param glyphIndex the glyph whose advance width is to be
+ * determined.
+ *
+ * @param pointSize the point size of the font.
+ *
+ * @param transform a transform that is applied in addition to
+ * scaling to the specified point size. This is often used for
+ * scaling according to the device resolution. Those who lack any
+ * aesthetic sense may also use the transform to slant or stretch
+ * glyphs.
+ *
+ * @param antialias <code>true</code> for anti-aliased rendering,
+ * <code>false</code> for normal rendering. For hinted fonts,
+ * this parameter may indeed affect the result.
+ *
+ * @param fractionalMetrics <code>true</code> for fractional metrics,
+ * <code>false</code> for rounding the result to a pixel boundary.
+ *
+ * @param horizontal <code>true</code> for horizontal line layout,
+ * <code>false</code> for vertical line layout.
+ *
+ * @param advance a point whose <code>x</code> and <code>y</code>
+ * fields will hold the advance in each direction. It is well
+ * possible that both values are non-zero, for example for rotated
+ * text or for Urdu fonts.
+ */
+ public abstract void getAdvance(int glyphIndex,
+ float pointSize,
+ AffineTransform transform,
+ boolean antialias,
+ boolean fractionalMetrics,
+ boolean horizontal,
+ Point2D advance);
+
+
+ /**
+ * Determines the distance between the base line and the highest
+ * ascender.
+ *
+ * @param pointSize the point size of the font.
+ *
+ * @param transform a transform that is applied in addition to
+ * scaling to the specified point size. This is often used for
+ * scaling according to the device resolution. Those who lack any
+ * aesthetic sense may also use the transform to slant or stretch
+ * glyphs.
+ *
+ * @param antialias <code>true</code> for anti-aliased rendering,
+ * <code>false</code> for normal rendering. For hinted fonts,
+ * this parameter may indeed affect the result.
+ *
+ * @param fractionalMetrics <code>true</code> for fractional metrics,
+ * <code>false</code> for rounding the result to a pixel boundary.
+ *
+ * @param horizontal <code>true</code> for horizontal line layout,
+ * <code>false</code> for vertical line layout.
+ *
+ * @return the ascent, which usually is a positive number.
+ */
+ public abstract float getAscent(float pointSize,
+ AffineTransform transform,
+ boolean antialias,
+ boolean fractionalMetrics,
+ boolean horizontal);
+
+
+ /**
+ * Determines the distance between the base line and the lowest
+ * descender.
+ *
+ * @param pointSize the point size of the font.
+ *
+ * @param transform a transform that is applied in addition to
+ * scaling to the specified point size. This is often used for
+ * scaling according to the device resolution. Those who lack any
+ * aesthetic sense may also use the transform to slant or stretch
+ * glyphs.
+ *
+ * @param antialiased <code>true</code> for anti-aliased rendering,
+ * <code>false</code> for normal rendering. For hinted fonts,
+ * this parameter may indeed affect the result.
+ *
+ * @param fractionalMetrics <code>true</code> for fractional metrics,
+ * <code>false</code> for rounding the result to a pixel boundary.
+ *
+ * @param horizontal <code>true</code> for horizontal line layout,
+ * <code>false</code> for vertical line layout.
+ *
+ * @return the descent, which usually is a nagative number.
+ */
+ public abstract float getDescent(float pointSize,
+ AffineTransform transform,
+ boolean antialiased,
+ boolean fractionalMetrics,
+ boolean horizontal);
+
+ /**
+ * Returns the raw outline data. This is used for the autofitter atm.
+ *
+ * @param glyph the glyph index
+ * @param transform the transform to apply
+ *
+ * @return the raw glyph outline
+ */
+ public abstract Zone getRawOutline(int glyph, AffineTransform transform);
+}
diff --git a/libjava/classpath/gnu/java/awt/font/opentype/truetype/Fixed.java b/libjava/classpath/gnu/java/awt/font/opentype/truetype/Fixed.java
new file mode 100644
index 000000000..87dfebd41
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/opentype/truetype/Fixed.java
@@ -0,0 +1,176 @@
+/* Fixed.java -- Fixed-point arithmetics for TrueType coordinates.
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.font.opentype.truetype;
+
+import gnu.java.lang.CPStringBuilder;
+
+/**
+ * A utility class for fixed-point arithmetics, where numbers are
+ * represented with 26 dot 6 digits. This representation is used by
+ * TrueType coordinates.
+ *
+ * <p>A good compiler will inline calls of methods in this class.
+ *
+ * @author Sascha Brawer (brawer@dandelis.ch)
+ */
+public final class Fixed
+{
+ public static final int ONE = 1<<6;
+
+
+ /**
+ * The constructor is private so nobody can use it.
+ */
+ private Fixed()
+ {
+ }
+
+
+ /**
+ * Multiplies two fixed-point numbers.
+ */
+ public static int mul(int a, int b)
+ {
+ return (int) ((((long) a) * b) >> 6);
+ }
+
+ public static int mul16(int a, int b)
+ {
+ return (int) ((((long) a) * b) >> 16);
+ }
+
+ public static int div(int a, int b)
+ {
+ return (int) ((((long) a) << 6) / b);
+ }
+
+ public static int div16(int a, int b)
+ {
+ return (int) ((((long) a) << 16) / b);
+ }
+
+ public static int ceil(int a)
+ {
+ return (a + 63) & -64;
+ }
+
+
+ public static int floor(int a)
+ {
+ return a & -64;
+ }
+
+
+ /**
+ * Calculates the length of a fixed-point vector.
+ */
+ public static int vectorLength(int x, int y)
+ {
+ int shift;
+ float fx, fy;
+
+ if (x == 0)
+ return Math.abs(y);
+ else if (y == 0)
+ return Math.abs(x);
+
+ /* Use the FPU. */
+ fx = ((float) x) / 64.0f;
+ fy = ((float) y) / 64.0f;
+ return (int) (Math.sqrt(fx * fx + fy * fy) * 64.0);
+ }
+
+
+ public static int intValue(int f)
+ {
+ return f >> 6;
+ }
+
+
+ public static float floatValue(int f)
+ {
+ return ((float) f) / 64;
+ }
+ public static float floatValue16(int f)
+ {
+ return ((float) f) / 65536;
+ }
+
+ public static double doubleValue(int f)
+ {
+ return ((double) f) / 64;
+ }
+
+
+ public static int valueOf(float f)
+ {
+ return (int) (f * 64);
+ }
+
+
+ public static int valueOf(double d)
+ {
+ return (int) (d * 64);
+ }
+
+ public static int valueOf16(double d)
+ {
+ return (int) (d * (1 << 16));
+ }
+
+ /**
+ * Makes a string representation of a fixed-point number.
+ */
+ public static String toString(int f)
+ {
+ return String.valueOf(floatValue(f));
+ }
+
+
+ public static String toString(int x, int y)
+ {
+ CPStringBuilder sbuf = new CPStringBuilder(40);
+ sbuf.append('(');
+ sbuf.append(((float) x) / 64);
+ sbuf.append(", ");
+ sbuf.append(((float) y) / 64);
+ sbuf.append(')');
+ return sbuf.toString();
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/opentype/truetype/GlyphLoader.java b/libjava/classpath/gnu/java/awt/font/opentype/truetype/GlyphLoader.java
new file mode 100644
index 000000000..8a3c56665
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/opentype/truetype/GlyphLoader.java
@@ -0,0 +1,447 @@
+/* GlyphLoader.java -- Helper for loading TrueType glyph outlines.
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.font.opentype.truetype;
+
+import gnu.java.awt.font.opentype.Hinter;
+
+import java.awt.geom.AffineTransform;
+import java.nio.ByteBuffer;
+
+
+/**
+ * A class for loading scaled and hinted glyph outlines.
+ *
+ * <p><b>Lack of Thread Safety:</b> Glyph loaders are intentionally
+ * <i>not</i> safe to access from multiple concurrent
+ * threads. Synchronization needs to be performed externally. Usually,
+ * the font has already obtained a lock before calling the scaler,
+ * which in turn calls the GlyphLoader. It would thus be wasteful to
+ * acquire additional locks for the GlyphLoader.
+ *
+ * @author Sascha Brawer (brawer@dandelis.ch)
+ */
+final class GlyphLoader
+{
+ /**
+ * A helper object for locating glyph data. GlyphLocator is an
+ * abstract superclass, and there is a concretization for each glyph
+ * location table ('loca') format.
+ */
+ private final GlyphLocator glyphLocator;
+
+
+ /**
+ * A helper object for measuring the advance width and height of a
+ * glyph.
+ */
+ private final GlyphMeasurer glyphMeasurer;
+
+
+ /**
+ * The virtual machine for executing TrueType bytecodes.
+ */
+ private final VirtualMachine vm;
+
+
+ /**
+ * The number of font units in one em. A typical value is 2048,
+ * but this depends on the font.
+ */
+ private final int unitsPerEm;
+
+ private final int[] contourEndPoints;
+ private final byte[] pointFlags;
+
+
+ /**
+ * Constructs a GlyphLoader.
+ */
+ GlyphLoader(GlyphLocator glyphLocator, VirtualMachine vm,
+ int unitsPerEm, int maxContours, int maxPoints,
+ GlyphMeasurer glyphMeasurer)
+ {
+ this.glyphLocator = glyphLocator;
+ this.glyphMeasurer = glyphMeasurer;
+ this.unitsPerEm = unitsPerEm;
+ this.vm = vm;
+
+ contourEndPoints = new int[maxContours];
+ pointFlags = new byte[maxPoints];
+ }
+
+
+ /**
+ * @param glyphIndex the number of the glyph whose outlines are to be
+ * retrieved.
+ */
+ public void loadGlyph(int glyphIndex,
+ double pointSize,
+ AffineTransform transform,
+ boolean antialias,
+ Zone glyphZone, Hinter hinter)
+ {
+ glyphZone.setNumPoints(4);
+ loadSubGlyph(glyphIndex, pointSize, transform, antialias, glyphZone,
+ 0, 0, hinter);
+ }
+
+ public void loadGlyph(int glyphIndex, AffineTransform transform,
+ Zone glyphZone, Hinter hinter)
+ {
+ loadGlyph(glyphIndex, unitsPerEm, transform, false, glyphZone, hinter);
+ }
+
+ private void loadSubGlyph(int glyphIndex,
+ double pointSize,
+ AffineTransform transform,
+ boolean antialias,
+ Zone glyphZone,
+ int preTranslateX,
+ int preTranslateY,
+ Hinter hinter)
+ {
+ ByteBuffer glyph;
+ int numContours;
+ int xMin, yMin, xMax, yMax;
+ byte flag;
+
+ glyph = glyphLocator.getGlyphData(glyphIndex);
+
+ if (glyph == null)
+ {
+ glyphZone.setNumPoints(4);
+ setPhantomPoints(glyphIndex, 0, glyphZone);
+ glyphZone.transform(pointSize, transform, unitsPerEm,
+ preTranslateX, preTranslateY);
+ return;
+ }
+
+ numContours = glyph.getShort();
+ xMin = glyph.getChar();
+ yMin = glyph.getChar();
+ xMax = glyph.getChar();
+ yMax = glyph.getChar();
+
+
+ if (numContours >= 0)
+ loadSimpleGlyph(glyphIndex, pointSize, transform, antialias,
+ numContours, glyph, glyphZone,
+ preTranslateX, preTranslateY, hinter);
+ else
+ loadCompoundGlyph(glyphIndex, pointSize, transform, antialias,
+ glyph, glyphZone,
+ preTranslateX, preTranslateY, hinter);
+ }
+
+
+ private void loadSimpleGlyph(int glyphIndex,
+ double pointSize, AffineTransform transform,
+ boolean antialias,
+ int numContours, ByteBuffer glyph,
+ Zone glyphZone,
+ int preTranslateX, int preTranslateY,
+ Hinter hinter)
+ {
+ int numPoints;
+ int posInstructions, numInstructions;
+ boolean execInstructions;
+
+ execInstructions = vm.setup(pointSize, transform, antialias);
+
+ /* Load the contour end points and determine the number of
+ * points.
+ */
+ for (int i = 0; i < numContours; i++)
+ contourEndPoints[i] = glyph.getChar();
+ if (numContours > 0)
+ numPoints = 1 + contourEndPoints[numContours - 1];
+ else
+ numPoints = 0;
+ glyphZone.setNumPoints(numPoints + 4);
+
+ numInstructions = glyph.getChar();
+ posInstructions = glyph.position();
+ glyph.position(posInstructions + numInstructions);
+ loadFlags(numPoints, glyph);
+ loadCoordinates(numPoints, glyph, glyphZone);
+ for (int i = 0; i < numContours; i++)
+ glyphZone.setContourEnd(contourEndPoints[i], true);
+
+ setPhantomPoints(glyphIndex, numPoints, glyphZone);
+ glyphZone.transform(pointSize, transform, unitsPerEm,
+ preTranslateX, preTranslateY);
+
+ if (execInstructions && hinter != null)
+ {
+ hinter.applyHints(glyphZone);
+ }
+ }
+
+
+ private static final short ARGS_ARE_WORDS = 1;
+ private static final short ARGS_ARE_XY_VALUES = 2;
+ private static final short ROUND_XY_TO_GRID = 4;
+ private static final short WE_HAVE_A_SCALE = 8;
+ private static final short MORE_COMPONENTS = 32;
+ private static final short WE_HAVE_AN_X_AND_Y_SCALE = 64;
+ private static final short WE_HAVE_A_TWO_BY_TWO = 128;
+ private static final short WE_HAVE_INSTRUCTIONS = 256;
+ private static final short USE_MY_METRICS = 512;
+ private static final short OVERLAP_COMPOUND = 1024;
+ private static final short SCALED_COMPONENT_OFFSET = 2048;
+ private static final short UNSCALED_COMPONENT_OFFSET = 4096;
+
+ private void loadCompoundGlyph(int glyphIndex,
+ double pointSize,
+ AffineTransform transform,
+ boolean antialias,
+ ByteBuffer glyph,
+ Zone glyphZone,
+ int preTranslateX, int preTranslateY,
+ Hinter hinter)
+ {
+ short flags;
+ int subGlyphIndex;
+ int metricsGlyphIndex;
+ Zone subGlyphZone = new Zone(glyphZone.getCapacity());
+ int arg1, arg2;
+ double a, b, c, d, e, f;
+ AffineTransform componentTransform = new AffineTransform();
+
+ /* By default, use the metrics of the compound glyph. The default
+ * is overridden if some component glyph has the USE_MY_METRICS
+ * flag set.
+ */
+ metricsGlyphIndex = glyphIndex;
+
+ do
+ {
+ flags = glyph.getShort();
+ subGlyphIndex = glyph.getChar();
+
+ if ((flags & USE_MY_METRICS) != 0)
+ metricsGlyphIndex = subGlyphIndex;
+
+ if ((flags & ARGS_ARE_WORDS) != 0)
+ {
+ arg1 = glyph.getShort();
+ arg2 = glyph.getShort();
+ }
+ else
+ {
+ arg1 = glyph.get();
+ arg2 = glyph.get();
+ }
+
+ if ((flags & WE_HAVE_A_SCALE) != 0)
+ {
+ a = d = getDouble214(glyph);
+ b = c = 0.0;
+ }
+ else if ((flags & WE_HAVE_AN_X_AND_Y_SCALE) != 0)
+ {
+ a = getDouble214(glyph);
+ d = getDouble214(glyph);
+ b = c = 0.0;
+ }
+ else if ((flags & WE_HAVE_A_TWO_BY_TWO) != 0)
+ {
+ a = getDouble214(glyph);
+ b = getDouble214(glyph);
+ c = getDouble214(glyph);
+ d = getDouble214(glyph);
+ }
+ else
+ {
+ a = d = 1.0;
+ b = c = 0.0;
+ }
+
+ double m = Math.max(Math.abs(a), Math.abs(b));
+ double n = Math.max(Math.abs(c), Math.abs(d));
+
+ /* The Apple TrueType specification actually says that m is
+ * multiplied by two if
+ *
+ * abs(abs(a) - abs(c)) <= 33/65536,
+ *
+ * but this is probably a typo. On 2003-07-23, Sascha Brawer
+ * wrote an e-mail message to applefonts@apple.com, asking
+ * whether this might possibly be an error in the specification.
+ */
+ if (Math.abs(Math.abs(a) - Math.abs(b)) <= 33.0/65536.0)
+ m = m * 2;
+
+ if (Math.abs(Math.abs(c) - Math.abs(d)) <= 33.0/65536.0)
+ n = n * 2;
+
+ if ((flags & ARGS_ARE_XY_VALUES) != 0)
+ {
+ e = m * arg1;
+ f = n * arg2;
+ }
+ else
+ e = f = 0.0;
+
+ componentTransform.setTransform(a, b, c, d, 0.0, 0.0);
+
+ // System.out.println("componentTransform = " + componentTransform
+ // + ", e=" + e + ", f=" + f);
+ componentTransform.concatenate(transform);
+
+ int pos = glyph.position();
+ int lim = glyph.limit();
+
+ loadSubGlyph(subGlyphIndex, pointSize, componentTransform,
+ antialias, subGlyphZone,
+ Math.round((float) e + preTranslateX),
+ Math.round(-((float) f + preTranslateY)), hinter);
+ glyphZone.combineWithSubGlyph(subGlyphZone, 4);
+ glyph.limit(lim).position(pos);
+ }
+ while ((flags & MORE_COMPONENTS) != 0);
+
+ setPhantomPoints(metricsGlyphIndex, glyphZone.getSize() - 4, glyphZone);
+ }
+
+
+ private double getDouble214(ByteBuffer buf)
+ {
+ return ((double) buf.getShort()) / (1 << 14);
+ }
+
+
+ /**
+ * Loads the per-point flags of a glyph into the
+ * <code>pointFlags</code> field.
+ */
+ private void loadFlags(int numPoints, ByteBuffer glyph)
+ {
+ byte flag;
+ int numRepetitions;
+
+ for (int i = 0; i < numPoints; i++)
+ {
+ pointFlags[i] = flag = glyph.get();
+ if ((flag & 8) != 0)
+ {
+ numRepetitions = ((int) glyph.get()) & 0xff;
+ while (numRepetitions > 0)
+ {
+ pointFlags[++i] = flag;
+ --numRepetitions;
+ }
+ }
+ }
+ }
+
+
+ private void loadCoordinates(int numPoints, ByteBuffer glyph,
+ Zone glyphZone)
+ {
+ int x, y;
+ byte flag;
+
+ x = 0;
+ for (int i = 0; i < numPoints; i++)
+ {
+ flag = pointFlags[i];
+ if ((flag & 2) == 0)
+ {
+ if ((flag & 16) == 0)
+ x += glyph.getShort();
+ }
+ else
+ {
+ if ((flag & 16) != 0)
+ x += (glyph.get() & 0xff);
+ else
+ x -= (glyph.get() & 0xff);
+ }
+ glyphZone.setOriginalX(i, x);
+ glyphZone.setOnCurve(i, (flag & 1) == 1);
+ }
+
+ y = 0;
+ for (int i = 0; i < numPoints; i++)
+ {
+ flag = pointFlags[i];
+ if ((flag & 4) == 0)
+ {
+ if ((flag & 32) == 0)
+ y += glyph.getShort();
+ }
+ else
+ {
+ if ((flag & 32) != 0)
+ y += (glyph.get() & 0xff);
+ else
+ y -= (glyph.get() & 0xff);
+ }
+ glyphZone.setOriginalY(i, -y);
+ }
+ }
+
+
+ private void setPhantomPoints(int glyphIndex, int numPoints,
+ Zone glyphZone)
+ {
+ /* Phantom point 0: Character origin. */
+ glyphZone.setOriginalX(numPoints, 0);
+ glyphZone.setOriginalY(numPoints, 0);
+
+ /* Phantom point 1: Horizontal advance point. */
+ glyphZone.setOriginalX(numPoints + 1,
+ glyphMeasurer.getAdvanceWidth(glyphIndex, true));
+ glyphZone.setOriginalY(numPoints + 1,
+ glyphMeasurer.getAdvanceHeight(glyphIndex, true));
+
+ /* Phantom point 2: Vertical origin. */
+ int vertX = glyphMeasurer.getAscent(/* vertical */ false);
+ int vertY = glyphMeasurer.getAscent(/* horizontal */ true);
+ glyphZone.setOriginalX(numPoints + 2, vertX);
+ glyphZone.setOriginalY(numPoints + 2, vertY);
+
+ /* Phantom point 3: Vertical advance point. */
+ glyphZone.setOriginalX(numPoints + 3,
+ vertX + glyphMeasurer.getAdvanceWidth(glyphIndex, false));
+ glyphZone.setOriginalY(numPoints + 3,
+ vertY + glyphMeasurer.getAdvanceHeight(glyphIndex, false));
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/opentype/truetype/GlyphLocator.java b/libjava/classpath/gnu/java/awt/font/opentype/truetype/GlyphLocator.java
new file mode 100644
index 000000000..fc2256b15
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/opentype/truetype/GlyphLocator.java
@@ -0,0 +1,187 @@
+/* GlyphLocator.java -- Locates outlines of TrueType glyphs.
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.awt.font.opentype.truetype;
+
+import java.awt.FontFormatException;
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.IntBuffer;
+
+
+/**
+ * Locates glyph outlines in a TrueType or OpenType <code>glyf</code>
+ * table.
+ *
+ * @see <a href=
+ * "http://partners.adobe.com/asn/tech/type/opentype/loca.html"
+ * >Adobe&#x2019;s specification of the OpenType &#x2018;loca&#x2019;
+ * table</a>
+ *
+ * @author Sascha Brawer (brawer@dandelis.ch)
+ */
+abstract class GlyphLocator
+{
+ /**
+ * The actual glyph data of the font, which is contained in the
+ * 'glyf' table.
+ */
+ protected ByteBuffer glyfTable;
+
+
+ /**
+ * Creates a new GlyphLocator for a <code>loca</code> table.
+ *
+ * @param format the format of the <code>loca</code> table. The
+ * value must be 0 for two-byte offsets, or 1 for four-byte
+ * offsets. TrueType and OpenType fonts indicate the format in the
+ * <code>indexToLoc</code> field of the <a href=
+ * "http://partners.adobe.com/asn/tech/type/opentype/head.html"
+ * >font header</a>.
+ *
+ * @param loca the <code>loca</code> table of the font, which
+ * contains the position of each glyph in the <code>glyf</code>
+ * table.
+ *
+ * @param glyf the <code>glyf</code> table of the font, which
+ * contains the outline data of each glyph.
+ *
+ * @throws FontFormatException if <code>format</code> is neither 0
+ * nor 1.
+ */
+ public static GlyphLocator forTable(int format, ByteBuffer loca,
+ ByteBuffer glyf)
+ throws FontFormatException
+ {
+ switch (format)
+ {
+ case 0:
+ return new GlyphLocator.TwoByte(loca, glyf);
+
+ case 1:
+ return new GlyphLocator.FourByte(loca, glyf);
+
+ default:
+ throw new FontFormatException("unsupported loca format");
+ }
+ }
+
+
+ /**
+ * Locates the outline data for a glyph.
+ *
+ * <p>For efficiency, the glyph locator does not create a new buffer
+ * for each invocation. Instead, this method always returns the same
+ * buffer object. Therefore, the data of a glyph must have been read
+ * completely before another glyph of the same font gets requested
+ * through this method.
+ *
+ * @param glyph the number of the glyph whose outlines are to be
+ * retrieved.
+ *
+ * @return a buffer whose position is set to the first byte of glyph
+ * data, and whose limit is set to disallow accessing any data that
+ * does not belong to the glyph. If there is no outline data for the
+ * requested glyph, as would be the case for the space glyph, the
+ * result will be <code>null</code>.
+ */
+ public abstract ByteBuffer getGlyphData(int glyph);
+
+
+ /**
+ * A GlyphLocator that locates glyphs using two-byte offsets,
+ * interpreting <code>loca</code> tables of format 0.
+ *
+ * @author Sascha Brawer (brawer@dandelis.ch)
+ */
+ private final static class TwoByte
+ extends GlyphLocator
+ {
+ final CharBuffer indexToLoc;
+
+ TwoByte(ByteBuffer loca, ByteBuffer glyf)
+ {
+ this.glyfTable = glyf;
+ indexToLoc = loca.asCharBuffer();
+ }
+
+
+ public ByteBuffer getGlyphData(int glyph)
+ {
+ int offset, limit;
+ offset = ((int) indexToLoc.get(glyph)) << 1;
+ limit = ((int) indexToLoc.get(glyph + 1)) << 1;
+ if (offset >= limit)
+ return null;
+
+ glyfTable.limit(limit).position(offset);
+ return glyfTable;
+ }
+ }
+
+
+ /**
+ * A GlyphLocator that locates glyphs using four-byte offsets,
+ * interpreting <code>loca</code> tables of format 1.
+ *
+ * @author Sascha Brawer (brawer@dandelis.ch)
+ */
+ private final static class FourByte
+ extends GlyphLocator
+ {
+ final IntBuffer indexToLoc;
+
+ FourByte(ByteBuffer loca, ByteBuffer glyf)
+ {
+ this.glyfTable = glyf;
+ indexToLoc = loca.asIntBuffer();
+ }
+
+
+ public ByteBuffer getGlyphData(int glyph)
+ {
+ int offset, limit;
+ offset = indexToLoc.get(glyph);
+ limit = indexToLoc.get(glyph + 1);
+ if (offset >= limit)
+ return null;
+
+ glyfTable.limit(limit).position(offset);
+ return glyfTable;
+ }
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/opentype/truetype/GlyphMeasurer.java b/libjava/classpath/gnu/java/awt/font/opentype/truetype/GlyphMeasurer.java
new file mode 100644
index 000000000..452456d13
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/opentype/truetype/GlyphMeasurer.java
@@ -0,0 +1,228 @@
+/* GlyphMeasurer.java -- Helper for measuring TrueType glyphs.
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.font.opentype.truetype;
+
+import java.awt.FontFormatException;
+import java.nio.ByteBuffer;
+import java.nio.ShortBuffer;
+
+
+/**
+ * A class for measuring TrueType and OpenType glyphs.
+ *
+ * <p><b>Lack of Thread Safety:</b> Glyph measurers are intentionally
+ * <i>not</i> safe to access from multiple concurrent
+ * threads. Synchronization needs to be performed externally. Usually,
+ * the font has already obtained a lock before calling the scaler,
+ * which in turn calls the GlyphMeasurer. It would thus be wasteful to
+ * acquire additional locks for the GlyphMeasurer.
+ *
+ * @author Sascha Brawer (brawer@dandelis.ch)
+ */
+final class GlyphMeasurer
+{
+ /**
+ * A view buffer that allows accessing the contents of the
+ * font&#x2019;s <code>hmtx</code> table as shorts.
+ */
+ private final ShortBuffer horizontalGlyphMetrics;
+
+
+ /**
+ * A view buffer that allows accessing the contents of the
+ * font&#x2019;s <code>vmtx</code> table as shorts.
+ */
+ private final ShortBuffer verticalGlyphMetrics;
+
+
+ private final int numLongHorizontalMetricsEntries;
+ private final int numLongVerticalMetricsEntries;
+
+ private final int horizontalAscent;
+ private final int verticalAscent;
+
+ private final int horizontalDescent;
+ private final int verticalDescent;
+
+ private final int horizontalLineGap;
+
+
+ /**
+ * Constructs a GlyphMeasurer from TrueType/OpenType font tables.
+ *
+ * @param hhea the <code>hhea</code> table, which contains
+ * information about horizontal metrics that is common to all
+ * glyphs.
+ *
+ * @param hmtx the <code>hmtx</code> table, which contains
+ * glyph-specific information about horizontal metrics.
+ *
+ * @param vhea the <code>vhea</code> table, which contains
+ * information about vertical metrics that is common to all
+ * glyphs. If a font does not provide such a table, pass
+ * <code>null</code>.
+ *
+ * @param vmtx the <code>vmtx</code> table, which contains
+ * glyph-specific information about vertical metrics. If a font
+ * does not provide such a table, pass <code>null</code>.
+ */
+ GlyphMeasurer(ByteBuffer hhea, ByteBuffer hmtx,
+ ByteBuffer vhea, ByteBuffer vmtx)
+ throws FontFormatException
+ {
+ if ((hhea.getInt(0) != 0x00010000) || (hhea.getInt(30) != 0))
+ throw new FontFormatException("unsupported hhea format");
+
+ horizontalAscent = hhea.getShort(4);
+ horizontalDescent = hhea.getShort(6);
+ horizontalLineGap = hhea.getShort(8);
+
+ numLongHorizontalMetricsEntries = hhea.getChar(34);
+ horizontalGlyphMetrics = hmtx.asShortBuffer();
+
+ if (vhea != null)
+ {
+ verticalAscent = vhea.getShort(4);
+ verticalDescent = vhea.getShort(6);
+ numLongVerticalMetricsEntries = vhea.getChar(34);
+ verticalGlyphMetrics = vmtx.asShortBuffer();
+ }
+ else
+ {
+ verticalAscent = /* advanceWidthMax */ hhea.getChar(10) / 2;
+ verticalDescent = -verticalAscent;
+ numLongVerticalMetricsEntries = 0;
+ verticalGlyphMetrics = null;
+ }
+ }
+
+
+ /**
+ * Returns the distance from the baseline to the highest ascender.
+ *
+ * @param horizontal <code>true</code> for horizontal line layout,
+ * <code>false</code> for vertical line layout.
+ *
+ * @return the maximal ascent, in font units.
+ */
+ public int getAscent(boolean horizontal)
+ {
+ return horizontal ? horizontalAscent : verticalAscent;
+ }
+
+
+ /**
+ * Returns the distance from the baseline to the lowest descender.
+ *
+ * @param horizontal <code>true</code> for horizontal line layout,
+ * <code>false</code> for vertical line layout.
+ *
+ * @return the maximal descent, in font units.
+ */
+ public int getDescent(boolean horizontal)
+ {
+ return horizontal ? horizontalDescent : verticalDescent;
+ }
+
+
+ /**
+ * Returns the typographic line gap.
+ *
+ * @param horizontal <code>true</code> for horizontal line layout,
+ * <code>false</code> for vertical line layout.
+ *
+ * @return the line gap, in font units.
+ */
+ public int getLineGap(boolean horizontal)
+ {
+ return horizontalLineGap;
+ }
+
+
+ /**
+ * Determines the advance width of a glyph, without considering
+ * hinting.
+ *
+ * @param glyphIndex the index of the glyph whose advance width is
+ * to be determined.
+ *
+ * @param horizontal <code>true</code> for horizontal line layout,
+ * <code>false</code> for vertical line layout.
+ *
+ * @return the advance width, in font units.
+ */
+ public int getAdvanceWidth(int glyphIndex, boolean horizontal)
+ {
+ if (!horizontal)
+ return 0;
+
+ glyphIndex = Math.min(glyphIndex,
+ numLongHorizontalMetricsEntries - 1);
+ return horizontalGlyphMetrics.get(glyphIndex << 1);
+ }
+
+
+ /**
+ * Determines the advance width of a glyph, without considering
+ * hinting.
+ *
+ * @param glyphIndex the index of the glyph whose advance width is
+ * to be determined.
+ *
+ * @param horizontal <code>true</code> for horizontal line layout,
+ * <code>false</code> for vertical line layout.
+ *
+ * @return the advance width, in font units.
+ */
+ public int getAdvanceHeight(int glyphIndex, boolean horizontal)
+ {
+ if (horizontal)
+ return 0;
+
+ /* If a font does not provide vertical glyph metrics, advance
+ * by the height of one horizontal line.
+ */
+ if (verticalGlyphMetrics == null)
+ return horizontalAscent - horizontalDescent + horizontalLineGap;
+
+ glyphIndex = Math.min(glyphIndex,
+ numLongVerticalMetricsEntries - 1);
+ return verticalGlyphMetrics.get(glyphIndex << 1);
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/opentype/truetype/Point.java b/libjava/classpath/gnu/java/awt/font/opentype/truetype/Point.java
new file mode 100644
index 000000000..438eb6558
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/opentype/truetype/Point.java
@@ -0,0 +1,287 @@
+/* Point.java -- Holds information for one point on a glyph outline
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.awt.font.opentype.truetype;
+
+import gnu.java.lang.CPStringBuilder;
+
+/**
+ * Encapsulates information regarding one point on a glyph outline.
+ */
+public class Point
+{
+ public static final short FLAG_TOUCHED_X = 1;
+ public static final short FLAG_TOUCHED_Y = 2;
+ public static final short FLAG_ON_CURVE = 4;
+ public static final short FLAG_CONTOUR_END = 8;
+ public static final short FLAG_WEAK_INTERPOLATION = 16;
+ public static final short FLAG_INFLECTION = 32;
+ public static final short FLAG_DONE_X = 64;
+ public static final short FLAG_DONE_Y = 128;
+
+ /**
+ * Right direction.
+ */
+ public static final int DIR_RIGHT = 1;
+
+ /**
+ * Left direction.
+ */
+ public static final int DIR_LEFT = -1;
+
+ /**
+ * Up direction.
+ */
+ public static final int DIR_UP = 2;
+
+ /**
+ * Down direction.
+ */
+ public static final int DIR_DOWN = -2;
+
+ /**
+ * The original x coordinate in font units.
+ */
+ int origX;
+
+ /**
+ * The original y coordinate in font units.
+ */
+ int origY;
+
+ /**
+ * The x coordinate scaled to the target.
+ */
+ int scaledX;
+
+ /**
+ * The y coordinate scaled to the target.
+ */
+ int scaledY;
+
+ /**
+ * The final hinted and scaled x coordinate.
+ */
+ int x;
+
+ /**
+ * The final hinted and scaled y coordinate.
+ */
+ int y;
+
+ int u;
+ int v;
+
+ /**
+ * The glyph flags.
+ */
+ short flags;
+
+ /**
+ * The previous point in the contour.
+ */
+ private Point prev;
+
+ /**
+ * The next point in the contour.
+ */
+ private Point next;
+
+ /**
+ * The in-direction of the point, according to the DIR_* constants of this
+ * class.
+ */
+ int inDir;
+
+ /**
+ * The out-direction of the point, according to the DIR_* constants of this
+ * class.
+ */
+ int outDir;
+
+ public Point getNext()
+ {
+ return next;
+ }
+
+ public void setNext(Point next)
+ {
+ this.next = next;
+ }
+
+ public Point getPrev()
+ {
+ return prev;
+ }
+
+ public void setPrev(Point prev)
+ {
+ this.prev = prev;
+ }
+
+ public int getOrigX()
+ {
+ return origX;
+ }
+
+ public void setOrigX(int origX)
+ {
+ this.origX = origX;
+ }
+
+ public int getOrigY()
+ {
+ return origY;
+ }
+
+ public void setOrigY(int origY)
+ {
+ this.origY = origY;
+ }
+
+ public int getInDir()
+ {
+ return inDir;
+ }
+
+ public void setInDir(int inDir)
+ {
+ this.inDir = inDir;
+ }
+
+ public int getOutDir()
+ {
+ return outDir;
+ }
+
+ public void setOutDir(int outDir)
+ {
+ this.outDir = outDir;
+ }
+
+ public short getFlags()
+ {
+ return flags;
+ }
+
+ public void setFlags(short flags)
+ {
+ this.flags = flags;
+ }
+
+ public void addFlags(short flags)
+ {
+ this.flags |= flags;
+ }
+
+ public boolean isControlPoint()
+ {
+ return (flags & FLAG_ON_CURVE) == 0;
+ }
+
+ public int getU()
+ {
+ return u;
+ }
+
+ public void setU(int u)
+ {
+ this.u = u;
+ }
+
+ public int getV()
+ {
+ return v;
+ }
+
+ public void setV(int v)
+ {
+ this.v = v;
+ }
+
+ public String toString()
+ {
+ CPStringBuilder s = new CPStringBuilder();
+ s.append("[Point] origX: ");
+ s.append(origX);
+ s.append(", origY: ");
+ s.append(origY);
+ // TODO: Add more info when needed.
+ return s.toString();
+ }
+
+ public int getX()
+ {
+ return x;
+ }
+
+ public void setX(int x)
+ {
+ this.x = x;
+ }
+
+ public int getY()
+ {
+ return y;
+ }
+
+ public void setY(int y)
+ {
+ this.y = y;
+ }
+
+ public int getScaledX()
+ {
+ return scaledX;
+ }
+
+ public void setScaledX(int scaledX)
+ {
+ this.scaledX = scaledX;
+ }
+
+ public int getScaledY()
+ {
+ return scaledY;
+ }
+
+ public void setScaledY(int scaledY)
+ {
+ this.scaledY = scaledY;
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/opentype/truetype/TrueTypeScaler.java b/libjava/classpath/gnu/java/awt/font/opentype/truetype/TrueTypeScaler.java
new file mode 100644
index 000000000..1d5c53f9d
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/opentype/truetype/TrueTypeScaler.java
@@ -0,0 +1,380 @@
+/* TrueTypeScaler.java -- Font scaler for TrueType outlines.
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.awt.font.opentype.truetype;
+
+import gnu.java.awt.font.opentype.Hinter;
+import gnu.java.awt.font.opentype.Scaler;
+
+import java.awt.FontFormatException;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.GeneralPath;
+import java.awt.geom.Point2D;
+import java.nio.ByteBuffer;
+
+
+/**
+ * A scaler for fonts whose outlines are described in the TrueType
+ * format.
+ *
+ * <p><b>Lack of Thread Safety:</b> Font scalers are intentionally
+ * <i>not</i> safe to access from multiple concurrent threads.
+ * Synchronization needs to be performed externally. Usually, the font
+ * that uses this scaler already has obtained a lock before calling
+ * the scaler.
+ *
+ * @author Sascha Brawer (brawer@dandelis.ch)
+ */
+public final class TrueTypeScaler
+ extends Scaler
+{
+ /**
+ * The TrueType or OpenType table that contains the glyph outlines.
+ */
+ private ByteBuffer glyfTable;
+
+
+ /**
+ * A helper object for loading glyph outlines.
+ */
+ private GlyphLoader glyphLoader;
+
+
+ /**
+ * A helper object for measuring the advance width and height of a
+ * glyph.
+ */
+ private final GlyphMeasurer glyphMeasurer;
+
+ private final Zone glyphZone;
+
+
+ /**
+ * The number of units per em. A typical value is 2048, but some
+ * font use other numbers as well.
+ */
+ private int unitsPerEm;
+
+
+ /**
+ * Constructs a new TrueTypeScaler.
+ *
+ * @param unitsPerEm the number of font units per em. This value can
+ * be retrieved from the font&#x2019;s <code>head</code> table.
+ *
+ * @param maxp the <code>maxp</code> table of the font, which
+ * contains various constants needed for setting up the virtual
+ * machine that interprets TrueType bytecodes.
+ *
+ * @param controlValueTable the <code>cvt</code> table of the font,
+ * which contains the initial values of the control value table.
+ *
+ * @param fpgm the <code>fpgm</code> table of the font, which
+ * contains a font program that is executed exactly once. The
+ * purpose of the font program is to define functions and to patch
+ * the interpreter.
+ *
+ * @param locaFormat the format of the <code>loca</code> table. The
+ * value must be 0 for two-byte offsets, or 1 for four-byte
+ * offsets. TrueType and OpenType fonts indicate the format in the
+ * <code>indexToLoc</code> field of the <a href=
+ * "http://partners.adobe.com/asn/tech/type/opentype/head.html"
+ * >font header</a>.
+ *
+ * @param loca the <code>loca</code> table of the font, which
+ * contains for each glyph the offset of its outline data
+ * in <code>glyf</code>.
+ *
+ * @param glyf the <code>glyf</code> table of the font, which
+ * contains the outline data for all glyphs in the font.
+ *
+ * @param preProgram the <code>prep</code> table of the font, which
+ * contains a program that is executed whenever the point size or
+ * the device transform have changed. This program is called
+ * pre-program because it gets executed before the instructions of
+ * the individual glyphs. If the font does not contain a
+ * pre-program, pass <code>null</code>.
+ *
+ * @throws FontFormatException if <code>format</code> is neither 0
+ * nor 1.
+ */
+ public TrueTypeScaler(int unitsPerEm,
+ ByteBuffer hhea,
+ ByteBuffer htmx,
+ ByteBuffer vhea,
+ ByteBuffer vtmx,
+ ByteBuffer maxp,
+ ByteBuffer controlValueTable,
+ ByteBuffer fpgm,
+ int locaFormat, ByteBuffer loca,
+ ByteBuffer glyf,
+ ByteBuffer preProgram)
+ throws FontFormatException
+ {
+ int maxContours, maxPoints;
+ VirtualMachine vm;
+
+ maxContours = Math.max(/* maxContours */ (int) maxp.getChar(8),
+ /* maxCompositeContours */ (int) maxp.getChar(12))
+ + /* fix for some broken fonts */ 8;
+ maxPoints = Math.max(/* maxPoints */ (int) maxp.getChar(6),
+ /* maxCompositePoints */ (int) maxp.getChar(10))
+ + /* fix for some broken fonts */ 12;
+
+
+ glyphZone = new Zone(maxPoints + /* four phantom points */ 4);
+ this.glyfTable = glyf;
+ vm = new VirtualMachine(unitsPerEm, maxp,
+ controlValueTable, fpgm,
+ preProgram);
+
+ GlyphLocator locator = GlyphLocator.forTable(locaFormat, loca, glyf);
+ glyphMeasurer = new GlyphMeasurer(hhea, htmx, vhea, vtmx);
+ glyphLoader = new GlyphLoader(locator, vm, unitsPerEm,
+ maxContours, maxPoints,
+ glyphMeasurer);
+
+ this.unitsPerEm = unitsPerEm;
+ }
+
+
+ /**
+ * Retrieves the scaled outline of a glyph, adjusting control points
+ * to the raster grid if necessary.
+ *
+ * @param glyphIndex the glyph number whose outline is retrieved.
+ *
+ * @param pointSize the point size for the glyph.
+ *
+ * @param deviceTransform an affine transformation for the device.
+ *
+ * @param antialias whether or not the rasterizer will perform
+ * anti-aliasing on the returned path.
+ *
+ * @param fractionalMetrics <code>false</code> for adjusting glyph
+ * positions to the raster grid of device space.
+ */
+ public GeneralPath getOutline(int glyphIndex,
+ float pointSize,
+ AffineTransform deviceTransform,
+ boolean antialias,
+ boolean fractionalMetrics, Hinter hinter,
+ int type)
+ {
+ glyphLoader.loadGlyph(glyphIndex, pointSize, deviceTransform,
+ antialias, glyphZone, hinter);
+ return glyphZone.getPath(type);
+ }
+
+ public Zone getRawOutline(int glyphIndex, AffineTransform transform)
+ {
+ Zone zone = new Zone(glyphZone.getCapacity());
+ glyphLoader.loadGlyph(glyphIndex, transform, zone, null);
+ return zone;
+ }
+
+ /**
+ * Determines the advance width and height for a glyph.
+ *
+ * @param glyphIndex the glyph whose advance width and height is to
+ * be determined.
+ *
+ * @param pointSize the point size of the font.
+ *
+ * @param transform a transform that is applied in addition to
+ * scaling to the specified point size. This is often used for
+ * scaling according to the device resolution. Those who lack any
+ * aesthetic sense may also use the transform to slant or stretch
+ * glyphs.
+ *
+ * @param antialias <code>true</code> for anti-aliased rendering,
+ * <code>false</code> for normal rendering. For hinted fonts,
+ * this parameter may indeed affect the result.
+ *
+ * @param fractionalMetrics <code>true</code> for fractional metrics,
+ * <code>false</code> for rounding the result to a pixel boundary.
+ *
+ * @param horizontal <code>true</code> for horizontal line layout,
+ * <code>false</code> for vertical line layout.
+ *
+ * @param advance a point whose <code>x</code> and <code>y</code>
+ * fields will hold the advance in each direction. It is possible
+ * that both values are non-zero, for example if
+ * <code>transform</code> is a rotation, or in the case of Urdu
+ * fonts.
+ */
+ public void getAdvance(int glyphIndex,
+ float pointSize,
+ AffineTransform transform,
+ boolean antialias,
+ boolean fractionalMetrics,
+ boolean horizontal,
+ Point2D advance)
+ {
+ double x, y;
+ double scaleFactor = (double) pointSize / unitsPerEm;
+
+ /* FIXME: Should grid-fit if needed. Also, use cache if present
+ * in the font.
+ */
+ advance.setLocation(
+ scaleFactor * glyphMeasurer.getAdvanceWidth(glyphIndex, horizontal),
+ scaleFactor * glyphMeasurer.getAdvanceHeight(glyphIndex, horizontal));
+
+ transform.transform(advance, advance);
+ }
+
+
+ /**
+ * Scales a value from font units to pixels, given the point size
+ * and the transform.
+ *
+ * @param pointSize the point size of the font.
+ *
+ * @param transform a transform that is applied in addition to
+ * scaling to the specified point size. This is often used for
+ * scaling according to the device resolution.
+ *
+ * @param fractionalMetrics <code>true</code> for fractional
+ * metrics, <code>false</code> for rounding the result to a pixel
+ * boundary.
+ *
+ * @param horizontal <code>true</code> if the <code>funits</code>
+ * value is along the x axis, <code>false</code> if it is along the
+ * y axis.
+ */
+ private float scaleFromFUnits(int funits,
+ float pointSize,
+ AffineTransform transform,
+ boolean fractionalMetrics,
+ boolean horizontal)
+ {
+ double s;
+
+ s = (double) pointSize / unitsPerEm;
+ if (transform != null)
+ s *= horizontal ? transform.getScaleY() : transform.getScaleX();
+ s *= funits;
+ if (!fractionalMetrics)
+ s = Math.round(s);
+ return (float) s;
+ }
+
+
+ /**
+ * Determines the distance between the base line and the highest
+ * ascender.
+ *
+ * @param pointSize the point size of the font.
+ *
+ * @param transform a transform that is applied in addition to
+ * scaling to the specified point size. This is often used for
+ * scaling according to the device resolution. Those who lack any
+ * aesthetic sense may also use the transform to slant or stretch
+ * glyphs.
+ *
+ * @param antialias <code>true</code> for anti-aliased rendering,
+ * <code>false</code> for normal rendering. For hinted fonts,
+ * this parameter may indeed affect the result.
+ *
+ * @param fractionalMetrics <code>true</code> for fractional metrics,
+ * <code>false</code> for rounding the result to a pixel boundary.
+ *
+ * @param horizontal <code>true</code> for horizontal line layout,
+ * <code>false</code> for vertical line layout.
+ *
+ * @return the ascent, which usually is a positive number.
+ */
+ public float getAscent(float pointSize,
+ AffineTransform transform,
+ boolean antialias,
+ boolean fractionalMetrics,
+ boolean horizontal)
+ {
+ /* Note that the ascent is orthogonal to the direction of line
+ * layout: If the line direction is horizontal, the measurement of
+ * ascent is along the vertical axis, and vice versa.
+ */
+ return scaleFromFUnits(glyphMeasurer.getAscent(horizontal),
+ pointSize,
+ transform,
+ fractionalMetrics,
+ /* reverse */ !horizontal);
+ }
+
+
+ /**
+ * Determines the distance between the base line and the lowest
+ * descender.
+ *
+ * @param pointSize the point size of the font.
+ *
+ * @param transform a transform that is applied in addition to
+ * scaling to the specified point size. This is often used for
+ * scaling according to the device resolution. Those who lack any
+ * aesthetic sense may also use the transform to slant or stretch
+ * glyphs.
+ *
+ * @param antialiased <code>true</code> for anti-aliased rendering,
+ * <code>false</code> for normal rendering. For hinted fonts,
+ * this parameter may indeed affect the result.
+ *
+ * @param fractionalMetrics <code>true</code> for fractional metrics,
+ * <code>false</code> for rounding the result to a pixel boundary.
+ *
+ * @param horizontal <code>true</code> for horizontal line layout,
+ * <code>false</code> for vertical line layout.
+ *
+ * @return the descent, which usually is a nagative number.
+ */
+ public float getDescent(float pointSize,
+ AffineTransform transform,
+ boolean antialiased,
+ boolean fractionalMetrics,
+ boolean horizontal)
+ {
+ /* Note that the descent is orthogonal to the direction of line
+ * layout: If the line direction is horizontal, the measurement of
+ * descent is along the vertical axis, and vice versa.
+ */
+ return scaleFromFUnits(glyphMeasurer.getDescent(horizontal),
+ pointSize,
+ transform,
+ fractionalMetrics,
+ /* reverse */ !horizontal);
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/opentype/truetype/VirtualMachine.java b/libjava/classpath/gnu/java/awt/font/opentype/truetype/VirtualMachine.java
new file mode 100644
index 000000000..512c39ffd
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/opentype/truetype/VirtualMachine.java
@@ -0,0 +1,1815 @@
+/* VirtualMachine.java -- Virtual machine for TrueType bytecodes.
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.awt.font.opentype.truetype;
+
+import gnu.java.lang.CPStringBuilder;
+
+import java.awt.FontFormatException;
+import java.awt.geom.AffineTransform;
+import java.nio.ByteBuffer;
+import java.nio.ShortBuffer;
+
+
+/**
+ * A virtual machine for interpreting TrueType bytecodes.
+ *
+ * <p><b>Lack of Thread Safety:</b> The virtual machine is
+ * intentionally <i>not</i> safe to access from multiple concurrent
+ * threads. Synchronization needs to be performed externally. Usually,
+ * the font has already obtained a lock before calling the scaler,
+ * which in turn calls the VM. It would be wasteful to acquire
+ * additional locks for the VM.
+ *
+ * <p><b>Implementation Status:</b> The current implementation can
+ * execute pre-programs of fonts, but it does not yet actually move
+ * any points. Control flow and arithmeti instructions are
+ * implemented, but most geometric instructions are not working
+ * yet. So, the VirtualMachine class is currently a no-op. However,
+ * not very much is missing. You are more than welcome to complete the
+ * implementation.
+ *
+ * <p><b>Patents:</b> Apple Computer holds three United States Patents
+ * for the mathematical algorithms that are used by TrueType
+ * instructions. The monopoly granted by these patents will expire in
+ * October 2009. Before the expiration date, a license must be
+ * obtained from Apple Computer to use the patented technology inside
+ * the United States. For other countries, different dates might
+ * apply, or no license might be needed.
+ *
+ * <p>The default build of this class does not use the patented
+ * algorithms. If you have obtained a license from Apple, or if the
+ * patent protection has expired, or if no license is required for
+ * your contry, you can set a flag in the source file which will
+ * enable the use of the patented mathematical algorithms.</p>
+ *
+ * <p>The relevant patents are listed subsequently.</p>
+ *
+ * <p><ol><li>United States Patent 5155805, <i>Method and Apparatus
+ * for Moving Control Points in Displaying Digital Typeface on Raster
+ * Output Devices,</i> invented by Sampo Kaasila, assigned to Apple
+ * Computer. Filing date: May 8, 1989. Date of patent: October 13,
+ * 1992.</li>
+ *
+ * <li>United States Patent 5159668, <i>Method and Apparatus for
+ * Manipulating Outlines in Improving Digital Typeface on Raster
+ * Output Devices,</i> invented by Sampo Kaasila, assigned to Apple
+ * Computer. Filing date: May 8, 1989. Date of patent: October 27,
+ * 1992.</li>
+ *
+ * <li>United States Patent 5325479, <i>Method and Apparatus for
+ * Moving Control Points in Displaying Digital Typeface on Raster
+ * Output Devices,</i> invented by Sampo Kaasila, assigned to Apple
+ * Computer. Filing date: May 28, 1989. Date of patent: June 28, 1994
+ * (with a statement that &#x201c;[t]he portion of the term of this
+ * patent subsequent to Oct. 13, 2009 has been
+ * disclaimed&#x201d;).</li></ol>
+ *
+ * @author Sascha Brawer (brawer@dandelis.ch)
+ */
+class VirtualMachine
+{
+ /**
+ * Indicates whether or not to perform hinting operations that are
+ * protected by a number of US patents, two of which will expire on
+ * October 13, 2009, and one of which will expire on October 27,
+ * 2009.
+ */
+ private final static boolean PATENTED_HINTING = false;
+
+
+ /**
+ * Indicates whether the execution of the Virtual Machine is traced
+ * to System.out.
+ */
+ private final static boolean TRACE_EXECUTION = false;
+
+
+ /**
+ * The value 1 in 2-dot-14 fixed notation.
+ */
+ private static final short ONE_214 = 0x4000; // 1 << 14
+
+
+ /**
+ * The storage area of the virtual machine.
+ */
+ private final int[] storage;
+
+
+ /**
+ * The stack. The stack grows from bottom to top, so
+ * <code>sp[0]</code> gets used before <code>sp[1]</code>.
+ */
+ private int[] stack;
+
+
+ /**
+ * The maximum number of stack elements.
+ */
+ private final int maxStackElements;
+
+
+ /**
+ * The current stack pointer of the virtual machine.
+ */
+ private int sp;
+
+
+ /**
+ * fdefBuffer[i] is the buffer that contains the TrueType
+ * instructions of function #i. Most of the time, functions are
+ * defined in the font program, but a font may also re-define
+ * functions in its CVT program.
+ */
+ private ByteBuffer[] fdefBuffer;
+
+
+ /**
+ * fdefEntryPoint[i] is the position in fdefBuffer[i] where the
+ * first TrueType instruction after the FDEF is located.
+ */
+ private int[] fdefEntryPoint;
+
+
+ /**
+ * The original Control Value Table, sometimes abbreviated as CVT.
+ * The table contains signed 16-bit FUnits. Some fonts have no CVT,
+ * in which case the field will be <code>null</code>.
+ */
+ private ShortBuffer controlValueTable;
+
+
+ /**
+ * The scaled values inside the control value table.
+ */
+ private int[] cvt;
+
+
+ /**
+ * A value that is used by rounding operations to compensate for dot
+ * gain.
+ */
+ private int engineCompensation = 0;
+
+
+ /**
+ * The contents of the font&#x2019;s <code>fpgm</code> table, or
+ * <code>null</code> after the font program has been executed once.
+ */
+ private ByteBuffer fontProgram;
+
+
+ /**
+ * The <code>prep</code> table of the font, which contains a program
+ * that is executed whenever the point size or the device transform
+ * have changed. This program is called pre-program because it gets
+ * executed before the instructions of the individual glyphs. If
+ * the font does not contain a pre-program, the value of this field
+ * is <code>null</code>.
+ */
+ private ByteBuffer preProgram;
+
+
+ /**
+ * The number of points in the Twilight Zone.
+ */
+ private int numTwilightPoints;
+
+
+ /**
+ * The current point size of the scaled font. The value is in Fixed
+ * 26.6 notation.
+ */
+ private int pointSize; // 26.6
+
+ private AffineTransform deviceTransform;
+
+ private int scaleX, scaleY, shearX, shearY; // 26.6
+
+
+ /**
+ * Indicates whether or not scan-line conversion will use
+ * anti-aliasing (with gray levels). Font programs can ask for this
+ * value with the <code>GETINFO</code> instruction, and some
+ * programs may behave differently according to this setting.
+ */
+ private boolean antialiased;
+
+
+ /* Graphics State. FIXME: Move this to its own class? Some
+ * documentation would not hurt, either.
+ */
+ private int cvtCutIn; // 26.6
+ private int deltaBase; // uint32
+ private int deltaShift; // uint32
+ private short freeX; // 2.14
+ private short freeY; // 2.14
+ private int loop; // int
+ private int minimumDistance; // 26.6
+ private short projX; // 2.14
+ private short projY; // 2.14
+ private short dualX; // 2.14
+ private short dualY; // 2.14
+ private int rp0, rp1, rp2; // point numbers
+ private boolean scanControl;
+ private int scanType;
+ private int singleWidthValue; // 26.6
+ private Zone zp0, zp1, zp2;
+
+ private Zone twilightZone;
+ private Zone glyphZone;
+
+
+ /**
+ * Indicates whether or not the instructions that are associated
+ * with individual glyphs shall be executed. Set as a side effect
+ * of executing the pre-program when the point size, device
+ * transform or some other relevant parameter have changed.
+ */
+ private boolean executeGlyphInstructions;
+
+
+ /**
+ * Indicates whether to ignore any modifications to the control
+ * value table that the font&#x2019;s pre-program might have
+ * performed. Set as a side effect of executing the pre-program
+ * when the point size, device transform or some other relevant
+ * parameter have changed.
+ */
+ private boolean ignoreCVTProgram;
+
+
+ /**
+ * The length of the space between rounded values. A value
+ * of zero means that rounding has been switched off.
+ */
+ private int roundPeriod; // 26.6
+
+
+ /**
+ * The offset of the rounded values from multiples of
+ * <code>roundPeriod</code>.
+ */
+ private int roundPhase; // 26.6
+
+
+ private int roundThreshold; // 26.6
+
+
+ /**
+ * A cache for the number of pixels per EM. The value is a normal
+ * integer, not a fixed point notation.
+ *
+ * @see #getPixelsPerEM()
+ */
+ private int cachedPixelsPerEM;
+
+
+ /**
+ * The number of font units per EM.
+ */
+ private int unitsPerEm;
+
+
+ /**
+ * Constructs a new Virtual Machine for executing TrueType
+ * instructions.
+ *
+ * @param unitsPerEm the number of font units in one typographic
+ * em.
+ *
+ * @param preProgram the <code>prep</code> table of the font, which
+ * contains a program that is executed whenever the point size or
+ * the device transform have changed. This program is called
+ * pre-program because it gets executed before the instructions of
+ * the individual glyphs. If the font does not contain a
+ * pre-program, pass <code>null</code>.
+ */
+ VirtualMachine(int unitsPerEm,
+ ByteBuffer maxp,
+ ByteBuffer controlValueTable,
+ ByteBuffer fontProgram,
+ ByteBuffer preProgram)
+ throws FontFormatException
+ {
+ int maxStorage, numFunctionDefs, maxInstructionDefs;
+
+ if (maxp.getInt(0) != 0x00010000)
+ throw new FontFormatException("unsupported maxp version");
+
+ this.unitsPerEm = unitsPerEm;
+ maxStorage = maxp.getChar(18);
+
+ /* FreeType says that there exist some broken fonts (like
+ * "Keystrokes MT") that contain function defs, but have a zero
+ * value in their maxp table.
+ */
+ numFunctionDefs = maxp.getChar(20);
+ if (numFunctionDefs == 0)
+ numFunctionDefs = 64;
+ fdefBuffer = new ByteBuffer[numFunctionDefs];
+ fdefEntryPoint = new int[numFunctionDefs];
+
+ /* Read the contents of the Control Value Table. */
+ if (controlValueTable != null)
+ this.controlValueTable = controlValueTable.asShortBuffer();
+
+ maxInstructionDefs = maxp.getChar(22);
+ maxStackElements = maxp.getChar(24);
+ storage = new int[maxStorage];
+ this.fontProgram = fontProgram;
+ this.preProgram = preProgram;
+ numTwilightPoints = maxp.getChar(16);
+ }
+
+
+ /**
+ * Sets the graphics state to default values.
+ */
+ private void resetGraphicsState()
+ {
+ /* The freedom, projection and dual vector default to the x axis. */
+ freeX = projX = dualX = ONE_214;
+ freeY = projY = dualX = 0;
+ cachedPixelsPerEM = 0;
+
+ cvtCutIn = 68; // 17/16 in 26.6 notation
+ deltaBase = 9;
+ deltaShift = 3;
+ loop = 1;
+ minimumDistance = Fixed.ONE;
+ singleWidthValue = 0;
+ rp0 = rp1 = rp2 = 0;
+ scanControl = false;
+ scanType = 2;
+ zp0 = zp1 = zp2 = getZone(1);
+
+ setRoundingMode(Fixed.ONE, 0x48); // round to grid
+ }
+
+
+ /**
+ * Reloads the control value table and scales each entry from font
+ * units to pixel values.
+ */
+ private void reloadControlValueTable()
+ {
+ /* Some TrueType fonts have no control value table. */
+ if (controlValueTable == null)
+ return;
+
+ /* Read in the Control Value Table. */
+ if (cvt == null)
+ cvt = new int[controlValueTable.capacity()];
+
+ /* Scale the entries. */
+ for (int i = 0; i < cvt.length; i++)
+ cvt[i] = funitsToPixels(controlValueTable.get(i));
+ }
+
+
+ /**
+ * Scales a value from font unites to pixels.
+ *
+ * @return the scaled value.
+ */
+ private int funitsToPixels(int funits)
+ {
+ return (int) (((long) funits * scaleY + (unitsPerEm>>1))
+ / unitsPerEm);
+ }
+
+
+ /**
+ * Sets up the virtual machine for the specified parameters. If
+ * there is no change to the last set-up, the method will quickly
+ * return. Otherwise, the font&#x2019;s pre-program will be
+ * executed.
+ *
+ * @param pointSize the point size of the scaled font.
+ *
+ * @param deviceTransform an affine transformation which gets
+ * applied in addition to scaling by <code>pointSize</code>. Font
+ * programs can separately inquire about the point size. For this
+ * reason, it is not recommended to pre-multiply the point size to
+ * the device transformation.
+ *
+ * @param antialiased <code>true</code> if the scan-line conversion
+ * algorithm will use gray levels to give a smoother appearance,
+ * <code>false</code> otherwise. Font programs can ask for this
+ * value with the <code>GETINFO</code> instruction, and some
+ * programs may behave differently according to this setting.
+ */
+ public boolean setup(double pointSize,
+ AffineTransform deviceTransform,
+ boolean antialiased)
+ {
+ boolean changeCTM;
+ int pointSize_Fixed;
+
+ if (stack == null)
+ stack = new int[maxStackElements];
+
+ if (twilightZone == null)
+ twilightZone = new Zone(numTwilightPoints);
+
+ /* If the font program has not yet been executed, do so. */
+ if (fontProgram != null)
+ {
+ resetGraphicsState();
+ sp = -1;
+ execute(fontProgram, 0);
+ fontProgram = null; // prevent further execution
+ }
+
+ /* Determine whether the transformation matrix has changed. */
+ pointSize_Fixed = Fixed.valueOf(pointSize);
+ changeCTM = ((pointSize_Fixed != this.pointSize)
+ || !deviceTransform.equals(this.deviceTransform)
+ || (antialiased != this.antialiased));
+
+ if (changeCTM)
+ {
+ this.pointSize = pointSize_Fixed;
+ this.deviceTransform = deviceTransform;
+ this.antialiased = antialiased;
+ scaleX = (int) (deviceTransform.getScaleX() * pointSize * 64);
+ scaleY = (int) (deviceTransform.getScaleY() * pointSize * 64);
+ shearX = (int) (deviceTransform.getShearX() * pointSize * 64);
+ shearY = (int) (deviceTransform.getShearY() * pointSize * 64);
+
+ resetGraphicsState();
+ reloadControlValueTable();
+ executeGlyphInstructions = true;
+ ignoreCVTProgram = false;
+
+ if (preProgram != null)
+ {
+ sp = -1;
+ execute(preProgram, 0);
+ if (ignoreCVTProgram)
+ reloadControlValueTable();
+ }
+ }
+
+ return executeGlyphInstructions;
+ }
+
+
+ /**
+ * Executes a stream of TrueType instructions.
+ */
+ private void execute(ByteBuffer instructions, int pos)
+ {
+ instructions.position(pos);
+
+ // FIXME: SECURITY: Possible denial-of-service attack
+ // via instructions that have an endless loop.
+ while (instructions.hasRemaining()
+ && executeInstruction(instructions))
+ ;
+ }
+
+
+ /**
+ * Writes a textual description of the current TrueType instruction,
+ * including the top stack elements, to <code>System.out</code>.
+ * This is useful for debugging.
+ *
+ * @param inst the instruction stream, positioned at the current
+ * instruction.
+ */
+ private void dumpInstruction(ByteBuffer inst)
+ {
+ CPStringBuilder sbuf = new CPStringBuilder(40);
+ int pc = inst.position();
+ int bcode = inst.get(pc) & 0xff;
+ int count;
+ int delta;
+
+ char pcPrefix = 'c';
+ for (int i = 0; i < fdefBuffer.length; i++)
+ {
+ if (fdefBuffer[i] == inst)
+ {
+ pcPrefix = 'f';
+ break;
+ }
+ }
+ sbuf.append(pcPrefix);
+
+
+ sbuf.append(getHex((short) inst.position()));
+ sbuf.append(": ");
+ sbuf.append(getHex((byte) bcode));
+ sbuf.append(" ");
+ sbuf.append(INST_NAME[bcode]);
+
+ if (bcode == 0x40) // NPUSHB
+ {
+ count = inst.get(pc + 1) & 0xff;
+ sbuf.append(" (");
+ sbuf.append(count);
+ sbuf.append(") ");
+ for (int i = 0; i < count; i++)
+ {
+ if (i > 0)
+ sbuf.append(" ");
+ sbuf.append('$');
+ sbuf.append(getHex(inst.get(pc + 2 + i)));
+ }
+ }
+ if (bcode == 0x41) // NPUSHW
+ {
+ count = inst.get(pc + 1) & 0xff;
+ sbuf.append(" (");
+ sbuf.append(count);
+ sbuf.append(") ");
+ for (int i = 0; i < count; i++)
+ {
+ if (i > 0)
+ sbuf.append(' ');
+ sbuf.append('$');
+ sbuf.append(getHex(inst.getShort(pc + 2 + 2*i)));
+ }
+ }
+ else
+ {
+ count = getInstructionLength(bcode) - 1;
+ for (int i = 0; i < count; i++)
+ {
+ sbuf.append(" $");
+ sbuf.append(getHex(inst.get(pc + 1 + i)));
+ }
+ }
+
+ while (sbuf.length() < 30)
+ sbuf.append(' ');
+ sbuf.append('|');
+ sbuf.append(sp + 1);
+ sbuf.append("| ");
+ for (int i = sp; i >= Math.max(0, sp - 5); i = i - 1)
+ {
+ if (i < sp)
+ sbuf.append(" ");
+ if ((stack[i] >> 16) != 0)
+ sbuf.append(getHex((short) (stack[i] >> 16)));
+ sbuf.append(getHex((short) stack[i]));
+ }
+ System.out.println(sbuf);
+ }
+
+
+ private static char getNibble(int i, int rightShift)
+ {
+ i = (i >> rightShift) & 15;
+ if (i < 10)
+ return (char) (i + '0');
+ else
+ return (char) (i + 'a' - 10);
+ }
+
+
+ private static String getHex(byte b)
+ {
+ char[] a = new char[2];
+ a[0] = getNibble(b, 4);
+ a[1] = getNibble(b, 0);
+ return new String(a);
+ }
+
+
+ private static String getHex(short b)
+ {
+ char[] a = new char[4];
+ a[0] = getNibble(b, 12);
+ a[1] = getNibble(b, 8);
+ a[2] = getNibble(b, 4);
+ a[3] = getNibble(b, 0);
+ return new String(a);
+ }
+
+
+ /**
+ * Skips any instructions until the specified opcode has been
+ * encoutered.
+ *
+ * @param inst the current instruction stream. After the call,
+ * the position of <code>inst</code> is right after the first
+ * occurence of <code>opcode</code>.
+ *
+ * @param opcode1 the opcode for which to look.
+ *
+ * @param opcode2 another opcode for which to look. Pass -1
+ * if only <code>opcode1</code> would terminate skipping.
+ *
+ * @param illegalCode1 an opcode that must not be encountered
+ * while skipping. Pass -1 if any opcode is acceptable.
+ *
+ * @param illegalCode2 another opcode that must not be encountered
+ * while skipping. Pass -1 to perform no check.
+ *
+ * @param handleNestedIfClauses <code>true</code> to handle
+ * nested <code>IF [ELSE] EIF</code> clauses, <code>false</code>
+ * to ignore them. From the TrueType specification document,
+ * one would think that nested if clauses would not be valid,
+ * but they do appear in some fonts.
+ *
+ * @throws IllegalStateException if <code>illegalCode1</code> or
+ * <code>illegalCode2</code> has been encountered while skipping.
+ */
+ private static void skipAfter(ByteBuffer inst,
+ int opcode1, int opcode2,
+ int illegalCode1, int illegalCode2,
+ boolean handleNestedIfClauses)
+ {
+ int pos = inst.position();
+ int curOpcode;
+ int instLen;
+ int nestingLevel = 0; // increased inside IF [ELSE] EIF sequences
+
+ while (true)
+ {
+ curOpcode = inst.get(pos) & 0xff;
+ instLen = getInstructionLength(curOpcode);
+
+ if (false && TRACE_EXECUTION)
+ {
+ for (int i = 0; i < nestingLevel; i++)
+ System.out.print("--");
+ System.out.print("--" + pos + "-" + INST_NAME[curOpcode]);
+ if (nestingLevel > 0)
+ System.out.print(", ifNestingLevel=" + nestingLevel);
+ System.out.println();
+ }
+
+ if (curOpcode == 0x40) // NPUSHB
+ pos += 1 + (inst.get(pos + 1) & 0xff);
+ else if (curOpcode == 0x41) // NPUSHW
+ pos += 1 + 2 * (inst.get(pos + 1) & 0xff);
+ else
+ pos += instLen;
+
+ if ((nestingLevel == 0)
+ && ((curOpcode == opcode1) || (curOpcode == opcode2)))
+ break;
+
+ if (handleNestedIfClauses)
+ {
+ if (curOpcode == /* IF */ 0x58)
+ ++nestingLevel;
+ else if (curOpcode == /* EIF */ 0x59)
+ --nestingLevel;
+ }
+
+ if ((nestingLevel < 0)
+ || (curOpcode == illegalCode1)
+ || (curOpcode == illegalCode2))
+ throw new IllegalStateException();
+ }
+
+ inst.position(pos);
+ }
+
+
+ /**
+ * Returns the number of bytes that a TrueType instruction occupies.
+ *
+ * @param opcode the instruction.
+ *
+ * @return the number of bytes occupied by the instructions and its
+ * operands. For <code>NPUSHB</code> and <code>NPUSHW</code>, where
+ * the instruction length depends on the first operand byte, the
+ * result is -1.
+ */
+ private static int getInstructionLength(int opcode)
+ {
+ /* NPUSHB, NPUSHW --> see following byte */
+ if ((opcode == 0x40) || (opcode == 0x41))
+ return -1;
+
+ /* PUSHB[0] .. PUSHB[7] --> 2, 3, 4, 5, 6, 7, 8, 9 */
+ if ((opcode >= 0xb0) && (opcode <= 0xb7))
+ return opcode - 0xae;
+
+ /* PUSHW[0] .. PUSHW[7] --> 3, 5, 6, 7, 11, 13, 15, 17*/
+ if ((opcode >= 0xb8) && (opcode <= 0xbf))
+ return 1 + ((opcode - 0xb7) << 1);
+
+ return 1;
+ }
+
+
+ /**
+ * Executes a single TrueType instruction. This is the core
+ * routine of the Virtual Machine.
+ *
+ * @return <code>true</code> if another instruction shall be
+ * executed in the same call frame; <code>false</code> if the
+ * current call frame shall be popped.
+ */
+ private boolean executeInstruction(ByteBuffer inst)
+ {
+ if (TRACE_EXECUTION)
+ dumpInstruction(inst);
+
+ int i, count, e1, e2, e3, e4, x, y;
+ int bcode = inst.get() & 0xff;
+
+ switch (bcode)
+ {
+ case 0x00: // SVTCA[0], Set freedom and proj. Vectors To Coord. Axis [y]
+ setFreedomVector((short) 0, ONE_214);
+ setProjectionVector((short) 0, ONE_214);
+ break;
+
+ case 0x01: // SVTCA[1], Set freedom and proj. Vectors To Coord. Axis [x]
+ setFreedomVector(ONE_214, (short) 0);
+ setProjectionVector(ONE_214, (short) 0);
+ break;
+
+ case 0x02: // SPVTCA[0], Set Projection Vector To Coordinate Axis [y]
+ setProjectionVector((short) 0, ONE_214);
+ break;
+
+ case 0x03: // SPVTCA[1], Set Projection Vector To Coordinate Axis [x]
+ setProjectionVector(ONE_214, (short) 0);
+ break;
+
+ case 0x0c: // GPV, Get Projection Vector
+ stack[++sp] = projX;
+ stack[++sp] = projY;
+ break;
+
+ case 0x0d: // GPV, Get Freedom Vector
+ stack[++sp] = freeX;
+ stack[++sp] = freeY;
+ break;
+
+ case 0x0F: // ISECT, move point p to the InterSECTION of two lines
+ sp -= 4;
+ handleISECT(stack[sp], stack[sp+1], stack[sp+2],
+ stack[sp+3], stack[sp+4]);
+ break;
+
+ case 0x10: // SRP0, Set Reference Point 0
+ rp0 = stack[sp--];
+ break;
+
+ case 0x11: // SRP1, Set Reference Point 1
+ rp1 = stack[sp--];
+ break;
+
+ case 0x12: // SRP2, Set Reference Point 2
+ rp2 = stack[sp--];
+ break;
+
+ case 0x13: // SZP0, Set Zone Pointer 0
+ zp0 = getZone(stack[sp--]);
+ break;
+
+ case 0x14: // SZP1, Set Zone Pointer 1
+ zp1 = getZone(stack[sp--]);
+ break;
+
+ case 0x15: // SZP2, Set Zone Pointer 2
+ zp2 = getZone(stack[sp--]);
+ break;
+
+ case 0x16: // SZPS, Set Zone PointerS
+ zp0 = zp1 = zp2 = getZone(stack[sp--]);
+ break;
+
+ case 0x17: // SLOOP, Set LOOP variable
+ loop = stack[sp--];
+ break;
+
+ case 0x18: // RTG, Round To Grid
+ setRoundingMode(Fixed.ONE, 0x48);
+ break;
+
+ case 0x19: // RTHG, Round To Half Grid
+ setRoundingMode(Fixed.ONE, 0x68);
+ break;
+
+ case 0x1a: // SMD, Set Minimum Distance
+ minimumDistance = stack[sp--];
+ break;
+
+ case 0x1B: // ELSE, ELSE clause
+ skipAfter(inst,
+ /* look for: EIF, -- */ 0x59, -1,
+ /* illegal: --, -- */ -1, -1,
+ /* handle nested if clauses */ true);
+ break;
+
+ case 0x1C: // JMPR, JuMP Relative
+ inst.position(inst.position() - 1 + stack[sp--]);
+ break;
+
+ case 0x1D: // SCVTCI, Set Control Value Table Cut-In
+ cvtCutIn = stack[sp--];
+ break;
+
+ case 0x1F: // SSW, Set Single Width
+ singleWidthValue = stack[sp--];
+ break;
+
+ case 0x20: // DUP, DUPlicate top stack element
+ e1 = stack[sp];
+ stack[++sp] = e1;
+ break;
+
+ case 0x21: // POP, POP top stack element
+ sp--;
+ break;
+
+ case 0x22: // CLEAR, CLEAR the stack
+ sp = -1;
+ break;
+
+ case 0x23: // SWAP, SWAP the top two elements on the stack
+ e1 = stack[sp--];
+ e2 = stack[sp];
+ stack[sp] = e1;
+ stack[++sp] = e2;
+ break;
+
+ case 0x24: // DEPTH, DEPTH of the stack
+ stack[++sp] = sp + 1;
+ break;
+
+ case 0x25: // CINDEX, Copy the INDEXed element to the top of the stack
+ stack[sp] = stack[sp - stack[sp]];
+ break;
+
+ case 0x26: // MINDEX, Move the INDEXed element to the top of the stack
+ i = stack[sp];
+ e1 = stack[sp - i];
+ System.arraycopy(/* src */ stack, /* srcPos */ sp - i + 1,
+ /* dest */ stack, /* destPos*/ sp - i,
+ /* length */ i - 1);
+ --sp;
+ stack[sp] = e1;
+ break;
+
+ case 0x2a: // LOOPCALL, LOOP and CALL function
+ i = stack[sp--];
+ count = stack[sp--];
+ e1 = inst.position();
+ e2 = sp;
+ for (int j = 0; j < count; j++)
+ execute(fdefBuffer[i], fdefEntryPoint[i]);
+ inst.position(e1);
+ break;
+
+ case 0x2B: // CALL, CALL function
+ i = stack[sp--];
+ e1 = inst.position();
+ e2 = sp;
+ execute(fdefBuffer[i], fdefEntryPoint[i]);
+ inst.position(e1);
+ break;
+
+ case 0x2C: // FDEF, Function DEFinition
+ i = stack[sp--];
+ fdefBuffer[i] = inst;
+ fdefEntryPoint[i] = inst.position();
+ skipAfter(inst,
+ /* look for: ENDF */ 0x2d,
+ /* look for: --- */ -1,
+ /* illegal: IDEF */ 0x89,
+ /* illegal: FDEF */ 0x2c,
+ /* do not handle nested if clauses */ false);
+ break;
+
+ case 0x2D: // ENDF, END Function definition
+ /* Pop the current stack frame. */
+ return false;
+
+ case 0x2e: // MDAP[0], Move Direct Absolute Point
+ handleMDAP(stack[sp--], /* round */ false);
+ break;
+
+ case 0x2f: // MDAP[1], Move Direct Absolute Point
+ handleMDAP(stack[sp--], /* round */ true);
+ break;
+
+ case 0x39: // IP, Interpolate Point by the last relative stretch
+ handleIP();
+ break;
+
+ case 0x3d: // RTDG, Round To Double Grid
+ setRoundingMode(Fixed.ONE, 0x08);
+ roundThreshold = roundThreshold / 64; // period/128
+ break;
+
+ case 0x3e: // MIAP[0], Move Indirect Absolute Point
+ e1 = stack[sp--];
+ handleMIAP(e1, stack[sp--], /* round */ false);
+ break;
+
+ case 0x3f: // MIAP[1], Move Indirect Absolute Point
+ e1 = stack[sp--];
+ handleMIAP(e1, stack[sp--], /* round */ true);
+ break;
+
+ case 0x40: // NPUSHB
+ count = inst.get() & 0xff;
+ for (i = 0; i < count; i++)
+ stack[++sp] = inst.get() & 0xff;
+ break;
+
+ case 0x41: // NPUSHW
+ count = inst.get() & 0xff;
+ for (i = 0; i < count; i++)
+ stack[++sp] = inst.getShort();
+ break;
+
+ case 0x42: // WS, Write Store
+ e1 = stack[sp--]; i = stack[sp--];
+ storage[i] = e1;
+ break;
+
+ case 0x43: // RS, Read Store
+ stack[sp] = storage[stack[sp]];
+ break;
+
+ case 0x44: // WCVTP, Write Control Value Table in Pixel units
+ e1 = stack[sp--];
+ i = stack[sp--];
+ if (i < cvt.length)
+ cvt[i] = e1;
+ break;
+
+ case 0x45: // RCVT, Read Control Value Table entry
+ if (stack[sp] < cvt.length)
+ stack[sp] = cvt[stack[sp]];
+ else
+ stack[sp] = 0;
+ break;
+
+ case 0x46: // GC[0], Get Coordinate projected onto the projection vector
+ stack[sp] = getProjection(zp2, stack[sp]);
+ break;
+
+ case 0x47: // GC[1], Get Coordinate projected onto the projection vector
+ stack[sp] = getOriginalProjection(zp2, stack[sp]);
+ break;
+
+ case 0x4B: // MPPEM, Measure Pixels Per EM
+ stack[++sp] = getPixelsPerEM();
+ break;
+
+ case 0x4c: // MPS, Measure Point Size
+ /* FreeType2 returns pixels per em here, because they think that
+ * the point size would be irrelevant in a given font program.
+ * This is extremely surprising, because the appearance of good
+ * fonts _should_ change with point size. For example, a good
+ * font should be wider at small point sizes, and the holes
+ * inside glyphs ("Punzen" in German, I do not know the correct
+ * English expression) should be larger. Note that this change
+ * of appearance is dependent on point size, _not_ the
+ * resolution of the display device.
+ */
+ stack[++sp] = pointSize;
+ break;
+
+ case 0x4f: // DEBUG, DEBUG call
+ sp--;
+ break;
+
+ case 0x50: // LT, Less Than
+ e1 = stack[sp--];
+ stack[sp] = (stack[sp] < e1) ? 1 : 0;
+ break;
+
+ case 0x51: // LTEQ, Greater Than or EQual
+ e1 = stack[sp--];
+ stack[sp] = (stack[sp] <= e1) ? 1 : 0;
+ break;
+
+ case 0x52: // GT, Greater Than
+ e1 = stack[sp--];
+ stack[sp] = (stack[sp] > e1) ? 1 : 0;
+ break;
+
+ case 0x53: // GTEQ, Greater Than or EQual
+ e1 = stack[sp--];
+ stack[sp] = (stack[sp] >= e1) ? 1 : 0;
+ break;
+
+ case 0x54: // EQ, EQual
+ e1 = stack[sp--];
+ stack[sp] = (stack[sp] == e1) ? 1 : 0;
+ break;
+
+ case 0x55: // NEQ, Not EQual
+ e1 = stack[sp--];
+ stack[sp] = (stack[sp] != e1) ? 1 : 0;
+ break;
+
+ case 0x58: // IF, IF test
+ if (stack[sp--] == 0)
+ skipAfter(inst,
+ /* look for: ELSE */ 0x1B,
+ /* look for: EIF */ 0x59,
+ /* illegal: -- */ -1,
+ /* illegal: -- */ -1,
+ /* handle nested if clauses */ true);
+ break;
+
+ case 0x59: // EIF, End IF
+ // Do nothing.
+ break;
+
+ case 0x5A: // AND
+ e1 = stack[sp--];
+ stack[sp] = ((e1 != 0) && (stack[sp] != 0)) ? 1 : 0;
+ break;
+
+ case 0x5B: // OR
+ e1 = stack[sp--];
+ stack[sp] = ((e1 != 0) || (stack[sp] != 0)) ? 1 : 0;
+ break;
+
+ case 0x5C: // NOT
+ stack[sp] = (stack[sp] != 0) ? 0 : 1;
+ break;
+
+ case 0x5e: // SDB, Set Delta Base in the graphics state
+ deltaBase = stack[sp--];
+ break;
+
+ case 0x5f: // SDS, Set Delta Shift in the graphics state
+ deltaShift = stack[sp--];
+ break;
+
+ case 0x60: // ADD
+ e1 = stack[sp--];
+ stack[sp] += e1;
+ break;
+
+ case 0x61: // SUB, SUBtract
+ e1 = stack[sp--];
+ stack[sp] -= e1;
+ break;
+
+ case 0x62: // DIV, DIVide
+ e1 = stack[sp--];
+ stack[sp] = Fixed.div(e1, stack[sp]);
+ break;
+
+ case 0x63: // MUL, MULtiply
+ e1 = stack[sp--];
+ stack[sp] = Fixed.mul(e1, stack[sp]);
+ break;
+
+ case 0x64: // ABS, ABSolute value
+ stack[sp] = Math.abs(stack[sp]);
+ break;
+
+ case 0x65: // NEG, NEGate
+ stack[sp] = -stack[sp];
+ break;
+
+ case 0x66: // FLOOR
+ stack[sp] = Fixed.floor(stack[sp]);
+ break;
+
+ case 0x67: // CEILING
+ stack[sp] = Fixed.ceil(stack[sp]);
+ break;
+
+ case 0x68: // ROUND[0] -- round grey distance
+ stack[sp] = round(stack[sp], /* no engine compensation */ 0);
+ break;
+
+ case 0x69: // ROUND[1] -- round black distance
+ stack[sp] = round(stack[sp], -engineCompensation);
+ break;
+
+ case 0x6a: // ROUND[2] -- round white distance
+ stack[sp] = round(stack[sp], engineCompensation);
+ break;
+
+ case 0x6b: // ROUND[3] -- round distance (not yet defined)
+ stack[sp] = round(stack[sp], /* no engine compensation */ 0);
+ break;
+
+ case 0x6c: // NROUND[0] -- compensate grey distance
+ stack[sp] = nround(stack[sp], 0);
+ break;
+
+ case 0x6d: // NROUND[1] -- compensate black distance
+ stack[sp] = nround(stack[sp], -engineCompensation);
+ break;
+
+ case 0x6e: // NROUND[2] -- compensate white distance
+ stack[sp] = nround(stack[sp], engineCompensation);
+ break;
+
+ case 0x6f: // NROUND[3] -- compensate distance (not yet defined)
+ stack[sp] = nround(stack[sp], 0);
+ break;
+
+ case 0x70: // WCVTF, Write Control Value Table in Funits
+ e1 = stack[sp--];
+ cvt[stack[sp--]] = e1 * getPixelsPerEM();
+ break;
+
+ case 0x73: // DELTAC1, DELTA exception C1
+ count = stack[sp--];
+ sp -= 2 * count;
+ deltaC(stack, sp + 1, count, 0);
+ break;
+
+ case 0x74: // DELTAC2, DELTA exception C2
+ count = stack[sp--];
+ sp -= 2 * count;
+ deltaC(stack, sp + 1, count, 16);
+ break;
+
+ case 0x75: // DELTAC3, DELTA exception C3
+ count = stack[sp--];
+ sp -= 2 * count;
+ deltaC(stack, sp + 1, count, 32);
+ break;
+
+ case 0x76: // SROUND, Super ROUND
+ setRoundingMode(Fixed.ONE, stack[sp--]);
+ break;
+
+ case 0x77: // S45ROUND, Super ROUND 45 degrees
+ setRoundingMode(/* sqrt(2)/2 */ 0x2d, stack[sp--]);
+ break;
+
+ case 0x78: // JROT, Jump Relative On True
+ e1 = stack[sp--];
+ i = inst.position() - 1 + stack[sp--];
+ if (e1 != 0)
+ inst.position(i);
+ break;
+
+ case 0x79: // JROF, Jump Relative On False
+ e1 = stack[sp--];
+ i = inst.position() - 1 + stack[sp--];
+ if (e1 == 0)
+ inst.position(i);
+ break;
+
+ case 0x7a: // ROFF, Round OFF
+ roundPeriod = 0;
+ break;
+
+ case 0x7c: // RUTG, Round Up To Grid
+ setRoundingMode(Fixed.ONE, 0x40);
+ break;
+
+ case 0x7d: // RDTG, Round Down To Grid
+ setRoundingMode(Fixed.ONE, 0x40);
+ roundThreshold = 0;
+ break;
+
+ case 0x7e: // SANGW, Set ANGle Weight (no-op according to TrueType spec)
+ case 0x7f: // AA, Adjust Angle (no-op according to TrueType spec)
+ sp--;
+ break;
+
+ case 0x85: // SCANCTRL, SCAN conversion ConTRoL
+ e1 = stack[sp--];
+ int ppemThreshold = e1 & 255;
+ scanControl = false;
+ boolean ppemCondition = (ppemThreshold == 255)
+ || ((ppemThreshold != 0) && (getPixelsPerEM() > ppemThreshold));
+ if (((e1 & (1<<8)) != 0) && ppemCondition)
+ scanControl = true;
+ if (((e1 & (1<<9)) != 0) && isRotated())
+ scanControl = true;
+ if (((e1 & (1<<10)) != 0) && isStretched())
+ scanControl = true;
+ if (((e1 & (1<<11)) != 0) && !ppemCondition)
+ scanControl = false;
+ if (((e1 & (1<<12)) != 0) && !isRotated())
+ scanControl = false;
+ if (((e1 & (1<<13)) != 0) && !isStretched())
+ scanControl = false;
+ break;
+
+ case 0x88: // GETINFO, GET INFOrmation
+ e1 = 0;
+ if ((stack[sp] & 1) != 0) // ask for rasterizer version
+ e1 |= 35; // "Microsoft Rasterizer version 1.7" (grayscale-capable)
+ if (((stack[sp] & 2) != 0) && isRotated())
+ e1 |= 1 << 8; // bit 8: glyph has been rotated
+ if (((stack[sp] & 4) != 0) && isStretched())
+ e1 |= 1 << 9; // bit 9: glyph has been stretched
+ if (((stack[sp] & 32) != 0) && antialiased)
+ e1 |= 1 << 12; // bit 12: antialiasing is active
+ stack[sp] = e1;
+ break;
+
+ case 0x8a: // ROLL, ROLL the top three stack elements
+ e1 = stack[sp - 2];
+ stack[sp - 2] = stack[sp - 1];
+ stack[sp - 1] = stack[sp];
+ stack[sp] = e1;
+ break;
+
+ case 0x8b: // MAX, MAXimum of top two stack elements
+ e1 = stack[sp--];
+ stack[sp] = Math.max(e1, stack[sp]);
+ break;
+
+ case 0x8c: // MIN, MINimum of top two stack elements
+ e1 = stack[sp--];
+ stack[sp] = Math.min(e1, stack[sp]);
+ break;
+
+ case 0x8d: // SCANTYPE
+ scanType = stack[sp--];
+ break;
+
+ case 0x8e: // INSTCTRL, INSTRuction execution ConTRoL
+ e1 = stack[sp--]; // selector
+ e2 = stack[sp--]; // value
+ switch (e1)
+ {
+ case 1:
+ executeGlyphInstructions = (e2 == 0);
+ break;
+
+ case 2:
+ ignoreCVTProgram = (e2 != 0);
+ break;
+ }
+ break;
+
+ case 0xb0: // PUSHB[0]
+ case 0xb1: // PUSHB[1]
+ case 0xb2: // PUSHB[2]
+ case 0xb3: // PUSHB[3]
+ case 0xb4: // PUSHB[4]
+ case 0xb5: // PUSHB[5]
+ case 0xb6: // PUSHB[6]
+ case 0xb7: // PUSHB[7]
+ count = bcode - 0xb0 + 1;
+ for (i = 0; i < count; i++)
+ stack[++sp] = inst.get() & 0xff;
+ break;
+
+ case 0xb8: // PUSHW[0]
+ case 0xb9: // PUSHW[1]
+ case 0xba: // PUSHW[2]
+ case 0xbb: // PUSHW[3]
+ case 0xbc: // PUSHW[4]
+ case 0xbd: // PUSHW[5]
+ case 0xbe: // PUSHW[6]
+ case 0xbf: // PUSHW[7]
+ count = bcode - 0xb8 + 1;
+ for (i = 0; i < count; i++)
+ stack[++sp] = inst.getShort();
+ break;
+
+ // MIRPxxxx, Move Indirect Relative Point
+ case 0xe0: case 0xe1: case 0xe2: case 0xe3:
+ case 0xe4: case 0xe5: case 0xe6: case 0xe7:
+ case 0xe8: case 0xe9: case 0xea: case 0xeb:
+ case 0xec: case 0xed: case 0xee: case 0xef:
+ case 0xf0: case 0xf1: case 0xf2: case 0xf3:
+ case 0xf4: case 0xf5: case 0xf6: case 0xf7:
+ case 0xf8: case 0xf9: case 0xfa: case 0xfb:
+ case 0xfc: case 0xfd: case 0xfe: case 0xff:
+ e1 = stack[sp--];
+ handleMIRP(bcode, /* point */ e1, /* cvtIndex */ stack[sp--]);
+ break;
+
+ default:
+ throw new IllegalStateException();
+ }
+
+ return true;
+ }
+
+
+ /**
+ * Sets the rounding mode.
+ *
+ * @param period the grid period in fixed-point notation, such as
+ * {@link Fixed#ONE} for the <code>SROUND</code> instruction or
+ * <code>sqrt(2)/2</code> for the <code>S45ROUND</code> instruction.
+ *
+ * @param mode a byte whose bits are set according to the TrueType
+ * specification for SROUND and S45ROUND parameters.
+ */
+ private void setRoundingMode(int period, int mode)
+ {
+ /* Set the period. */
+ switch ((mode & 0xc0) >> 6)
+ {
+ case 0:
+ roundPeriod = period / 2;
+ break;
+
+ case 2:
+ roundPeriod = period * 2;
+ break;
+
+ default:
+ roundPeriod = period;
+ break;
+ }
+
+ /* Set the phase. */
+ switch ((mode & 0x30) >> 4)
+ {
+ case 0:
+ roundPhase = 0;
+ break;
+
+ case 1:
+ roundPhase = roundPeriod >> 2; // period/4
+ break;
+
+ case 2:
+ roundPhase = roundPeriod >> 1; // period/2
+ break;
+
+ case 3:
+ roundPhase = (roundPeriod >> 1) + (roundPeriod >> 2); // period * 3/4
+ break;
+ }
+
+ /* Set the threshold. */
+ int threshold = mode & 0x0f;
+ if (threshold == 0)
+ roundThreshold = roundPeriod - Fixed.ONE;
+ else
+ roundThreshold = ((threshold - 4) * roundPeriod) / 8;
+ }
+
+
+
+ /**
+ * Implements the DELTAC instructions. These instructions check
+ * whether the current number of pixels per em is contained in an
+ * exception table. If it is, a delta value is determined, and the
+ * specified entry in the Control Value Table is modified according
+ * to the delta.
+ *
+ * @param pairs the delta table. Because the delta table is on
+ * the stack, callers usually just want to pass the stack array.
+ *
+ * @param offset the offset of the first pair in <code>pairs</code>.
+ *
+ * @param numPairs the number of pairs.
+ *
+ * @param base 0 for <code>DELTAC1</code>, 16 for <code>DELTAC2</code>,
+ * or 32 for <code>DELTAC2</code>.
+ *
+ * @see <a href=
+ * "http://developer.apple.com/fonts/TTRefMan/RM05/Chap5.html#DELTAC1"
+ * >Apple&#x2019;s documentation for <code>DELTAC1</code></a>, <a href=
+ * "http://developer.apple.com/fonts/TTRefMan/RM05/Chap5.html#DELTAC2"
+ * ><code>DELTAC2</code></a>, and <a href=
+ * "http://developer.apple.com/fonts/TTRefMan/RM05/Chap5.html#DELTAC3"
+ * ><code>DELTAC3</code></a>
+ */
+ private void deltaC(int[] pairs, int offset, int numPairs, int base)
+ {
+ int arg, relativePpem;
+ int ppemTrigger = getPixelsPerEM() - (deltaBase + base);
+ int delta, cvtIndex, rightShift;
+ for (int i = 0; i < numPairs; i++)
+ {
+ arg = pairs[offset + 2 * i];
+ relativePpem = (arg >> 4) & 15;
+ if (relativePpem == ppemTrigger)
+ {
+ delta = (arg & 15) - 8;
+ if (delta >= 0)
+ ++delta;
+
+ rightShift = deltaShift - 6;
+ if (rightShift > 0)
+ delta = delta >> rightShift;
+ else if (rightShift < 0)
+ delta = delta << (-rightShift);
+ cvt[pairs[offset + 2 * i + 1]] += delta;
+
+ break;
+ }
+ }
+ }
+
+
+ private Zone getZone(int zoneNumber)
+ {
+ return (zoneNumber == 0) ? twilightZone : glyphZone;
+ }
+
+
+ /**
+ * Projects the specified vector along the current projection
+ * vector.
+ *
+ * @param x the x component of the input vector, in 26.6 fixed-point
+ * notation.
+ *
+ * @param y the y component of the input vector, in 26.6 fixed-point
+ * notation.
+ *
+ * @return the projected distance, in 26.6 fixed-point notation.
+ */
+ private int getProjection(int x, int y)
+ {
+ return (int) (((((long) x) * projX + ((long) y) * projY)) >> 14);
+ }
+
+
+ /**
+ * Projects the specified vector along the current dual projection
+ * vector.
+ *
+ * @param x the x component of the input vector, in 26.6 fixed-point
+ * notation.
+ *
+ * @param y the y component of the input vector, in 26.6 fixed-point
+ * notation.
+ *
+ * @return the projected distance, in 26.6 fixed-point notation.
+ */
+ private int getDualProjection(int x, int y)
+ {
+ return (int) (((((long) x) * dualX + ((long) y) * dualY)) >> 14);
+ }
+
+
+ private int getProjection(Zone zone, int point)
+ {
+ return getProjection(zone.getX(point), zone.getY(point));
+ }
+
+
+ private int getOriginalProjection(Zone zone, int point)
+ {
+ return getDualProjection(zone.getOriginalX(point),
+ zone.getOriginalY(point));
+ }
+
+
+ private void handleISECT(int a0, int a1, int b0, int b1, int p)
+ {
+ System.out.println("FIXME: Unimplemented ISECT " + p);
+ }
+
+
+ private static int muldiv(int a, int b, int c)
+ {
+ int s;
+ s = a; a = Math.abs(a);
+ s ^= b; b = Math.abs(b);
+ s ^= c; c = Math.abs(c);
+ a = (int) ((((long) a) * b + (c>>1)) / c);
+ return (s < 0) ? -a : a;
+ }
+
+
+ private int getFreeDotProj()
+ {
+ int result;
+
+ result = ((((int) projX) * freeX) << 2)
+ + ((((int) projY) * freeY) << 2);
+
+ /* FIXME: This seems somewhat bogus. Need to contact the
+ * developers of FreeType.
+ */
+ if (Math.abs(result) < 0x4000000)
+ result = 0x40000000;
+ return result;
+ }
+
+
+ private void movePoint(Zone zone, int point, int distance)
+ {
+ int freeDotProj = getFreeDotProj();
+ int c;
+
+ if (freeX != 0)
+ {
+ c = zone.getX(point);
+ c += muldiv(distance, freeX << 16, freeDotProj);
+ zone.setX(point, c, /* touch */ true);
+ }
+
+ if (freeY != 0)
+ {
+ c = zone.getY(point);
+ c += muldiv(distance, freeY << 16, freeDotProj);
+ zone.setY(point, c, /* touch */ true);
+ }
+
+ if (TRACE_EXECUTION)
+ {
+ System.out.println("point[" + point + "] moved to "
+ + Fixed.toString(zone.getX(point),
+ zone.getY(point)));
+ dumpVectors();
+ }
+ }
+
+ private void dumpVectors()
+ {
+ System.out.println(" proj=" + Fixed.toString(projX>>8, projY>>8)
+ + ", free=" + Fixed.toString(freeX>>8, freeY>>8));
+ }
+
+
+ private void handleIP()
+ {
+ // Implementation taken from FreeType.
+ int p, org_a, org_b, org_x, cur_a, cur_b, cur_x, distance;
+ int freeDotProj;
+
+ org_a = getOriginalProjection(zp0, rp1);
+ cur_a = getProjection(zp0, rp1);
+
+ org_b = getOriginalProjection(zp1, rp2);
+ cur_b = getProjection(zp1, rp2);
+
+ while (--loop >= 0)
+ {
+ p = stack[sp--];
+ org_x = getOriginalProjection(zp2, p);
+ cur_x = getProjection(zp2, p);
+
+ if (((org_a <= org_b) && (org_x <= org_a))
+ || ((org_a > org_b) && (org_x >= org_a)))
+ distance = (cur_a - org_a) + (org_x - cur_x);
+ else if (((org_a <= org_b) && (org_x >= org_b))
+ || ((org_a > org_b) && (org_x < org_b)))
+ distance = (cur_b - org_b) + (org_x - cur_x);
+ else
+ distance = muldiv(cur_b - cur_a, org_x - org_a, org_b - org_a)
+ + (cur_a - cur_x);
+ movePoint(zp2, p, distance);
+ }
+ loop = 1;
+ }
+
+
+ private void handleMDAP(int point, boolean round)
+ {
+ System.out.println("FIXME: Unimplemented MDAP: point "
+ + point + "/" + zp0);
+ }
+
+
+ private void handleMIAP(int cvtIndex, int point, boolean round)
+ {
+ int previousPos, pos;
+
+ previousPos = getProjection(zp0, point);
+ pos = cvt[cvtIndex];
+
+ if (round)
+ {
+ if (Math.abs(pos - previousPos) > cvtCutIn)
+ pos = previousPos;
+ pos = round(pos, /* no engine compensation */ 0);
+ }
+ movePoint(zp0, point, pos - previousPos);
+ rp0 = rp1 = point;
+ }
+
+
+ private void handleMIRP(int bcode, int point, int cvtIndex)
+ {
+ System.out.println("FIXME: Unimplemented mirp " + point + ", " + cvtIndex);
+ }
+
+
+
+ private int round(int distance, int compensation)
+ {
+ int result;
+
+ if (roundPeriod == 0)
+ return nround(distance, compensation);
+
+ if (distance >= 0)
+ {
+ result = distance + compensation - roundPhase + roundThreshold;
+ result &= -roundPeriod; // truncate to the next lowest periodic value
+ return Math.max(result, 0) + roundPhase;
+ }
+ else
+ {
+ result = compensation - roundPhase + roundThreshold - distance;
+ result &= -roundPeriod;
+ return Math.max(-result, 0) - roundPhase;
+ }
+ }
+
+
+ private static int nround(int distance, int compensation)
+ {
+ if (distance >= 0)
+ return Math.max(distance + compensation, 0);
+ else
+ return Math.min(distance - compensation, 0);
+ }
+
+
+ /**
+ * Determines whether the current glyph is rotated.
+ *
+ * @return <code>false</code> if the shearing factors for the
+ * <i>x</i> and <i>y</i> axes are zero; <code>true</code> if they
+ * are non-zero.
+ */
+ private boolean isRotated()
+ {
+ return (shearX != 0) || (shearY != 0);
+ }
+
+
+ /**
+ * Determines whether the current glyph is stretched.
+ *
+ * @return <code>false</code> if the scaling factors for the
+ * <i>x</i> and <i>y</i> axes are are equal; <code>true</code> if
+ * they differ.
+ */
+ private boolean isStretched()
+ {
+ return scaleX != scaleY;
+ }
+
+
+ /**
+ * Returns how many pixels there are per EM, in direction of the
+ * current projection vector. The result is a normal integer,
+ * not a Fixed.
+ */
+ private int getPixelsPerEM()
+ {
+ if (cachedPixelsPerEM == 0)
+ {
+ cachedPixelsPerEM = Fixed.intValue(Fixed.vectorLength(
+ applyCTM_x(projX >> 8, projY >> 8),
+ applyCTM_y(projX >> 8, projY >> 8)));
+ }
+
+ return cachedPixelsPerEM;
+ }
+
+
+ private void setProjectionVector(short x, short y)
+ {
+ if (PATENTED_HINTING)
+ {
+ if ((x != projX) || (y != projY))
+ cachedPixelsPerEM = 0;
+
+ projX = x;
+ projY = y;
+ }
+ }
+
+
+ private void setFreedomVector(short x, short y)
+ {
+ if (PATENTED_HINTING)
+ {
+ freeX = x;
+ freeY = y;
+ }
+ }
+
+
+ private void setDualVector(short x, short y)
+ {
+ if (PATENTED_HINTING)
+ {
+ dualX = x;
+ dualY = y;
+ }
+ }
+
+
+ private int applyCTM_x(int x, int y)
+ {
+ return (int) (((long) scaleX * x + (long) shearX * y) >> 6);
+ }
+
+ private int applyCTM_y(int x, int y)
+ {
+ return (int) (((long) shearY * x + (long) scaleY * y) >> 6);
+ }
+
+
+ private static final String[] INST_NAME =
+ {
+ /* 00 */ "SVTCA[0]", "SVTCA[1]", "SPVTCA[0]", "SPVTCA[1]",
+ /* 04 */ "INST_04", "INST_05", "INST_06", "INST_07",
+ /* 08 */ "INST_08", "INST_09", "INST_0A", "INST_0B",
+ /* 0c */ "GPV", "GFV", "INST_0E", "ISECT",
+ /* 10 */ "SRP0", "SRP1", "SRP2", "SZP0",
+ /* 14 */ "SZP1", "SZP2", "SZPS", "SLOOP",
+ /* 18 */ "RTG", "RTHG", "SMD", "ELSE",
+ /* 1c */ "JMPR", "SCVTCI", "INST_1E", "SSW",
+ /* 20 */ "DUP", "POP", "CLEAR", "SWAP",
+ /* 24 */ "DEPTH", "CINDEX", "MINDEX", "INST_27",
+ /* 28 */ "INST_28", "INST_29", "LOOPCALL", "CALL",
+ /* 2c */ "FDEF", "ENDF", "MDAP[0]", "MDAP[1]",
+ /* 30 */ "IUP[0]", "IUP[1]", "SHP[0]", "SHP[1]",
+ /* 34 */ "INST_34", "INST_35", "INST_36", "INST_37",
+ /* 38 */ "INST_38", "IP", "INST_3A", "INST_3B",
+ /* 3c */ "INST_3C", "RTDG", "MIAP[0]", "MIAP[1]",
+ /* 40 */ "NPUSHB", "NPUSHW", "WS", "RS",
+ /* 44 */ "WCVTP", "RCVT", "GC[0]", "GC[1]",
+ /* 48 */ "INST_48", "INST_49", "INST_4A", "MPPEM",
+ /* 4c */ "MPS", "FLIPON", "FLIPOFF", "DEBUG",
+ /* 50 */ "LT", "LTEQ", "GT", "GTEQ",
+ /* 54 */ "EQ", "NEQ", "INST_56", "INST_57",
+ /* 58 */ "IF", "EIF", "AND", "OR",
+ /* 5c */ "NOT", "INST_5D", "SDB", "SDS",
+ /* 60 */ "ADD", "SUB", "DIV", "MUL",
+ /* 64 */ "ABS", "NEG", "FLOOR", "CEILING",
+ /* 68 */ "ROUND[0]", "ROUND[1]", "ROUND[2]", "ROUND[3]",
+ /* 6c */ "NROUND[0]", "NROUND[1]", "NROUND[2]", "NROUND[3]",
+ /* 70 */ "WCVTF", "INST_71", "INST_72", "DELTAC1",
+ /* 74 */ "DELTAC2", "DELTAC3", "SROUND", "S45ROUND",
+ /* 78 */ "JROT", "JROF", "ROFF", "INST_7B",
+ /* 7c */ "RUTG", "RDTG", "SANGW", "AA",
+ /* 80 */ "FLIPPT", "FLIPRGON", "FLIPRGOFF", "INST_83",
+ /* 84 */ "INST_84", "SCANCTRL", "INST_86", "INST_87",
+ /* 88 */ "GETINFO", "INST_89", "ROLL", "MAX",
+ /* 8c */ "MIN", "SCANTYPE", "INSTCTRL", "INST_8F",
+ /* 90 */ "INST_90", "INST_91", "INST_92", "INST_93",
+ /* 94 */ "INST_94", "INST_95", "INST_96", "INST_97",
+ /* 98 */ "INST_98", "INST_99", "INST_9A", "INST_9B",
+ /* 9c */ "INST_9C", "INST_9D", "INST_9E", "INST_9F",
+ /* a0 */ "INST_A0", "INST_A1", "INST_A2", "INST_A3",
+ /* a4 */ "INST_A4", "INST_A5", "INST_A6", "INST_A7",
+ /* a8 */ "INST_A8", "INST_A9", "INST_AA", "INST_AB",
+ /* ac */ "INST_AC", "INST_AD", "INST_AE", "INST_AF",
+ /* b0 */ "PUSHB[0]", "PUSHB[1]", "PUSHB[2]", "PUSHB[3]",
+ /* b4 */ "PUSHB[4]", "PUSHB[5]", "PUSHB[6]", "PUSHB[7]",
+ /* b8 */ "PUSHW[0]", "PUSHW[1]", "PUSHW[2]", "PUSHW[3]",
+ /* bc */ "PUSHW[4]", "PUSHW[5]", "PUSHW[6]", "PUSHW[7]",
+ /* c0 */ "INST_C0", "INST_C1", "INST_C2", "INST_C3",
+ /* c4 */ "INST_C4", "INST_C5", "INST_C6", "INST_C7",
+ /* c8 */ "INST_C8", "INST_C9", "INST_CA", "INST_CB",
+ /* cc */ "INST_CC", "INST_CD", "INST_CE", "INST_CF",
+ /* d0 */ "INST_D0", "INST_D1", "INST_D2", "INST_D3",
+ /* d4 */ "INST_D4", "INST_D5", "INST_D6", "INST_D7",
+ /* d8 */ "INST_D8", "INST_D9", "INST_DA", "INST_DB",
+ /* dc */ "INST_DC", "INST_DD", "INST_DE", "INST_DF",
+ /* e0 */ "MIRP00000", "MIRP00001", "MIRP00010", "MIRP00011",
+ /* e4 */ "MIRP00100", "MIRP00101", "MIRP00110", "MIRP00111",
+ /* e8 */ "MIRP01000", "MIRP01001", "MIRP01010", "MIRP01011",
+ /* ec */ "MIRP01100", "MIRP01101", "MIRP01110", "MIRP01111",
+ /* f0 */ "MIRP10000", "MIRP10001", "MIRP10010", "MIRP10011",
+ /* f4 */ "MIRP10100", "MIRP10101", "MIRP10110", "MIRP10111",
+ /* f8 */ "MIRP11000", "MIRP11001", "MIRP11010", "MIRP11011",
+ /* fc */ "MIRP11100", "MIRP11101", "MIRP11110", "MIRP11111"
+ };
+}
diff --git a/libjava/classpath/gnu/java/awt/font/opentype/truetype/Zone.java b/libjava/classpath/gnu/java/awt/font/opentype/truetype/Zone.java
new file mode 100644
index 000000000..b0559e0e3
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/opentype/truetype/Zone.java
@@ -0,0 +1,291 @@
+/* Zone.java -- A collection of points with some additional information.
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.awt.font.opentype.truetype;
+
+import gnu.java.awt.font.FontDelegate;
+
+import java.awt.geom.AffineTransform;
+import java.awt.geom.GeneralPath;
+import java.awt.geom.PathIterator;
+
+
+/**
+ * A collection of points with some additional information.
+ */
+public final class Zone
+{
+ private Point[] points;
+ private int numPoints;
+
+ public double scaleX, scaleY, shearX, shearY;
+
+ public Zone(int maxNumPoints)
+ {
+ points = new Point[maxNumPoints];
+ }
+
+ public int getCapacity()
+ {
+ return points.length;
+ }
+
+
+ public int getSize()
+ {
+ return numPoints;
+ }
+
+
+ public int getX(int point)
+ {
+ return getX(point, FontDelegate.FLAG_FITTED);
+ }
+
+ public int getX(int point, int flags)
+ {
+ int x;
+ if ((flags & FontDelegate.FLAG_FITTED) != 0)
+ x = points[point].x;
+ else
+ x = points[point].scaledX;
+ return x;
+ }
+
+
+ public void setX(int point, int value, boolean touch)
+ {
+ points[point].scaledX = value;
+ points[point].x = value;
+ if (touch)
+ points[point].flags |= Point.FLAG_TOUCHED_X;
+ }
+
+
+ public void setY(int point, int value, boolean touch)
+ {
+ points[point].scaledY = value;
+ points[point].y = value;
+ if (touch)
+ points[point].flags |= Point.FLAG_TOUCHED_Y;
+ }
+
+ public int getY(int point)
+ {
+ return getY(point, FontDelegate.FLAG_FITTED);
+ }
+
+ public int getY(int point, int flags)
+ {
+ int y;
+ if ((flags & FontDelegate.FLAG_FITTED) != 0)
+ y = points[point].y;
+ else
+ y = points[point].scaledY;
+ return y;
+ }
+
+
+ public int getOriginalX(int point)
+ {
+ return points[point].origX;
+ }
+
+
+ public int getOriginalY(int point)
+ {
+ return points[point].origY;
+ }
+
+
+ public void setOriginalX(int point, int x)
+ {
+ points[point].origX = x;
+ }
+
+ public void setOriginalY(int point, int y)
+ {
+ points[point].origY = y;
+ }
+
+ public void setNumPoints(int numPoints)
+ {
+ for (int i = 0; i < numPoints; i++)
+ points[i] = new Point();
+ this.numPoints = numPoints;
+ }
+
+
+ public boolean isOnCurve(int point)
+ {
+ return (points[point].flags & Point.FLAG_ON_CURVE) != 0;
+ }
+
+
+ public void setOnCurve(int point, boolean onCurve)
+ {
+ if (onCurve)
+ points[point].flags |= Point.FLAG_ON_CURVE;
+ else
+ points[point].flags &= ~Point.FLAG_ON_CURVE;
+ }
+
+
+ public boolean isContourEnd(int point)
+ {
+ return (points[point].flags & Point.FLAG_CONTOUR_END) != 0;
+ }
+
+
+ public void setContourEnd(int point, boolean segEnd)
+ {
+ if (segEnd)
+ points[point].flags |= Point.FLAG_CONTOUR_END;
+ else
+ points[point].flags &= ~Point.FLAG_CONTOUR_END;
+ }
+
+
+
+
+ void transform(double pointSize, AffineTransform deviceTransform,
+ int unitsPerEm, int preTranslateX, int preTranslateY)
+ {
+ double factor;
+
+ factor = pointSize / (double) unitsPerEm;
+ scaleX = deviceTransform.getScaleX() * factor;
+ scaleY = deviceTransform.getScaleY() * factor;
+ shearX = deviceTransform.getShearX() * factor;
+ shearY = deviceTransform.getShearY() * factor;
+
+ for (int i = 0; i < numPoints; i++)
+ {
+ int x = points[i].origX + preTranslateX;
+ int y = points[i].origY + preTranslateY;
+
+ points[i].scaledX = points[i].x = Fixed.valueOf(scaleX * x
+ + shearX * y);
+ points[i].scaledY = points[i].y = Fixed.valueOf(shearY * x
+ + scaleY * y);
+ }
+ }
+
+
+
+ void combineWithSubGlyph(Zone zone, int numPhantomPoints)
+ {
+ int offset = this.numPoints - numPhantomPoints;
+ int count = zone.numPoints;
+ System.arraycopy(zone.points, 0, this.points, offset, count);
+ this.numPoints += count - numPhantomPoints;
+ }
+
+
+ private void dump()
+ {
+ for (int i = 0; i < numPoints; i++)
+ {
+ System.out.print(" " + i + ": ");
+ System.out.print(Fixed.toString(points[i].scaledX, points[i].scaledY));
+ System.out.print(' ');
+ System.out.print(Fixed.toString(points[i].origX, points[i].origY));
+ System.out.print(' ');
+ if (isOnCurve(i))
+ System.out.print('.');
+ else
+ System.out.print('c');
+ if (isContourEnd(i))
+ System.out.print('E');
+ System.out.println();
+ if (isContourEnd(i))
+ System.out.println();
+ }
+ }
+
+
+ public PathIterator getPathIterator(int type)
+ {
+ return new ZonePathIterator(this, type);
+ }
+
+
+ public GeneralPath getPath(int type)
+ {
+ GeneralPath p = new GeneralPath(GeneralPath.WIND_NON_ZERO, numPoints);
+ p.append(getPathIterator(type), /* connect */ false);
+ return p;
+ }
+
+ /**
+ * Returns the number of contours in this outline.
+ *
+ * @return the number of contours in this outline
+ */
+ public int getNumContours()
+ {
+ int num = 0;
+ for (int i = 0; i < numPoints; i++)
+ {
+ if (isContourEnd(i))
+ num++;
+ }
+ return num;
+ }
+
+ public int getContourEnd(int n)
+ {
+ int idx = -1;
+ int num = 0;
+ for (int i = 0; i < numPoints; i++)
+ {
+ if (isContourEnd(i))
+ {
+ idx = i;
+ if (num == n)
+ break;
+ num++;
+ }
+ }
+ return idx;
+ }
+
+ public Point[] getPoints()
+ {
+ return points;
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/opentype/truetype/ZonePathIterator.java b/libjava/classpath/gnu/java/awt/font/opentype/truetype/ZonePathIterator.java
new file mode 100644
index 000000000..f4534f36f
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/opentype/truetype/ZonePathIterator.java
@@ -0,0 +1,393 @@
+/* ZonePathIterator.java -- A PathIterator over glyph zones.
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.awt.font.opentype.truetype;
+
+import java.awt.geom.PathIterator;
+
+
+/**
+ * A PathIterator that enumerates the non-phantom points in a zone.
+ *
+ * <p><b>Lack of thread safety:</b> Instances of this class are
+ * <i>not</i> safe to access from multiple concurrent threads.
+ *
+ * @see Zone
+ *
+ * @author Sascha Brawer (brawer@dandelis.ch)
+ */
+final class ZonePathIterator
+ implements PathIterator
+{
+ /**
+ * If <code>state</code> has this value, <code>currentSegment</code>
+ * will emit a <code>SEG_LINETO</code> or <code>SEG_QUADTO</code> segment
+ * to the current point. For a discussion of subtleties of on-curve
+ * and off-curve points, please refer to the documentation for
+ * {@link #getSegment}.
+ */
+ private static final int EMIT_SEGMENT = 0;
+
+
+ /**
+ * If <code>state</code> has this value, <code>currentSegment</code>
+ * will emit a <code>SEG_CLOSE</code> in order to close the sub-path
+ * for the current contour.
+ */
+ private static final int EMIT_CLOSE = 1;
+
+
+ /**
+ * If <code>state</code> has this value, <code>currentSegment</code>
+ * will emit a <code>SEG_MOVETO</code> segment to the first point in
+ * the current contour. If the first point is off-curve, a suitable
+ * on-curve point is calculated.
+ *
+ * @see #getStartSegment
+ */
+ private static final int EMIT_MOVETO = 2;
+
+
+ /**
+ * The state of the iterator, which is one of
+ * <code>EMIT_SEGMENT</code>, <code>EMIT_CLOSE</code>, or
+ * <code>EMIT_MOVETO</code>.
+ */
+ private int state;
+
+
+
+ /**
+ * The zone whose segments are enumerated by this iterator.
+ */
+ private Zone zone;
+
+
+ /**
+ * The total number of points in the zone, not including the four
+ * phantom points at its end.
+ */
+ private int numPoints;
+
+
+ /**
+ * The number of the current point.
+ */
+ private int curPoint;
+
+
+ /**
+ * The number of the first point in the current contour.
+ */
+ private int contourStart;
+
+
+ private int type;
+
+ /**
+ * Constructs a ZonePathIterator for the specified zone.
+ *
+ * @param zone the zone whose segments will be enumerated
+ * by this iterator.
+ */
+ ZonePathIterator(Zone zone, int t)
+ {
+ this.zone = zone;
+ type = t;
+ numPoints = zone.getSize() - /* four phantom points */ 4;
+
+ // The first segment that needs to be emitted is a SEG_MOVETO.
+ state = EMIT_MOVETO;
+ }
+
+
+ /**
+ * Returns the winding rule. TrueType glyphs always use the non-zero
+ * winding rule, so this method will always return {@link
+ * PathIterator#WIND_NON_ZERO}.
+ */
+ public int getWindingRule()
+ {
+ return PathIterator.WIND_NON_ZERO;
+ }
+
+
+
+ public boolean isDone()
+ {
+ return (state != EMIT_CLOSE) && (curPoint >= numPoints);
+ }
+
+
+ public void next()
+ {
+ boolean onCurve;
+
+ /* If the current point is the end of a segment, and no SEG_CLOSE
+ * has been emitted yet, this will be the next segment.
+ */
+ if (zone.isContourEnd(curPoint) && (state != EMIT_CLOSE))
+ {
+ state = EMIT_CLOSE;
+ return;
+ }
+
+ /* If the previously emitted segment was a SEG_CLOSE, we are now
+ * at the beginning of a new contour.
+ */
+ if (state == EMIT_CLOSE)
+ {
+ contourStart = ++curPoint;
+ state = EMIT_MOVETO;
+ return;
+ }
+
+ onCurve = zone.isOnCurve(curPoint);
+
+ /* If the last segment was a moveto, and the current point
+ * (which is the first point in the contour) is off-curve,
+ * we need to emit a quadto segment for the first point.
+ */
+ if ((state == EMIT_MOVETO) && !onCurve)
+ {
+ state = EMIT_SEGMENT;
+ return;
+ }
+
+
+ curPoint++;
+
+ /* If the last point has been off-curve, and the now current
+ * point is on-curve, the last segment was a quadto that
+ * had the now current point at its end. In this case, we can
+ * skip a segment.
+ */
+ if (!onCurve && zone.isOnCurve(curPoint))
+ {
+ /* But if the skipped point is the end of a contour, we must not
+ * skip the SEG_CLOSE. An example where this matters is the 'o'
+ * glyph in the Helvetica font face that comes with MacOS X
+ * 10.1.5.
+ */
+ if (zone.isContourEnd(curPoint))
+ {
+ state = EMIT_CLOSE;
+ return;
+ }
+
+ curPoint++;
+ }
+
+ state = EMIT_SEGMENT;
+ }
+
+
+ /**
+ * Determines the successor of the current point in the current
+ * contour. The successor of the last point in a contour is the
+ * start of that contour.
+ *
+ * @return the number of the point that follows the current point in
+ * the same contour.
+ */
+ private int getSuccessor(int p)
+ {
+ if (zone.isContourEnd(p))
+ return contourStart;
+ else
+ return p + 1;
+ }
+
+
+
+ /**
+ * Retrieves the current path segment using single-precision
+ * coordinate values.
+ */
+ public int currentSegment(float[] coords)
+ {
+ switch (state)
+ {
+ case EMIT_CLOSE:
+ return PathIterator.SEG_CLOSE;
+
+ case EMIT_MOVETO:
+ return getStartSegment(curPoint, coords);
+
+ default:
+ return getSegment(curPoint, coords);
+ }
+ }
+
+
+ /**
+ * A helper array that is used by {@link
+ * #currentSegment(double[])}.
+ */
+ float[] floats;
+
+
+ /**
+ * Retrieves the current path segment using double-precision
+ * coordinate values.
+ */
+ public int currentSegment(double[] coords)
+ {
+ if (floats == null)
+ floats = new float[6];
+ int result;
+
+ result = currentSegment(floats);
+ for (int i = 0; i < 6; i++)
+ coords[i] = floats[i];
+ return result;
+ }
+
+
+ /**
+ * Returns the segment for the specified point.
+ *
+ * <p><img src="doc-files/ZonePathIterator-1.png" width="426"
+ * height="194" alt="An example curve" /></p>
+ *
+ * <p>If <code>cur</code> is an on-curve point, the returned segment
+ * is a straight line to <code>cur</code>. In the illustration, this
+ * would be the case for <code>cur = 4</code>.</p>
+ *
+ * <p>If <code>cur</code> is an off-curve point, and
+ * <code>cur</code>&#x2019;s successor <code>succ</code> is also
+ * off-curve, the returned segment is a quadratic B&eacute;zier
+ * spline whose control point is <code>cur</code>, and whose end
+ * point is located at the middle of the line connecting
+ * <code>cur</code> and <code>succ</code>. In the illustration,
+ * this would be the case for <code>cur = 5</code>.</p>
+ *
+ * <p>If <code>cur</code> is an off-curve point, and
+ * <code>cur</code>&#x2019;s successor <code>succ</code> is
+ * on-curve, the returned segment is a quadratic B&eacute;zier
+ * spline whose control point is <code>cur</code>, and whose end
+ * point is <code>succ</code>. In the illustration, this would
+ * be the case for <code>cur = 6</code>.</p>
+ *
+ * @return either <code>PathIterator.SEG_LINETO</code> or
+ * <code>PathIterator.SEG_QUADTO</code>.
+ */
+ private int getSegment(int cur, float[] coords)
+ {
+ int curX, curY;
+ int succ, succX, succY;
+
+ curX = zone.getX(cur, type);
+ curY = zone.getY(cur, type);
+ coords[0] = Fixed.floatValue(curX);
+ coords[1] = Fixed.floatValue(curY);
+
+ if (zone.isOnCurve(cur))
+ return PathIterator.SEG_LINETO;
+
+ succ = getSuccessor(cur);
+ succX = zone.getX(succ, type);
+ succY = zone.getY(succ, type);
+
+ if (zone.isOnCurve(succ))
+ {
+ coords[2] = Fixed.floatValue(succX);
+ coords[3] = Fixed.floatValue(succY);
+ }
+ else
+ {
+ coords[2] = Fixed.floatValue((curX + succX) / 2);
+ coords[3] = Fixed.floatValue((curY + succY) / 2);
+ }
+ return PathIterator.SEG_QUADTO;
+ }
+
+
+ /**
+ * Returns the start segment for the contour which starts
+ * at the specified point.
+ *
+ * <p>If the contour starts with an on-curve point, the returned
+ * segment is a <code>SEG_MOVETO</code> to that point.</p>
+ *
+ * <p>If the contour starts with an off-curve point, and the contour
+ * ends with an on-curve point, the returned segment is a
+ * <code>SEG_MOVETO</code> to the end point.</p>
+ *
+ * <p>If the contour starts with an off-curve point, and the contour
+ * also ends with an off-curve point, the returned segment is a
+ * <code>SEG_MOVETO</code> to the location at the middle between the
+ * start and end points of the contour.</p>
+ *
+ * @return <code>PathIterator.SEG_MOVETO</code>.
+ */
+ private int getStartSegment(int contourStart, float[] coords)
+ {
+ int x, y;
+
+ if (zone.isOnCurve(contourStart))
+ {
+ x = zone.getX(contourStart, type);
+ y = zone.getY(contourStart, type);
+ }
+ else
+ {
+ /* Find the last point of the current contour. */
+ int contourEnd = contourStart;
+ while (!zone.isContourEnd(contourEnd))
+ ++contourEnd;
+
+ if (zone.isOnCurve(contourEnd))
+ {
+ /* An example is the 'o' glyph of the Helvetica which comes
+ * with Apple MacOS X 10.1.5.
+ */
+ x = zone.getX(contourEnd, type);
+ y = zone.getY(contourEnd, type);
+ }
+ else
+ {
+ x = (zone.getX(contourStart, type) + zone.getX(contourEnd, type)) / 2;
+ y = (zone.getY(contourStart, type) + zone.getY(contourEnd, type)) / 2;
+ }
+ }
+
+ coords[0] = Fixed.floatValue(x);
+ coords[1] = Fixed.floatValue(y);
+ return PathIterator.SEG_MOVETO;
+ }
+}
diff --git a/libjava/classpath/gnu/java/awt/font/opentype/truetype/doc-files/ZonePathIterator-1.dia b/libjava/classpath/gnu/java/awt/font/opentype/truetype/doc-files/ZonePathIterator-1.dia
new file mode 100644
index 000000000..b715ea02c
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/opentype/truetype/doc-files/ZonePathIterator-1.dia
Binary files differ
diff --git a/libjava/classpath/gnu/java/awt/font/opentype/truetype/doc-files/ZonePathIterator-1.png b/libjava/classpath/gnu/java/awt/font/opentype/truetype/doc-files/ZonePathIterator-1.png
new file mode 100644
index 000000000..81d09d839
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/opentype/truetype/doc-files/ZonePathIterator-1.png
Binary files differ