Rect.h revision 59332804306c054082a39e9b004146bd03ae1d30 
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
25namespace android {
26
27class Rect : public ARect
28{
29public:
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
35    inline Rect() {
36    }
37    inline Rect(int32_t w, int32_t h) {
38        left = top = 0; right = w; bottom = h;
39    }
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    }
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
49    inline void clear() {
50        left = top = right = bottom = 0;
51    }
52
53    // a valid rectangle has a non negative width and height
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
59    inline bool isEmpty() const {
60        return (width()<=0) || (height()<=0);
61    }
62
63    inline void set(const Rect& rhs) {
64        operator = (rhs);
65    }
66
67    // rectangle's width
68    inline int32_t width() const {
69        return right-left;
70    }
71
72    // rectangle's height
73    inline int32_t height() const {
74        return bottom-top;
75    }
76
77    void setLeftTop(const Point& lt) {
78        left = lt.x;
79        top  = lt.y;
80    }
81
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
88    Point leftTop() const {
89        return Point(left, top);
90    }
91    Point rightBottom() const {
92        return Point(right, bottom);
93    }
94    Point rightTop() const {
95        return Point(right, top);
96    }
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
115    Rect& offsetToOrigin() {
116        right -= left;
117        bottom -= top;
118        left = top = 0;
119        return *this;
120    }
121    Rect& offsetTo(const Point& p) {
122        return offsetTo(p.x, p.y);
123    }
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
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    // Create a new Rect by transforming this one using a graphics HAL
145    // transform.  This rectangle is defined in a coordinate space starting at
146    // the origin and extending to (width, height).  If the transform includes
147    // a ROT90 then the output rectangle is defined in a space extending to
148    // (height, width).  Otherwise the output rectangle is in the same space as
149    // the input.
150    Rect transform(uint32_t xform, int32_t width, int32_t height);
151};
152
153ANDROID_BASIC_TYPES_TRAITS(Rect)
154
155}; // namespace android
156
157#endif // ANDROID_UI_RECT
158