mirror of
https://bitbucket.org/smil3y/katie.git
synced 2025-02-26 20:03:13 +00:00
2446 lines
58 KiB
C++
2446 lines
58 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2015 The Qt Company Ltd.
|
|
** Copyright (C) 2016-2019 Ivailo Monev
|
|
**
|
|
** This file is part of the QtCore module of the Katie Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:LGPL$
|
|
** 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 or version 3 as published by the Free
|
|
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
|
|
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
|
|
** following information to ensure the GNU Lesser General Public License
|
|
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
|
|
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
|
**
|
|
** As a special exception, The Qt Company gives you certain additional
|
|
** rights. These rights are described in The Qt Company LGPL Exception
|
|
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 3.0 as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.GPL included in the
|
|
** packaging of this file. Please review the following information to
|
|
** ensure the GNU General Public License version 3.0 requirements will be
|
|
** met: http://www.gnu.org/copyleft/gpl.html.
|
|
**
|
|
** $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)
|
|
{
|
|
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)
|
|
{
|
|
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
|