graphics/java/android/graphics/RectF.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2006 The Android Open Source Project
  *
  * Licensed 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.
  */

 package android.graphics;

 import java.io.PrintWriter;

 import android.os.Parcel;
 import android.os.Parcelable;
 import com.android.internal.util.FastMath;

 /**
  * 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).
  */
 public class RectF implements Parcelable {
     public float left;
     public float top;
     public float right;
     public float bottom;

     /**
      * Create a new empty RectF. All coordinates are initialized to 0.
      */
     public RectF() {}

     /**
      * 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.
      *
      * @param left   The X coordinate of the left side of the rectangle
      * @param top    The Y coordinate of the top of the rectangle
      * @param right  The X coordinate of the right side of the rectangle
      * @param bottom The Y coordinate of the bottom of the rectangle
      */
     public RectF(float left, float top, float right, float bottom) {
         this.left = left;
         this.top = top;
         this.right = right;
         this.bottom = bottom;
     }

     /**
      * Create a new rectangle, initialized with the values in the specified
      * rectangle (which is left unmodified).
      *
      * @param r The rectangle whose coordinates are copied into the new
      *          rectangle.
      */
     public RectF(RectF r) {
         if (r == null) {
             left = top = right = bottom = 0.0f;
         } else {
             left = r.left;
             top = r.top;
             right = r.right;
             bottom = r.bottom;
         }
     }

     public RectF(Rect r) {
         if (r == null) {
             left = top = right = bottom = 0.0f;
         } else {
             left = r.left;
             top = r.top;
             right = r.right;
             bottom = r.bottom;
         }
     }

     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;

         RectF r = (RectF) o;
         return left == r.left && top == r.top && right == r.right && bottom == r.bottom;
     }

     @Override
     public int hashCode() {
         int result = (left != +0.0f ? Float.floatToIntBits(left) : 0);
         result = 31 * result + (top != +0.0f ? Float.floatToIntBits(top) : 0);
         result = 31 * result + (right != +0.0f ? Float.floatToIntBits(right) : 0);
         result = 31 * result + (bottom != +0.0f ? Float.floatToIntBits(bottom) : 0);
         return result;
     }

     public String toString() {
         return "RectF(" + left + ", " + top + ", "
                       + right + ", " + bottom + ")";
     }

     /**
      * Return a string representation of the rectangle in a compact form.
      */
     public String toShortString() {
         return toShortString(new StringBuilder(32));
     }

     /**
      * Return a string representation of the rectangle in a compact form.
      * @hide
      */
     public String toShortString(StringBuilder sb) {
         sb.setLength(0);
         sb.append('['); sb.append(left); sb.append(',');
         sb.append(top); sb.append("]["); sb.append(right);
         sb.append(','); sb.append(bottom); sb.append(']');
         return sb.toString();
     }

     /**
      * Print short representation to given writer.
      * @hide
      */
     public void printShortString(PrintWriter pw) {
         pw.print('['); pw.print(left); pw.print(',');
         pw.print(top); pw.print("]["); pw.print(right);
         pw.print(','); pw.print(bottom); pw.print(']');
     }

     /**
      * Returns true if the rectangle is empty (left >= right or top >= bottom)
      */
     public final boolean isEmpty() {
         return left >= right || top >= bottom;
     }

     /**
      * @return the rectangle's width. This does not check for a valid rectangle
      * (i.e. left <= right) so the result may be negative.
      */
     public final float width() {
         return right - left;
     }

     /**
      * @return the rectangle's height. This does not check for a valid rectangle
      * (i.e. top <= bottom) so the result may be negative.
      */
     public final float height() {
         return bottom - top;
     }

     /**
      * @return the horizontal center of the rectangle. This does not check for
      * a valid rectangle (i.e. left <= right)
      */
     public final float centerX() {
         return (left + right) * 0.5f;
     }

     /**
      * @return the vertical center of the rectangle. This does not check for
      * a valid rectangle (i.e. top <= bottom)
      */
     public final float centerY() {
         return (top + bottom) * 0.5f;
     }

     /**
      * Set the rectangle to (0,0,0,0)
      */
     public void setEmpty() {
         left = right = top = bottom = 0;
     }

     /**
      * 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 left   The X coordinate of the left side of the rectangle
      * @param top    The Y coordinate of the top of the rectangle
      * @param right  The X coordinate of the right side of the rectangle
      * @param bottom The Y coordinate of the bottom of the rectangle
      */
     public void set(float left, float top, float right, float bottom) {
         this.left   = left;
         this.top    = top;
         this.right  = right;
         this.bottom = bottom;
     }

     /**
      * Copy the coordinates from src into this rectangle.
      *
      * @param src The rectangle whose coordinates are copied into this
      *           rectangle.
      */
     public void set(RectF src) {
         this.left   = src.left;
         this.top    = src.top;
         this.right  = src.right;
         this.bottom = src.bottom;
     }

     /**
      * Copy the coordinates from src into this rectangle.
      *
      * @param src The rectangle whose coordinates are copied into this
      *           rectangle.
      */
     public void set(Rect src) {
         this.left   = src.left;
         this.top    = src.top;
         this.right  = src.right;
         this.bottom = src.bottom;
     }

     /**
      * Offset the rectangle by adding dx to its left and right coordinates, and
      * adding dy to its top and bottom coordinates.
      *
      * @param dx The amount to add to the rectangle's left and right coordinates
      * @param dy The amount to add to the rectangle's top and bottom coordinates
      */
     public void offset(float dx, float dy) {
         left    += dx;
         top     += dy;
         right   += dx;
         bottom  += dy;
     }

     /**
      * Offset the rectangle to a specific (left, top) position,
      * keeping its width and height the same.
      *
      * @param newLeft   The new "left" coordinate for the rectangle
      * @param newTop    The new "top" coordinate for the rectangle
      */
     public void offsetTo(float newLeft, float newTop) {
         right += newLeft - left;
         bottom += newTop - top;
         left = newLeft;
         top = newTop;
     }

     /**
      * 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 dx The amount to add(subtract) from the rectangle's left(right)
      * @param dy The amount to add(subtract) from the rectangle's top(bottom)
      */
     public void inset(float dx, float dy) {
         left    += dx;
         top     += dy;
         right   -= dx;
         bottom  -= dy;
     }

     /**
      * 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 x The X coordinate of the point being tested for containment
      * @param y The Y coordinate of the point being tested for containment
      * @return true iff (x,y) are contained by the rectangle, where containment
      *              means left <= x < right and top <= y < bottom
      */
     public boolean contains(float x, float y) {
         return left < right && top < bottom  // check for empty first
                 && x >= left && x < right && y >= top && y < 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.
      *
      * @param left The left side of the rectangle being tested for containment
      * @param top The top of the rectangle being tested for containment
      * @param right The right side of the rectangle being tested for containment
      * @param bottom The bottom of the rectangle being tested for containment
      * @return true iff the the 4 specified sides of a rectangle are inside or
      *              equal to this rectangle
      */
     public boolean contains(float left, float top, float right, float bottom) {
                 // check for empty first
         return this.left < this.right && this.top < this.bottom
                 // now check for containment
                 && this.left <= left && this.top <= top
                 && this.right >= right && this.bottom >= bottom;
     }

     /**
      * Returns true iff the specified rectangle r is inside or equal to this
      * rectangle. An empty rectangle never contains another rectangle.
      *
      * @param r The rectangle being tested for containment.
      * @return true iff the specified rectangle r is inside or equal to this
      *              rectangle
      */
     public boolean contains(RectF r) {
                 // check for empty first
         return this.left < this.right && this.top < this.bottom
                 // now check for containment
                 && left <= r.left && top <= r.top
                 && right >= r.right && bottom >= r.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()
      *
      * @param left The left side of the rectangle being intersected with this
      *             rectangle
      * @param top The top of the rectangle being intersected with this rectangle
      * @param right The right side of the rectangle being intersected with this
      *              rectangle.
      * @param bottom The bottom of the rectangle being intersected with this
      *             rectangle.
      * @return 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(float left, float top, float right, float bottom) {
         if (this.left < right && left < this.right
                 && this.top < bottom && top < this.bottom) {
             if (this.left < left) {
                 this.left = left;
             }
             if (this.top < top) {
                 this.top = top;
             }
             if (this.right > right) {
                 this.right = right;
             }
             if (this.bottom > bottom) {
                 this.bottom = bottom;
             }
             return true;
         }
         return false;
     }

     /**
      * 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 r The rectangle being intersected with this rectangle.
      * @return 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(RectF r) {
         return intersect(r.left, r.top, r.right, r.bottom);
     }

     /**
      * 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 a The first rectangle being intersected with
      * @param b The second rectangle being intersected with
      * @return 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 boolean setIntersect(RectF a, RectF b) {
         if (a.left < b.right && b.left < a.right
                 && a.top < b.bottom && b.top < a.bottom) {
             left = Math.max(a.left, b.left);
             top = Math.max(a.top, b.top);
             right = Math.min(a.right, b.right);
             bottom = Math.min(a.bottom, b.bottom);
             return true;
         }
         return false;
     }

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

     /**
      * 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 a The first rectangle being tested for intersection
      * @param b The second rectangle being tested for intersection
      * @return true iff the two specified rectangles intersect. In no event are
      *              either of the rectangles modified.
      */
     public static boolean intersects(RectF a, RectF b) {
         return a.left < b.right && b.left < a.right
                 && a.top < b.bottom && b.top < a.bottom;
     }

     /**
      * Set the dst integer Rect by rounding this rectangle's coordinates
      * to their nearest integer values.
      */
     public void round(Rect dst) {
         dst.set(FastMath.round(left), FastMath.round(top),
                 FastMath.round(right), FastMath.round(bottom));
     }

     /**
      * Set the dst integer Rect by rounding "out" this rectangle, choosing the
      * floor of top and left, and the ceiling of right and bottom.
      */
     public void roundOut(Rect dst) {
         dst.set((int) Math.floor(left), (int) Math.floor(top),
                 (int) Math.ceil(right), (int) Math.ceil(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.
      *
      * @param left The left edge being unioned with this rectangle
      * @param top The top edge being unioned with this rectangle
      * @param right The right edge being unioned with this rectangle
      * @param bottom The bottom edge being unioned with this rectangle
      */
     public void union(float left, float top, float right, float bottom) {
         if ((left < right) && (top < bottom)) {
             if ((this.left < this.right) && (this.top < this.bottom)) {
                 if (this.left > left)
                     this.left = left;
                 if (this.top > top)
                     this.top = top;
                 if (this.right < right)
                     this.right = right;
                 if (this.bottom < bottom)
                     this.bottom = bottom;
             } else {
                 this.left = left;
                 this.top = top;
                 this.right = right;
                 this.bottom = 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.
      *
      * @param r The rectangle being unioned with this rectangle
      */
     public void union(RectF r) {
         union(r.left, r.top, r.right, r.bottom);
     }

     /**
      * Update this Rect to enclose itself and the [x,y] coordinate. There is no
      * check to see that this rectangle is non-empty.
      *
      * @param x The x coordinate of the point to add to the rectangle
      * @param y The y coordinate of the point to add to the rectangle
      */
     public void union(float x, float y) {
         if (x < left) {
             left = x;
         } else if (x > right) {
             right = x;
         }
         if (y < top) {
             top = y;
         } else if (y > bottom) {
             bottom = y;
         }
     }

     /**
      * 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 void sort() {
         if (left > right) {
             float temp = left;
             left = right;
             right = temp;
         }
         if (top > bottom) {
             float temp = top;
             top = bottom;
             bottom = temp;
         }
     }

     /**
      * Parcelable interface methods
      */
     public int describeContents() {
         return 0;
     }

     /**
      * Write this rectangle to the specified parcel. To restore a rectangle from
      * a parcel, use readFromParcel()
      * @param out The parcel to write the rectangle's coordinates into
      */
     public void writeToParcel(Parcel out, int flags) {
         out.writeFloat(left);
         out.writeFloat(top);
         out.writeFloat(right);
         out.writeFloat(bottom);
     }

     public static final Parcelable.Creator<RectF> CREATOR = new Parcelable.Creator<RectF>() {
         /**
          * Return a new rectangle from the data in the specified parcel.
          */
         public RectF createFromParcel(Parcel in) {
             RectF r = new RectF();
             r.readFromParcel(in);
             return r;
         }

         /**
          * Return an array of rectangles of the specified size.
          */
         public RectF[] newArray(int size) {
             return new RectF[size];
         }
     };

     /**
      * Set the rectangle's coordinates from the data stored in the specified
      * parcel. To write a rectangle to a parcel, call writeToParcel().
      *
      * @param in The parcel to read the rectangle's coordinates from
      */
     public void readFromParcel(Parcel in) {
         left = in.readFloat();
         top = in.readFloat();
         right = in.readFloat();
         bottom = in.readFloat();
     }
 }
	/*
	* Copyright (C) 2006 The Android Open Source Project
	*
	* Licensed 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.
	*/

	package android.graphics;

	import java.io.PrintWriter;

	import android.os.Parcel;
	import android.os.Parcelable;
	import com.android.internal.util.FastMath;

	/**
	* 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).
	*/
	public class RectF implements Parcelable {
	public float left;
	public float top;
	public float right;
	public float bottom;

	/**
	* Create a new empty RectF. All coordinates are initialized to 0.
	*/
	public RectF() {}

	/**
	* 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.
	*
	* @param left The X coordinate of the left side of the rectangle
	* @param top The Y coordinate of the top of the rectangle
	* @param right The X coordinate of the right side of the rectangle
	* @param bottom The Y coordinate of the bottom of the rectangle
	*/
	public RectF(float left, float top, float right, float bottom) {
	this.left = left;
	this.top = top;
	this.right = right;
	this.bottom = bottom;
	}

	/**
	* Create a new rectangle, initialized with the values in the specified
	* rectangle (which is left unmodified).
	*
	* @param r The rectangle whose coordinates are copied into the new
	* rectangle.
	*/
	public RectF(RectF r) {
	if (r == null) {
	left = top = right = bottom = 0.0f;
	} else {
	left = r.left;
	top = r.top;
	right = r.right;
	bottom = r.bottom;
	}
	}

	public RectF(Rect r) {
	if (r == null) {
	left = top = right = bottom = 0.0f;
	} else {
	left = r.left;
	top = r.top;
	right = r.right;
	bottom = r.bottom;
	}
	}

	@Override
	public boolean equals(Object o) {
	if (this == o) return true;
	if (o == null \|\| getClass() != o.getClass()) return false;

	RectF r = (RectF) o;
	return left == r.left && top == r.top && right == r.right && bottom == r.bottom;
	}

	@Override
	public int hashCode() {
	int result = (left != +0.0f ? Float.floatToIntBits(left) : 0);
	result = 31 * result + (top != +0.0f ? Float.floatToIntBits(top) : 0);
	result = 31 * result + (right != +0.0f ? Float.floatToIntBits(right) : 0);
	result = 31 * result + (bottom != +0.0f ? Float.floatToIntBits(bottom) : 0);
	return result;
	}

	public String toString() {
	return "RectF(" + left + ", " + top + ", "
	+ right + ", " + bottom + ")";
	}

	/**
	* Return a string representation of the rectangle in a compact form.
	*/
	public String toShortString() {
	return toShortString(new StringBuilder(32));
	}

	/**
	* Return a string representation of the rectangle in a compact form.
	* @hide
	*/
	public String toShortString(StringBuilder sb) {
	sb.setLength(0);
	sb.append('['); sb.append(left); sb.append(',');
	sb.append(top); sb.append("]["); sb.append(right);
	sb.append(','); sb.append(bottom); sb.append(']');
	return sb.toString();
	}

	/**
	* Print short representation to given writer.
	* @hide
	*/
	public void printShortString(PrintWriter pw) {
	pw.print('['); pw.print(left); pw.print(',');
	pw.print(top); pw.print("]["); pw.print(right);
	pw.print(','); pw.print(bottom); pw.print(']');
	}

	/**
	* Returns true if the rectangle is empty (left >= right or top >= bottom)
	*/
	public final boolean isEmpty() {
	return left >= right \|\| top >= bottom;
	}

	/**
	* @return the rectangle's width. This does not check for a valid rectangle
	* (i.e. left <= right) so the result may be negative.
	*/
	public final float width() {
	return right - left;
	}

	/**
	* @return the rectangle's height. This does not check for a valid rectangle
	* (i.e. top <= bottom) so the result may be negative.
	*/
	public final float height() {
	return bottom - top;
	}

	/**
	* @return the horizontal center of the rectangle. This does not check for
	* a valid rectangle (i.e. left <= right)
	*/
	public final float centerX() {
	return (left + right) * 0.5f;
	}

	/**
	* @return the vertical center of the rectangle. This does not check for
	* a valid rectangle (i.e. top <= bottom)
	*/
	public final float centerY() {
	return (top + bottom) * 0.5f;
	}

	/**
	* Set the rectangle to (0,0,0,0)
	*/
	public void setEmpty() {
	left = right = top = bottom = 0;
	}

	/**
	* 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 left The X coordinate of the left side of the rectangle
	* @param top The Y coordinate of the top of the rectangle
	* @param right The X coordinate of the right side of the rectangle
	* @param bottom The Y coordinate of the bottom of the rectangle
	*/
	public void set(float left, float top, float right, float bottom) {
	this.left = left;
	this.top = top;
	this.right = right;
	this.bottom = bottom;
	}

	/**
	* Copy the coordinates from src into this rectangle.
	*
	* @param src The rectangle whose coordinates are copied into this
	* rectangle.
	*/
	public void set(RectF src) {
	this.left = src.left;
	this.top = src.top;
	this.right = src.right;
	this.bottom = src.bottom;
	}

	/**
	* Copy the coordinates from src into this rectangle.
	*
	* @param src The rectangle whose coordinates are copied into this
	* rectangle.
	*/
	public void set(Rect src) {
	this.left = src.left;
	this.top = src.top;
	this.right = src.right;
	this.bottom = src.bottom;
	}

	/**
	* Offset the rectangle by adding dx to its left and right coordinates, and
	* adding dy to its top and bottom coordinates.
	*
	* @param dx The amount to add to the rectangle's left and right coordinates
	* @param dy The amount to add to the rectangle's top and bottom coordinates
	*/
	public void offset(float dx, float dy) {
	left += dx;
	top += dy;
	right += dx;
	bottom += dy;
	}

	/**
	* Offset the rectangle to a specific (left, top) position,
	* keeping its width and height the same.
	*
	* @param newLeft The new "left" coordinate for the rectangle
	* @param newTop The new "top" coordinate for the rectangle
	*/
	public void offsetTo(float newLeft, float newTop) {
	right += newLeft - left;
	bottom += newTop - top;
	left = newLeft;
	top = newTop;
	}

	/**
	* 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 dx The amount to add(subtract) from the rectangle's left(right)
	* @param dy The amount to add(subtract) from the rectangle's top(bottom)
	*/
	public void inset(float dx, float dy) {
	left += dx;
	top += dy;
	right -= dx;
	bottom -= dy;
	}

	/**
	* 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 x The X coordinate of the point being tested for containment
	* @param y The Y coordinate of the point being tested for containment
	* @return true iff (x,y) are contained by the rectangle, where containment
	* means left <= x < right and top <= y < bottom
	*/
	public boolean contains(float x, float y) {
	return left < right && top < bottom // check for empty first
	&& x >= left && x < right && y >= top && y < 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.
	*
	* @param left The left side of the rectangle being tested for containment
	* @param top The top of the rectangle being tested for containment
	* @param right The right side of the rectangle being tested for containment
	* @param bottom The bottom of the rectangle being tested for containment
	* @return true iff the the 4 specified sides of a rectangle are inside or
	* equal to this rectangle
	*/
	public boolean contains(float left, float top, float right, float bottom) {
	// check for empty first
	return this.left < this.right && this.top < this.bottom
	// now check for containment
	&& this.left <= left && this.top <= top
	&& this.right >= right && this.bottom >= bottom;
	}

	/**
	* Returns true iff the specified rectangle r is inside or equal to this
	* rectangle. An empty rectangle never contains another rectangle.
	*
	* @param r The rectangle being tested for containment.
	* @return true iff the specified rectangle r is inside or equal to this
	* rectangle
	*/
	public boolean contains(RectF r) {
	// check for empty first
	return this.left < this.right && this.top < this.bottom
	// now check for containment
	&& left <= r.left && top <= r.top
	&& right >= r.right && bottom >= r.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()
	*
	* @param left The left side of the rectangle being intersected with this
	* rectangle
	* @param top The top of the rectangle being intersected with this rectangle
	* @param right The right side of the rectangle being intersected with this
	* rectangle.
	* @param bottom The bottom of the rectangle being intersected with this
	* rectangle.
	* @return 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(float left, float top, float right, float bottom) {
	if (this.left < right && left < this.right
	&& this.top < bottom && top < this.bottom) {
	if (this.left < left) {
	this.left = left;
	}
	if (this.top < top) {
	this.top = top;
	}
	if (this.right > right) {
	this.right = right;
	}
	if (this.bottom > bottom) {
	this.bottom = bottom;
	}
	return true;
	}
	return false;
	}

	/**
	* 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 r The rectangle being intersected with this rectangle.
	* @return 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(RectF r) {
	return intersect(r.left, r.top, r.right, r.bottom);
	}

	/**
	* 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 a The first rectangle being intersected with
	* @param b The second rectangle being intersected with
	* @return 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 boolean setIntersect(RectF a, RectF b) {
	if (a.left < b.right && b.left < a.right
	&& a.top < b.bottom && b.top < a.bottom) {
	left = Math.max(a.left, b.left);
	top = Math.max(a.top, b.top);
	right = Math.min(a.right, b.right);
	bottom = Math.min(a.bottom, b.bottom);
	return true;
	}
	return false;
	}

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

	/**
	* 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 a The first rectangle being tested for intersection
	* @param b The second rectangle being tested for intersection
	* @return true iff the two specified rectangles intersect. In no event are
	* either of the rectangles modified.
	*/
	public static boolean intersects(RectF a, RectF b) {
	return a.left < b.right && b.left < a.right
	&& a.top < b.bottom && b.top < a.bottom;
	}

	/**
	* Set the dst integer Rect by rounding this rectangle's coordinates
	* to their nearest integer values.
	*/
	public void round(Rect dst) {
	dst.set(FastMath.round(left), FastMath.round(top),
	FastMath.round(right), FastMath.round(bottom));
	}

	/**
	* Set the dst integer Rect by rounding "out" this rectangle, choosing the
	* floor of top and left, and the ceiling of right and bottom.
	*/
	public void roundOut(Rect dst) {
	dst.set((int) Math.floor(left), (int) Math.floor(top),
	(int) Math.ceil(right), (int) Math.ceil(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.
	*
	* @param left The left edge being unioned with this rectangle
	* @param top The top edge being unioned with this rectangle
	* @param right The right edge being unioned with this rectangle
	* @param bottom The bottom edge being unioned with this rectangle
	*/
	public void union(float left, float top, float right, float bottom) {
	if ((left < right) && (top < bottom)) {
	if ((this.left < this.right) && (this.top < this.bottom)) {
	if (this.left > left)
	this.left = left;
	if (this.top > top)
	this.top = top;
	if (this.right < right)
	this.right = right;
	if (this.bottom < bottom)
	this.bottom = bottom;
	} else {
	this.left = left;
	this.top = top;
	this.right = right;
	this.bottom = 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.
	*
	* @param r The rectangle being unioned with this rectangle
	*/
	public void union(RectF r) {
	union(r.left, r.top, r.right, r.bottom);
	}

	/**
	* Update this Rect to enclose itself and the [x,y] coordinate. There is no
	* check to see that this rectangle is non-empty.
	*
	* @param x The x coordinate of the point to add to the rectangle
	* @param y The y coordinate of the point to add to the rectangle
	*/
	public void union(float x, float y) {
	if (x < left) {
	left = x;
	} else if (x > right) {
	right = x;
	}
	if (y < top) {
	top = y;
	} else if (y > bottom) {
	bottom = y;
	}
	}

	/**
	* 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 void sort() {
	if (left > right) {
	float temp = left;
	left = right;
	right = temp;
	}
	if (top > bottom) {
	float temp = top;
	top = bottom;
	bottom = temp;
	}
	}

	/**
	* Parcelable interface methods
	*/
	public int describeContents() {
	return 0;
	}

	/**
	* Write this rectangle to the specified parcel. To restore a rectangle from
	* a parcel, use readFromParcel()
	* @param out The parcel to write the rectangle's coordinates into
	*/
	public void writeToParcel(Parcel out, int flags) {
	out.writeFloat(left);
	out.writeFloat(top);
	out.writeFloat(right);
	out.writeFloat(bottom);
	}

	public static final Parcelable.Creator<RectF> CREATOR = new Parcelable.Creator<RectF>() {
	/**
	* Return a new rectangle from the data in the specified parcel.
	*/
	public RectF createFromParcel(Parcel in) {
	RectF r = new RectF();
	r.readFromParcel(in);
	return r;
	}

	/**
	* Return an array of rectangles of the specified size.
	*/
	public RectF[] newArray(int size) {
	return new RectF[size];
	}
	};

	/**
	* Set the rectangle's coordinates from the data stored in the specified
	* parcel. To write a rectangle to a parcel, call writeToParcel().
	*
	* @param in The parcel to read the rectangle's coordinates from
	*/
	public void readFromParcel(Parcel in) {
	left = in.readFloat();
	top = in.readFloat();
	right = in.readFloat();
	bottom = in.readFloat();
	}
	}