/*

 * Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved.

 * 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.  Oracle designates this

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

 * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package java.awt.geom;

import java.awt.Shape;

import java.awt.Rectangle;

import java.beans.Transient;

/**

 * <code>RectangularShape</code> is the base class for a number of

 * {@link Shape} objects whose geometry is defined by a rectangular frame.

 * This class does not directly specify any specific geometry by

 * itself, but merely provides manipulation methods inherited by

 * a whole category of <code>Shape</code> objects.

 * The manipulation methods provided by this class can be used to

 * query and modify the rectangular frame, which provides a reference

 * for the subclasses to define their geometry.

 *

 * @author      Jim Graham

 * @since 1.2

 */

public abstract class RectangularShape implements Shape, Cloneable {

    /**

     * This is an abstract class that cannot be instantiated directly.

     *

     * @see Arc2D

     * @see Ellipse2D

     * @see Rectangle2D

     * @see RoundRectangle2D

     * @since 1.2

     */

    protected RectangularShape() {

    }

    /**

     * Returns the X coordinate of the upper-left corner of

     * the framing rectangle in <code>double</code> precision.

     * @return the X coordinate of the upper-left corner of

     * the framing rectangle.

     * @since 1.2

     */

    public abstract double getX();

    /**

     * Returns the Y coordinate of the upper-left corner of

     * the framing rectangle in <code>double</code> precision.

     * @return the Y coordinate of the upper-left corner of

     * the framing rectangle.

     * @since 1.2

     */

    public abstract double getY();

    /**

     * Returns the width of the framing rectangle in

     * <code>double</code> precision.

     * @return the width of the framing rectangle.

     * @since 1.2

     */

    public abstract double getWidth();

    /**

     * Returns the height of the framing rectangle

     * in <code>double</code> precision.

     * @return the height of the framing rectangle.

     * @since 1.2

     */

    public abstract double getHeight();

    /**

     * Returns the smallest X coordinate of the framing

     * rectangle of the <code>Shape</code> in <code>double</code>

     * precision.

     * @return the smallest X coordinate of the framing

     *          rectangle of the <code>Shape</code>.

     * @since 1.2

     */

    public double getMinX() {

        return getX();

    }

    /**

     * Returns the smallest Y coordinate of the framing

     * rectangle of the <code>Shape</code> in <code>double</code>

     * precision.

     * @return the smallest Y coordinate of the framing

     *          rectangle of the <code>Shape</code>.

     * @since 1.2

     */

    public double getMinY() {

        return getY();

    }

    /**

     * Returns the largest X coordinate of the framing

     * rectangle of the <code>Shape</code> in <code>double</code>

     * precision.

     * @return the largest X coordinate of the framing

     *          rectangle of the <code>Shape</code>.

     * @since 1.2

     */

    public double getMaxX() {

        return getX() + getWidth();

    }

    /**

     * Returns the largest Y coordinate of the framing

     * rectangle of the <code>Shape</code> in <code>double</code>

     * precision.

     * @return the largest Y coordinate of the framing

     *          rectangle of the <code>Shape</code>.

     * @since 1.2

     */

    public double getMaxY() {

        return getY() + getHeight();

    }

    /**

     * Returns the X coordinate of the center of the framing

     * rectangle of the <code>Shape</code> in <code>double</code>

     * precision.

     * @return the X coordinate of the center of the framing rectangle

     *          of the <code>Shape</code>.

     * @since 1.2

     */

    public double getCenterX() {

        return getX() + getWidth() / 2.0;

    }

    /**

     * Returns the Y coordinate of the center of the framing

     * rectangle of the <code>Shape</code> in <code>double</code>

     * precision.

     * @return the Y coordinate of the center of the framing rectangle

     *          of the <code>Shape</code>.

     * @since 1.2

     */

    public double getCenterY() {

        return getY() + getHeight() / 2.0;

    }

