/* RoundRectangle2D.java -- represents a rectangle with rounded corners
   Copyright (C) 2000, 2002, 2003, 2004 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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 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.util.NoSuchElementException;


/** This class implements a rectangle with rounded corners.
 * @author Tom Tromey (tromey@cygnus.com)
 * @date December 3, 2000
 */
public abstract class RoundRectangle2D extends RectangularShape
{
  /** Return the arc height of this round rectangle.  */
  public abstract double getArcHeight();

  /** Return the arc width of this round rectangle.  */
  public abstract double getArcWidth();

  /** Set the values of this round rectangle
   * @param x The x coordinate
   * @param y The y coordinate
   * @param w The width
   * @param h The height
   * @param arcWidth The arc width
   * @param arcHeight The arc height
   */
  public abstract void setRoundRect(double x, double y, double w, double h,
                                    double arcWidth, double arcHeight);

  /** Create a RoundRectangle2D.  This is protected because this class
   * is abstract and cannot be instantiated.
   */
  protected RoundRectangle2D()
  {
  }

  /** Return true if this object contains the specified point.
   * @param x The x coordinate
   * @param y The y coordinate
   */
  public boolean contains(double x, double y)
  {
    double mx = getX();
    double mw = getWidth();
    if (x < mx || x >= mx + mw)
      return false;
    double my = getY();
    double mh = getHeight();
    if (y < my || y >= my + mh)
      return false;

    // Now check to see if the point is in range of an arc.
    double dy = Math.min(Math.abs(my - y), Math.abs(my + mh - y));
    double dx = Math.min(Math.abs(mx - x), Math.abs(mx + mw - x));

    // The arc dimensions are that of the corresponding ellipse
    // thus a 90 degree segment is half of that.
    double aw = getArcWidth() / 2.0;
    double ah = getArcHeight() / 2.0;
    if (dx > aw || dy > ah)
      return true;

    // At this point DX represents the distance from the nearest edge
    // of the rectangle.  But we want to transform it to represent the
    // scaled distance from the center of the ellipse that forms the
    // arc.  Hence this code:
    dy = (ah - dy) / ah;
    dx = (aw - dx) / aw;

    return dx * dx + dy * dy <= 1.0;
  }

  /** Return true if this object contains the specified rectangle
   * @param x The x coordinate
   * @param y The y coordinate
   * @param w The width
   * @param h The height
   */
  public boolean contains(double x, double y, double w, double h)
  {
    // We have to check all four points here (for ordinary rectangles
    // we can just check opposing corners).
    return (contains(x, y) && contains(x, y + h) && contains(x + w, y + h)
           && contains(x + w, y));
  }

