awt/geom/GeneralPath.java

/*
 *  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.geom;

import java.awt.Rectangle;
import java.awt.Shape;
import java.util.NoSuchElementException;

import org.apache.harmony.awt.gl.Crossing;
import org.apache.harmony.awt.internal.nls.Messages;

/**
 * The class GeneralPath represents a shape whose outline is given by different
 * types of curved and straight segments.
 *
 * @since Android 1.0
 */
public final class GeneralPath implements Shape, Cloneable {

    /**
     * The Constant WIND_EVEN_ODD see {@link PathIterator#WIND_EVEN_ODD}.
     */
    public static final int WIND_EVEN_ODD = PathIterator.WIND_EVEN_ODD;

    /**
     * The Constant WIND_NON_ZERO see {@link PathIterator#WIND_NON_ZERO}.
     */
    public static final int WIND_NON_ZERO = PathIterator.WIND_NON_ZERO;

    /**
     * The buffers size.
     */
    private static final int BUFFER_SIZE = 10;

    /**
     * The buffers capacity.
     */
    private static final int BUFFER_CAPACITY = 10;

    /**
     * The point's types buffer.
     */
    byte[] types;

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

    /**
     * The point's type buffer size.
     */
    int typeSize;

    /**
     * The points buffer size.
     */
    int pointSize;

    /**
     * The path rule.
     */
    int rule;

    /**
     * The space amount in points buffer for different segmenet's types.
     */
    static int pointShift[] = {
            2, // MOVETO
            2, // LINETO
            4, // QUADTO
            6, // CUBICTO
            0
    }; // CLOSE

    /*
     * GeneralPath path iterator
     */
    /**
     * The Class Iterator is the subclass of Iterator for traversing the outline
     * of a GeneralPath.
     */
    class Iterator implements PathIterator {

        /**
         * The current cursor position in types buffer.
         */
        int typeIndex;

        /**
         * The current cursor position in points buffer.
         */
        int pointIndex;

        /**
         * The source GeneralPath object.
         */
        GeneralPath p;

        /**
         * The path iterator transformation.
         */
        AffineTransform t;

        /**
         * Constructs a new GeneralPath.Iterator for given general path.
         *
         * @param path
         *            the source GeneralPath object.
         */
        Iterator(GeneralPath path) {
            this(path, null);
        }

        /**
         * Constructs a new GeneralPath.Iterator for given general path and
         * transformation.
         *
         * @param path
         *            the source GeneralPath object.
         * @param at
         *            the AffineTransform object to apply rectangle path.
         */
        Iterator(GeneralPath path, AffineTransform at) {
            this.p = path;
            this.t = at;
        }

        public int getWindingRule() {
            return p.getWindingRule();
        }

        public boolean isDone() {
            return typeIndex >= p.typeSize;
        }

        public void next() {
            typeIndex++;
        }

        public int currentSegment(double[] coords) {
            if (isDone()) {
                // awt.4B=Iterator out of bounds
                throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
            }
            int type = p.types[typeIndex];
            int count = GeneralPath.pointShift[type];
            for (int i = 0; i < count; i++) {
                coords[i] = p.points[pointIndex + i];
            }
            if (t != null) {
                t.transform(coords, 0, coords, 0, count / 2);
            }
            pointIndex += count;
            return type;
        }

        public int currentSegment(float[] coords) {
            if (isDone()) {
                // awt.4B=Iterator out of bounds
                throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
            }
            int type = p.types[typeIndex];
            int count = GeneralPath.pointShift[type];
            System.arraycopy(p.points, pointIndex, coords, 0, count);
            if (t != null) {
                t.transform(coords, 0, coords, 0, count / 2);
            }
            pointIndex += count;
            return type;
        }

    }

    /**
     * Instantiates a new general path with the winding rule set to
     * {@link PathIterator#WIND_NON_ZERO} and the initial capacity (number of
     * segments) set to the default value 10.
     */
    public GeneralPath() {
        this(WIND_NON_ZERO, BUFFER_SIZE);
    }

    /**
     * Instantiates a new general path with the given winding rule and the
     * initial capacity (number of segments) set to the default value 10.
     *
     * @param rule
     *            the winding rule, either {@link PathIterator#WIND_EVEN_ODD} or
     *            {@link PathIterator#WIND_NON_ZERO}.
     */
    public GeneralPath(int rule) {
        this(rule, BUFFER_SIZE);
    }

