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/TypeHelpers.h>
     21 #include <ui/Point.h>
     22 
     23 #include <android/rect.h>
     24 
     25 namespace android {
     26 
     27 class Rect : public ARect
     28 {
     29 public:
     30     typedef int32_t value_type;
     31 
     32     // we don't provide copy-ctor and operator= on purpose
     33     // because we want the compiler generated versions
     34 
     35     inline Rect() {
     36     }
     37     inline Rect(int32_t w, int32_t h) {
     38         left = top = 0; right = w; bottom = h;
     39     }
     40     inline Rect(int32_t l, int32_t t, int32_t r, int32_t b) {
     41         left = l; top = t; right = r; bottom = b;
     42     }
     43     inline Rect(const Point& lt, const Point& rb) {
     44         left = lt.x; top = lt.y; right = rb.x; bottom = rb.y;
     45     }
     46 
     47     void makeInvalid();
     48 
     49     inline void clear() {
     50         left = top = right = bottom = 0;
     51     }
     52 
     53     // a valid rectangle has a non negative width and height
     54     inline bool isValid() const {
     55         return (width()>=0) && (height()>=0);
     56     }
     57 
     58     // an empty rect has a zero width or height, or is invalid
     59     inline bool isEmpty() const {
     60         return (width()<=0) || (height()<=0);
     61     }
     62 
     63     inline void set(const Rect& rhs) {
     64         operator = (rhs);
     65     }
     66 
     67     // rectangle's width
     68     inline int32_t width() const {
     69         return right-left;
     70     }
     71 
     72     // rectangle's height
     73     inline int32_t height() const {
     74         return bottom-top;
     75     }
     76 
     77     void setLeftTop(const Point& lt) {
     78         left = lt.x;
     79         top  = lt.y;
     80     }
     81 
     82     void setRightBottom(const Point& rb) {
     83         right = rb.x;
     84         bottom  = rb.y;
     85     }
     86 
     87     // the following 4 functions return the 4 corners of the rect as Point
     88     Point leftTop() const {
     89         return Point(left, top);
     90     }
     91     Point rightBottom() const {
     92         return Point(right, bottom);
     93     }
     94     Point rightTop() const {
     95         return Point(right, top);
     96     }
     97     Point leftBottom() const {
     98         return Point(left, bottom);
     99     }
    100 
    101     // comparisons
    102     inline bool operator == (const Rect& rhs) const {
    103         return (left == rhs.left) && (top == rhs.top) &&
    104                (right == rhs.right) && (bottom == rhs.bottom);
    105     }
    106 
    107     inline bool operator != (const Rect& rhs) const {
    108         return !operator == (rhs);
    109     }
    110 
    111     // operator < defines an order which allows to use rectangles in sorted
    112     // vectors.
    113     bool operator < (const Rect& rhs) const;
    114 
    115     Rect& offsetToOrigin() {
    116         right -= left;
    117         bottom -= top;
    118         left = top = 0;
    119         return *this;
    120     }
    121     Rect& offsetTo(const Point& p) {
    122         return offsetTo(p.x, p.y);
    123     }
    124     Rect& offsetBy(const Point& dp) {
    125         return offsetBy(dp.x, dp.y);
    126     }
    127     Rect& operator += (const Point& rhs) {
    128         return offsetBy(rhs.x, rhs.y);
    129     }
    130     Rect& operator -= (const Point& rhs) {
    131         return offsetBy(-rhs.x, -rhs.y);
    132     }
    133     const Rect operator + (const Point& rhs) const;
    134     const Rect operator - (const Point& rhs) const;
    135 
    136     void translate(int32_t dx, int32_t dy) { // legacy, don't use.
    137         offsetBy(dx, dy);
    138     }
    139 
    140     Rect&   offsetTo(int32_t x, int32_t y);
    141     Rect&   offsetBy(int32_t x, int32_t y);
    142     bool    intersect(const Rect& with, Rect* result) const;
    143 };
    144 
    145 ANDROID_BASIC_TYPES_TRAITS(Rect)
    146 
    147 }; // namespace android
    148 
    149 #endif // ANDROID_UI_RECT
    150