  /** Return a new path iterator which iterates over this rectangle.
   * @param at An affine transform to apply to the object
   */
  public PathIterator getPathIterator(final AffineTransform at)
  {
    final double minx = getX();
    final double miny = getY();
    final double maxx = minx + getWidth();
    final double maxy = miny + getHeight();
    final double arcwidth = getArcWidth();
    final double archeight = getArcHeight();
    return new PathIterator()
      {
	/** We iterate counterclockwise around the rectangle, starting in the
	 * upper right.  This variable tracks our current point, which
	 * can be on either side of a given corner.  */
	private int current = 0;

	/** Child path iterator, used for corners.  */
	private PathIterator corner;

	/** This is used when rendering the corners.  We re-use the arc
	 * for each corner.  */
	private Arc2D arc = new Arc2D.Double();

	/** Temporary array used by getPoint.  */
	private double[] temp = new double[2];

	public int getWindingRule()
	{
	  return WIND_NON_ZERO;
	}

	public boolean isDone()
	{
	  return current > 9;
	}

	private void getPoint(int val)
	{
	  switch (val)
	    {
	    case 0:
	    case 8:
	      temp[0] = maxx;
	      temp[1] = miny + archeight;
	      break;
	    case 7:
	      temp[0] = maxx;
	      temp[1] = maxy - archeight;
	      break;
	    case 6:
	      temp[0] = maxx - arcwidth;
	      temp[1] = maxy;
	      break;
	    case 5:
	      temp[0] = minx + arcwidth;
	      temp[1] = maxy;
	      break;
	    case 4:
	      temp[0] = minx;
	      temp[1] = maxy - archeight;
	      break;
	    case 3:
	      temp[0] = minx;
	      temp[1] = miny + archeight;
	      break;
	    case 2:
	      temp[0] = minx + arcwidth;
	      temp[1] = miny;
	      break;
	    case 1:
	      temp[0] = maxx - arcwidth;
	      temp[1] = miny;
	      break;
	    }
	}

	public void next()
	{
	  if (current >= 8)
	    ++current;
	  else if (corner != null)
	    {
	      // We're iterating through the corner.  Work on the child
	      // iterator; if it finishes, reset and move to the next
	      // point along the rectangle.
	      corner.next();
	      if (corner.isDone())
	        {
		  corner = null;
		  ++current;
	        }
	    }
	  else
	    {
	      // Make an arc between this point on the rectangle and
	      // the next one, and then iterate over this arc.
	      getPoint(current);
	      double x1 = temp[0];
	      double y1 = temp[1];
	      getPoint(current + 1);
	      Rectangle2D.Double r = new Rectangle2D.Double(Math.min(x1,
	                                                             temp[0]),
	                                                    Math.min(y1,
	                                                             temp[1]),
	                                                    Math.abs(x1
	                                                             - temp[0]),
	                                                    Math.abs(y1
	                                                             - temp[1]));
	      arc.setArc(r, (current >> 1) * 90.0, 90.0, Arc2D.OPEN);
	      corner = arc.getPathIterator(at);
	    }
	}

	public int currentSegment(float[] coords)
	{
	  if (corner != null)
	    {
	      int r = corner.currentSegment(coords);
	      if (r == SEG_MOVETO)
		r = SEG_LINETO;
	      return r;
	    }

	  if (current < 9)
	    {
	      getPoint(current);
	      coords[0] = (float) temp[0];
	      coords[1] = (float) temp[1];
	    }
	  else if (current == 9)
	    return SEG_CLOSE;
	  else
	    throw new NoSuchElementException("rect iterator out of bounds");

	  if (at != null)
	    at.transform(coords, 0, coords, 0, 1);
	  return current == 0 ? SEG_MOVETO : SEG_LINETO;
	}

	public int currentSegment(double[] coords)
	{
	  if (corner != null)
	    {
	      int r = corner.currentSegment(coords);
	      if (r == SEG_MOVETO)
		r = SEG_LINETO;
	      return r;
	    }

	  if (current < 9)
	    {
	      getPoint(current);
	      coords[0] = temp[0];
	      coords[1] = temp[1];
	    }
	  else if (current == 9)
	    return SEG_CLOSE;
	  else
	    throw new NoSuchElementException("rect iterator out of bounds");

	  if (at != null)
	    at.transform(coords, 0, coords, 0, 1);
	  return current == 0 ? SEG_MOVETO : SEG_LINETO;
	}
      };
  }

  /** Return true if the given rectangle intersects this shape.
   * @param x The x coordinate
   * @param y The y coordinate
   * @param w The width
   * @param h The height
   */
  public boolean intersects(double x, double y, double w, double h)
  {
    // Check if any corner is within the rectangle
    return (contains(x, y) || contains(x, y + h) || contains(x + w, y + h)
           || contains(x + w, y));
  }

  /** Set the boundary of this round rectangle.
   * @param x The x coordinate
   * @param y The y coordinate
   * @param w The width
   * @param h The height
   */
  public void setFrame(double x, double y, double w, double h)
  {
    // This is a bit lame.
    setRoundRect(x, y, w, h, getArcWidth(), getArcHeight());
  }