    /**
     * Instantiates a new general path with the given winding rule and initial
     * capacity (number of segments).
     *
     * @param rule
     *            the winding rule, either {@link PathIterator#WIND_EVEN_ODD} or
     *            {@link PathIterator#WIND_NON_ZERO}.
     * @param initialCapacity
     *            the number of segments the path is set to hold.
     */
    public GeneralPath(int rule, int initialCapacity) {
        setWindingRule(rule);
        types = new byte[initialCapacity];
        points = new float[initialCapacity * 2];
    }

    /**
     * Creates a new GeneralPath from the outline of the given shape.
     *
     * @param shape
     *            the shape.
     */
    public GeneralPath(Shape shape) {
        this(WIND_NON_ZERO, BUFFER_SIZE);
        PathIterator p = shape.getPathIterator(null);
        setWindingRule(p.getWindingRule());
        append(p, false);
    }

    /**
     * Sets the winding rule, which determines how to decide whether a point
     * that isn't on the path itself is inside or outside of the shape.
     *
     * @param rule
     *            the new winding rule.
     * @throws IllegalArgumentException
     *             if the winding rule is neither
     *             {@link PathIterator#WIND_EVEN_ODD} nor
     *             {@link PathIterator#WIND_NON_ZERO}.
     */
    public void setWindingRule(int rule) {
        if (rule != WIND_EVEN_ODD && rule != WIND_NON_ZERO) {
            // awt.209=Invalid winding rule value
            throw new java.lang.IllegalArgumentException(Messages.getString("awt.209")); //$NON-NLS-1$
        }
        this.rule = rule;
    }

    /**
     * Gets the winding rule.
     *
     * @return the winding rule, either {@link PathIterator#WIND_EVEN_ODD} or
     *         {@link PathIterator#WIND_NON_ZERO}.
     */
    public int getWindingRule() {
        return rule;
    }

    /**
     * Checks the point data buffer sizes to see whether pointCount additional
     * point-data elements can fit. (Note that the number of point data elements
     * to add is more than one per point -- it depends on the type of point
     * being added.) Reallocates the buffers to enlarge the size if necessary.
     *
     * @param pointCount
     *            the number of point data elements to be added.
     * @param checkMove
     *            whether to check for existing points.
     * @throws IllegalPathStateException
     *             checkMove is true and the path is currently empty.
     */
    void checkBuf(int pointCount, boolean checkMove) {
        if (checkMove && typeSize == 0) {
            // awt.20A=First segment should be SEG_MOVETO type
            throw new IllegalPathStateException(Messages.getString("awt.20A")); //$NON-NLS-1$
        }
        if (typeSize == types.length) {
            byte tmp[] = new byte[typeSize + BUFFER_CAPACITY];
            System.arraycopy(types, 0, tmp, 0, typeSize);
            types = tmp;
        }
        if (pointSize + pointCount > points.length) {
            float tmp[] = new float[pointSize + Math.max(BUFFER_CAPACITY * 2, pointCount)];
            System.arraycopy(points, 0, tmp, 0, pointSize);
            points = tmp;
        }
    }

    /**
     * Appends a new point to the end of this general path, disconnected from
     * the existing path.
     *
     * @param x
     *            the x coordinate of the next point to append.
     * @param y
     *            the y coordinate of the next point to append.
     */
    public void moveTo(float x, float y) {
        if (typeSize > 0 && types[typeSize - 1] == PathIterator.SEG_MOVETO) {
            points[pointSize - 2] = x;
            points[pointSize - 1] = y;
        } else {
            checkBuf(2, false);
            types[typeSize++] = PathIterator.SEG_MOVETO;
            points[pointSize++] = x;
            points[pointSize++] = y;
        }
    }

    /**
     * Appends a new segment to the end of this general path by making a
     * straight line segment from the current endpoint to the given new point.
     *
     * @param x
     *            the x coordinate of the next point to append.
     * @param y
     *            the y coordinate of the next point to append.
     */
    public void lineTo(float x, float y) {
        checkBuf(2, true);
        types[typeSize++] = PathIterator.SEG_LINETO;
        points[pointSize++] = x;
        points[pointSize++] = y;
    }

