libjava/classpath/ChangeLog.gcj:

2007-05-31  Matthias Klose  <doko@ubuntu.com>

        * javax/management/NotificationBroadcasterSupport.java
        (getNotificationInfo): Add cast.
        * native/jni/qt-peer/Makefile.am (AM_CXXFLAGS): Add libstdc++ include
        directories.
        * native/jni/qt-peer/Makefile.in: Regenerate.

libjava/ChangeLog:

2007-06-03  Matthias Klose  <doko@ubuntu.com>

        * java/io/natFileWin32.cc (setFilePermissions): New (stub only).
        _access: Handle EXEC query, stub only.

2007-06-03  Matthias Klose  <doko@ubuntu.com>

        Merged from classpath:
        * gnu/java/nio/SelectorProviderImpl.java: Whitespace merge.
        * java/lang/System.java(inheritedChannel): New.
        * java/lang/Character.java: Remove stray`;'.
        * java/net/MulticastSocket.java: Merged.
        * java/text/DateFormatSymbols.java(getInstance): New, comment updates.
        * java/text/Collator.java(getInstance): Merged.
        * java/util/Calendar.java: New attributes ALL_STYLES, SHORT, LONG.
        getDisplayName, getDisplayNames: New.
        * java/util/logging/Logger.java: Merged.
        * Regenerate .class and .h files.

2007-06-03  Matthias Klose  <doko@ubuntu.com>

        * java/io/File.java: Merge with classpath-0.95, new method
        setFilePermissions, new attribute EXEC.
        * java/io/natFilePosix.cc (setFilePermissions): New.
        _access: Handle EXEC query.
        * classpath/lib/java/io/File.class, java/io/File.h: Regenerate.

2007-06-03  Matthias Klose  <doko@ubuntu.com>

        Imported GNU Classpath 0.95.

        * classpath/Makefile.in,
        classpath/native/jni/midi-dssi/Makefile.in,
        classpath/native/jni/classpath/Makefile.in,
        classpath/native/jni/Makefile.in,
        classpath/native/jni/gconf-peer/Makefile.in,
        classpath/native/jni/java-io/Makefile.in,
        classpath/native/jni/native-lib/Makefile.in,
        classpath/native/jni/java-util/Makefile.in,
        classpath/native/jni/midi-alsa/Makefile.in,
        classpath/native/jni/java-lang/Makefile.in,
        classpath/native/jni/java-nio/Makefile.in,
        classpath/native/jni/java-net/Makefile.in,
        classpath/native/jni/xmlj/Makefile.in,
        classpath/native/jni/qt-peer/Makefile.in,
        classpath/native/jni/gtk-peer/Makefile.in,
        classpath/native/Makefile.in, classpath/native/jawt/Makefile.in,
        classpath/native/fdlibm/Makefile.in,
        classpath/native/plugin/Makefile.in,
        classpath/resource/Makefile.in, classpath/scripts/Makefile.in,
        classpath/tools/Makefile.in, classpath/doc/Makefile.in,
        classpath/doc/api/Makefile.in, classpath/lib/Makefile.in,
        classpath/external/Makefile.in, classpath/external/jsr166/Makefile.in,
        classpath/external/sax/Makefile.in,
        classpath/external/w3c_dom/Makefile.in,
        classpath/external/relaxngDatatype/Makefile.in,
        classpath/include/Makefile.in,
        classpath/examples/Makefile.in: Regenerate.
        * classpath/config.guess, classpath/config.sub,
        classpath/ltmain.sh : Update.
        * classpath/configure, classpath/depcomp, classpath/missing,
        classpath/aclocal.m4, classpath/install-sh: Regenerate.

        * gnu/classpath/Configuration.java (CLASSPATH_VERSION): Now 0.95.
        * sources.am: Regenerate.
        * Makefile.in: Regenerate.

        * Update the .class files and generated CNI header files, add new
        .class and generated CNI header files.
        * Remove generated files for removed java source files:
        classpath/gnu/java/net/BASE64.java,
        classpath/gnu/java/security/util/Base64.java,
        classpath/gnu/java/awt/peer/gtk/GThreadMutex.java,
        classpath/gnu/java/awt/peer/gtk/GThreadNativeMethodRunner.java,
        classpath/gnu/java/awt/font/autofit/Scaler.java,
        classpath/gnu/classpath/jdwp/util/Value.java,
        classpath/gnu/javax/net/ssl/Base64.java.
        * Remove empty directories.

        * Makefile.am(nat_source_files): Add natVMOperatingSystemMXBeanImpl.cc.
        * java/lang/Class.java(setAccessible): Merge from classpath.
        * java/util/Locale.java: Remove.
        * gnu/java/lang/management/VMOperatingSystemMXBeanImpl.java,
        gnu/java/lang/management/natVMOperatingSystemMXBeanImpl.cc: New.
        * gcj/javaprims.h: Update class declarations.
        * scripts/classes.pl: Update usage.
        * HACKING: Mention to build all peers.

From-SVN: r125302

26 files changed, 3036 insertions, 118 deletions

diff --git a/libjava/classpath/gnu/java/awt/font/FontDelegate.java b/libjava/classpath/gnu/java/awt/font/FontDelegate.java
index a26510e..030f9d3 100644
--- a/libjava/classpath/gnu/java/awt/font/FontDelegate.java
+++ b/libjava/classpath/gnu/java/awt/font/FontDelegate.java
@@ -61,6 +61,13 @@ import java.util.Locale;
  */
 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>.
@@ -221,7 +228,8 @@ public interface FontDelegate
                                      float pointSize,
                                      AffineTransform transform,
                                      boolean antialias,
-                                     boolean fractionalMetrics);
+                                     boolean fractionalMetrics,
+                                     int type);
 
 
   /**
diff --git a/libjava/classpath/gnu/java/awt/font/GNUGlyphVector.java b/libjava/classpath/gnu/java/awt/font/GNUGlyphVector.java
index f17a451..2f73dce 100644
--- a/libjava/classpath/gnu/java/awt/font/GNUGlyphVector.java
+++ b/libjava/classpath/gnu/java/awt/font/GNUGlyphVector.java
@@ -164,7 +164,9 @@ public class GNUGlyphVector
                               renderContext.usesFractionalMetrics(),
                               /* horizontal */ true,
                               advance);
-      pos[p] = x += advance.x;
+      // 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;
@@ -284,6 +286,22 @@ public class GNUGlyphVector
     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.
@@ -309,7 +327,8 @@ public class GNUGlyphVector
 
     path = fontDelegate.getGlyphOutline(glyphs[glyphIndex], fontSize, tx,
                                         renderContext.isAntiAliased(),
-                                        renderContext.usesFractionalMetrics());
+                                        renderContext.usesFractionalMetrics(),
+                                        FontDelegate.FLAG_FITTED);
 
     tx = new AffineTransform();
     tx.translate(pos[glyphIndex * 2], pos[glyphIndex * 2 + 1]);
@@ -317,6 +336,32 @@ public class GNUGlyphVector
     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
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 0000000..b0420ab
--- /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
index b2c9912..87f2abc 100644
--- a/libjava/classpath/gnu/java/awt/font/autofit/AxisHints.java
+++ b/libjava/classpath/gnu/java/awt/font/autofit/AxisHints.java
@@ -1,4 +1,4 @@
-/* AxisHints.java -- FIXME: briefly describe file purpose
+/* AxisHints.java -- Hints specific to an axis
    Copyright (C) 2006 Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
@@ -42,4 +42,71 @@ 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
index cb39928..c5b90fa 100644
--- a/libjava/classpath/gnu/java/awt/font/autofit/Constants.java
+++ b/libjava/classpath/gnu/java/awt/font/autofit/Constants.java
@@ -58,4 +58,29 @@ interface Constants
    * 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 0000000..d973665
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/autofit/Edge.java
@@ -0,0 +1,80 @@
+/* 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;
+
+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()
+  {
+    StringBuilder s = new StringBuilder();
+    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
index ad73a04..72f07ed 100644
--- a/libjava/classpath/gnu/java/awt/font/autofit/GlyphHints.java
+++ b/libjava/classpath/gnu/java/awt/font/autofit/GlyphHints.java
@@ -38,12 +38,16 @@ 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;
@@ -53,23 +57,584 @@ class GlyphHints
 
   AxisHints[] axis;
 
-  void rescale(ScriptMetrics metrics)
+  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)
   {
-    // TODO: Implement.
+    metrics = m;
+    // TODO: Copy scalerFlags.
   }
   
   void reload(Zone outline)
   {
-    // TODO: Implement.
+    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;
   }
 
-  void computeSegments(int dim)
+  public boolean doAlignStrongPoints()
   {
-    // TODO: Implement.
+    return (flags & FontDelegate.FLAG_NO_HINT_STRONG_POINTS) == 0;
   }
 
-  void linkSegments(int dim)
+  public boolean doAlignWeakPoints()
   {
-    // TODO: Implement.
+    return (flags & FontDelegate.FLAG_NO_HINT_WEAK_POINTS) == 0;
   }
 }
diff --git a/libjava/classpath/gnu/java/awt/font/autofit/Scaler.java b/libjava/classpath/gnu/java/awt/font/autofit/HintScaler.java
index 1051851..01276b4 100644
--- a/libjava/classpath/gnu/java/awt/font/autofit/Scaler.java
+++ b/libjava/classpath/gnu/java/awt/font/autofit/HintScaler.java
@@ -40,7 +40,7 @@ package gnu.java.awt.font.autofit;
 
 import gnu.java.awt.font.opentype.OpenTypeFont;
 
-class Scaler
+class HintScaler
 {
 
   int xScale;
@@ -48,5 +48,6 @@ class Scaler
   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
index 0352b41..8951e8b 100644
--- a/libjava/classpath/gnu/java/awt/font/autofit/Latin.java
+++ b/libjava/classpath/gnu/java/awt/font/autofit/Latin.java
@@ -39,8 +39,11 @@ 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;
 
 /**
@@ -50,12 +53,476 @@ class Latin
   implements Script, Constants
 {
 
-  private static final int MAX_WIDTHS = 16;
+  static final int MAX_WIDTHS = 16;
 
-  public void applyHints(GlyphHints hints, ScriptMetrics metrics)
+  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)
@@ -99,10 +566,119 @@ class Latin
     initBlues(lm, face);
   }
 
-  public void scaleMetrics(ScriptMetrics metrics)
+  public void scaleMetrics(ScriptMetrics metrics, HintScaler scaler)
   {
-    // TODO Auto-generated method stub
+    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;
+              }
+          }
+      }
   }
 
   /**
@@ -118,12 +694,9 @@ class Latin
     metrics.axis[DIMENSION_HORZ].widthCount = 0;
     metrics.axis[DIMENSION_VERT].widthCount = 0;
     int glyphIndex = face.getGlyph(ch);
-    // TODO: Avoid that AffineTransform constructor and change
-    // getRawGlyphOutline() to accept null or remove that parameter altogether.
-    // Consider this when the thing is done and we know what we need that for.
-    Zone outline = face.getRawGlyphOutline(glyphIndex, new AffineTransform());
+    Zone outline = face.getRawGlyphOutline(glyphIndex, IDENTITY);
     LatinMetrics dummy = new LatinMetrics();
-    Scaler scaler = dummy.scaler;
+    HintScaler scaler = dummy.scaler;
     dummy.unitsPerEm = metrics.unitsPerEm;
     scaler.xScale = scaler.yScale = 10000;
     scaler.xDelta = scaler.yDelta = 0;
@@ -135,20 +708,24 @@ class Latin
         LatinAxis axis = metrics.axis[dim];
         AxisHints axHints = hints.axis[dim];
         int numWidths = 0;
-        hints.computeSegments(dim);
-        hints.linkSegments(dim);
+        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 && link.index > i)
+            if (link != null && link.link == seg && ! touched.contains(link))
               {
                 int dist = Math.abs(seg.pos - link.pos);
                 if (numWidths < MAX_WIDTHS)
-                  axis.widths[numWidths++].org = dist;
+                  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++)
       {
@@ -159,6 +736,78 @@ class Latin
       }
   }
 
+  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.
    *
@@ -167,11 +816,548 @@ class Latin
    */
   private void initBlues(LatinMetrics metrics, OpenTypeFont face)
   {
-    // TODO: Implement.
+    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
index 8ca1e6d..9237d0e 100644
--- a/libjava/classpath/gnu/java/awt/font/autofit/LatinAxis.java
+++ b/libjava/classpath/gnu/java/awt/font/autofit/LatinAxis.java
@@ -49,5 +49,14 @@ class LatinAxis
 
   int widthCount;
   Width[] widths;
-  float edgeDistanceTreshold;
+  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 0000000..694fb24
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/autofit/LatinBlue.java
@@ -0,0 +1,59 @@
+/* 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;
+
+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()
+  {
+    StringBuilder s = new StringBuilder();
+    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
index cd95534..33fc63a 100644
--- a/libjava/classpath/gnu/java/awt/font/autofit/LatinMetrics.java
+++ b/libjava/classpath/gnu/java/awt/font/autofit/LatinMetrics.java
@@ -38,6 +38,8 @@ exception statement from your version. */
 
 package gnu.java.awt.font.autofit;
 
+import gnu.java.awt.font.opentype.OpenTypeFont;
+
 /**
  * Latin specific metrics data.
  */
@@ -48,4 +50,17 @@ class LatinMetrics
   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
index 3b35301..c223f0a 100644
--- a/libjava/classpath/gnu/java/awt/font/autofit/Script.java
+++ b/libjava/classpath/gnu/java/awt/font/autofit/Script.java
@@ -39,6 +39,7 @@ 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.
@@ -51,12 +52,11 @@ interface Script
    */
   void initMetrics(ScriptMetrics metrics, OpenTypeFont face);
 
-  void scaleMetrics(ScriptMetrics metrics/* , scaler, map this */);
+  void scaleMetrics(ScriptMetrics metrics , HintScaler scaler);
 
   void doneMetrics(ScriptMetrics metrics);
 
   void initHints(GlyphHints hints, ScriptMetrics metrics);
 
-  void applyHints(GlyphHints hints, /* some outline object, */
-                  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
index 77c815a..984a06d 100644
--- a/libjava/classpath/gnu/java/awt/font/autofit/ScriptMetrics.java
+++ b/libjava/classpath/gnu/java/awt/font/autofit/ScriptMetrics.java
@@ -45,5 +45,9 @@ class ScriptMetrics
 {
 
   Script script;
-  Scaler scaler;
+  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
index 32032a4..640e82c 100644
--- a/libjava/classpath/gnu/java/awt/font/autofit/Segment.java
+++ b/libjava/classpath/gnu/java/awt/font/autofit/Segment.java
@@ -38,10 +38,58 @@ exception statement from your version. */
 
 package gnu.java.awt.font.autofit;
 
+import gnu.java.awt.font.opentype.truetype.Point;
+
 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;
-  int index;
+  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()
+  {
+    StringBuilder s = new StringBuilder();
+    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 0000000..4df4705
--- /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
index d4d5400..c890cf3 100644
--- a/libjava/classpath/gnu/java/awt/font/autofit/Width.java
+++ b/libjava/classpath/gnu/java/awt/font/autofit/Width.java
@@ -43,4 +43,20 @@ public class Width
   int org;
   int cur;
   int fit;
+  Width(int dist)
+  {
+    org = dist;
+  }
+
+  public String toString()
+  {
+    StringBuilder s = new StringBuilder();
+    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/Hinter.java b/libjava/classpath/gnu/java/awt/font/opentype/Hinter.java
new file mode 100644
index 0000000..9758a28
--- /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/OpenTypeFont.java b/libjava/classpath/gnu/java/awt/font/opentype/OpenTypeFont.java
index efc3081..a270ce7 100644
--- a/libjava/classpath/gnu/java/awt/font/opentype/OpenTypeFont.java
+++ b/libjava/classpath/gnu/java/awt/font/opentype/OpenTypeFont.java
@@ -51,6 +51,7 @@ 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;
 
@@ -146,7 +147,8 @@ public final class OpenTypeFont
    */
   private GlyphNamer glyphNamer;
 
-  
+  private Hinter hinter;
+
   /**
    * Constructs an OpenType or TrueType font.
    *
@@ -579,6 +581,9 @@ public final class OpenTypeFont
                                                     FontRenderContext frc,
                                                     CharacterIterator ci)
   {
+    // Initialize hinter if necessary.
+    checkHinter(FontDelegate.FLAG_FITTED);
+
     CharGlyphMap cmap;    
     int numGlyphs;
     int[] glyphs;
@@ -689,13 +694,15 @@ public final class OpenTypeFont
                                                   float pointSize,
                                                   AffineTransform transform,
                                                   boolean antialias,
-                                                  boolean fractionalMetrics)
+                                                  boolean fractionalMetrics,
+                                                  int flags)
   {
     /* The synchronization is needed because the scaler is not
      * synchronized.
      */
+    checkHinter(flags);
     return scaler.getOutline(glyph, pointSize, transform,
-                             antialias, fractionalMetrics);
+                             antialias, fractionalMetrics, hinter, flags);
   }
 
   /**
@@ -837,4 +844,29 @@ public final class OpenTypeFont
     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/Scaler.java b/libjava/classpath/gnu/java/awt/font/opentype/Scaler.java
index 83a31c5..c7582b6 100644
--- a/libjava/classpath/gnu/java/awt/font/opentype/Scaler.java
+++ b/libjava/classpath/gnu/java/awt/font/opentype/Scaler.java
@@ -90,7 +90,8 @@ public abstract class Scaler
                                          float pointSize,
                                          AffineTransform transform,
                                          boolean antialias,
-                                         boolean fractionalMetrics);
+                                         boolean fractionalMetrics,
+                                         Hinter hinter, int type);
 
 
   /**
diff --git a/libjava/classpath/gnu/java/awt/font/opentype/truetype/Fixed.java b/libjava/classpath/gnu/java/awt/font/opentype/truetype/Fixed.java
index 5d81c5d..287593e 100644
--- a/libjava/classpath/gnu/java/awt/font/opentype/truetype/Fixed.java
+++ b/libjava/classpath/gnu/java/awt/font/opentype/truetype/Fixed.java
@@ -48,7 +48,7 @@ package gnu.java.awt.font.opentype.truetype;
  *
  * @author Sascha Brawer (brawer@dandelis.ch)
  */
-final class Fixed
+public final class Fixed
 {
   public static final int ONE = 1<<6;
 
@@ -69,14 +69,21 @@ final class Fixed
     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;
@@ -119,7 +126,10 @@ final class Fixed
   {
     return ((float) f) / 64;
   }
-
+  public static float floatValue16(int f)
+  {
+    return ((float) f) / 65536;
+  }
 
   public static double doubleValue(int f)
   {
@@ -138,6 +148,10 @@ final class Fixed
     return (int) (d * 64);
   }
 
+  public static int valueOf16(double d)
+  {
+    return (int) (d * (1 << 16));
+  }
 
   /**
    * Makes a string representation of a fixed-point number.
diff --git a/libjava/classpath/gnu/java/awt/font/opentype/truetype/GlyphLoader.java b/libjava/classpath/gnu/java/awt/font/opentype/truetype/GlyphLoader.java
index 3733afe..249a87d 100644
--- a/libjava/classpath/gnu/java/awt/font/opentype/truetype/GlyphLoader.java
+++ b/libjava/classpath/gnu/java/awt/font/opentype/truetype/GlyphLoader.java
@@ -38,6 +38,8 @@ 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;
 
@@ -112,17 +114,17 @@ final class GlyphLoader
                         double pointSize,
                         AffineTransform transform,
                         boolean antialias,
-                        Zone glyphZone)
+                        Zone glyphZone, Hinter hinter)
   {
     glyphZone.setNumPoints(4);
     loadSubGlyph(glyphIndex, pointSize, transform, antialias, glyphZone,
-                 0, 0);
+                 0, 0, hinter);
   }
 
   public void loadGlyph(int glyphIndex, AffineTransform transform,
-                        Zone glyphZone)
+                        Zone glyphZone, Hinter hinter)
   {
-    loadGlyph(glyphIndex, unitsPerEm, transform, false, glyphZone);
+    loadGlyph(glyphIndex, unitsPerEm, transform, false, glyphZone, hinter);
   }
 
   private void loadSubGlyph(int glyphIndex,
@@ -131,7 +133,8 @@ final class GlyphLoader
                             boolean antialias,
                             Zone glyphZone,
                             int preTranslateX,
-                            int preTranslateY)
+                            int preTranslateY,
+                            Hinter hinter)
   {
     ByteBuffer glyph;
     int numContours;
@@ -159,11 +162,11 @@ final class GlyphLoader
     if (numContours >= 0)
       loadSimpleGlyph(glyphIndex, pointSize, transform, antialias,
                       numContours, glyph, glyphZone,
-                      preTranslateX, preTranslateY);
+                      preTranslateX, preTranslateY, hinter);
     else
       loadCompoundGlyph(glyphIndex, pointSize, transform, antialias,
                         glyph, glyphZone,
-                        preTranslateX, preTranslateY);
+                        preTranslateX, preTranslateY, hinter);
   }
 
 
@@ -172,7 +175,8 @@ final class GlyphLoader
                                boolean antialias,
                                int numContours, ByteBuffer glyph,
                                Zone glyphZone,
-                               int preTranslateX, int preTranslateY)
+                               int preTranslateX, int preTranslateY,
+                               Hinter hinter)
   {
     int numPoints;
     int posInstructions, numInstructions;
@@ -203,10 +207,10 @@ final class GlyphLoader
     glyphZone.transform(pointSize, transform, unitsPerEm,
                         preTranslateX, preTranslateY);
 
-    if (execInstructions)
-    {
-      // FIXME: Hint the glyph.
-    }
+    if (execInstructions && hinter != null)
+      {
+        hinter.applyHints(glyphZone);
+      }
   }
 
 
@@ -229,7 +233,8 @@ final class GlyphLoader
                                  boolean antialias,
                                  ByteBuffer glyph,
                                  Zone glyphZone,
-                                 int preTranslateX, int preTranslateY)
+                                 int preTranslateX, int preTranslateY,
+                                 Hinter hinter)
   {
     short flags;
     int subGlyphIndex;
@@ -326,7 +331,7 @@ final class GlyphLoader
       loadSubGlyph(subGlyphIndex, pointSize, componentTransform,
                    antialias, subGlyphZone,
                    Math.round((float) e + preTranslateX),
-                   Math.round(-((float) f + preTranslateY)));
+                   Math.round(-((float) f + preTranslateY)), hinter);
       glyphZone.combineWithSubGlyph(subGlyphZone, 4);
       glyph.limit(lim).position(pos);
     }
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 0000000..c9664d2
--- /dev/null
+++ b/libjava/classpath/gnu/java/awt/font/opentype/truetype/Point.java
@@ -0,0 +1,285 @@
+/* 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;
+
+/**
+ * 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()
+  {
+    StringBuilder s = new StringBuilder();
+    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
index 8dfdeff..5f5cc00 100644
--- a/libjava/classpath/gnu/java/awt/font/opentype/truetype/TrueTypeScaler.java
+++ b/libjava/classpath/gnu/java/awt/font/opentype/truetype/TrueTypeScaler.java
@@ -37,6 +37,7 @@ 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;
@@ -191,17 +192,18 @@ public final class TrueTypeScaler
                                 float pointSize,
                                 AffineTransform deviceTransform,
                                 boolean antialias,
-                                boolean fractionalMetrics)
+                                boolean fractionalMetrics, Hinter hinter,
+                                int type)
   {
     glyphLoader.loadGlyph(glyphIndex, pointSize, deviceTransform,
-                          antialias, glyphZone);
-    return glyphZone.getPath();
+                          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);
+    glyphLoader.loadGlyph(glyphIndex, transform, zone, null);
     return zone;
   }
 
diff --git a/libjava/classpath/gnu/java/awt/font/opentype/truetype/Zone.java b/libjava/classpath/gnu/java/awt/font/opentype/truetype/Zone.java
index ff5bb63..7c25a0a 100644
--- a/libjava/classpath/gnu/java/awt/font/opentype/truetype/Zone.java
+++ b/libjava/classpath/gnu/java/awt/font/opentype/truetype/Zone.java
@@ -37,6 +37,8 @@ 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;
@@ -47,27 +49,19 @@ import java.awt.geom.PathIterator;
  */
 public final class Zone
 {
-  private final int[] pos;
-  private final int[] origPos;
-  private final byte[] flags;
+  private Point[] points;
   private int numPoints;
 
-  private static final int FLAG_TOUCHED_X = 1;
-  private static final int FLAG_TOUCHED_Y = 2;
-  private static final int FLAG_ON_CURVE = 4;
-  private static final int FLAG_CONTOUR_END = 8;
+  public double scaleX, scaleY, shearX, shearY;
 
   public Zone(int maxNumPoints)
   {
-    origPos = new int[maxNumPoints * 2];
-    pos = new int[maxNumPoints * 2];
-    flags = new byte[maxNumPoints];
+    points = new Point[maxNumPoints];
   }
 
-
   public int getCapacity()
   {
-    return flags.length;
+    return points.length;
   }
 
 
@@ -79,91 +73,110 @@ public final class Zone
 
   public int getX(int point)
   {
-    return pos[2 * 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)
   {
-    pos[2 * point] = value;
+    points[point].scaledX = value;
+    points[point].x = value;
     if (touch)
-      flags[point] |= FLAG_TOUCHED_X;
+      points[point].flags |= Point.FLAG_TOUCHED_X;
   }
 
 
   public void setY(int point, int value, boolean touch)
   {
-    pos[2 * point + 1] = value;
+    points[point].scaledY = value;
+    points[point].y = value;
     if (touch)
-      flags[point] |= FLAG_TOUCHED_Y;
+      points[point].flags |= Point.FLAG_TOUCHED_Y;
   }
 
-
   public int getY(int point)
   {
-    return pos[2 * point + 1];
+    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 origPos[2 * point];
+    return points[point].origX;
   }
 
 
   public int getOriginalY(int point)
   {
-    return origPos[2 * point + 1];
+    return points[point].origY;
   }
 
 
   public void setOriginalX(int point, int x)
   {
-    origPos[2 * point] = x;
+    points[point].origX = x;
   }
 
   public void setOriginalY(int point, int y)
   {
-    origPos[2 * point + 1] = y;
+    points[point].origY = y;
   }
 
   public void setNumPoints(int numPoints)
   {
-    this.numPoints = numPoints;
     for (int i = 0; i < numPoints; i++)
-      flags[i] = 0;
-    for (int i = 0; i < 2 * numPoints; i++)
-      origPos[i] = pos[i] = 0;
+      points[i] = new Point();
+    this.numPoints = numPoints;
   }
 
 
   public boolean isOnCurve(int point)
   {
-    return (flags[point] & FLAG_ON_CURVE) != 0;
+    return (points[point].flags & Point.FLAG_ON_CURVE) != 0;
   }
 
 
   public void setOnCurve(int point, boolean onCurve)
   {
     if (onCurve)
-      flags[point] |= FLAG_ON_CURVE;
+      points[point].flags |= Point.FLAG_ON_CURVE;
     else
-      flags[point] &= ~FLAG_ON_CURVE;
+      points[point].flags &= ~Point.FLAG_ON_CURVE;
   }
 
 
   public boolean isContourEnd(int point)
   {
-    return (flags[point] & FLAG_CONTOUR_END) != 0;
+    return (points[point].flags & Point.FLAG_CONTOUR_END) != 0;
   }
 
 
   public void setContourEnd(int point, boolean segEnd)
   {
     if (segEnd)
-      flags[point] |= FLAG_CONTOUR_END;
+      points[point].flags |= Point.FLAG_CONTOUR_END;
     else
-      flags[point] &= ~FLAG_CONTOUR_END;
+      points[point].flags &= ~Point.FLAG_CONTOUR_END;
   }
 
 
@@ -172,7 +185,6 @@ public final class Zone
   void transform(double pointSize, AffineTransform deviceTransform,
                  int unitsPerEm, int preTranslateX, int preTranslateY)
   {
-    double scaleX, scaleY, shearX, shearY;
     double factor;
 
     factor = pointSize / (double) unitsPerEm;
@@ -183,11 +195,13 @@ public final class Zone
 
     for (int i = 0; i < numPoints; i++)
     {
-      int x = origPos[2 * i] + preTranslateX;
-      int y = origPos[2 * i + 1] + preTranslateY;
+      int x = points[i].origX + preTranslateX;
+      int y = points[i].origY + preTranslateY;
 
-      origPos[2*i] = pos[2 * i] = Fixed.valueOf(scaleX * x + shearX * y);
-      origPos[2*i+1] = pos[2 * i + 1] = Fixed.valueOf(shearY * x + scaleY * y);
+      points[i].scaledX = points[i].x = Fixed.valueOf(scaleX * x
+                                                      + shearX * y);
+      points[i].scaledY = points[i].y = Fixed.valueOf(shearY * x
+                                                      + scaleY * y);
     }
   }
 
@@ -197,11 +211,7 @@ public final class Zone
   {
     int offset = this.numPoints - numPhantomPoints;
     int count = zone.numPoints;
-    System.arraycopy(zone.origPos, 0, this.origPos, 2 * offset,
-                     count * 2);
-    System.arraycopy(zone.pos, 0, this.pos, 2 * offset,
-                     count * 2);
-    System.arraycopy(zone.flags, 0, this.flags, offset, count);
+    System.arraycopy(zone.points, 0, this.points, offset, count);
     this.numPoints += count - numPhantomPoints;
   }
 
@@ -211,9 +221,9 @@ public final class Zone
     for (int i = 0; i < numPoints; i++)
     {
       System.out.print(" " + i + ": ");
-      System.out.print(Fixed.toString(pos[i*2], pos[i*2+1]));
+      System.out.print(Fixed.toString(points[i].scaledX, points[i].scaledY));
       System.out.print(' ');
-      System.out.print(Fixed.toString(origPos[i*2], origPos[i*2+1]));
+      System.out.print(Fixed.toString(points[i].origX, points[i].origY));
       System.out.print(' ');
       if (isOnCurve(i))
         System.out.print('.');
@@ -228,16 +238,54 @@ public final class Zone
   }
 
 
-  public PathIterator getPathIterator()
+  public PathIterator getPathIterator(int type)
   {
-    return new ZonePathIterator(this);
+    return new ZonePathIterator(this, type);
   }
 
 
-  public GeneralPath getPath()
+  public GeneralPath getPath(int type)
   {
     GeneralPath p = new GeneralPath(GeneralPath.WIND_NON_ZERO, numPoints);
-    p.append(getPathIterator(), /* connect */ false);
+    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
index d000b9c..0f60828 100644
--- a/libjava/classpath/gnu/java/awt/font/opentype/truetype/ZonePathIterator.java
+++ b/libjava/classpath/gnu/java/awt/font/opentype/truetype/ZonePathIterator.java
@@ -116,6 +116,7 @@ final class ZonePathIterator
   private int contourStart;
 
   
+  private int type;
 
   /**
    * Constructs a ZonePathIterator for the specified zone.
@@ -123,9 +124,10 @@ final class ZonePathIterator
    * @param zone the zone whose segments will be enumerated
    * by this iterator.
    */
-  ZonePathIterator(Zone zone)
+  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.
@@ -309,8 +311,8 @@ final class ZonePathIterator
     int curX, curY;
     int succ, succX, succY;
 
-    curX = zone.getX(cur);
-    curY = zone.getY(cur);
+    curX = zone.getX(cur, type);
+    curY = zone.getY(cur, type);
     coords[0] = Fixed.floatValue(curX);
     coords[1] = Fixed.floatValue(curY);
 
@@ -318,8 +320,8 @@ final class ZonePathIterator
       return PathIterator.SEG_LINETO;
 
     succ = getSuccessor(cur);
-    succX = zone.getX(succ);
-    succY = zone.getY(succ);
+    succX = zone.getX(succ, type);
+    succY = zone.getY(succ, type);
 
     if (zone.isOnCurve(succ))
     {
@@ -359,8 +361,8 @@ final class ZonePathIterator
 
     if (zone.isOnCurve(contourStart))
     {
-      x = zone.getX(contourStart);
-      y = zone.getY(contourStart);    
+      x = zone.getX(contourStart, type);
+      y = zone.getY(contourStart, type);    
     }
     else
     {
@@ -374,13 +376,13 @@ final class ZonePathIterator
         /* An example is the 'o' glyph of the Helvetica which comes
          * with Apple MacOS X 10.1.5.
          */
-        x = zone.getX(contourEnd);
-        y = zone.getY(contourEnd);
+        x = zone.getX(contourEnd, type);
+        y = zone.getY(contourEnd, type);
       }
       else
       {
-        x = (zone.getX(contourStart) + zone.getX(contourEnd)) / 2;
-        y = (zone.getY(contourStart) + zone.getY(contourEnd)) / 2;
+        x = (zone.getX(contourStart, type) + zone.getX(contourEnd, type)) / 2;
+        y = (zone.getY(contourStart, type) + zone.getY(contourEnd, type)) / 2;
       }
     }