    /**

     * Returns the framing {@link Rectangle2D}

     * that defines the overall shape of this object.

     * @return a <code>Rectangle2D</code>, specified in

     * <code>double</code> coordinates.

     * @see #setFrame(double, double, double, double)

     * @see #setFrame(Point2D, Dimension2D)

     * @see #setFrame(Rectangle2D)

     * @since 1.2

     */

    @Transient

    public Rectangle2D getFrame() {

        return new Rectangle2D.Double(getX(), getY(), getWidth(), getHeight());

    }

    /**

     * Determines whether the <code>RectangularShape</code> is empty.

     * When the <code>RectangularShape</code> is empty, it encloses no

     * area.

     * @return <code>true</code> if the <code>RectangularShape</code> is empty;

     *          <code>false</code> otherwise.

     * @since 1.2

     */

    public abstract boolean isEmpty();

    /**

     * Sets the location and size of the framing rectangle of this

     * <code>Shape</code> to the specified rectangular values.

     *

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

     *          specified rectangular shape

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

     *          specified rectangular shape

     * @param w the width of the specified rectangular shape

     * @param h the height of the specified rectangular shape

     * @see #getFrame

     * @since 1.2

     */

    public abstract void setFrame(double x, double y, double w, double h);

    /**

     * Sets the location and size of the framing rectangle of this

     * <code>Shape</code> to the specified {@link Point2D} and

     * {@link Dimension2D}, respectively.  The framing rectangle is used

     * by the subclasses of <code>RectangularShape</code> to define

     * their geometry.

     * @param loc the specified <code>Point2D</code>

     * @param size the specified <code>Dimension2D</code>

     * @see #getFrame

     * @since 1.2

     */

    public void setFrame(Point2D loc, Dimension2D size) {

        setFrame(loc.getX(), loc.getY(), size.getWidth(), size.getHeight());

    }

    /**

     * Sets the framing rectangle of this <code>Shape</code> to

     * be the specified <code>Rectangle2D</code>.  The framing rectangle is

     * used by the subclasses of <code>RectangularShape</code> to define

     * their geometry.

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

     * @see #getFrame

     * @since 1.2

     */

    public void setFrame(Rectangle2D r) {

        setFrame(r.getX(), r.getY(), r.getWidth(), r.getHeight());

    }

    /**

     * Sets the diagonal of the framing rectangle of this <code>Shape</code>

     * based on the two specified coordinates.  The framing rectangle is

     * used by the subclasses of <code>RectangularShape</code> to define

     * their geometry.

     *

     * @param x1 the X coordinate of the start point of the specified diagonal

     * @param y1 the Y coordinate of the start point of the specified diagonal

     * @param x2 the X coordinate of the end point of the specified diagonal

     * @param y2 the Y coordinate of the end point of the specified diagonal

     * @since 1.2

     */

    public void setFrameFromDiagonal(double x1, double y1,

                                     double x2, double y2) {

        if (x2 < x1) {

            double t = x1;

            x1 = x2;

            x2 = t;

        }

        if (y2 < y1) {

            double t = y1;

            y1 = y2;

            y2 = t;

        }

        setFrame(x1, y1, x2 - x1, y2 - y1);

    }

    /**

     * Sets the diagonal of the framing rectangle of this <code>Shape</code>

     * based on two specified <code>Point2D</code> objects.  The framing

     * rectangle is used by the subclasses of <code>RectangularShape</code>

     * to define their geometry.

     *

     * @param p1 the start <code>Point2D</code> of the specified diagonal

     * @param p2 the end <code>Point2D</code> of the specified diagonal

     * @since 1.2

     */

    public void setFrameFromDiagonal(Point2D p1, Point2D p2) {

        setFrameFromDiagonal(p1.getX(), p1.getY(), p2.getX(), p2.getY());

    }

