/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
/**
 * @author Denis M. Kishenko
 * @version $Revision$
 */

package java.awt;

import java.awt.geom.GeneralPath;
import java.awt.geom.PathIterator;

import org.apache.harmony.awt.internal.nls.Messages;
import org.apache.harmony.misc.HashCode;

/**
 * The BasicStroke class specifies a set of rendering attributes for the
 * outlines of graphics primitives. The BasicStroke attributes describe the
 * shape of the pen which draws the outline of a Shape and the decorations
 * applied at the ends and joins of path segments of the Shape. The BasicStroke
 * has the following rendering attributes:
 * <p>
 * <ul>
 * <li>line width -the pen width which draws the outlines.</li>
 * <li>end caps - indicates the decoration applied to the ends of unclosed
 * subpaths and dash segments. The BasicStroke defines three different
 * decorations: CAP_BUTT, CAP_ROUND, and CAP_SQUARE.</li>
 * <li>line joins - indicates the decoration applied at the intersection of two
 * path segments and at the intersection of the endpoints of a subpath. The
 * BasicStroke defines three decorations: JOIN_BEVEL, JOIN_MITER, and
 * JOIN_ROUND.</li>
 * <li>miter limit - the limit to trim a line join that has a JOIN_MITER
 * decoration.</li>
 * <li>dash attributes - the definition of how to make a dash pattern by
 * alternating between opaque and transparent sections</li>
 * </ul>
 * </p>
 * 
 * @since Android 1.0
 */
public class BasicStroke implements Stroke {

    /**
     * The Constant CAP_BUTT indicates the ends of unclosed subpaths and dash
     * segments have no added decoration.
     */
    public static final int CAP_BUTT = 0;

    /**
     * The Constant CAP_ROUND indicates the ends of unclosed subpaths and dash
     * segments have a round decoration.
     */
    public static final int CAP_ROUND = 1;

    /**
     * The Constant CAP_SQUARE indicates the ends of unclosed subpaths and dash
     * segments have a square projection.
     */
    public static final int CAP_SQUARE = 2;

    /**
     * The Constant JOIN_MITER indicates that path segments are joined by
     * extending their outside edges until they meet.
     */
    public static final int JOIN_MITER = 0;

    /**
     * The Constant JOIN_ROUND indicates that path segments are joined by
     * rounding off the corner at a radius of half the line width.
     */
    public static final int JOIN_ROUND = 1;

    /**
     * The Constant JOIN_BEVEL indicates that path segments are joined by
     * connecting the outer corners of their wide outlines with a straight
     * segment.
     */
    public static final int JOIN_BEVEL = 2;

    /**
     * Constants for calculating.
     */
    static final int MAX_LEVEL = 20; // Maximal deepness of curve subdivision

    /**
     * The Constant CURVE_DELTA.
     */
    static final double CURVE_DELTA = 2.0; // Width tolerance

    /**
     * The Constant CORNER_ANGLE.
     */
    static final double CORNER_ANGLE = 4.0; // Minimum corner angle

    /**
     * The Constant CORNER_ZERO.
     */
    static final double CORNER_ZERO = 0.01; // Zero angle

    /**
     * The Constant CUBIC_ARC.
     */
    static final double CUBIC_ARC = 4.0 / 3.0 * (Math.sqrt(2.0) - 1);

    /**
     * Stroke width.
     */
    float width;

    /**
     * Stroke cap type.
     */
    int cap;

    /**
     * Stroke join type.
     */
    int join;

    /**
     * Stroke miter limit.
     */
    float miterLimit;

    /**
     * Stroke dashes array.
     */
    float dash[];

    /**
     * Stroke dash phase.
     */
    float dashPhase;

    /**
     * The temporary pre-calculated values.
     */
    double curveDelta;

    /**
     * The corner delta.
     */
    double cornerDelta;

    /**
     * The zero delta.
     */
    double zeroDelta;

    /**
     * The w2.
     */
    double w2;

    /**
     * The fmy.
     */
    double fmx, fmy;

    /**
     * The smy.
     */
    double scx, scy, smx, smy;

    /**
     * The cy.
     */
    double mx, my, cx, cy;

    /**
     * The temporary indicators.
     */
    boolean isMove;

    /**
     * The is first.
     */
    boolean isFirst;

    /**
     * The check move.
     */
    boolean checkMove;

    /**
     * The temporary and destination work paths.
     */
    BufferedPath dst, lp, rp, sp;

    /**
     * Stroke dasher class.
     */
    Dasher dasher;

    /**
     * Instantiates a new BasicStroke with default width, cap, join, limit, dash
     * attributes parameters. The default parameters are a solid line of width
     * 1.0, CAP_SQUARE, JOIN_MITER, a miter limit of 10.0, null dash attributes,
     * and a dash phase of 0.0f.
     */
    public BasicStroke() {
        this(1.0f, CAP_SQUARE, JOIN_MITER, 10.0f, null, 0.0f);
    }

    /**
     * Instantiates a new BasicStroke with the specified width, caps, joins,
     * limit, dash attributes, dash phase parameters.
     * 
     * @param width
     *            the width of BasikStroke.
     * @param cap
     *            the end decoration of BasikStroke.
     * @param join
     *            the join segments decoration.
     * @param miterLimit
     *            the limit to trim the miter join.
     * @param dash
     *            the array with the dashing pattern.
     * @param dashPhase
     *            the offset to start the dashing pattern.
     */
    public BasicStroke(float width, int cap, int join, float miterLimit, float[] dash,
            float dashPhase) {
        if (width < 0.0f) {
            // awt.133=Negative width
            throw new IllegalArgumentException(Messages.getString("awt.133")); //$NON-NLS-1$
        }
        if (cap != CAP_BUTT && cap != CAP_ROUND && cap != CAP_SQUARE) {
            // awt.134=Illegal cap
            throw new IllegalArgumentException(Messages.getString("awt.134")); //$NON-NLS-1$
        }
        if (join != JOIN_MITER && join != JOIN_ROUND && join != JOIN_BEVEL) {
            // awt.135=Illegal join
            throw new IllegalArgumentException(Messages.getString("awt.135")); //$NON-NLS-1$
        }
        if (join == JOIN_MITER && miterLimit < 1.0f) {
            // awt.136=miterLimit less than 1.0f
            throw new IllegalArgumentException(Messages.getString("awt.136")); //$NON-NLS-1$
        }
        if (dash != null) {
            if (dashPhase < 0.0f) {
                // awt.137=Negative dashPhase
                throw new IllegalArgumentException(Messages.getString("awt.137")); //$NON-NLS-1$
            }
            if (dash.length == 0) {
                // awt.138=Zero dash length
                throw new IllegalArgumentException(Messages.getString("awt.138")); //$NON-NLS-1$
            }
            ZERO: {
                for (int i = 0; i < dash.length; i++) {
                    if (dash[i] < 0.0) {
                        // awt.139=Negative dash[{0}]
                        throw new IllegalArgumentException(Messages.getString("awt.139", i)); //$NON-NLS-1$
                    }
                    if (dash[i] > 0.0) {
                        break ZERO;
                    }
                }
                // awt.13A=All dash lengths zero
                throw new IllegalArgumentException(Messages.getString("awt.13A")); //$NON-NLS-1$
            }
        }
        this.width = width;
        this.cap = cap;
        this.join = join;
        this.miterLimit = miterLimit;
        this.dash = dash;
        this.dashPhase = dashPhase;
    }

    /**
     * Instantiates a new BasicStroke with specified width, cap, join, limit and
     * default dash attributes parameters.
     * 
     * @param width
     *            the width of BasikStroke.
     * @param cap
     *            the end decoration of BasikStroke.
     * @param join
     *            the join segments decoration.
     * @param miterLimit
     *            the limit to trim the miter join.
     */
    public BasicStroke(float width, int cap, int join, float miterLimit) {
        this(width, cap, join, miterLimit, null, 0.0f);
    }

    /**
     * Instantiates a new BasicStroke with specified width, cap, join and
     * default limit and dash attributes parameters.
     * 
     * @param width
     *            the width of BasikStroke.
     * @param cap
     *            the end decoration of BasikStroke.
     * @param join
     *            the join segments decoration.
     */
    public BasicStroke(float width, int cap, int join) {
        this(width, cap, join, 10.0f, null, 0.0f);
    }

    /**
     * Instantiates a new BasicStroke with specified width and default cap,
     * join, limit, dash attributes parameters.
     * 
     * @param width
     *            the width of BasicStroke.
     */
    public BasicStroke(float width) {
        this(width, CAP_SQUARE, JOIN_MITER, 10.0f, null, 0.0f);
    }