  /** Set the values of this round rectangle to be the same as those
   * of the argument.
   * @param rr The round rectangle to copy
   */
  public void setRoundRect(RoundRectangle2D rr)
  {
    setRoundRect(rr.getX(), rr.getY(), rr.getWidth(), rr.getHeight(),
                 rr.getArcWidth(), rr.getArcHeight());
  }

  /** A subclass of RoundRectangle which keeps its parameters as
   * doubles.  */
  public static class Double extends RoundRectangle2D
  {
    /** The height of the corner arc.  */
    public double archeight;

    /** The width of the corner arc.  */
    public double arcwidth;

    /** The x coordinate of this object.  */
    public double x;

    /** The y coordinate of this object.  */
    public double y;

    /** The width of this object.  */
    public double width;

    /** The height of this object.  */
    public double height;

    /** Construct a new instance, with all parameters set to 0.  */
    public Double()
    {
    }

    /** Construct a new instance with the given arguments.
     * @param x The x coordinate
     * @param y The y coordinate
     * @param w The width
     * @param h The height
     * @param arcWidth The arc width
     * @param arcHeight The arc height
     */
    public Double(double x, double y, double w, double h, double arcWidth,
                  double arcHeight)
    {
      this.x = x;
      this.y = y;
      this.width = w;
      this.height = h;
      this.arcwidth = arcWidth;
      this.archeight = arcHeight;
    }

    public double getArcHeight()
    {
      return archeight;
    }

    public double getArcWidth()
    {
      return arcwidth;
    }

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

    public double getX()
    {
      return x;
    }

    public double getY()
    {
      return y;
    }

    public double getWidth()
    {
      return width;
    }

    public double getHeight()
    {
      return height;
    }

    public boolean isEmpty()
    {
      return width <= 0 || height <= 0;
    }

    public void setRoundRect(double x, double y, double w, double h,
                             double arcWidth, double arcHeight)
    {
      this.x = x;
      this.y = y;
      this.width = w;
      this.height = h;
      this.arcwidth = arcWidth;
      this.archeight = arcHeight;
    }
  } // class Double

  /** A subclass of RoundRectangle which keeps its parameters as
   * floats.  */
  public static class Float extends RoundRectangle2D
  {
    /** The height of the corner arc.  */
    public float archeight;

    /** The width of the corner arc.  */
    public float arcwidth;

    /** The x coordinate of this object.  */
    public float x;

    /** The y coordinate of this object.  */
    public float y;

    /** The width of this object.  */
    public float width;

    /** The height of this object.  */
    public float height;

    /** Construct a new instance, with all parameters set to 0.  */
    public Float()
    {
    }

    /** Construct a new instance with the given arguments.
     * @param x The x coordinate
     * @param y The y coordinate
     * @param w The width
     * @param h The height
     * @param arcWidth The arc width
     * @param arcHeight The arc height
     */
    public Float(float x, float y, float w, float h, float arcWidth,
                 float arcHeight)
    {
      this.x = x;
      this.y = y;
      this.width = w;
      this.height = h;
      this.arcwidth = arcWidth;
      this.archeight = arcHeight;
    }

    public double getArcHeight()
    {
      return archeight;
    }

    public double getArcWidth()
    {
      return arcwidth;
    }

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

    public double getX()
    {
      return x;
    }

    public double getY()
    {
      return y;
    }

    public double getWidth()
    {
      return width;
    }

    public double getHeight()
    {
      return height;
    }

    public boolean isEmpty()
    {
      return width <= 0 || height <= 0;
    }

    public void setRoundRect(float x, float y, float w, float h,
                             float arcWidth, float arcHeight)
    {
      this.x = x;
      this.y = y;
      this.width = w;
      this.height = h;
      this.arcwidth = arcWidth;
      this.archeight = arcHeight;
    }

    public void setRoundRect(double x, double y, double w, double h,
                             double arcWidth, double arcHeight)
    {
      this.x = (float) x;
      this.y = (float) y;
      this.width = (float) w;
      this.height = (float) h;
      this.arcwidth = (float) arcWidth;
      this.archeight = (float) arcHeight;
    }
  } // class Float
} // class RoundRectangle2D