java.lang.Object java.awt.geom.RectangularShape java.awt.geom.Rectangle2D java.awt.Rectangle
All Implemented Interfaces:
Shape, java$io$Serializable, Cloneable
Direct Known Subclasses:
ComposedTextCaret, DefaultCaret, AWTCaret, BasicCaret
Rectangle
specifies an area in a coordinate space that is
enclosed by the Rectangle
object's upperleft point
{@code (x,y)}
in the coordinate space, its width, and its height.
A Rectangle
object's width
and
height
are public
fields. The constructors
that create a Rectangle
, and the methods that can modify
one, do not prevent setting a negative value for width or height.
A {@code Rectangle} whose width or height is exactly zero has location along those axes with zero dimension, but is otherwise considered empty. The #isEmpty method will return true for such a {@code Rectangle}. Methods which test if an empty {@code Rectangle} contains or intersects a point or rectangle will always return false if either dimension is zero. Methods which combine such a {@code Rectangle} with a point or rectangle will include the location of the {@code Rectangle} on that axis in the result as if the #add(Point) method were being called.
Methods which affect only the location of a {@code Rectangle} will operate on its location regardless of whether or not it has a negative or zero dimension along either axis.
Note that a {@code Rectangle} constructed with the default noargument constructor will have dimensions of {@code 0x0} and therefore be empty. That {@code Rectangle} will still have a location of {@code (0,0)} and will contribute that location to the union and add operations. Code attempting to accumulate the bounds of a set of points should therefore initially construct the {@code Rectangle} with a specifically negative width and height or it should use the first point in the set to construct the {@code Rectangle}. For example:
Rectangle bounds = new Rectangle(0, 0, 1, 1); for (int i = 0; i < points.length; i++) { bounds.add(points[i]); }or if we know that the points array contains at least one point:
Rectangle bounds = new Rectangle(points[0]); for (int i = 1; i < points.length; i++) { bounds.add(points[i]); }
This class uses 32bit integers to store its location and dimensions. Frequently operations may produce a result that exceeds the range of a 32bit integer. The methods will calculate their results in a way that avoids any 32bit overflow for intermediate results and then choose the best representation to store the final results back into the 32bit fields which hold the location and dimensions. The location of the result will be stored into the #x and #y fields by clipping the true result to the nearest 32bit value. The values stored into the #width and #height dimension fields will be chosen as the 32bit values that encompass the largest part of the true result as possible. Generally this means that the dimension will be clipped independently to the range of 32bit integers except that if the location had to be moved to store it into its pair of 32bit fields then the dimensions will be adjusted relative to the "best representation" of the location. If the true result had a negative dimension and was therefore nonexistant along one or both axes, the stored dimensions will be negative numbers in those axes. If the true result had a location that could be represented within the range of 32bit integers, but zero dimension along one or both axes, then the stored dimensions will be zero in those axes.
Sami
 Shaio1.0
 Field Summary  

public int  x  The X coordinate of the upperleft corner of the Rectangle .

public int  y  The Y coordinate of the upperleft corner of the Rectangle .

public int  width  The width of the Rectangle .

public int  height  The height of the Rectangle .

Fields inherited from java.awt.geom.Rectangle2D: 

OUT_LEFT, OUT_TOP, OUT_RIGHT, OUT_BOTTOM 
Constructor: 

public Rectangle(){ this(0, 0, 0, 0); } 
public Rectangle(Rectangle r){ this(r.x, r.y, r.width, r.height); }
Rectangle , initialized to match
the values of the specified Rectangle .

public Rectangle(Point p){ this(p.x, p.y, 0, 0); }
Rectangle whose upperleft corner is the
specified Point , and whose width and height are both zero.

public Rectangle(Dimension d){ this(0, 0, d.width, d.height); }
Rectangle whose top left corner is
(0, 0) and whose width and height are specified
by the Dimension argument.

public Rectangle(int width, int height){ this(0, 0, width, height); } 
public Rectangle(Point p, Dimension d){ this(p.x, p.y, d.width, d.height); }
Rectangle whose upperleft corner is
specified by the Point argument, and
whose width and height are specified by the
Dimension argument.

public Rectangle(int x, int y, int width, int height){ this.x = x; this.y = y; this.width = width; this.height = height; } 
Method from java.awt.Rectangle Summary: 

add, add, add, contains, contains, contains, contains, createIntersection, createUnion, equals, getBounds, getBounds2D, getHeight, getLocation, getSize, getWidth, getX, getY, grow, inside, intersection, intersects, isEmpty, move, outcode, reshape, resize, setBounds, setBounds, setLocation, setLocation, setRect, setSize, setSize, toString, translate, union 
Methods from java.awt.geom.Rectangle2D: 

