diff options
Diffstat (limited to 'src/corelib/tools/qrect.cpp')
| -rw-r--r-- | src/corelib/tools/qrect.cpp | 2465 |
1 files changed, 2465 insertions, 0 deletions
diff --git a/src/corelib/tools/qrect.cpp b/src/corelib/tools/qrect.cpp new file mode 100644 index 0000000000..36627264ce --- /dev/null +++ b/src/corelib/tools/qrect.cpp @@ -0,0 +1,2465 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtCore module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qrect.h" +#include "qdatastream.h" +#include "qdebug.h" +#include "qmath.h" + +#include <math.h> + +QT_BEGIN_NAMESPACE + +/*! + \class QRect + \ingroup painting + + \brief The QRect class defines a rectangle in the plane using + integer precision. + + A rectangle is normally expressed as an upper-left corner and a + size. The size (width and height) of a QRect is always equivalent + to the mathematical rectangle that forms the basis for its + rendering. + + A QRect can be constructed with a set of left, top, width and + height integers, or from a QPoint and a QSize. The following code + creates two identical rectangles. + + \snippet doc/src/snippets/code/src_corelib_tools_qrect.cpp 0 + + There is a third constructor that creates a QRect using the + top-left and bottom-right coordinates, but we recommend that you + avoid using it. The rationale is that for historical reasons the + values returned by the bottom() and right() functions deviate from + the true bottom-right corner of the rectangle. + + The QRect class provides a collection of functions that return the + various rectangle coordinates, and enable manipulation of + these. QRect also provide functions to move the rectangle relative + to the various coordinates. In addition there is a moveTo() + function that moves the rectangle, leaving its top left corner at + the given coordinates. Alternatively, the translate() function + moves the rectangle the given offset relative to the current + position, and the translated() function returns a translated copy + of this rectangle. + + The size() function returns the rectange's dimensions as a + QSize. The dimensions can also be retrieved separately using the + width() and height() functions. To manipulate the dimensions use + the setSize(), setWidth() or setHeight() functions. Alternatively, + the size can be changed by applying either of the functions + setting the rectangle coordinates, for example, setBottom() or + setRight(). + + The contains() function tells whether a given point is inside the + rectangle or not, and the intersects() function returns true if + this rectangle intersects with a given rectangle. The QRect class + also provides the intersected() function which returns the + intersection rectangle, and the united() function which returns the + rectangle that encloses the given rectangle and this: + + \table + \row + \o \inlineimage qrect-intersect.png + \o \inlineimage qrect-unite.png + \row + \o intersected() + \o united() + \endtable + + The isEmpty() function returns true if left() > right() or top() > + bottom(). Note that an empty rectangle is not valid: The isValid() + function returns true if left() <= right() \e and top() <= + bottom(). A null rectangle (isNull() == true) on the other hand, + has both width and height set to 0. + + Note that due to the way QRect and QRectF are defined, an + empty QRect is defined in essentially the same way as QRectF. + + Finally, QRect objects can be streamed as well as compared. + + \tableofcontents + + \section1 Rendering + + When using an \l {QPainter::Antialiasing}{anti-aliased} painter, + the boundary line of a QRect will be rendered symmetrically on + both sides of the mathematical rectangle's boundary line. But when + using an aliased painter (the default) other rules apply. + + Then, when rendering with a one pixel wide pen the QRect's boundary + line will be rendered to the right and below the mathematical + rectangle's boundary line. + + When rendering with a two pixels wide pen the boundary line will + be split in the middle by the mathematical rectangle. This will be + the case whenever the pen is set to an even number of pixels, + while rendering with a pen with an odd number of pixels, the spare + pixel will be rendered to the right and below the mathematical + rectangle as in the one pixel case. + + \table + \row + \o \inlineimage qrect-diagram-zero.png + \o \inlineimage qrect-diagram-one.png + \row + \o Logical representation + \o One pixel wide pen + \row + \o \inlineimage qrect-diagram-two.png + \o \inlineimage qrect-diagram-three.png + \row + \o Two pixel wide pen + \o Three pixel wide pen + \endtable + + \section1 Coordinates + + The QRect class provides a collection of functions that return the + various rectangle coordinates, and enable manipulation of + these. QRect also provide functions to move the rectangle relative + to the various coordinates. + + For example the left(), setLeft() and moveLeft() functions as an + example: left() returns the x-coordinate of the rectangle's left + edge, setLeft() sets the left edge of the rectangle to the given x + coordinate (it may change the width, but will never change the + rectangle's right edge) and moveLeft() moves the entire rectangle + horizontally, leaving the rectangle's left edge at the given x + coordinate and its size unchanged. + + \image qrect-coordinates.png + + Note that for historical reasons the values returned by the + bottom() and right() functions deviate from the true bottom-right + corner of the rectangle: The right() function returns \e { left() + + width() - 1} and the bottom() function returns \e {top() + + height() - 1}. The same is the case for the point returned by the + bottomRight() convenience function. In addition, the x and y + coordinate of the topRight() and bottomLeft() functions, + respectively, contain the same deviation from the true right and + bottom edges. + + We recommend that you use x() + width() and y() + height() to find + the true bottom-right corner, and avoid right() and + bottom(). Another solution is to use QRectF: The QRectF class + defines a rectangle in the plane using floating point accuracy for + coordinates, and the QRectF::right() and QRectF::bottom() + functions \e do return the right and bottom coordinates. + + It is also possible to add offsets to this rectangle's coordinates + using the adjust() function, as well as retrieve a new rectangle + based on adjustments of the original one using the adjusted() + function. If either of the width and height is negative, use the + normalized() function to retrieve a rectangle where the corners + are swapped. + + In addition, QRect provides the getCoords() function which extracts + the position of the rectangle's top-left and bottom-right corner, + and the getRect() function which extracts the rectangle's top-left + corner, width and height. Use the setCoords() and setRect() + function to manipulate the rectangle's coordinates and dimensions + in one go. + + \sa QRectF, QRegion +*/ + +/***************************************************************************** + QRect member functions + *****************************************************************************/ + +/*! + \fn QRect::QRect() + + Constructs a null rectangle. + + \sa isNull() +*/ + +/*! + \fn QRect::QRect(const QPoint &topLeft, const QPoint &bottomRight) + + Constructs a rectangle with the given \a topLeft and \a bottomRight corners. + + \sa setTopLeft(), setBottomRight() +*/ + + +/*! + \fn QRect::QRect(const QPoint &topLeft, const QSize &size) + + Constructs a rectangle with the given \a topLeft corner and the + given \a size. + + \sa setTopLeft(), setSize() +*/ + + +/*! + \fn QRect::QRect(int x, int y, int width, int height) + + Constructs a rectangle with (\a x, \a y) as its top-left corner + and the given \a width and \a height. + + \sa setRect() +*/ + + +/*! + \fn bool QRect::isNull() const + + Returns true if the rectangle is a null rectangle, otherwise + returns false. + + A null rectangle has both the width and the height set to 0 (i.e., + right() == left() - 1 and bottom() == top() - 1). A null rectangle + is also empty, and hence is not valid. + + \sa isEmpty(), isValid() +*/ + +/*! + \fn bool QRect::isEmpty() const + + Returns true if the rectangle is empty, otherwise returns false. + + An empty rectangle has a left() > right() or top() > bottom(). An + empty rectangle is not valid (i.e., isEmpty() == !isValid()). + + Use the normalized() function to retrieve a rectangle where the + corners are swapped. + + \sa isNull(), isValid(), normalized() +*/ + +/*! + \fn bool QRect::isValid() const + + Returns true if the rectangle is valid, otherwise returns false. + + A valid rectangle has a left() < right() and top() < + bottom(). Note that non-trivial operations like intersections are + not defined for invalid rectangles. A valid rectangle is not empty + (i.e., isValid() == !isEmpty()). + + \sa isNull(), isEmpty(), normalized() +*/ + + +/*! + Returns a normalized rectangle; i.e., a rectangle that has a + non-negative width and height. + + If width() < 0 the function swaps the left and right corners, and + it swaps the top and bottom corners if height() < 0. + + \sa isValid(), isEmpty() +*/ + +QRect QRect::normalized() const +{ + QRect r; + if (x2 < x1 - 1) { // swap bad x values + r.x1 = x2; + r.x2 = x1; + } else { + r.x1 = x1; + r.x2 = x2; + } + if (y2 < y1 - 1) { // swap bad y values + r.y1 = y2; + r.y2 = y1; + } else { + r.y1 = y1; + r.y2 = y2; + } + return r; +} + + +/*! + \fn QRect QRect::normalize() const + \compat + + Returns a normalized rectangle; i.e., a rectangle that has a + non-negative width and height. + + Use the normalized() function instead +*/ + +/*! + \fn int QRect::left() const + + Returns the x-coordinate of the rectangle's left edge. Equivalent + to x(). + + \sa setLeft(), topLeft(), bottomLeft() +*/ + +/*! + \fn int QRect::top() const + + Returns the y-coordinate of the rectangle's top edge. + Equivalent to y(). + + \sa setTop(), topLeft(), topRight() +*/ + +/*! + \fn int QRect::right() const + + Returns the x-coordinate of the rectangle's right edge. + + Note that for historical reasons this function returns left() + + width() - 1; use x() + width() to retrieve the true x-coordinate. + + \sa setRight(), topRight(), bottomRight() +*/ + +/*! + \fn int QRect::bottom() const + + Returns the y-coordinate of the rectangle's bottom edge. + + Note that for historical reasons this function returns top() + + height() - 1; use y() + height() to retrieve the true y-coordinate. + + \sa setBottom(), bottomLeft(), bottomRight() +*/ + +/*! + \fn int &QRect::rLeft() + \compat + + Returns a reference to the left coordinate of the rectangle. + + Use the left() function instead. +*/ + +/*! + \fn int &QRect::rTop() + \compat + + Returns a reference to the top coordinate of the rectangle. + + Use the top() function instead. +*/ + +/*! + \fn int &QRect::rRight() + \compat + + Returns a reference to the right coordinate of the rectangle. + + Use the right() function instead. +*/ + +/*! + \fn int &QRect::rBottom() + \compat + + Returns a reference to the bottom coordinate of the rectangle. + + Use the bottom() function instead. +*/ + +/*! + \fn int QRect::x() const + + Returns the x-coordinate of the rectangle's left edge. Equivalent to left(). + + \sa setX(), y(), topLeft() +*/ + +/*! + \fn int QRect::y() const + + Returns the y-coordinate of the rectangle's top edge. Equivalent to top(). + + \sa setY(), x(), topLeft() +*/ + +/*! + \fn void QRect::setLeft(int x) + + Sets the left edge of the rectangle to the given \a x + coordinate. May change the width, but will never change the right + edge of the rectangle. + + Equivalent to setX(). + + \sa left(), moveLeft() +*/ + +/*! + \fn void QRect::setTop(int y) + + Sets the top edge of the rectangle to the given \a y + coordinate. May change the height, but will never change the + bottom edge of the rectangle. + + Equivalent to setY(). + + \sa top(), moveTop() +*/ + +/*! + \fn void QRect::setRight(int x) + + Sets the right edge of the rectangle to the given \a x + coordinate. May change the width, but will never change the left + edge of the rectangle. + + \sa right(), moveRight() +*/ + +/*! + \fn void QRect::setBottom(int y) + + Sets the bottom edge of the rectangle to the given \a y + coordinate. May change the height, but will never change the top + edge of the rectangle. + + \sa bottom(), moveBottom(), +*/ + +/*! + \fn void QRect::setX(int x) + + Sets the left edge of the rectangle to the given \a x + coordinate. May change the width, but will never change the right + edge of the rectangle. + + Equivalent to setLeft(). + + \sa x(), setY(), setTopLeft() +*/ + +/*! + \fn void QRect::setY(int y) + + Sets the top edge of the rectangle to the given \a y + coordinate. May change the height, but will never change the + bottom edge of the rectangle. + + Equivalent to setTop(). + + \sa y(), setX(), setTopLeft() +*/ + +/*! + \fn void QRect::setTopLeft(const QPoint &position) + + Set the top-left corner of the rectangle to the given \a + position. May change the size, but will never change the + bottom-right corner of the rectangle. + + \sa topLeft(), moveTopLeft() +*/ + +/*! + \fn void QRect::setBottomRight(const QPoint &position) + + Set the bottom-right corner of the rectangle to the given \a + position. May change the size, but will never change the + top-left corner of the rectangle. + + \sa bottomRight(), moveBottomRight() +*/ + +/*! + \fn void QRect::setTopRight(const QPoint &position) + + Set the top-right corner of the rectangle to the given \a + position. May change the size, but will never change the + bottom-left corner of the rectangle. + + \sa topRight(), moveTopRight() +*/ + +/*! + \fn void QRect::setBottomLeft(const QPoint &position) + + Set the bottom-left corner of the rectangle to the given \a + position. May change the size, but will never change the + top-right corner of the rectangle. + + \sa bottomLeft(), moveBottomLeft() +*/ + +/*! + \fn QPoint QRect::topLeft() const + + Returns the position of the rectangle's top-left corner. + + \sa setTopLeft(), top(), left() +*/ + +/*! + \fn QPoint QRect::bottomRight() const + + Returns the position of the rectangle's bottom-right corner. + + Note that for historical reasons this function returns + QPoint(left() + width() -1, top() + height() - 1). + + \sa setBottomRight(), bottom(), right() +*/ + +/*! + \fn QPoint QRect::topRight() const + + Returns the position of the rectangle's top-right corner. + + Note that for historical reasons this function returns + QPoint(left() + width() -1, top()). + + \sa setTopRight(), top(), right() +*/ + +/*! + \fn QPoint QRect::bottomLeft() const + + Returns the position of the rectangle's bottom-left corner. Note + that for historical reasons this function returns QPoint(left(), + top() + height() - 1). + + \sa setBottomLeft(), bottom(), left() +*/ + +/*! + \fn QPoint QRect::center() const + + Returns the center point of the rectangle. + + \sa moveCenter() +*/ + + +/*! + \fn void QRect::getRect(int *x, int *y, int *width, int *height) const + + Extracts the position of the rectangle's top-left corner to *\a x + and *\a y, and its dimensions to *\a width and *\a height. + + \sa setRect(), getCoords() +*/ + + +/*! + \fn void QRect::getCoords(int *x1, int *y1, int *x2, int *y2) const + + Extracts the position of the rectangle's top-left corner to *\a x1 + and *\a y1, and the position of the bottom-right corner to *\a x2 + and *\a y2. + + \sa setCoords(), getRect() +*/ + +/*! + \fn void QRect::rect(int *x, int *y, int *width, int *height) const + \compat + + Extracts the position of the rectangle's top-left corner to *\a x and + *\a y, and its dimensions to *\a width and * \a height. + + Use the getRect() function instead. +*/ + + +/*! + \fn void QRect::coords(int *x1, int *y1, int *x2, int *y2) const + \compat + + Extracts the position of the rectangle's top-left corner to *\a x1 + and *\a y1, and the position of the bottom-right corner to *\a x2 + and *\a y2. + + Use the getCoords() function instead. +*/ + +/*! + \fn void QRect::moveLeft(int x) + + Moves the rectangle horizontally, leaving the rectangle's left + edge at the given \a x coordinate. The rectangle's size is + unchanged. + + \sa left(), setLeft(), moveRight() +*/ + +/*! + \fn void QRect::moveTop(int y) + + Moves the rectangle vertically, leaving the rectangle's top edge + at the given \a y coordinate. The rectangle's size is unchanged. + + \sa top(), setTop(), moveBottom() +*/ + + +/*! + \fn void QRect::moveRight(int x) + + Moves the rectangle horizontally, leaving the rectangle's right + edge at the given \a x coordinate. The rectangle's size is + unchanged. + + \sa right(), setRight(), moveLeft() +*/ + + +/*! + \fn void QRect::moveBottom(int y) + + Moves the rectangle vertically, leaving the rectangle's bottom + edge at the given \a y coordinate. The rectangle's size is + unchanged. + + \sa bottom(), setBottom(), moveTop() +*/ + + +/*! + \fn void QRect::moveTopLeft(const QPoint &position) + + Moves the rectangle, leaving the top-left corner at the given \a + position. The rectangle's size is unchanged. + + \sa setTopLeft(), moveTop(), moveLeft() +*/ + + +/*! + \fn void QRect::moveBottomRight(const QPoint &position) + + Moves the rectangle, leaving the bottom-right corner at the given + \a position. The rectangle's size is unchanged. + + \sa setBottomRight(), moveRight(), moveBottom() +*/ + + +/*! + \fn void QRect::moveTopRight(const QPoint &position) + + Moves the rectangle, leaving the top-right corner at the given \a + position. The rectangle's size is unchanged. + + \sa setTopRight(), moveTop(), moveRight() +*/ + + +/*! + \fn void QRect::moveBottomLeft(const QPoint &position) + + Moves the rectangle, leaving the bottom-left corner at the given + \a position. The rectangle's size is unchanged. + + \sa setBottomLeft(), moveBottom(), moveLeft() +*/ + + +/*! + \fn void QRect::moveCenter(const QPoint &position) + + Moves the rectangle, leaving the center point at the given \a + position. The rectangle's size is unchanged. + + \sa center() +*/ + +void QRect::moveCenter(const QPoint &p) +{ + int w = x2 - x1; + int h = y2 - y1; + x1 = p.x() - w/2; + y1 = p.y() - h/2; + x2 = x1 + w; + y2 = y1 + h; +} + +/*! + \fn void QRect::moveBy(int dx, int dy) + \compat + + Moves the rectangle \a dx along the x axis and \a dy along the y + axis, relative to the current position. + + Use the translate() function instead. +*/ + +/*! + \fn void QRect::moveBy(const QPoint &) + \compat + + Use the translate() function instead. +*/ + +/*! + \fn void QRect::moveTo(int x, int y) + + Moves the rectangle, leaving the top-left corner at the given + position (\a x, \a y). The rectangle's size is unchanged. + + \sa translate(), moveTopLeft() +*/ + +/*! + \fn void QRect::moveTo(const QPoint &position) + + Moves the rectangle, leaving the top-left corner at the given \a + position. +*/ + +/*! + \fn void QRect::translate(int dx, int dy) + + Moves the rectangle \a dx along the x axis and \a dy along the y + axis, relative to the current position. Positive values move the + rectangle to the right and down. + + \sa moveTopLeft(), moveTo(), translated() +*/ + + +/*! + \fn void QRect::translate(const QPoint &offset) + \overload + + Moves the rectangle \a{offset}.\l{QPoint::x()}{x()} along the x + axis and \a{offset}.\l{QPoint::y()}{y()} along the y axis, + relative to the current position. +*/ + + +/*! + \fn QRect QRect::translated(int dx, int dy) const + + Returns a copy of the rectangle that is translated \a dx along the + x axis and \a dy along the y axis, relative to the current + position. Positive values move the rectangle to the right and + down. + + \sa translate() + +*/ + + +/*! + \fn QRect QRect::translated(const QPoint &offset) const + + \overload + + Returns a copy of the rectangle that is translated + \a{offset}.\l{QPoint::x()}{x()} along the x axis and + \a{offset}.\l{QPoint::y()}{y()} along the y axis, relative to the + current position. +*/ + + +/*! + \fn void QRect::setRect(int x, int y, int width, int height) + + Sets the coordinates of the rectangle's top-left corner to (\a{x}, + \a{y}), and its size to the given \a width and \a height. + + \sa getRect(), setCoords() +*/ + + +/*! + \fn void QRect::setCoords(int x1, int y1, int x2, int y2) + + Sets the coordinates of the rectangle's top-left corner to (\a x1, + \a y1), and the coordinates of its bottom-right corner to (\a x2, + \a y2). + + \sa getCoords(), setRect() +*/ + + +/*! + \fn void QRect::addCoords(int dx1, int dy1, int dx2, int dy2) + \compat + + Adds \a dx1, \a dy1, \a dx2 and \a dy2 to the existing coordinates + of the rectangle respectively. + + Use the adjust() function instead. +*/ + +/*! \fn QRect QRect::adjusted(int dx1, int dy1, int dx2, int dy2) const + + Returns a new rectangle with \a dx1, \a dy1, \a dx2 and \a dy2 + added respectively to the existing coordinates of this rectangle. + + \sa adjust() +*/ + +/*! \fn void QRect::adjust(int dx1, int dy1, int dx2, int dy2) + + Adds \a dx1, \a dy1, \a dx2 and \a dy2 respectively to the + existing coordinates of the rectangle. + + \sa adjusted(), setRect() +*/ + +/*! + \fn QSize QRect::size() const + + Returns the size of the rectangle. + + \sa setSize(), width(), height() +*/ + +/*! + \fn int QRect::width() const + + Returns the width of the rectangle. + + \sa setWidth(), height(), size() +*/ + +/*! + \fn int QRect::height() const + + Returns the height of the rectangle. + + \sa setHeight(), width(), size() +*/ + +/*! + \fn void QRect::setWidth(int width) + + Sets the width of the rectangle to the given \a width. The right + edge is changed, but not the left one. + + \sa width(), setSize() +*/ + + +/*! + \fn void QRect::setHeight(int height) + + Sets the height of the rectangle to the given \a height. The bottom + edge is changed, but not the top one. + + \sa height(), setSize() +*/ + + +/*! + \fn void QRect::setSize(const QSize &size) + + Sets the size of the rectangle to the given \a size. The top-left + corner is not moved. + + \sa size(), setWidth(), setHeight() +*/ + + +/*! + \fn bool QRect::contains(const QPoint &point, bool proper) const + + Returns true if the given \a point is inside or on the edge of + the rectangle, otherwise returns false. If \a proper is true, this + function only returns true if the given \a point is \e inside the + rectangle (i.e., not on the edge). + + \sa intersects() +*/ + +bool QRect::contains(const QPoint &p, bool proper) const +{ + int l, r; + if (x2 < x1 - 1) { + l = x2; + r = x1; + } else { + l = x1; + r = x2; + } + if (proper) { + if (p.x() <= l || p.x() >= r) + return false; + } else { + if (p.x() < l || p.x() > r) + return false; + } + int t, b; + if (y2 < y1 - 1) { + t = y2; + b = y1; + } else { + t = y1; + b = y2; + } + if (proper) { + if (p.y() <= t || p.y() >= b) + return false; + } else { + if (p.y() < t || p.y() > b) + return false; + } + return true; +} + + +/*! + \fn bool QRect::contains(int x, int y, bool proper) const + \overload + + Returns true if the point (\a x, \a y) is inside or on the edge of + the rectangle, otherwise returns false. If \a proper is true, this + function only returns true if the point is entirely inside the + rectangle(not on the edge). +*/ + +/*! + \fn bool QRect::contains(int x, int y) const + \overload + + Returns true if the point (\a x, \a y) is inside this rectangle, + otherwise returns false. +*/ + +/*! + \fn bool QRect::contains(const QRect &rectangle, bool proper) const + \overload + + Returns true if the given \a rectangle is inside this rectangle. + otherwise returns false. If \a proper is true, this function only + returns true if the \a rectangle is entirely inside this + rectangle (not on the edge). +*/ + +bool QRect::contains(const QRect &r, bool proper) const +{ + if (isNull() || r.isNull()) + return false; + + int l1 = x1; + int r1 = x1; + if (x2 - x1 + 1 < 0) + l1 = x2; + else + r1 = x2; + + int l2 = r.x1; + int r2 = r.x1; + if (r.x2 - r.x1 + 1 < 0) + l2 = r.x2; + else + r2 = r.x2; + + if (proper) { + if (l2 <= l1 || r2 >= r1) + return false; + } else { + if (l2 < l1 || r2 > r1) + return false; + } + + int t1 = y1; + int b1 = y1; + if (y2 - y1 + 1 < 0) + t1 = y2; + else + b1 = y2; + + int t2 = r.y1; + int b2 = r.y1; + if (r.y2 - r.y1 + 1 < 0) + t2 = r.y2; + else + b2 = r.y2; + + if (proper) { + if (t2 <= t1 || b2 >= b1) + return false; + } else { + if (t2 < t1 || b2 > b1) + return false; + } + + return true; +} + +/*! + \fn QRect& QRect::operator|=(const QRect &rectangle) + + Unites this rectangle with the given \a rectangle. + + \sa united(), operator|() +*/ + +/*! + \fn QRect& QRect::operator&=(const QRect &rectangle) + + Intersects this rectangle with the given \a rectangle. + + \sa intersected(), operator&() +*/ + + +/*! + \fn QRect QRect::operator|(const QRect &rectangle) const + + Returns the bounding rectangle of this rectangle and the given \a + rectangle. + + \sa operator|=(), united() +*/ + +QRect QRect::operator|(const QRect &r) const +{ + if (isNull()) + return r; + if (r.isNull()) + return *this; + + int l1 = x1; + int r1 = x1; + if (x2 - x1 + 1 < 0) + l1 = x2; + else + r1 = x2; + + int l2 = r.x1; + int r2 = r.x1; + if (r.x2 - r.x1 + 1 < 0) + l2 = r.x2; + else + r2 = r.x2; + + int t1 = y1; + int b1 = y1; + if (y2 - y1 + 1 < 0) + t1 = y2; + else + b1 = y2; + + int t2 = r.y1; + int b2 = r.y1; + if (r.y2 - r.y1 + 1 < 0) + t2 = r.y2; + else + b2 = r.y2; + + QRect tmp; + tmp.x1 = qMin(l1, l2); + tmp.x2 = qMax(r1, r2); + tmp.y1 = qMin(t1, t2); + tmp.y2 = qMax(b1, b2); + return tmp; +} + +/*! + \fn QRect QRect::unite(const QRect &rectangle) const + \obsolete + + Use united(\a rectangle) instead. +*/ + +/*! + \fn QRect QRect::united(const QRect &rectangle) const + \since 4.2 + + Returns the bounding rectangle of this rectangle and the given \a rectangle. + + \image qrect-unite.png + + \sa intersected() +*/ + + +/*! + \fn QRect QRect::operator&(const QRect &rectangle) const + + Returns the intersection of this rectangle and the given \a + rectangle. Returns an empty rectangle if there is no intersection. + + \sa operator&=(), intersected() +*/ + +QRect QRect::operator&(const QRect &r) const +{ + if (isNull() || r.isNull()) + return QRect(); + + int l1 = x1; + int r1 = x1; + if (x2 - x1 + 1 < 0) + l1 = x2; + else + r1 = x2; + + int l2 = r.x1; + int r2 = r.x1; + if (r.x2 - r.x1 + 1 < 0) + l2 = r.x2; + else + r2 = r.x2; + + if (l1 > r2 || l2 > r1) + return QRect(); + + int t1 = y1; + int b1 = y1; + if (y2 - y1 + 1 < 0) + t1 = y2; + else + b1 = y2; + + int t2 = r.y1; + int b2 = r.y1; + if (r.y2 - r.y1 + 1 < 0) + t2 = r.y2; + else + b2 = r.y2; + + if (t1 > b2 || t2 > b1) + return QRect(); + + QRect tmp; + tmp.x1 = qMax(l1, l2); + tmp.x2 = qMin(r1, r2); + tmp.y1 = qMax(t1, t2); + tmp.y2 = qMin(b1, b2); + return tmp; +} + +/*! + \fn QRect QRect::intersect(const QRect &rectangle) const + \obsolete + + Use intersected(\a rectangle) instead. +*/ + +/*! + \fn QRect QRect::intersected(const QRect &rectangle) const + \since 4.2 + + Returns the intersection of this rectangle and the given \a + rectangle. Note that \c{r.intersected(s)} is equivalent to \c{r & s}. + + \image qrect-intersect.png + + \sa intersects(), united(), operator&=() +*/ + +/*! + \fn bool QRect::intersects(const QRect &rectangle) const + + Returns true if this rectangle intersects with the given \a + rectangle (i.e., there is at least one pixel that is within both + rectangles), otherwise returns false. + + The intersection rectangle can be retrieved using the intersected() + function. + + \sa contains() +*/ + +bool QRect::intersects(const QRect &r) const +{ + if (isNull() || r.isNull()) + return false; + + int l1 = x1; + int r1 = x1; + if (x2 - x1 + 1 < 0) + l1 = x2; + else + r1 = x2; + + int l2 = r.x1; + int r2 = r.x1; + if (r.x2 - r.x1 + 1 < 0) + l2 = r.x2; + else + r2 = r.x2; + + if (l1 > r2 || l2 > r1) + return false; + + int t1 = y1; + int b1 = y1; + if (y2 - y1 + 1 < 0) + t1 = y2; + else + b1 = y2; + + int t2 = r.y1; + int b2 = r.y1; + if (r.y2 - r.y1 + 1 < 0) + t2 = r.y2; + else + b2 = r.y2; + + if (t1 > b2 || t2 > b1) + return false; + + return true; +} + +/*! + \fn bool operator==(const QRect &r1, const QRect &r2) + \relates QRect + + Returns true if the rectangles \a r1 and \a r2 are equal, + otherwise returns false. +*/ + + +/*! + \fn bool operator!=(const QRect &r1, const QRect &r2) + \relates QRect + + Returns true if the rectangles \a r1 and \a r2 are different, otherwise + returns false. +*/ + + +/***************************************************************************** + QRect stream functions + *****************************************************************************/ +#ifndef QT_NO_DATASTREAM +/*! + \fn QDataStream &operator<<(QDataStream &stream, const QRect &rectangle) + \relates QRect + + Writes the given \a rectangle to the given \a stream, and returns + a reference to the stream. + + \sa {Serializing Qt Data Types} +*/ + +QDataStream &operator<<(QDataStream &s, const QRect &r) +{ + if (s.version() == 1) + s << (qint16)r.left() << (qint16)r.top() + << (qint16)r.right() << (qint16)r.bottom(); + else + s << (qint32)r.left() << (qint32)r.top() + << (qint32)r.right() << (qint32)r.bottom(); + return s; +} + +/*! + \fn QDataStream &operator>>(QDataStream &stream, QRect &rectangle) + \relates QRect + + Reads a rectangle from the given \a stream into the given \a + rectangle, and returns a reference to the stream. + + \sa {Serializing Qt Data Types} +*/ + +QDataStream &operator>>(QDataStream &s, QRect &r) +{ + if (s.version() == 1) { + qint16 x1, y1, x2, y2; + s >> x1; s >> y1; s >> x2; s >> y2; + r.setCoords(x1, y1, x2, y2); + } + else { + qint32 x1, y1, x2, y2; + s >> x1; s >> y1; s >> x2; s >> y2; + r.setCoords(x1, y1, x2, y2); + } + return s; +} + +#endif // QT_NO_DATASTREAM + + +#ifndef QT_NO_DEBUG_STREAM +QDebug operator<<(QDebug dbg, const QRect &r) { + dbg.nospace() << "QRect(" << r.x() << ',' << r.y() << ' ' + << r.width() << 'x' << r.height() << ')'; + return dbg.space(); +} +#endif + +/*! + \class QRectF + \ingroup painting + + \brief The QRectF class defines a rectangle in the plane using floating + point precision. + + A rectangle is normally expressed as an upper-left corner and a + size. The size (width and height) of a QRectF is always equivalent + to the mathematical rectangle that forms the basis for its + rendering. + + A QRectF can be constructed with a set of left, top, width and + height integers, or from a QPoint and a QSize. The following code + creates two identical rectangles. + + \snippet doc/src/snippets/code/src_corelib_tools_qrect.cpp 1 + + There is also a third constructor creating a QRectF from a QRect, + and a corresponding toRect() function that returns a QRect object + based on the values of this rectangle (note that the coordinates + in the returned rectangle are rounded to the nearest integer). + + The QRectF class provides a collection of functions that return + the various rectangle coordinates, and enable manipulation of + these. QRectF also provide functions to move the rectangle + relative to the various coordinates. In addition there is a + moveTo() function that moves the rectangle, leaving its top left + corner at the given coordinates. Alternatively, the translate() + function moves the rectangle the given offset relative to the + current position, and the translated() function returns a + translated copy of this rectangle. + + The size() function returns the rectange's dimensions as a + QSize. The dimensions can also be retrieved separately using the + width() and height() functions. To manipulate the dimensions use + the setSize(), setWidth() or setHeight() functions. Alternatively, + the size can be changed by applying either of the functions + setting the rectangle coordinates, for example, setBottom() or + setRight(). + + The contains() function tells whether a given point is inside the + rectangle or not, and the intersects() function returns true if + this rectangle intersects with a given rectangle (otherwise + false). The QRectF class also provides the intersected() function + which returns the intersection rectangle, and the united() function + which returns the rectangle that encloses the given rectangle and + this: + + \table + \row + \o \inlineimage qrect-intersect.png + \o \inlineimage qrect-unite.png + \row + \o intersected() + \o united() + \endtable + + The isEmpty() function returns true if the rectangle's width or + height is less than, or equal to, 0. Note that an empty rectangle + is not valid: The isValid() function returns true if both width + and height is larger than 0. A null rectangle (isNull() == true) + on the other hand, has both width and height set to 0. + + Note that due to the way QRect and QRectF are defined, an + empty QRectF is defined in essentially the same way as QRect. + + Finally, QRectF objects can be streamed as well as compared. + + \tableofcontents + + \section1 Rendering + + When using an \l {QPainter::Antialiasing}{anti-aliased} painter, + the boundary line of a QRectF will be rendered symmetrically on both + sides of the mathematical rectangle's boundary line. But when + using an aliased painter (the default) other rules apply. + + Then, when rendering with a one pixel wide pen the QRectF's boundary + line will be rendered to the right and below the mathematical + rectangle's boundary line. + + When rendering with a two pixels wide pen the boundary line will + be split in the middle by the mathematical rectangle. This will be + the case whenever the pen is set to an even number of pixels, + while rendering with a pen with an odd number of pixels, the spare + pixel will be rendered to the right and below the mathematical + rectangle as in the one pixel case. + + \table + \row + \o \inlineimage qrect-diagram-zero.png + \o \inlineimage qrectf-diagram-one.png + \row + \o Logical representation + \o One pixel wide pen + \row + \o \inlineimage qrectf-diagram-two.png + \o \inlineimage qrectf-diagram-three.png + \row + \o Two pixel wide pen + \o Three pixel wide pen + \endtable + + \section1 Coordinates + + The QRectF class provides a collection of functions that return + the various rectangle coordinates, and enable manipulation of + these. QRectF also provide functions to move the rectangle + relative to the various coordinates. + + For example: the bottom(), setBottom() and moveBottom() functions: + bottom() returns the y-coordinate of the rectangle's bottom edge, + setBottom() sets the bottom edge of the rectangle to the given y + coordinate (it may change the height, but will never change the + rectangle's top edge) and moveBottom() moves the entire rectangle + vertically, leaving the rectangle's bottom edge at the given y + coordinate and its size unchanged. + + \image qrectf-coordinates.png + + It is also possible to add offsets to this rectangle's coordinates + using the adjust() function, as well as retrieve a new rectangle + based on adjustments of the original one using the adjusted() + function. If either of the width and height is negative, use the + normalized() function to retrieve a rectangle where the corners + are swapped. + + In addition, QRectF provides the getCoords() function which extracts + the position of the rectangle's top-left and bottom-right corner, + and the getRect() function which extracts the rectangle's top-left + corner, width and height. Use the setCoords() and setRect() + function to manipulate the rectangle's coordinates and dimensions + in one go. + + \sa QRect, QRegion +*/ + +/***************************************************************************** + QRectF member functions + *****************************************************************************/ + +/*! + \fn QRectF::QRectF() + + Constructs a null rectangle. + + \sa isNull() +*/ + +/*! + \fn QRectF::QRectF(const QPointF &topLeft, const QSizeF &size) + + Constructs a rectangle with the given \a topLeft corner and the given \a size. + + \sa setTopLeft(), setSize() +*/ + +/*! + \fn QRectF::QRectF(const QPointF &topLeft, const QPointF &bottomRight) + \since 4.3 + + Constructs a rectangle with the given \a topLeft and \a bottomRight corners. + + \sa setTopLeft(), setBottomRight() +*/ + +/*! + \fn QRectF::QRectF(qreal x, qreal y, qreal width, qreal height) + + Constructs a rectangle with (\a x, \a y) as its top-left corner + and the given \a width and \a height. + + \sa setRect() +*/ + +/*! + \fn QRectF::QRectF(const QRect &rectangle) + + Constructs a QRectF rectangle from the given QRect \a rectangle. + + \sa toRect() +*/ + +/*! + \fn bool QRectF::isNull() const + + Returns true if the rectangle is a null rectangle, otherwise returns false. + + A null rectangle has both the width and the height set to 0. A + null rectangle is also empty, and hence not valid. + + \sa isEmpty(), isValid() +*/ + +/*! + \fn bool QRectF::isEmpty() const + + Returns true if the rectangle is empty, otherwise returns false. + + An empty rectangle has width() <= 0 or height() <= 0. An empty + rectangle is not valid (i.e., isEmpty() == !isValid()). + + Use the normalized() function to retrieve a rectangle where the + corners are swapped. + + \sa isNull(), isValid(), normalized() +*/ + +/*! + \fn bool QRectF::isValid() const + + Returns true if the rectangle is valid, otherwise returns false. + + A valid rectangle has a width() > 0 and height() > 0. Note that + non-trivial operations like intersections are not defined for + invalid rectangles. A valid rectangle is not empty (i.e., isValid() + == !isEmpty()). + + \sa isNull(), isEmpty(), normalized() +*/ + + +/*! + Returns a normalized rectangle; i.e., a rectangle that has a + non-negative width and height. + + If width() < 0 the function swaps the left and right corners, and + it swaps the top and bottom corners if height() < 0. + + \sa isValid(), isEmpty() +*/ + +QRectF QRectF::normalized() const +{ + QRectF r = *this; + if (r.w < 0) { + r.xp += r.w; + r.w = -r.w; + } + if (r.h < 0) { + r.yp += r.h; + r.h = -r.h; + } + return r; +} + +/*! + \fn qreal QRectF::x() const + + Returns the x-coordinate of the rectangle's left edge. Equivalent + to left(). + + + \sa setX(), y(), topLeft() +*/ + +/*! + \fn qreal QRectF::y() const + + Returns the y-coordinate of the rectangle's top edge. Equivalent + to top(). + + \sa setY(), x(), topLeft() +*/ + + +/*! + \fn void QRectF::setLeft(qreal x) + + Sets the left edge of the rectangle to the given \a x + coordinate. May change the width, but will never change the right + edge of the rectangle. + + Equivalent to setX(). + + \sa left(), moveLeft() +*/ + +/*! + \fn void QRectF::setTop(qreal y) + + Sets the top edge of the rectangle to the given \a y coordinate. May + change the height, but will never change the bottom edge of the + rectangle. + + Equivalent to setY(). + + \sa top(), moveTop() +*/ + +/*! + \fn void QRectF::setRight(qreal x) + + Sets the right edge of the rectangle to the given \a x + coordinate. May change the width, but will never change the left + edge of the rectangle. + + \sa right(), moveRight() +*/ + +/*! + \fn void QRectF::setBottom(qreal y) + + Sets the bottom edge of the rectangle to the given \a y + coordinate. May change the height, but will never change the top + edge of the rectangle. + + \sa bottom(), moveBottom() +*/ + +/*! + \fn void QRectF::setX(qreal x) + + Sets the left edge of the rectangle to the given \a x + coordinate. May change the width, but will never change the right + edge of the rectangle. + + Equivalent to setLeft(). + + \sa x(), setY(), setTopLeft() +*/ + +/*! + \fn void QRectF::setY(qreal y) + + Sets the top edge of the rectangle to the given \a y + coordinate. May change the height, but will never change the + bottom edge of the rectangle. + + Equivalent to setTop(). + + \sa y(), setX(), setTopLeft() +*/ + +/*! + \fn void QRectF::setTopLeft(const QPointF &position) + + Set the top-left corner of the rectangle to the given \a + position. May change the size, but will never change the + bottom-right corner of the rectangle. + + \sa topLeft(), moveTopLeft() +*/ + +/*! + \fn void QRectF::setBottomRight(const QPointF &position) + + Set the bottom-right corner of the rectangle to the given \a + position. May change the size, but will never change the + top-left corner of the rectangle. + + \sa bottomRight(), moveBottomRight() +*/ + +/*! + \fn void QRectF::setTopRight(const QPointF &position) + + Set the top-right corner of the rectangle to the given \a + position. May change the size, but will never change the + bottom-left corner of the rectangle. + + \sa topRight(), moveTopRight() +*/ + +/*! + \fn void QRectF::setBottomLeft(const QPointF &position) + + Set the bottom-left corner of the rectangle to the given \a + position. May change the size, but will never change the + top-right corner of the rectangle. + + \sa bottomLeft(), moveBottomLeft() +*/ + +/*! + \fn QPointF QRectF::center() const + + Returns the center point of the rectangle. + + \sa moveCenter() +*/ + + +/*! + \fn void QRectF::getRect(qreal *x, qreal *y, qreal *width, qreal *height) const + + Extracts the position of the rectangle's top-left corner to *\a x and + *\a y, and its dimensions to *\a width and *\a height. + + \sa setRect(), getCoords() +*/ + + +/*! + \fn void QRectF::getCoords(qreal *x1, qreal *y1, qreal *x2, qreal *y2) const + + Extracts the position of the rectangle's top-left corner to *\a x1 + and *\a y1, and the position of the bottom-right corner to *\a x2 and + *\a y2. + + \sa setCoords(), getRect() +*/ + +/*! + \fn void QRectF::moveLeft(qreal x) + + Moves the rectangle horizontally, leaving the rectangle's left + edge at the given \a x coordinate. The rectangle's size is + unchanged. + + \sa left(), setLeft(), moveRight() +*/ + +/*! + \fn void QRectF::moveTop(qreal y) + + Moves the rectangle vertically, leaving the rectangle's top line + at the given \a y coordinate. The rectangle's size is unchanged. + + \sa top(), setTop(), moveBottom() +*/ + + +/*! + \fn void QRectF::moveRight(qreal x) + + Moves the rectangle horizontally, leaving the rectangle's right + edge at the given \a x coordinate. The rectangle's size is + unchanged. + + \sa right(), setRight(), moveLeft() +*/ + + +/*! + \fn void QRectF::moveBottom(qreal y) + + Moves the rectangle vertically, leaving the rectangle's bottom + edge at the given \a y coordinate. The rectangle's size is + unchanged. + + \sa bottom(), setBottom(), moveTop() +*/ + + +/*! + \fn void QRectF::moveTopLeft(const QPointF &position) + + Moves the rectangle, leaving the top-left corner at the given \a + position. The rectangle's size is unchanged. + + \sa setTopLeft(), moveTop(), moveLeft() +*/ + + +/*! + \fn void QRectF::moveBottomRight(const QPointF &position) + + Moves the rectangle, leaving the bottom-right corner at the given + \a position. The rectangle's size is unchanged. + + \sa setBottomRight(), moveBottom(), moveRight() +*/ + + +/*! + \fn void QRectF::moveTopRight(const QPointF &position) + + Moves the rectangle, leaving the top-right corner at the given + \a position. The rectangle's size is unchanged. + + \sa setTopRight(), moveTop(), moveRight() +*/ + + +/*! + \fn void QRectF::moveBottomLeft(const QPointF &position) + + Moves the rectangle, leaving the bottom-left corner at the given + \a position. The rectangle's size is unchanged. + + \sa setBottomLeft(), moveBottom(), moveLeft() +*/ + + +/*! + \fn void QRectF::moveTo(qreal x, qreal y) + + Moves the rectangle, leaving the top-left corner at the given + position (\a x, \a y). The rectangle's size is unchanged. + + \sa translate(), moveTopLeft() +*/ + +/*! + \fn void QRectF::moveTo(const QPointF &position) + \overload + + Moves the rectangle, leaving the top-left corner at the given \a + position. +*/ + +/*! + \fn void QRectF::translate(qreal dx, qreal dy) + + Moves the rectangle \a dx along the x-axis and \a dy along the y-axis, + relative to the current position. Positive values move the rectangle to the + right and downwards. + + \sa moveTopLeft(), moveTo(), translated() +*/ + + +/*! + \fn void QRectF::translate(const QPointF &offset) + \overload + + Moves the rectangle \a{offset}.\l{QPointF::x()}{x()} along the x + axis and \a{offset}.\l{QPointF::y()}{y()} along the y axis, + relative to the current position. +*/ + + +/*! + \fn QRectF QRectF::translated(qreal dx, qreal dy) const + + Returns a copy of the rectangle that is translated \a dx along the + x axis and \a dy along the y axis, relative to the current + position. Positive values move the rectangle to the right and + down. + + \sa translate() +*/ + + +/*! + \fn QRectF QRectF::translated(const QPointF &offset) const + \overload + + Returns a copy of the rectangle that is translated + \a{offset}.\l{QPointF::x()}{x()} along the x axis and + \a{offset}.\l{QPointF::y()}{y()} along the y axis, relative to the + current position. +*/ + + +/*! + \fn void QRectF::setRect(qreal x, qreal y, qreal width, qreal height) + + Sets the coordinates of the rectangle's top-left corner to (\a x, + \a y), and its size to the given \a width and \a height. + + \sa getRect(), setCoords() +*/ + + +/*! + \fn void QRectF::setCoords(qreal x1, qreal y1, qreal x2, qreal y2) + + Sets the coordinates of the rectangle's top-left corner to (\a x1, + \a y1), and the coordinates of its bottom-right corner to (\a x2, + \a y2). + + \sa getCoords() setRect() +*/ + +/*! + \fn QRectF QRectF::adjusted(qreal dx1, qreal dy1, qreal dx2, qreal dy2) const + + Returns a new rectangle with \a dx1, \a dy1, \a dx2 and \a dy2 + added respectively to the existing coordinates of this rectangle. + + \sa adjust() +*/ + +/*! \fn void QRectF::adjust(qreal dx1, qreal dy1, qreal dx2, qreal dy2) + + Adds \a dx1, \a dy1, \a dx2 and \a dy2 respectively to the + existing coordinates of the rectangle. + + \sa adjusted(), setRect() +*/ +/*! + \fn QSizeF QRectF::size() const + + Returns the size of the rectangle. + + \sa setSize(), width(), height() +*/ + +/*! + \fn qreal QRectF::width() const + + Returns the width of the rectangle. + + \sa setWidth(), height(), size() +*/ + +/*! + \fn qreal QRectF::height() const + + Returns the height of the rectangle. + + \sa setHeight(), width(), size() +*/ + +/*! + \fn void QRectF::setWidth(qreal width) + + Sets the width of the rectangle to the given \a width. The right + edge is changed, but not the left one. + + \sa width(), setSize() +*/ + + +/*! + \fn void QRectF::setHeight(qreal height) + + Sets the height of the rectangle to the given \a height. The bottom + edge is changed, but not the top one. + + \sa height(), setSize() +*/ + + +/*! + \fn void QRectF::setSize(const QSizeF &size) + + Sets the size of the rectangle to the given \a size. The top-left + corner is not moved. + + \sa size(), setWidth(), setHeight() +*/ + + +/*! + \fn bool QRectF::contains(const QPointF &point) const + + Returns true if the given \a point is inside or on the edge of the + rectangle; otherwise returns false. + + \sa intersects() +*/ + +bool QRectF::contains(const QPointF &p) const +{ + qreal l = xp; + qreal r = xp; + if (w < 0) + l += w; + else + r += w; + if (l == r) // null rect + return false; + + if (p.x() < l || p.x() > r) + return false; + + qreal t = yp; + qreal b = yp; + if (h < 0) + t += h; + else + b += h; + if (t == b) // null rect + return false; + + if (p.y() < t || p.y() > b) + return false; + + return true; +} + + +/*! + \fn bool QRectF::contains(qreal x, qreal y) const + \overload + + Returns true if the point (\a x, \a y) is inside or on the edge of + the rectangle; otherwise returns false. +*/ + +/*! + \fn bool QRectF::contains(const QRectF &rectangle) const + \overload + + Returns true if the given \a rectangle is inside this rectangle; + otherwise returns false. +*/ + +bool QRectF::contains(const QRectF &r) const +{ + qreal l1 = xp; + qreal r1 = xp; + if (w < 0) + l1 += w; + else + r1 += w; + if (l1 == r1) // null rect + return false; + + qreal l2 = r.xp; + qreal r2 = r.xp; + if (r.w < 0) + l2 += r.w; + else + r2 += r.w; + if (l2 == r2) // null rect + return false; + + if (l2 < l1 || r2 > r1) + return false; + + qreal t1 = yp; + qreal b1 = yp; + if (h < 0) + t1 += h; + else + b1 += h; + if (t1 == b1) // null rect + return false; + + qreal t2 = r.yp; + qreal b2 = r.yp; + if (r.h < 0) + t2 += r.h; + else + b2 += r.h; + if (t2 == b2) // null rect + return false; + + if (t2 < t1 || b2 > b1) + return false; + + return true; +} + +/*! + \fn qreal QRectF::left() const + + Returns the x-coordinate of the rectangle's left edge. Equivalent + to x(). + + \sa setLeft(), topLeft(), bottomLeft() +*/ + +/*! + \fn qreal QRectF::top() const + + Returns the y-coordinate of the rectangle's top edge. Equivalent + to y(). + + \sa setTop(), topLeft(), topRight() +*/ + +/*! + \fn qreal QRectF::right() const + + Returns the x-coordinate of the rectangle's right edge. + + \sa setRight(), topRight(), bottomRight() +*/ + +/*! + \fn qreal QRectF::bottom() const + + Returns the y-coordinate of the rectangle's bottom edge. + + \sa setBottom(), bottomLeft(), bottomRight() +*/ + +/*! + \fn QPointF QRectF::topLeft() const + + Returns the position of the rectangle's top-left corner. + + \sa setTopLeft(), top(), left() +*/ + +/*! + \fn QPointF QRectF::bottomRight() const + + Returns the position of the rectangle's bottom-right corner. + + \sa setBottomRight(), bottom(), right() +*/ + +/*! + \fn QPointF QRectF::topRight() const + + Returns the position of the rectangle's top-right corner. + + \sa setTopRight(), top(), right() +*/ + +/*! + \fn QPointF QRectF::bottomLeft() const + + Returns the position of the rectangle's bottom-left corner. + + \sa setBottomLeft(), bottom(), left() +*/ + +/*! + \fn QRectF& QRectF::operator|=(const QRectF &rectangle) + + Unites this rectangle with the given \a rectangle. + + \sa united(), operator|() +*/ + +/*! + \fn QRectF& QRectF::operator&=(const QRectF &rectangle) + + Intersects this rectangle with the given \a rectangle. + + \sa intersected(), operator|=() +*/ + + +/*! + \fn QRectF QRectF::operator|(const QRectF &rectangle) const + + Returns the bounding rectangle of this rectangle and the given \a rectangle. + + \sa united(), operator|=() +*/ + +QRectF QRectF::operator|(const QRectF &r) const +{ + if (isNull()) + return r; + if (r.isNull()) + return *this; + + qreal left = xp; + qreal right = xp; + if (w < 0) + left += w; + else + right += w; + + if (r.w < 0) { + left = qMin(left, r.xp + r.w); + right = qMax(right, r.xp); + } else { + left = qMin(left, r.xp); + right = qMax(right, r.xp + r.w); + } + + qreal top = yp; + qreal bottom = yp; + if (h < 0) + top += h; + else + bottom += h; + + if (r.h < 0) { + top = qMin(top, r.yp + r.h); + bottom = qMax(bottom, r.yp); + } else { + top = qMin(top, r.yp); + bottom = qMax(bottom, r.yp + r.h); + } + + return QRectF(left, top, right - left, bottom - top); +} + +/*! + \fn QRectF QRectF::unite(const QRectF &rectangle) const + \obsolete + + Use united(\a rectangle) instead. +*/ + +/*! + \fn QRectF QRectF::united(const QRectF &rectangle) const + \since 4.2 + + Returns the bounding rectangle of this rectangle and the given \a + rectangle. + + \image qrect-unite.png + + \sa intersected() +*/ + + +/*! + \fn QRectF QRectF::operator &(const QRectF &rectangle) const + + Returns the intersection of this rectangle and the given \a + rectangle. Returns an empty rectangle if there is no intersection. + + \sa operator&=(), intersected() +*/ + +QRectF QRectF::operator&(const QRectF &r) const +{ + qreal l1 = xp; + qreal r1 = xp; + if (w < 0) + l1 += w; + else + r1 += w; + if (l1 == r1) // null rect + return QRectF(); + + qreal l2 = r.xp; + qreal r2 = r.xp; + if (r.w < 0) + l2 += r.w; + else + r2 += r.w; + if (l2 == r2) // null rect + return QRectF(); + + if (l1 >= r2 || l2 >= r1) + return QRectF(); + + qreal t1 = yp; + qreal b1 = yp; + if (h < 0) + t1 += h; + else + b1 += h; + if (t1 == b1) // null rect + return QRectF(); + + qreal t2 = r.yp; + qreal b2 = r.yp; + if (r.h < 0) + t2 += r.h; + else + b2 += r.h; + if (t2 == b2) // null rect + return QRectF(); + + if (t1 >= b2 || t2 >= b1) + return QRectF(); + + QRectF tmp; + tmp.xp = qMax(l1, l2); + tmp.yp = qMax(t1, t2); + tmp.w = qMin(r1, r2) - tmp.xp; + tmp.h = qMin(b1, b2) - tmp.yp; + return tmp; +} + +/*! + \fn QRectF QRectF::intersect(const QRectF &rectangle) const + \obsolete + + Use intersected(\a rectangle) instead. +*/ + +/*! + \fn QRectF QRectF::intersected(const QRectF &rectangle) const + \since 4.2 + + Returns the intersection of this rectangle and the given \a + rectangle. Note that \c {r.intersected(s)} is equivalent to \c + {r & s}. + + \image qrect-intersect.png + + \sa intersects(), united(), operator&=() +*/ + +/*! + \fn bool QRectF::intersects(const QRectF &rectangle) const + + Returns true if this rectangle intersects with the given \a + rectangle (i.e. there is a non-empty area of overlap between + them), otherwise returns false. + + The intersection rectangle can be retrieved using the intersected() + function. + + \sa contains() +*/ + +bool QRectF::intersects(const QRectF &r) const +{ + qreal l1 = xp; + qreal r1 = xp; + if (w < 0) + l1 += w; + else + r1 += w; + if (l1 == r1) // null rect + return false; + + qreal l2 = r.xp; + qreal r2 = r.xp; + if (r.w < 0) + l2 += r.w; + else + r2 += r.w; + if (l2 == r2) // null rect + return false; + + if (l1 >= r2 || l2 >= r1) + return false; + + qreal t1 = yp; + qreal b1 = yp; + if (h < 0) + t1 += h; + else + b1 += h; + if (t1 == b1) // null rect + return false; + + qreal t2 = r.yp; + qreal b2 = r.yp; + if (r.h < 0) + t2 += r.h; + else + b2 += r.h; + if (t2 == b2) // null rect + return false; + + if (t1 >= b2 || t2 >= b1) + return false; + + return true; +} + +/*! + \fn QRect QRectF::toRect() const + + Returns a QRect based on the values of this rectangle. Note that the + coordinates in the returned rectangle are rounded to the nearest integer. + + \sa QRectF(), toAlignedRect() +*/ + +/*! + \fn QRect QRectF::toAlignedRect() const + \since 4.3 + + Returns a QRect based on the values of this rectangle that is the + smallest possible integer rectangle that completely contains this + rectangle. + + \sa toRect() +*/ + +QRect QRectF::toAlignedRect() const +{ + int xmin = int(qFloor(xp)); + int xmax = int(qCeil(xp + w)); + int ymin = int(qFloor(yp)); + int ymax = int(qCeil(yp + h)); + return QRect(xmin, ymin, xmax - xmin, ymax - ymin); +} + +/*! + \fn void QRectF::moveCenter(const QPointF &position) + + Moves the rectangle, leaving the center point at the given \a + position. The rectangle's size is unchanged. + + \sa center() +*/ + +/*! + \fn bool operator==(const QRectF &r1, const QRectF &r2) + \relates QRectF + + Returns true if the rectangles \a r1 and \a r2 are equal, + otherwise returns false. +*/ + + +/*! + \fn bool operator!=(const QRectF &r1, const QRectF &r2) + \relates QRectF + + Returns true if the rectangles \a r1 and \a r2 are different, otherwise + returns false. +*/ + +/***************************************************************************** + QRectF stream functions + *****************************************************************************/ +#ifndef QT_NO_DATASTREAM +/*! + \fn QDataStream &operator<<(QDataStream &stream, const QRectF &rectangle) + + \relates QRectF + + Writes the \a rectangle to the \a stream, and returns a reference to the + stream. + + \sa {Serializing Qt Data Types} +*/ + +QDataStream &operator<<(QDataStream &s, const QRectF &r) +{ + s << double(r.x()) << double(r.y()) << double(r.width()) << double(r.height()); + return s; +} + +/*! + \fn QDataStream &operator>>(QDataStream &stream, QRectF &rectangle) + + \relates QRectF + + Reads a \a rectangle from the \a stream, and returns a reference to the + stream. + + \sa {Serializing Qt Data Types} +*/ + +QDataStream &operator>>(QDataStream &s, QRectF &r) +{ + double x, y, w, h; + s >> x; + s >> y; + s >> w; + s >> h; + r.setRect(qreal(x), qreal(y), qreal(w), qreal(h)); + return s; +} + +#endif // QT_NO_DATASTREAM + + +#ifndef QT_NO_DEBUG_STREAM +QDebug operator<<(QDebug dbg, const QRectF &r) { + dbg.nospace() << "QRectF(" << r.x() << ',' << r.y() << ' ' + << r.width() << 'x' << r.height() << ')'; + return dbg.space(); +} +#endif + +QT_END_NAMESPACE |