/****************************************************************************

**

** Copyright (C) 2010 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()

*/