harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From telli...@apache.org
Subject svn commit: r547012 - in /harmony/enhanced/classlib/trunk/modules/awt/src: main/java/common/java/awt/geom/Area.java test/api/java/common/java/awt/geom/AreaTest.java
Date Wed, 13 Jun 2007 20:02:43 GMT
Author: tellison
Date: Wed Jun 13 13:02:41 2007
New Revision: 547012

URL: http://svn.apache.org/viewvc?view=rev&rev=547012
Log:
Rollback changes in r546906 (java.awt.geom.Area implementation from HARMONY-1476)

Modified:
    harmony/enhanced/classlib/trunk/modules/awt/src/main/java/common/java/awt/geom/Area.java
    harmony/enhanced/classlib/trunk/modules/awt/src/test/api/java/common/java/awt/geom/AreaTest.java

Modified: harmony/enhanced/classlib/trunk/modules/awt/src/main/java/common/java/awt/geom/Area.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/awt/src/main/java/common/java/awt/geom/Area.java?view=diff&rev=547012&r1=547011&r2=547012
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/awt/src/main/java/common/java/awt/geom/Area.java (original)
+++ harmony/enhanced/classlib/trunk/modules/awt/src/main/java/common/java/awt/geom/Area.java Wed Jun 13 13:02:41 2007
@@ -14,1287 +14,199 @@
  *  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.awt.geom.PathIterator;
+import java.awt.geom.Rectangle2D;
 import java.util.NoSuchElementException;
 
-import org.apache.harmony.awt.gl.Crossing;
-import org.apache.harmony.awt.internal.CrossingHelper;
-import org.apache.harmony.awt.internal.CurveCrossingHelper;
-import org.apache.harmony.awt.internal.GeometryUtil;
-import org.apache.harmony.awt.internal.IntersectPoint;
 import org.apache.harmony.awt.internal.nls.Messages;
 
