| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| /** |
| * @author Denis M. Kishenko |
| * @version $Revision$ |
| */ |
| |
| package java.awt.geom; |
| |
| import java.awt.Rectangle; |
| import java.awt.Shape; |
| |
| /** |
| * The Class RectangularShape represents a Shape whose data is (at least |
| * partially) described by a rectangular frame. This includes shapes which are |
| * obviously rectangular (such as Rectangle2D) as well as shapes like Arc2D |
| * which are largely determined by the rectangle they fit inside. |
| * |
| * @since Android 1.0 |
| */ |
| public abstract class RectangularShape implements Shape, Cloneable { |
| |
| /** |
| * Instantiates a new rectangular shape. |
| */ |
| protected RectangularShape() { |
| } |
| |
| /** |
| * Gets the x coordinate of the upper left corner of the rectangle. |
| * |
| * @return the x coordinate of the upper left corner of the rectangle. |
| */ |
| public abstract double getX(); |
| |
| /** |
| * Gets the y coordinate of the upper left corner of the rectangle. |
| * |
| * @return the y coordinate of the upper left corner of the rectangle. |
| */ |
| public abstract double getY(); |
| |
| /** |
| * Gets the width of the rectangle. |
| * |
| * @return the width of the rectangle. |
| */ |
| public abstract double getWidth(); |
| |
| /** |
| * Gets the height of the rectangle. |
| * |
| * @return the height of the rectangle. |
| */ |
| public abstract double getHeight(); |
| |
| /** |
| * Checks if this is an empty rectangle: one with zero as its width or |
| * height. |
| * |
| * @return true, if the width or height is empty. |
| */ |
| public abstract boolean isEmpty(); |
| |
| /** |
| * Sets the data for the bounding rectangle in terms of double values. |
| * |
| * @param x |
| * the x coordinate of the upper left corner of the rectangle. |
| * @param y |
| * the y coordinate of the upper left corner of the rectangle. |
| * @param w |
| * the width of the rectangle. |
| * @param h |
| * the height of the rectangle. |
| */ |
| public abstract void setFrame(double x, double y, double w, double h); |
| |
| /** |
| * Gets the minimum x value of the bounding rectangle (the x coordinate of |
| * the upper left corner of the rectangle). |
| * |
| * @return the minimum x value of the bounding rectangle. |
| */ |
| public double getMinX() { |
| return getX(); |
| } |
| |
| /** |
| * Gets the minimum y value of the bounding rectangle (the y coordinate of |
| * the upper left corner of the rectangle). |
| * |
| * @return the minimum y value of the bounding rectangle. |
| */ |
| public double getMinY() { |
| return getY(); |
| } |
| |
| /** |
| * Gets the maximum x value of the bounding rectangle (the x coordinate of |
| * the upper left corner of the rectangle plus the rectangle's width). |
| * |
| * @return the maximum x value of the bounding rectangle. |
| */ |
| public double getMaxX() { |
| return getX() + getWidth(); |
| } |
| |
| /** |
| * Gets the maximum y value of the bounding rectangle (the y coordinate of |
| * the upper left corner of the rectangle plus the rectangle's height). |
| * |
| * @return the maximum y value of the bounding rectangle. |
| */ |
| public double getMaxY() { |
| return getY() + getHeight(); |
| } |
| |
| /** |
| * Gets the x coordinate of the center of the rectangle. |
| * |
| * @return the x coordinate of the center of the rectangle. |
| */ |
| public double getCenterX() { |
| return getX() + getWidth() / 2.0; |
| } |
| |
| /** |
| * Gets the y coordinate of the center of the rectangle. |
| * |
| * @return the y coordinate of the center of the rectangle. |
| */ |
| public double getCenterY() { |
| return getY() + getHeight() / 2.0; |
| } |
| |
| /** |
| * Places the rectangle's size and location data in a new Rectangle2D object |
| * and returns it. |
| * |
| * @return the bounding rectangle as a new Rectangle2D object. |
| */ |
| public Rectangle2D getFrame() { |
| return new Rectangle2D.Double(getX(), getY(), getWidth(), getHeight()); |
| } |
| |
| /** |
| * Sets the bounding rectangle in terms of a Point2D which gives its upper |
| * left corner and a Dimension2D object giving its width and height. |
| * |
| * @param loc |
| * the new upper left corner coordinate. |
| * @param size |
| * the new size dimensions. |
| */ |
| public void setFrame(Point2D loc, Dimension2D size) { |
| setFrame(loc.getX(), loc.getY(), size.getWidth(), size.getHeight()); |
| } |
| |
| /** |
| * Sets the bounding rectangle to match the data contained in the specified |
| * Rectangle2D. |
| * |
| * @param r |
| * the rectangle that gives the new frame data. |
| */ |
| public void setFrame(Rectangle2D r) { |
| setFrame(r.getX(), r.getY(), r.getWidth(), r.getHeight()); |
| } |
| |
| /** |
| * Sets the framing rectangle given two opposite corners. Any two corners |
| * may be used in any order as long as they are diagonally opposite one |
| * another. |
| * |
| * @param x1 |
| * the x coordinate of one of the corner points. |
| * @param y1 |
| * the y coordinate of one of the corner points. |
| * @param x2 |
| * the x coordinate of the other corner point. |
| * @param y2 |
| * the y coordinate of the other corner point. |
| */ |
| public void setFrameFromDiagonal(double x1, double y1, double x2, double y2) { |
| double rx, ry, rw, rh; |
| if (x1 < x2) { |
| rx = x1; |
| rw = x2 - x1; |
| } else { |
| rx = x2; |
| rw = x1 - x2; |
| } |
| if (y1 < y2) { |
| ry = y1; |
| rh = y2 - y1; |
| } else { |
| ry = y2; |
| rh = y1 - y2; |
| } |
| setFrame(rx, ry, rw, rh); |
| } |
| |
| /** |
| * Sets the framing rectangle given two opposite corners. Any two corners |
| * may be used in any order as long as they are diagonally opposite one |
| * another. |
| * |
| * @param p1 |
| * one of the corner points. |
| * @param p2 |
| * the other corner point. |
| */ |
| public void setFrameFromDiagonal(Point2D p1, Point2D p2) { |
| setFrameFromDiagonal(p1.getX(), p1.getY(), p2.getX(), p2.getY()); |
| } |
| |
| /** |
| * Sets the framing rectangle given the center point and one corner. Any |
| * corner may be used. |
| * |
| * @param centerX |
| * the x coordinate of the center point. |
| * @param centerY |
| * the y coordinate of the center point. |
| * @param cornerX |
| * the x coordinate of one of the corner points. |
| * @param cornerY |
| * the y coordinate of one of the corner points. |
| */ |
| public void setFrameFromCenter(double centerX, double centerY, double cornerX, double cornerY) { |
| double width = Math.abs(cornerX - centerX); |
| double height = Math.abs(cornerY - centerY); |
| setFrame(centerX - width, centerY - height, width * 2.0, height * 2.0); |
| } |
| |
| /** |
| * Sets the framing rectangle given the center point and one corner. Any |
| * corner may be used. |
| * |
| * @param center |
| * the center point. |
| * @param corner |
| * a corner point. |
| */ |
| public void setFrameFromCenter(Point2D center, Point2D corner) { |
| setFrameFromCenter(center.getX(), center.getY(), corner.getX(), corner.getY()); |
| } |
| |
| public boolean contains(Point2D point) { |
| return contains(point.getX(), point.getY()); |
| } |
| |
| public boolean intersects(Rectangle2D rect) { |
| return intersects(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight()); |
| } |
| |
| public boolean contains(Rectangle2D rect) { |
| return contains(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight()); |
| } |
| |
| public Rectangle getBounds() { |
| int x1 = (int)Math.floor(getMinX()); |
| int y1 = (int)Math.floor(getMinY()); |
| int x2 = (int)Math.ceil(getMaxX()); |
| int y2 = (int)Math.ceil(getMaxY()); |
| return new Rectangle(x1, y1, x2 - x1, y2 - y1); |
| } |
| |
| public PathIterator getPathIterator(AffineTransform t, double flatness) { |
| return new FlatteningPathIterator(getPathIterator(t), flatness); |
| } |
| |
| @Override |
| public Object clone() { |
| try { |
| return super.clone(); |
| } catch (CloneNotSupportedException e) { |
| throw new InternalError(); |
| } |
| } |
| |
| } |