Rect.h revision f3e85d432749ca77ad707bec523b67d741d43e6e 
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    }
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
173ANDROID_BASIC_TYPES_TRAITS(Rect)
174
175}; // namespace android
176
177#endif // ANDROID_UI_RECT
178