awt/java/awt/geom/Rectangle2D.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.util.NoSuchElementException;

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

 /**
  * The Class Rectangle2D represents a rectangle whose coordinates are given with
  * the correct precision to be used with the Graphics2D classes.
  *
  * @since Android 1.0
  */
 public abstract class Rectangle2D extends RectangularShape {

     /**
      * The Constant OUT_LEFT is a mask that is used to indicate that a given
      * point is outside the rectangle and to its left.
      */
     public static final int OUT_LEFT = 1;

     /**
      * The Constant OUT_TOP is a mask that is used to indicate that a given
      * point is outside the rectangle and above it.
      */
     public static final int OUT_TOP = 2;

     /**
      * The Constant OUT_RIGHT is a mask that is used to indicate that a given
      * point is outside the rectangle and to its right.
      */
     public static final int OUT_RIGHT = 4;

     /**
      * The Constant OUT_BOTTOM is a mask that is used to indicate that a given
      * point is outside the rectangle and above it.
      */
     public static final int OUT_BOTTOM = 8;

     /**
      * The Class Float is the subclass of Rectangle2D that represents a
      * rectangle whose data values are given as floats (with float-level
      * precision).
      *
      * @since Android 1.0
      */
     public static class Float extends Rectangle2D {

         /**
          * The x coordinate of the rectangle's upper left corner.
          */
         public float x;

         /**
          * The y coordinate of the rectangle's upper left corner.
          */
         public float y;

         /**
          * The width of the rectangle.
          */
         public float width;

         /**
          * The height of the rectangle.
          */
         public float height;

         /**
          * Instantiates a new empty rectangle with float-precision data fields.
          */
         public Float() {
         }

         /**
          * Instantiates a new rectangle with the specified float-precision data.
          *
          * @param x
          *            the x coordinate of the rectangle's upper left corner.
          * @param y
          *            the y coordinate of the rectangle's upper left corner.
          * @param width
          *            the width of the rectangle.
          * @param height
          *            the height of the rectangle.
          */
         public Float(float x, float y, float width, float height) {
             setRect(x, y, width, height);
         }

         @Override
         public double getX() {
             return x;
         }

         @Override
         public double getY() {
             return y;
         }

         @Override
         public double getWidth() {
             return width;
         }

         @Override
         public double getHeight() {
             return height;
         }

         @Override
         public boolean isEmpty() {
             return width <= 0.0f || height <= 0.0f;
         }

         /**
          * Sets the rectangle's data to the given values.
          *
          * @param x
          *            the x coordinate of the rectangle's upper left corner.
          * @param y
          *            the y coordinate of the rectangle's upper left corner.
          * @param width
          *            the width of the rectangle.
          * @param height
          *            the height of the rectangle.
          */
         public void setRect(float x, float y, float width, float height) {
             this.x = x;
             this.y = y;
             this.width = width;
             this.height = height;
         }

         @Override
         public void setRect(double x, double y, double width, double height) {
             this.x = (float)x;
             this.y = (float)y;
             this.width = (float)width;
             this.height = (float)height;
         }

         @Override
         public void setRect(Rectangle2D r) {
             this.x = (float)r.getX();
             this.y = (float)r.getY();
             this.width = (float)r.getWidth();
             this.height = (float)r.getHeight();
         }

         @Override
         public int outcode(double px, double py) {
             int code = 0;

             if (width <= 0.0f) {
                 code |= OUT_LEFT | OUT_RIGHT;
             } else if (px < x) {
                 code |= OUT_LEFT;
             } else if (px > x + width) {
                 code |= OUT_RIGHT;
             }

             if (height <= 0.0f) {
                 code |= OUT_TOP | OUT_BOTTOM;
             } else if (py < y) {
                 code |= OUT_TOP;
             } else if (py > y + height) {
                 code |= OUT_BOTTOM;
             }

             return code;
         }

         @Override
         public Rectangle2D getBounds2D() {
             return new Float(x, y, width, height);
         }

         @Override
         public Rectangle2D createIntersection(Rectangle2D r) {
             Rectangle2D dst;
             if (r instanceof Double) {
                 dst = new Rectangle2D.Double();
             } else {
                 dst = new Rectangle2D.Float();
             }
             Rectangle2D.intersect(this, r, dst);
             return dst;
         }

         @Override
         public Rectangle2D createUnion(Rectangle2D r) {
             Rectangle2D dst;
             if (r instanceof Double) {
                 dst = new Rectangle2D.Double();
             } else {
                 dst = new Rectangle2D.Float();
             }
             Rectangle2D.union(this, r, dst);
             return dst;
         }

         @Override
         public String toString() {
             // The output format based on 1.5 release behaviour. It could be
             // obtained in the following way
             // System.out.println(new Rectangle2D.Float().toString())
             return getClass().getName()
                     + "[x=" + x + ",y=" + y + ",width=" + width + ",height=" + height + "]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
         }
     }

     /**
      * The Class Double is the subclass of Rectangle2D that represents a
      * rectangle whose data values are given as doubles (with
      * double-precision-level precision).
      *
      * @since Android 1.0
      */
     public static class Double extends Rectangle2D {

         /**
          * The x coordinate of the rectangle's upper left corner.
          */
         public double x;

         /**
          * The y coordinate of the rectangle's upper left corner.
          */
         public double y;

         /**
          * The width of the rectangle.
          */
         public double width;

         /**
          * The height of the rectangle.
          */
         public double height;

         /**
          * Instantiates a new empty rectangle with double-precision data fields.
          */
         public Double() {
         }

         /**
          * Instantiates a new rectangle with the given double values.
          *
          * @param x
          *            the x coordinate of the rectangle's upper left corner.
          * @param y
          *            the y coordinate of the rectangle's upper left corner.
          * @param width
          *            the width of the rectangle.
          * @param height
          *            the height of the rectangle.
          */
         public Double(double x, double y, double width, double height) {
             setRect(x, y, width, height);
         }

         @Override
         public double getX() {
             return x;
         }

         @Override
         public double getY() {
             return y;
         }

         @Override
         public double getWidth() {
             return width;
         }

         @Override
         public double getHeight() {
             return height;
         }

         @Override
         public boolean isEmpty() {
             return width <= 0.0 || height <= 0.0;
         }

         @Override
         public void setRect(double x, double y, double width, double height) {
             this.x = x;
             this.y = y;
             this.width = width;
             this.height = height;
         }

         @Override
         public void setRect(Rectangle2D r) {
             this.x = r.getX();
             this.y = r.getY();
             this.width = r.getWidth();
             this.height = r.getHeight();
         }

         @Override
         public int outcode(double px, double py) {
             int code = 0;

             if (width <= 0.0) {
                 code |= OUT_LEFT | OUT_RIGHT;
             } else if (px < x) {
                 code |= OUT_LEFT;
             } else if (px > x + width) {
                 code |= OUT_RIGHT;
             }

             if (height <= 0.0) {
                 code |= OUT_TOP | OUT_BOTTOM;
             } else if (py < y) {
                 code |= OUT_TOP;
             } else if (py > y + height) {
                 code |= OUT_BOTTOM;
             }

             return code;
         }

         @Override
         public Rectangle2D getBounds2D() {
             return new Double(x, y, width, height);
         }

         @Override
         public Rectangle2D createIntersection(Rectangle2D r) {
             Rectangle2D dst = new Rectangle2D.Double();
             Rectangle2D.intersect(this, r, dst);
             return dst;
         }

         @Override
         public Rectangle2D createUnion(Rectangle2D r) {
             Rectangle2D dest = new Rectangle2D.Double();
             Rectangle2D.union(this, r, dest);
             return dest;
         }

         @Override
         public String toString() {
             // The output format based on 1.5 release behaviour. It could be
             // obtained in the following way
             // System.out.println(new Rectangle2D.Double().toString())
             return getClass().getName()
                     + "[x=" + x + ",y=" + y + ",width=" + width + ",height=" + height + "]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
         }
     }

     /**
      * The Class Iterator provides access to the coordinates of the
      * Rectangle2D's boundary modified by an AffineTransform.
      */
     class Iterator implements PathIterator {

         /**
          * The x coordinate of the rectangle's upper left corner.
          */
         double x;

         /**
          * The y coordinate of the rectangle's upper left corner.
          */
         double y;

         /**
          * The width of the rectangle.
          */
         double width;

         /**
          * The height of the rectangle.
          */
         double height;

         /**
          * The AffineTransform that is used to modify the coordinates that are
          * returned by the path iterator.
          */
         AffineTransform t;

         /**
          * The current segment index.
          */
         int index;

         /**
          * Constructs a new Rectangle2D.Iterator for given rectangle and
          * transformation.
          *
          * @param r
          *            the source Rectangle2D object.
          * @param at
          *            the AffineTransform object to apply to the coordinates
          *            before returning them.
          */
         Iterator(Rectangle2D r, AffineTransform at) {
             this.x = r.getX();
             this.y = r.getY();
             this.width = r.getWidth();
             this.height = r.getHeight();
             this.t = at;
             if (width < 0.0 || height < 0.0) {
                 index = 6;
             }
         }

         public int getWindingRule() {
             return WIND_NON_ZERO;
         }

         public boolean isDone() {
             return index > 5;
         }

         public void next() {
             index++;
         }

         public int currentSegment(double[] coords) {
             if (isDone()) {
                 throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
             }
             if (index == 5) {
                 return SEG_CLOSE;
             }
             int type;
             if (index == 0) {
                 type = SEG_MOVETO;
                 coords[0] = x;
                 coords[1] = y;
             } else {
                 type = SEG_LINETO;
                 switch (index) {
                     case 1:
                         coords[0] = x + width;
                         coords[1] = y;
                         break;
                     case 2:
                         coords[0] = x + width;
                         coords[1] = y + height;
                         break;
                     case 3:
                         coords[0] = x;
                         coords[1] = y + height;
                         break;
                     case 4:
                         coords[0] = x;
                         coords[1] = y;
                         break;
                 }
             }
             if (t != null) {
                 t.transform(coords, 0, coords, 0, 1);
             }
             return type;
         }

         public int currentSegment(float[] coords) {
             if (isDone()) {
                 throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
             }
             if (index == 5) {
                 return SEG_CLOSE;
             }
             int type;
             if (index == 0) {
                 coords[0] = (float)x;
                 coords[1] = (float)y;
                 type = SEG_MOVETO;
             } else {
                 type = SEG_LINETO;
                 switch (index) {
                     case 1:
                         coords[0] = (float)(x + width);
                         coords[1] = (float)y;
                         break;
                     case 2:
                         coords[0] = (float)(x + width);
                         coords[1] = (float)(y + height);
                         break;
                     case 3:
                         coords[0] = (float)x;
                         coords[1] = (float)(y + height);
                         break;
                     case 4:
                         coords[0] = (float)x;
                         coords[1] = (float)y;
                         break;
                 }
             }
             if (t != null) {
                 t.transform(coords, 0, coords, 0, 1);
             }
             return type;
         }

     }

     /**
      * Instantiates a new Rectangle2D.
      */
     protected Rectangle2D() {
     }

     /**
      * Sets the rectangle's location and dimension.
      *
      * @param x
      *            the x coordinate of the rectangle's upper left corner.
      * @param y
      *            the y coordinate of the rectangle's upper left corner.
      * @param width
      *            the width of the rectangle.
      * @param height
      *            the height of the rectangle.
      */
     public abstract void setRect(double x, double y, double width, double height);

     /**
      * Gets the location of the point with respect to the rectangle and packs
      * the information into a single integer using the bitmasks
      * {@link Rectangle2D#OUT_LEFT}, {@link Rectangle2D#OUT_RIGHT},
      * {@link Rectangle2D#OUT_TOP}, and {@link Rectangle2D#OUT_BOTTOM}. If the
      * rectangle has zero or negative width, then every point is regarded as
      * being both to the left and to the right of the rectangle. Similarly, if
      * the height is zero or negative then all points are considered to be both
      * both above and below it.
      *
      * @param x
      *            the x coordinate of the point to check.
      * @param y
      *            the y coordinate of the point to check.
      * @return the point's location with respect to the rectangle.
      */
     public abstract int outcode(double x, double y);

     /**
      * Creates an new rectangle that is the intersection of this rectangle with
      * the given rectangle. The resulting rectangle may be empty. The data of
      * this rectangle is left unchanged.
      *
      * @param r
      *            the rectangle to intersect with this rectangle.
      * @return the new rectangle given by intersection.
      */
     public abstract Rectangle2D createIntersection(Rectangle2D r);

     /**
      * Creates an new rectangle that is the union of this rectangle with the
      * given rectangle. The new rectangle is the smallest rectangle which
      * contains both this rectangle and the rectangle specified as a parameter.
      * The data of this rectangle is left unchanged.
      *
      * @param r
      *            the rectangle to combine with this rectangle.
      * @return the new rectangle given by union.
      */
     public abstract Rectangle2D createUnion(Rectangle2D r);

     /**
      * Sets the data of this rectangle to match the data of the given rectangle.
      *
      * @param r
      *            the rectangle whose data is to be copied into this rectangle's
      *            fields.
      */
     public void setRect(Rectangle2D r) {
         setRect(r.getX(), r.getY(), r.getWidth(), r.getHeight());
     }

     @Override
     public void setFrame(double x, double y, double width, double height) {
         setRect(x, y, width, height);
     }

     public Rectangle2D getBounds2D() {
         return (Rectangle2D)clone();
     }

     /**
      * Determines whether any part of the line segment between (and including)
      * the two given points touches any part of the rectangle, including its
      * boundary.
      *
      * @param x1
      *            the x coordinate of one of the points that determines the line
      *            segment to test.
      * @param y1
      *            the y coordinate of one of the points that determines the line
      *            segment to test.
      * @param x2
      *            the x coordinate of one of the points that determines the line
      *            segment to test.
      * @param y2
      *            the y coordinate of one of the points that determines the line
      *            segment to test.
      * @return true, if at least one point of the line segment between the two
      *         points matches any point of the interior of the rectangle or the
      *         rectangle's boundary.
      */
     public boolean intersectsLine(double x1, double y1, double x2, double y2) {
         double rx1 = getX();
         double ry1 = getY();
         double rx2 = rx1 + getWidth();
         double ry2 = ry1 + getHeight();
         return (rx1 <= x1 && x1 <= rx2 && ry1 <= y1 && y1 <= ry2)
                 || (rx1 <= x2 && x2 <= rx2 && ry1 <= y2 && y2 <= ry2)
                 || Line2D.linesIntersect(rx1, ry1, rx2, ry2, x1, y1, x2, y2)
                 || Line2D.linesIntersect(rx2, ry1, rx1, ry2, x1, y1, x2, y2);
     }

     /**
      * Determines whether any part of the specified line segment touches any
      * part of the rectangle, including its boundary.
      *
      * @param l
      *            the line segment to test.
      * @return true, if at least one point of the given line segment matches any
      *         point of the interior of the rectangle or the rectangle's
      *         boundary.
      */
     public boolean intersectsLine(Line2D l) {
         return intersectsLine(l.getX1(), l.getY1(), l.getX2(), l.getY2());
     }

     /**
      * Gets the location of the point with respect to the rectangle and packs
      * the information into a single integer using the bitmasks
      * {@link Rectangle2D#OUT_LEFT}, {@link Rectangle2D#OUT_RIGHT},
      * {@link Rectangle2D#OUT_TOP}, and {@link Rectangle2D#OUT_BOTTOM}. If the
      * rectangle has zero or negative width, then every point is regarded as
      * being both to the left and to the right of the rectangle. Similarly, if
      * the height is zero or negative then all points are considered to be both
      * both above and below it.
      *
      * @param p
      *            the point to check.
      * @return the point's location with respect to the rectangle.
      */
     public int outcode(Point2D p) {
         return outcode(p.getX(), p.getY());
     }

     public boolean contains(double x, double y) {
         if (isEmpty()) {
             return false;
         }

         double x1 = getX();
         double y1 = getY();
         double x2 = x1 + getWidth();
         double y2 = y1 + getHeight();

         return x1 <= x && x < x2 && y1 <= y && y < y2;
     }

     public boolean intersects(double x, double y, double width, double height) {
         if (isEmpty() || width <= 0.0 || height <= 0.0) {
             return false;
         }

         double x1 = getX();
         double y1 = getY();
         double x2 = x1 + getWidth();
         double y2 = y1 + getHeight();

         return x + width > x1 && x < x2 && y + height > y1 && y < y2;
     }

     public boolean contains(double x, double y, double width, double height) {
         if (isEmpty() || width <= 0.0 || height <= 0.0) {
             return false;
         }

         double x1 = getX();
         double y1 = getY();
         double x2 = x1 + getWidth();
         double y2 = y1 + getHeight();

         return x1 <= x && x + width <= x2 && y1 <= y && y + height <= y2;
     }

     /**
      * Changes the data values of the destination rectangle to match the
      * intersection of the two source rectangles, leaving the two source
      * rectangles unchanged. The resulting rectangle may be empty.
      *
      * @param src1
      *            one of the two source rectangles giving the data to intersect.
      * @param src2
      *            one of the two source rectangles giving the data to intersect.
      * @param dst
      *            the destination object where the data of the intersection is
      *            written.
      */
     public static void intersect(Rectangle2D src1, Rectangle2D src2, Rectangle2D dst) {
         double x1 = Math.max(src1.getMinX(), src2.getMinX());
         double y1 = Math.max(src1.getMinY(), src2.getMinY());
         double x2 = Math.min(src1.getMaxX(), src2.getMaxX());
         double y2 = Math.min(src1.getMaxY(), src2.getMaxY());
         dst.setFrame(x1, y1, x2 - x1, y2 - y1);
     }

     /**
      * Changes the data values of the destination rectangle to match the union
      * of the two source rectangles, leaving the two source rectangles
      * unchanged. The union is the smallest rectangle that completely covers the
      * two source rectangles.
      *
      * @param src1
      *            one of the two source rectangles giving the data.
      * @param src2
      *            one of the two source rectangles giving the data.
      * @param dst
      *            the destination object where the data of the union is written.
      */
     public static void union(Rectangle2D src1, Rectangle2D src2, Rectangle2D dst) {
         double x1 = Math.min(src1.getMinX(), src2.getMinX());
         double y1 = Math.min(src1.getMinY(), src2.getMinY());
         double x2 = Math.max(src1.getMaxX(), src2.getMaxX());
         double y2 = Math.max(src1.getMaxY(), src2.getMaxY());
         dst.setFrame(x1, y1, x2 - x1, y2 - y1);
     }

     /**
      * Enlarges the rectangle so that it includes the given point.
      *
      * @param x
      *            the x coordinate of the new point to be covered by the
      *            rectangle.
      * @param y
      *            the y coordinate of the new point to be covered by the
      *            rectangle.
      */
     public void add(double x, double y) {
         double x1 = Math.min(getMinX(), x);
         double y1 = Math.min(getMinY(), y);
         double x2 = Math.max(getMaxX(), x);
         double y2 = Math.max(getMaxY(), y);
         setRect(x1, y1, x2 - x1, y2 - y1);
     }

     /**
      * Enlarges the rectangle so that it includes the given point.
      *
      * @param p
      *            the new point to be covered by the rectangle.
      */
     public void add(Point2D p) {
         add(p.getX(), p.getY());
     }

     /**
      * Enlarges the rectangle so that it covers the given rectangle.
      *
      * @param r
      *            the new rectangle to be covered by this rectangle.
      */
     public void add(Rectangle2D r) {
         union(this, r, this);
     }

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

     @Override
     public PathIterator getPathIterator(AffineTransform t, double flatness) {
         return new Iterator(this, t);
     }

     @Override
     public int hashCode() {
         HashCode hash = new HashCode();
         hash.append(getX());
         hash.append(getY());
         hash.append(getWidth());
         hash.append(getHeight());
         return hash.hashCode();
     }

     @Override
     public boolean equals(Object obj) {
         if (obj == this) {
             return true;
         }
         if (obj instanceof Rectangle2D) {
             Rectangle2D r = (Rectangle2D)obj;
             return getX() == r.getX() && getY() == r.getY() && getWidth() == r.getWidth()
                     && getHeight() == r.getHeight();
         }
         return false;
     }

 }
	/*
	* 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.util.NoSuchElementException;

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

	/**
	* The Class Rectangle2D represents a rectangle whose coordinates are given with
	* the correct precision to be used with the Graphics2D classes.
	*
	* @since Android 1.0
	*/
	public abstract class Rectangle2D extends RectangularShape {

	/**
	* The Constant OUT_LEFT is a mask that is used to indicate that a given
	* point is outside the rectangle and to its left.
	*/
	public static final int OUT_LEFT = 1;

	/**
	* The Constant OUT_TOP is a mask that is used to indicate that a given
	* point is outside the rectangle and above it.
	*/
	public static final int OUT_TOP = 2;

	/**
	* The Constant OUT_RIGHT is a mask that is used to indicate that a given
	* point is outside the rectangle and to its right.
	*/
	public static final int OUT_RIGHT = 4;

	/**
	* The Constant OUT_BOTTOM is a mask that is used to indicate that a given
	* point is outside the rectangle and above it.
	*/
	public static final int OUT_BOTTOM = 8;

	/**
	* The Class Float is the subclass of Rectangle2D that represents a
	* rectangle whose data values are given as floats (with float-level
	* precision).
	*
	* @since Android 1.0
	*/
	public static class Float extends Rectangle2D {

	/**
	* The x coordinate of the rectangle's upper left corner.
	*/
	public float x;

	/**
	* The y coordinate of the rectangle's upper left corner.
	*/
	public float y;

	/**
	* The width of the rectangle.
	*/
	public float width;

	/**
	* The height of the rectangle.
	*/
	public float height;

	/**
	* Instantiates a new empty rectangle with float-precision data fields.
	*/
	public Float() {
	}

	/**
	* Instantiates a new rectangle with the specified float-precision data.
	*
	* @param x
	* the x coordinate of the rectangle's upper left corner.
	* @param y
	* the y coordinate of the rectangle's upper left corner.
	* @param width
	* the width of the rectangle.
	* @param height
	* the height of the rectangle.
	*/
	public Float(float x, float y, float width, float height) {
	setRect(x, y, width, height);
	}

	@Override
	public double getX() {
	return x;
	}

	@Override
	public double getY() {
	return y;
	}

	@Override
	public double getWidth() {
	return width;
	}

	@Override
	public double getHeight() {
	return height;
	}

	@Override
	public boolean isEmpty() {
	return width <= 0.0f \|\| height <= 0.0f;
	}

	/**
	* Sets the rectangle's data to the given values.
	*
	* @param x
	* the x coordinate of the rectangle's upper left corner.
	* @param y
	* the y coordinate of the rectangle's upper left corner.
	* @param width
	* the width of the rectangle.
	* @param height
	* the height of the rectangle.
	*/
	public void setRect(float x, float y, float width, float height) {
	this.x = x;
	this.y = y;
	this.width = width;
	this.height = height;
	}

	@Override
	public void setRect(double x, double y, double width, double height) {
	this.x = (float)x;
	this.y = (float)y;
	this.width = (float)width;
	this.height = (float)height;
	}

	@Override
	public void setRect(Rectangle2D r) {
	this.x = (float)r.getX();
	this.y = (float)r.getY();
	this.width = (float)r.getWidth();
	this.height = (float)r.getHeight();
	}

	@Override
	public int outcode(double px, double py) {
	int code = 0;

	if (width <= 0.0f) {
	code \|= OUT_LEFT \| OUT_RIGHT;
	} else if (px < x) {
	code \|= OUT_LEFT;
	} else if (px > x + width) {
	code \|= OUT_RIGHT;
	}

	if (height <= 0.0f) {
	code \|= OUT_TOP \| OUT_BOTTOM;
	} else if (py < y) {
	code \|= OUT_TOP;
	} else if (py > y + height) {
	code \|= OUT_BOTTOM;
	}

	return code;
	}

	@Override
	public Rectangle2D getBounds2D() {
	return new Float(x, y, width, height);
	}

	@Override
	public Rectangle2D createIntersection(Rectangle2D r) {
	Rectangle2D dst;
	if (r instanceof Double) {
	dst = new Rectangle2D.Double();
	} else {
	dst = new Rectangle2D.Float();
	}
	Rectangle2D.intersect(this, r, dst);
	return dst;
	}

	@Override
	public Rectangle2D createUnion(Rectangle2D r) {
	Rectangle2D dst;
	if (r instanceof Double) {
	dst = new Rectangle2D.Double();
	} else {
	dst = new Rectangle2D.Float();
	}
	Rectangle2D.union(this, r, dst);
	return dst;
	}

	@Override
	public String toString() {
	// The output format based on 1.5 release behaviour. It could be
	// obtained in the following way
	// System.out.println(new Rectangle2D.Float().toString())
	return getClass().getName()
	+ "[x=" + x + ",y=" + y + ",width=" + width + ",height=" + height + "]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
	}
	}

	/**
	* The Class Double is the subclass of Rectangle2D that represents a
	* rectangle whose data values are given as doubles (with
	* double-precision-level precision).
	*
	* @since Android 1.0
	*/
	public static class Double extends Rectangle2D {

	/**
	* The x coordinate of the rectangle's upper left corner.
	*/
	public double x;

	/**
	* The y coordinate of the rectangle's upper left corner.
	*/
	public double y;

	/**
	* The width of the rectangle.
	*/
	public double width;

	/**
	* The height of the rectangle.
	*/
	public double height;

	/**
	* Instantiates a new empty rectangle with double-precision data fields.
	*/
	public Double() {
	}

	/**
	* Instantiates a new rectangle with the given double values.
	*
	* @param x
	* the x coordinate of the rectangle's upper left corner.
	* @param y
	* the y coordinate of the rectangle's upper left corner.
	* @param width
	* the width of the rectangle.
	* @param height
	* the height of the rectangle.
	*/
	public Double(double x, double y, double width, double height) {
	setRect(x, y, width, height);
	}

	@Override
	public double getX() {
	return x;
	}

	@Override
	public double getY() {
	return y;
	}

	@Override
	public double getWidth() {
	return width;
	}

	@Override
	public double getHeight() {
	return height;
	}

	@Override
	public boolean isEmpty() {
	return width <= 0.0 \|\| height <= 0.0;
	}

	@Override
	public void setRect(double x, double y, double width, double height) {
	this.x = x;
	this.y = y;
	this.width = width;
	this.height = height;
	}

	@Override
	public void setRect(Rectangle2D r) {
	this.x = r.getX();
	this.y = r.getY();
	this.width = r.getWidth();
	this.height = r.getHeight();
	}

	@Override
	public int outcode(double px, double py) {
	int code = 0;

	if (width <= 0.0) {
	code \|= OUT_LEFT \| OUT_RIGHT;
	} else if (px < x) {
	code \|= OUT_LEFT;
	} else if (px > x + width) {
	code \|= OUT_RIGHT;
	}

	if (height <= 0.0) {
	code \|= OUT_TOP \| OUT_BOTTOM;
	} else if (py < y) {
	code \|= OUT_TOP;
	} else if (py > y + height) {
	code \|= OUT_BOTTOM;
	}

	return code;
	}

	@Override
	public Rectangle2D getBounds2D() {
	return new Double(x, y, width, height);
	}

	@Override
	public Rectangle2D createIntersection(Rectangle2D r) {
	Rectangle2D dst = new Rectangle2D.Double();
	Rectangle2D.intersect(this, r, dst);
	return dst;
	}

	@Override
	public Rectangle2D createUnion(Rectangle2D r) {
	Rectangle2D dest = new Rectangle2D.Double();
	Rectangle2D.union(this, r, dest);
	return dest;
	}

	@Override
	public String toString() {
	// The output format based on 1.5 release behaviour. It could be
	// obtained in the following way
	// System.out.println(new Rectangle2D.Double().toString())
	return getClass().getName()
	+ "[x=" + x + ",y=" + y + ",width=" + width + ",height=" + height + "]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
	}
	}

	/**
	* The Class Iterator provides access to the coordinates of the
	* Rectangle2D's boundary modified by an AffineTransform.
	*/
	class Iterator implements PathIterator {

	/**
	* The x coordinate of the rectangle's upper left corner.
	*/
	double x;

	/**
	* The y coordinate of the rectangle's upper left corner.
	*/
	double y;

	/**
	* The width of the rectangle.
	*/
	double width;

	/**
	* The height of the rectangle.
	*/
	double height;

	/**
	* The AffineTransform that is used to modify the coordinates that are
	* returned by the path iterator.
	*/
	AffineTransform t;

	/**
	* The current segment index.
	*/
	int index;

	/**
	* Constructs a new Rectangle2D.Iterator for given rectangle and
	* transformation.
	*
	* @param r
	* the source Rectangle2D object.
	* @param at
	* the AffineTransform object to apply to the coordinates
	* before returning them.
	*/
	Iterator(Rectangle2D r, AffineTransform at) {
	this.x = r.getX();
	this.y = r.getY();
	this.width = r.getWidth();
	this.height = r.getHeight();
	this.t = at;
	if (width < 0.0 \|\| height < 0.0) {
	index = 6;
	}
	}

	public int getWindingRule() {
	return WIND_NON_ZERO;
	}

	public boolean isDone() {
	return index > 5;
	}

	public void next() {
	index++;
	}

	public int currentSegment(double[] coords) {
	if (isDone()) {
	throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
	}
	if (index == 5) {
	return SEG_CLOSE;
	}
	int type;
	if (index == 0) {
	type = SEG_MOVETO;
	coords[0] = x;
	coords[1] = y;
	} else {
	type = SEG_LINETO;
	switch (index) {
	case 1:
	coords[0] = x + width;
	coords[1] = y;
	break;
	case 2:
	coords[0] = x + width;
	coords[1] = y + height;
	break;
	case 3:
	coords[0] = x;
	coords[1] = y + height;
	break;
	case 4:
	coords[0] = x;
	coords[1] = y;
	break;
	}
	}
	if (t != null) {
	t.transform(coords, 0, coords, 0, 1);
	}
	return type;
	}

	public int currentSegment(float[] coords) {
	if (isDone()) {
	throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
	}
	if (index == 5) {
	return SEG_CLOSE;
	}
	int type;
	if (index == 0) {
	coords[0] = (float)x;
	coords[1] = (float)y;
	type = SEG_MOVETO;
	} else {
	type = SEG_LINETO;
	switch (index) {
	case 1:
	coords[0] = (float)(x + width);
	coords[1] = (float)y;
	break;
	case 2:
	coords[0] = (float)(x + width);
	coords[1] = (float)(y + height);
	break;
	case 3:
	coords[0] = (float)x;
	coords[1] = (float)(y + height);
	break;
	case 4:
	coords[0] = (float)x;
	coords[1] = (float)y;
	break;
	}
	}
	if (t != null) {
	t.transform(coords, 0, coords, 0, 1);
	}
	return type;
	}

	}

	/**
	* Instantiates a new Rectangle2D.
	*/
	protected Rectangle2D() {
	}

	/**
	* Sets the rectangle's location and dimension.
	*
	* @param x
	* the x coordinate of the rectangle's upper left corner.
	* @param y
	* the y coordinate of the rectangle's upper left corner.
	* @param width
	* the width of the rectangle.
	* @param height
	* the height of the rectangle.
	*/
	public abstract void setRect(double x, double y, double width, double height);

	/**
	* Gets the location of the point with respect to the rectangle and packs
	* the information into a single integer using the bitmasks
	* {@link Rectangle2D#OUT_LEFT}, {@link Rectangle2D#OUT_RIGHT},
	* {@link Rectangle2D#OUT_TOP}, and {@link Rectangle2D#OUT_BOTTOM}. If the
	* rectangle has zero or negative width, then every point is regarded as
	* being both to the left and to the right of the rectangle. Similarly, if
	* the height is zero or negative then all points are considered to be both
	* both above and below it.
	*
	* @param x
	* the x coordinate of the point to check.
	* @param y
	* the y coordinate of the point to check.
	* @return the point's location with respect to the rectangle.
	*/
	public abstract int outcode(double x, double y);

	/**
	* Creates an new rectangle that is the intersection of this rectangle with
	* the given rectangle. The resulting rectangle may be empty. The data of
	* this rectangle is left unchanged.
	*
	* @param r
	* the rectangle to intersect with this rectangle.
	* @return the new rectangle given by intersection.
	*/
	public abstract Rectangle2D createIntersection(Rectangle2D r);

	/**
	* Creates an new rectangle that is the union of this rectangle with the
	* given rectangle. The new rectangle is the smallest rectangle which
	* contains both this rectangle and the rectangle specified as a parameter.
	* The data of this rectangle is left unchanged.
	*
	* @param r
	* the rectangle to combine with this rectangle.
	* @return the new rectangle given by union.
	*/
	public abstract Rectangle2D createUnion(Rectangle2D r);

	/**
	* Sets the data of this rectangle to match the data of the given rectangle.
	*
	* @param r
	* the rectangle whose data is to be copied into this rectangle's
	* fields.
	*/
	public void setRect(Rectangle2D r) {
	setRect(r.getX(), r.getY(), r.getWidth(), r.getHeight());
	}

	@Override
	public void setFrame(double x, double y, double width, double height) {
	setRect(x, y, width, height);
	}

	public Rectangle2D getBounds2D() {
	return (Rectangle2D)clone();
	}

	/**
	* Determines whether any part of the line segment between (and including)
	* the two given points touches any part of the rectangle, including its
	* boundary.
	*
	* @param x1
	* the x coordinate of one of the points that determines the line
	* segment to test.
	* @param y1
	* the y coordinate of one of the points that determines the line
	* segment to test.
	* @param x2
	* the x coordinate of one of the points that determines the line
	* segment to test.
	* @param y2
	* the y coordinate of one of the points that determines the line
	* segment to test.
	* @return true, if at least one point of the line segment between the two
	* points matches any point of the interior of the rectangle or the
	* rectangle's boundary.
	*/
	public boolean intersectsLine(double x1, double y1, double x2, double y2) {
	double rx1 = getX();
	double ry1 = getY();
	double rx2 = rx1 + getWidth();
	double ry2 = ry1 + getHeight();
	return (rx1 <= x1 && x1 <= rx2 && ry1 <= y1 && y1 <= ry2)
	\|\| (rx1 <= x2 && x2 <= rx2 && ry1 <= y2 && y2 <= ry2)
	\|\| Line2D.linesIntersect(rx1, ry1, rx2, ry2, x1, y1, x2, y2)
	\|\| Line2D.linesIntersect(rx2, ry1, rx1, ry2, x1, y1, x2, y2);
	}

	/**
	* Determines whether any part of the specified line segment touches any
	* part of the rectangle, including its boundary.
	*
	* @param l
	* the line segment to test.
	* @return true, if at least one point of the given line segment matches any
	* point of the interior of the rectangle or the rectangle's
	* boundary.
	*/
	public boolean intersectsLine(Line2D l) {
	return intersectsLine(l.getX1(), l.getY1(), l.getX2(), l.getY2());
	}

	/**
	* Gets the location of the point with respect to the rectangle and packs
	* the information into a single integer using the bitmasks
	* {@link Rectangle2D#OUT_LEFT}, {@link Rectangle2D#OUT_RIGHT},
	* {@link Rectangle2D#OUT_TOP}, and {@link Rectangle2D#OUT_BOTTOM}. If the
	* rectangle has zero or negative width, then every point is regarded as
	* being both to the left and to the right of the rectangle. Similarly, if
	* the height is zero or negative then all points are considered to be both
	* both above and below it.
	*
	* @param p
	* the point to check.
	* @return the point's location with respect to the rectangle.
	*/
	public int outcode(Point2D p) {
	return outcode(p.getX(), p.getY());
	}

	public boolean contains(double x, double y) {
	if (isEmpty()) {
	return false;
	}

	double x1 = getX();
	double y1 = getY();
	double x2 = x1 + getWidth();
	double y2 = y1 + getHeight();

	return x1 <= x && x < x2 && y1 <= y && y < y2;
	}

	public boolean intersects(double x, double y, double width, double height) {
	if (isEmpty() \|\| width <= 0.0 \|\| height <= 0.0) {
	return false;
	}

	double x1 = getX();
	double y1 = getY();
	double x2 = x1 + getWidth();
	double y2 = y1 + getHeight();

	return x + width > x1 && x < x2 && y + height > y1 && y < y2;
	}

	public boolean contains(double x, double y, double width, double height) {
	if (isEmpty() \|\| width <= 0.0 \|\| height <= 0.0) {
	return false;
	}

	double x1 = getX();
	double y1 = getY();
	double x2 = x1 + getWidth();
	double y2 = y1 + getHeight();

	return x1 <= x && x + width <= x2 && y1 <= y && y + height <= y2;
	}

	/**
	* Changes the data values of the destination rectangle to match the
	* intersection of the two source rectangles, leaving the two source
	* rectangles unchanged. The resulting rectangle may be empty.
	*
	* @param src1
	* one of the two source rectangles giving the data to intersect.
	* @param src2
	* one of the two source rectangles giving the data to intersect.
	* @param dst
	* the destination object where the data of the intersection is
	* written.
	*/
	public static void intersect(Rectangle2D src1, Rectangle2D src2, Rectangle2D dst) {
	double x1 = Math.max(src1.getMinX(), src2.getMinX());
	double y1 = Math.max(src1.getMinY(), src2.getMinY());
	double x2 = Math.min(src1.getMaxX(), src2.getMaxX());
	double y2 = Math.min(src1.getMaxY(), src2.getMaxY());
	dst.setFrame(x1, y1, x2 - x1, y2 - y1);
	}

	/**
	* Changes the data values of the destination rectangle to match the union
	* of the two source rectangles, leaving the two source rectangles
	* unchanged. The union is the smallest rectangle that completely covers the
	* two source rectangles.
	*
	* @param src1
	* one of the two source rectangles giving the data.
	* @param src2
	* one of the two source rectangles giving the data.
	* @param dst
	* the destination object where the data of the union is written.
	*/
	public static void union(Rectangle2D src1, Rectangle2D src2, Rectangle2D dst) {
	double x1 = Math.min(src1.getMinX(), src2.getMinX());
	double y1 = Math.min(src1.getMinY(), src2.getMinY());
	double x2 = Math.max(src1.getMaxX(), src2.getMaxX());
	double y2 = Math.max(src1.getMaxY(), src2.getMaxY());
	dst.setFrame(x1, y1, x2 - x1, y2 - y1);
	}

	/**
	* Enlarges the rectangle so that it includes the given point.
	*
	* @param x
	* the x coordinate of the new point to be covered by the
	* rectangle.
	* @param y
	* the y coordinate of the new point to be covered by the
	* rectangle.
	*/
	public void add(double x, double y) {
	double x1 = Math.min(getMinX(), x);
	double y1 = Math.min(getMinY(), y);
	double x2 = Math.max(getMaxX(), x);
	double y2 = Math.max(getMaxY(), y);
	setRect(x1, y1, x2 - x1, y2 - y1);
	}

	/**
	* Enlarges the rectangle so that it includes the given point.
	*
	* @param p
	* the new point to be covered by the rectangle.
	*/
	public void add(Point2D p) {
	add(p.getX(), p.getY());
	}

	/**
	* Enlarges the rectangle so that it covers the given rectangle.
	*
	* @param r
	* the new rectangle to be covered by this rectangle.
	*/
	public void add(Rectangle2D r) {
	union(this, r, this);
	}

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

	@Override
	public PathIterator getPathIterator(AffineTransform t, double flatness) {
	return new Iterator(this, t);
	}

	@Override
	public int hashCode() {
	HashCode hash = new HashCode();
	hash.append(getX());
	hash.append(getY());
	hash.append(getWidth());
	hash.append(getHeight());
	return hash.hashCode();
	}

	@Override
	public boolean equals(Object obj) {
	if (obj == this) {
	return true;
	}
	if (obj instanceof Rectangle2D) {
	Rectangle2D r = (Rectangle2D)obj;
	return getX() == r.getX() && getY() == r.getY() && getWidth() == r.getWidth()
	&& getHeight() == r.getHeight();
	}
	return false;
	}

	}