    /**
     * Gets the line width of the BasicStroke.
     * 
     * @return the line width of the BasicStroke.
     */
    public float getLineWidth() {
        return width;
    }

    /**
     * Gets the end cap style of the BasicStroke.
     * 
     * @return the end cap style of the BasicStroke.
     */
    public int getEndCap() {
        return cap;
    }

    /**
     * Gets the line join style of the BasicStroke.
     * 
     * @return the line join style of the BasicStroke.
     */
    public int getLineJoin() {
        return join;
    }

    /**
     * Gets the miter limit of the BasicStroke (the limit to trim the miter
     * join).
     * 
     * @return the miter limit of the BasicStroke.
     */
    public float getMiterLimit() {
        return miterLimit;
    }

    /**
     * Gets the dash attributes array of the BasicStroke.
     * 
     * @return the dash attributes array of the BasicStroke.
     */
    public float[] getDashArray() {
        return dash;
    }

    /**
     * Gets the dash phase of the BasicStroke.
     * 
     * @return the dash phase of the BasicStroke.
     */
    public float getDashPhase() {
        return dashPhase;
    }

    /**
     * Returns hash code of this BasicStroke.
     * 
     * @return the hash code of this BasicStroke.
     */
    @Override
    public int hashCode() {
        HashCode hash = new HashCode();
        hash.append(width);
        hash.append(cap);
        hash.append(join);
        hash.append(miterLimit);
        if (dash != null) {
            hash.append(dashPhase);
            for (float element : dash) {
                hash.append(element);
            }
        }
        return hash.hashCode();
    }

