/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package java.awt;

import java.awt.geom.Rectangle2D;

/**

 * A <code>Rectangle</code> specifies an area in a coordinate space that is

 * enclosed by the <code>Rectangle</code> object's upper-left point

 * {@code (x,y)}

 * in the coordinate space, its width, and its height.

 * <p>

 * A <code>Rectangle</code> object's <code>width</code> and

 * <code>height</code> are <code>public</code> fields. The constructors

 * that create a <code>Rectangle</code>, and the methods that can modify

 * one, do not prevent setting a negative value for width or height.

 * <p>

 * <a name="Empty">

 * A {@code Rectangle} whose width or height is exactly zero has location

 * along those axes with zero dimension, but is otherwise considered empty.

 * The {@link #isEmpty} method will return true for such a {@code Rectangle}.

 * Methods which test if an empty {@code Rectangle} contains or intersects

 * a point or rectangle will always return false if either dimension is zero.

 * Methods which combine such a {@code Rectangle} with a point or rectangle

 * will include the location of the {@code Rectangle} on that axis in the

 * result as if the {@link #add(Point)} method were being called.

 * </a>

 * <p>

 * <a name="NonExistant">

 * A {@code Rectangle} whose width or height is negative has neither

 * location nor dimension along those axes with negative dimensions.

 * Such a {@code Rectangle} is treated as non-existant along those axes.

 * Such a {@code Rectangle} is also empty with respect to containment

 * calculations and methods which test if it contains or intersects a

 * point or rectangle will always return false.

 * Methods which combine such a {@code Rectangle} with a point or rectangle

 * will ignore the {@code Rectangle} entirely in generating the result.

 * If two {@code Rectangle} objects are combined and each has a negative

 * dimension, the result will have at least one negative dimension.

 * </a>

 * <p>

 * Methods which affect only the location of a {@code Rectangle} will

 * operate on its location regardless of whether or not it has a negative

 * or zero dimension along either axis.

 * <p>

 * Note that a {@code Rectangle} constructed with the default no-argument

 * constructor will have dimensions of {@code 0x0} and therefore be empty.

 * That {@code Rectangle} will still have a location of {@code (0,0)} and

 * will contribute that location to the union and add operations.

 * Code attempting to accumulate the bounds of a set of points should

 * therefore initially construct the {@code Rectangle} with a specifically

 * negative width and height or it should use the first point in the set

 * to construct the {@code Rectangle}.

 * For example:

 * <pre>

 *     Rectangle bounds = new Rectangle(0, 0, -1, -1);

 *     for (int i = 0; i < points.length; i++) {

 *         bounds.add(points[i]);

 *     }

 * </pre>

 * or if we know that the points array contains at least one point:

 * <pre>

 *     Rectangle bounds = new Rectangle(points[0]);

 *     for (int i = 1; i < points.length; i++) {

 *         bounds.add(points[i]);

 *     }

 * </pre>

 * <p>

 * This class uses 32-bit integers to store its location and dimensions.

 * Frequently operations may produce a result that exceeds the range of

 * a 32-bit integer.

 * The methods will calculate their results in a way that avoids any

 * 32-bit overflow for intermediate results and then choose the best

 * representation to store the final results back into the 32-bit fields

 * which hold the location and dimensions.

 * The location of the result will be stored into the {@link #x} and

 * {@link #y} fields by clipping the true result to the nearest 32-bit value.

 * The values stored into the {@link #width} and {@link #height} dimension

 * fields will be chosen as the 32-bit values that encompass the largest

 * part of the true result as possible.

 * Generally this means that the dimension will be clipped independently

 * to the range of 32-bit integers except that if the location had to be

 * moved to store it into its pair of 32-bit fields then the dimensions

 * will be adjusted relative to the "best representation" of the location.

 * If the true result had a negative dimension and was therefore

 * non-existant along one or both axes, the stored dimensions will be

 * negative numbers in those axes.

 * If the true result had a location that could be represented within

 * the range of 32-bit integers, but zero dimension along one or both

 * axes, then the stored dimensions will be zero in those axes.

 *

 * @author      Sami Shaio

 * @since 1.0

 */

public class Rectangle extends Rectangle2D

    implements Shape, java.io.Serializable