    /**

     * Sets the framing rectangle of this <code>Shape</code>

     * based on the specified center point coordinates and corner point

     * coordinates.  The framing rectangle is used by the subclasses of

     * <code>RectangularShape</code> to define their geometry.

     *

     * @param centerX the X coordinate of the specified center point

     * @param centerY the Y coordinate of the specified center point

     * @param cornerX the X coordinate of the specified corner point

     * @param cornerY the Y coordinate of the specified corner point

     * @since 1.2

     */

    public void setFrameFromCenter(double centerX, double centerY,

                                   double cornerX, double cornerY) {

        double halfW = Math.abs(cornerX - centerX);

        double halfH = Math.abs(cornerY - centerY);

        setFrame(centerX - halfW, centerY - halfH, halfW * 2.0, halfH * 2.0);

    }

    /**

     * Sets the framing rectangle of this <code>Shape</code> based on a

     * specified center <code>Point2D</code> and corner

     * <code>Point2D</code>.  The framing rectangle is used by the subclasses

     * of <code>RectangularShape</code> to define their geometry.

     * @param center the specified center <code>Point2D</code>

     * @param corner the specified corner <code>Point2D</code>

     * @since 1.2

     */

    public void setFrameFromCenter(Point2D center, Point2D corner) {

        setFrameFromCenter(center.getX(), center.getY(),

                           corner.getX(), corner.getY());

    }

    /**

     * {@inheritDoc}

     * @since 1.2

     */

    public boolean contains(Point2D p) {

        return contains(p.getX(), p.getY());

    }

    /**

     * {@inheritDoc}

     * @since 1.2

     */

    public boolean intersects(Rectangle2D r) {

        return intersects(r.getX(), r.getY(), r.getWidth(), r.getHeight());

    }

    /**

     * {@inheritDoc}

     * @since 1.2

     */

    public boolean contains(Rectangle2D r) {

        return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight());

    }

    /**

     * {@inheritDoc}

     * @since 1.2

     */

    public Rectangle getBounds() {

        double width = getWidth();

        double height = getHeight();

        if (width < 0 || height < 0) {

            return new Rectangle();

        }

        double x = getX();

        double y = getY();

        double x1 = Math.floor(x);

        double y1 = Math.floor(y);

        double x2 = Math.ceil(x + width);

        double y2 = Math.ceil(y + height);

        return new Rectangle((int) x1, (int) y1,

                                      (int) (x2 - x1), (int) (y2 - y1));

    }

    /**

     * Returns an iterator object that iterates along the

     * <code>Shape</code> object's boundary and provides access to a

     * flattened view of the outline of the <code>Shape</code>

     * object's geometry.

     * <p>

     * Only SEG_MOVETO, SEG_LINETO, and SEG_CLOSE point types will

     * be returned by the iterator.

     * <p>

     * The amount of subdivision of the curved segments is controlled

     * by the <code>flatness</code> parameter, which specifies the

     * maximum distance that any point on the unflattened transformed

     * curve can deviate from the returned flattened path segments.

     * An optional {@link AffineTransform} can

     * be specified so that the coordinates returned in the iteration are

     * transformed accordingly.

     * @param at an optional <code>AffineTransform</code> to be applied to the

     *          coordinates as they are returned in the iteration,

     *          or <code>null</code> if untransformed coordinates are desired.

     * @param flatness the maximum distance that the line segments used to

     *          approximate the curved segments are allowed to deviate

     *          from any point on the original curve

     * @return a <code>PathIterator</code> object that provides access to

     *          the <code>Shape</code> object's flattened geometry.

     * @since 1.2

     */

    public PathIterator getPathIterator(AffineTransform at, double flatness) {

        return new FlatteningPathIterator(getPathIterator(at), flatness);

    }

    /**

     * Creates a new object of the same class and with the same

     * contents as this object.

     * @return     a clone of this instance.

     * @exception  OutOfMemoryError            if there is not enough memory.

     * @see        java.lang.Cloneable

     * @since      1.2

     */

    public Object clone() {

        try {

            return super.clone();

        } catch (CloneNotSupportedException e) {

            // this shouldn't happen, since we are Cloneable

        }

    }

}