mirror of git://gcc.gnu.org/git/gcc.git
585 lines
16 KiB
Java
585 lines
16 KiB
Java
/* RoundRectangle2D.java -- represents a rectangle with rounded corners
|
|
Copyright (C) 2000, 2002, 2003, 2004, 2006, 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;
|
|
|
|
|
|
|
|
/** 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. The arc height and width
|
|
* control the roundness of the corners of the rectangle.
|
|
*
|
|
* @return The arc height.
|
|
*
|
|
* @see #getArcWidth()
|
|
*/
|
|
public abstract double getArcHeight();
|
|
|
|
/**
|
|
* Return the arc width of this round rectangle. The arc width and height
|
|
* control the roundness of the corners of the rectangle.
|
|
*
|
|
* @return The arc width.
|
|
*
|
|
* @see #getArcHeight()
|
|
*/
|
|
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)
|
|
{
|
|
double arcW = Math.min(getArcWidth(), getWidth());
|
|
double arcH = Math.min(getArcHeight(), getHeight());
|
|
|
|
// check for special cases...
|
|
if (arcW <= 0 || arcH <= 0)
|
|
{
|
|
Rectangle2D r = new Rectangle2D.Double(getX(), getY(), getWidth(),
|
|
getHeight());
|
|
return r.getPathIterator(at);
|
|
}
|
|
else if (arcW >= getWidth() && arcH >= getHeight())
|
|
{
|
|
Ellipse2D e = new Ellipse2D.Double(getX(), getY(), getWidth(),
|
|
getHeight());
|
|
return e.getPathIterator(at);
|
|
}
|
|
|
|
// otherwise return the standard case...
|
|
return new PathIterator()
|
|
{
|
|
double x = getX();
|
|
double y = getY();
|
|
double w = getWidth();
|
|
double h = getHeight();
|
|
double arcW = Math.min(getArcWidth(), w);
|
|
double arcH = Math.min(getArcHeight(), h);
|
|
Arc2D.Double arc = new Arc2D.Double();
|
|
PathIterator corner;
|
|
int step = -1;
|
|
|
|
public int currentSegment(double[] coords)
|
|
{
|
|
if (corner != null) // steps 1, 3, 5 and 7
|
|
{
|
|
int r = corner.currentSegment(coords);
|
|
if (r == SEG_MOVETO)
|
|
r = SEG_LINETO;
|
|
return r;
|
|
}
|
|
if (step == -1)
|
|
{
|
|
// move to the start position
|
|
coords[0] = x + w - arcW / 2;
|
|
coords[1] = y;
|
|
}
|
|
else if (step == 0)
|
|
{
|
|
// top line
|
|
coords[0] = x + arcW / 2;
|
|
coords[1] = y;
|
|
}
|
|
else if (step == 2)
|
|
{
|
|
// left line
|
|
coords[0] = x;
|
|
coords[1] = y + h - arcH / 2;
|
|
}
|
|
else if (step == 4)
|
|
{
|
|
// bottom line
|
|
coords[0] = x + w - arcW / 2;
|
|
coords[1] = y + h;
|
|
}
|
|
else if (step == 6)
|
|
{
|
|
// right line
|
|
coords[0] = x + w;
|
|
coords[1] = y + arcH / 2;
|
|
}
|
|
if (at != null)
|
|
at.transform(coords, 0, coords, 0, 1);
|
|
return step == -1 ? SEG_MOVETO : SEG_LINETO;
|
|
}
|
|
|
|
public int currentSegment(float[] coords) {
|
|
if (corner != null) // steps 1, 3, 5 and 7
|
|
{
|
|
int r = corner.currentSegment(coords);
|
|
if (r == SEG_MOVETO)
|
|
r = SEG_LINETO;
|
|
return r;
|
|
}
|
|
if (step == -1)
|
|
{
|
|
// move to the start position
|
|
coords[0] = (float) (x + w - arcW / 2);
|
|
coords[1] = (float) y;
|
|
}
|
|
else if (step == 0)
|
|
{
|
|
// top line
|
|
coords[0] = (float) (x + arcW / 2);
|
|
coords[1] = (float) y;
|
|
}
|
|
else if (step == 2)
|
|
{
|
|
// left line
|
|
coords[0] = (float) x;
|
|
coords[1] = (float) (y + h - arcH / 2);
|
|
}
|
|
else if (step == 4)
|
|
{
|
|
// bottom line
|
|
coords[0] = (float) (x + w - arcW / 2);
|
|
coords[1] = (float) (y + h);
|
|
}
|
|
else if (step == 6)
|
|
{
|
|
// right line
|
|
coords[0] = (float) (x + w);
|
|
coords[1] = (float) (y + arcH / 2);
|
|
}
|
|
if (at != null)
|
|
at.transform(coords, 0, coords, 0, 1);
|
|
return step == -1 ? SEG_MOVETO : SEG_LINETO;
|
|
}
|
|
|
|
public int getWindingRule() {
|
|
return WIND_NON_ZERO;
|
|
}
|
|
|
|
public boolean isDone() {
|
|
return step >= 8;
|
|
}
|
|
|
|
public void next()
|
|
{
|
|
if (corner != null)
|
|
{
|
|
corner.next();
|
|
if (corner.isDone())
|
|
{
|
|
corner = null;
|
|
step++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
step++;
|
|
if (step == 1)
|
|
{
|
|
// create top left corner
|
|
arc.setArc(x, y, arcW, arcH, 90, 90, Arc2D.OPEN);
|
|
corner = arc.getPathIterator(at);
|
|
}
|
|
else if (step == 3)
|
|
{
|
|
// create bottom left corner
|
|
arc.setArc(x, y + h - arcH, arcW, arcH, 180, 90,
|
|
Arc2D.OPEN);
|
|
corner = arc.getPathIterator(at);
|
|
}
|
|
else if (step == 5)
|
|
{
|
|
// create bottom right corner
|
|
arc.setArc(x + w - arcW, y + h - arcH, arcW, arcH, 270, 90,
|
|
Arc2D.OPEN);
|
|
corner = arc.getPathIterator(at);
|
|
}
|
|
else if (step == 7)
|
|
{
|
|
// create top right corner
|
|
arc.setArc(x + w - arcW, y, arcW, arcH, 0, 90, Arc2D.OPEN);
|
|
corner = arc.getPathIterator(at);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
/**
|
|
* Sets the dimensions for this rounded rectangle.
|
|
*
|
|
* @param x the x-coordinate of the top left corner.
|
|
* @param y the y-coordinate of the top left corner.
|
|
* @param w the width of the rectangle.
|
|
* @param h the height of the rectangle.
|
|
* @param arcWidth the arc width.
|
|
* @param arcHeight the arc height.
|
|
*
|
|
* @see #setRoundRect(double, double, double, double, double, double)
|
|
*/
|
|
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
|