{

    /**

     * The X coordinate of the upper-left corner of the <code>Rectangle</code>.

     *

     * @serial

     * @see #setLocation(int, int)

     * @see #getLocation()

     * @since 1.0

     */

    public int x;

    /**

     * The Y coordinate of the upper-left corner of the <code>Rectangle</code>.

     *

     * @serial

     * @see #setLocation(int, int)

     * @see #getLocation()

     * @since 1.0

     */

    public int y;

    /**

     * The width of the <code>Rectangle</code>.

     * @serial

     * @see #setSize(int, int)

     * @see #getSize()

     * @since 1.0

     */

    public int width;

    /**

     * The height of the <code>Rectangle</code>.

     *

     * @serial

     * @see #setSize(int, int)

     * @see #getSize()

     * @since 1.0

     */

    public int height;

    /*

     * JDK 1.1 serialVersionUID

     */

     private static final long serialVersionUID = -4345857070255674764L;

    /**

     * Initialize JNI field and method IDs

     */

    private static native void initIDs();

    static {

        /* ensure that the necessary native libraries are loaded */

        Toolkit.loadLibraries();

        if (!GraphicsEnvironment.isHeadless()) {

            initIDs();

        }

    }

    /**

     * Constructs a new <code>Rectangle</code> whose upper-left corner

     * is at (0, 0) in the coordinate space, and whose width and

     * height are both zero.

     */

    public Rectangle() {

        this(0, 0, 0, 0);

    }

    /**

     * Constructs a new <code>Rectangle</code>, initialized to match

     * the values of the specified <code>Rectangle</code>.

     * @param r  the <code>Rectangle</code> from which to copy initial values

     *           to a newly constructed <code>Rectangle</code>

     * @since 1.1

     */

    public Rectangle(Rectangle r) {

        this(r.x, r.y, r.width, r.height);

    }

    /**

     * Constructs a new <code>Rectangle</code> whose upper-left corner is

     * specified as

     * {@code (x,y)} and whose width and height

     * are specified by the arguments of the same name.

     * @param     x the specified X coordinate

     * @param     y the specified Y coordinate

     * @param     width    the width of the <code>Rectangle</code>

     * @param     height   the height of the <code>Rectangle</code>

     * @since 1.0

     */

    public Rectangle(int x, int y, int width, int height) {

        this.x = x;

        this.y = y;

        this.width = width;

        this.height = height;

    }

    /**

     * Constructs a new <code>Rectangle</code> whose upper-left corner

     * is at (0, 0) in the coordinate space, and whose width and

     * height are specified by the arguments of the same name.

     * @param width the width of the <code>Rectangle</code>

     * @param height the height of the <code>Rectangle</code>

     */

    public Rectangle(int width, int height) {

        this(0, 0, width, height);

    }

    /**

     * Constructs a new <code>Rectangle</code> whose upper-left corner is

     * specified by the {@link Point} argument, and

     * whose width and height are specified by the

     * {@link Dimension} argument.

     * @param p a <code>Point</code> that is the upper-left corner of

     * the <code>Rectangle</code>

     * @param d a <code>Dimension</code>, representing the

     * width and height of the <code>Rectangle</code>

     */

    public Rectangle(Point p, Dimension d) {

        this(p.x, p.y, d.width, d.height);

    }

    /**

     * Constructs a new <code>Rectangle</code> whose upper-left corner is the

     * specified <code>Point</code>, and whose width and height are both zero.

     * @param p a <code>Point</code> that is the top left corner

     * of the <code>Rectangle</code>

     */

    public Rectangle(Point p) {

        this(p.x, p.y, 0, 0);

    }

    /**

     * Constructs a new <code>Rectangle</code> whose top left corner is

     * (0, 0) and whose width and height are specified

     * by the <code>Dimension</code> argument.

     * @param d a <code>Dimension</code>, specifying width and height

     */

    public Rectangle(Dimension d) {

        this(0, 0, d.width, d.height);

    }

    /**

     * Returns the X coordinate of the bounding <code>Rectangle</code> in

     * <code>double</code> precision.

     * @return the X coordinate of the bounding <code>Rectangle</code>.

     */

    public double getX() {

        return x;

    }

    /**

     * Returns the Y coordinate of the bounding <code>Rectangle</code> in

     * <code>double</code> precision.

     * @return the Y coordinate of the bounding <code>Rectangle</code>.

     */

    public double getY() {

        return y;

    }

    /**

     * Returns the width of the bounding <code>Rectangle</code> in

     * <code>double</code> precision.

     * @return the width of the bounding <code>Rectangle</code>.

     */

    public double getWidth() {

        return width;

    }

    /**

     * Returns the height of the bounding <code>Rectangle</code> in

     * <code>double</code> precision.

     * @return the height of the bounding <code>Rectangle</code>.

     */

    public double getHeight() {

        return height;

    }

    /**

     * Gets the bounding <code>Rectangle</code> of this <code>Rectangle</code>.

     * <p>

     * This method is included for completeness, to parallel the

     * <code>getBounds</code> method of

     * {@link Component}.

     * @return    a new <code>Rectangle</code>, equal to the

     * bounding <code>Rectangle</code> for this <code>Rectangle</code>.

     * @see       java.awt.Component#getBounds

     * @see       #setBounds(Rectangle)

     * @see       #setBounds(int, int, int, int)

     * @since     1.1

     */

    public Rectangle getBounds() {

        return new Rectangle(x, y, width, height);

    }

    /**

     * {@inheritDoc}

     * @since 1.2

     */

    public Rectangle2D getBounds2D() {

        return new Rectangle(x, y, width, height);

    }

    /**

     * Sets the bounding <code>Rectangle</code> of this <code>Rectangle</code>

     * to match the specified <code>Rectangle</code>.

     * <p>

     * This method is included for completeness, to parallel the

     * <code>setBounds</code> method of <code>Component</code>.

     * @param r the specified <code>Rectangle</code>

     * @see       #getBounds

     * @see       java.awt.Component#setBounds(java.awt.Rectangle)

     * @since     1.1

     */

    public void setBounds(Rectangle r) {

        setBounds(r.x, r.y, r.width, r.height);

    }

    /**

     * Sets the bounding <code>Rectangle</code> of this

     * <code>Rectangle</code> to the specified

     * <code>x</code>, <code>y</code>, <code>width</code>,

     * and <code>height</code>.

     * <p>

     * This method is included for completeness, to parallel the

     * <code>setBounds</code> method of <code>Component</code>.

     * @param x the new X coordinate for the upper-left

     *                    corner of this <code>Rectangle</code>

     * @param y the new Y coordinate for the upper-left

     *                    corner of this <code>Rectangle</code>

     * @param width the new width for this <code>Rectangle</code>

     * @param height the new height for this <code>Rectangle</code>

     * @see       #getBounds

     * @see       java.awt.Component#setBounds(int, int, int, int)

     * @since     1.1

     */

    public void setBounds(int x, int y, int width, int height) {

        reshape(x, y, width, height);

    }

    /**

     * Sets the bounds of this {@code Rectangle} to the integer bounds

     * which encompass the specified {@code x}, {@code y}, {@code width},

     * and {@code height}.

     * If the parameters specify a {@code Rectangle} that exceeds the

     * maximum range of integers, the result will be the best

     * representation of the specified {@code Rectangle} intersected

     * with the maximum integer bounds.

     * @param x the X coordinate of the upper-left corner of

     *                  the specified rectangle

     * @param y the Y coordinate of the upper-left corner of

     *                  the specified rectangle

     * @param width the width of the specified rectangle

     * @param height the new height of the specified rectangle

     */

    public void setRect(double x, double y, double width, double height) {

        int newx, newy, neww, newh;

        if (x > 2.0 * Integer.MAX_VALUE) {

            // Too far in positive X direction to represent...

            // We cannot even reach the left side of the specified

            // rectangle even with both x & width set to MAX_VALUE.

            // The intersection with the "maximal integer rectangle"

            // is non-existant so we should use a width < 0.

            // REMIND: Should we try to determine a more "meaningful"

            // adjusted value for neww than just "-1"?

            newx = Integer.MAX_VALUE;

            neww = -1;

        } else {

            newx = clip(x, false);

            if (width >= 0) width += x-newx;

            neww = clip(width, width >= 0);

        }

        if (y > 2.0 * Integer.MAX_VALUE) {

            // Too far in positive Y direction to represent...

            newy = Integer.MAX_VALUE;

            newh = -1;

        } else {

            newy = clip(y, false);

            if (height >= 0) height += y-newy;

            newh = clip(height, height >= 0);

        }

        reshape(newx, newy, neww, newh);

    }

    // Return best integer representation for v, clipped to integer

    // range and floor-ed or ceiling-ed, depending on the boolean.

    private static int clip(double v, boolean doceil) {

        if (v <= Integer.MIN_VALUE) {

            return Integer.MIN_VALUE;

        }

        if (v >= Integer.MAX_VALUE) {

            return Integer.MAX_VALUE;

        }

        return (int) (doceil ? Math.ceil(v) : Math.floor(v));

    }

    /**

     * Sets the bounding <code>Rectangle</code> of this

     * <code>Rectangle</code> to the specified

     * <code>x</code>, <code>y</code>, <code>width</code>,

     * and <code>height</code>.

     * <p>

     * @param x the new X coordinate for the upper-left

     *                    corner of this <code>Rectangle</code>

     * @param y the new Y coordinate for the upper-left

     *                    corner of this <code>Rectangle</code>

     * @param width the new width for this <code>Rectangle</code>

     * @param height the new height for this <code>Rectangle</code>

     * @deprecated As of JDK version 1.1,

     * replaced by <code>setBounds(int, int, int, int)</code>.

     */

    @Deprecated

    public void reshape(int x, int y, int width, int height) {

        this.x = x;

        this.y = y;

        this.width = width;

        this.height = height;

    }

    /**

     * Returns the location of this <code>Rectangle</code>.

     * <p>

     * This method is included for completeness, to parallel the

     * <code>getLocation</code> method of <code>Component</code>.

     * @return the <code>Point</code> that is the upper-left corner of

     *                  this <code>Rectangle</code>.

     * @see       java.awt.Component#getLocation

     * @see       #setLocation(Point)

     * @see       #setLocation(int, int)

     * @since     1.1

     */

    public Point getLocation() {

        return new Point(x, y);

    }

    /**

     * Moves this <code>Rectangle</code> to the specified location.

     * <p>

     * This method is included for completeness, to parallel the

     * <code>setLocation</code> method of <code>Component</code>.

     * @param p the <code>Point</code> specifying the new location

     *                for this <code>Rectangle</code>

     * @see       java.awt.Component#setLocation(java.awt.Point)

     * @see       #getLocation

     * @since     1.1

     */

    public void setLocation(Point p) {

        setLocation(p.x, p.y);

    }

    /**

     * Moves this <code>Rectangle</code> to the specified location.

     * <p>

     * This method is included for completeness, to parallel the

     * <code>setLocation</code> method of <code>Component</code>.

     * @param x the X coordinate of the new location

     * @param y the Y coordinate of the new location

     * @see       #getLocation

     * @see       java.awt.Component#setLocation(int, int)

     * @since     1.1

     */

    public void setLocation(int x, int y) {

        move(x, y);

    }

    /**

     * Moves this <code>Rectangle</code> to the specified location.

     * <p>

     * @param x the X coordinate of the new location

     * @param y the Y coordinate of the new location

     * @deprecated As of JDK version 1.1,

     * replaced by <code>setLocation(int, int)</code>.

     */

    @Deprecated

    public void move(int x, int y) {

        this.x = x;

        this.y = y;

    }

    /**

     * Translates this <code>Rectangle</code> the indicated distance,

     * to the right along the X coordinate axis, and

     * downward along the Y coordinate axis.

     * @param dx the distance to move this <code>Rectangle</code>

     *                 along the X axis

     * @param dy the distance to move this <code>Rectangle</code>

     *                 along the Y axis

     * @see       java.awt.Rectangle#setLocation(int, int)

     * @see       java.awt.Rectangle#setLocation(java.awt.Point)

     */

    public void translate(int dx, int dy) {

        int oldv = this.x;

        int newv = oldv + dx;

        if (dx < 0) {

            // moving leftward

            if (newv > oldv) {

                // negative overflow

                // Only adjust width if it was valid (>= 0).

                if (width >= 0) {

                    // The right edge is now conceptually at

                    // newv+width, but we may move newv to prevent

                    // overflow.  But we want the right edge to

                    // remain at its new location in spite of the

                    // clipping.  Think of the following adjustment

                    // conceptually the same as: