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