/**@class android.graphics.RectF
 implements android.os.Parcelable

@extends java.lang.Object

 RectF holds four float 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).
*/
var RectF = {

/***/
left : "null",
/***/
top : "null",
/***/
right : "null",
/***/
bottom : "null",
/***/
CREATOR : "null",
/**
*/
equals : function(  ) {},

/**
*/
hashCode : function(  ) {},

/**
*/
toString : function(  ) {},

/**Return a string representation of the rectangle in a compact form.
*/
toShortString : function(  ) {},

/**Return a string representation of the rectangle in a compact form.
@hide 
*/
toShortString : function(  ) {},

/**Print short representation to given writer.
@hide 
*/
printShortString : function(  ) {},

/**Returns true if the rectangle is empty (left >= right or top >= bottom)
*/
isEmpty : function(  ) {},

/**
@return {Number} the rectangle's width. This does not check for a valid rectangle
 (i.e. left <= right) so the result may be negative.
*/
width : function(  ) {},

/**
@return {Number} the rectangle's height. This does not check for a valid rectangle
 (i.e. top <= bottom) so the result may be negative.
*/
height : function(  ) {},

/**
@return {Number} the horizontal center of the rectangle. This does not check for
 a valid rectangle (i.e. left <= right)
*/
centerX : function(  ) {},

/**
@return {Number} the vertical center of the rectangle. This does not check for
 a valid rectangle (i.e. top <= bottom)
*/
centerY : function(  ) {},

/**Set the rectangle to (0,0,0,0)
*/
setEmpty : function(  ) {},

/**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.
@param {Number} left   The X coordinate of the left side of the rectangle
@param {Number} top    The Y coordinate of the top of the rectangle
@param {Number} right  The X coordinate of the right side of the rectangle
@param {Number} bottom The Y coordinate of the bottom of the rectangle
*/
set : function(  ) {},

/**Copy the coordinates from src into this rectangle.
@param {Object {RectF}} src The rectangle whose coordinates are copied into this
           rectangle.
*/
set : function(  ) {},

/**Copy the coordinates from src into this rectangle.
@param {Object {Rect}} src The rectangle whose coordinates are copied into this
           rectangle.
*/
set : function(  ) {},

/**Offset the rectangle by adding dx to its left and right coordinates, and
 adding dy to its top and bottom coordinates.
@param {Number} dx The amount to add to the rectangle's left and right coordinates
@param {Number} dy The amount to add to the rectangle's top and bottom coordinates
*/
offset : function(  ) {},

/**Offset the rectangle to a specific (left, top) position,
 keeping its width and height the same.
@param {Number} newLeft   The new "left" coordinate for the rectangle
@param {Number} newTop    The new "top" coordinate for the rectangle
*/
offsetTo : function(  ) {},

/**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.
@param {Number} dx The amount to add(subtract) from the rectangle's left(right)
@param {Number} dy The amount to add(subtract) from the rectangle's top(bottom)
*/
inset : function(  ) {},

/**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.
@param {Number} x The X coordinate of the point being tested for containment
@param {Number} y The Y coordinate of the point being tested for containment
@return {Boolean} true iff (x,y) are contained by the rectangle, where containment
              means left <= x < right and top <= y < bottom
*/
contains : function(  ) {},

/**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.
@param {Number} left The left side of the rectangle being tested for containment
@param {Number} top The top of the rectangle being tested for containment
@param {Number} right The right side of the rectangle being tested for containment
@param {Number} bottom The bottom of the rectangle being tested for containment
@return {Boolean} true iff the the 4 specified sides of a rectangle are inside or
              equal to this rectangle
*/
contains : function(  ) {},

/**Returns true iff the specified rectangle r is inside or equal to this
 rectangle. An empty rectangle never contains another rectangle.
@param {Object {RectF}} r The rectangle being tested for containment.
@return {Boolean} true iff the specified rectangle r is inside or equal to this
              rectangle
*/
contains : function(  ) {},

/**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()
@param {Number} left The left side of the rectangle being intersected with this
             rectangle
@param {Number} top The top of the rectangle being intersected with this rectangle
@param {Number} right The right side of the rectangle being intersected with this
              rectangle.
@param {Number} bottom The bottom of the rectangle being intersected with this
             rectangle.
@return {Boolean} 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.
*/
intersect : function(  ) {},

/**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()
@param {Object {RectF}} r The rectangle being intersected with this rectangle.
@return {Boolean} 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.
*/
intersect : function(  ) {},

/**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()
@param {Object {RectF}} a The first rectangle being intersected with
@param {Object {RectF}} b The second rectangle being intersected with
@return {Boolean} 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.
*/
setIntersect : function(  ) {},

/**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().
@param {Number} left The left side of the rectangle being tested for intersection
@param {Number} top The top of the rectangle being tested for intersection
@param {Number} right The right side of the rectangle being tested for
              intersection
@param {Number} bottom The bottom of the rectangle being tested for intersection
@return {Boolean} true iff the specified rectangle intersects this rectangle. In
              no event is this rectangle modified.
*/
intersects : function(  ) {},

/**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().
@param {Object {RectF}} a The first rectangle being tested for intersection
@param {Object {RectF}} b The second rectangle being tested for intersection
@return {Boolean} true iff the two specified rectangles intersect. In no event are
              either of the rectangles modified.
*/
intersects : function(  ) {},

/**Set the dst integer Rect by rounding this rectangle's coordinates
 to their nearest integer values.
*/
round : function(  ) {},

/**Set the dst integer Rect by rounding "out" this rectangle, choosing the
 floor of top and left, and the ceiling of right and bottom.
*/
roundOut : function(  ) {},

/**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.
@param {Number} left The left edge being unioned with this rectangle
@param {Number} top The top edge being unioned with this rectangle
@param {Number} right The right edge being unioned with this rectangle
@param {Number} bottom The bottom edge being unioned with this rectangle
*/
union : function(  ) {},

/**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.
@param {Object {RectF}} r The rectangle being unioned with this rectangle
*/
union : function(  ) {},

/**Update this Rect to enclose itself and the [x,y] coordinate. There is no
 check to see that this rectangle is non-empty.
@param {Number} x The x coordinate of the point to add to the rectangle
@param {Number} y The y coordinate of the point to add to the rectangle
*/
union : function(  ) {},

/**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.
*/
sort : function(  ) {},

/**Parcelable interface methods
*/
describeContents : function(  ) {},

/**Write this rectangle to the specified parcel. To restore a rectangle from
 a parcel, use readFromParcel()
@param {Object {Parcel}} out The parcel to write the rectangle's coordinates into
*/
writeToParcel : function(  ) {},

/**Set the rectangle's coordinates from the data stored in the specified
 parcel. To write a rectangle to a parcel, call writeToParcel().
@param {Object {Parcel}} in The parcel to read the rectangle's coordinates from
*/
readFromParcel : function(  ) {},

/**Scales up the rect by the given scale.
@hide 
*/
scale : function(  ) {},


};