qrect.cpp

Go to the documentation of this file.

/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtCore module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
 
#include "qrect.h"
#include "qdatastream.h"
#include "qmath.h"
 
#include <private/qdebug_p.h>
 
QT_BEGIN_NAMESPACE
 
/*****************************************************************************
  QRect member functions
 *****************************************************************************/
 
QRect QRect::normalized() const noexcept
{
    QRect r(*this);
    if (x2 < x1) {                                // swap bad x values
        r.x1 = x2 + 1;
        r.x2 = x1 - 1;
    }
    if (y2 < y1) {                                // swap bad y values
        r.y1 = y2 + 1;
        r.y2 = y1 - 1;
    }
    return r;
}
 
 
bool QRect::contains(const QPoint &p, bool proper) const noexcept
{
    int l, r;
    if (x2 < x1 - 1) {
        l = x2 + 1;
        r = x1 - 1;
    } 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 + 1;
        b = y1 - 1;
    } 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;
}
 
 
bool QRect::contains(const QRect &r, bool proper) const noexcept
{
    if (isNull() || r.isNull())
        return false;
 
    int l1 = x1;
    int r1 = x1 - 1;
    if (x2 < x1 - 1)
        l1 = x2 + 1;
    else
        r1 = x2;
 
    int l2 = r.x1;
    int r2 = r.x1 - 1;
    if (r.x2 < r.x1 - 1)
        l2 = r.x2 + 1;
    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 - 1;
    if (y2 < y1 - 1)
        t1 = y2 + 1;
    else
        b1 = y2;
 
    int t2 = r.y1;
    int b2 = r.y1 - 1;
    if (r.y2 < r.y1 - 1)
        t2 = r.y2 + 1;
    else
        b2 = r.y2;
 
    if (proper) {
        if (t2 <= t1 || b2 >= b1)
            return false;
    } else {
        if (t2 < t1 || b2 > b1)
            return false;
    }
 
    return true;
}
 
QRect QRect::operator|(const QRect &r) const noexcept
{
    if (isNull())
        return r;
    if (r.isNull())
        return *this;
 
    int l1 = x1;
    int r1 = x1 - 1;
    if (x2 < x1 - 1)
        l1 = x2 + 1;
    else
        r1 = x2;
 
    int l2 = r.x1;
    int r2 = r.x1 - 1;
    if (r.x2 < r.x1 - 1)
        l2 = r.x2 + 1;
    else
        r2 = r.x2;
 
    int t1 = y1;
    int b1 = y1 - 1;
    if (y2 < y1 - 1)
        t1 = y2 + 1;
    else
        b1 = y2;
 
    int t2 = r.y1;
    int b2 = r.y1 - 1;
    if (r.y2 < r.y1 - 1)
        t2 = r.y2 + 1;
    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;
}
 
QRect QRect::operator&(const QRect &r) const noexcept
{
    if (isNull() || r.isNull())
        return QRect();
 
    int l1 = x1;
    int r1 = x2;
    if (x2 < x1 - 1) {
        l1 = x2 + 1;
        r1 = x1 - 1;
    }
 
    int l2 = r.x1;
    int r2 = r.x2;
    if (r.x2 < r.x1 - 1) {
        l2 = r.x2 + 1;
        r2 = r.x1 - 1;
    }
 
    if (l1 > r2 || l2 > r1)
        return QRect();
 
    int t1 = y1;
    int b1 = y2;
    if (y2 < y1 - 1) {
        t1 = y2 + 1;
        b1 = y1 - 1;
    }
 
    int t2 = r.y1;
    int b2 = r.y2;
    if (r.y2 < r.y1 - 1) {
        t2 = r.y2 + 1;
        b2 = r.y1 - 1;
    }
 
    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;
}
 
bool QRect::intersects(const QRect &r) const noexcept
{
    if (isNull() || r.isNull())
        return false;
 
    int l1 = x1;
    int r1 = x2;
    if (x2 < x1 - 1) {
        l1 = x2 + 1;
        r1 = x1 - 1;
    }
 
    int l2 = r.x1;
    int r2 = r.x2;
    if (r.x2 < r.x1 - 1) {
        l2 = r.x2 + 1;
        r2 = r.x1 - 1;
    }
 
    if (l1 > r2 || l2 > r1)
        return false;
 
    int t1 = y1;
    int b1 = y2;
    if (y2 < y1 - 1) {
        t1 = y2 + 1;
        b1 = y1 - 1;
    }
 
    int t2 = r.y1;
    int b2 = r.y2;
    if (r.y2 < r.y1 - 1) {
        t2 = r.y2 + 1;
        b2 = r.y1 - 1;
    }
 
    if (t1 > b2 || t2 > b1)
        return false;
 
    return true;
}
 
/*****************************************************************************
  QRect stream functions
 *****************************************************************************/
#ifndef QT_NO_DATASTREAM
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;
}
 
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)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace();
    dbg << "QRect" << '(';
    QtDebugUtils::formatQRect(dbg, r);
    dbg << ')';
    return dbg;
}
#endif
 
/*****************************************************************************
  QRectF member functions
 *****************************************************************************/
 
QRectF QRectF::normalized() const noexcept
{
    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;
}
 
bool QRectF::contains(const QPointF &p) const noexcept
{
    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;
}
 
 
bool QRectF::contains(const QRectF &r) const noexcept
{
    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;
}
 
QRectF QRectF::operator|(const QRectF &r) const noexcept
{
    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);
}
 
QRectF QRectF::operator&(const QRectF &r) const noexcept
{
    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;
}
 
bool QRectF::intersects(const QRectF &r) const noexcept
{
    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;
}
 
QRect QRectF::toAlignedRect() const noexcept
{
    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);
}
 
/*****************************************************************************
  QRectF stream functions
 *****************************************************************************/
#ifndef QT_NO_DATASTREAM
QDataStream &operator<<(QDataStream &s, const QRectF &r)
{
    s << double(r.x()) << double(r.y()) << double(r.width()) << double(r.height());
    return s;
}
 
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)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace();
    dbg << "QRectF" << '(';
    QtDebugUtils::formatQRect(dbg, r);
    dbg << ')';
    return dbg;
}
#endif
 
QT_END_NAMESPACE