/* RectangularShape.java -- a rectangular frame for several generic shapes
   Copyright (C) 2000, 2002 Free Software Foundation

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Classpath 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 for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */


package java.awt.geom;

import java.awt.Rectangle;
import java.awt.Shape;

/**
 * This class provides a generic framework, and several helper methods, for
 * subclasses which represent geometric objects inside a rectangular frame.
 * This does not specify any geometry except for the bounding box.
 *
 * @author Tom Tromey <tromey@cygnus.com>
 * @author Eric Blake <ebb9@email.byu.edu>
 * @since 1.2
 * @see Arc2D
 * @see Ellipse2D
 * @see Rectangle2D
 * @see RoundRectangle2D
 * @status updated to 1.4
 */
public abstract class RectangularShape implements Shape, Cloneable
{
  /**
   * Default constructor.
   */
  protected RectangularShape()
  {
  }

  /**
   * Get the x coordinate of the upper-left corner of the framing rectangle.
   *
   * @return the x coordinate
   */
  public abstract double getX();

  /**
   * Get the y coordinate of the upper-left corner of the framing rectangle.
   *
   * @return the y coordinate
   */
  public abstract double getY();

  /**
   * Get the width of the framing rectangle.
   *
   * @return the width
   */
  public abstract double getWidth();

  /**
   * Get the height of the framing rectangle.
   *
   * @return the height
   */
  public abstract double getHeight();

  /**
   * Get the minimum x coordinate in the frame. This is misnamed, or else
   * Sun has a bug, because the implementation returns getX() even when
   * getWidth() is negative.
   *
   * @return the minimum x coordinate
   */
  public double getMinX()
  {
    return getX();
  }

  /**
   * Get the minimum y coordinate in the frame. This is misnamed, or else
   * Sun has a bug, because the implementation returns getY() even when
   * getHeight() is negative.
   *
   * @return the minimum y coordinate
   */
  public double getMinY()
  {
    return getY();
  }

  /**
   * Get the maximum x coordinate in the frame. This is misnamed, or else
   * Sun has a bug, because the implementation returns getX()+getWidth() even
   * when getWidth() is negative.
   *
   * @return the maximum x coordinate
   */
  public double getMaxX()
  {
    return getX() + getWidth();
  }

  /**
   * Get the maximum y coordinate in the frame. This is misnamed, or else
   * Sun has a bug, because the implementation returns getY()+getHeight() even
   * when getHeight() is negative.
   *
   * @return the maximum y coordinate
   */
  public double getMaxY()
  {
    return getY() + getHeight();
  }

  /**
   * Return the x coordinate of the center point of the framing rectangle.
   *
   * @return the central x coordinate
   */
  public double getCenterX()
  {
    return getX() + getWidth() / 2;
  }

  /**
   * Return the y coordinate of the center point of the framing rectangle.
   *
   * @return the central y coordinate
   */
  public double getCenterY()
  {
    return getY() + getHeight() / 2;
  }

  /**
   * Return the frame around this object. Note that this may be a looser
   * bounding box than getBounds2D.
   *
   * @return the frame, in double precision
   * @see #setFrame(double, double, double, double)
   */
  public Rectangle2D getFrame()
  {
    return new Rectangle2D.Double(getX(), getY(), getWidth(), getHeight());
  }

  /**
   * Test if the shape is empty, meaning that no points are inside it.
   *
   * @return true if the shape is empty
   */
  public abstract boolean isEmpty();

  /**
   * Set the framing rectangle of this shape to the given coordinate and size.
   *
   * @param x the new x coordinate
   * @param y the new y coordinate
   * @param w the new width
   * @param h the new height
   * @see #getFrame()
   */
  public abstract void setFrame(double x, double y, double w, double h);

  /**
   * Set the framing rectangle of this shape to the given coordinate and size.
   *
   * @param p the new point
   * @param d the new dimension
   * @throws NullPointerException if p or d is null
   * @see #getFrame()
   */
  public void setFrame(Point2D p, Dimension2D d)
  {
    setFrame(p.getX(), p.getY(), d.getWidth(), d.getHeight());
  }

  /**
   * Set the framing rectangle of this shape to the given rectangle.
   *
   * @param r the new framing rectangle
   * @throws NullPointerException if r is null
   * @see #getFrame()
   */
  public void setFrame(Rectangle2D r)
  {
    setFrame(r.getX(), r.getY(), r.getWidth(), r.getHeight());
  }

