android.graphics
public
final
class
android.graphics.Rect
Rect holds four integer coordinates for a rectangle. The rectangle is
represented by the coordinates of its 4 edges (left, top, right bottom).
These fields can be accessed directly. Use width() and height() to retrieve
the rectangle's width and height. Note: most methods do not check to see that
the coordinates are sorted correctly (i.e. left <= right and top <= bottom).
Summary
Constants
Fields
Public Constructors
Public Methods
|
|
final |
|
|
int |
centerX() |
|
|
final |
|
|
int |
centerY() |
|
|
|
|
|
boolean |
contains(int left, int top, int right, int bottom) |
|
|
|
|
|
boolean |
contains(int x, int y) |
|
|
|
|
|
boolean |
contains(Rect r) |
|
|
|
|
|
int |
describeContents() |
|
|
|
|
|
boolean |
equals(Object obj) |
|
|
final |
|
|
float |
exactCenterX() |
|
|
final |
|
|
float |
exactCenterY() |
|
|
final |
|
|
int |
height() |
|
|
|
|
|
void |
inset(int dx, int dy) |
|
|
|
|
|
boolean |
intersect(int left, int top, int right, int bottom) |
|
|
|
|
|
boolean |
intersect(Rect r) |
|
|
|
static |
|
boolean |
intersects(Rect a, Rect b) |
|
|
|
|
|
boolean |
intersects(int left, int top, int right, int bottom) |
|
|
final |
|
|
boolean |
isEmpty() |
|
|
|
|
|
void |
offset(int dx, int dy) |
|
|
|
|
|
void |
offsetTo(int newLeft, int newTop) |
|
|
|
|
|
void |
readFromParcel(Parcel in) |
|
|
|
|
|
void |
set(Rect src) |
|
|
|
|
|
void |
set(int left, int top, int right, int bottom) |
|
|
|
|
|
void |
setEmpty() |
|
|
|
|
|
boolean |
setIntersect(Rect a, Rect b) |
|
|
|
|
|
void |
sort() |
|
|
|
|
|
String |
toString() |
|
|
|
|
|
void |
union(int x, int y) |
|
|
|
|
|
void |
union(Rect r) |
|
|
|
|
|
void |
union(int left, int top, int right, int bottom) |
|
|
final |
|
|
int |
width() |
|
|
|
|
|
void |
writeToParcel(Parcel out, int flags) |
clone,
equals,
finalize,
getClass,
hashCode,
notify,
notifyAll,
toString,
wait,
wait,
wait
Details
Constants
Fields
Public Constructors
public
Rect()
Create a new empty Rect. All coordinates are initialized to 0.
public
Rect(int left, int top, int right, int bottom)
Create a new rectangle with the specified coordinates. Note: no range
checking is performed, so the caller must ensure that left <= right and
top <= bottom.
Parameters
left
| The X coordinate of the left side of the rectagle |
top
| The Y coordinate of the top of the rectangle |
right
| The X coordinate of the right side of the rectagle |
bottom
| The Y coordinate of the bottom of the rectangle
|
public
Rect(Rect r)
Create a new rectangle, initialized with the values in the specified
rectangle (which is left unmodified).
Parameters
r
| The rectangle whose coordinates are copied into the new
rectangle.
|
Public Methods
public
final
int
centerX()
Returns
- the horizontal center of the rectangle. If the computed value
is fractional, this method returns the largest integer that is
less than the computed value.
public
final
int
centerY()
Returns
- the vertical center of the rectangle. If the computed value
is fractional, this method returns the largest integer that is
less than the computed value.
public
boolean
contains(int left, int top, int right, int bottom)
Returns true iff the 4 specified sides of a rectangle are inside or equal
to this rectangle. i.e. is this rectangle a superset of the specified
rectangle. An empty rectangle never contains another rectangle.
Parameters
left
| The left side of the rectangle being tested for containment |
top
| The top of the rectangle being tested for containment |
right
| The right side of the rectangle being tested for containment |
bottom
| The bottom of the rectangle being tested for containment |
Returns
- true iff the the 4 specified sides of a rectangle are inside or
equal to this rectangle
public
boolean
contains(int x, int y)
Returns true if (x,y) is inside the rectangle. The left and top are
considered to be inside, while the right and bottom are not. This means
that for a x,y to be contained: left <= x < right and top <= y < bottom.
An empty rectangle never contains any point.
Parameters
x
| The X coordinate of the point being tested for containment |
y
| The Y coordinate of the point being tested for containment |
Returns
- true iff (x,y) are contained by the rectangle, where containment
means left <= x < right and top <= y < bottom
public
boolean
contains(Rect r)
Returns true iff the specified rectangle r is inside or equal to this
rectangle. An empty rectangle never contains another rectangle.
Parameters
r
| The rectangle being tested for containment. |
Returns
- true iff the specified rectangle r is inside or equal to this
rectangle
public
int
describeContents()
Parcelable interface methods
public
boolean
equals(Object obj)
Compares the argument to the receiver, and returns true if they represent
the
same object using a class specific comparison. The
implementation in Object returns true only if the argument is the exact
same object as the receiver (==).
Parameters
obj
| Object the object to compare with this object. |
Returns
- boolean
true
if the object is the same as this
object false
if it is different from this object.
public
final
float
exactCenterX()
Returns
- the exact horizontal center of the rectangle as a float.
public
final
float
exactCenterY()
Returns
- the exact vertical center of the rectangle as a float.
public
final
int
height()
Returns
- the rectangle's height. This does not check for a valid rectangle
(i.e. top <= bottom) so the result may be negative.
public
void
inset(int dx, int dy)
Inset the rectangle by (dx,dy). If dx is positive, then the sides are
moved inwards, making the rectangle narrower. If dx is negative, then the
sides are moved outwards, making the rectangle wider. The same holds true
for dy and the top and bottom.
Parameters
dx
| The amount to add(subtract) from the rectangle's left(right) |
dy
| The amount to add(subtract) from the rectangle's top(bottom)
|
public
boolean
intersect(int left, int top, int right, int bottom)
If the rectangle specified by left,top,right,bottom intersects this
rectangle, return true and set this rectangle to that intersection,
otherwise return false and do not change this rectangle. No check is
performed to see if either rectangle is empty. Note: To just test for
intersection, use intersects()
Parameters
left
| The left side of the rectangle being intersected with this
rectangle |
top
| The top of the rectangle being intersected with this rectangle |
right
| The right side of the rectangle being intersected with this
rectangle. |
bottom
| The bottom of the rectangle being intersected with this
rectangle. |
Returns
- true if the specified rectangle and this rectangle intersect
(and this rectangle is then set to that intersection) else
return false and do not change this rectangle.
public
boolean
intersect(Rect r)
If the specified rectangle intersects this rectangle, return true and set
this rectangle to that intersection, otherwise return false and do not
change this rectangle. No check is performed to see if either rectangle
is empty. To just test for intersection, use intersects()
Parameters
r
| The rectangle being intersected with this rectangle. |
Returns
- true if the specified rectangle and this rectangle intersect
(and this rectangle is then set to that intersection) else
return false and do not change this rectangle.
public
static
boolean
intersects(Rect a, Rect b)
Returns true iff the two specified rectangles intersect. In no event are
either of the rectangles modified. To record the intersection,
use intersect() or setIntersect().
Parameters
a
| The first rectangle being tested for intersection |
b
| The second rectangle being tested for intersection |
Returns
- true iff the two specified rectangles intersect. In no event are
either of the rectangles modified.
public
boolean
intersects(int left, int top, int right, int bottom)
Returns true if this rectangle intersects the specified rectangle.
In no event is this rectangle modified. No check is performed to see
if either rectangle is empty. To record the intersection, use intersect()
or setIntersect().
Parameters
left
| The left side of the rectangle being tested for intersection |
top
| The top of the rectangle being tested for intersection |
right
| The right side of the rectangle being tested for
intersection |
bottom
| The bottom of the rectangle being tested for intersection |
Returns
- true iff the specified rectangle intersects this rectangle. In
no event is this rectangle modified.
public
final
boolean
isEmpty()
Returns true if the rectangle is empty (left >= right or top >= bottom)
public
void
offset(int dx, int dy)
Offset the rectangle by adding dx to its left and right coordinates, and
adding dy to its top and bottom coordinates.
Parameters
dx
| The amount to add to the rectangle's left and right coordinates |
dy
| The amount to add to the rectangle's top and bottom coordinates
|
public
void
offsetTo(int newLeft, int newTop)
Offset the rectangle to a specific (left, top) position,
keeping its width and height the same.
Parameters
newLeft
| The new "left" coordinate for the rectangle |
newTop
| The new "top" coordinate for the rectangle
|
public
void
readFromParcel(Parcel in)
Set the rectangle's coordinates from the data stored in the specified
parcel. To write a rectangle to a parcel, call writeToParcel().
Parameters
in
| The parcel to read the rectangle's coordinates from
|
public
void
set(Rect src)
Copy the coordinates from src into this rectangle.
Parameters
src
| The rectangle whose coordinates are copied into this
rectangle.
|
public
void
set(int left, int top, int right, int bottom)
Set the rectangle's coordinates to the specified values. Note: no range
checking is performed, so it is up to the caller to ensure that
left <= right and top <= bottom.
Parameters
left
| The X coordinate of the left side of the rectagle |
top
| The Y coordinate of the top of the rectangle |
right
| The X coordinate of the right side of the rectagle |
bottom
| The Y coordinate of the bottom of the rectangle
|
public
void
setEmpty()
Set the rectangle to (0,0,0,0)
public
boolean
setIntersect(Rect a, Rect b)
If rectangles a and b intersect, return true and set this rectangle to
that intersection, otherwise return false and do not change this
rectangle. No check is performed to see if either rectangle is empty.
To just test for intersection, use intersects()
Parameters
a
| The first rectangle being intersected with |
b
| The second rectangle being intersected with |
Returns
- true iff the two specified rectangles intersect. If they do, set
this rectangle to that intersection. If they do not, return
false and do not change this rectangle.
public
void
sort()
Swap top/bottom or left/right if there are flipped (i.e. left > right
and/or top > bottom). This can be called if
the edges are computed separately, and may have crossed over each other.
If the edges are already correct (i.e. left <= right and top <= bottom)
then nothing is done.
public
String
toString()
Returns a string containing a concise, human-readable description of the
receiver.
Returns
- String a printable representation for the receiver.
public
void
union(int x, int y)
Update this Rect to enclose itself and the [x,y] coordinate. There is no
check to see that this rectangle is non-empty.
Parameters
x
| The x coordinate of the point to add to the rectangle |
y
| The y coordinate of the point to add to the rectangle
|
public
void
union(Rect r)
Update this Rect to enclose itself and the specified rectangle. If the
specified rectangle is empty, nothing is done. If this rectangle is empty
it is set to the specified rectangle.
Parameters
r
| The rectangle being unioned with this rectangle
|
public
void
union(int left, int top, int right, int bottom)
Update this Rect to enclose itself and the specified rectangle. If the
specified rectangle is empty, nothing is done. If this rectangle is empty
it is set to the specified rectangle.
Parameters
left
| The left edge being unioned with this rectangle |
top
| The top edge being unioned with this rectangle |
right
| The right edge being unioned with this rectangle |
bottom
| The bottom edge being unioned with this rectangle
|
public
final
int
width()
Returns
- the rectangle's width. This does not check for a valid rectangle
(i.e. left <= right) so the result may be negative.
public
void
writeToParcel(Parcel out, int flags)
Write this rectangle to the specified parcel. To restore a rectangle from
a parcel, use readFromParcel()
Parameters
out
| The parcel to write the rectangle's coordinates into
|