1: /* RectangularShape.java -- a rectangular frame for several generic shapes 2: Copyright (C) 2000, 2002 Free Software Foundation 3: 4: This file is part of GNU Classpath. 5: 6: GNU Classpath is free software; you can redistribute it and/or modify 7: it under the terms of the GNU General Public License as published by 8: the Free Software Foundation; either version 2, or (at your option) 9: any later version. 10: 11: GNU Classpath is distributed in the hope that it will be useful, but 12: WITHOUT ANY WARRANTY; without even the implied warranty of 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14: General Public License for more details. 15: 16: You should have received a copy of the GNU General Public License 17: along with GNU Classpath; see the file COPYING. If not, write to the 18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19: 02110-1301 USA. 20: 21: Linking this library statically or dynamically with other modules is 22: making a combined work based on this library. Thus, the terms and 23: conditions of the GNU General Public License cover the whole 24: combination. 25: 26: As a special exception, the copyright holders of this library give you 27: permission to link this library with independent modules to produce an 28: executable, regardless of the license terms of these independent 29: modules, and to copy and distribute the resulting executable under 30: terms of your choice, provided that you also meet, for each linked 31: independent module, the terms and conditions of the license of that 32: module. An independent module is a module which is not derived from 33: or based on this library. If you modify this library, you may extend 34: this exception to your version of the library, but you are not 35: obligated to do so. If you do not wish to do so, delete this 36: exception statement from your version. */ 37: 38: 39: package java.awt.geom; 40: 41: import java.awt.Rectangle; 42: import java.awt.Shape; 43: 44: /** 45: * This class provides a generic framework, and several helper methods, for 46: * subclasses which represent geometric objects inside a rectangular frame. 47: * This does not specify any geometry except for the bounding box. 48: * 49: * @author Tom Tromey (tromey@cygnus.com) 50: * @author Eric Blake (ebb9@email.byu.edu) 51: * @since 1.2 52: * @see Arc2D 53: * @see Ellipse2D 54: * @see Rectangle2D 55: * @see RoundRectangle2D 56: * @status updated to 1.4 57: */ 58: public abstract class RectangularShape implements Shape, Cloneable 59: { 60: /** 61: * Default constructor. 62: */ 63: protected RectangularShape() 64: { 65: } 66: 67: /** 68: * Get the x coordinate of the upper-left corner of the framing rectangle. 69: * 70: * @return the x coordinate 71: */ 72: public abstract double getX(); 73: 74: /** 75: * Get the y coordinate of the upper-left corner of the framing rectangle. 76: * 77: * @return the y coordinate 78: */ 79: public abstract double getY(); 80: 81: /** 82: * Get the width of the framing rectangle. 83: * 84: * @return the width 85: */ 86: public abstract double getWidth(); 87: 88: /** 89: * Get the height of the framing rectangle. 90: * 91: * @return the height 92: */ 93: public abstract double getHeight(); 94: 95: /** 96: * Get the minimum x coordinate in the frame. This is misnamed, or else 97: * Sun has a bug, because the implementation returns getX() even when 98: * getWidth() is negative. 99: * 100: * @return the minimum x coordinate 101: */ 102: public double getMinX() 103: { 104: return getX(); 105: } 106: 107: /** 108: * Get the minimum y coordinate in the frame. This is misnamed, or else 109: * Sun has a bug, because the implementation returns getY() even when 110: * getHeight() is negative. 111: * 112: * @return the minimum y coordinate 113: */ 114: public double getMinY() 115: { 116: return getY(); 117: } 118: 119: /** 120: * Get the maximum x coordinate in the frame. This is misnamed, or else 121: * Sun has a bug, because the implementation returns getX()+getWidth() even 122: * when getWidth() is negative. 123: * 124: * @return the maximum x coordinate 125: */ 126: public double getMaxX() 127: { 128: return getX() + getWidth(); 129: } 130: 131: /** 132: * Get the maximum y coordinate in the frame. This is misnamed, or else 133: * Sun has a bug, because the implementation returns getY()+getHeight() even 134: * when getHeight() is negative. 135: * 136: * @return the maximum y coordinate 137: */ 138: public double getMaxY() 139: { 140: return getY() + getHeight(); 141: } 142: 143: /** 144: * Return the x coordinate of the center point of the framing rectangle. 145: * 146: * @return the central x coordinate 147: */ 148: public double getCenterX() 149: { 150: return getX() + getWidth() / 2; 151: } 152: 153: /** 154: * Return the y coordinate of the center point of the framing rectangle. 155: * 156: * @return the central y coordinate 157: */ 158: public double getCenterY() 159: { 160: return getY() + getHeight() / 2; 161: } 162: 163: /** 164: * Return the frame around this object. Note that this may be a looser 165: * bounding box than getBounds2D. 166: * 167: * @return the frame, in double precision 168: * @see #setFrame(double, double, double, double) 169: */ 170: public Rectangle2D getFrame() 171: { 172: return new Rectangle2D.Double(getX(), getY(), getWidth(), getHeight()); 173: } 174: 175: /** 176: * Test if the shape is empty, meaning that no points are inside it. 177: * 178: * @return true if the shape is empty 179: */ 180: public abstract boolean isEmpty(); 181: 182: /** 183: * Set the framing rectangle of this shape to the given coordinate and size. 184: * 185: * @param x the new x coordinate 186: * @param y the new y coordinate 187: * @param w the new width 188: * @param h the new height 189: * @see #getFrame() 190: */ 191: public abstract void setFrame(double x, double y, double w, double h); 192: 193: /** 194: * Set the framing rectangle of this shape to the given coordinate and size. 195: * 196: * @param p the new point 197: * @param d the new dimension 198: * @throws NullPointerException if p or d is null 199: * @see #getFrame() 200: */ 201: public void setFrame(Point2D p, Dimension2D d) 202: { 203: setFrame(p.getX(), p.getY(), d.getWidth(), d.getHeight()); 204: } 205: 206: /** 207: * Set the framing rectangle of this shape to the given rectangle. 208: * 209: * @param r the new framing rectangle 210: * @throws NullPointerException if r is null 211: * @see #getFrame() 212: */ 213: public void setFrame(Rectangle2D r) 214: { 215: setFrame(r.getX(), r.getY(), r.getWidth(), r.getHeight()); 216: } 217: 218: /** 219: * Set the framing rectangle of this shape using two points on a diagonal. 220: * The area will be positive. 221: * 222: * @param x1 the first x coordinate 223: * @param y1 the first y coordinate 224: * @param x2 the second x coordinate 225: * @param y2 the second y coordinate 226: */ 227: public void setFrameFromDiagonal(double x1, double y1, double x2, double y2) 228: { 229: if (x1 > x2) 230: { 231: double t = x2; 232: x2 = x1; 233: x1 = t; 234: } 235: if (y1 > y2) 236: { 237: double t = y2; 238: y2 = y1; 239: y1 = t; 240: } 241: setFrame(x1, y1, x2 - x1, y2 - y1); 242: } 243: 244: /** 245: * Set the framing rectangle of this shape using two points on a diagonal. 246: * The area will be positive. 247: * 248: * @param p1 the first point 249: * @param p2 the second point 250: * @throws NullPointerException if either point is null 251: */ 252: public void setFrameFromDiagonal(Point2D p1, Point2D p2) 253: { 254: setFrameFromDiagonal(p1.getX(), p1.getY(), p2.getX(), p2.getY()); 255: } 256: 257: /** 258: * Set the framing rectangle of this shape using the center of the frame, 259: * and one of the four corners. The area will be positive. 260: * 261: * @param centerX the x coordinate at the center 262: * @param centerY the y coordinate at the center 263: * @param cornerX the x coordinate at a corner 264: * @param cornerY the y coordinate at a corner 265: */ 266: public void setFrameFromCenter(double centerX, double centerY, 267: double cornerX, double cornerY) 268: { 269: double halfw = Math.abs(cornerX - centerX); 270: double halfh = Math.abs(cornerY - centerY); 271: setFrame(centerX - halfw, centerY - halfh, halfw + halfw, halfh + halfh); 272: } 273: 274: /** 275: * Set the framing rectangle of this shape using the center of the frame, 276: * and one of the four corners. The area will be positive. 277: * 278: * @param center the center point 279: * @param corner a corner point 280: * @throws NullPointerException if either point is null 281: */ 282: public void setFrameFromCenter(Point2D center, Point2D corner) 283: { 284: setFrameFromCenter(center.getX(), center.getY(), 285: corner.getX(), corner.getY()); 286: } 287: 288: /** 289: * Tests if a point is inside the boundary of the shape. 290: * 291: * @param p the point to test 292: * @return true if the point is inside the shape 293: * @throws NullPointerException if p is null 294: * @see #contains(double, double) 295: */ 296: public boolean contains(Point2D p) 297: { 298: return contains(p.getX(), p.getY()); 299: } 300: 301: /** 302: * Tests if a rectangle and this shape share common internal points. 303: * 304: * @param r the rectangle to test 305: * @return true if the rectangle intersects this shpae 306: * @throws NullPointerException if r is null 307: * @see #intersects(double, double, double, double) 308: */ 309: public boolean intersects(Rectangle2D r) 310: { 311: return intersects(r.getX(), r.getY(), r.getWidth(), r.getHeight()); 312: } 313: 314: /** 315: * Tests if the shape completely contains the given rectangle. 316: * 317: * @param r the rectangle to test 318: * @return true if r is contained in this shape 319: * @throws NullPointerException if r is null 320: * @see #contains(double, double, double, double) 321: */ 322: public boolean contains(Rectangle2D r) 323: { 324: return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight()); 325: } 326: 327: /** 328: * Returns a bounding box for this shape, in integer format. Notice that you 329: * may get a tighter bound with getBounds2D. 330: * 331: * @return a bounding box 332: */ 333: public Rectangle getBounds() 334: { 335: double x = getX(); 336: double y = getY(); 337: double maxx = Math.ceil(x + getWidth()); 338: double maxy = Math.ceil(y + getHeight()); 339: x = Math.floor(x); 340: y = Math.floor(y); 341: return new Rectangle((int) x, (int) y, (int) (maxx - x), (int) (maxy - y)); 342: } 343: 344: /** 345: * Return an iterator along the shape boundary. If the optional transform 346: * is provided, the iterator is transformed accordingly. The path is 347: * flattened until all segments differ from the curve by at most the value 348: * of the flatness parameter, within the limits of the default interpolation 349: * recursion limit of 1024 segments between actual points. Each call 350: * returns a new object, independent from others in use. The result is 351: * threadsafe if and only if the iterator returned by 352: * {@link #getPathIterator(AffineTransform)} is as well. 353: * 354: * @param at an optional transform to apply to the iterator 355: * @param flatness the desired flatness 356: * @return a new iterator over the boundary 357: * @throws IllegalArgumentException if flatness is invalid 358: * @since 1.2 359: */ 360: public PathIterator getPathIterator(AffineTransform at, double flatness) 361: { 362: return new FlatteningPathIterator(getPathIterator(at), flatness); 363: } 364: 365: /** 366: * Create a new shape of the same run-time type with the same contents as 367: * this one. 368: * 369: * @return the clone 370: */ 371: public Object clone() 372: { 373: try 374: { 375: return super.clone(); 376: } 377: catch (CloneNotSupportedException e) 378: { 379: throw (Error) new InternalError().initCause(e); // Impossible 380: } 381: } 382: } // class RectangularShape