awt/java/awt/geom/GeneralPath.java - platform/frameworks/base - Git at Google

 /*
  *  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();
         }
     }

 }
	/*
	* 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();
	}
	}

	}