  /**
   * Set the framing rectangle of this shape using two points on a diagonal.
   * The area will be positive.
   *
   * @param x1 the first x coordinate
   * @param y1 the first y coordinate
   * @param x2 the second x coordinate
   * @param y2 the second y coordinate
   */
  public void setFrameFromDiagonal(double x1, double y1, double x2, double y2)
  {
    if (x1 > x2)
      {
	double t = x2;
	x2 = x1;
	x1 = t;
      }
    if (y1 > y2)
      {
	double t = y2;
	y2 = y1;
	y1 = t;
      }
    setFrame(x1, y1, x2 - x1, y2 - y1);
  }

  /**
   * Set the framing rectangle of this shape using two points on a diagonal.
   * The area will be positive.
   *
   * @param p1 the first point
   * @param p2 the second point
   * @throws NullPointerException if either point is null
   */
  public void setFrameFromDiagonal(Point2D p1, Point2D p2)
  {
    setFrameFromDiagonal(p1.getX(), p1.getY(), p2.getX(), p2.getY());
  }

  /**
   * Set the framing rectangle of this shape using the center of the frame,
   * and one of the four corners. The area will be positive.
   *
   * @param centerX the x coordinate at the center
   * @param centerY the y coordinate at the center
   * @param cornerX the x coordinate at a corner
   * @param cornerY the y coordinate at a corner
   */
  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 + halfw, halfh + halfh);
  }

  /**
   * Set the framing rectangle of this shape using the center of the frame,
   * and one of the four corners. The area will be positive.
   *
   * @param center the center point
   * @param corner a corner point
   * @throws NullPointerException if either point is null
   */
  public void setFrameFromCenter(Point2D center, Point2D corner)
  {
    setFrameFromCenter(center.getX(), center.getY(),
                       corner.getX(), corner.getY());
  }

  /**
   * Tests if a point is inside the boundary of the shape.
   *
   * @param p the point to test
   * @return true if the point is inside the shape
   * @throws NullPointerException if p is null
   * @see #contains(double, double)
   */
  public boolean contains(Point2D p)
  {
    return contains(p.getX(), p.getY());
  }

  /**
   * Tests if a rectangle and this shape share common internal points.
   *
   * @param r the rectangle to test
   * @return true if the rectangle intersects this shpae
   * @throws NullPointerException if r is null
   * @see #intersects(double, double, double, double)
   */
  public boolean intersects(Rectangle2D r)
  {
    return intersects(r.getX(), r.getY(), r.getWidth(), r.getHeight());
  }

  /**
   * Tests if the shape completely contains the given rectangle.
   *
   * @param r the rectangle to test
   * @return true if r is contained in this shape
   * @throws NullPointerException if r is null
   * @see #contains(double, double, double, double)
   */
  public boolean contains(Rectangle2D r)
  {
    return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight());
  }

  /**
   * Returns a bounding box for this shape, in integer format. Notice that you
   * may get a tighter bound with getBounds2D. If the frame is empty, the
   * box is the default empty box at the origin.
   *
   * @return a bounding box
   */
  public Rectangle getBounds()
  {
    if (isEmpty())
      return new Rectangle();
    double x = getX();
    double y = getY();
    double maxx = Math.ceil(x + getWidth());
    double maxy = Math.ceil(y + getHeight());
    x = Math.floor(x);
    y = Math.floor(y);
    return new Rectangle((int) x, (int) y, (int) (maxx - x), (int) (maxy - y));
  }

  /**
   * Return an iterator along the shape boundary. If the optional transform
   * is provided, the iterator is transformed accordingly. The path is
   * flattened until all segments differ from the curve by at most the value
   * of the flatness parameter, within the limits of the default interpolation
   * recursion limit of 1024 segments between actual points. Each call
   * returns a new object, independent from others in use. The result is
   * threadsafe if and only if the iterator returned by
   * {@link #getPathIterator(AffineTransform)} is as well.
   *
   * @param transform an optional transform to apply to the iterator
   * @param flatness the desired flatness
   * @return a new iterator over the boundary
   * @throws IllegalArgumentException if flatness is invalid
   * @since 1.2
   */
  public PathIterator getPathIterator(AffineTransform at, double flatness)
  {
    return new FlatteningPathIterator(getPathIterator(at), flatness);
  }

  /**
   * Create a new shape of the same run-time type with the same contents as
   * this one.
   *
   * @return the clone
   */
  public Object clone()
  {
    try
      {
        return super.clone();
      }
    catch (CloneNotSupportedException e)
      {
        throw (Error) new InternalError().initCause(e); // Impossible
      }
  }
} // class RectangularShape