    /**
     * Compares this BasicStroke object with the specified Object.
     * 
     * @param obj
     *            the Object to be compared.
     * @return true, if the Object is a BasicStroke with the same data values as
     *         this BasicStroke; false otherwise.
     */
    @Override
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (obj instanceof BasicStroke) {
            BasicStroke bs = (BasicStroke)obj;
            return bs.width == width && bs.cap == cap && bs.join == join
                    && bs.miterLimit == miterLimit && bs.dashPhase == dashPhase
                    && java.util.Arrays.equals(bs.dash, dash);
        }
        return false;
    }

    /**
     * Calculates allowable curve derivation.
     * 
     * @param width
     *            the width.
     * @return the curve delta.
     */
    double getCurveDelta(double width) {
        double a = width + CURVE_DELTA;
        double cos = 1.0 - 2.0 * width * width / (a * a);
        double sin = Math.sqrt(1.0 - cos * cos);
        return Math.abs(sin / cos);
    }

    /**
     * Calculates the value to detect a small angle.
     * 
     * @param width
     *            the width.
     * @return the corner delta.
     */
    double getCornerDelta(double width) {
        return width * width * Math.sin(Math.PI * CORNER_ANGLE / 180.0);
    }

    /**
     * Calculates value to detect a zero angle.
     * 
     * @param width
     *            the width.
     * @return the zero delta.
     */
    double getZeroDelta(double width) {
        return width * width * Math.sin(Math.PI * CORNER_ZERO / 180.0);
    }

    /**
     * Creates a Shape from the outline of the specified shape drawn with this
     * BasicStroke.
     * 
     * @param s
     *            the specified Shape to be stroked.
     * @return the Shape of the stroked outline.
     * @see java.awt.Stroke#createStrokedShape(java.awt.Shape)
     */
    public Shape createStrokedShape(Shape s) {
        w2 = width / 2.0;
        curveDelta = getCurveDelta(w2);
        cornerDelta = getCornerDelta(w2);
        zeroDelta = getZeroDelta(w2);

        dst = new BufferedPath();
        lp = new BufferedPath();
        rp = new BufferedPath();

        if (dash == null) {
            createSolidShape(s.getPathIterator(null));
        } else {
            createDashedShape(s.getPathIterator(null));
        }

        return dst.createGeneralPath();
    }

    /**
     * Generates a shape with a solid (not dashed) outline.
     * 
     * @param p
     *            the PathIterator of source shape.
     */
    void createSolidShape(PathIterator p) {
        double coords[] = new double[6];
        mx = my = cx = cy = 0.0;
        isMove = false;
        isFirst = false;
        checkMove = true;
        boolean isClosed = true;

        while (!p.isDone()) {
            switch (p.currentSegment(coords)) {
                case PathIterator.SEG_MOVETO:
                    if (!isClosed) {
                        closeSolidShape();
                    }
                    rp.clean();
                    mx = cx = coords[0];
                    my = cy = coords[1];
                    isMove = true;
                    isClosed = false;
                    break;
                case PathIterator.SEG_LINETO:
                    addLine(cx, cy, cx = coords[0], cy = coords[1], true);
                    break;
                case PathIterator.SEG_QUADTO:
                    addQuad(cx, cy, coords[0], coords[1], cx = coords[2], cy = coords[3]);
                    break;
                case PathIterator.SEG_CUBICTO:
                    addCubic(cx, cy, coords[0], coords[1], coords[2], coords[3], cx = coords[4],
                            cy = coords[5]);
                    break;
                case PathIterator.SEG_CLOSE:
                    addLine(cx, cy, mx, my, false);
                    addJoin(lp, mx, my, lp.xMove, lp.yMove, true);
                    addJoin(rp, mx, my, rp.xMove, rp.yMove, false);
                    lp.closePath();
                    rp.closePath();
                    lp.appendReverse(rp);
                    isClosed = true;
                    break;
            }
            p.next();
        }
        if (!isClosed) {
            closeSolidShape();
        }

        dst = lp;
    }

    /**
     * Closes solid shape path.
     */
    void closeSolidShape() {
        addCap(lp, cx, cy, rp.xLast, rp.yLast);
        lp.combine(rp);
        addCap(lp, mx, my, lp.xMove, lp.yMove);
        lp.closePath();
    }

    /**
     * Generates dashed stroked shape.
     * 
     * @param p
     *            the PathIterator of source shape.
     */
    void createDashedShape(PathIterator p) {
        double coords[] = new double[6];
        mx = my = cx = cy = 0.0;
        smx = smy = scx = scy = 0.0;
        isMove = false;
        checkMove = false;
        boolean isClosed = true;

        while (!p.isDone()) {
            switch (p.currentSegment(coords)) {
                case PathIterator.SEG_MOVETO:

                    if (!isClosed) {
                        closeDashedShape();
                    }

                    dasher = new Dasher(dash, dashPhase);
                    lp.clean();
                    rp.clean();
                    sp = null;
                    isFirst = true;
                    isMove = true;
                    isClosed = false;
                    mx = cx = coords[0];
                    my = cy = coords[1];
                    break;
                case PathIterator.SEG_LINETO:
                    addDashLine(cx, cy, cx = coords[0], cy = coords[1]);
                    break;
                case PathIterator.SEG_QUADTO:
                    addDashQuad(cx, cy, coords[0], coords[1], cx = coords[2], cy = coords[3]);
                    break;
                case PathIterator.SEG_CUBICTO:
                    addDashCubic(cx, cy, coords[0], coords[1], coords[2], coords[3],
                            cx = coords[4], cy = coords[5]);
                    break;
                case PathIterator.SEG_CLOSE:
                    addDashLine(cx, cy, cx = mx, cy = my);

                    if (dasher.isConnected()) {
                        // Connect current and head segments
                        addJoin(lp, fmx, fmy, sp.xMove, sp.yMove, true);
                        lp.join(sp);
                        addJoin(lp, fmx, fmy, rp.xLast, rp.yLast, true);
                        lp.combine(rp);
                        addCap(lp, smx, smy, lp.xMove, lp.yMove);
                        lp.closePath();
                        dst.append(lp);
                        sp = null;
                    } else {
                        closeDashedShape();
                    }

                    isClosed = true;
                    break;
            }
            p.next();
        }

        if (!isClosed) {
            closeDashedShape();
        }

    }

    /**
     * Closes dashed shape path.
     */
    void closeDashedShape() {
        // Add head segment
        if (sp != null) {
            addCap(sp, fmx, fmy, sp.xMove, sp.yMove);
            sp.closePath();
            dst.append(sp);
        }
        if (lp.typeSize > 0) {
            // Close current segment
            if (!dasher.isClosed()) {
                addCap(lp, scx, scy, rp.xLast, rp.yLast);
                lp.combine(rp);
                addCap(lp, smx, smy, lp.xMove, lp.yMove);
                lp.closePath();
            }
            dst.append(lp);
        }
    }

    /**
     * Adds cap to the work path.
     * 
     * @param p
     *            the BufferedPath object of work path.
     * @param x0
     *            the x coordinate of the source path.
     * @param y0
     *            the y coordinate on the source path.
     * @param x2
     *            the x coordinate of the next point on the work path.
     * @param y2
     *            the y coordinate of the next point on the work path.
     */
    void addCap(BufferedPath p, double x0, double y0, double x2, double y2) {
        double x1 = p.xLast;
        double y1 = p.yLast;
        double x10 = x1 - x0;
        double y10 = y1 - y0;
        double x20 = x2 - x0;
        double y20 = y2 - y0;

        switch (cap) {
            case CAP_BUTT:
                p.lineTo(x2, y2);
                break;
            case CAP_ROUND:
                double mx = x10 * CUBIC_ARC;
                double my = y10 * CUBIC_ARC;

                double x3 = x0 + y10;
                double y3 = y0 - x10;

                x10 *= CUBIC_ARC;
                y10 *= CUBIC_ARC;
                x20 *= CUBIC_ARC;
                y20 *= CUBIC_ARC;

                p.cubicTo(x1 + y10, y1 - x10, x3 + mx, y3 + my, x3, y3);
                p.cubicTo(x3 - mx, y3 - my, x2 - y20, y2 + x20, x2, y2);
                break;
            case CAP_SQUARE:
                p.lineTo(x1 + y10, y1 - x10);
                p.lineTo(x2 - y20, y2 + x20);
                p.lineTo(x2, y2);
                break;
        }
    }

    /**
     * Adds bevel and miter join to the work path.
     * 
     * @param p
     *            the BufferedPath object of work path.
     * @param x0
     *            the x coordinate of the source path.
     * @param y0
     *            the y coordinate on the source path.
     * @param x2
     *            the x coordinate of the next point on the work path.
     * @param y2
     *            the y coordinate of the next point on the work path.
     * @param isLeft
     *            the orientation of work path, true if work path lies to the
     *            left from source path, false otherwise.
     */
    void addJoin(BufferedPath p, double x0, double y0, double x2, double y2, boolean isLeft) {
        double x1 = p.xLast;
        double y1 = p.yLast;
        double x10 = x1 - x0;
        double y10 = y1 - y0;
        double x20 = x2 - x0;
        double y20 = y2 - y0;
        double sin0 = x10 * y20 - y10 * x20;

        // Small corner
        if (-cornerDelta < sin0 && sin0 < cornerDelta) {
            double cos0 = x10 * x20 + y10 * y20;
            if (cos0 > 0.0) {
                // if zero corner do nothing
                if (-zeroDelta > sin0 || sin0 > zeroDelta) {
                    double x3 = x0 + w2 * w2 * (y20 - y10) / sin0;
                    double y3 = y0 + w2 * w2 * (x10 - x20) / sin0;
                    p.setLast(x3, y3);
                }
                return;
            }
            // Zero corner
            if (-zeroDelta < sin0 && sin0 < zeroDelta) {
                p.lineTo(x2, y2);
            }
            return;
        }

        if (isLeft ^ (sin0 < 0.0)) {
            // Twisted corner
            p.lineTo(x0, y0);
            p.lineTo(x2, y2);
        } else {
            switch (join) {
                case JOIN_BEVEL:
                    p.lineTo(x2, y2);
                    break;
                case JOIN_MITER:
                    double s1 = x1 * x10 + y1 * y10;
                    double s2 = x2 * x20 + y2 * y20;
                    double x3 = (s1 * y20 - s2 * y10) / sin0;
                    double y3 = (s2 * x10 - s1 * x20) / sin0;
                    double x30 = x3 - x0;
                    double y30 = y3 - y0;
                    double miterLength = Math.sqrt(x30 * x30 + y30 * y30);
                    if (miterLength < miterLimit * w2) {
                        p.lineTo(x3, y3);
                    }
                    p.lineTo(x2, y2);
                    break;
                case JOIN_ROUND:
                    addRoundJoin(p, x0, y0, x2, y2, isLeft);
                    break;
            }
        }
    }

    /**
     * Adds round join to the work path.
     * 
     * @param p
     *            the BufferedPath object of work path.
     * @param x0
     *            the x coordinate of the source path.
     * @param y0
     *            the y coordinate on the source path.
     * @param x2
     *            the x coordinate of the next point on the work path.
     * @param y2
     *            the y coordinate of the next point on the work path.
     * @param isLeft
     *            the orientation of work path, true if work path lies to the
     *            left from source path, false otherwise.
     */
    void addRoundJoin(BufferedPath p, double x0, double y0, double x2, double y2, boolean isLeft) {
        double x1 = p.xLast;
        double y1 = p.yLast;
        double x10 = x1 - x0;
        double y10 = y1 - y0;
        double x20 = x2 - x0;
        double y20 = y2 - y0;

        double x30 = x10 + x20;
        double y30 = y10 + y20;

        double l30 = Math.sqrt(x30 * x30 + y30 * y30);

        if (l30 < 1E-5) {
            p.lineTo(x2, y2);
            return;
        }

        double w = w2 / l30;

        x30 *= w;
        y30 *= w;

        double x3 = x0 + x30;
        double y3 = y0 + y30;

        double cos = x10 * x20 + y10 * y20;
        double a = Math.acos(cos / (w2 * w2));
        if (cos >= 0.0) {
            double k = 4.0 / 3.0 * Math.tan(a / 4.0);
            if (isLeft) {
                k = -k;
            }

            x10 *= k;
            y10 *= k;
            x20 *= k;
            y20 *= k;

            p.cubicTo(x1 - y10, y1 + x10, x2 + y20, y2 - x20, x2, y2);
        } else {
            double k = 4.0 / 3.0 * Math.tan(a / 8.0);
            if (isLeft) {
                k = -k;
            }

            x10 *= k;
            y10 *= k;
            x20 *= k;
            y20 *= k;
            x30 *= k;
            y30 *= k;

            p.cubicTo(x1 - y10, y1 + x10, x3 + y30, y3 - x30, x3, y3);
            p.cubicTo(x3 - y30, y3 + x30, x2 + y20, y2 - x20, x2, y2);
        }

    }

    /**
     * Adds solid line segment to the work path.
     * 
     * @param x1
     *            the x coordinate of the start line point.
     * @param y1
     *            the y coordinate of the start line point.
     * @param x2
     *            the x coordinate of the end line point.
     * @param y2
     *            the y coordinate of the end line point.
     * @param zero
     *            if true it's allowable to add zero length line segment.
     */
    void addLine(double x1, double y1, double x2, double y2, boolean zero) {
        double dx = x2 - x1;
        double dy = y2 - y1;

        if (dx == 0.0 && dy == 0.0) {
            if (!zero) {
                return;
            }
            dx = w2;
            dy = 0;
        } else {
            double w = w2 / Math.sqrt(dx * dx + dy * dy);
            dx *= w;
            dy *= w;
        }

        double lx1 = x1 - dy;
        double ly1 = y1 + dx;
        double rx1 = x1 + dy;
        double ry1 = y1 - dx;

        if (checkMove) {
            if (isMove) {
                isMove = false;
                lp.moveTo(lx1, ly1);
                rp.moveTo(rx1, ry1);
            } else {
                addJoin(lp, x1, y1, lx1, ly1, true);
                addJoin(rp, x1, y1, rx1, ry1, false);
            }
        }

        lp.lineTo(x2 - dy, y2 + dx);
        rp.lineTo(x2 + dy, y2 - dx);
    }

    /**
     * Adds solid quad segment to the work path.
     * 
     * @param x1
     *            the x coordinate of the first control point.
     * @param y1
     *            the y coordinate of the first control point.
     * @param x2
     *            the x coordinate of the second control point.
     * @param y2
     *            the y coordinate of the second control point.
     * @param x3
     *            the x coordinate of the third control point.
     * @param y3
     *            the y coordinate of the third control point.
     */
    void addQuad(double x1, double y1, double x2, double y2, double x3, double y3) {
        double x21 = x2 - x1;
        double y21 = y2 - y1;
        double x23 = x2 - x3;
        double y23 = y2 - y3;

        double l21 = Math.sqrt(x21 * x21 + y21 * y21);
        double l23 = Math.sqrt(x23 * x23 + y23 * y23);

        if (l21 == 0.0 && l23 == 0.0) {
            addLine(x1, y1, x3, y3, false);
            return;
        }

        if (l21 == 0.0) {
            addLine(x2, y2, x3, y3, false);
            return;
        }

        if (l23 == 0.0) {
            addLine(x1, y1, x2, y2, false);
            return;
        }

        double w;
        w = w2 / l21;
        double mx1 = -y21 * w;
        double my1 = x21 * w;
        w = w2 / l23;
        double mx3 = y23 * w;
        double my3 = -x23 * w;

        double lx1 = x1 + mx1;
        double ly1 = y1 + my1;
        double rx1 = x1 - mx1;
        double ry1 = y1 - my1;

        if (checkMove) {
            if (isMove) {
                isMove = false;
                lp.moveTo(lx1, ly1);
                rp.moveTo(rx1, ry1);
            } else {
                addJoin(lp, x1, y1, lx1, ly1, true);
                addJoin(rp, x1, y1, rx1, ry1, false);
            }
        }

        if (x21 * y23 - y21 * x23 == 0.0) {
            // On line curve
            if (x21 * x23 + y21 * y23 > 0.0) {
                // Twisted curve
                if (l21 == l23) {
                    double px = x1 + (x21 + x23) / 4.0;
                    double py = y1 + (y21 + y23) / 4.0;
                    lp.lineTo(px + mx1, py + my1);
                    rp.lineTo(px - mx1, py - my1);
                    lp.lineTo(px - mx1, py - my1);
                    rp.lineTo(px + mx1, py + my1);
                    lp.lineTo(x3 - mx1, y3 - my1);
                    rp.lineTo(x3 + mx1, y3 + my1);
                } else {
                    double px1, py1;
                    double k = l21 / (l21 + l23);
                    double px = x1 + (x21 + x23) * k * k;
                    double py = y1 + (y21 + y23) * k * k;
                    px1 = (x1 + px) / 2.0;
                    py1 = (y1 + py) / 2.0;
                    lp.quadTo(px1 + mx1, py1 + my1, px + mx1, py + my1);
                    rp.quadTo(px1 - mx1, py1 - my1, px - mx1, py - my1);
                    lp.lineTo(px - mx1, py - my1);
                    rp.lineTo(px + mx1, py + my1);
                    px1 = (x3 + px) / 2.0;
                    py1 = (y3 + py) / 2.0;
                    lp.quadTo(px1 - mx1, py1 - my1, x3 - mx1, y3 - my1);
                    rp.quadTo(px1 + mx1, py1 + my1, x3 + mx1, y3 + my1);
                }
            } else {
                // Simple curve
                lp.quadTo(x2 + mx1, y2 + my1, x3 + mx3, y3 + my3);
                rp.quadTo(x2 - mx1, y2 - my1, x3 - mx3, y3 - my3);
            }
        } else {
            addSubQuad(x1, y1, x2, y2, x3, y3, 0);
        }
    }

    /**
     * Subdivides solid quad curve to make outline for source quad segment and
     * adds it to work path.
     * 
     * @param x1
     *            the x coordinate of the first control point.
     * @param y1
     *            the y coordinate of the first control point.
     * @param x2
     *            the x coordinate of the second control point.
     * @param y2
     *            the y coordinate of the second control point.
     * @param x3
     *            the x coordinate of the third control point.
     * @param y3
     *            the y coordinate of the third control point.
     * @param level
     *            the maximum level of subdivision deepness.
     */
    void addSubQuad(double x1, double y1, double x2, double y2, double x3, double y3, int level) {
        double x21 = x2 - x1;
        double y21 = y2 - y1;
        double x23 = x2 - x3;
        double y23 = y2 - y3;

        double cos = x21 * x23 + y21 * y23;
        double sin = x21 * y23 - y21 * x23;

        if (level < MAX_LEVEL && (cos >= 0.0 || (Math.abs(sin / cos) > curveDelta))) {
            double c1x = (x2 + x1) / 2.0;
            double c1y = (y2 + y1) / 2.0;
            double c2x = (x2 + x3) / 2.0;
            double c2y = (y2 + y3) / 2.0;
            double c3x = (c1x + c2x) / 2.0;
            double c3y = (c1y + c2y) / 2.0;
            addSubQuad(x1, y1, c1x, c1y, c3x, c3y, level + 1);
            addSubQuad(c3x, c3y, c2x, c2y, x3, y3, level + 1);
        } else {
            double w;
            double l21 = Math.sqrt(x21 * x21 + y21 * y21);
            double l23 = Math.sqrt(x23 * x23 + y23 * y23);
            w = w2 / sin;
            double mx2 = (x21 * l23 + x23 * l21) * w;
            double my2 = (y21 * l23 + y23 * l21) * w;
            w = w2 / l23;
            double mx3 = y23 * w;
            double my3 = -x23 * w;
            lp.quadTo(x2 + mx2, y2 + my2, x3 + mx3, y3 + my3);
            rp.quadTo(x2 - mx2, y2 - my2, x3 - mx3, y3 - my3);
        }
    }

    /**
     * Adds solid cubic segment to the work path.
     * 
     * @param x1
     *            the x coordinate of the first control point.
     * @param y1
     *            the y coordinate of the first control point.
     * @param x2
     *            the x coordinate of the second control point.
     * @param y2
     *            the y coordinate of the second control point.
     * @param x3
     *            the x coordinate of the third control point.
     * @param y3
     *            the y coordinate of the third control point.
     * @param x4
     *            the x coordinate of the fours control point.
     * @param y4
     *            the y coordinate of the fours control point.
     */
    void addCubic(double x1, double y1, double x2, double y2, double x3, double y3, double x4,
            double y4) {
        double x12 = x1 - x2;
        double y12 = y1 - y2;
        double x23 = x2 - x3;
        double y23 = y2 - y3;
        double x34 = x3 - x4;
        double y34 = y3 - y4;

        double l12 = Math.sqrt(x12 * x12 + y12 * y12);
        double l23 = Math.sqrt(x23 * x23 + y23 * y23);
        double l34 = Math.sqrt(x34 * x34 + y34 * y34);

        // All edges are zero
        if (l12 == 0.0 && l23 == 0.0 && l34 == 0.0) {
            addLine(x1, y1, x4, y4, false);
            return;
        }

        // One zero edge
        if (l12 == 0.0 && l23 == 0.0) {
            addLine(x3, y3, x4, y4, false);
            return;
        }

        if (l23 == 0.0 && l34 == 0.0) {
            addLine(x1, y1, x2, y2, false);
            return;
        }

        if (l12 == 0.0 && l34 == 0.0) {
            addLine(x2, y2, x3, y3, false);
            return;
        }

        double w, mx1, my1, mx4, my4;
        boolean onLine;

        if (l12 == 0.0) {
            w = w2 / l23;
            mx1 = y23 * w;
            my1 = -x23 * w;
            w = w2 / l34;
            mx4 = y34 * w;
            my4 = -x34 * w;
            onLine = -x23 * y34 + y23 * x34 == 0.0; // sin3
        } else if (l34 == 0.0) {
            w = w2 / l12;
            mx1 = y12 * w;
            my1 = -x12 * w;
            w = w2 / l23;
            mx4 = y23 * w;
            my4 = -x23 * w;
            onLine = -x12 * y23 + y12 * x23 == 0.0; // sin2
        } else {
            w = w2 / l12;
            mx1 = y12 * w;
            my1 = -x12 * w;
            w = w2 / l34;
            mx4 = y34 * w;
            my4 = -x34 * w;
            if (l23 == 0.0) {
                onLine = -x12 * y34 + y12 * x34 == 0.0;
            } else {
                onLine = -x12 * y34 + y12 * x34 == 0.0 && -x12 * y23 + y12 * x23 == 0.0 && // sin2
                        -x23 * y34 + y23 * x34 == 0.0; // sin3
            }
        }

        double lx1 = x1 + mx1;
        double ly1 = y1 + my1;
        double rx1 = x1 - mx1;
        double ry1 = y1 - my1;

        if (checkMove) {
            if (isMove) {
                isMove = false;
                lp.moveTo(lx1, ly1);
                rp.moveTo(rx1, ry1);
            } else {
                addJoin(lp, x1, y1, lx1, ly1, true);
                addJoin(rp, x1, y1, rx1, ry1, false);
            }
        }

        if (onLine) {
            if ((x1 == x2 && y1 < y2) || x1 < x2) {
                l12 = -l12;
            }
            if ((x2 == x3 && y2 < y3) || x2 < x3) {
                l23 = -l23;
            }
            if ((x3 == x4 && y3 < y4) || x3 < x4) {
                l34 = -l34;
            }
            double d = l23 * l23 - l12 * l34;
            double roots[] = new double[3];
            int rc = 0;
            if (d == 0.0) {
                double t = (l12 - l23) / (l12 + l34 - l23 - l23);
                if (0.0 < t && t < 1.0) {
                    roots[rc++] = t;
                }
            } else if (d > 0.0) {
                d = Math.sqrt(d);
                double z = l12 + l34 - l23 - l23;
                double t;
                t = (l12 - l23 + d) / z;
                if (0.0 < t && t < 1.0) {
                    roots[rc++] = t;
                }
                t = (l12 - l23 - d) / z;
                if (0.0 < t && t < 1.0) {
                    roots[rc++] = t;
                }
            }

            if (rc > 0) {
                // Sort roots
                if (rc == 2 && roots[0] > roots[1]) {
                    double tmp = roots[0];
                    roots[0] = roots[1];
                    roots[1] = tmp;
                }
                roots[rc++] = 1.0;

                double ax = -x34 - x12 + x23 + x23;
                double ay = -y34 - y12 + y23 + y23;
                double bx = 3.0 * (-x23 + x12);
                double by = 3.0 * (-y23 + y12);
                double cx = 3.0 * (-x12);
                double cy = 3.0 * (-y12);
                double xPrev = x1;
                double yPrev = y1;
                for (int i = 0; i < rc; i++) {
                    double t = roots[i];
                    double px = t * (t * (t * ax + bx) + cx) + x1;
                    double py = t * (t * (t * ay + by) + cy) + y1;
                    double px1 = (xPrev + px) / 2.0;
                    double py1 = (yPrev + py) / 2.0;
                    lp.cubicTo(px1 + mx1, py1 + my1, px1 + mx1, py1 + my1, px + mx1, py + my1);
                    rp.cubicTo(px1 - mx1, py1 - my1, px1 - mx1, py1 - my1, px - mx1, py - my1);
                    if (i < rc - 1) {
                        lp.lineTo(px - mx1, py - my1);
                        rp.lineTo(px + mx1, py + my1);
                    }
                    xPrev = px;
                    yPrev = py;
                    mx1 = -mx1;
                    my1 = -my1;
                }
            } else {
                lp.cubicTo(x2 + mx1, y2 + my1, x3 + mx4, y3 + my4, x4 + mx4, y4 + my4);
                rp.cubicTo(x2 - mx1, y2 - my1, x3 - mx4, y3 - my4, x4 - mx4, y4 - my4);
            }
        } else {
            addSubCubic(x1, y1, x2, y2, x3, y3, x4, y4, 0);
        }
    }

    /**
     * Subdivides solid cubic curve to make outline for source quad segment and
     * adds it to work path.
     * 
     * @param x1
     *            the x coordinate of the first control point.
     * @param y1
     *            the y coordinate of the first control point.
     * @param x2
     *            the x coordinate of the second control point.
     * @param y2
     *            the y coordinate of the second control point.
     * @param x3
     *            the x coordinate of the third control point.
     * @param y3
     *            the y coordinate of the third control point.
     * @param x4
     *            the x coordinate of the fours control point.
     * @param y4
     *            the y coordinate of the fours control point.
     * @param level
     *            the maximum level of subdivision deepness.
     */
    void addSubCubic(double x1, double y1, double x2, double y2, double x3, double y3, double x4,
            double y4, int level) {
        double x12 = x1 - x2;
        double y12 = y1 - y2;
        double x23 = x2 - x3;
        double y23 = y2 - y3;
        double x34 = x3 - x4;
        double y34 = y3 - y4;

        double cos2 = -x12 * x23 - y12 * y23;
        double cos3 = -x23 * x34 - y23 * y34;
        double sin2 = -x12 * y23 + y12 * x23;
        double sin3 = -x23 * y34 + y23 * x34;
        double sin0 = -x12 * y34 + y12 * x34;
        double cos0 = -x12 * x34 - y12 * y34;

        if (level < MAX_LEVEL
                && (sin2 != 0.0 || sin3 != 0.0 || sin0 != 0.0)
                && (cos2 >= 0.0 || cos3 >= 0.0 || cos0 >= 0.0
                        || (Math.abs(sin2 / cos2) > curveDelta)
                        || (Math.abs(sin3 / cos3) > curveDelta) || (Math.abs(sin0 / cos0) > curveDelta))) {
            double cx = (x2 + x3) / 2.0;
            double cy = (y2 + y3) / 2.0;
            double lx2 = (x2 + x1) / 2.0;
            double ly2 = (y2 + y1) / 2.0;
            double rx3 = (x3 + x4) / 2.0;
            double ry3 = (y3 + y4) / 2.0;
            double lx3 = (cx + lx2) / 2.0;
            double ly3 = (cy + ly2) / 2.0;
            double rx2 = (cx + rx3) / 2.0;
            double ry2 = (cy + ry3) / 2.0;
            cx = (lx3 + rx2) / 2.0;
            cy = (ly3 + ry2) / 2.0;
            addSubCubic(x1, y1, lx2, ly2, lx3, ly3, cx, cy, level + 1);
            addSubCubic(cx, cy, rx2, ry2, rx3, ry3, x4, y4, level + 1);
        } else {
            double w, mx1, my1, mx2, my2, mx3, my3, mx4, my4;
            double l12 = Math.sqrt(x12 * x12 + y12 * y12);
            double l23 = Math.sqrt(x23 * x23 + y23 * y23);
            double l34 = Math.sqrt(x34 * x34 + y34 * y34);

            if (l12 == 0.0) {
                w = w2 / l23;
                mx1 = y23 * w;
                my1 = -x23 * w;
                w = w2 / l34;
                mx4 = y34 * w;
                my4 = -x34 * w;
            } else if (l34 == 0.0) {
                w = w2 / l12;
                mx1 = y12 * w;
                my1 = -x12 * w;
                w = w2 / l23;
                mx4 = y23 * w;
                my4 = -x23 * w;
            } else {
                // Common case
                w = w2 / l12;
                mx1 = y12 * w;
                my1 = -x12 * w;
                w = w2 / l34;
                mx4 = y34 * w;
                my4 = -x34 * w;
            }

            if (sin2 == 0.0) {
                mx2 = mx1;
                my2 = my1;
            } else {
                w = w2 / sin2;
                mx2 = -(x12 * l23 - x23 * l12) * w;
                my2 = -(y12 * l23 - y23 * l12) * w;
            }
            if (sin3 == 0.0) {
                mx3 = mx4;
                my3 = my4;
            } else {
                w = w2 / sin3;
                mx3 = -(x23 * l34 - x34 * l23) * w;
                my3 = -(y23 * l34 - y34 * l23) * w;
            }

            lp.cubicTo(x2 + mx2, y2 + my2, x3 + mx3, y3 + my3, x4 + mx4, y4 + my4);
            rp.cubicTo(x2 - mx2, y2 - my2, x3 - mx3, y3 - my3, x4 - mx4, y4 - my4);
        }
    }

    /**
     * Adds dashed line segment to the work path.
     * 
     * @param x1
     *            the x coordinate of the start line point.
     * @param y1
     *            the y coordinate of the start line point.
     * @param x2
     *            the x coordinate of the end line point.
     * @param y2
     *            the y coordinate of the end line point.
     */
    void addDashLine(double x1, double y1, double x2, double y2) {
        double x21 = x2 - x1;
        double y21 = y2 - y1;

        double l21 = Math.sqrt(x21 * x21 + y21 * y21);

        if (l21 == 0.0) {
            return;
        }

        double px1, py1;
        px1 = py1 = 0.0;
        double w = w2 / l21;
        double mx = -y21 * w;
        double my = x21 * w;

        dasher.init(new DashIterator.Line(l21));

        while (!dasher.eof()) {
            double t = dasher.getValue();
            scx = x1 + t * x21;
            scy = y1 + t * y21;

            if (dasher.isOpen()) {
                px1 = scx;
                py1 = scy;
                double lx1 = px1 + mx;
                double ly1 = py1 + my;
                double rx1 = px1 - mx;
                double ry1 = py1 - my;
                if (isMove) {
                    isMove = false;
                    smx = px1;
                    smy = py1;
                    rp.clean();
                    lp.moveTo(lx1, ly1);
                    rp.moveTo(rx1, ry1);
                } else {
                    addJoin(lp, x1, y1, lx1, ly1, true);
                    addJoin(rp, x1, y1, rx1, ry1, false);
                }
            } else if (dasher.isContinue()) {
                double px2 = scx;
                double py2 = scy;
                lp.lineTo(px2 + mx, py2 + my);
                rp.lineTo(px2 - mx, py2 - my);
                if (dasher.close) {
                    addCap(lp, px2, py2, rp.xLast, rp.yLast);
                    lp.combine(rp);
                    if (isFirst) {
                        isFirst = false;
                        fmx = smx;
                        fmy = smy;
                        sp = lp;
                        lp = new BufferedPath();
                    } else {
                        addCap(lp, smx, smy, lp.xMove, lp.yMove);
                        lp.closePath();
                    }
                    isMove = true;
                }
            }

            dasher.next();
        }
    }

    /**
     * Adds dashed quad segment to the work path.
     * 
     * @param x1
     *            the x coordinate of the first control point.
     * @param y1
     *            the y coordinate of the first control point.
     * @param x2
     *            the x coordinate of the second control point.
     * @param y2
     *            the y coordinate of the second control point.
     * @param x3
     *            the x coordinate of the third control point.
     * @param y3
     *            the y coordinate of the third control point.
     */
    void addDashQuad(double x1, double y1, double x2, double y2, double x3, double y3) {

        double x21 = x2 - x1;
        double y21 = y2 - y1;
        double x23 = x2 - x3;
        double y23 = y2 - y3;

        double l21 = Math.sqrt(x21 * x21 + y21 * y21);
        double l23 = Math.sqrt(x23 * x23 + y23 * y23);

        if (l21 == 0.0 && l23 == 0.0) {
            return;
        }

        if (l21 == 0.0) {
            addDashLine(x2, y2, x3, y3);
            return;
        }

        if (l23 == 0.0) {
            addDashLine(x1, y1, x2, y2);
            return;
        }

        double ax = x1 + x3 - x2 - x2;
        double ay = y1 + y3 - y2 - y2;
        double bx = x2 - x1;
        double by = y2 - y1;
        double cx = x1;
        double cy = y1;

        double px1, py1, dx1, dy1;
        px1 = py1 = dx1 = dy1 = 0.0;
        double prev = 0.0;

        dasher.init(new DashIterator.Quad(x1, y1, x2, y2, x3, y3));

        while (!dasher.eof()) {
            double t = dasher.getValue();
            double dx = t * ax + bx;
            double dy = t * ay + by;
            scx = t * (dx + bx) + cx; // t^2 * ax + 2.0 * t * bx + cx
            scy = t * (dy + by) + cy; // t^2 * ay + 2.0 * t * by + cy
            if (dasher.isOpen()) {
                px1 = scx;
                py1 = scy;
                dx1 = dx;
                dy1 = dy;
                double w = w2 / Math.sqrt(dx1 * dx1 + dy1 * dy1);
                double mx1 = -dy1 * w;
                double my1 = dx1 * w;
                double lx1 = px1 + mx1;
                double ly1 = py1 + my1;
                double rx1 = px1 - mx1;
                double ry1 = py1 - my1;
                if (isMove) {
                    isMove = false;
                    smx = px1;
                    smy = py1;
                    rp.clean();
                    lp.moveTo(lx1, ly1);
                    rp.moveTo(rx1, ry1);
                } else {
                    addJoin(lp, x1, y1, lx1, ly1, true);
                    addJoin(rp, x1, y1, rx1, ry1, false);
                }
            } else if (dasher.isContinue()) {
                double px3 = scx;
                double py3 = scy;
                double sx = x2 - x23 * prev;
                double sy = y2 - y23 * prev;
                double t2 = (t - prev) / (1 - prev);
                double px2 = px1 + (sx - px1) * t2;
                double py2 = py1 + (sy - py1) * t2;

                addQuad(px1, py1, px2, py2, px3, py3);
                if (dasher.isClosed()) {
                    addCap(lp, px3, py3, rp.xLast, rp.yLast);
                    lp.combine(rp);
                    if (isFirst) {
                        isFirst = false;
                        fmx = smx;
                        fmy = smy;
                        sp = lp;
                        lp = new BufferedPath();
                    } else {
                        addCap(lp, smx, smy, lp.xMove, lp.yMove);
                        lp.closePath();
                    }
                    isMove = true;
                }
            }

            prev = t;
            dasher.next();
        }
    }

    /**
     * Adds dashed cubic segment to the work path.
     * 
     * @param x1
     *            the x coordinate of the first control point.
     * @param y1
     *            the y coordinate of the first control point.
     * @param x2
     *            the x coordinate of the second control point.
     * @param y2
     *            the y coordinate of the second control point.
     * @param x3
     *            the x coordinate of the third control point.
     * @param y3
     *            the y coordinate of the third control point.
     * @param x4
     *            the x coordinate of the fours control point.
     * @param y4
     *            the y coordinate of the fours control point.
     */
    void addDashCubic(double x1, double y1, double x2, double y2, double x3, double y3, double x4,
            double y4) {

        double x12 = x1 - x2;
        double y12 = y1 - y2;
        double x23 = x2 - x3;
        double y23 = y2 - y3;
        double x34 = x3 - x4;
        double y34 = y3 - y4;

        double l12 = Math.sqrt(x12 * x12 + y12 * y12);
        double l23 = Math.sqrt(x23 * x23 + y23 * y23);
        double l34 = Math.sqrt(x34 * x34 + y34 * y34);

        // All edges are zero
        if (l12 == 0.0 && l23 == 0.0 && l34 == 0.0) {
            // NOTHING
            return;
        }

        // One zero edge
        if (l12 == 0.0 && l23 == 0.0) {
            addDashLine(x3, y3, x4, y4);
            return;
        }

        if (l23 == 0.0 && l34 == 0.0) {
            addDashLine(x1, y1, x2, y2);
            return;
        }

        if (l12 == 0.0 && l34 == 0.0) {
            addDashLine(x2, y2, x3, y3);
            return;
        }

        double ax = x4 - x1 + 3.0 * (x2 - x3);
        double ay = y4 - y1 + 3.0 * (y2 - y3);
        double bx = 3.0 * (x1 + x3 - x2 - x2);
        double by = 3.0 * (y1 + y3 - y2 - y2);
        double cx = 3.0 * (x2 - x1);
        double cy = 3.0 * (y2 - y1);
        double dx = x1;
        double dy = y1;

        double px1 = 0.0;
        double py1 = 0.0;
        double prev = 0.0;

        dasher.init(new DashIterator.Cubic(x1, y1, x2, y2, x3, y3, x4, y4));

        while (!dasher.eof()) {

            double t = dasher.getValue();
            scx = t * (t * (t * ax + bx) + cx) + dx;
            scy = t * (t * (t * ay + by) + cy) + dy;
            if (dasher.isOpen()) {
                px1 = scx;
                py1 = scy;
                double dx1 = t * (t * (ax + ax + ax) + bx + bx) + cx;
                double dy1 = t * (t * (ay + ay + ay) + by + by) + cy;
                double w = w2 / Math.sqrt(dx1 * dx1 + dy1 * dy1);
                double mx1 = -dy1 * w;
                double my1 = dx1 * w;
                double lx1 = px1 + mx1;
                double ly1 = py1 + my1;
                double rx1 = px1 - mx1;
                double ry1 = py1 - my1;
                if (isMove) {
                    isMove = false;
                    smx = px1;
                    smy = py1;
                    rp.clean();
                    lp.moveTo(lx1, ly1);
                    rp.moveTo(rx1, ry1);
                } else {
                    addJoin(lp, x1, y1, lx1, ly1, true);
                    addJoin(rp, x1, y1, rx1, ry1, false);
                }
            } else if (dasher.isContinue()) {
                double sx1 = x2 - x23 * prev;
                double sy1 = y2 - y23 * prev;
                double sx2 = x3 - x34 * prev;
                double sy2 = y3 - y34 * prev;
                double sx3 = sx1 + (sx2 - sx1) * prev;
                double sy3 = sy1 + (sy2 - sy1) * prev;
                double t2 = (t - prev) / (1 - prev);
                double sx4 = sx3 + (sx2 - sx3) * t2;
                double sy4 = sy3 + (sy2 - sy3) * t2;

                double px4 = scx;
                double py4 = scy;
                double px2 = px1 + (sx3 - px1) * t2;
                double py2 = py1 + (sy3 - py1) * t2;
                double px3 = px2 + (sx4 - px2) * t2;
                double py3 = py2 + (sy4 - py2) * t2;

                addCubic(px1, py1, px2, py2, px3, py3, px4, py4);
                if (dasher.isClosed()) {
                    addCap(lp, px4, py4, rp.xLast, rp.yLast);
                    lp.combine(rp);
                    if (isFirst) {
                        isFirst = false;
                        fmx = smx;
                        fmy = smy;
                        sp = lp;
                        lp = new BufferedPath();
                    } else {
                        addCap(lp, smx, smy, lp.xMove, lp.yMove);
                        lp.closePath();
                    }
                    isMove = true;
                }
            }

            prev = t;
            dasher.next();
        }
    }

    /**
     * Dasher class provides dashing for particular dash style.
     */
    class Dasher {

        /**
         * The pos.
         */
        double pos;

        /**
         * The first.
         */
        boolean close, visible, first;

        /**
         * The dash.
         */
        float dash[];

        /**
         * The phase.
         */
        float phase;

        /**
         * The index.
         */
        int index;

        /**
         * The iter.
         */
        DashIterator iter;

        /**
         * Instantiates a new dasher.
         * 
         * @param dash
         *            the dash.
         * @param phase
         *            the phase.
         */
        Dasher(float dash[], float phase) {
            this.dash = dash;
            this.phase = phase;
            index = 0;
            pos = phase;
            visible = true;
            while (pos >= dash[index]) {
                visible = !visible;
                pos -= dash[index];
                index = (index + 1) % dash.length;
            }
            pos = -pos;
            first = visible;
        }

        /**
         * Inits the.
         * 
         * @param iter
         *            the iter.
         */
        void init(DashIterator iter) {
            this.iter = iter;
            close = true;
        }

        /**
         * Checks if is open.
         * 
         * @return true, if is open.
         */
        boolean isOpen() {
            return visible && pos < iter.length;
        }

        /**
         * Checks if is continue.
         * 
         * @return true, if is continue.
         */
        boolean isContinue() {
            return !visible && pos > 0;
        }

        /**
         * Checks if is closed.
         * 
         * @return true, if is closed.
         */
        boolean isClosed() {
            return close;
        }

        /**
         * Checks if is connected.
         * 
         * @return true, if is connected.
         */
        boolean isConnected() {
            return first && !close;
        }

        /**
         * Eof.
         * 
         * @return true, if successful.
         */
        boolean eof() {
            if (!close) {
                pos -= iter.length;
                return true;
            }
            if (pos >= iter.length) {
                if (visible) {
                    pos -= iter.length;
                    return true;
                }
                close = pos == iter.length;
            }
            return false;
        }

        /**
         * Next.
         */
        void next() {
            if (close) {
                pos += dash[index];
                index = (index + 1) % dash.length;
            } else {
                // Go back
                index = (index + dash.length - 1) % dash.length;
                pos -= dash[index];
            }
            visible = !visible;
        }

        /**
         * Gets the value.
         * 
         * @return the value.
         */
        double getValue() {
            double t = iter.getNext(pos);
            return t < 0 ? 0 : (t > 1 ? 1 : t);
        }

    }

    /**
     * DashIterator class provides dashing for particular segment type.
     */
    static abstract class DashIterator {

        /**
         * The Constant FLATNESS.
         */
        static final double FLATNESS = 1.0;

        /**
         * The Class Line.
         */
        static class Line extends DashIterator {

            /**
             * Instantiates a new line.
             * 
             * @param len
             *            the len.
             */
            Line(double len) {
                length = len;
            }

            @Override
            double getNext(double dashPos) {
                return dashPos / length;
            }

        }

        /**
         * The Class Quad.
         */
        static class Quad extends DashIterator {

            /**
             * The val size.
             */
            int valSize;

            /**
             * The val pos.
             */
            int valPos;

            /**
             * The cur len.
             */
            double curLen;

            /**
             * The prev len.
             */
            double prevLen;

            /**
             * The last len.
             */
            double lastLen;

            /**
             * The values.
             */
            double[] values;

            /**
             * The step.
             */
            double step;

            /**
             * Instantiates a new quad.
             * 
             * @param x1
             *            the x1.
             * @param y1
             *            the y1.
             * @param x2
             *            the x2.
             * @param y2
             *            the y2.
             * @param x3
             *            the x3.
             * @param y3
             *            the y3.
             */
            Quad(double x1, double y1, double x2, double y2, double x3, double y3) {

                double nx = x1 + x3 - x2 - x2;
                double ny = y1 + y3 - y2 - y2;

                int n = (int)(1 + Math.sqrt(0.75 * (Math.abs(nx) + Math.abs(ny)) * FLATNESS));
                step = 1.0 / n;

                double ax = x1 + x3 - x2 - x2;
                double ay = y1 + y3 - y2 - y2;
                double bx = 2.0 * (x2 - x1);
                double by = 2.0 * (y2 - y1);

                double dx1 = step * (step * ax + bx);
                double dy1 = step * (step * ay + by);
                double dx2 = step * (step * ax * 2.0);
                double dy2 = step * (step * ay * 2.0);
                double vx = x1;
                double vy = y1;

                valSize = n;
                values = new double[valSize];
                double pvx = vx;
                double pvy = vy;
                length = 0.0;
                for (int i = 0; i < n; i++) {
                    vx += dx1;
                    vy += dy1;
                    dx1 += dx2;
                    dy1 += dy2;
                    double lx = vx - pvx;
                    double ly = vy - pvy;
                    values[i] = Math.sqrt(lx * lx + ly * ly);
                    length += values[i];
                    pvx = vx;
                    pvy = vy;
                }

                valPos = 0;
                curLen = 0.0;
                prevLen = 0.0;
            }

            @Override
            double getNext(double dashPos) {
                double t = 2.0;
                while (curLen <= dashPos && valPos < valSize) {
                    prevLen = curLen;
                    curLen += lastLen = values[valPos++];
                }
                if (curLen > dashPos) {
                    t = (valPos - 1 + (dashPos - prevLen) / lastLen) * step;
                }
                return t;
            }

        }

        /**
         * The Class Cubic.
         */
        static class Cubic extends DashIterator {

            /**
             * The val size.
             */
            int valSize;

            /**
             * The val pos.
             */
            int valPos;

            /**
             * The cur len.
             */
            double curLen;

            /**
             * The prev len.
             */
            double prevLen;

            /**
             * The last len.
             */
            double lastLen;

            /**
             * The values.
             */
            double[] values;

            /**
             * The step.
             */
            double step;

            /**
             * Instantiates a new cubic.
             * 
             * @param x1
             *            the x1.
             * @param y1
             *            the y1.
             * @param x2
             *            the x2.
             * @param y2
             *            the y2.
             * @param x3
             *            the x3.
             * @param y3
             *            the y3.
             * @param x4
             *            the x4.
             * @param y4
             *            the y4.
             */
            Cubic(double x1, double y1, double x2, double y2, double x3, double y3, double x4,
                    double y4) {

                double nx1 = x1 + x3 - x2 - x2;
                double ny1 = y1 + y3 - y2 - y2;
                double nx2 = x2 + x4 - x3 - x3;
                double ny2 = y2 + y4 - y3 - y3;

                double max = Math.max(Math.abs(nx1) + Math.abs(ny1), Math.abs(nx2) + Math.abs(ny2));
                int n = (int)(1 + Math.sqrt(0.75 * max) * FLATNESS);
                step = 1.0 / n;

                double ax = x4 - x1 + 3.0 * (x2 - x3);
                double ay = y4 - y1 + 3.0 * (y2 - y3);
                double bx = 3.0 * (x1 + x3 - x2 - x2);
                double by = 3.0 * (y1 + y3 - y2 - y2);
                double cx = 3.0 * (x2 - x1);
                double cy = 3.0 * (y2 - y1);

                double dx1 = step * (step * (step * ax + bx) + cx);
                double dy1 = step * (step * (step * ay + by) + cy);
                double dx2 = step * (step * (step * ax * 6.0 + bx * 2.0));
                double dy2 = step * (step * (step * ay * 6.0 + by * 2.0));
                double dx3 = step * (step * (step * ax * 6.0));
                double dy3 = step * (step * (step * ay * 6.0));
                double vx = x1;
                double vy = y1;

                valSize = n;
                values = new double[valSize];
                double pvx = vx;
                double pvy = vy;
                length = 0.0;
                for (int i = 0; i < n; i++) {
                    vx += dx1;
                    vy += dy1;
                    dx1 += dx2;
                    dy1 += dy2;
                    dx2 += dx3;
                    dy2 += dy3;
                    double lx = vx - pvx;
                    double ly = vy - pvy;
                    values[i] = Math.sqrt(lx * lx + ly * ly);
                    length += values[i];
                    pvx = vx;
                    pvy = vy;
                }

                valPos = 0;
                curLen = 0.0;
                prevLen = 0.0;
            }

            @Override
            double getNext(double dashPos) {
                double t = 2.0;
                while (curLen <= dashPos && valPos < valSize) {
                    prevLen = curLen;
                    curLen += lastLen = values[valPos++];
                }
                if (curLen > dashPos) {
                    t = (valPos - 1 + (dashPos - prevLen) / lastLen) * step;
                }
                return t;
            }

        }

        /**
         * The length.
         */
        double length;

        /**
         * Gets the next.
         * 
         * @param dashPos
         *            the dash pos.
         * @return the next.
         */
        abstract double getNext(double dashPos);

    }

    /**
     * BufferedPath class provides work path storing and processing.
     */
    static class BufferedPath {

        /**
         * The Constant bufCapacity.
         */
        private static final int bufCapacity = 10;

        /**
         * The point shift.
         */
        static int pointShift[] = {
                2, // MOVETO
                2, // LINETO
                4, // QUADTO
                6, // CUBICTO
                0
        }; // CLOSE

        /**
         * The types.
         */
        byte[] types;

        /**
         * The points.
         */
        float[] points;

        /**
         * The type size.
         */
        int typeSize;

        /**
         * The point size.
         */
        int pointSize;

        /**
         * The x last.
         */
        float xLast;

        /**
         * The y last.
         */
        float yLast;

        /**
         * The x move.
         */
        float xMove;

        /**
         * The y move.
         */
        float yMove;

        /**
         * Instantiates a new buffered path.
         */
        public BufferedPath() {
            types = new byte[bufCapacity];
            points = new float[bufCapacity * 2];
        }

        /**
         * Check buf.
         * 
         * @param typeCount
         *            the type count.
         * @param pointCount
         *            the point count.
         */
        void checkBuf(int typeCount, int pointCount) {
            if (typeSize + typeCount > types.length) {
                byte tmp[] = new byte[typeSize + Math.max(bufCapacity, typeCount)];
                System.arraycopy(types, 0, tmp, 0, typeSize);
                types = tmp;
            }
            if (pointSize + pointCount > points.length) {
                float tmp[] = new float[pointSize + Math.max(bufCapacity * 2, pointCount)];
                System.arraycopy(points, 0, tmp, 0, pointSize);
                points = tmp;
            }
        }

        /**
         * Checks if is empty.
         * 
         * @return true, if is empty.
         */
        boolean isEmpty() {
            return typeSize == 0;
        }

        /**
         * Clean.
         */
        void clean() {
            typeSize = 0;
            pointSize = 0;
        }

        /**
         * Move to.
         * 
         * @param x
         *            the x.
         * @param y
         *            the y.
         */
        void moveTo(double x, double y) {
            checkBuf(1, 2);
            types[typeSize++] = PathIterator.SEG_MOVETO;
            points[pointSize++] = xMove = (float)x;
            points[pointSize++] = yMove = (float)y;
        }

        /**
         * Line to.
         * 
         * @param x
         *            the x.
         * @param y
         *            the y.
         */
        void lineTo(double x, double y) {
            checkBuf(1, 2);
            types[typeSize++] = PathIterator.SEG_LINETO;
            points[pointSize++] = xLast = (float)x;
            points[pointSize++] = yLast = (float)y;
        }

        /**
         * Quad to.
         * 
         * @param x1
         *            the x1.
         * @param y1
         *            the y1.
         * @param x2
         *            the x2.
         * @param y2
         *            the y2.
         */
        void quadTo(double x1, double y1, double x2, double y2) {
            checkBuf(1, 4);
            types[typeSize++] = PathIterator.SEG_QUADTO;
            points[pointSize++] = (float)x1;
            points[pointSize++] = (float)y1;
            points[pointSize++] = xLast = (float)x2;
            points[pointSize++] = yLast = (float)y2;
        }

        /**
         * Cubic to.
         * 
         * @param x1
         *            the x1.
         * @param y1
         *            the y1.
         * @param x2
         *            the x2.
         * @param y2
         *            the y2.
         * @param x3
         *            the x3.
         * @param y3
         *            the y3.
         */
        void cubicTo(double x1, double y1, double x2, double y2, double x3, double y3) {
            checkBuf(1, 6);
            types[typeSize++] = PathIterator.SEG_CUBICTO;
            points[pointSize++] = (float)x1;
            points[pointSize++] = (float)y1;
            points[pointSize++] = (float)x2;
            points[pointSize++] = (float)y2;
            points[pointSize++] = xLast = (float)x3;
            points[pointSize++] = yLast = (float)y3;
        }

        /**
         * Close path.
         */
        void closePath() {
            checkBuf(1, 0);
            types[typeSize++] = PathIterator.SEG_CLOSE;
        }

        /**
         * Sets the last.
         * 
         * @param x
         *            the x.
         * @param y
         *            the y.
         */
        void setLast(double x, double y) {
            points[pointSize - 2] = xLast = (float)x;
            points[pointSize - 1] = yLast = (float)y;
        }

        /**
         * Append.
         * 
         * @param p
         *            the p.
         */
        void append(BufferedPath p) {
            checkBuf(p.typeSize, p.pointSize);
            System.arraycopy(p.points, 0, points, pointSize, p.pointSize);
            System.arraycopy(p.types, 0, types, typeSize, p.typeSize);
            pointSize += p.pointSize;
            typeSize += p.typeSize;
            xLast = points[pointSize - 2];
            yLast = points[pointSize - 1];
        }

        /**
         * Append reverse.
         * 
         * @param p
         *            the p.
         */
        void appendReverse(BufferedPath p) {
            checkBuf(p.typeSize, p.pointSize);
            // Skip last point, beacause it's the first point of the second path
            for (int i = p.pointSize - 2; i >= 0; i -= 2) {
                points[pointSize++] = p.points[i + 0];
                points[pointSize++] = p.points[i + 1];
            }
            // Skip first type, beacuse it's always MOVETO
            int closeIndex = 0;
            for (int i = p.typeSize - 1; i >= 0; i--) {
                byte type = p.types[i];
                if (type == PathIterator.SEG_MOVETO) {
                    types[closeIndex] = PathIterator.SEG_MOVETO;
                    types[typeSize++] = PathIterator.SEG_CLOSE;
                } else {
                    if (type == PathIterator.SEG_CLOSE) {
                        closeIndex = typeSize;
                    }
                    types[typeSize++] = type;
                }
            }
            xLast = points[pointSize - 2];
            yLast = points[pointSize - 1];
        }

        /**
         * Join.
         * 
         * @param p
         *            the p.
         */
        void join(BufferedPath p) {
            // Skip MOVETO
            checkBuf(p.typeSize - 1, p.pointSize - 2);
            System.arraycopy(p.points, 2, points, pointSize, p.pointSize - 2);
            System.arraycopy(p.types, 1, types, typeSize, p.typeSize - 1);
            pointSize += p.pointSize - 2;
            typeSize += p.typeSize - 1;
            xLast = points[pointSize - 2];
            yLast = points[pointSize - 1];
        }

        /**
         * Combine.
         * 
         * @param p
         *            the p.
         */
        void combine(BufferedPath p) {
            checkBuf(p.typeSize - 1, p.pointSize - 2);
            // Skip last point, beacause it's the first point of the second path
            for (int i = p.pointSize - 4; i >= 0; i -= 2) {
                points[pointSize++] = p.points[i + 0];
                points[pointSize++] = p.points[i + 1];
            }
            // Skip first type, beacuse it's always MOVETO
            for (int i = p.typeSize - 1; i >= 1; i--) {
                types[typeSize++] = p.types[i];
            }
            xLast = points[pointSize - 2];
            yLast = points[pointSize - 1];
        }

        /**
         * Creates the general path.
         * 
         * @return the general path.
         */
        GeneralPath createGeneralPath() {
            GeneralPath p = new GeneralPath();
            int j = 0;
            for (int i = 0; i < typeSize; i++) {
                int type = types[i];
                switch (type) {
                    case PathIterator.SEG_MOVETO:
                        p.moveTo(points[j], points[j + 1]);
                        break;
                    case PathIterator.SEG_LINETO:
                        p.lineTo(points[j], points[j + 1]);
                        break;
                    case PathIterator.SEG_QUADTO:
                        p.quadTo(points[j], points[j + 1], points[j + 2], points[j + 3]);
                        break;
                    case PathIterator.SEG_CUBICTO:
                        p.curveTo(points[j], points[j + 1], points[j + 2], points[j + 3],
                                points[j + 4], points[j + 5]);
                        break;
                    case PathIterator.SEG_CLOSE:
                        p.closePath();
                        break;
                }
                j += pointShift[type];
            }
            return p;
        }

    }

}