IT. Expert System.

Android Reference

RectF


android.graphics

Class RectF

  • All Implemented Interfaces:
    Parcelable


    public class RectF
    extends Object
    implements Parcelable
    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).
    • Constructor Summary

      Constructors
      Constructor and Description
      RectF()
      Create a new empty RectF.
      RectF(float left, float top, float right, float bottom)
      Create a new rectangle with the specified coordinates.
      RectF(Rect r)
      RectF(RectF r)
      Create a new rectangle, initialized with the values in the specified rectangle (which is left unmodified).
    • Method Summary

      Methods
      Modifier and Type Method and Description
      float centerX()
      float centerY()
      boolean contains(float x, float y)
      Returns true if (x,y) is inside the rectangle.
      boolean contains(float left, float top, float right, float bottom)
      Returns true iff the 4 specified sides of a rectangle are inside or equal to this rectangle.
      boolean contains(RectF r)
      Returns true iff the specified rectangle r is inside or equal to this rectangle.
      int describeContents()
      Parcelable interface methods
      boolean equals(Object o)
      Compares this instance with the specified object and indicates if they are equal.
      int hashCode()
      Returns an integer hash code for this object.
      float height()
      void inset(float dx, float dy)
      Inset the rectangle by (dx,dy).
      boolean intersect(float left, float top, float right, float 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.
      boolean intersect(RectF 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.
      boolean intersects(float left, float top, float right, float bottom)
      Returns true if this rectangle intersects the specified rectangle.
      static boolean intersects(RectF a, RectF b)
      Returns true iff the two specified rectangles intersect.
      boolean isEmpty()
      Returns true if the rectangle is empty (left >= right or top >= bottom)
      void offset(float dx, float dy)
      Offset the rectangle by adding dx to its left and right coordinates, and adding dy to its top and bottom coordinates.
      void offsetTo(float newLeft, float newTop)
      Offset the rectangle to a specific (left, top) position, keeping its width and height the same.
      void printShortString(PrintWriter pw)
      Print short representation to given writer.
      void readFromParcel(Parcel in)
      Set the rectangle's coordinates from the data stored in the specified parcel.
      void round(Rect dst)
      Set the dst integer Rect by rounding this rectangle's coordinates to their nearest integer values.
      void roundOut(Rect dst)
      Set the dst integer Rect by rounding "out" this rectangle, choosing the floor of top and left, and the ceiling of right and bottom.
      void set(float left, float top, float right, float bottom)
      Set the rectangle's coordinates to the specified values.
      void set(Rect src)
      Copy the coordinates from src into this rectangle.
      void set(RectF src)
      Copy the coordinates from src into this rectangle.
      void setEmpty()
      Set the rectangle to (0,0,0,0)
      boolean setIntersect(RectF a, RectF 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.
      void sort()
      Swap top/bottom or left/right if there are flipped (i.e.
      String toShortString()
      Return a string representation of the rectangle in a compact form.
      String toShortString(StringBuilder sb)
      Return a string representation of the rectangle in a compact form.
      String toString()
      Returns a string containing a concise, human-readable description of this object.
      void union(float x, float y)
      Update this Rect to enclose itself and the [x,y] coordinate.
      void union(float left, float top, float right, float bottom)
      Update this Rect to enclose itself and the specified rectangle.
      void union(RectF r)
      Update this Rect to enclose itself and the specified rectangle.
      float width()
      void writeToParcel(Parcel out, int flags)
      Write this rectangle to the specified parcel.
    • Field Detail

      • left

        public float left
      • top

        public float top
      • right

        public float right
      • bottom

        public float bottom
    • Constructor Detail

      • RectF

        public RectF()
        Create a new empty RectF. All coordinates are initialized to 0.
      • RectF

        public RectF(float left,
             float top,
             float right,
             float 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 rectangle
        top - The Y coordinate of the top of the rectangle
        right - The X coordinate of the right side of the rectangle
        bottom - The Y coordinate of the bottom of the rectangle
      • RectF

        public RectF(RectF 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.
      • RectF

        public RectF(Rect r)
    • Method Detail

      • equals

        public boolean equals(Object o)
        Description copied from class: Object
        Compares this instance with the specified object and indicates if they are equal. In order to be equal, o must represent the same object as this instance using a class-specific comparison. The general contract is that this comparison should be reflexive, symmetric, and transitive. Also, no object reference other than null is equal to null.

        The default implementation returns true only if this == o. See Writing a correct equals method if you intend implementing your own equals method.

        The general contract for the equals and Object.hashCode() methods is that if equals returns true for any two objects, then hashCode() must return the same value for these objects. This means that subclasses of Object usually override either both methods or neither of them.

        Overrides:
        equals in class Object
        Parameters:
        o - the object to compare this instance with.
        Returns:
        true if the specified object is equal to this Object; false otherwise.
        See Also:
        Object.hashCode()
      • hashCode

        public int hashCode()
        Description copied from class: Object
        Returns an integer hash code for this object. By contract, any two objects for which Object.equals(java.lang.Object) returns true must return the same hash code value. This means that subclasses of Object usually override both methods or neither method.

        Note that hash values must not change over time unless information used in equals comparisons also changes.

        See Writing a correct hashCode method if you intend implementing your own hashCode method.

        Overrides:
        hashCode in class Object
        Returns:
        this object's hash code.
        See Also:
        Object.equals(java.lang.Object)
      • toString

        public String toString()
        Description copied from class: Object
        Returns a string containing a concise, human-readable description of this object. Subclasses are encouraged to override this method and provide an implementation that takes into account the object's type and data. The default implementation is equivalent to the following expression:
           getClass().getName() + '@' + Integer.toHexString(hashCode())

        See Writing a useful toString method if you intend implementing your own toString method.

        Overrides:
        toString in class Object
        Returns:
        a printable representation of this object.
      • toShortString

        public String toShortString()
        Return a string representation of the rectangle in a compact form.
      • toShortString

        public String toShortString(StringBuilder sb)
        Return a string representation of the rectangle in a compact form.
      • printShortString

        public void printShortString(PrintWriter pw)
        Print short representation to given writer.
      • isEmpty

        public final boolean isEmpty()
        Returns true if the rectangle is empty (left >= right or top >= bottom)
      • width

        public final float width()
        Returns:
        the rectangle's width. This does not check for a valid rectangle (i.e. left <= right) so the result may be negative.
      • height

        public final float height()
        Returns:
        the rectangle's height. This does not check for a valid rectangle (i.e. top <= bottom) so the result may be negative.
      • centerX

        public final float centerX()
        Returns:
        the horizontal center of the rectangle. This does not check for a valid rectangle (i.e. left <= right)
      • centerY

        public final float centerY()
        Returns:
        the vertical center of the rectangle. This does not check for a valid rectangle (i.e. top <= bottom)
      • setEmpty

        public void setEmpty()
        Set the rectangle to (0,0,0,0)
      • set

        public void set(float left,
               float top,
               float right,
               float 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 rectangle
        top - The Y coordinate of the top of the rectangle
        right - The X coordinate of the right side of the rectangle
        bottom - The Y coordinate of the bottom of the rectangle
      • set

        public void set(RectF src)
        Copy the coordinates from src into this rectangle.
        Parameters:
        src - The rectangle whose coordinates are copied into this rectangle.
      • set

        public void set(Rect src)
        Copy the coordinates from src into this rectangle.
        Parameters:
        src - The rectangle whose coordinates are copied into this rectangle.
      • offset

        public void offset(float dx,
                  float 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
      • offsetTo

        public void offsetTo(float newLeft,
                    float 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
      • inset

        public void inset(float dx,
                 float 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)
      • contains

        public boolean contains(float x,
                       float 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
      • contains

        public boolean contains(float left,
                       float top,
                       float right,
                       float 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
      • contains

        public boolean contains(RectF 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
      • intersect

        public boolean intersect(float left,
                        float top,
                        float right,
                        float 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.
      • intersect

        public boolean intersect(RectF 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.
      • setIntersect

        public boolean setIntersect(RectF a,
                           RectF 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.
      • intersects

        public boolean intersects(float left,
                         float top,
                         float right,
                         float 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.
      • intersects

        public static boolean intersects(RectF a,
                         RectF 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.
      • round

        public void round(Rect dst)
        Set the dst integer Rect by rounding this rectangle's coordinates to their nearest integer values.
      • roundOut

        public void roundOut(Rect dst)
        Set the dst integer Rect by rounding "out" this rectangle, choosing the floor of top and left, and the ceiling of right and bottom.
      • union

        public void union(float left,
                 float top,
                 float right,
                 float 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
      • union

        public void union(RectF 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
      • union

        public void union(float x,
                 float 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
      • sort

        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.
      • describeContents

        public int describeContents()
        Parcelable interface methods
        Specified by:
        describeContents in interface Parcelable
        Returns:
        a bitmask indicating the set of special object types marshalled by the Parcelable.
      • writeToParcel

        public void writeToParcel(Parcel out,
                         int flags)
        Write this rectangle to the specified parcel. To restore a rectangle from a parcel, use readFromParcel()
        Specified by:
        writeToParcel in interface Parcelable
        Parameters:
        out - The parcel to write the rectangle's coordinates into
        flags - Additional flags about how the object should be written. May be 0 or Parcelable.PARCELABLE_WRITE_RETURN_VALUE.
      • readFromParcel

        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


Content

Android Reference

Java basics

Java Enterprise Edition (EE)

Java Standard Edition (SE)

SQL

HTML

PHP

CSS

Java Script

MYSQL

JQUERY

VBS

REGEX

C

C++

C#

Design patterns

RFC (standard status)

RFC (proposed standard status)

RFC (draft standard status)

RFC (informational status)

RFC (experimental status)

RFC (best current practice status)

RFC (historic status)

RFC (unknown status)

IT dictionary

License.
All information of this service is derived from the free sources and is provided solely in the form of quotations. This service provides information and interfaces solely for the familiarization (not ownership) and under the "as is" condition.
Copyright 2016 © ELTASK.COM. All rights reserved.
Site is optimized for mobile devices.
Downloads: 865 / . Delta: 0.04903 с