Rect.h revision b2e19208ddf3274e7cc044ca1abfcd02787a7cf1 
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
26namespace android {
27
28class Rect : public ARect, public LightFlattenablePod<Rect>
29{
30public:
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      left = right = top = bottom = 0;
38    }
39
40    inline Rect(int32_t w, int32_t h) {
41        left = top = 0;
42        right = w;
43        bottom = h;
44    }
45
46    inline Rect(int32_t l, int32_t t, int32_t r, int32_t b) {
47        left = l;
48        top = t;
49        right = r;
50        bottom = b;
51    }
52
53    inline Rect(const Point& lt, const Point& rb) {
54        left = lt.x;
55        top = lt.y;
56        right = rb.x;
57        bottom = rb.y;
58    }
59
60    void makeInvalid();
61
62    inline void clear() {
63        left = top = right = bottom = 0;
64    }
65
66    // a valid rectangle has a non negative width and height
67    inline bool isValid() const {
68        return (getWidth() >= 0) && (getHeight() >= 0);
69    }
70
71    // an empty rect has a zero width or height, or is invalid
72    inline bool isEmpty() const {
73        return (getWidth() <= 0) || (getHeight() <= 0);
74    }
75
76    // rectangle's width
77    inline int32_t getWidth() const {
78        return right - left;
79    }
80
81    // rectangle's height
82    inline int32_t getHeight() const {
83        return bottom - top;
84    }
85
86    inline Rect getBounds() const {
87        return Rect(right - left, bottom - top);
88    }
89
90    void setLeftTop(const Point& lt) {
91        left = lt.x;
92        top = lt.y;
93    }
94
95    void setRightBottom(const Point& rb) {
96        right = rb.x;
97        bottom = rb.y;
98    }
99
100    // the following 4 functions return the 4 corners of the rect as Point
101    Point leftTop() const {
102        return Point(left, top);
103    }
104    Point rightBottom() const {
105        return Point(right, bottom);
106    }
107    Point rightTop() const {
108        return Point(right, top);
109    }
110    Point leftBottom() const {
111        return Point(left, bottom);
112    }
113
114    // comparisons
115    inline bool operator == (const Rect& rhs) const {
116        return (left == rhs.left) && (top == rhs.top) &&
117               (right == rhs.right) && (bottom == rhs.bottom);
118    }
119
120    inline bool operator != (const Rect& rhs) const {
121        return !operator == (rhs);
122    }
123
124    // operator < defines an order which allows to use rectangles in sorted
125    // vectors.
126    bool operator < (const Rect& rhs) const;
127
128    const Rect operator + (const Point& rhs) const;
129    const Rect operator - (const Point& rhs) const;
130
131    Rect& operator += (const Point& rhs) {
132        return offsetBy(rhs.x, rhs.y);
133    }
134    Rect& operator -= (const Point& rhs) {
135        return offsetBy(-rhs.x, -rhs.y);
136    }
137
138    Rect& offsetToOrigin() {
139        right -= left;
140        bottom -= top;
141        left = top = 0;
142        return *this;
143    }
144    Rect& offsetTo(const Point& p) {
145        return offsetTo(p.x, p.y);
146    }
147    Rect& offsetBy(const Point& dp) {
148        return offsetBy(dp.x, dp.y);
149    }
150
151    Rect& offsetTo(int32_t x, int32_t y);
152    Rect& offsetBy(int32_t x, int32_t y);
153
154    bool intersect(const Rect& with, Rect* result) const;
155
156    // Create a new Rect by transforming this one using a graphics HAL
157    // transform.  This rectangle is defined in a coordinate space starting at
158    // the origin and extending to (width, height).  If the transform includes
159    // a ROT90 then the output rectangle is defined in a space extending to
160    // (height, width).  Otherwise the output rectangle is in the same space as
161    // the input.
162    Rect transform(uint32_t xform, int32_t width, int32_t height) const;
163
164    // this calculates (Region(*this) - exclude).bounds() efficiently
165    Rect reduce(const Rect& exclude) const;
166
167
168    // for backward compatibility
169    inline int32_t width() const { return getWidth(); }
170    inline int32_t height() const { return getHeight(); }
171    inline void set(const Rect& rhs) { operator = (rhs); }
172};
173
174ANDROID_BASIC_TYPES_TRAITS(Rect)
175
176}; // namespace android
177
178#endif // ANDROID_UI_RECT
179