com.levigo.util.gwtawt.emul.java.awt.geom.Rectangle2D Maven / Gradle / Ivy
Show all versions of gwt-awt Show documentation
/*
* Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved. DO NOT ALTER OR
* REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it under the terms of the GNU
* General Public License version 2 only, as published by the Free Software Foundation. Oracle
* designates this particular file as subject to the "Classpath" exception as provided by Oracle in
* the LICENSE file that accompanied this code.
*
* This code 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 version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version 2 along with this work;
* if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA or visit www.oracle.com
* if you need additional information or have any questions.
*/
package java.awt.geom;
import java.io.Serializable;
/**
* The Rectangle2D class describes a rectangle defined by a location {@code (x,y)} and
* dimension {@code (w x h)}.
*
* This class is only the abstract superclass for all objects that store a 2D rectangle. The actual
* storage representation of the coordinates is left to the subclass.
*
* @author Jim Graham
* @since 1.2
*/
public abstract class Rectangle2D extends RectangularShape {
/**
* The bitmask that indicates that a point lies to the left of this Rectangle2D.
*
* @since 1.2
*/
public static final int OUT_LEFT = 1;
/**
* The bitmask that indicates that a point lies above this Rectangle2D.
*
* @since 1.2
*/
public static final int OUT_TOP = 2;
/**
* The bitmask that indicates that a point lies to the right of this Rectangle2D.
*
* @since 1.2
*/
public static final int OUT_RIGHT = 4;
/**
* The bitmask that indicates that a point lies below this Rectangle2D.
*
* @since 1.2
*/
public static final int OUT_BOTTOM = 8;
/**
* The Float class defines a rectangle specified in float coordinates.
*
* @since 1.2
*/
public static class Float extends Rectangle2D implements Serializable {
/**
* The X coordinate of this Rectangle2D.
*
* @since 1.2
* @serial
*/
public float x;
/**
* The Y coordinate of this Rectangle2D.
*
* @since 1.2
* @serial
*/
public float y;
/**
* The width of this Rectangle2D.
*
* @since 1.2
* @serial
*/
public float width;
/**
* The height of this Rectangle2D.
*
* @since 1.2
* @serial
*/
public float height;
/**
* Constructs a new Rectangle2D, initialized to location (0.0, 0.0) and size
* (0.0, 0.0).
*
* @since 1.2
*/
public Float() {
}
/**
* Constructs and initializes a Rectangle2D from the specified float
* coordinates.
*
* @param x the X coordinate of the upper-left corner of the newly constructed
* Rectangle2D
* @param y the Y coordinate of the upper-left corner of the newly constructed
* Rectangle2D
* @param w the width of the newly constructed Rectangle2D
* @param h the height of the newly constructed Rectangle2D
* @since 1.2
*/
public Float(float x, float y, float w, float h) {
setRect(x, y, w, h);
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public double getX() {
return (double) x;
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public double getY() {
return (double) y;
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public double getWidth() {
return (double) width;
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public double getHeight() {
return (double) height;
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public boolean isEmpty() {
return (width <= 0.0f) || (height <= 0.0f);
}
/**
* Sets the location and size of this Rectangle2D to the specified
* float values.
*
* @param x the X coordinate of the upper-left corner of this Rectangle2D
* @param y the Y coordinate of the upper-left corner of this Rectangle2D
* @param w the width of this Rectangle2D
* @param h the height of this Rectangle2D
* @since 1.2
*/
public void setRect(float x, float y, float w, float h) {
this.x = x;
this.y = y;
this.width = w;
this.height = h;
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public void setRect(double x, double y, double w, double h) {
this.x = (float) x;
this.y = (float) y;
this.width = (float) w;
this.height = (float) h;
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public void setRect(Rectangle2D r) {
this.x = (float) r.getX();
this.y = (float) r.getY();
this.width = (float) r.getWidth();
this.height = (float) r.getHeight();
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public int outcode(double x, double y) {
/*
* Note on casts to double below. If the arithmetic of x+w or y+h is done in float, then some
* bits may be lost if the binary exponents of x/y and w/h are not similar. By converting to
* double before the addition we force the addition to be carried out in double to avoid
* rounding error in the comparison.
*
* See bug 4320890 for problems that this inaccuracy causes.
*/
int out = 0;
if (this.width <= 0) {
out |= OUT_LEFT | OUT_RIGHT;
} else if (x < this.x) {
out |= OUT_LEFT;
} else if (x > this.x + (double) this.width) {
out |= OUT_RIGHT;
}
if (this.height <= 0) {
out |= OUT_TOP | OUT_BOTTOM;
} else if (y < this.y) {
out |= OUT_TOP;
} else if (y > this.y + (double) this.height) {
out |= OUT_BOTTOM;
}
return out;
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public Rectangle2D getBounds2D() {
return new Float(x, y, width, height);
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public Rectangle2D createIntersection(Rectangle2D r) {
Rectangle2D dest;
if (r instanceof Float) {
dest = new Rectangle2D.Float();
} else {
dest = new Rectangle2D.Double();
}
Rectangle2D.intersect(this, r, dest);
return dest;
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public Rectangle2D createUnion(Rectangle2D r) {
Rectangle2D dest;
if (r instanceof Float) {
dest = new Rectangle2D.Float();
} else {
dest = new Rectangle2D.Double();
}
Rectangle2D.union(this, r, dest);
return dest;
}
/**
* Returns the String representation of this Rectangle2D.
*
* @return a String representing this Rectangle2D.
* @since 1.2
*/
public String toString() {
return getClass().getName() + "[x=" + x + ",y=" + y + ",w=" + width + ",h=" + height + "]";
}
/*
* JDK 1.6 serialVersionUID
*/
private static final long serialVersionUID = 3798716824173675777L;
}
/**
* The Double class defines a rectangle specified in double coordinates.
*
* @since 1.2
*/
public static class Double extends Rectangle2D implements Serializable {
/**
* The X coordinate of this Rectangle2D.
*
* @since 1.2
* @serial
*/
public double x;
/**
* The Y coordinate of this Rectangle2D.
*
* @since 1.2
* @serial
*/
public double y;
/**
* The width of this Rectangle2D.
*
* @since 1.2
* @serial
*/
public double width;
/**
* The height of this Rectangle2D.
*
* @since 1.2
* @serial
*/
public double height;
/**
* Constructs a new Rectangle2D, initialized to location (0, 0) and size
* (0, 0).
*
* @since 1.2
*/
public Double() {
}
/**
* Constructs and initializes a Rectangle2D from the specified double
* coordinates.
*
* @param x the X coordinate of the upper-left corner of the newly constructed
* Rectangle2D
* @param y the Y coordinate of the upper-left corner of the newly constructed
* Rectangle2D
* @param w the width of the newly constructed Rectangle2D
* @param h the height of the newly constructed Rectangle2D
* @since 1.2
*/
public Double(double x, double y, double w, double h) {
setRect(x, y, w, h);
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public double getX() {
return x;
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public double getY() {
return y;
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public double getWidth() {
return width;
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public double getHeight() {
return height;
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public boolean isEmpty() {
return (width <= 0.0) || (height <= 0.0);
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public void setRect(double x, double y, double w, double h) {
this.x = x;
this.y = y;
this.width = w;
this.height = h;
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public void setRect(Rectangle2D r) {
this.x = r.getX();
this.y = r.getY();
this.width = r.getWidth();
this.height = r.getHeight();
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public int outcode(double x, double y) {
int out = 0;
if (this.width <= 0) {
out |= OUT_LEFT | OUT_RIGHT;
} else if (x < this.x) {
out |= OUT_LEFT;
} else if (x > this.x + this.width) {
out |= OUT_RIGHT;
}
if (this.height <= 0) {
out |= OUT_TOP | OUT_BOTTOM;
} else if (y < this.y) {
out |= OUT_TOP;
} else if (y > this.y + this.height) {
out |= OUT_BOTTOM;
}
return out;
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public Rectangle2D getBounds2D() {
return new Double(x, y, width, height);
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public Rectangle2D createIntersection(Rectangle2D r) {
Rectangle2D dest = new Rectangle2D.Double();
Rectangle2D.intersect(this, r, dest);
return dest;
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public Rectangle2D createUnion(Rectangle2D r) {
Rectangle2D dest = new Rectangle2D.Double();
Rectangle2D.union(this, r, dest);
return dest;
}
/**
* Returns the String representation of this Rectangle2D.
*
* @return a String representing this Rectangle2D.
* @since 1.2
*/
public String toString() {
return getClass().getName() + "[x=" + x + ",y=" + y + ",w=" + width + ",h=" + height + "]";
}
/*
* JDK 1.6 serialVersionUID
*/
private static final long serialVersionUID = 7771313791441850493L;
}
// Dont work because of prohibited package when its included in the buildpath
// When not in Buildpath not found..
// public static class Double_CustomFieldSerializer extends CustomFieldSerializer {
// public static void deserialize(SerializationStreamReader streamReader, Double instance)
// throws SerializationException {
// instance.setRect(streamReader.readDouble(), streamReader.readDouble(), streamReader.readDouble(),
// streamReader.readDouble());
// }
//
// public static void serialize(SerializationStreamWriter streamWriter, Double instance) throws SerializationException {
// streamWriter.writeDouble(instance.getX());
// streamWriter.writeDouble(instance.getY());
// streamWriter.writeDouble(instance.getWidth());
// streamWriter.writeDouble(instance.getHeight());
// }
//
// @Override
// public void deserializeInstance(SerializationStreamReader streamReader, Double instance)
// throws SerializationException {
// deserialize(streamReader, instance);
// }
//
// @Override
// public void serializeInstance(SerializationStreamWriter streamWriter, Double instance)
// throws SerializationException {
// serialize(streamWriter, instance);
// }
// }
/**
* This is an abstract class that cannot be instantiated directly. Type-specific implementation
* subclasses are available for instantiation and provide a number of formats for storing the
* information necessary to satisfy the various accessor methods below.
*
* @see java.awt.geom.Rectangle2D.Float
* @see java.awt.geom.Rectangle2D.Double
* @see java.awt.Rectangle
* @since 1.2
*/
protected Rectangle2D() {
}
/**
* Sets the location and size of this Rectangle2D to the specified
* double values.
*
* @param x the X coordinate of the upper-left corner of this Rectangle2D
* @param y the Y coordinate of the upper-left corner of this Rectangle2D
* @param w the width of this Rectangle2D
* @param h the height of this Rectangle2D
* @since 1.2
*/
public abstract void setRect(double x, double y, double w, double h);
/**
* Sets this Rectangle2D to be the same as the specified Rectangle2D.
*
* @param r the specified Rectangle2D
* @since 1.2
*/
public void setRect(Rectangle2D r) {
setRect(r.getX(), r.getY(), r.getWidth(), r.getHeight());
}
/**
* Tests if the specified line segment intersects the interior of this Rectangle2D.
*
* @param x1 the X coordinate of the start point of the specified line segment
* @param y1 the Y coordinate of the start point of the specified line segment
* @param x2 the X coordinate of the end point of the specified line segment
* @param y2 the Y coordinate of the end point of the specified line segment
* @return true if the specified line segment intersects the interior of this
* Rectangle2D; false otherwise.
* @since 1.2
*/
public boolean intersectsLine(double x1, double y1, double x2, double y2) {
int out1, out2;
if ((out2 = outcode(x2, y2)) == 0) {
return true;
}
while ((out1 = outcode(x1, y1)) != 0) {
if ((out1 & out2) != 0) {
return false;
}
if ((out1 & (OUT_LEFT | OUT_RIGHT)) != 0) {
double x = getX();
if ((out1 & OUT_RIGHT) != 0) {
x += getWidth();
}
y1 = y1 + (x - x1) * (y2 - y1) / (x2 - x1);
x1 = x;
} else {
double y = getY();
if ((out1 & OUT_BOTTOM) != 0) {
y += getHeight();
}
x1 = x1 + (y - y1) * (x2 - x1) / (y2 - y1);
y1 = y;
}
}
return true;
}
/**
* Tests if the specified line segment intersects the interior of this Rectangle2D.
*
* @param l the specified {@link Line2D} to test for intersection with the interior of this
* Rectangle2D
* @return true if the specified Line2D intersects the interior of this
* Rectangle2D; false otherwise.
* @since 1.2
*/
public boolean intersectsLine(Line2D l) {
return intersectsLine(l.getX1(), l.getY1(), l.getX2(), l.getY2());
}
/**
* Determines where the specified coordinates lie with respect to this Rectangle2D.
* This method computes a binary OR of the appropriate mask values indicating, for each side of
* this Rectangle2D, whether or not the specified coordinates are on the same side of
* the edge as the rest of this Rectangle2D.
*
* @param x the specified X coordinate
* @param y the specified Y coordinate
* @return the logical OR of all appropriate out codes.
* @see #OUT_LEFT
* @see #OUT_TOP
* @see #OUT_RIGHT
* @see #OUT_BOTTOM
* @since 1.2
*/
public abstract int outcode(double x, double y);
/**
* Determines where the specified {@link Point2D} lies with respect to this
* Rectangle2D. This method computes a binary OR of the appropriate mask values
* indicating, for each side of this Rectangle2D, whether or not the specified
* Point2D is on the same side of the edge as the rest of this
* Rectangle2D.
*
* @param p the specified Point2D
* @return the logical OR of all appropriate out codes.
* @see #OUT_LEFT
* @see #OUT_TOP
* @see #OUT_RIGHT
* @see #OUT_BOTTOM
* @since 1.2
*/
public int outcode(Point2D p) {
return outcode(p.getX(), p.getY());
}
/**
* Sets the location and size of the outer bounds of this Rectangle2D to the
* specified rectangular values.
*
* @param x the X coordinate of the upper-left corner of this Rectangle2D
* @param y the Y coordinate of the upper-left corner of this Rectangle2D
* @param w the width of this Rectangle2D
* @param h the height of this Rectangle2D
* @since 1.2
*/
public void setFrame(double x, double y, double w, double h) {
setRect(x, y, w, h);
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public abstract Rectangle2D getBounds2D();
/**
* {@inheritDoc}
*
* @since 1.2
*/
public boolean contains(double x, double y) {
double x0 = getX();
double y0 = getY();
return (x >= x0 && y >= y0 && x < x0 + getWidth() && y < y0 + getHeight());
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public boolean intersects(double x, double y, double w, double h) {
if (isEmpty() || w <= 0 || h <= 0) {
return false;
}
double x0 = getX();
double y0 = getY();
return (x + w > x0 && y + h > y0 && x < x0 + getWidth() && y < y0 + getHeight());
}
/**
* {@inheritDoc}
*
* @since 1.2
*/
public boolean contains(double x, double y, double w, double h) {
if (isEmpty() || w <= 0 || h <= 0) {
return false;
}
double x0 = getX();
double y0 = getY();
return (x >= x0 && y >= y0 && (x + w) <= x0 + getWidth() && (y + h) <= y0 + getHeight());
}
/**
* Returns a new Rectangle2D object representing the intersection of this
* Rectangle2D with the specified Rectangle2D.
*
* @param r the Rectangle2D to be intersected with this Rectangle2D
* @return the largest Rectangle2D contained in both the specified
* Rectangle2D and in this Rectangle2D.
* @since 1.2
*/
public abstract Rectangle2D createIntersection(Rectangle2D r);
/**
* Intersects the pair of specified source Rectangle2D objects and puts the result
* into the specified destination Rectangle2D object. One of the source rectangles
* can also be the destination to avoid creating a third Rectangle2D object, but in this case the
* original points of this source rectangle will be overwritten by this method.
*
* @param src1 the first of a pair of Rectangle2D objects to be intersected with each
* other
* @param src2 the second of a pair of Rectangle2D objects to be intersected with
* each other
* @param dest the Rectangle2D that holds the results of the intersection of
* src1 and src2
* @since 1.2
*/
public static void intersect(Rectangle2D src1, Rectangle2D src2, Rectangle2D dest) {
double x1 = Math.max(src1.getMinX(), src2.getMinX());
double y1 = Math.max(src1.getMinY(), src2.getMinY());
double x2 = Math.min(src1.getMaxX(), src2.getMaxX());
double y2 = Math.min(src1.getMaxY(), src2.getMaxY());
dest.setFrame(x1, y1, x2 - x1, y2 - y1);
}
/**
* Returns a new Rectangle2D object representing the union of this
* Rectangle2D with the specified Rectangle2D.
*
* @param r the Rectangle2D to be combined with this Rectangle2D
* @return the smallest Rectangle2D containing both the specified
* Rectangle2D and this Rectangle2D.
* @since 1.2
*/
public abstract Rectangle2D createUnion(Rectangle2D r);
/**
* Unions the pair of source Rectangle2D objects and puts the result into the
* specified destination Rectangle2D object. One of the source rectangles can also be
* the destination to avoid creating a third Rectangle2D object, but in this case the original
* points of this source rectangle will be overwritten by this method.
*
* @param src1 the first of a pair of Rectangle2D objects to be combined with each
* other
* @param src2 the second of a pair of Rectangle2D objects to be combined with each
* other
* @param dest the Rectangle2D that holds the results of the union of
* src1 and src2
* @since 1.2
*/
public static void union(Rectangle2D src1, Rectangle2D src2, Rectangle2D dest) {
double x1 = Math.min(src1.getMinX(), src2.getMinX());
double y1 = Math.min(src1.getMinY(), src2.getMinY());
double x2 = Math.max(src1.getMaxX(), src2.getMaxX());
double y2 = Math.max(src1.getMaxY(), src2.getMaxY());
dest.setFrameFromDiagonal(x1, y1, x2, y2);
}
/**
* Adds a point, specified by the double precision arguments newx and
* newy, to this Rectangle2D. The resulting Rectangle2D is
* the smallest Rectangle2D that contains both the original Rectangle2D
* and the specified point.
*
* After adding a point, a call to contains with the added point as an argument does
* not necessarily return true. The contains method does not return
* true for points on the right or bottom edges of a rectangle. Therefore, if the
* added point falls on the left or bottom edge of the enlarged rectangle, contains
* returns false for that point.
*
* @param newx the X coordinate of the new point
* @param newy the Y coordinate of the new point
* @since 1.2
*/
public void add(double newx, double newy) {
double x1 = Math.min(getMinX(), newx);
double x2 = Math.max(getMaxX(), newx);
double y1 = Math.min(getMinY(), newy);
double y2 = Math.max(getMaxY(), newy);
setRect(x1, y1, x2 - x1, y2 - y1);
}
/**
* Adds the Point2D object pt to this Rectangle2D. The
* resulting Rectangle2D is the smallest Rectangle2D that contains both
* the original Rectangle2D and the specified Point2D.
*
* After adding a point, a call to contains with the added point as an argument does
* not necessarily return true. The contains method does not return
* true for points on the right or bottom edges of a rectangle. Therefore, if the
* added point falls on the left or bottom edge of the enlarged rectangle, contains
* returns false for that point.
*
* @param pt the new Point2D to add to this Rectangle2D.
* @since 1.2
*/
public void add(Point2D pt) {
add(pt.getX(), pt.getY());
}
/**
* Adds a Rectangle2D object to this Rectangle2D. The resulting
* Rectangle2D is the union of the two Rectangle2D objects.
*
* @param r the Rectangle2D to add to this Rectangle2D.
* @since 1.2
*/
public void add(Rectangle2D r) {
double x1 = Math.min(getMinX(), r.getMinX());
double x2 = Math.max(getMaxX(), r.getMaxX());
double y1 = Math.min(getMinY(), r.getMinY());
double y2 = Math.max(getMaxY(), r.getMaxY());
setRect(x1, y1, x2 - x1, y2 - y1);
}
/**
* Returns an iteration object that defines the boundary of this Rectangle2D. The
* iterator for this class is multi-threaded safe, which means that this Rectangle2D
* class guarantees that modifications to the geometry of this Rectangle2D object do
* not affect any iterations of that geometry that are already in process.
*
* @param at an optional AffineTransform to be applied to the coordinates as they are
* returned in the iteration, or null if untransformed coordinates are
* desired
* @return the PathIterator object that returns the geometry of the outline of this
* Rectangle2D, one segment at a time.
* @since 1.2
*/
public PathIterator getPathIterator(AffineTransform at) {
return new RectIterator(this, at);
}
/**
* Returns an iteration object that defines the boundary of the flattened Rectangle2D
* . Since rectangles are already flat, the flatness parameter is ignored. The
* iterator for this class is multi-threaded safe, which means that this Rectangle2D
* class guarantees that modifications to the geometry of this Rectangle2D object do
* not affect any iterations of that geometry that are already in process.
*
* @param at an optional AffineTransform to be applied to the coordinates as they are
* returned in the iteration, or null if untransformed coordinates are
* desired
* @param flatness the maximum distance that the line segments used to approximate the curved
* segments are allowed to deviate from any point on the original curve. Since rectangles
* are already flat, the flatness parameter is ignored.
* @return the PathIterator object that returns the geometry of the outline of this
* Rectangle2D, one segment at a time.
* @since 1.2
*/
public PathIterator getPathIterator(AffineTransform at, double flatness) {
return new RectIterator(this, at);
}
/**
* Returns the hashcode for this Rectangle2D.
* @return the hashcode for this Rectangle2D.
* @since 1.2
*/
public int hashCode() {
long bits = java.lang.Double.doubleToLongBits(getX());
bits += java.lang.Double.doubleToLongBits(getY()) * 37;
bits += java.lang.Double.doubleToLongBits(getWidth()) * 43;
bits += java.lang.Double.doubleToLongBits(getHeight()) * 47;
return (((int) bits) ^ ((int) (bits >> 32)));
}
/**
* Determines whether or not the specified Object is equal to this
* Rectangle2D. The specified Object is equal to this
* Rectangle2D if it is an instance of Rectangle2D and if its location
* and size are the same as this Rectangle2D.
*
* @param obj an Object to be compared with this Rectangle2D.
* @return true if obj is an instance of Rectangle2D and
* has the same values; false otherwise.
* @since 1.2
*/
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (obj instanceof Rectangle2D) {
Rectangle2D r2d = (Rectangle2D) obj;
return ((getX() == r2d.getX()) && (getY() == r2d.getY()) && (getWidth() == r2d.getWidth()) && (getHeight() == r2d.getHeight()));
}
return false;
}
}