add, add, add, contains, contains, createIntersection, createUnion, equals, getBounds2D, getPathIterator, getPathIterator, hashCode, intersect, intersects, intersectsLine, intersectsLine, outcode, outcode, setFrame, setRect, setRect, union 
Methods from java.awt.geom.RectangularShape: 

clone, contains, contains, getBounds, getCenterX, getCenterY, getFrame, getHeight, getMaxX, getMaxY, getMinX, getMinY, getPathIterator, getWidth, getX, getY, intersects, isEmpty, setFrame, setFrame, setFrame, setFrameFromCenter, setFrameFromCenter, setFrameFromDiagonal, setFrameFromDiagonal 
Methods from java.lang.Object: 

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait 
Method from java.awt.Rectangle Detail: 

public void add(Point pt){ add(pt.x, pt.y); }
If this {@code Rectangle} has any dimension less than zero, the rules for nonexistant rectangles apply. In that case, the new bounds of this {@code Rectangle} will have a location equal to the coordinates of the specified {@code Point} and width and height equal to zero.
After adding a r.add(pt.x, pt.y, 1, 1); 
public void add(Rectangle r){ long tx2 = this.width; long ty2 = this.height; if ((tx2  ty2) < 0) { reshape(r.x, r.y, r.width, r.height); } long rx2 = r.width; long ry2 = r.height; if ((rx2  ry2) < 0) { return; } int tx1 = this.x; int ty1 = this.y; tx2 += tx1; ty2 += ty1; int rx1 = r.x; int ry1 = r.y; rx2 += rx1; ry2 += ry1; if (tx1 > rx1) tx1 = rx1; if (ty1 > ry1) ty1 = ry1; if (tx2 < rx2) tx2 = rx2; if (ty2 < ry2) ty2 = ry2; tx2 = tx1; ty2 = ty1; // tx2,ty2 will never underflow since both original // rectangles were nonempty // they might overflow, though... if (tx2 > Integer.MAX_VALUE) tx2 = Integer.MAX_VALUE; if (ty2 > Integer.MAX_VALUE) ty2 = Integer.MAX_VALUE; reshape(tx1, ty1, (int) tx2, (int) ty2); }
Rectangle to this Rectangle .
The resulting Rectangle is the union of the two
rectangles.
If either {@code Rectangle} has any dimension less than 0, the result will have the dimensions of the other {@code Rectangle}. If both {@code Rectangle}s have at least one dimension less than 0, the result will have at least one dimension less than 0. If either {@code Rectangle} has one or both dimensions equal to 0, the result along those axes with 0 dimensions will be equivalent to the results obtained by adding the corresponding origin coordinate to the result rectangle along that axis, similar to the operation of the #add(Point) method, but contribute no further dimension beyond that. If the resulting {@code Rectangle} would have a dimension too large to be expressed as an {@code int}, the result will have a dimension of {@code Integer.MAX_VALUE} along that dimension. 
public void add(int newx, int newy){ if ((width  height) < 0) { this.x = newx; this.y = newy; this.width = this.height = 0; return; } int x1 = this.x; int y1 = this.y; long x2 = this.width; long y2 = this.height; x2 += x1; y2 += y1; if (x1 > newx) x1 = newx; if (y1 > newy) y1 = newy; if (x2 < newx) x2 = newx; if (y2 < newy) y2 = newy; x2 = x1; y2 = y1; if (x2 > Integer.MAX_VALUE) x2 = Integer.MAX_VALUE; if (y2 > Integer.MAX_VALUE) y2 = Integer.MAX_VALUE; reshape(x1, y1, (int) x2, (int) y2); }
If this {@code Rectangle} has any dimension less than zero, the rules for nonexistant rectangles apply. In that case, the new bounds of this {@code Rectangle} will have a location equal to the specified coordinates and width and height equal to zero.
After adding a point, a call to r.add(newx, newy, 1, 1); 
public boolean contains(Point p){ return contains(p.x, p.y); }
Rectangle contains the
specified Point . 
public boolean contains(Rectangle r){ return contains(r.x, r.y, r.width, r.height); }
Rectangle entirely contains
the specified Rectangle . 
public boolean contains(int x, int y){ return inside(x, y); }
Rectangle contains the
point at the specified location {@code (x,y)}. 
public boolean contains(int X, int Y, int W, int H){ int w = this.width; int h = this.height; if ((w  h  W  H) < 0) { // At least one of the dimensions is negative... return false; } // Note: if any dimension is zero, tests below must return false... int x = this.x; int y = this.y; if (X < x  Y < y) { return false; } w += x; W += X; if (W < = X) { // X+W overflowed or W was zero, return false if... // either original w or W was zero or // x+w did not overflow or // the overflowed x+w is smaller than the overflowed X+W if (w >= x  W > w) return false; } else { // X+W did not overflow and W was not zero, return false if... // original w was zero or // x+w did not overflow and x+w is smaller than X+W if (w >= x && W > w) return false; } h += y; H += Y; if (H < = Y) { if (h >= y  H > h) return false; } else { if (h >= y && H > h) return false; } return true; }
Rectangle entirely contains
the Rectangle
at the specified location {@code (X,Y)} with the
specified dimensions {@code (W,H)}. 
public Rectangle2D createIntersection(Rectangle2D r){ if (r instanceof Rectangle) { return intersection((Rectangle) r); } Rectangle2D dest = new Rectangle2D.Double(); Rectangle2D.intersect(this, r, dest); return dest; }

public Rectangle2D createUnion(Rectangle2D r){ if (r instanceof Rectangle) { return union((Rectangle) r); } Rectangle2D dest = new Rectangle2D.Double(); Rectangle2D.union(this, r, dest); return dest; }

public boolean equals(Object obj){ if (obj instanceof Rectangle) { Rectangle r = (Rectangle)obj; return ((x == r.x) && (y == r.y) && (width == r.width) && (height == r.height)); } return super.equals(obj); }
The result is 
public Rectangle getBounds(){ return new Rectangle(x, y, width, height); }
Rectangle of this Rectangle .
This method is included for completeness, to parallel the

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

public double getHeight(){ return height; }
Rectangle in
double precision. 
public Point getLocation(){ return new Point(x, y); }
Rectangle .
This method is included for completeness, to parallel the

public Dimension getSize(){ return new Dimension(width, height); }
Rectangle , represented by
the returned Dimension .
This method is included for completeness, to parallel the

public double getWidth(){ return width; }
Rectangle in
double precision. 
public double getX(){ return x; }
Rectangle in
double precision. 
public double getY(){ return y; }
Rectangle in
double precision. 
public void grow(int h, int v){ long x0 = this.x; long y0 = this.y; long x1 = this.width; long y1 = this.height; x1 += x0; y1 += y0; x0 = h; y0 = v; x1 += h; y1 += v; if (x1 < x0) { // Nonexistant in X direction // Final width must remain negative so subtract x0 before // it is clipped so that we avoid the risk that the clipping // of x0 will reverse the ordering of x0 and x1. x1 = x0; if (x1 < Integer.MIN_VALUE) x1 = Integer.MIN_VALUE; if (x0 < Integer.MIN_VALUE) x0 = Integer.MIN_VALUE; else if (x0 > Integer.MAX_VALUE) x0 = Integer.MAX_VALUE; } else { // (x1 >= x0) // Clip x0 before we subtract it from x1 in case the clipping // affects the representable area of the rectangle. if (x0 < Integer.MIN_VALUE) x0 = Integer.MIN_VALUE; else if (x0 > Integer.MAX_VALUE) x0 = Integer.MAX_VALUE; x1 = x0; // The only way x1 can be negative now is if we clipped // x0 against MIN and x1 is less than MIN  in which case // we want to leave the width negative since the result // did not intersect the representable area. if (x1 < Integer.MIN_VALUE) x1 = Integer.MIN_VALUE; else if (x1 > Integer.MAX_VALUE) x1 = Integer.MAX_VALUE; } if (y1 < y0) { // Nonexistant in Y direction y1 = y0; if (y1 < Integer.MIN_VALUE) y1 = Integer.MIN_VALUE; if (y0 < Integer.MIN_VALUE) y0 = Integer.MIN_VALUE; else if (y0 > Integer.MAX_VALUE) y0 = Integer.MAX_VALUE; } else { // (y1 >= y0) if (y0 < Integer.MIN_VALUE) y0 = Integer.MIN_VALUE; else if (y0 > Integer.MAX_VALUE) y0 = Integer.MAX_VALUE; y1 = y0; if (y1 < Integer.MIN_VALUE) y1 = Integer.MIN_VALUE; else if (y1 > Integer.MAX_VALUE) y1 = Integer.MAX_VALUE; } reshape((int) x0, (int) y0, (int) x1, (int) y1); }
Rectangle both horizontally and vertically.
This method modifies the
The new
If negative values are supplied for 
public boolean inside(int X, int Y)Deprecated!{ int w = this.width; int h = this.height; if ((w  h) < 0) { // At least one of the dimensions is negative... return false; } // Note: if either dimension is zero, tests below must return false... int x = this.x; int y = this.y; if (X < x  Y < y) { return false; } w += x; h += y; // overflow  intersect return ((w < x  w > X) && (h < y  h > Y)); } As  of JDK version 1.1,
replaced by contains(int, int) .
Rectangle contains the
point at the specified location {@code (X,Y)}. 
public Rectangle intersection(Rectangle r){ int tx1 = this.x; int ty1 = this.y; int rx1 = r.x; int ry1 = r.y; long tx2 = tx1; tx2 += this.width; long ty2 = ty1; ty2 += this.height; long rx2 = rx1; rx2 += r.width; long ry2 = ry1; ry2 += r.height; if (tx1 < rx1) tx1 = rx1; if (ty1 < ry1) ty1 = ry1; if (tx2 > rx2) tx2 = rx2; if (ty2 > ry2) ty2 = ry2; tx2 = tx1; ty2 = ty1; // tx2,ty2 will never overflow (they will never be // larger than the smallest of the two source w,h) // they might underflow, though... if (tx2 < Integer.MIN_VALUE) tx2 = Integer.MIN_VALUE; if (ty2 < Integer.MIN_VALUE) ty2 = Integer.MIN_VALUE; return new Rectangle(tx1, ty1, (int) tx2, (int) ty2); }
Rectangle with the
specified Rectangle . Returns a new Rectangle
that represents the intersection of the two rectangles.
If the two rectangles do not intersect, the result will be
an empty rectangle. 
public boolean intersects(Rectangle r){ int tw = this.width; int th = this.height; int rw = r.width; int rh = r.height; if (rw < = 0  rh < = 0  tw < = 0  th < = 0) { return false; } int tx = this.x; int ty = this.y; int rx = r.x; int ry = r.y; rw += rx; rh += ry; tw += tx; th += ty; // overflow  intersect return ((rw < rx  rw > tx) && (rh < ry  rh > ty) && (tw < tx  tw > rx) && (th < ty  th > ry)); }
Rectangle and the specified
Rectangle intersect. Two rectangles intersect if
their intersection is nonempty. 
public boolean isEmpty(){ return (width < = 0)  (height < = 0); }

public void move(int x, int y)Deprecated!{ this.x = x; this.y = y; } As  of JDK version 1.1,
replaced by setLocation(int, int) .
Rectangle to the specified location.

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 int, then we may get integer * overflow. By converting to double before the addition * we force the addition to be carried out in double to * avoid overflow in the comparison. * * See bug 4320890 for problems that this can cause. */ 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; }

public void reshape(int x, int y, int width, int height)Deprecated!{ this.x = x; this.y = y; this.width = width; this.height = height; } As  of JDK version 1.1,
replaced by setBounds(int, int, int, int) .
Rectangle of this
Rectangle to the specified
x , y , width ,
and height .

public void resize(int width, int height)Deprecated!{ this.width = width; this.height = height; } As  of JDK version 1.1,
replaced by setSize(int, int) .
Rectangle to the specified
width and height.

public void setBounds(Rectangle r){ setBounds(r.x, r.y, r.width, r.height); }
Rectangle of this Rectangle
to match the specified Rectangle .
This method is included for completeness, to parallel the

public void setBounds(int x, int y, int width, int height){ reshape(x, y, width, height); }
Rectangle of this
Rectangle to the specified
x , y , width ,
and height .
This method is included for completeness, to parallel the

public void setLocation(Point p){ setLocation(p.x, p.y); }
Rectangle to the specified location.
This method is included for completeness, to parallel the

public void setLocation(int x, int y){ move(x, y); }
Rectangle to the specified location.
This method is included for completeness, to parallel the

public void setRect(double x, double y, double width, double height){ int newx, newy, neww, newh; if (x > 2.0 * Integer.MAX_VALUE) { // Too far in positive X direction to represent... // We cannot even reach the left side of the specified // rectangle even with both x & width set to MAX_VALUE. // The intersection with the "maximal integer rectangle" // is nonexistant so we should use a width < 0. // REMIND: Should we try to determine a more "meaningful" // adjusted value for neww than just "1"? newx = Integer.MAX_VALUE; neww = 1; } else { newx = clip(x, false); if (width >= 0) width += xnewx; neww = clip(width, width >= 0); } if (y > 2.0 * Integer.MAX_VALUE) { // Too far in positive Y direction to represent... newy = Integer.MAX_VALUE; newh = 1; } else { newy = clip(y, false); if (height >= 0) height += ynewy; newh = clip(height, height >= 0); } reshape(newx, newy, neww, newh); }

public void setSize(Dimension d){ setSize(d.width, d.height); }
Rectangle to match the
specified Dimension .
This method is included for completeness, to parallel the

public void setSize(int width, int height){ resize(width, height); }
Rectangle to the specified
width and height.
This method is included for completeness, to parallel the

public String toString(){ return getClass().getName() + "[x=" + x + ",y=" + y + ",width=" + width + ",height=" + height + "]"; }
String representing this
Rectangle and its values. 
public void translate(int dx, int dy){ int oldv = this.x; int newv = oldv + dx; if (dx < 0) { // moving leftward if (newv > oldv) { // negative overflow // Only adjust width if it was valid ( >= 0). if (width >= 0) { // The right edge is now conceptually at // newv+width, but we may move newv to prevent // overflow. But we want the right edge to // remain at its new location in spite of the // clipping. Think of the following adjustment // conceptually the same as: // width += newv; newv = MIN_VALUE; width = newv; width += newv  Integer.MIN_VALUE; // width may go negative if the right edge went past // MIN_VALUE, but it cannot overflow since it cannot // have moved more than MIN_VALUE and any nonnegative // number + MIN_VALUE does not overflow. } newv = Integer.MIN_VALUE; } } else { // moving rightward (or staying still) if (newv < oldv) { // positive overflow if (width >= 0) { // Conceptually the same as: // width += newv; newv = MAX_VALUE; width = newv; width += newv  Integer.MAX_VALUE; // With large widths and large displacements // we may overflow so we need to check it. if (width < 0) width = Integer.MAX_VALUE; } newv = Integer.MAX_VALUE; } } this.x = newv; oldv = this.y; newv = oldv + dy; if (dy < 0) { // moving upward if (newv > oldv) { // negative overflow if (height >= 0) { height += newv  Integer.MIN_VALUE; // See above comment about no overflow in this case } newv = Integer.MIN_VALUE; } } else { // moving downward (or staying still) if (newv < oldv) { // positive overflow if (height >= 0) { height += newv  Integer.MAX_VALUE; if (height < 0) height = Integer.MAX_VALUE; } newv = Integer.MAX_VALUE; } } this.y = newv; }
Rectangle the indicated distance,
to the right along the X coordinate axis, and
downward along the Y coordinate axis. 
public Rectangle union(Rectangle r){ long tx2 = this.width; long ty2 = this.height; if ((tx2  ty2) < 0) { // This rectangle has negative dimensions... // If r has nonnegative dimensions then it is the answer. // If r is nonexistant (has a negative dimension), then both // are nonexistant and we can return any nonexistant rectangle // as an answer. Thus, returning r meets that criterion. // Either way, r is our answer. return new Rectangle(r); } long rx2 = r.width; long ry2 = r.height; if ((rx2  ry2) < 0) { return new Rectangle(this); } int tx1 = this.x; int ty1 = this.y; tx2 += tx1; ty2 += ty1; int rx1 = r.x; int ry1 = r.y; rx2 += rx1; ry2 += ry1; if (tx1 > rx1) tx1 = rx1; if (ty1 > ry1) ty1 = ry1; if (tx2 < rx2) tx2 = rx2; if (ty2 < ry2) ty2 = ry2; tx2 = tx1; ty2 = ty1; // tx2,ty2 will never underflow since both original rectangles // were already proven to be nonempty // they might overflow, though... if (tx2 > Integer.MAX_VALUE) tx2 = Integer.MAX_VALUE; if (ty2 > Integer.MAX_VALUE) ty2 = Integer.MAX_VALUE; return new Rectangle(tx1, ty1, (int) tx2, (int) ty2); }
Rectangle with the
specified Rectangle . Returns a new
Rectangle that
represents the union of the two rectangles.
If either {@code Rectangle} has any dimension less than zero the rules for nonexistant rectangles apply. If only one has a dimension less than zero, then the result will be a copy of the other {@code Rectangle}. If both have dimension less than zero, then the result will have at least one dimension less than zero. If the resulting {@code Rectangle} would have a dimension too large to be expressed as an {@code int}, the result will have a dimension of {@code Integer.MAX_VALUE} along that dimension. 