/*
* 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.Point;
import java.awt.Rectangle;
import java.awt.Shape;
import java.awt.geom.AffineTransform;
import java.awt.geom.PathIterator;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.io.Serializable;
import java.util.NoSuchElementException;
import org.apache.harmony.awt.gl.*;
import org.apache.harmony.awt.internal.nls.Messages;
/**
* The Polygon class defines an closed area specified by n vertices and n edges.
* The coordinates of the vertices are specified by x, y arrays. The edges are
* the line segments from the point (x[i], y[i]) to the point (x[i+1], y[i+1]),
* for -1 < i < (n-1) plus the line segment from the point (x[n-1], y[n-1]) to
* the point (x[0], y[0]) point. The Polygon is empty if the number of vertices
* is zero.
*
* @since Android 1.0
*/
public class Polygon implements Shape, Serializable {
/**
* The Constant serialVersionUID.
*/
private static final long serialVersionUID = -6460061437900069969L;
/**
* The points buffer capacity.
*/
private static final int BUFFER_CAPACITY = 4;
/**
* The number of Polygon vertices.
*/
public int npoints;
/**
* The array of X coordinates of the vertices.
*/
public int[] xpoints;
/**
* The array of Y coordinates of the vertices.
*/
public int[] ypoints;
/**
* The smallest Rectangle that completely contains this Polygon.
*/
protected Rectangle bounds;
/*
* Polygon path iterator
*/
/**
* The internal Class Iterator.
*/
class Iterator implements PathIterator {
/**
* The source Polygon object.
*/
public Polygon p;
/**
* The path iterator transformation.
*/
public AffineTransform t;
/**
* The current segment index.
*/
public int index;
/**
* Constructs a new Polygon.Iterator for the given polygon and
* transformation
*
* @param at
* the AffineTransform object to apply rectangle path.
* @param p
* the p.
*/
public Iterator(AffineTransform at, Polygon p) {
this.p = p;
this.t = at;
if (p.npoints == 0) {
index = 1;
}
}
public int getWindingRule() {
return WIND_EVEN_ODD;
}
public boolean isDone() {
return index > p.npoints;
}
public void next() {
index++;
}
public int currentSegment(double[] coords) {
if (isDone()) {
// awt.110=Iterator out of bounds
throw new NoSuchElementException(Messages.getString("awt.110")); //$NON-NLS-1$
}
if (index == p.npoints) {
return SEG_CLOSE;
}
coords[0] = p.xpoints[index];
coords[1] = p.ypoints[index];
if (t != null) {
t.transform(coords, 0, coords, 0, 1);
}
return index == 0 ? SEG_MOVETO : SEG_LINETO;
}
public int currentSegment(float[] coords) {
if (isDone()) {
// awt.110=Iterator out of bounds
throw new NoSuchElementException(Messages.getString("awt.110")); //$NON-NLS-1$
}
if (index == p.npoints) {
return SEG_CLOSE;
}
coords[0] = p.xpoints[index];
coords[1] = p.ypoints[index];
if (t != null) {
t.transform(coords, 0, coords, 0, 1);
}
return index == 0 ? SEG_MOVETO : SEG_LINETO;
}
}
/**
* Instantiates a new empty polygon.
*/
public Polygon() {
xpoints = new int[BUFFER_CAPACITY];
ypoints = new int[BUFFER_CAPACITY];
}
/**
* Instantiates a new polygon with the specified number of vertices, and the
* given arrays of x, y vertex coordinates. The length of each coordinate
* array may not be less than the specified number of vertices but may be
* greater. Only the first n elements are used from each coordinate array.
*
* @param xpoints
* the array of X vertex coordinates.
* @param ypoints
* the array of Y vertex coordinates.
* @param npoints
* the number vertices of the polygon.
* @throws IndexOutOfBoundsException
* if the length of xpoints or ypoints is less than n.
* @throws NegativeArraySizeException
* if n is negative.
*/
public Polygon(int[] xpoints, int[] ypoints, int npoints) {
if (npoints > xpoints.length || npoints > ypoints.length) {
// awt.111=Parameter npoints is greater than array length
throw new IndexOutOfBoundsException(Messages.getString("awt.111")); //$NON-NLS-1$
}
if (npoints < 0) {
// awt.112=Negative number of points
throw new NegativeArraySizeException(Messages.getString("awt.112")); //$NON-NLS-1$
}
this.npoints = npoints;
this.xpoints = new int[npoints];
this.ypoints = new int[npoints];
System.arraycopy(xpoints, 0, this.xpoints, 0, npoints);
System.arraycopy(ypoints, 0, this.ypoints, 0, npoints);
}
/**
* Resets the current Polygon to an empty Polygon. More precisely, the
* number of Polygon vertices is set to zero, but x, y coordinates arrays
* are not affected.
*/
public void reset() {
npoints = 0;
bounds = null;
}
/**
* Invalidates the data that depends on the vertex coordinates. This method
* should be called after direct manipulations of the x, y vertex
* coordinates arrays to avoid unpredictable results of methods which rely
* on the bounding box.
*/
public void invalidate() {
bounds = null;
}
/**
* Adds the point to the Polygon and updates the bounding box accordingly.
*
* @param px
* the X coordinate of the added vertex.
* @param py
* the Y coordinate of the added vertex.
*/
public void addPoint(int px, int py) {
if (npoints == xpoints.length) {
int[] tmp;
tmp = new int[xpoints.length + BUFFER_CAPACITY];
System.arraycopy(xpoints, 0, tmp, 0, xpoints.length);
xpoints = tmp;
tmp = new int[ypoints.length + BUFFER_CAPACITY];
System.arraycopy(ypoints, 0, tmp, 0, ypoints.length);
ypoints = tmp;
}
xpoints[npoints] = px;
ypoints[npoints] = py;
npoints++;
if (bounds != null) {
bounds.setFrameFromDiagonal(Math.min(bounds.getMinX(), px), Math.min(bounds.getMinY(),
py), Math.max(bounds.getMaxX(), px), Math.max(bounds.getMaxY(), py));
}
}
/**
* Gets the bounding rectangle of the Polygon. The bounding rectangle is the
* smallest rectangle which contains the Polygon.
*
* @return the bounding rectangle of the Polygon.
* @see java.awt.Shape#getBounds()
*/
public Rectangle getBounds() {
if (bounds != null) {
return bounds;
}
if (npoints == 0) {
return new Rectangle();
}
int bx1 = xpoints[0];
int by1 = ypoints[0];
int bx2 = bx1;
int by2 = by1;
for (int i = 1; i < npoints; i++) {
int x = xpoints[i];
int y = ypoints[i];
if (x < bx1) {
bx1 = x;
} else if (x > bx2) {
bx2 = x;
}
if (y < by1) {
by1 = y;
} else if (y > by2) {
by2 = y;
}
}
return bounds = new Rectangle(bx1, by1, bx2 - bx1, by2 - by1);
}
/**
* Gets the bounding rectangle of the Polygon. The bounding rectangle is the
* smallest rectangle which contains the Polygon.
*
* @return the bounding rectangle of the Polygon.
* @deprecated Use getBounds() method.
*/
@Deprecated
public Rectangle getBoundingBox() {
return getBounds();
}
/**
* Gets the Rectangle2D which represents Polygon bounds. The bounding
* rectangle is the smallest rectangle which contains the Polygon.
*
* @return the bounding rectangle of the Polygon.
* @see java.awt.Shape#getBounds2D()
*/
public Rectangle2D getBounds2D() {
return getBounds().getBounds2D();
}
/**
* Translates all vertices of Polygon the specified distances along X, Y
* axis.
*
* @param mx
* the distance to translate horizontally.
* @param my
* the distance to translate vertically.
*/
public void translate(int mx, int my) {
for (int i = 0; i < npoints; i++) {
xpoints[i] += mx;
ypoints[i] += my;
}
if (bounds != null) {
bounds.translate(mx, my);
}
}
/**
* Checks whether or not the point given by the coordinates x, y lies inside
* the Polygon.
*
* @param x
* the X coordinate of the point to check.
* @param y
* the Y coordinate of the point to check.
* @return true, if the specified point lies inside the Polygon, false
* otherwise.
* @deprecated Use contains(int, int) method.
*/
@Deprecated
public boolean inside(int x, int y) {
return contains((double)x, (double)y);
}
/**
* Checks whether or not the point given by the coordinates x, y lies inside
* the Polygon.
*
* @param x
* the X coordinate of the point to check.
* @param y
* the Y coordinate of the point to check.
* @return true, if the specified point lies inside the Polygon, false
* otherwise.
*/
public boolean contains(int x, int y) {
return contains((double)x, (double)y);
}
/**
* Checks whether or not the point with specified double coordinates lies
* inside the Polygon.
*
* @param x
* the X coordinate of the point to check.
* @param y
* the Y coordinate of the point to check.
* @return true, if the point given by the double coordinates lies inside
* the Polygon, false otherwise.
* @see java.awt.Shape#contains(double, double)
*/
public boolean contains(double x, double y) {
return Crossing.isInsideEvenOdd(Crossing.crossShape(this, x, y));
}
/**
* Checks whether or not the rectangle determined by the parameters [x, y,
* width, height] lies inside the Polygon.
*
* @param x
* the X coordinate of the rectangles's left upper corner as a
* double.
* @param y
* the Y coordinate of the rectangles's left upper corner as a
* double.
* @param width
* the width of rectangle as a double.
* @param height
* the height of rectangle as a double.
* @return true, if the specified rectangle lies inside the Polygon, false
* otherwise.
* @see java.awt.Shape#contains(double, double, double, double)
*/
public boolean contains(double x, double y, double width, double height) {
int cross = Crossing.intersectShape(this, x, y, width, height);
return cross != Crossing.CROSSING && Crossing.isInsideEvenOdd(cross);
}
/**
* Checks whether or not the rectangle determined by the parameters [x, y,
* width, height] intersects the interior of the Polygon.
*
* @param x
* the X coordinate of the rectangles's left upper corner as a
* double.
* @param y
* the Y coordinate of the rectangles's left upper corner as a
* double.
* @param width
* the width of rectangle as a double.
* @param height
* the height of rectangle as a double.
* @return true, if the specified rectangle intersects the interior of the
* Polygon, false otherwise.
* @see java.awt.Shape#intersects(double, double, double, double)
*/
public boolean intersects(double x, double y, double width, double height) {
int cross = Crossing.intersectShape(this, x, y, width, height);
return cross == Crossing.CROSSING || Crossing.isInsideEvenOdd(cross);
}
/**
* Checks whether or not the specified rectangle lies inside the Polygon.
*
* @param rect
* the Rectangle2D object.
* @return true, if the specified rectangle lies inside the Polygon, false
* otherwise.
* @see java.awt.Shape#contains(java.awt.geom.Rectangle2D)
*/
public boolean contains(Rectangle2D rect) {
return contains(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight());
}
/**
* Checks whether or not the specified Point lies inside the Polygon.
*
* @param point
* the Point object.
* @return true, if the specified Point lies inside the Polygon, false
* otherwise.
*/
public boolean contains(Point point) {
return contains(point.getX(), point.getY());
}
/**
* Checks whether or not the specified Point2D lies inside the Polygon.
*
* @param point
* the Point2D object.
* @return true, if the specified Point2D lies inside the Polygon, false
* otherwise.
* @see java.awt.Shape#contains(java.awt.geom.Point2D)
*/
public boolean contains(Point2D point) {
return contains(point.getX(), point.getY());
}
/**
* Checks whether or not the interior of rectangle specified by the
* Rectangle2D object intersects the interior of the Polygon.
*
* @param rect
* the Rectangle2D object.
* @return true, if the Rectangle2D intersects the interior of the Polygon,
* false otherwise.
* @see java.awt.Shape#intersects(java.awt.geom.Rectangle2D)
*/
public boolean intersects(Rectangle2D rect) {
return intersects(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight());
}
/**
* Gets the PathIterator object which gives the coordinates of the polygon,
* transformed according to the specified AffineTransform.
*
* @param t
* the specified AffineTransform object or null.
* @return PathIterator object for the Polygon.
* @see java.awt.Shape#getPathIterator(java.awt.geom.AffineTransform)
*/
public PathIterator getPathIterator(AffineTransform t) {
return new Iterator(t, this);
}
/**
* Gets the PathIterator object which gives the coordinates of the polygon,
* transformed according to the specified AffineTransform. The flatness
* parameter is ignored.
*
* @param t
* the specified AffineTransform object or null.
* @param flatness
* the maximum number of the control points for a given curve
* which varies from colinear before a subdivided curve is
* replaced by a straight line connecting the endpoints. This
* parameter is ignored for the Polygon class.
* @return PathIterator object for the Polygon.
* @see java.awt.Shape#getPathIterator(java.awt.geom.AffineTransform,
* double)
*/
public PathIterator getPathIterator(AffineTransform t, double flatness) {
return new Iterator(t, this);
}
}