-
 public class Area implements Shape, Cloneable {
 
     /**
-     * the coordinates array of the shape vertices
+     * The source Shape object
      */
-	private double coords[] = new double[20];
-	
-	/**
-	 * the coordinates quantity
-	 */
-	private int coordsSize = 0;
-	
-	/**
-	 * the rules array for the drawing of the shape edges
-	 */
-	private int rules[] = new int[10];
-	
-	/**
-	 * the rules quantity
-	 */
-	private int rulesSize = 0;
-	
-	/**
-	 * offsets[i] - index in array of coords and i - index in array of rules
-	 */
-	private int offsets[] = new int[10];
-	
-	/**
-	 * the quantity of MOVETO rule occurences
-	 */
-	private int moveToCount = 0;
-	
-	/**
-	 * true if the shape is polygon
-	 */
-	private boolean isPolygonal = true;
-
-	public Area() {
-	}
-
-	public Area(Shape s) {
-		double segmentCoords[] = new double[6];
-		double lastMoveX = 0.0;
-		double lastMoveY = 0.0;
-		int rulesIndex = 0;
-		int coordsIndex = 0;
-		
-		for (PathIterator pi = s.getPathIterator(null); 
-		        !pi.isDone(); pi.next()) {
-			coords = adjustSize(coords, coordsIndex + 6);
-			rules = adjustSize(rules, rulesIndex + 1);
-			offsets = adjustSize(offsets, rulesIndex + 1);
-			rules[rulesIndex] = pi.currentSegment(segmentCoords);
-			offsets[rulesIndex] = coordsIndex;
-			
-			switch (rules[rulesIndex]) {
-                case PathIterator.SEG_MOVETO:
-                    coords[coordsIndex++] = segmentCoords[0];
-                    coords[coordsIndex++] = segmentCoords[1];
-                    lastMoveX = segmentCoords[0];
-                    lastMoveY = segmentCoords[1];
-                    ++moveToCount;
-                    break;
-                case PathIterator.SEG_LINETO:
-                    if ((segmentCoords[0] != lastMoveX) || 
-                    		(segmentCoords[1] != lastMoveY)) {
-                        coords[coordsIndex++] = segmentCoords[0];
-                        coords[coordsIndex++] = segmentCoords[1];
-                    } else {
-                        --rulesIndex;
-                    }
-                    break;
-                case PathIterator.SEG_QUADTO:
-                    System.arraycopy(segmentCoords, 0, coords, coordsIndex, 4);
-                    coordsIndex += 4;
-                    isPolygonal = false;
-                    break;
-                case PathIterator.SEG_CUBICTO:
-                    System.arraycopy(segmentCoords, 0, coords, coordsIndex, 6);
-                    coordsIndex += 6;
-                    isPolygonal = false;
-                    break;
-                case PathIterator.SEG_CLOSE:
-                    break;
-            }
-            ++rulesIndex;
-		}
-		
-		if ((rulesIndex != 0) && 
-				(rules[rulesIndex - 1] != PathIterator.SEG_CLOSE)) {
-			rules[rulesIndex] = PathIterator.SEG_CLOSE;
-			offsets[rulesIndex] = coordsSize;
-		}
-		
-		rulesSize = rulesIndex;
-		coordsSize = coordsIndex;
-	}
-
-	public boolean contains(double x, double y) {
-        return !isEmpty() &&
-                   containsExact(x, y) > 0;
-    }
-
-	public boolean contains(double x, double y, double width, double height) {
-		int crossCount = Crossing.intersectPath(getPathIterator(null), x, y,
-				width, height);
-		return crossCount != Crossing.CROSSING &&
-			       Crossing.isInsideEvenOdd(crossCount);
-	}
-
-	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 equals(Area obj) {
-		if (this == obj) {
-			return true;
-		}
-		
-		if (obj == null) {
-			return false;
-		}
-		
-		Area area = (Area)clone();
-		area.subtract(obj);
-		return area.isEmpty();
-	}
-
-	public boolean intersects(double x, double y, double width, double height) {
-		if ((width <= 0.0) || (height <= 0.0)) {
-			return false;
-		} else if (!getBounds2D().intersects(x, y, width, height)) {
-			return false;
-		}
-		
-		int crossCount = Crossing.intersectShape(this, x, y, width, height);
-		return Crossing.isInsideEvenOdd(crossCount);
-	}
-
-	public boolean intersects(Rectangle2D r) {
-		return intersects(r.getX(), r.getY(), r.getWidth(), r.getHeight());
-	}
-
-	public Rectangle getBounds() {
-		return getBounds2D().getBounds();
-	}
-
-	public Rectangle2D getBounds2D() {
-		double maxX = coords[0];
-		double maxY = coords[1];
-		double minX = coords[0];
-		double minY = coords[1];
-
-		for (int i = 0; i < coordsSize;) {
-			minX = Math.min(minX, coords[i]);
-			maxX = Math.max(maxX, coords[i++]);
-			minY = Math.min(minY, coords[i]);
-			maxY = Math.max(maxY, coords[i++]);
-		}
-		
-		return new Rectangle2D.Double(minX, minY, maxX - minX, maxY - minY);
-	}
-
-	public PathIterator getPathIterator(AffineTransform t) {
-		return new AreaPathIterator(this, t);
-	}
-	
-	public PathIterator getPathIterator(AffineTransform t, double flatness) {
-		return new FlatteningPathIterator(getPathIterator(t), flatness);
-	}
-	
-	public boolean isEmpty() {
-		return (rulesSize == 0) && (coordsSize == 0);
-	}
-
-	public boolean isPolygonal() {
-		return isPolygonal;
-	}
-
-	public boolean isRectangular() {
-        return (isPolygonal) && (rulesSize <= 5) && (coordsSize <= 8) &&
-               (coords[1] == coords[3]) && (coords[7] == coords[5]) &&
-               (coords[0] == coords[6]) && (coords[2] == coords[4]);
-    }
-
-	public boolean isSingular() {
-		return (moveToCount <= 1);
-	}
-
-	public void reset() {
-		coordsSize = 0;
-		rulesSize = 0;
-	}
-
-	public void transform(AffineTransform t) {
-		copy(new Area(t.createTransformedShape(this)), this);
-	}
-
-	public Area createTransformedArea(AffineTransform t) {
-		return new Area(t.createTransformedShape(this));
-	}
-
-	public Object clone() {
-		Area area = new Area();
-		copy(this, area);
-		return area;
-	}
-
-	public void add(Area area) {
-		if (isPolygonal() && area.isPolygonal()) {
-			addPolygon(area);
-		} else {
-			addCurvePolygon(area);
-		}
-	}
-	   
-	public void intersect(Area area) {
-		if (isPolygonal() && area.isPolygonal()) {
-			intersectPolygon(area);
-		} else {
-			intersectCurvePolygon(area);
-		}
-	}
-	
-	public void subtract(Area area) {
-		if (isPolygonal() && area.isPolygonal()) {
-			subtractPolygon(area);
-		} else {
-			subtractCurvePolygon(area);
-		}
-	}
-	
- 	public void exclusiveOr(Area area) {
-		Area a = (Area) clone();
-		a.intersect(area);
-		add(area);
-		subtract(a);
-	}
-
-	private void addCurvePolygon(Area area) {
-		CurveCrossingHelper crossHelper = new CurveCrossingHelper(
-	            new double[][] { coords, area.coords },  
-		        new int[] { coordsSize, area.coordsSize }, 
-		        new int[][] { rules, area.rules },
-				new int[] { rulesSize, area.rulesSize }, 
-				new int[][] { offsets, area.offsets });
-		IntersectPoint[] intersectPoints = crossHelper.findCrossing();
-
-		if (intersectPoints.length == 0) {
-			if (area.contains(getBounds2D())) {
-				copy(area, this);
-			} else if (!contains(area.getBounds2D())) {
-				coords = adjustSize(coords, coordsSize + area.coordsSize);
-				System.arraycopy(area.coords, 0, coords, coordsSize,
-								 area.coordsSize);
-				coordsSize += area.coordsSize;
-				rules = adjustSize(rules, rulesSize + area.rulesSize);
-				System.arraycopy(area.rules, 0, rules, rulesSize, 
-								 area.rulesSize);
-				rulesSize += area.rulesSize;
-				offsets = adjustSize(offsets, rulesSize + area.rulesSize);
-				System.arraycopy(area.offsets, 0, offsets, rulesSize, 
-								 area.rulesSize);
-			}
-			
-			return;
-		}
-
-        double[] resultCoords = new double[coordsSize + area.coordsSize + 
-                                                       intersectPoints.length];
-        int[] resultRules = new int[rulesSize + area.rulesSize + 
-                                                       intersectPoints.length];
-        int[] resultOffsets = new int[rulesSize + area.rulesSize + 
-                                                       intersectPoints.length];
-        int resultCoordPos = 0;
-        int resultRulesPos = 0;
-        boolean isCurrentArea = true;
-
-        IntersectPoint point = intersectPoints[0];
-        resultRules[resultRulesPos] = PathIterator.SEG_MOVETO;
-        resultOffsets[resultRulesPos++] = resultCoordPos;
-        
-        do {
-        	resultCoords[resultCoordPos++] = point.getX();
-            resultCoords[resultCoordPos++] = point.getY();
-            int curIndex = point.getEndIndex(true);
-            
-            if (curIndex < 0) {
-            	isCurrentArea = !isCurrentArea;
-            } else if (area.containsExact(coords[2 * curIndex], 
-            		                      coords[2 * curIndex + 1]) > 0) { 
-            	isCurrentArea = false;
-            } else {
-            	isCurrentArea = true;
-            }
+    Shape s;
 
-            IntersectPoint nextPoint = getNextIntersectPoint(intersectPoints, 
-                                                             point, 
-                                                             isCurrentArea);
-            double[] coords = (isCurrentArea) ? this.coords : area.coords;
-            int[] offsets = (isCurrentArea) ? this.offsets : area.offsets;
-            int[] rules = (isCurrentArea) ? this.rules : area.rules;
-            int offset = point.getRuleIndex(isCurrentArea);
-            boolean isCopyUntilZero = false;
-            
-            if ((point.getRuleIndex(isCurrentArea) > 
-                    nextPoint.getRuleIndex(isCurrentArea))) {
-            	int rulesSize = (isCurrentArea) ? this.rulesSize : 
-            		                              area.rulesSize;
-            	resultCoordPos = includeCoordsAndRules(offset + 1, rulesSize,
-            			                               rules, offsets, 
-            			                               resultRules, 
-            			                               resultOffsets, 
-            			                               resultCoords, coords, 
-            			                               resultRulesPos, 
-            			                               resultCoordPos,
-            			                               point, isCurrentArea, 
-            			                               false, 0);
-            	resultRulesPos += rulesSize - offset - 1; 
-            	offset = 1;
-            	isCopyUntilZero = true;
-            }
-            
-            int length = nextPoint.getRuleIndex(isCurrentArea) - offset + 1;
-            
-            if (isCopyUntilZero) {
-            	offset = 0;
-            }
-            
-           	resultCoordPos = includeCoordsAndRules(offset, length, rules, 
-           			                               offsets, resultRules, 
-           			                               resultOffsets, resultCoords,
-           			                               coords, resultRulesPos, 
-           			                               resultCoordPos, point, 
-           			                               isCurrentArea, true, 0);
-            resultRulesPos += length - offset; 
-            point = nextPoint;
-        } while (point != intersectPoints[0]);
-        
-        resultRules[resultRulesPos++] = PathIterator.SEG_CLOSE;
-        resultOffsets[resultRulesPos - 1] = resultCoordPos;
-		this.coords = resultCoords;
-		this.rules = resultRules;
-		this.offsets = resultOffsets;
-		this.coordsSize = resultCoordPos;
-		this.rulesSize = resultRulesPos;
-	}
-
-    private void addPolygon(Area area) {
-		CrossingHelper crossHelper = new CrossingHelper(new double[][] {coords,
-				                                        area.coords }, 
-				                                        new int[] {coordsSize, 
-				                                        area.coordsSize });
-		IntersectPoint[] intersectPoints = crossHelper.findCrossing();
-
-		if (intersectPoints.length == 0) {
-			if (area.contains(getBounds2D())) {
-				copy(area, this);
-			} else if (!contains(area.getBounds2D())) {
-				coords = adjustSize(coords, coordsSize + area.coordsSize);
-				System.arraycopy(area.coords, 0, coords, coordsSize,
-								 area.coordsSize);
-				coordsSize += area.coordsSize;
-				rules = adjustSize(rules, rulesSize + area.rulesSize);
-				System.arraycopy(area.rules, 0, rules, rulesSize, 
-								 area.rulesSize);
-				rulesSize += area.rulesSize;
-				offsets = adjustSize(offsets, rulesSize + area.rulesSize);
-				System.arraycopy(area.offsets, 0, offsets, rulesSize, 
-								 area.rulesSize);
-			}
-			return;
-		}
-
-        double[] resultCoords = new double[coordsSize + area.coordsSize + 
-                                                       intersectPoints.length];
-        int[] resultRules = new int[rulesSize + area.rulesSize + 
-                                                       intersectPoints.length];
-        int[] resultOffsets = new int[rulesSize + area.rulesSize + 
-                                                       intersectPoints.length];
-        int resultCoordPos = 0;
-        int resultRulesPos = 0;
-        boolean isCurrentArea = true;
-
-        IntersectPoint point = intersectPoints[0];
-        resultRules[resultRulesPos] = PathIterator.SEG_MOVETO;
-        resultOffsets[resultRulesPos++] = resultCoordPos;
-        
-        do {
-        	resultCoords[resultCoordPos++] = point.getX();
-            resultCoords[resultCoordPos++] = point.getY();
-            resultRules[resultRulesPos] = PathIterator.SEG_LINETO;
-            resultOffsets[resultRulesPos++] = resultCoordPos - 2;
-            int curIndex = point.getEndIndex(true);
-            if (curIndex < 0) {
-            	isCurrentArea = !isCurrentArea;
-            } else if (area.containsExact(coords[2 * curIndex], 
-            		                      coords[2 * curIndex + 1]) > 0) { 
-            	isCurrentArea = false;
-            } else {
-            	isCurrentArea = true;
-            }
+    private static class NullIterator implements PathIterator {
 
-            IntersectPoint nextPoint = getNextIntersectPoint(intersectPoints, 
-            		                                         point, 
-            		                                         isCurrentArea);
-            double[] coords = (isCurrentArea) ? this.coords : area.coords;
-            int offset = 2 * point.getEndIndex(isCurrentArea);
- 
-            if (nextPoint.getBegIndex(isCurrentArea) < 
-            		point.getEndIndex(isCurrentArea)) {
-                int coordSize = (isCurrentArea) ? this.coordsSize : 
-                	                              area.coordsSize;
-                int length = coordSize - offset;
-                System.arraycopy(coords, offset, 
-                		         resultCoords, resultCoordPos, length);
-                
-                for (int i = 0; i < length / 2; i++) {
-                	resultRules[resultRulesPos] = PathIterator.SEG_LINETO;
-                	resultOffsets[resultRulesPos++] = resultCoordPos;
-                	resultCoordPos += 2;
-                }
-                
-                offset = 0;
-            }
-            
-            int length = 2 * nextPoint.getBegIndex(isCurrentArea) - offset + 2;
-            System.arraycopy(coords, offset, 
-            		         resultCoords, resultCoordPos, length);
-            
-            for (int i = 0; i < length / 2; i++) {
-            	resultRules[resultRulesPos] = PathIterator.SEG_LINETO;
-            	resultOffsets[resultRulesPos++] = resultCoordPos;
-            	resultCoordPos += 2;
-            }
+        NullIterator() {
+        }
 
-            point = nextPoint;
-        } while (point != intersectPoints[0]);
-        
-        resultRules[resultRulesPos - 1] = PathIterator.SEG_CLOSE;
-        resultOffsets[resultRulesPos - 1] = resultCoordPos;
-		coords = resultCoords;
-		rules = resultRules;
-		offsets = resultOffsets;
-		coordsSize = resultCoordPos;
-		rulesSize = resultRulesPos;
-	}
-    
- 	private void intersectCurvePolygon(Area area) {
-		CurveCrossingHelper crossHelper = new CurveCrossingHelper(
-				new double[][] {coords, area.coords }, 
-				new int[] { coordsSize, area.coordsSize }, 
-				new int[][] { rules, area.rules },
-				new int[] { rulesSize, area.rulesSize }, 
-				new int[][] { offsets, area.offsets });
-		IntersectPoint[] intersectPoints = crossHelper.findCrossing();
-
-		if (intersectPoints.length == 0) {
-			if (contains(area.getBounds2D())) {
-				copy(area, this);
-			} else if (!area.contains(getBounds2D())) {
-				reset();
-			}
-			return;
-		}
-
-        double[] resultCoords = new double[coordsSize + area.coordsSize + 
-                                                       intersectPoints.length];
-        int[] resultRules = new int[rulesSize + area.rulesSize + 
-                                                       intersectPoints.length];
-        int[] resultOffsets = new int[rulesSize + area.rulesSize + 
-                                                       intersectPoints.length];
-        int resultCoordPos = 0;
-        int resultRulesPos = 0;
-        boolean isCurrentArea = true;
-
-        IntersectPoint point = intersectPoints[0];
-        IntersectPoint nextPoint = intersectPoints[0];
-        resultRules[resultRulesPos] = PathIterator.SEG_MOVETO;
-        resultOffsets[resultRulesPos++] = resultCoordPos;
-        
-        do {
-        	resultCoords[resultCoordPos++] = point.getX();
-            resultCoords[resultCoordPos++] = point.getY();
- 
-            int curIndex = point.getEndIndex(true);
-            if ((curIndex < 0) || (area.containsExact(
-            		coords[2 * curIndex], coords[2 * curIndex + 1]) == 0)) {
-            	isCurrentArea = !isCurrentArea;
-            } else if (area.containsExact(coords[2 * curIndex], 
-            		                      coords[2 * curIndex + 1]) > 0) { 
-            	isCurrentArea = true;
-            } else {
-            	isCurrentArea = false;
-            }
-            
-            nextPoint = getNextIntersectPoint(intersectPoints, point, isCurrentArea);
-            double[] coords = (isCurrentArea) ? this.coords : area.coords;
-            int[] offsets = (isCurrentArea) ? this.offsets : area.offsets;
-            int[] rules = (isCurrentArea) ? this.rules : area.rules;
-            int offset = point.getRuleIndex(isCurrentArea);
-            boolean isCopyUntilZero = false;
-            
-            if (point.getRuleIndex(isCurrentArea) > 
-                    nextPoint.getRuleIndex(isCurrentArea)) {
-            	int rulesSize = (isCurrentArea) ? this.rulesSize : 
-            		                              area.rulesSize;
-            	resultCoordPos = includeCoordsAndRules(offset + 1, rulesSize, 
-            			                               rules, offsets, 
-            			                               resultRules, 
-            			                               resultOffsets, 
-            			                               resultCoords, coords, 
-            			                               resultRulesPos, 
-            			                               resultCoordPos, point, 
-            			                               isCurrentArea, false, 
-            			                               1);
-            	resultRulesPos += rulesSize - offset - 1; 
-            	offset = 1;
-            	isCopyUntilZero = true;
-            }
-            
-            int length = nextPoint.getRuleIndex(isCurrentArea) - offset + 1;
-            
-            if (isCopyUntilZero) {
-            	offset = 0;
-            	isCopyUntilZero = false;
-            }
-            if ((length == offset) && 
-            	(nextPoint.getRule(isCurrentArea) != PathIterator.SEG_LINETO) && 
-                (nextPoint.getRule(isCurrentArea) != PathIterator.SEG_CLOSE) &&
-            	(point.getRule(isCurrentArea) != PathIterator.SEG_LINETO) && 
-            	(point.getRule(isCurrentArea) != PathIterator.SEG_CLOSE)) {
-            	
-            	isCopyUntilZero = true;
-            	length++;
-            }
-            
-           	resultCoordPos = includeCoordsAndRules(offset, length, rules, 
-           			                               offsets, resultRules, 
-           			                               resultOffsets, resultCoords, 
-           			                               coords, resultRulesPos, 
-           			                               resultCoordPos, nextPoint, 
-           			                               isCurrentArea, true, 1);
-            resultRulesPos = ((length <= offset) || (isCopyUntilZero)) ? 
-            		resultRulesPos + 1 : resultRulesPos + length; 
-
-            point = nextPoint;
-        } while (point != intersectPoints[0]);
-        
-        if (resultRules[resultRulesPos - 1] == PathIterator.SEG_LINETO) {
-        	resultRules[resultRulesPos - 1] = PathIterator.SEG_CLOSE;
-        } else {
-        	resultCoords[resultCoordPos++] = nextPoint.getX();
-            resultCoords[resultCoordPos++] = nextPoint.getY();
-        	resultRules[resultRulesPos++] = PathIterator.SEG_CLOSE;
+        public int getWindingRule() {
+            return WIND_NON_ZERO;
         }
-        
-        resultOffsets[resultRulesPos - 1] = resultCoordPos;
-		coords = resultCoords;
-		rules = resultRules;
-		offsets = resultOffsets;
-		coordsSize = resultCoordPos;
-		rulesSize = resultRulesPos;
-	}
-
-	private void intersectPolygon(Area area) {
-		CrossingHelper crossHelper = new CrossingHelper(new double[][] {coords, 
-				                                        area.coords }, 
-				                                        new int[] { coordsSize, 
-				                                        area.coordsSize });
-		IntersectPoint[] intersectPoints = crossHelper.findCrossing();
-
-		if (intersectPoints.length == 0) {
-			if (contains(area.getBounds2D())) {
-				copy(area, this);
-			} else if (!area.contains(getBounds2D())) {
-				reset();
-			}
-			return;
-		}
-
-        double[] resultCoords = new double[coordsSize + area.coordsSize + 
-                                                        intersectPoints.length];
-        int[] resultRules = new int[rulesSize + area.rulesSize + 
-                                                        intersectPoints.length];
-        int[] resultOffsets = new int[rulesSize + area.rulesSize + 
-                                                        intersectPoints.length];
-        int resultCoordPos = 0;
-        int resultRulesPos = 0;
-        boolean isCurrentArea = true;
-
-        IntersectPoint point = intersectPoints[0];
-        resultRules[resultRulesPos] = PathIterator.SEG_MOVETO;
-        resultOffsets[resultRulesPos++] = resultCoordPos; 
-        
-        do {
-        	resultCoords[resultCoordPos++] = point.getX();
-            resultCoords[resultCoordPos++] = point.getY();
-            resultRules[resultRulesPos] = PathIterator.SEG_LINETO;
-            resultOffsets[resultRulesPos++] = resultCoordPos - 2;
-            int curIndex = point.getEndIndex(true);
-
-            if ((curIndex < 0) || 
-            	(area.containsExact(coords[2 * curIndex], 
-            		                coords[2 * curIndex + 1]) == 0)) {
-            	isCurrentArea = !isCurrentArea;
-            } else if (area.containsExact(coords[2 * curIndex], 
-            		                      coords[2 * curIndex + 1]) > 0) { 
-            	isCurrentArea = true;
-            } else {
-            	isCurrentArea = false;
-            }
 
-            IntersectPoint nextPoint = getNextIntersectPoint(intersectPoints, 
-            		                                         point, 
-            		                                         isCurrentArea);
-            double[] coords = (isCurrentArea) ? this.coords : area.coords;
-            int offset = 2 * point.getEndIndex(isCurrentArea);
-            if ((offset >= 0) && 
-            		(nextPoint.getBegIndex(isCurrentArea) < 
-            		    point.getEndIndex(isCurrentArea))) {
-                int coordSize = (isCurrentArea) ? this.coordsSize : 
-                	                              area.coordsSize;
-                int length = coordSize - offset;
-                System.arraycopy(coords, offset, 
-                		         resultCoords, resultCoordPos, length);
-                
-                for (int i = 0; i < length / 2; i++) {
-                	resultRules[resultRulesPos] = PathIterator.SEG_LINETO;
-                	resultOffsets[resultRulesPos++] = resultCoordPos;
-                	resultCoordPos += 2;
-                }
-                
-                offset = 0;
-            }
-            
-            if (offset >= 0) {
-            	int length = 2 * nextPoint.getBegIndex(isCurrentArea) - 
-            	                 offset + 2;
-            	System.arraycopy(coords, offset, 
-            			         resultCoords, resultCoordPos, length);
-            	
-            	for (int i = 0; i < length / 2; i++) {
-            		resultRules[resultRulesPos] = PathIterator.SEG_LINETO;
-            		resultOffsets[resultRulesPos++] = resultCoordPos;
-            		resultCoordPos += 2;
-            	}
-            }
+        public boolean isDone() {
+            return true;
+        }
 
-            point = nextPoint;
-        } while (point != intersectPoints[0]);
-        
-        resultRules[resultRulesPos - 1] = PathIterator.SEG_CLOSE;
-        resultOffsets[resultRulesPos - 1] = resultCoordPos;
-		coords = resultCoords;
-		rules = resultRules;
-		offsets = resultOffsets;
-		coordsSize = resultCoordPos;
-		rulesSize = resultRulesPos;
-	}
-
-	private void subtractCurvePolygon(Area area) {
-		CurveCrossingHelper crossHelper = new CurveCrossingHelper(
-				new double[][] { coords, area.coords }, 
-				new int[] { coordsSize, area.coordsSize }, 
-				new int[][] { rules, area.rules },
-				new int[] { rulesSize, area.rulesSize }, 
-				new int[][] { offsets, area.offsets });
-		IntersectPoint[] intersectPoints = crossHelper.findCrossing();
-
-		if (intersectPoints.length == 0 && contains(area.getBounds2D())) {
-			copy(area, this);
-			return;
-		}
-
-        double[] resultCoords = new double[coordsSize + area.coordsSize + 
-                                                       intersectPoints.length];
-        int[] resultRules = new int[rulesSize + area.rulesSize + 
-                                                       intersectPoints.length];
-        int[] resultOffsets = new int[rulesSize + area.rulesSize + 
-                                                       intersectPoints.length];
-        int resultCoordPos = 0;
-        int resultRulesPos = 0;
-        boolean isCurrentArea = true;
-
-        IntersectPoint point = intersectPoints[0];
-        resultRules[resultRulesPos] = PathIterator.SEG_MOVETO;
-        resultOffsets[resultRulesPos++] = resultCoordPos;
-        
-        do {
-        	resultCoords[resultCoordPos++] = point.getX();
-            resultCoords[resultCoordPos++] = point.getY();
-            int curIndex = offsets[point.getRuleIndex(true)] % coordsSize;
-            
-            if (area.containsExact(coords[curIndex], 
-            		               coords[curIndex + 1]) == 0) {
-            	isCurrentArea = !isCurrentArea;
-            } else if (area.containsExact(coords[curIndex],
-            		                      coords[curIndex + 1]) > 0) { 
-            	isCurrentArea = false;
-            } else {
-            	isCurrentArea = true;
-            }
-  
-            IntersectPoint nextPoint = (isCurrentArea) ? 
-            		getNextIntersectPoint(intersectPoints, point, 
-            				              isCurrentArea):
-            		getPrevIntersectPoint(intersectPoints, point, 
-            				              isCurrentArea);	
-            double[] coords = (isCurrentArea) ? this.coords : area.coords;
-            int[] offsets = (isCurrentArea) ? this.offsets : area.offsets;
-            int[] rules = (isCurrentArea) ? this.rules : area.rules;
-            int offset = (isCurrentArea) ? point.getRuleIndex(isCurrentArea) :
-            	                         nextPoint.getRuleIndex(isCurrentArea);
-            boolean isCopyUntilZero = false;
-         
-            if (((isCurrentArea) && 
-            	 (point.getRuleIndex(isCurrentArea) > 
-            	  nextPoint.getRuleIndex(isCurrentArea))) ||
-            	((!isCurrentArea) && 
-            	 (nextPoint.getRuleIndex(isCurrentArea) > 
-            	  nextPoint.getRuleIndex(isCurrentArea)))) {
-            	
-            	int rulesSize = (isCurrentArea) ? this.rulesSize : 
-            		                              area.rulesSize;
-            	resultCoordPos = includeCoordsAndRules(offset + 1, rulesSize, 
-            			                               rules, offsets, 
-            			                               resultRules, 
-            			                               resultOffsets, 
-            			                               resultCoords, coords, 
-            			                               resultRulesPos, 
-            			                               resultCoordPos, point, 
-            			                               isCurrentArea, false, 
-            			                               2);
-            	resultRulesPos += rulesSize - offset - 1; 
-            	offset = 1;
-            	isCopyUntilZero = true;
-            }
-            
-            int length = nextPoint.getRuleIndex(isCurrentArea) - offset + 1;
-            
-            if (isCopyUntilZero) {
-            	offset = 0;
-            	isCopyUntilZero = false;
-            }
-            
-           	resultCoordPos = includeCoordsAndRules(offset, length, rules, 
-           			                               offsets, resultRules, 
-           			                               resultOffsets, resultCoords, 
-           			                               coords, resultRulesPos, 
-           			                               resultCoordPos, point, 
-           			                               isCurrentArea, true, 2);
-           	
-           	if ((length == offset) && 
-           		((rules[offset] == PathIterator.SEG_QUADTO) || 
-           		 (rules[offset] == PathIterator.SEG_CUBICTO))) {
-           		
-           		resultRulesPos++;
-    		} else {
-           	    resultRulesPos = (length < offset || isCopyUntilZero) ? 
-           	    		resultRulesPos + 1 : resultRulesPos + length - offset;
-    		}
-
-            point = nextPoint;
-        } while (point != intersectPoints[0]);
-        
-        resultRules[resultRulesPos++] = PathIterator.SEG_CLOSE;
-        resultOffsets[resultRulesPos - 1] = resultCoordPos;
-		coords = resultCoords;
-		rules = resultRules;
-		offsets = resultOffsets;
-		coordsSize = resultCoordPos;
-		rulesSize = resultRulesPos;
-	}
-
-	private void subtractPolygon(Area area) {
-		CrossingHelper crossHelper = new CrossingHelper(new double[][] {coords, 
-				                                        area.coords }, 
-				                                        new int[] { coordsSize, 
-				                                        area.coordsSize });
-		IntersectPoint[] intersectPoints = crossHelper.findCrossing();
-
-		if ((intersectPoints.length == 0) && (contains(area.getBounds2D()))) {
-			copy(area, this);
-			return;
-		} 
-
-        double[] resultCoords = new double[coordsSize + area.coordsSize + 
-                                                       intersectPoints.length];
-        int[] resultRules = new int[rulesSize + area.rulesSize + 
-                                                       intersectPoints.length];
-        int[] resultOffsets = new int[rulesSize + area.rulesSize + 
-                                                       intersectPoints.length];
-        int resultCoordPos = 0;
-        int resultRulesPos = 0;
-        boolean isCurrentArea = true;
-        int count = 0;
+        public void next() {
+            // nothing
+        }
 
-        IntersectPoint point = intersectPoints[0];
-        resultRules[resultRulesPos] = PathIterator.SEG_MOVETO;
-        resultOffsets[resultRulesPos++] = resultCoordPos;
-        
-        do {
-        	resultCoords[resultCoordPos++] = point.getX();
-            resultCoords[resultCoordPos++] = point.getY();
-            resultRules[resultRulesPos] = PathIterator.SEG_LINETO;
-            resultOffsets[resultRulesPos++] = resultCoordPos - 2;
-            int curIndex = point.getEndIndex(true);
-            
-            if ((curIndex < 0) || 
-            	(area.containsExact(coords[2 * curIndex], 
-            			            coords[2 * curIndex + 1]) > 0)) {
-            	isCurrentArea = !isCurrentArea;
-            } else if (area.containsExact(coords[2 * curIndex], 
-            		                      coords[2 * curIndex + 1]) > 0) { 
-            	isCurrentArea = false;
-            } else {
-            	isCurrentArea = true;
-            }
+        public int currentSegment(double[] coords) {
+            // awt.4B=Iterator out of bounds
+            throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
+        }
 
-            IntersectPoint nextPoint = (isCurrentArea) ? 
-            		getNextIntersectPoint(intersectPoints, point, isCurrentArea):
-            		getPrevIntersectPoint(intersectPoints, point, isCurrentArea);	
-            double[] coords = (isCurrentArea) ? this.coords : area.coords;
-            
-            int offset = (isCurrentArea) ? 2 * point.getEndIndex(isCurrentArea): 
-            							 2 * nextPoint.getEndIndex(isCurrentArea);
-            
-            if ((offset > 0) && 
-            	(((isCurrentArea) && 
-            	  (nextPoint.getBegIndex(isCurrentArea) < 
-            			  point.getEndIndex(isCurrentArea))) ||
-            	  ((!isCurrentArea) && 
-            	  (nextPoint.getEndIndex(isCurrentArea) < 
-            			  nextPoint.getBegIndex(isCurrentArea))))) {
-            	
-                int coordSize = (isCurrentArea) ? this.coordsSize : 
-                	                              area.coordsSize;
-                int length = coordSize - offset; 
-                
-                if (isCurrentArea) {
-                	System.arraycopy(coords, offset, 
-                			         resultCoords, resultCoordPos, length);
-                } else {
-                	double[] temp = new double[length];
-                	System.arraycopy(coords, offset, temp, 0, length);
-                	reverseCopy(temp);
-                	System.arraycopy(temp, 0, 
-                			         resultCoords, resultCoordPos, length);
-                }
-                
-                for (int i = 0; i < length / 2; i++) {
-                	resultRules[resultRulesPos] = PathIterator.SEG_LINETO;
-                	resultOffsets[resultRulesPos++] = resultCoordPos;
-                	resultCoordPos += 2;
-                }
-                
-                offset = 0;
-            }
-            
-            if (offset >= 0) {
-            	int length = (isCurrentArea) ? 
-            			         2 * nextPoint.getBegIndex(isCurrentArea) - offset + 2:
-            	                 2 * point.getBegIndex(isCurrentArea) - offset + 2;
-            			         
-            	if (isCurrentArea) {
-            		System.arraycopy(coords, offset, 
-            				         resultCoords, resultCoordPos, length);
-            	} else {
-            		double[] temp = new double[length];
-            		System.arraycopy(coords, offset, temp, 0, length);
-            		reverseCopy(temp);
-            		System.arraycopy(temp, 0, 
-            				         resultCoords, resultCoordPos, length);
-            	}
-            	
-            	for (int i = 0; i < length / 2; i++) {
-            		resultRules[resultRulesPos] = PathIterator.SEG_LINETO;
-            		resultOffsets[resultRulesPos++] = resultCoordPos;
-            		resultCoordPos += 2;
-            	}
-            }
+        public int currentSegment(float[] coords) {
+            // awt.4B=Iterator out of bounds
+            throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
+        }
 
-            point = nextPoint;
-            count++;
-        } while (point != intersectPoints[0] && count <= intersectPoints.length);
-        
-        if (count > intersectPoints.length) {
-        	reset();
-        } else {
-            resultRules[resultRulesPos - 1] = PathIterator.SEG_CLOSE;
-            resultOffsets[resultRulesPos - 1] = resultCoordPos;
-		    coords = resultCoords;
-		    rules = resultRules;
-		    offsets = resultOffsets;
-		    coordsSize = resultCoordPos;
-		    rulesSize = resultRulesPos;
+    }
+
+    public Area() {
+    }
+
+    public Area(Shape s) {
+        if (s == null) {
+            throw new NullPointerException();
         }
-	}
-	
-	   private IntersectPoint getNextIntersectPoint(IntersectPoint[] iPoints,
-			                                        IntersectPoint isectPoint, 
-			                                        boolean isCurrentArea) {
-		   
-		int endIndex = isectPoint.getEndIndex(isCurrentArea);
-		if (endIndex < 0) {
-			return iPoints[Math.abs(endIndex) - 1];
-		}
-
-		IntersectPoint firstIsectPoint = null;
-		IntersectPoint nextIsectPoint = null;
-		for (IntersectPoint point : iPoints) {
-			int begIndex = point.getBegIndex(isCurrentArea);
-			
-			if (begIndex >= 0) {
-				if (firstIsectPoint == null) {
-					firstIsectPoint = point;
-				} else if (begIndex < firstIsectPoint
-						.getBegIndex(isCurrentArea)) {
-					firstIsectPoint = point;
-				}
-			}
-
-			if (endIndex <= begIndex) {
-				if (nextIsectPoint == null) {
-					nextIsectPoint = point;
-				} else if (begIndex < 
-						       nextIsectPoint.getBegIndex(isCurrentArea)) {
-					nextIsectPoint = point;
-				}
-			}
-		}
-
-		return (nextIsectPoint != null) ? nextIsectPoint : firstIsectPoint;
-	}
-
-	private IntersectPoint getPrevIntersectPoint(IntersectPoint[] iPoints,
-			                                     IntersectPoint isectPoint, 
-			                                     boolean isCurrentArea) {
-
-		int begIndex = isectPoint.getBegIndex(isCurrentArea);
-		
-		if (begIndex < 0) {
-			return iPoints[Math.abs(begIndex) - 1];
-		}
-
-		IntersectPoint firstIsectPoint = null;
-		IntersectPoint predIsectPoint = null;
-		for (IntersectPoint point : iPoints) {
-			int endIndex = point.getEndIndex(isCurrentArea);
-			
-			if (endIndex >= 0) {
-				if (firstIsectPoint == null) {
-					firstIsectPoint = point;
-				} else if (endIndex < firstIsectPoint
-						.getEndIndex(isCurrentArea)) {
-					firstIsectPoint = point;
-				}
-			}
-
-			if (endIndex <= begIndex) {
-				if (predIsectPoint == null) {
-					predIsectPoint = point;
-				} else if (endIndex > 
-				               predIsectPoint.getEndIndex(isCurrentArea)) {
-					predIsectPoint = point;
-				}
-			}
-		}
-
-		return (predIsectPoint != null) ? predIsectPoint : firstIsectPoint;
-	}
-
-	
-	private int includeCoordsAndRules(int offset, int length, int[] rules,
-			                          int[] offsets, int[] resultRules, 
-			                          int[] resultOffsets, double[] resultCoords, 
-			                          double[] coords, int resultRulesPos,
-			                          int resultCoordPos, IntersectPoint point, 
-			                          boolean isCurrentArea, boolean way, 
-			                          int operation) {
-
-		double[] temp = new double[8 * length];
-		int coordsCount = 0;
-		boolean isMoveIndex = true;
-		boolean isMoveLength = true;
-		boolean additional = false;
-
-		if (length <= offset) {
-			for (int i = resultRulesPos; i < resultRulesPos + 1; i++) {
-				resultRules[i] = PathIterator.SEG_LINETO;
-			}
-		} else {
-			int j = resultRulesPos;
-			for (int i = offset; i < length; i++) {
-				resultRules[j++] = PathIterator.SEG_LINETO;
-			}
-		}
-
-		if ((length == offset) &&
-			((rules[offset] == PathIterator.SEG_QUADTO) || 
-			 (rules[offset] == PathIterator.SEG_CUBICTO))) {
-			length++;
-			additional = true;
-		}
-		for (int i = offset; i < length; i++) {
-			int index = offsets[i];
-			
-			if (!isMoveIndex) {
-				index -= 2;
-			}
-			
-			if (!isMoveLength) {
-				length++;
-				isMoveLength = true;
-			}
-			
-			switch (rules[i]) {
-			    case PathIterator.SEG_MOVETO:
-			    	isMoveIndex = false;
-			    	isMoveLength = false;
-				    break;
-			    case PathIterator.SEG_LINETO:
-			    case PathIterator.SEG_CLOSE:
-				    resultRules[resultRulesPos] = PathIterator.SEG_LINETO;
-				    resultOffsets[resultRulesPos++] = resultCoordPos + 2;
-				    boolean isLeft = CrossingHelper.compare(coords[index],
-						    coords[index + 1], point.getX(), point.getY()) > 0;
-						    
-				    if (way || !isLeft) {
-					    temp[coordsCount++] = coords[index];
-					    temp[coordsCount++] = coords[index + 1];
-				    }
-				    break;
-			    case PathIterator.SEG_QUADTO:
-				    resultRules[resultRulesPos] = PathIterator.SEG_QUADTO;
-				    resultOffsets[resultRulesPos++] = resultCoordPos + 4;
-				    double[] coefs = new double[] { coords[index - 2],
-						    coords[index - 1], coords[index], coords[index + 1],
-						    coords[index + 2], coords[index + 3] };
-				    isLeft = CrossingHelper.compare(coords[index - 2],
-						    coords[index - 1], point.getX(), point.getY()) > 0;
-						    
-				    if ((!additional) && (operation == 0 || operation == 2)) {
-					    isLeft = !isLeft;
-					    way = false;
-				    }
-				    GeometryUtil
-						.subQuad(coefs, point.getParam(isCurrentArea), isLeft);
-				    
-				    if (way || isLeft) {
-					    temp[coordsCount++] = coefs[2];
-					    temp[coordsCount++] = coefs[3];
-				    } else {
-					    System.arraycopy(coefs, 2, temp, coordsCount, 4);
-					    coordsCount += 4;
-				    }
-				    break;
-			    case PathIterator.SEG_CUBICTO:
-				    resultRules[resultRulesPos] = PathIterator.SEG_CUBICTO;
-				    resultOffsets[resultRulesPos++] = resultCoordPos + 6;
-				    coefs = new double[] {coords[index - 2], coords[index - 1],
-						                  coords[index], coords[index + 1], 
-						                  coords[index + 2], coords[index + 3], 
-						                  coords[index + 4], coords[index + 5] };
-				    isLeft = CrossingHelper.compare(coords[index - 2],
-						    coords[index - 1], point.getX(), point.getY()) > 0;
-				    GeometryUtil.subCubic(coefs, point.getParam(isCurrentArea),
-						                  !isLeft);
-				    
-				    if (isLeft) {
-					    System.arraycopy(coefs, 2, temp, coordsCount, 6);
-					    coordsCount += 6;
-				    } else {
-					    System.arraycopy(coefs, 2, temp, coordsCount, 4);
-					    coordsCount += 4;
-				    }
-				    break;
-		    }
-		}
-
-        if (operation == 2 && !isCurrentArea && coordsCount > 2) {
-			reverseCopy(temp);
-			System.arraycopy(temp, 0, resultCoords, resultCoordPos, coordsCount);
-		} else {
-			System.arraycopy(temp, 0, resultCoords, resultCoordPos, coordsCount);
-		}
-        
-		return (resultCoordPos + coordsCount);
-	}
-	
-	// the method check up the array size and necessarily increases it. 
-	private static double[] adjustSize(double[] array, int newSize) {
-		if (newSize <= array.length) {
-			return array;
-		}
-		double[] newArray = new double[2 * newSize];
-		System.arraycopy(array, 0, newArray, 0, array.length);
-		return newArray;
-	}
-
-	private static int[] adjustSize(int[] array, int newSize) {
-		if (newSize <= array.length) {
-			return array;
-		}
-		int[] newArray = new int[2 * newSize];
-		System.arraycopy(array, 0, newArray, 0, array.length);
-		return newArray;
-	}
-
-	private void copy(Area src, Area dst) {
-		dst.coordsSize = src.coordsSize;
-		dst.coords = src.coords.clone();
-		dst.rulesSize = src.rulesSize;
-		dst.rules = src.rules.clone();
-		dst.moveToCount = src.moveToCount;
-		dst.offsets = src.offsets.clone();
-	}
-
-    private int containsExact(double x, double y) {
-        PathIterator pi = getPathIterator(null);
-        int crossCount = Crossing.crossPath(pi, x, y);
-        
-        if (Crossing.isInsideEvenOdd(crossCount)) {
-            return 1;
+        this.s = s;
+    }
+
+    public boolean contains(double x, double y) {
+        return s == null ? false : s.contains(x, y);
+    }
+
+    public boolean contains(double x, double y, double width, double height) {
+        return s == null ? false : s.contains(x, y, width, height);
+    }
+
+    public boolean contains(Point2D p) {
+        if (p == null) {
+            throw new NullPointerException();
         }
+        return s == null ? false : s.contains(p);
+    }
 
-        double[] segmentCoords = new double[6];
-        double[] resultPoints = new double[6];
-        int rule;
-        double curX = -1;
-        double curY = -1;
-        double moveX = -1;
-        double moveY = -1;
-        
-        for (pi = getPathIterator(null); !pi.isDone(); pi.next()) {
-            rule = pi.currentSegment(segmentCoords);
-            switch (rule) {
-                case PathIterator.SEG_MOVETO:
-                    moveX = curX = segmentCoords[0];
-                    moveY = curY = segmentCoords[1];
-                    break;
-                case PathIterator.SEG_LINETO:
-                    if (GeometryUtil.intersectLines(curX, curY, 
-                    		segmentCoords[0], segmentCoords[1], x, y, x, y, 
-                    		resultPoints) != 0) {
-                        return 0;
-                    }
-                    curX = segmentCoords[0];
-                    curY = segmentCoords[1];
-                    break;
-                case PathIterator.SEG_QUADTO:
-                    if (GeometryUtil.intersectLineAndQuad(x, y, x, y, 
-                    		curX, curY, segmentCoords[0], segmentCoords[1], 
-                    		segmentCoords[2], segmentCoords[3], 
-                    		resultPoints) > 0) {
-                        return 0;
-                    }
-                    curX = segmentCoords[2];
-                    curY = segmentCoords[3];
-                    break;
-                case PathIterator.SEG_CUBICTO:
-                    if (GeometryUtil.intersectLineAndCubic(x, y, x, y, 
-                    		curX, curY, segmentCoords[0], segmentCoords[1], 
-                    		segmentCoords[2], segmentCoords[3], segmentCoords[4], 
-                    		segmentCoords[5], resultPoints) > 0) {
-                        return 0;
-                    }
-                    curX = segmentCoords[4];
-                    curY = segmentCoords[5];
-                    break;
-                case PathIterator.SEG_CLOSE:
-                    if (GeometryUtil.intersectLines(curX, curY, moveX, moveY,
-                    		x, y, x, y, resultPoints) != 0) {
-                        return 0;
-                    }
-                    curX = moveX;
-                    curY = moveY;
-                    break;
-            }
+    public boolean contains(Rectangle2D r) {
+        if (r == null) {
+            throw new NullPointerException();
         }
-        return -1;
+        return s == null ? false : s.contains(r);
     }
 
-    private void reverseCopy(double[] coords) {
-    	double[] temp = new double[coords.length];
-    	System.arraycopy(coords, 0, temp, 0, coords.length);
-    	
-    	for (int i = 0; i < coords.length;) {
-    		coords[i] = temp[coords.length - i - 2];
-    		coords[i + 1] = temp[coords.length - i - 1]; 
-    		i = i + 2;
-    	}
+    public boolean equals(Area obj) throws org.apache.harmony.luni.util.NotImplementedException {
+        throw new RuntimeException("Not implemented"); //$NON-NLS-1$
+    }
+
+    public boolean intersects(double x, double y, double width, double height) {
+        return s == null ? false : s.intersects(x, y, width, height);
+    }
+
+    public boolean intersects(Rectangle2D r) {
+        if (r == null) {
+            throw new NullPointerException();
+        }
+        return s == null ? false : s.intersects(r);
+    }
+
+    public Rectangle getBounds() {
+        return s == null ? new Rectangle() : s.getBounds();
+    }
+
+    public Rectangle2D getBounds2D() {
+        return s == null ? new Rectangle2D.Double(): s.getBounds2D();
+    }
+
+    public PathIterator getPathIterator(AffineTransform t) {
+        return s == null ? new NullIterator() : s.getPathIterator(t);
+    }
+
+    public PathIterator getPathIterator(AffineTransform t, double flatness) {
+        return s == null ? new NullIterator() : s.getPathIterator(t, flatness);
+    }
+
+    public void add(Area area) throws org.apache.harmony.luni.util.NotImplementedException {
+        throw new RuntimeException("Not implemented"); //$NON-NLS-1$
+    }
+
+    public void exclusiveOr(Area area) throws org.apache.harmony.luni.util.NotImplementedException {
+        throw new RuntimeException("Not implemented"); //$NON-NLS-1$
+    }
+
+    /**
+     * Extract Rectangle2D from the source shape
+     * @return a Rectangle2D object if the source shape is rectangle, or null if shape is empty or not rectangle. 
+     */
+    Rectangle2D extractRectangle() {
+        if (s == null) {
+            return null;
+        }
+        float[] points = new float[12];
+        int count = 0;
+        PathIterator p = s.getPathIterator(null);
+        float[] coords = new float[6];
+        while(!p.isDone()) {
+            int type = p.currentSegment(coords);
+            if (count > 12 || type == PathIterator.SEG_QUADTO || type == PathIterator.SEG_CUBICTO) {
+                return null;
+            }
+            points[count++] = coords[0];
+            points[count++] = coords[1];
+            p.next();
+        }
+        if (points[0] == points[6] && points[6] == points[8] && points[2] == points[4] &&
+            points[1] == points[3] && points[3] == points[9] && points[5] == points[7])
+        {
+            return new Rectangle2D.Float(points[0], points[1], points[2] - points[0], points[7] - points[1]);
+        }
+        return null;
     }
     
-    // the internal class implements PathIterator
-	private class AreaPathIterator implements PathIterator {
+    public void intersect(Area area) {
+        Rectangle2D src1 = extractRectangle();
+        Rectangle2D src2 = area.extractRectangle();
+        if (src1 != null && src2 != null) {
+            Rectangle2D.intersect(src1, src2, (Rectangle2D)s);
+        }
+    }
+
+    public void subtract(Area area) throws org.apache.harmony.luni.util.NotImplementedException {
+        throw new RuntimeException("Not implemented"); //$NON-NLS-1$
+    }
+
+    public boolean isEmpty() throws org.apache.harmony.luni.util.NotImplementedException {
+        throw new RuntimeException("Not implemented"); //$NON-NLS-1$
+    }
+
+    public boolean isPolygonal() throws org.apache.harmony.luni.util.NotImplementedException {
+        throw new RuntimeException("Not implemented"); //$NON-NLS-1$
+    }
+
+    public boolean isRectangular() throws org.apache.harmony.luni.util.NotImplementedException {
+        throw new RuntimeException("Not implemented"); //$NON-NLS-1$
+    }
+
+    public boolean isSingular() throws org.apache.harmony.luni.util.NotImplementedException {
+        throw new RuntimeException("Not implemented"); //$NON-NLS-1$
+    }
+
+    public void reset() throws org.apache.harmony.luni.util.NotImplementedException {
+        throw new RuntimeException("Not implemented"); //$NON-NLS-1$
+    }
+
+    public void transform(AffineTransform t) {
+        s = t.createTransformedShape(s);
+    }
+
+    public Area createTransformedArea(AffineTransform t) {
+        return s == null ? new Area() : new Area(t.createTransformedShape(s));
+    }
+
+    @Override
+    public Object clone() {
+        return new Area(this);
+    }
 
-		AffineTransform t;
-		Area area;
-		int curRuleIndex = 0;
-		int curCoordIndex = 0;
-
-		AreaPathIterator(Area area) {
-			this(area, null);
-		}
-
-		AreaPathIterator(Area area, AffineTransform t) {
-			this.area = area;
-			this.t = t;
-		}
-
-		public int getWindingRule() {
-			return WIND_EVEN_ODD;
-		}
-
-		public boolean isDone() {
-			return curRuleIndex >= rulesSize;
-		}
-
-		public void next() {
-			switch (rules[curRuleIndex]) {
-			case PathIterator.SEG_MOVETO:
-			case PathIterator.SEG_LINETO:
-				curCoordIndex += 2;
-				break;
-			case PathIterator.SEG_QUADTO:
-				curCoordIndex += 4;
-				break;
-			case PathIterator.SEG_CUBICTO:
-				curCoordIndex += 6;
-				break;
-			}
-			curRuleIndex++;
-		}
-
-		public int currentSegment(double[] c) {
-			if (isDone()) {
-				throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
-			}
-			switch (rules[curRuleIndex]) {
-				case PathIterator.SEG_CUBICTO:
-					c[4] = coords[curCoordIndex + 4];
-					c[5] = coords[curCoordIndex + 5];
-				case PathIterator.SEG_QUADTO:
-					c[2] = coords[curCoordIndex + 2];
-					c[3] = coords[curCoordIndex + 3];
-				case PathIterator.SEG_MOVETO:
-				case PathIterator.SEG_LINETO:
-					c[0] = coords[curCoordIndex];
-					c[1] = coords[curCoordIndex + 1];
-			}
-			return rules[curRuleIndex];
-		}
-
-		public int currentSegment(float[] c) {
-			double[] doubleCoords = new double[6];
-			int rule = currentSegment(doubleCoords);
-			
-			for (int i = 0; i < 6; i++) {
-				c[i] = (float) doubleCoords[i];
-			}
-			return rule;
-		}
-	}
-}
\ No newline at end of file
+}

Modified: harmony/enhanced/classlib/trunk/modules/awt/src/test/api/java/common/java/awt/geom/AreaTest.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/awt/src/test/api/java/common/java/awt/geom/AreaTest.java?view=diff&rev=547012&r1=547011&r2=547012
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/awt/src/test/api/java/common/java/awt/geom/AreaTest.java (original)
+++ harmony/enhanced/classlib/trunk/modules/awt/src/test/api/java/common/java/awt/geom/AreaTest.java Wed Jun 13 13:02:41 2007
@@ -45,126 +45,54 @@
     }
     
     public void testContainsPoint() {
+        // Regression test HARMONY-1404
         try {
-             Area area = new Area(new Ellipse2D.Double(200, 300, 400, 200));
-             assertTrue(area.contains(250, 350));
-             assertFalse(area.contains(200, 300));
-             assertFalse(area.contains(50, 50));
-             
-             assertTrue(area.contains(new Point2D.Double(500, 400)));
-             assertFalse(area.contains(new Point2D.Double(700, 400)));
-             
-             // Regression test HARMONY-1404
-             Area emptyArea = new Area();
-             emptyArea.contains((Point2D)null);
-             fail("Expected NPE");
-         } catch (NullPointerException e) {
-             // expected
-         }
-     }
-
-     public void testContainsRect() {
-         // Regression test HARMONY-1476
-         GeneralPath path = new GeneralPath();
-         path.moveTo(100, 500);
-         path.lineTo(400, 100);
-         path.lineTo(700, 500);
-         path.closePath();
-         
-         Area area = new Area(path);
-         assertTrue(area.contains(new Rectangle2D.Double(300, 400, 100, 50)));
-         assertFalse(area.contains(new Rectangle2D.Double(50, 400, 700, 50)));
-         
-         GeneralPath path1 = new GeneralPath();
-         path1.moveTo(400, 500);
-         path1.quadTo(200, 200, 400, 100);
-         path1.quadTo(600, 200, 400, 500);
-         path1.closePath();
-         
-         Area area1 = new Area(path1);
-         assertTrue(area1.contains(350, 200, 50, 50));
-         assertFalse(area1.contains(100, 50, 600, 500));
-         
-     	// Regression test HARMONY-1404
-         try {
-             Area emptyArea = new Area();
-             emptyArea.contains((Rectangle2D)null);
-             fail("Expected NPE");
-         } catch (NullPointerException e) {
-             // expected
-         }
-     }
+            Area a = new Area();
+            a.contains((Point2D)null);
+            fail("Expected NPE");
+        } catch (NullPointerException e) {
+            // expected
+        }
+    }
 
-     public void testIntersectsRect() {
-         // Regression test HARMONY-1476
-         GeneralPath path = new GeneralPath();
-         path.moveTo(100, 500);
-         path.lineTo(400, 100);
-         path.lineTo(700, 500);
-         path.closePath();
-         
-         Area area = new Area(path);
-         assertTrue(area.intersects(new Rectangle2D.Double(300, 400, 100, 50)));
-         assertFalse(area.intersects(new Rectangle2D.Double(50, 50, 50, 50)));
-         
-         GeneralPath path1 = new GeneralPath();
-         path1.moveTo(400, 500);
-         path1.quadTo(200, 200, 400, 100);
-         path1.quadTo(600, 200, 400, 500);
-         path1.closePath();
-         
-         Area area1 = new Area(path1);
-         assertTrue(area1.intersects(350, 200, 50, 50));
-         assertFalse(area1.intersects(500, 50, 100, 50));
-         
-         // Regression test HARMONY-1404
-         try {
-             Area emptyArea = new Area();
-             emptyArea.intersects((Rectangle2D)null);
-             fail("Expected NPE");
-         } catch (NullPointerException e) {
-             // expected
-         }
-     }
-     
-     public void testIsRectangle() {
-     	 // Regression test HARMONY-1476
-     	Area area = new Area(new Rectangle2D.Double(200, 300, 400, 150));
-     	assertTrue(area.isRectangular());
-         
-     	GeneralPath path = new GeneralPath();
-         path.moveTo(200, 300);
-         path.lineTo(600, 300);
-         path.lineTo(600, 450);
-         path.lineTo(200, 450);
-         path.closePath();
-         
-         Area area1 = new Area(path);
-         assertTrue(area1.isRectangular());
-         
-         Area area2 = new Area(new Ellipse2D.Double(200, 300, 400, 150));
-         assertFalse(area2.isRectangular());     
-     }
-     
-     public void testGetPathIterator() {
-         // Regression test HARMONY-1860
-         Area a = new Area();
-         PathIterator path = a.getPathIterator(null);
-         checkPathRule(path, PathIterator.WIND_EVEN_ODD);
-         checkPathDone(path, true);
-     }
-     
-     public void testCreateTransformedArea() {
-         // Regression test HARMONY-1880
-         AffineTransform t = AffineTransform.getScaleInstance(2, 3);
-         Area a1 = new Area();        
-         Area a2 = a1.createTransformedArea(t);
-         PathIterator path = a2.getPathIterator(null);
-         checkPathRule(path, PathIterator.WIND_EVEN_ODD);
-         checkPathDone(path, true);
-     }
+    public void testContainsRect() {
+        // Regression test HARMONY-1404
+        try {
+            Area a = new Area();
+            a.contains((Rectangle2D)null);
+            fail("Expected NPE");
+        } catch (NullPointerException e) {
+            // expected
+        }
+    }
 
-    public static void main(String[] args) {
-        junit.textui.TestRunner.run(AreaTest.class);
+    public void testIntersectsRect() {
+        // Regression test HARMONY-1404
+        try {
+            Area a = new Area();
+            a.intersects((Rectangle2D)null);
+            fail("Expected NPE");
+        } catch (NullPointerException e) {
+            // expected
+        }
+    }
+    
+    public void testGetPathIterator() {
+        // Regression test HARMONY-1860
+        Area a = new Area();
+        PathIterator path = a.getPathIterator(null);
+        checkPathRule(path, PathIterator.WIND_NON_ZERO);
+        checkPathDone(path, true);
     }
+    
+    public void testCreateTransformedArea() {
+        // Regression test HARMONY-1880
+        AffineTransform t = AffineTransform.getScaleInstance(2, 3);
+        Area a1 = new Area();        
+        Area a2 = a1.createTransformedArea(t);
+        PathIterator path = a2.getPathIterator(null);
+        checkPathRule(path, PathIterator.WIND_NON_ZERO);
+        checkPathDone(path, true);
+    }
+
 }



Mime
View raw message