Home | History | Annotate | Download | only in ui 
      1 /*
      2  * Copyright (C) 2006 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #ifndef ANDROID_UI_RECT
     18 #define ANDROID_UI_RECT
     19 
     20 #include <utils/Flattenable.h>
     21 #include <utils/TypeHelpers.h>
     22 #include <ui/Point.h>
     23 
     24 #include <android/rect.h>
     25 
     26 namespace android {
     27 
     28 class Rect : public ARect, public LightFlattenablePod<Rect>
     29 {
     30 public:
     31     typedef ARect::value_type value_type;
     32 
     33     // we don't provide copy-ctor and operator= on purpose
     34     // because we want the compiler generated versions
     35 
     36     inline Rect() {
     37     }
     38 
     39     inline Rect(int32_t w, int32_t h) {
     40         left = top = 0;
     41         right = w;
     42         bottom = h;
     43     }
     44 
     45     inline Rect(int32_t l, int32_t t, int32_t r, int32_t b) {
     46         left = l;
     47         top = t;
     48         right = r;
     49         bottom = b;
     50     }
     51 
     52     inline Rect(const Point& lt, const Point& rb) {
     53         left = lt.x;
     54         top = lt.y;
     55         right = rb.x;
     56         bottom = rb.y;
     57     }
     58 
     59     void makeInvalid();
     60 
     61     inline void clear() {
     62         left = top = right = bottom = 0;
     63     }
     64 
     65     // a valid rectangle has a non negative width and height
     66     inline bool isValid() const {
     67         return (getWidth() >= 0) && (getHeight() >= 0);
     68     }
     69 
     70     // an empty rect has a zero width or height, or is invalid
     71     inline bool isEmpty() const {
     72         return (getWidth() <= 0) || (getHeight() <= 0);
     73     }
     74 
     75     // rectangle's width
     76     inline int32_t getWidth() const {
     77         return right - left;
     78     }
     79 
     80     // rectangle's height
     81     inline int32_t getHeight() const {
     82         return bottom - top;
     83     }
     84 
     85     inline Rect getBounds() const {
     86         return Rect(right - left, bottom - top);
     87     }
     88 
     89     void setLeftTop(const Point& lt) {
     90         left = lt.x;
     91         top = lt.y;
     92     }
     93 
     94     void setRightBottom(const Point& rb) {
     95         right = rb.x;
     96         bottom = rb.y;
     97     }
     98 
     99     // the following 4 functions return the 4 corners of the rect as Point
    100     Point leftTop() const {
    101         return Point(left, top);
    102     }
    103     Point rightBottom() const {
    104         return Point(right, bottom);
    105     }
    106     Point rightTop() const {
    107         return Point(right, top);
    108     }
    109     Point leftBottom() const {
    110         return Point(left, bottom);
    111     }
    112 
    113     // comparisons
    114     inline bool operator == (const Rect& rhs) const {
    115         return (left == rhs.left) && (top == rhs.top) &&
    116                (right == rhs.right) && (bottom == rhs.bottom);
    117     }
    118 
    119     inline bool operator != (const Rect& rhs) const {
    120         return !operator == (rhs);
    121     }
    122 
    123     // operator < defines an order which allows to use rectangles in sorted
    124     // vectors.
    125     bool operator < (const Rect& rhs) const;
    126 
    127     const Rect operator + (const Point& rhs) const;
    128     const Rect operator - (const Point& rhs) const;
    129 
    130     Rect& operator += (const Point& rhs) {
    131         return offsetBy(rhs.x, rhs.y);
    132     }
    133     Rect& operator -= (const Point& rhs) {
    134         return offsetBy(-rhs.x, -rhs.y);
    135     }
    136 
    137     Rect& offsetToOrigin() {
    138         right -= left;
    139         bottom -= top;
    140         left = top = 0;
    141         return *this;
    142     }
    143     Rect& offsetTo(const Point& p) {
    144         return offsetTo(p.x, p.y);
    145     }
    146     Rect& offsetBy(const Point& dp) {
    147         return offsetBy(dp.x, dp.y);
    148     }
    149 
    150     Rect& offsetTo(int32_t x, int32_t y);
    151     Rect& offsetBy(int32_t x, int32_t y);
    152 
    153     bool intersect(const Rect& with, Rect* result) const;
    154 
    155     // Create a new Rect by transforming this one using a graphics HAL
    156     // transform.  This rectangle is defined in a coordinate space starting at
    157     // the origin and extending to (width, height).  If the transform includes
    158     // a ROT90 then the output rectangle is defined in a space extending to
    159     // (height, width).  Otherwise the output rectangle is in the same space as
    160     // the input.
    161     Rect transform(uint32_t xform, int32_t width, int32_t height) const;
    162 
    163     // this calculates (Region(*this) - exclude).bounds() efficiently
    164     Rect reduce(const Rect& exclude) const;
    165 
    166 
    167     // for backward compatibility
    168     inline int32_t width() const { return getWidth(); }
    169     inline int32_t height() const { return getHeight(); }
    170     inline void set(const Rect& rhs) { operator = (rhs); }
    171 };
    172 
    173 ANDROID_BASIC_TYPES_TRAITS(Rect)
    174 
    175 }; // namespace android
    176 
    177 #endif // ANDROID_UI_RECT
    178