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 ARect::value_type value_type;
31 
32     // we don't provide copy-ctor and operator= on purpose
33     // because we want the compiler generated versions
34 
Rect()35     inline Rect() {
36     }
Rect(int32_t w,int32_t h)37     inline Rect(int32_t w, int32_t h) {
38         left = top = 0; right = w; bottom = h;
39     }
Rect(int32_t l,int32_t t,int32_t r,int32_t b)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     }
Rect(const Point & lt,const Point & rb)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 
clear()49     inline void clear() {
50         left = top = right = bottom = 0;
51     }
52 
53     // a valid rectangle has a non negative width and height
isValid()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
isEmpty()59     inline bool isEmpty() const {
60         return (width()<=0) || (height()<=0);
61     }
62 
set(const Rect & rhs)63     inline void set(const Rect& rhs) {
64         operator = (rhs);
65     }
66 
67     // rectangle's width
width()68     inline int32_t width() const {
69         return right-left;
70     }
71 
72     // rectangle's height
height()73     inline int32_t height() const {
74         return bottom-top;
75     }
76 
setLeftTop(const Point & lt)77     void setLeftTop(const Point& lt) {
78         left = lt.x;
79         top  = lt.y;
80     }
81 
setRightBottom(const Point & rb)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
leftTop()88     Point leftTop() const {
89         return Point(left, top);
90     }
rightBottom()91     Point rightBottom() const {
92         return Point(right, bottom);
93     }
rightTop()94     Point rightTop() const {
95         return Point(right, top);
96     }
leftBottom()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 
offsetToOrigin()115     Rect& offsetToOrigin() {
116         right -= left;
117         bottom -= top;
118         left = top = 0;
119         return *this;
120     }
offsetTo(const Point & p)121     Rect& offsetTo(const Point& p) {
122         return offsetTo(p.x, p.y);
123     }
offsetBy(const Point & dp)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 
translate(int32_t dx,int32_t dy)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