awt/java/awt/Rectangle.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;

 import java.awt.geom.Rectangle2D;
 import java.io.Serializable;

 /**
  * The Rectangle class defines the rectangular area in terms of its upper left
  * corner coordinates [x,y], its width, and its height. A Rectangle specified by
  * [x, y, width, height] parameters has an outline path with corners at [x, y],
  * [x + width,y], [x + width,y + height], and [x, y + height]. <br>
  * <br>
  * The rectangle is empty if the width or height is negative or zero. In this
  * case the isEmpty method returns true.
  *
  * @since Android 1.0
  */
 public class Rectangle extends Rectangle2D implements Shape, Serializable {

     /**
      * The Constant serialVersionUID.
      */
     private static final long serialVersionUID = -4345857070255674764L;

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

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

     /**
      * The width of rectangle.
      */
     public int width;

     /**
      * The height of rectangle.
      */
     public int height;

     /**
      * Instantiates a new rectangle with [0, 0] upper left corner coordinates,
      * the width and the height are zero.
      */
     public Rectangle() {
         setBounds(0, 0, 0, 0);
     }

     /**
      * Instantiates a new rectangle whose upper left corner coordinates are
      * given by the Point object (p.X and p.Y), and the width and the height are
      * zero.
      *
      * @param p
      *            the Point specifies the upper left corner coordinates of the
      *            rectangle.
      */
     public Rectangle(Point p) {
         setBounds(p.x, p.y, 0, 0);
     }

     /**
      * Instantiates a new rectangle whose upper left corner coordinates are
      * given by the Point object (p.X and p.Y), and the width and the height are
      * given by Dimension object (d.width and d.height).
      *
      * @param p
      *            the point specifies the upper left corner coordinates of the
      *            rectangle.
      * @param d
      *            the dimension specifies the width and the height of the
      *            rectangle.
      */
     public Rectangle(Point p, Dimension d) {
         setBounds(p.x, p.y, d.width, d.height);
     }

     /**
      * Instantiates a new rectangle determined by the upper left corner
      * coordinates (x, y), width and height.
      *
      * @param x
      *            the X upper left corner coordinate of the rectangle.
      * @param y
      *            the Y upper left corner coordinate of the rectangle.
      * @param width
      *            the width of rectangle.
      * @param height
      *            the height of rectangle.
      */
     public Rectangle(int x, int y, int width, int height) {
         setBounds(x, y, width, height);
     }

     /**
      * Instantiates a new rectangle with [0, 0] as its upper left corner
      * coordinates and the specified width and height.
      *
      * @param width
      *            the width of rectangle.
      * @param height
      *            the height of rectangle.
      */
     public Rectangle(int width, int height) {
         setBounds(0, 0, width, height);
     }

     /**
      * Instantiates a new rectangle with the same coordinates as the given
      * source rectangle.
      *
      * @param r
      *            the Rectangle object which parameters will be used for
      *            instantiating a new Rectangle.
      */
     public Rectangle(Rectangle r) {
         setBounds(r.x, r.y, r.width, r.height);
     }

     /*
      * public Rectangle(Dimension d) { setBounds(0, 0, d.width, d.height); }
      */
     /**
      * Gets the X coordinate of bound as a double.
      *
      * @return the X coordinate of bound as a double.
      * @see java.awt.geom.RectangularShape#getX()
      */
     @Override
     public double getX() {
         return x;
     }

     /**
      * Gets the Y coordinate of bound as a double.
      *
      * @return the Y coordinate of bound as a double.
      * @see java.awt.geom.RectangularShape#getY()
      */
     @Override
     public double getY() {
         return y;
     }

     /**
      * Gets the height of the rectangle as a double.
      *
      * @return the height of the rectangle as a double.
      * @see java.awt.geom.RectangularShape#getHeight()
      */
     @Override
     public double getHeight() {
         return height;
     }

     /**
      * Gets the width of the rectangle as a double.
      *
      * @return the width of the rectangle as a double.
      * @see java.awt.geom.RectangularShape#getWidth()
      */
     @Override
     public double getWidth() {
         return width;
     }

     /**
      * Determines whether or not the rectangle is empty. The rectangle is empty
      * if its width or height is negative or zero.
      *
      * @return true, if the rectangle is empty, otherwise false.
      * @see java.awt.geom.RectangularShape#isEmpty()
      */
     @Override
     public boolean isEmpty() {
         return width <= 0 || height <= 0;
     }

     /**
      * Gets the size of a Rectangle as Dimension object.
      *
      * @return a Dimension object which represents size of the rectangle.
      */
     public Dimension getSize() {
         return new Dimension(width, height);
     }

     /**
      * Sets the size of the Rectangle.
      *
      * @param width
      *            the new width of the rectangle.
      * @param height
      *            the new height of the rectangle.
      */
     public void setSize(int width, int height) {
         this.width = width;
         this.height = height;
     }

     /**
      * Sets the size of a Rectangle specified as Dimension object.
      *
      * @param d
      *            a Dimension object which represents new size of a rectangle.
      */
     public void setSize(Dimension d) {
         setSize(d.width, d.height);
     }

     /**
      * Gets the location of a rectangle's upper left corner as a Point object.
      *
      * @return the Point object with coordinates equal to the upper left corner
      *         of the rectangle.
      */
     public Point getLocation() {
         return new Point(x, y);
     }

     /**
      * Sets the location of the rectangle in terms of its upper left corner
      * coordinates X and Y.
      *
      * @param x
      *            the X coordinate of the rectangle's upper left corner.
      * @param y
      *            the Y coordinate of the rectangle's upper left corner.
      */
     public void setLocation(int x, int y) {
         this.x = x;
         this.y = y;
     }

     /**
      * Sets the location of a rectangle using a Point object to give the
      * coordinates of the upper left corner.
      *
      * @param p
      *            the Point object which represents the new upper left corner
      *            coordinates of rectangle.
      */
     public void setLocation(Point p) {
         setLocation(p.x, p.y);
     }

     /**
      * Moves a rectangle to the new location by moving its upper left corner to
      * the point with coordinates X and Y.
      *
      * @param x
      *            the new X coordinate of the rectangle's upper left corner.
      * @param y
      *            the new Y coordinate of the rectangle's upper left corner.
      * @deprecated Use setLocation(int, int) method.
      */
     @Deprecated
     public void move(int x, int y) {
         setLocation(x, y);
     }

     /**
      * Sets the rectangle to be the nearest rectangle with integer coordinates
      * bounding the rectangle defined by the double-valued parameters.
      *
      * @param x
      *            the X coordinate of the upper left corner of the double-valued
      *            rectangle to be bounded.
      * @param y
      *            the Y coordinate of the upper left corner of the double-valued
      *            rectangle to be bounded.
      * @param width
      *            the width of the rectangle to be bounded.
      * @param height
      *            the height of the rectangle to be bounded.
      * @see java.awt.geom.Rectangle2D#setRect(double, double, double, double)
      */
     @Override
     public void setRect(double x, double y, double width, double height) {
         int x1 = (int)Math.floor(x);
         int y1 = (int)Math.floor(y);
         int x2 = (int)Math.ceil(x + width);
         int y2 = (int)Math.ceil(y + height);
         setBounds(x1, y1, x2 - x1, y2 - y1);
     }

     /**
      * Sets a new size for the rectangle.
      *
      * @param width
      *            the rectangle's new width.
      * @param height
      *            the rectangle's new height.
      * @deprecated use the setSize(int, int) method.
      */
     @Deprecated
     public void resize(int width, int height) {
         setBounds(x, y, width, height);
     }

     /**
      * Resets the bounds of a rectangle to the specified x, y, width and height
      * parameters.
      *
      * @param x
      *            the new X coordinate of the upper left corner.
      * @param y
      *            the new Y coordinate of the upper left corner.
      * @param width
      *            the new width of rectangle.
      * @param height
      *            the new height of rectangle.
      * @deprecated use setBounds(int, int, int, int) method
      */
     @Deprecated
     public void reshape(int x, int y, int width, int height) {
         setBounds(x, y, width, height);
     }

     /**
      * Gets bounds of the rectangle as a new Rectangle object.
      *
      * @return the Rectangle object with the same bounds as the original
      *         rectangle.
      * @see java.awt.geom.RectangularShape#getBounds()
      */
     @Override
     public Rectangle getBounds() {
         return new Rectangle(x, y, width, height);
     }

     /**
      * Gets the bounds of the original rectangle as a Rectangle2D object.
      *
      * @return the Rectangle2D object which represents the bounds of the
      *         original rectangle.
      * @see java.awt.geom.Rectangle2D#getBounds2D()
      */
     @Override
     public Rectangle2D getBounds2D() {
         return getBounds();
     }

     /**
      * Sets the bounds of a rectangle to the specified x, y, width, and height
      * parameters.
      *
      * @param x
      *            the X coordinate of the upper left corner.
      * @param y
      *            the Y coordinate of the upper left corner.
      * @param width
      *            the width of rectangle.
      * @param height
      *            the height of rectangle.
      */
     public void setBounds(int x, int y, int width, int height) {
         this.x = x;
         this.y = y;
         this.height = height;
         this.width = width;
     }

     /**
      * Sets the bounds of the rectangle to match the bounds of the Rectangle
      * object sent as a parameter.
      *
      * @param r
      *            the Rectangle object which specifies the new bounds.
      */
     public void setBounds(Rectangle r) {
         setBounds(r.x, r.y, r.width, r.height);
     }

     /**
      * Enlarges the rectangle by moving each corner outward from the center by a
      * distance of dx horizonally and a distance of dy vertically. Specifically,
      * changes a rectangle with [x, y, width, height] parameters to a rectangle
      * with [x-dx, y-dy, width+2*dx, height+2*dy] parameters.
      *
      * @param dx
      *            the horizontal distance to move each corner coordinate.
      * @param dy
      *            the vertical distance to move each corner coordinate.
      */
     public void grow(int dx, int dy) {
         x -= dx;
         y -= dy;
         width += dx + dx;
         height += dy + dy;
     }

     /**
      * Moves a rectangle a distance of mx along the x coordinate axis and a
      * distance of my along y coordinate axis.
      *
      * @param mx
      *            the horizontal translation increment.
      * @param my
      *            the vertical translation increment.
      */
     public void translate(int mx, int my) {
         x += mx;
         y += my;
     }

     /**
      * Enlarges the rectangle to cover the specified point.
      *
      * @param px
      *            the X coordinate of the new point to be covered by the
      *            rectangle.
      * @param py
      *            the Y coordinate of the new point to be covered by the
      *            rectangle.
      */
     public void add(int px, int py) {
         int x1 = Math.min(x, px);
         int x2 = Math.max(x + width, px);
         int y1 = Math.min(y, py);
         int y2 = Math.max(y + height, py);
         setBounds(x1, y1, x2 - x1, y2 - y1);
     }

     /**
      * Enlarges the rectangle to cover the specified point with the new point
      * given as a Point object.
      *
      * @param p
      *            the Point object that specifies the new point to be covered by
      *            the rectangle.
      */
     public void add(Point p) {
         add(p.x, p.y);
     }

     /**
      * Adds a new rectangle to the original rectangle, the result is an union of
      * the specified specified rectangle and original rectangle.
      *
      * @param r
      *            the Rectangle which is added to the original rectangle.
      */
     public void add(Rectangle r) {
         int x1 = Math.min(x, r.x);
         int x2 = Math.max(x + width, r.x + r.width);
         int y1 = Math.min(y, r.y);
         int y2 = Math.max(y + height, r.y + r.height);
         setBounds(x1, y1, x2 - x1, y2 - y1);
     }

     /**
      * Determines whether or not the point with specified coordinates [px, py]
      * is within the bounds of the rectangle.
      *
      * @param px
      *            the X coordinate of point.
      * @param py
      *            the Y coordinate of point.
      * @return true, if the point with specified coordinates [px, py] is within
      *         the bounds of the rectangle, false otherwise.
      */
     public boolean contains(int px, int py) {
         if (isEmpty()) {
             return false;
         }
         if (px < x || py < y) {
             return false;
         }
         px -= x;
         py -= y;
         return px < width && py < height;
     }

     /**
      * Determines whether or not the point given as a Point object is within the
      * bounds of the rectangle.
      *
      * @param p
      *            the Point object
      * @return true, if the point p is within the bounds of the rectangle,
      *         otherwise false.
      */
     public boolean contains(Point p) {
         return contains(p.x, p.y);
     }

     /**
      * Determines whether or not the rectangle specified by [rx, ry, rw, rh]
      * parameters is located inside the original rectangle.
      *
      * @param rx
      *            the X coordinate of the rectangle to compare.
      * @param ry
      *            the Y coordinate of the rectangle to compare.
      * @param rw
      *            the width of the rectangle to compare.
      * @param rh
      *            the height of the rectangle to compare.
      * @return true, if a rectangle with [rx, ry, rw, rh] parameters is entirely
      *         contained in the original rectangle, false otherwise.
      */
     public boolean contains(int rx, int ry, int rw, int rh) {
         return contains(rx, ry) && contains(rx + rw - 1, ry + rh - 1);
     }

     /**
      * Compares whether or not the rectangle specified by the Rectangle object
      * is located inside the original rectangle.
      *
      * @param r
      *            the Rectangle object.
      * @return true, if the rectangle specified by Rectangle object is entirely
      *         contained in the original rectangle, false otherwise.
      */
     public boolean contains(Rectangle r) {
         return contains(r.x, r.y, r.width, r.height);
     }

     /**
      * Compares whether or not a point with specified coordinates [px, py]
      * belongs to a rectangle.
      *
      * @param px
      *            the X coordinate of a point.
      * @param py
      *            the Y coordinate of a point.
      * @return true, if a point with specified coordinates [px, py] belongs to a
      *         rectangle, otherwise false.
      * @deprecated use contains(int, int) method.
      */
     @Deprecated
     public boolean inside(int px, int py) {
         return contains(px, py);
     }

     /**
      * Returns the intersection of the original rectangle with the specified
      * Rectangle2D.
      *
      * @param r
      *            the Rectangle2D object.
      * @return the Rectangle2D object that is the result of intersecting the
      *         original rectangle with the specified Rectangle2D.
      * @see java.awt.geom.Rectangle2D#createIntersection(java.awt.geom.Rectangle2D)
      */
     @Override
     public Rectangle2D createIntersection(Rectangle2D r) {
         if (r instanceof Rectangle) {
             return intersection((Rectangle)r);
         }
         Rectangle2D dst = new Rectangle2D.Double();
         Rectangle2D.intersect(this, r, dst);
         return dst;
     }

     /**
      * Returns the intersection of the original rectangle with the specified
      * rectangle. An empty rectangle is returned if there is no intersection.
      *
      * @param r
      *            the Rectangle object.
      * @return the Rectangle object is result of the original rectangle with the
      *         specified rectangle.
      */
     public Rectangle intersection(Rectangle r) {
         int x1 = Math.max(x, r.x);
         int y1 = Math.max(y, r.y);
         int x2 = Math.min(x + width, r.x + r.width);
         int y2 = Math.min(y + height, r.y + r.height);
         return new Rectangle(x1, y1, x2 - x1, y2 - y1);
     }

     /**
      * Determines whether or not the original rectangle intersects the specified
      * rectangle.
      *
      * @param r
      *            the Rectangle object.
      * @return true, if the two rectangles overlap, false otherwise.
      */
     public boolean intersects(Rectangle r) {
         return !intersection(r).isEmpty();
     }

     /**
      * Determines where the specified Point is located with respect to the
      * rectangle. This method computes whether the point is to the right or to
      * the left of the rectangle and whether it is above or below the rectangle,
      * and packs the result into an integer by using a binary OR operation with
      * the following masks:
      * <ul>
      *<li>Rectangle2D.OUT_LEFT</li>
      *<li>Rectangle2D.OUT_TOP</li>
      *<li>Rectangle2D.OUT_RIGHT</li>
      *<li>Rectangle2D.OUT_BOTTOM</li>
      *</ul>
      * If the rectangle is empty, all masks are set, and if the point is inside
      * the rectangle, none are set.
      *
      * @param px
      *            the X coordinate of the specified point.
      * @param py
      *            the Y coordinate of the specified point.
      * @return the location of the Point relative to the rectangle as the result
      *         of logical OR operation with all out masks.
      * @see java.awt.geom.Rectangle2D#outcode(double, double)
      */
     @Override
     public int outcode(double px, double py) {
         int code = 0;

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

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

         return code;
     }

     /**
      * Enlarges the rectangle to cover the specified Rectangle2D.
      *
      * @param r
      *            the Rectangle2D object.
      * @return the union of the original and the specified Rectangle2D.
      * @see java.awt.geom.Rectangle2D#createUnion(java.awt.geom.Rectangle2D)
      */
     @Override
     public Rectangle2D createUnion(Rectangle2D r) {
         if (r instanceof Rectangle) {
             return union((Rectangle)r);
         }
         Rectangle2D dst = new Rectangle2D.Double();
         Rectangle2D.union(this, r, dst);
         return dst;
     }

     /**
      * Enlarges the rectangle to cover the specified rectangle.
      *
      * @param r
      *            the Rectangle.
      * @return the union of the original and the specified rectangle.
      */
     public Rectangle union(Rectangle r) {
         Rectangle dst = new Rectangle(this);
         dst.add(r);
         return dst;
     }

     /**
      * Compares the original Rectangle with the specified object.
      *
      * @param obj
      *            the specified Object for comparison.
      * @return true, if the specified Object is a rectangle with the same
      *         dimensions as the original rectangle, false otherwise.
      * @see java.awt.geom.Rectangle2D#equals(Object)
      */
     @Override
     public boolean equals(Object obj) {
         if (obj == this) {
             return true;
         }
         if (obj instanceof Rectangle) {
             Rectangle r = (Rectangle)obj;
             return r.x == x && r.y == y && r.width == width && r.height == height;
         }
         return false;
     }

     /**
      * Returns a string representation of the rectangle; the string contains [x,
      * y, width, height] parameters of the rectangle.
      *
      * @return the string representation of the rectangle.
      */
     @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 Rectangle().toString())
         return getClass().getName() + "[x=" + x + ",y=" + y + //$NON-NLS-1$ //$NON-NLS-2$
                 ",width=" + width + ",height=" + height + "]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
     }

 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	/**
	* @author Denis M. Kishenko
	* @version $Revision$
	*/

	package java.awt;

	import java.awt.geom.Rectangle2D;
	import java.io.Serializable;

	/**
	* The Rectangle class defines the rectangular area in terms of its upper left
	* corner coordinates [x,y], its width, and its height. A Rectangle specified by
	* [x, y, width, height] parameters has an outline path with corners at [x, y],
	* [x + width,y], [x + width,y + height], and [x, y + height]. <br>
	* <br>
	* The rectangle is empty if the width or height is negative or zero. In this
	* case the isEmpty method returns true.
	*
	* @since Android 1.0
	*/
	public class Rectangle extends Rectangle2D implements Shape, Serializable {

	/**
	* The Constant serialVersionUID.
	*/
	private static final long serialVersionUID = -4345857070255674764L;

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

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

	/**
	* The width of rectangle.
	*/
	public int width;

	/**
	* The height of rectangle.
	*/
	public int height;

	/**
	* Instantiates a new rectangle with [0, 0] upper left corner coordinates,
	* the width and the height are zero.
	*/
	public Rectangle() {
	setBounds(0, 0, 0, 0);
	}

	/**
	* Instantiates a new rectangle whose upper left corner coordinates are
	* given by the Point object (p.X and p.Y), and the width and the height are
	* zero.
	*
	* @param p
	* the Point specifies the upper left corner coordinates of the
	* rectangle.
	*/
	public Rectangle(Point p) {
	setBounds(p.x, p.y, 0, 0);
	}

	/**
	* Instantiates a new rectangle whose upper left corner coordinates are
	* given by the Point object (p.X and p.Y), and the width and the height are
	* given by Dimension object (d.width and d.height).
	*
	* @param p
	* the point specifies the upper left corner coordinates of the
	* rectangle.
	* @param d
	* the dimension specifies the width and the height of the
	* rectangle.
	*/
	public Rectangle(Point p, Dimension d) {
	setBounds(p.x, p.y, d.width, d.height);
	}

	/**
	* Instantiates a new rectangle determined by the upper left corner
	* coordinates (x, y), width and height.
	*
	* @param x
	* the X upper left corner coordinate of the rectangle.
	* @param y
	* the Y upper left corner coordinate of the rectangle.
	* @param width
	* the width of rectangle.
	* @param height
	* the height of rectangle.
	*/
	public Rectangle(int x, int y, int width, int height) {
	setBounds(x, y, width, height);
	}

	/**
	* Instantiates a new rectangle with [0, 0] as its upper left corner
	* coordinates and the specified width and height.
	*
	* @param width
	* the width of rectangle.
	* @param height
	* the height of rectangle.
	*/
	public Rectangle(int width, int height) {
	setBounds(0, 0, width, height);
	}

	/**
	* Instantiates a new rectangle with the same coordinates as the given
	* source rectangle.
	*
	* @param r
	* the Rectangle object which parameters will be used for
	* instantiating a new Rectangle.
	*/
	public Rectangle(Rectangle r) {
	setBounds(r.x, r.y, r.width, r.height);
	}

	/*
	* public Rectangle(Dimension d) { setBounds(0, 0, d.width, d.height); }
	*/
	/**
	* Gets the X coordinate of bound as a double.
	*
	* @return the X coordinate of bound as a double.
	* @see java.awt.geom.RectangularShape#getX()
	*/
	@Override
	public double getX() {
	return x;
	}

	/**
	* Gets the Y coordinate of bound as a double.
	*
	* @return the Y coordinate of bound as a double.
	* @see java.awt.geom.RectangularShape#getY()
	*/
	@Override
	public double getY() {
	return y;
	}

	/**
	* Gets the height of the rectangle as a double.
	*
	* @return the height of the rectangle as a double.
	* @see java.awt.geom.RectangularShape#getHeight()
	*/
	@Override
	public double getHeight() {
	return height;
	}

	/**
	* Gets the width of the rectangle as a double.
	*
	* @return the width of the rectangle as a double.
	* @see java.awt.geom.RectangularShape#getWidth()
	*/
	@Override
	public double getWidth() {
	return width;
	}

	/**
	* Determines whether or not the rectangle is empty. The rectangle is empty
	* if its width or height is negative or zero.
	*
	* @return true, if the rectangle is empty, otherwise false.
	* @see java.awt.geom.RectangularShape#isEmpty()
	*/
	@Override
	public boolean isEmpty() {
	return width <= 0 \|\| height <= 0;
	}

	/**
	* Gets the size of a Rectangle as Dimension object.
	*
	* @return a Dimension object which represents size of the rectangle.
	*/
	public Dimension getSize() {
	return new Dimension(width, height);
	}

	/**
	* Sets the size of the Rectangle.
	*
	* @param width
	* the new width of the rectangle.
	* @param height
	* the new height of the rectangle.
	*/
	public void setSize(int width, int height) {
	this.width = width;
	this.height = height;
	}

	/**
	* Sets the size of a Rectangle specified as Dimension object.
	*
	* @param d
	* a Dimension object which represents new size of a rectangle.
	*/
	public void setSize(Dimension d) {
	setSize(d.width, d.height);
	}

	/**
	* Gets the location of a rectangle's upper left corner as a Point object.
	*
	* @return the Point object with coordinates equal to the upper left corner
	* of the rectangle.
	*/
	public Point getLocation() {
	return new Point(x, y);
	}

	/**
	* Sets the location of the rectangle in terms of its upper left corner
	* coordinates X and Y.
	*
	* @param x
	* the X coordinate of the rectangle's upper left corner.
	* @param y
	* the Y coordinate of the rectangle's upper left corner.
	*/
	public void setLocation(int x, int y) {
	this.x = x;
	this.y = y;
	}

	/**
	* Sets the location of a rectangle using a Point object to give the
	* coordinates of the upper left corner.
	*
	* @param p
	* the Point object which represents the new upper left corner
	* coordinates of rectangle.
	*/
	public void setLocation(Point p) {
	setLocation(p.x, p.y);
	}

	/**
	* Moves a rectangle to the new location by moving its upper left corner to
	* the point with coordinates X and Y.
	*
	* @param x
	* the new X coordinate of the rectangle's upper left corner.
	* @param y
	* the new Y coordinate of the rectangle's upper left corner.
	* @deprecated Use setLocation(int, int) method.
	*/
	@Deprecated
	public void move(int x, int y) {
	setLocation(x, y);
	}

	/**
	* Sets the rectangle to be the nearest rectangle with integer coordinates
	* bounding the rectangle defined by the double-valued parameters.
	*
	* @param x
	* the X coordinate of the upper left corner of the double-valued
	* rectangle to be bounded.
	* @param y
	* the Y coordinate of the upper left corner of the double-valued
	* rectangle to be bounded.
	* @param width
	* the width of the rectangle to be bounded.
	* @param height
	* the height of the rectangle to be bounded.
	* @see java.awt.geom.Rectangle2D#setRect(double, double, double, double)
	*/
	@Override
	public void setRect(double x, double y, double width, double height) {
	int x1 = (int)Math.floor(x);
	int y1 = (int)Math.floor(y);
	int x2 = (int)Math.ceil(x + width);
	int y2 = (int)Math.ceil(y + height);
	setBounds(x1, y1, x2 - x1, y2 - y1);
	}

	/**
	* Sets a new size for the rectangle.
	*
	* @param width
	* the rectangle's new width.
	* @param height
	* the rectangle's new height.
	* @deprecated use the setSize(int, int) method.
	*/
	@Deprecated
	public void resize(int width, int height) {
	setBounds(x, y, width, height);
	}

	/**
	* Resets the bounds of a rectangle to the specified x, y, width and height
	* parameters.
	*
	* @param x
	* the new X coordinate of the upper left corner.
	* @param y
	* the new Y coordinate of the upper left corner.
	* @param width
	* the new width of rectangle.
	* @param height
	* the new height of rectangle.
	* @deprecated use setBounds(int, int, int, int) method
	*/
	@Deprecated
	public void reshape(int x, int y, int width, int height) {
	setBounds(x, y, width, height);
	}

	/**
	* Gets bounds of the rectangle as a new Rectangle object.
	*
	* @return the Rectangle object with the same bounds as the original
	* rectangle.
	* @see java.awt.geom.RectangularShape#getBounds()
	*/
	@Override
	public Rectangle getBounds() {
	return new Rectangle(x, y, width, height);
	}

	/**
	* Gets the bounds of the original rectangle as a Rectangle2D object.
	*
	* @return the Rectangle2D object which represents the bounds of the
	* original rectangle.
	* @see java.awt.geom.Rectangle2D#getBounds2D()
	*/
	@Override
	public Rectangle2D getBounds2D() {
	return getBounds();
	}

	/**
	* Sets the bounds of a rectangle to the specified x, y, width, and height
	* parameters.
	*
	* @param x
	* the X coordinate of the upper left corner.
	* @param y
	* the Y coordinate of the upper left corner.
	* @param width
	* the width of rectangle.
	* @param height
	* the height of rectangle.
	*/
	public void setBounds(int x, int y, int width, int height) {
	this.x = x;
	this.y = y;
	this.height = height;
	this.width = width;
	}

	/**
	* Sets the bounds of the rectangle to match the bounds of the Rectangle
	* object sent as a parameter.
	*
	* @param r
	* the Rectangle object which specifies the new bounds.
	*/
	public void setBounds(Rectangle r) {
	setBounds(r.x, r.y, r.width, r.height);
	}

	/**
	* Enlarges the rectangle by moving each corner outward from the center by a
	* distance of dx horizonally and a distance of dy vertically. Specifically,
	* changes a rectangle with [x, y, width, height] parameters to a rectangle
	* with [x-dx, y-dy, width+2dx, height+2dy] parameters.
	*
	* @param dx
	* the horizontal distance to move each corner coordinate.
	* @param dy
	* the vertical distance to move each corner coordinate.
	*/
	public void grow(int dx, int dy) {
	x -= dx;
	y -= dy;
	width += dx + dx;
	height += dy + dy;
	}

	/**
	* Moves a rectangle a distance of mx along the x coordinate axis and a
	* distance of my along y coordinate axis.
	*
	* @param mx
	* the horizontal translation increment.
	* @param my
	* the vertical translation increment.
	*/
	public void translate(int mx, int my) {
	x += mx;
	y += my;
	}

	/**
	* Enlarges the rectangle to cover the specified point.
	*
	* @param px
	* the X coordinate of the new point to be covered by the
	* rectangle.
	* @param py
	* the Y coordinate of the new point to be covered by the
	* rectangle.
	*/
	public void add(int px, int py) {
	int x1 = Math.min(x, px);
	int x2 = Math.max(x + width, px);
	int y1 = Math.min(y, py);
	int y2 = Math.max(y + height, py);
	setBounds(x1, y1, x2 - x1, y2 - y1);
	}

	/**
	* Enlarges the rectangle to cover the specified point with the new point
	* given as a Point object.
	*
	* @param p
	* the Point object that specifies the new point to be covered by
	* the rectangle.
	*/
	public void add(Point p) {
	add(p.x, p.y);
	}

	/**
	* Adds a new rectangle to the original rectangle, the result is an union of
	* the specified specified rectangle and original rectangle.
	*
	* @param r
	* the Rectangle which is added to the original rectangle.
	*/
	public void add(Rectangle r) {
	int x1 = Math.min(x, r.x);
	int x2 = Math.max(x + width, r.x + r.width);
	int y1 = Math.min(y, r.y);
	int y2 = Math.max(y + height, r.y + r.height);
	setBounds(x1, y1, x2 - x1, y2 - y1);
	}

	/**
	* Determines whether or not the point with specified coordinates [px, py]
	* is within the bounds of the rectangle.
	*
	* @param px
	* the X coordinate of point.
	* @param py
	* the Y coordinate of point.
	* @return true, if the point with specified coordinates [px, py] is within
	* the bounds of the rectangle, false otherwise.
	*/
	public boolean contains(int px, int py) {
	if (isEmpty()) {
	return false;
	}
	if (px < x \|\| py < y) {
	return false;
	}
	px -= x;
	py -= y;
	return px < width && py < height;
	}

	/**
	* Determines whether or not the point given as a Point object is within the
	* bounds of the rectangle.
	*
	* @param p
	* the Point object
	* @return true, if the point p is within the bounds of the rectangle,
	* otherwise false.
	*/
	public boolean contains(Point p) {
	return contains(p.x, p.y);
	}

	/**
	* Determines whether or not the rectangle specified by [rx, ry, rw, rh]
	* parameters is located inside the original rectangle.
	*
	* @param rx
	* the X coordinate of the rectangle to compare.
	* @param ry
	* the Y coordinate of the rectangle to compare.
	* @param rw
	* the width of the rectangle to compare.
	* @param rh
	* the height of the rectangle to compare.
	* @return true, if a rectangle with [rx, ry, rw, rh] parameters is entirely
	* contained in the original rectangle, false otherwise.
	*/
	public boolean contains(int rx, int ry, int rw, int rh) {
	return contains(rx, ry) && contains(rx + rw - 1, ry + rh - 1);
	}

	/**
	* Compares whether or not the rectangle specified by the Rectangle object
	* is located inside the original rectangle.
	*
	* @param r
	* the Rectangle object.
	* @return true, if the rectangle specified by Rectangle object is entirely
	* contained in the original rectangle, false otherwise.
	*/
	public boolean contains(Rectangle r) {
	return contains(r.x, r.y, r.width, r.height);
	}

	/**
	* Compares whether or not a point with specified coordinates [px, py]
	* belongs to a rectangle.
	*
	* @param px
	* the X coordinate of a point.
	* @param py
	* the Y coordinate of a point.
	* @return true, if a point with specified coordinates [px, py] belongs to a
	* rectangle, otherwise false.
	* @deprecated use contains(int, int) method.
	*/
	@Deprecated
	public boolean inside(int px, int py) {
	return contains(px, py);
	}

	/**
	* Returns the intersection of the original rectangle with the specified
	* Rectangle2D.
	*
	* @param r
	* the Rectangle2D object.
	* @return the Rectangle2D object that is the result of intersecting the
	* original rectangle with the specified Rectangle2D.
	* @see java.awt.geom.Rectangle2D#createIntersection(java.awt.geom.Rectangle2D)
	*/
	@Override
	public Rectangle2D createIntersection(Rectangle2D r) {
	if (r instanceof Rectangle) {
	return intersection((Rectangle)r);
	}
	Rectangle2D dst = new Rectangle2D.Double();
	Rectangle2D.intersect(this, r, dst);
	return dst;
	}

	/**
	* Returns the intersection of the original rectangle with the specified
	* rectangle. An empty rectangle is returned if there is no intersection.
	*
	* @param r
	* the Rectangle object.
	* @return the Rectangle object is result of the original rectangle with the
	* specified rectangle.
	*/
	public Rectangle intersection(Rectangle r) {
	int x1 = Math.max(x, r.x);
	int y1 = Math.max(y, r.y);
	int x2 = Math.min(x + width, r.x + r.width);
	int y2 = Math.min(y + height, r.y + r.height);
	return new Rectangle(x1, y1, x2 - x1, y2 - y1);
	}

	/**
	* Determines whether or not the original rectangle intersects the specified
	* rectangle.
	*
	* @param r
	* the Rectangle object.
	* @return true, if the two rectangles overlap, false otherwise.
	*/
	public boolean intersects(Rectangle r) {
	return !intersection(r).isEmpty();
	}

	/**
	* Determines where the specified Point is located with respect to the
	* rectangle. This method computes whether the point is to the right or to
	* the left of the rectangle and whether it is above or below the rectangle,
	* and packs the result into an integer by using a binary OR operation with
	* the following masks:
	* <ul>
	*<li>Rectangle2D.OUT_LEFT</li>
	*<li>Rectangle2D.OUT_TOP</li>
	*<li>Rectangle2D.OUT_RIGHT</li>
	*<li>Rectangle2D.OUT_BOTTOM</li>
	*</ul>
	* If the rectangle is empty, all masks are set, and if the point is inside
	* the rectangle, none are set.
	*
	* @param px
	* the X coordinate of the specified point.
	* @param py
	* the Y coordinate of the specified point.
	* @return the location of the Point relative to the rectangle as the result
	* of logical OR operation with all out masks.
	* @see java.awt.geom.Rectangle2D#outcode(double, double)
	*/
	@Override
	public int outcode(double px, double py) {
	int code = 0;

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

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

	return code;
	}

	/**
	* Enlarges the rectangle to cover the specified Rectangle2D.
	*
	* @param r
	* the Rectangle2D object.
	* @return the union of the original and the specified Rectangle2D.
	* @see java.awt.geom.Rectangle2D#createUnion(java.awt.geom.Rectangle2D)
	*/
	@Override
	public Rectangle2D createUnion(Rectangle2D r) {
	if (r instanceof Rectangle) {
	return union((Rectangle)r);
	}
	Rectangle2D dst = new Rectangle2D.Double();
	Rectangle2D.union(this, r, dst);
	return dst;
	}

	/**
	* Enlarges the rectangle to cover the specified rectangle.
	*
	* @param r
	* the Rectangle.
	* @return the union of the original and the specified rectangle.
	*/
	public Rectangle union(Rectangle r) {
	Rectangle dst = new Rectangle(this);
	dst.add(r);
	return dst;
	}

	/**
	* Compares the original Rectangle with the specified object.
	*
	* @param obj
	* the specified Object for comparison.
	* @return true, if the specified Object is a rectangle with the same
	* dimensions as the original rectangle, false otherwise.
	* @see java.awt.geom.Rectangle2D#equals(Object)
	*/
	@Override
	public boolean equals(Object obj) {
	if (obj == this) {
	return true;
	}
	if (obj instanceof Rectangle) {
	Rectangle r = (Rectangle)obj;
	return r.x == x && r.y == y && r.width == width && r.height == height;
	}
	return false;
	}

	/**
	* Returns a string representation of the rectangle; the string contains [x,
	* y, width, height] parameters of the rectangle.
	*
	* @return the string representation of the rectangle.
	*/
	@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 Rectangle().toString())
	return getClass().getName() + "[x=" + x + ",y=" + y + //$NON-NLS-1$ //$NON-NLS-2$
	",width=" + width + ",height=" + height + "]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	}

	}