    /**
     * Appends a new segment to the end of this general path by making a
     * quadratic curve from the current endpoint to the point (x2, y2) using the
     * point (x1, y1) as the quadratic curve's control point.
     *
     * @param x1
     *            the x coordinate of the quadratic curve's control point.
     * @param y1
     *            the y coordinate of the quadratic curve's control point.
     * @param x2
     *            the x coordinate of the quadratic curve's end point.
     * @param y2
     *            the y coordinate of the quadratic curve's end point.
     */
    public void quadTo(float x1, float y1, float x2, float y2) {
        checkBuf(4, true);
        types[typeSize++] = PathIterator.SEG_QUADTO;
        points[pointSize++] = x1;
        points[pointSize++] = y1;
        points[pointSize++] = x2;
        points[pointSize++] = y2;
    }

    /**
     * Appends a new segment to the end of this general path by making a cubic
     * curve from the current endpoint to the point (x3, y3) using (x1, y1) and
     * (x2, y2) as control points.
     *
     * @see java.awt.geom.CubicCurve2D
     * @param x1
     *            the x coordinate of the new cubic segment's first control
     *            point.
     * @param y1
     *            the y coordinate of the new cubic segment's first control
     *            point.
     * @param x2
     *            the x coordinate of the new cubic segment's second control
     *            point.
     * @param y2
     *            the y coordinate of the new cubic segment's second control
     *            point.
     * @param x3
     *            the x coordinate of the new cubic segment's end point.
     * @param y3
     *            the y coordinate of the new cubic segment's end point.
     */
    public void curveTo(float x1, float y1, float x2, float y2, float x3, float y3) {
        checkBuf(6, true);
        types[typeSize++] = PathIterator.SEG_CUBICTO;
        points[pointSize++] = x1;
        points[pointSize++] = y1;
        points[pointSize++] = x2;
        points[pointSize++] = y2;
        points[pointSize++] = x3;
        points[pointSize++] = y3;
    }

    /**
     * Appends the type information to declare that the current endpoint closes
     * the curve.
     */
    public void closePath() {
        if (typeSize == 0 || types[typeSize - 1] != PathIterator.SEG_CLOSE) {
            checkBuf(0, true);
            types[typeSize++] = PathIterator.SEG_CLOSE;
        }
    }

    /**
     * Appends the outline of the specified shape onto the end of this
     * GeneralPath.
     *
     * @param shape
     *            the shape whose outline is to be appended.
     * @param connect
     *            true to connect this path's current endpoint to the first
     *            point of the shape's outline or false to append the shape's
     *            outline without connecting it.
     * @throws NullPointerException
     *             if the shape parameter is null.
     */
    public void append(Shape shape, boolean connect) {
        PathIterator p = shape.getPathIterator(null);
        append(p, connect);
    }

    /**
     * Appends the path defined by the specified PathIterator onto the end of
     * this GeneralPath.
     *
     * @param path
     *            the PathIterator that defines the new path to append.
     * @param connect
     *            true to connect this path's current endpoint to the first
     *            point of the shape's outline or false to append the shape's
     *            outline without connecting it.
     */
    public void append(PathIterator path, boolean connect) {
        while (!path.isDone()) {
            float coords[] = new float[6];
            switch (path.currentSegment(coords)) {
                case PathIterator.SEG_MOVETO:
                    if (!connect || typeSize == 0) {
                        moveTo(coords[0], coords[1]);
                        break;
                    }
                    if (types[typeSize - 1] != PathIterator.SEG_CLOSE
                            && points[pointSize - 2] == coords[0]
                            && points[pointSize - 1] == coords[1]) {
                        break;
                    }
                    // NO BREAK;
                case PathIterator.SEG_LINETO:
                    lineTo(coords[0], coords[1]);
                    break;
                case PathIterator.SEG_QUADTO:
                    quadTo(coords[0], coords[1], coords[2], coords[3]);
                    break;
                case PathIterator.SEG_CUBICTO:
                    curveTo(coords[0], coords[1], coords[2], coords[3], coords[4], coords[5]);
                    break;
                case PathIterator.SEG_CLOSE:
                    closePath();
                    break;
            }
            path.next();
            connect = false;
        }
    }

