replicant-frameworks_native/include/ui/Rect.h
2009-03-03 19:31:44 -08:00

153 lines
3.8 KiB
C++

/*
* Copyright (C) 2006 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ANDROID_UI_RECT
#define ANDROID_UI_RECT
#include <utils/TypeHelpers.h>
#include <ui/Point.h>
namespace android {
class Rect
{
public:
int left;
int top;
int right;
int bottom;
// we don't provide copy-ctor and operator= on purpose
// because we want the compiler generated versions
inline Rect()
{
}
inline Rect(int w, int h)
: left(0), top(0), right(w), bottom(h)
{
}
inline Rect(int l, int t, int r, int b)
: left(l), top(t), right(r), bottom(b)
{
}
inline Rect(const Point& lt, const Point& rb)
: left(lt.x), top(lt.y), right(rb.x), bottom(rb.y)
{
}
void makeInvalid();
// a valid rectangle has a non negative width and height
inline bool isValid() const {
return (width()>=0) && (height()>=0);
}
// an empty rect has a zero width or height, or is invalid
inline bool isEmpty() const {
return (width()<=0) || (height()<=0);
}
inline void set(const Rect& rhs) {
operator = (rhs);
}
// rectangle's width
inline int width() const {
return right-left;
}
// rectangle's height
inline int height() const {
return bottom-top;
}
// returns left-top Point non-const reference, can be assigned
inline Point& leftTop() {
return reinterpret_cast<Point&>(left);
}
// returns right bottom non-const reference, can be assigned
inline Point& rightBottom() {
return reinterpret_cast<Point&>(right);
}
// the following 4 functions return the 4 corners of the rect as Point
inline const Point& leftTop() const {
return reinterpret_cast<const Point&>(left);
}
inline const Point& rightBottom() const {
return reinterpret_cast<const Point&>(right);
}
Point rightTop() const {
return Point(right, top);
}
Point leftBottom() const {
return Point(left, bottom);
}
// comparisons
inline bool operator == (const Rect& rhs) const {
return (left == rhs.left) && (top == rhs.top) &&
(right == rhs.right) && (bottom == rhs.bottom);
}
inline bool operator != (const Rect& rhs) const {
return !operator == (rhs);
}
// operator < defines an order which allows to use rectangles in sorted
// vectors.
bool operator < (const Rect& rhs) const;
Rect& offsetToOrigin() {
right -= left;
bottom -= top;
left = top = 0;
return *this;
}
Rect& offsetTo(const Point& p) {
return offsetTo(p.x, p.y);
}
Rect& offsetBy(const Point& dp) {
return offsetBy(dp.x, dp.y);
}
Rect& operator += (const Point& rhs) {
return offsetBy(rhs.x, rhs.y);
}
Rect& operator -= (const Point& rhs) {
return offsetBy(-rhs.x, -rhs.y);
}
Rect operator + (const Point& rhs) const;
Rect operator - (const Point& rhs) const;
void translate(int dx, int dy) { // legacy, don't use.
offsetBy(dx, dy);
}
Rect& offsetTo(int x, int y);
Rect& offsetBy(int x, int y);
bool intersect(const Rect& with, Rect* result) const;
};
ANDROID_BASIC_TYPES_TRAITS(Rect)
}; // namespace android
#endif // ANDROID_UI_RECT