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