The Tor Browser: media/omx-plugin/include/froyo/ui/Rect.h@6474c204b198

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     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  */

    17 #ifndef ANDROID_UI_RECT

    18 #define ANDROID_UI_RECT

    20 #include <utils/TypeHelpers.h>

    21 #include <ui/Point.h>

    23 namespace android {

    25 class Rect

    26 {

    27 public:

    28     int left;

    29     int top;

    30     int right;

    31     int bottom;

    33     typedef int value_type;

    35     // we don't provide copy-ctor and operator= on purpose

    36     // because we want the compiler generated versions

    38     inline Rect() {

    39     }

    40     inline Rect(int w, int h)

    41         : left(0), top(0), right(w), bottom(h) {

    42     }

    43     inline Rect(int l, int t, int r, int b)

    44         : left(l), top(t), right(r), bottom(b) {

    45     }

    46     inline Rect(const Point& lt, const Point& rb)

    47         : left(lt.x), top(lt.y), right(rb.x), bottom(rb.y) {

    48     }

    50     void makeInvalid();

    52     inline void clear() {

    53         left = top = right = bottom = 0;

    54     }

    56     // a valid rectangle has a non negative width and height

    57     inline bool isValid() const {

    58         return (width()>=0) && (height()>=0);

    59     }

    61     // an empty rect has a zero width or height, or is invalid

    62     inline bool isEmpty() const {

    63         return (width()<=0) || (height()<=0);

    64     }

    66     inline void set(const Rect& rhs) {

    67         operator = (rhs);

    68     }

    70     // rectangle's width

    71     inline int width() const {

    72         return right-left;

    73     }

    75     // rectangle's height

    76     inline int height() const {

    77         return bottom-top;

    78     }

    80     void setLeftTop(const Point& lt) {

    81         left = lt.x;

    82         top  = lt.y;

    83     }

    85     void setRightBottom(const Point& rb) {

    86         right = rb.x;

    87         bottom  = rb.y;

    88     }

    90     // the following 4 functions return the 4 corners of the rect as Point

    91     Point leftTop() const {

    92         return Point(left, top);

    93     }

    94     Point rightBottom() const {

    95         return Point(right, bottom);

    96     }

    97     Point rightTop() const {

    98         return Point(right, top);

    99     }

   100     Point leftBottom() const {

   101         return Point(left, bottom);

   102     }

   104     // comparisons

   105     inline bool operator == (const Rect& rhs) const {

   106         return (left == rhs.left) && (top == rhs.top) &&

   107                (right == rhs.right) && (bottom == rhs.bottom);

   108     }

   110     inline bool operator != (const Rect& rhs) const {

   111         return !operator == (rhs);

   112     }

   114     // operator < defines an order which allows to use rectangles in sorted

   115     // vectors.

   116     bool operator < (const Rect& rhs) const;

   118     Rect& offsetToOrigin() {

   119         right -= left;

   120         bottom -= top;

   121         left = top = 0;

   122         return *this;

   123     }

   124     Rect& offsetTo(const Point& p) {

   125         return offsetTo(p.x, p.y);

   126     }

   127     Rect& offsetBy(const Point& dp) {

   128         return offsetBy(dp.x, dp.y);

   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     const Rect operator + (const Point& rhs) const;

   137     const Rect operator - (const Point& rhs) const;

   139     void translate(int dx, int dy) { // legacy, don't use.

   140         offsetBy(dx, dy);

   141     }

   143     Rect&   offsetTo(int x, int y);

   144     Rect&   offsetBy(int x, int y);

   145     bool    intersect(const Rect& with, Rect* result) const;

   146 };

   148 ANDROID_BASIC_TYPES_TRAITS(Rect)

   150 }; // namespace android

   152 #endif // ANDROID_UI_RECT

The Tor Browser / file revision