    /**
     * Gets the current end point of the path.
     *
     * @return the current end point of the path.
     */
    public Point2D getCurrentPoint() {
        if (typeSize == 0) {
            return null;
        }
        int j = pointSize - 2;
        if (types[typeSize - 1] == PathIterator.SEG_CLOSE) {

            for (int i = typeSize - 2; i > 0; i--) {
                int type = types[i];
                if (type == PathIterator.SEG_MOVETO) {
                    break;
                }
                j -= pointShift[type];
            }
        }
        return new Point2D.Float(points[j], points[j + 1]);
    }

    /**
     * Resets the GeneralPath to being an empty path. The underlying point and
     * segment data is not deleted but rather the end indices of the data arrays
     * are set to zero.
     */
    public void reset() {
        typeSize = 0;
        pointSize = 0;
    }

    /**
     * Transform all of the coordinates of this path according to the specified
     * AffineTransform.
     *
     * @param t
     *            the AffineTransform.
     */
    public void transform(AffineTransform t) {
        t.transform(points, 0, points, 0, pointSize / 2);
    }

    /**
     * Creates a new GeneralPath whose data is given by this path's data
     * transformed according to the specified AffineTransform.
     *
     * @param t
     *            the AffineTransform.
     * @return the new GeneralPath whose data is given by this path's data
     *         transformed according to the specified AffineTransform.
     */
    public Shape createTransformedShape(AffineTransform t) {
        GeneralPath p = (GeneralPath)clone();
        if (t != null) {
            p.transform(t);
        }
        return p;
    }

    public Rectangle2D getBounds2D() {
        float rx1, ry1, rx2, ry2;
        if (pointSize == 0) {
            rx1 = ry1 = rx2 = ry2 = 0.0f;
        } else {
            int i = pointSize - 1;
            ry1 = ry2 = points[i--];
            rx1 = rx2 = points[i--];
            while (i > 0) {
                float y = points[i--];
                float x = points[i--];
                if (x < rx1) {
                    rx1 = x;
                } else if (x > rx2) {
                    rx2 = x;
                }
                if (y < ry1) {
                    ry1 = y;
                } else if (y > ry2) {
                    ry2 = y;
                }
            }
        }
        return new Rectangle2D.Float(rx1, ry1, rx2 - rx1, ry2 - ry1);
    }

    public Rectangle getBounds() {
        return getBounds2D().getBounds();
    }

    /**
     * Checks the cross count (number of times a ray from the point crosses the
     * shape's boundary) to determine whether the number of crossings
     * corresponds to a point inside the shape or not (according to the shape's
     * path rule).
     *
     * @param cross
     *            the point's cross count.
     * @return true if the point is inside the path, or false otherwise.
     */
    boolean isInside(int cross) {
        if (rule == WIND_NON_ZERO) {
            return Crossing.isInsideNonZero(cross);
        }
        return Crossing.isInsideEvenOdd(cross);
    }

    public boolean contains(double px, double py) {
        return isInside(Crossing.crossShape(this, px, py));
    }

    public boolean contains(double rx, double ry, double rw, double rh) {
        int cross = Crossing.intersectShape(this, rx, ry, rw, rh);
        return cross != Crossing.CROSSING && isInside(cross);
    }

    public boolean intersects(double rx, double ry, double rw, double rh) {
        int cross = Crossing.intersectShape(this, rx, ry, rw, rh);
        return cross == Crossing.CROSSING || isInside(cross);
    }

    public boolean contains(Point2D p) {
        return contains(p.getX(), p.getY());
    }

    public boolean contains(Rectangle2D r) {
        return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight());
    }

    public boolean intersects(Rectangle2D r) {
        return intersects(r.getX(), r.getY(), r.getWidth(), r.getHeight());
    }

    public PathIterator getPathIterator(AffineTransform t) {
        return new Iterator(this, t);
    }

    public PathIterator getPathIterator(AffineTransform t, double flatness) {
        return new FlatteningPathIterator(getPathIterator(t), flatness);
    }

    @Override
    public Object clone() {
        try {
            GeneralPath p = (GeneralPath)super.clone();
            p.types = types.clone();
            p.points = points.clone();
            return p;
        } catch (CloneNotSupportedException e) {
            throw new InternalError();
        }
    }

}