feat(jdk8): move files to new folder to avoid resources compiled.

jdkSrc/jdk8/sun/dc/DuctusRenderingEngine.java

@@ -0,0 +1,836 @@
+/*
+ * Copyright (c) 2007, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.dc;
+
+import java.awt.Shape;
+import java.awt.BasicStroke;
+import java.awt.geom.Path2D;
+import java.awt.geom.PathIterator;
+import java.awt.geom.AffineTransform;
+
+import sun.awt.geom.PathConsumer2D;
+import sun.java2d.pipe.Region;
+import sun.java2d.pipe.AATileGenerator;
+import sun.java2d.pipe.RenderingEngine;
+
+import sun.dc.pr.Rasterizer;
+import sun.dc.pr.PathStroker;
+import sun.dc.pr.PathDasher;
+import sun.dc.pr.PRException;
+import sun.dc.path.PathConsumer;
+import sun.dc.path.PathException;
+import sun.dc.path.FastPathProducer;
+
+public class DuctusRenderingEngine extends RenderingEngine {
+    static final float PenUnits = 0.01f;
+    static final int MinPenUnits = 100;
+    static final int MinPenUnitsAA = 20;
+    static final float MinPenSizeAA = PenUnits * MinPenUnitsAA;
+
+    static final float UPPER_BND = Float.MAX_VALUE / 2.0f;
+    static final float LOWER_BND = -UPPER_BND;
+
+    private static final int RasterizerCaps[] = {
+        Rasterizer.BUTT, Rasterizer.ROUND, Rasterizer.SQUARE
+    };
+
+    private static final int RasterizerCorners[] = {
+        Rasterizer.MITER, Rasterizer.ROUND, Rasterizer.BEVEL
+    };
+
+    static float[] getTransformMatrix(AffineTransform transform) {
+        float matrix[] = new float[4];
+        double dmatrix[] = new double[6];
+        transform.getMatrix(dmatrix);
+        for (int i = 0; i < 4; i++) {
+            matrix[i] = (float) dmatrix[i];
+        }
+        return matrix;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Shape createStrokedShape(Shape src,
+                                    float width,
+                                    int caps,
+                                    int join,
+                                    float miterlimit,
+                                    float dashes[],
+                                    float dashphase)
+    {
+        FillAdapter filler = new FillAdapter();
+        PathStroker stroker = new PathStroker(filler);
+        PathDasher dasher = null;
+
+        try {
+            PathConsumer consumer;
+
+            stroker.setPenDiameter(width);
+            stroker.setPenT4(null);
+            stroker.setCaps(RasterizerCaps[caps]);
+            stroker.setCorners(RasterizerCorners[join], miterlimit);
+            if (dashes != null) {
+                dasher = new PathDasher(stroker);
+                dasher.setDash(dashes, dashphase);
+                dasher.setDashT4(null);
+                consumer = dasher;
+            } else {
+                consumer = stroker;
+            }
+
+            feedConsumer(consumer, src.getPathIterator(null));
+        } finally {
+            stroker.dispose();
+            if (dasher != null) {
+                dasher.dispose();
+            }
+        }
+
+        return filler.getShape();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void strokeTo(Shape src,
+                         AffineTransform transform,
+                         BasicStroke bs,
+                         boolean thin,
+                         boolean normalize,
+                         boolean antialias,
+                         PathConsumer2D sr)
+    {
+        PathStroker stroker = new PathStroker(sr);
+        PathConsumer consumer = stroker;
+
+        float matrix[] = null;
+        if (!thin) {
+            stroker.setPenDiameter(bs.getLineWidth());
+            if (transform != null) {
+                matrix = getTransformMatrix(transform);
+            }
+            stroker.setPenT4(matrix);
+            stroker.setPenFitting(PenUnits, MinPenUnits);
+        }
+        stroker.setCaps(RasterizerCaps[bs.getEndCap()]);
+        stroker.setCorners(RasterizerCorners[bs.getLineJoin()],
+                           bs.getMiterLimit());
+        float[] dashes = bs.getDashArray();
+        if (dashes != null) {
+            PathDasher dasher = new PathDasher(stroker);
+            dasher.setDash(dashes, bs.getDashPhase());
+            if (transform != null && matrix == null) {
+                matrix = getTransformMatrix(transform);
+            }
+            dasher.setDashT4(matrix);
+            consumer = dasher;
+        }
+
+        try {
+            PathIterator pi = src.getPathIterator(transform);
+
+            feedConsumer(pi, consumer, normalize, 0.25f);
+        } catch (PathException e) {
+            throw new InternalError("Unable to Stroke shape ("+
+                                    e.getMessage()+")", e);
+        } finally {
+            while (consumer != null && consumer != sr) {
+                PathConsumer next = consumer.getConsumer();
+                consumer.dispose();
+                consumer = next;
+            }
+        }
+    }
+
+    /*
+     * Feed a path from a PathIterator to a Ductus PathConsumer.
+     */
+    public static void feedConsumer(PathIterator pi, PathConsumer consumer,
+                                    boolean normalize, float norm)
+        throws PathException
+    {
+        consumer.beginPath();
+        boolean pathClosed = false;
+        boolean skip = false;
+        boolean subpathStarted = false;
+        float mx = 0.0f;
+        float my = 0.0f;
+        float point[]  = new float[6];
+        float rnd = (0.5f - norm);
+        float ax = 0.0f;
+        float ay = 0.0f;
+
+        while (!pi.isDone()) {
+            int type = pi.currentSegment(point);
+            if (pathClosed == true) {
+                pathClosed = false;
+                if (type != PathIterator.SEG_MOVETO) {
+                    // Force current point back to last moveto point
+                    consumer.beginSubpath(mx, my);
+                    subpathStarted = true;
+                }
+            }
+            if (normalize) {
+                int index;
+                switch (type) {
+                case PathIterator.SEG_CUBICTO:
+                    index = 4;
+                    break;
+                case PathIterator.SEG_QUADTO:
+                    index = 2;
+                    break;
+                case PathIterator.SEG_MOVETO:
+                case PathIterator.SEG_LINETO:
+                    index = 0;
+                    break;
+                case PathIterator.SEG_CLOSE:
+                default:
+                    index = -1;
+                    break;
+                }
+                if (index >= 0) {
+                    float ox = point[index];
+                    float oy = point[index+1];
+                    float newax = (float) Math.floor(ox + rnd) + norm;
+                    float neway = (float) Math.floor(oy + rnd) + norm;
+                    point[index] = newax;
+                    point[index+1] = neway;
+                    newax -= ox;
+                    neway -= oy;
+                    switch (type) {
+                    case PathIterator.SEG_CUBICTO:
+                        point[0] += ax;
+                        point[1] += ay;
+                        point[2] += newax;
+                        point[3] += neway;
+                        break;
+                    case PathIterator.SEG_QUADTO:
+                        point[0] += (newax + ax) / 2;
+                        point[1] += (neway + ay) / 2;
+                        break;
+                    case PathIterator.SEG_MOVETO:
+                    case PathIterator.SEG_LINETO:
+                    case PathIterator.SEG_CLOSE:
+                        break;
+                    }
+                    ax = newax;
+                    ay = neway;
+                }
+            }
+            switch (type) {
+            case PathIterator.SEG_MOVETO:
+
+                /* Checking SEG_MOVETO coordinates if they are out of the
+                 * [LOWER_BND, UPPER_BND] range. This check also handles NaN
+                 * and Infinity values. Skipping next path segment in case of
+                 * invalid data.
+                 */
+                if (point[0] < UPPER_BND && point[0] > LOWER_BND &&
+                    point[1] < UPPER_BND && point[1] > LOWER_BND)
+                {
+                    mx = point[0];
+                    my = point[1];
+                    consumer.beginSubpath(mx, my);
+                    subpathStarted = true;
+                    skip = false;
+                } else {
+                    skip = true;
+                }
+                break;
+            case PathIterator.SEG_LINETO:
+                /* Checking SEG_LINETO coordinates if they are out of the
+                 * [LOWER_BND, UPPER_BND] range. This check also handles NaN
+                 * and Infinity values. Ignoring current path segment in case
+                 * of invalid data. If segment is skipped its endpoint
+                 * (if valid) is used to begin new subpath.
+                 */
+                if (point[0] < UPPER_BND && point[0] > LOWER_BND &&
+                    point[1] < UPPER_BND && point[1] > LOWER_BND)
+                {
+                    if (skip) {
+                        consumer.beginSubpath(point[0], point[1]);
+                        subpathStarted = true;
+                        skip = false;
+                    } else {
+                        consumer.appendLine(point[0], point[1]);
+                    }
+                }
+                break;
+            case PathIterator.SEG_QUADTO:
+                // Quadratic curves take two points
+
+                /* Checking SEG_QUADTO coordinates if they are out of the
+                 * [LOWER_BND, UPPER_BND] range. This check also handles NaN
+                 * and Infinity values. Ignoring current path segment in case
+                 * of invalid endpoints's data. Equivalent to the SEG_LINETO
+                 * if endpoint coordinates are valid but there are invalid data
+                 * among other coordinates
+                 */
+                if (point[2] < UPPER_BND && point[2] > LOWER_BND &&
+                    point[3] < UPPER_BND && point[3] > LOWER_BND)
+                {
+                    if (skip) {
+                        consumer.beginSubpath(point[2], point[3]);
+                        subpathStarted = true;
+                        skip = false;
+                    } else {
+                        if (point[0] < UPPER_BND && point[0] > LOWER_BND &&
+                            point[1] < UPPER_BND && point[1] > LOWER_BND)
+                        {
+                            consumer.appendQuadratic(point[0], point[1],
+                                                     point[2], point[3]);
+                        } else {
+                            consumer.appendLine(point[2], point[3]);
+                        }
+                    }
+                }
+                break;
+            case PathIterator.SEG_CUBICTO:
+                // Cubic curves take three points
+
+                /* Checking SEG_CUBICTO coordinates if they are out of the
+                 * [LOWER_BND, UPPER_BND] range. This check also handles NaN
+                 * and Infinity values. Ignoring current path segment in case
+                 * of invalid endpoints's data. Equivalent to the SEG_LINETO
+                 * if endpoint coordinates are valid but there are invalid data
+                 * among other coordinates
+                 */
+                if (point[4] < UPPER_BND && point[4] > LOWER_BND &&
+                    point[5] < UPPER_BND && point[5] > LOWER_BND)
+                {
+                    if (skip) {
+                        consumer.beginSubpath(point[4], point[5]);
+                        subpathStarted = true;
+                        skip = false;
+                    } else {
+                        if (point[0] < UPPER_BND && point[0] > LOWER_BND &&
+                            point[1] < UPPER_BND && point[1] > LOWER_BND &&
+                            point[2] < UPPER_BND && point[2] > LOWER_BND &&
+                            point[3] < UPPER_BND && point[3] > LOWER_BND)
+                        {
+                            consumer.appendCubic(point[0], point[1],
+                                                 point[2], point[3],
+                                                 point[4], point[5]);
+                        } else {
+                            consumer.appendLine(point[4], point[5]);
+                        }
+                    }
+                }
+                break;
+            case PathIterator.SEG_CLOSE:
+                if (subpathStarted) {
+                    consumer.closedSubpath();
+                    subpathStarted = false;
+                    pathClosed = true;
+                }
+                break;
+            }
+            pi.next();
+        }
+
+        consumer.endPath();
+    }
+
+    private static Rasterizer theRasterizer;
+
+    public synchronized static Rasterizer getRasterizer() {
+        Rasterizer r = theRasterizer;
+        if (r == null) {
+            r = new Rasterizer();
+        } else {
+            theRasterizer = null;
+        }
+        return r;
+    }
+
+    public synchronized static void dropRasterizer(Rasterizer r) {
+        r.reset();
+        theRasterizer = r;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public float getMinimumAAPenSize() {
+        return MinPenSizeAA;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public AATileGenerator getAATileGenerator(Shape s,
+                                              AffineTransform at,
+                                              Region clip,
+                                              BasicStroke bs,
+                                              boolean thin,
+                                              boolean normalize,
+                                              int bbox[])
+    {
+        Rasterizer r = getRasterizer();
+        PathIterator pi = s.getPathIterator(at);
+
+        if (bs != null) {
+            float matrix[] = null;
+            r.setUsage(Rasterizer.STROKE);
+            if (thin) {
+                r.setPenDiameter(MinPenSizeAA);
+            } else {
+                r.setPenDiameter(bs.getLineWidth());
+                if (at != null) {
+                    matrix = getTransformMatrix(at);
+                    r.setPenT4(matrix);
+                }
+                r.setPenFitting(PenUnits, MinPenUnitsAA);
+            }
+            r.setCaps(RasterizerCaps[bs.getEndCap()]);
+            r.setCorners(RasterizerCorners[bs.getLineJoin()],
+                         bs.getMiterLimit());
+            float[] dashes = bs.getDashArray();
+            if (dashes != null) {
+                r.setDash(dashes, bs.getDashPhase());
+                if (at != null && matrix == null) {
+                    matrix = getTransformMatrix(at);
+                }
+                r.setDashT4(matrix);
+            }
+        } else {
+            r.setUsage(pi.getWindingRule() == PathIterator.WIND_EVEN_ODD
+                       ? Rasterizer.EOFILL
+                       : Rasterizer.NZFILL);
+        }
+
+        r.beginPath();
+        {
+            boolean pathClosed = false;
+            boolean skip = false;
+            boolean subpathStarted = false;
+            float mx = 0.0f;
+            float my = 0.0f;
+            float point[]  = new float[6];
+            float ax = 0.0f;
+            float ay = 0.0f;
+
+            while (!pi.isDone()) {
+                int type = pi.currentSegment(point);
+                if (pathClosed == true) {
+                    pathClosed = false;
+                    if (type != PathIterator.SEG_MOVETO) {
+                        // Force current point back to last moveto point
+                        r.beginSubpath(mx, my);
+                        subpathStarted = true;
+                    }
+                }
+                if (normalize) {
+                    int index;
+                    switch (type) {
+                    case PathIterator.SEG_CUBICTO:
+                        index = 4;
+                        break;
+                    case PathIterator.SEG_QUADTO:
+                        index = 2;
+                        break;
+                    case PathIterator.SEG_MOVETO:
+                    case PathIterator.SEG_LINETO:
+                        index = 0;
+                        break;
+                    case PathIterator.SEG_CLOSE:
+                    default:
+                        index = -1;
+                        break;
+                    }
+                    if (index >= 0) {
+                        float ox = point[index];
+                        float oy = point[index+1];
+                        float newax = (float) Math.floor(ox) + 0.5f;
+                        float neway = (float) Math.floor(oy) + 0.5f;
+                        point[index] = newax;
+                        point[index+1] = neway;
+                        newax -= ox;
+                        neway -= oy;
+                        switch (type) {
+                        case PathIterator.SEG_CUBICTO:
+                            point[0] += ax;
+                            point[1] += ay;
+                            point[2] += newax;
+                            point[3] += neway;
+                            break;
+                        case PathIterator.SEG_QUADTO:
+                            point[0] += (newax + ax) / 2;
+                            point[1] += (neway + ay) / 2;
+                            break;
+                        case PathIterator.SEG_MOVETO:
+                        case PathIterator.SEG_LINETO:
+                        case PathIterator.SEG_CLOSE:
+                            break;
+                        }
+                        ax = newax;
+                        ay = neway;
+                    }
+                }
+                switch (type) {
+                case PathIterator.SEG_MOVETO:
+
+                   /* Checking SEG_MOVETO coordinates if they are out of the
+                    * [LOWER_BND, UPPER_BND] range. This check also handles NaN
+                    * and Infinity values. Skipping next path segment in case
+                    * of invalid data.
+                    */
+
+                    if (point[0] < UPPER_BND &&  point[0] > LOWER_BND &&
+                        point[1] < UPPER_BND &&  point[1] > LOWER_BND)
+                    {
+                        mx = point[0];
+                        my = point[1];
+                        r.beginSubpath(mx, my);
+                        subpathStarted = true;
+                        skip = false;
+                    } else {
+                        skip = true;
+                    }
+                    break;
+
+                case PathIterator.SEG_LINETO:
+                    /* Checking SEG_LINETO coordinates if they are out of the
+                     * [LOWER_BND, UPPER_BND] range. This check also handles
+                     * NaN and Infinity values. Ignoring current path segment
+                     * in case of invalid data. If segment is skipped its
+                     * endpoint (if valid) is used to begin new subpath.
+                     */
+                    if (point[0] < UPPER_BND && point[0] > LOWER_BND &&
+                        point[1] < UPPER_BND && point[1] > LOWER_BND)
+                    {
+                        if (skip) {
+                            r.beginSubpath(point[0], point[1]);
+                            subpathStarted = true;
+                            skip = false;
+                        } else {
+                            r.appendLine(point[0], point[1]);
+                        }
+                    }
+                    break;
+
+                case PathIterator.SEG_QUADTO:
+                    // Quadratic curves take two points
+
+                    /* Checking SEG_QUADTO coordinates if they are out of the
+                     * [LOWER_BND, UPPER_BND] range. This check also handles
+                     * NaN and Infinity values. Ignoring current path segment
+                     * in case of invalid endpoints's data. Equivalent to the
+                     * SEG_LINETO if endpoint coordinates are valid but there
+                     * are invalid data among other coordinates
+                     */
+                    if (point[2] < UPPER_BND && point[2] > LOWER_BND &&
+                        point[3] < UPPER_BND && point[3] > LOWER_BND)
+                    {
+                        if (skip) {
+                            r.beginSubpath(point[2], point[3]);
+                            subpathStarted = true;
+                            skip = false;
+                        } else {
+                            if (point[0] < UPPER_BND && point[0] > LOWER_BND &&
+                                point[1] < UPPER_BND && point[1] > LOWER_BND)
+                            {
+                                r.appendQuadratic(point[0], point[1],
+                                                  point[2], point[3]);
+                            } else {
+                                r.appendLine(point[2], point[3]);
+                            }
+                        }
+                    }
+                    break;
+                case PathIterator.SEG_CUBICTO:
+                    // Cubic curves take three points
+
+                    /* Checking SEG_CUBICTO coordinates if they are out of the
+                     * [LOWER_BND, UPPER_BND] range. This check also handles
+                     * NaN and Infinity values. Ignoring  current path segment
+                     * in case of invalid endpoints's data. Equivalent to the
+                     * SEG_LINETO if endpoint coordinates are valid but there
+                     * are invalid data among other coordinates
+                     */
+
+                    if (point[4] < UPPER_BND && point[4] > LOWER_BND &&
+                        point[5] < UPPER_BND && point[5] > LOWER_BND)
+                    {
+                        if (skip) {
+                            r.beginSubpath(point[4], point[5]);
+                            subpathStarted = true;
+                            skip = false;
+                        } else {
+                            if (point[0] < UPPER_BND && point[0] > LOWER_BND &&
+                                point[1] < UPPER_BND && point[1] > LOWER_BND &&
+                                point[2] < UPPER_BND && point[2] > LOWER_BND &&
+                                point[3] < UPPER_BND && point[3] > LOWER_BND)
+                            {
+                                r.appendCubic(point[0], point[1],
+                                              point[2], point[3],
+                                              point[4], point[5]);
+                            } else {
+                                r.appendLine(point[4], point[5]);
+                            }
+                        }
+                    }
+                    break;
+                case PathIterator.SEG_CLOSE:
+                    if (subpathStarted) {
+                        r.closedSubpath();
+                        subpathStarted = false;
+                        pathClosed = true;
+                    }
+                    break;
+                }
+                pi.next();
+            }
+        }
+
+        try {
+            r.endPath();
+            r.getAlphaBox(bbox);
+            clip.clipBoxToBounds(bbox);
+            if (bbox[0] >= bbox[2] || bbox[1] >= bbox[3]) {
+                dropRasterizer(r);
+                return null;
+            }
+            r.setOutputArea(bbox[0], bbox[1],
+                            bbox[2] - bbox[0],
+                            bbox[3] - bbox[1]);
+        } catch (PRException e) {
+            /*
+             * This exeption is thrown from the native part of the Ductus
+             * (only in case of a debug build) to indicate that some
+             * segments of the path have very large coordinates.
+             * See 4485298 for more info.
+             */
+            System.err.println("DuctusRenderingEngine.getAATileGenerator: "+e);
+        }
+
+        return r;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public AATileGenerator getAATileGenerator(double x, double y,
+                                              double dx1, double dy1,
+                                              double dx2, double dy2,
+                                              double lw1, double lw2,
+                                              Region clip,
+                                              int bbox[])
+    {
+        // REMIND: Deal with large coordinates!
+        double ldx1, ldy1, ldx2, ldy2;
+        boolean innerpgram = (lw1 > 0 && lw2 > 0);
+
+        if (innerpgram) {
+            ldx1 = dx1 * lw1;
+            ldy1 = dy1 * lw1;
+            ldx2 = dx2 * lw2;
+            ldy2 = dy2 * lw2;
+            x -= (ldx1 + ldx2) / 2.0;
+            y -= (ldy1 + ldy2) / 2.0;
+            dx1 += ldx1;
+            dy1 += ldy1;
+            dx2 += ldx2;
+            dy2 += ldy2;
+            if (lw1 > 1 && lw2 > 1) {
+                // Inner parallelogram was entirely consumed by stroke...
+                innerpgram = false;
+            }
+        } else {
+            ldx1 = ldy1 = ldx2 = ldy2 = 0;
+        }
+
+        Rasterizer r = getRasterizer();
+
+        r.setUsage(Rasterizer.EOFILL);
+
+        r.beginPath();
+        r.beginSubpath((float) x, (float) y);
+        r.appendLine((float) (x+dx1), (float) (y+dy1));
+        r.appendLine((float) (x+dx1+dx2), (float) (y+dy1+dy2));
+        r.appendLine((float) (x+dx2), (float) (y+dy2));
+        r.closedSubpath();
+        if (innerpgram) {
+            x += ldx1 + ldx2;
+            y += ldy1 + ldy2;
+            dx1 -= 2.0 * ldx1;
+            dy1 -= 2.0 * ldy1;
+            dx2 -= 2.0 * ldx2;
+            dy2 -= 2.0 * ldy2;
+            r.beginSubpath((float) x, (float) y);
+            r.appendLine((float) (x+dx1), (float) (y+dy1));
+            r.appendLine((float) (x+dx1+dx2), (float) (y+dy1+dy2));
+            r.appendLine((float) (x+dx2), (float) (y+dy2));
+            r.closedSubpath();
+        }
+
+        try {
+            r.endPath();
+            r.getAlphaBox(bbox);
+            clip.clipBoxToBounds(bbox);
+            if (bbox[0] >= bbox[2] || bbox[1] >= bbox[3]) {
+                dropRasterizer(r);
+                return null;
+            }
+            r.setOutputArea(bbox[0], bbox[1],
+                            bbox[2] - bbox[0],
+                            bbox[3] - bbox[1]);
+        } catch (PRException e) {
+            /*
+             * This exeption is thrown from the native part of the Ductus
+             * (only in case of a debug build) to indicate that some
+             * segments of the path have very large coordinates.
+             * See 4485298 for more info.
+             */
+            System.err.println("DuctusRenderingEngine.getAATileGenerator: "+e);
+        }
+
+        return r;
+    }
+
+    private void feedConsumer(PathConsumer consumer, PathIterator pi) {
+        try {
+            consumer.beginPath();
+            boolean pathClosed = false;
+            float mx = 0.0f;
+            float my = 0.0f;
+            float point[]  = new float[6];
+
+            while (!pi.isDone()) {
+                int type = pi.currentSegment(point);
+                if (pathClosed == true) {
+                    pathClosed = false;
+                    if (type != PathIterator.SEG_MOVETO) {
+                        // Force current point back to last moveto point
+                        consumer.beginSubpath(mx, my);
+                    }
+                }
+                switch (type) {
+                case PathIterator.SEG_MOVETO:
+                    mx = point[0];
+                    my = point[1];
+                    consumer.beginSubpath(point[0], point[1]);
+                    break;
+                case PathIterator.SEG_LINETO:
+                    consumer.appendLine(point[0], point[1]);
+                    break;
+                case PathIterator.SEG_QUADTO:
+                    consumer.appendQuadratic(point[0], point[1],
+                                             point[2], point[3]);
+                    break;
+                case PathIterator.SEG_CUBICTO:
+                    consumer.appendCubic(point[0], point[1],
+                                         point[2], point[3],
+                                         point[4], point[5]);
+                    break;
+                case PathIterator.SEG_CLOSE:
+                    consumer.closedSubpath();
+                    pathClosed = true;
+                    break;
+                }
+                pi.next();
+            }
+
+            consumer.endPath();
+        } catch (PathException e) {
+            throw new InternalError("Unable to Stroke shape ("+
+                                    e.getMessage()+")", e);
+        }
+    }
+
+    private class FillAdapter implements PathConsumer {
+        boolean closed;
+        Path2D.Float path;
+
+        public FillAdapter() {
+            // Ductus only supplies float coordinates so
+            // Path2D.Double is not necessary here.
+            path = new Path2D.Float(Path2D.WIND_NON_ZERO);
+        }
+
+        public Shape getShape() {
+            return path;
+        }
+
+        public void dispose() {
+        }
+
+        public PathConsumer getConsumer() {
+            return null;
+        }
+
+        public void beginPath() {}
+
+        public void beginSubpath(float x0, float y0) {
+            if (closed) {
+                path.closePath();
+                closed = false;
+            }
+            path.moveTo(x0, y0);
+        }
+
+        public void appendLine(float x1, float y1) {
+            path.lineTo(x1, y1);
+        }
+
+        public void appendQuadratic(float xm, float ym, float x1, float y1) {
+            path.quadTo(xm, ym, x1, y1);
+        }
+
+        public void appendCubic(float xm, float ym,
+                                float xn, float yn,
+                                float x1, float y1) {
+            path.curveTo(xm, ym, xn, yn, x1, y1);
+        }
+
+        public void closedSubpath() {
+            closed = true;
+        }
+
+        public void endPath() {
+            if (closed) {
+                path.closePath();
+                closed = false;
+            }
+        }
+
+        public void useProxy(FastPathProducer proxy)
+            throws PathException
+        {
+            proxy.sendTo(this);
+        }
+
+        public long getCPathConsumer() {
+            return 0;
+        }
+    }
+}