Initial import from the monolithic Qt.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://qt.gitorious.org/qt/pages/GitIntroductionWithQt

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12

1 files changed, 1003 insertions, 0 deletions

diff --git a/src/gui/painting/qpolygon.cpp b/src/gui/painting/qpolygon.cpp
new file mode 100644
index 0000000000..41b686adef
--- /dev/null
+++ b/src/gui/painting/qpolygon.cpp
@@ -0,0 +1,1003 @@
+/****************************************************************************
+**
+** 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 QtGui 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 "qpolygon.h"
+#include "qrect.h"
+#include "qdatastream.h"
+#include "qmatrix.h"
+#include "qdebug.h"
+#include "qpainterpath.h"
+#include "qvariant.h"
+#include "qpainterpath_p.h"
+#include "qbezier_p.h"
+
+#include <stdarg.h>
+
+QT_BEGIN_NAMESPACE
+
+//same as qt_painterpath_isect_line in qpainterpath.cpp
+static void qt_polygon_isect_line(const QPointF &p1, const QPointF &p2, const QPointF &pos,
+                                  int *winding)
+{
+    qreal x1 = p1.x();
+    qreal y1 = p1.y();
+    qreal x2 = p2.x();
+    qreal y2 = p2.y();
+    qreal y = pos.y();
+
+    int dir = 1;
+
+    if (qFuzzyCompare(y1, y2)) {
+        // ignore horizontal lines according to scan conversion rule
+        return;
+    } else if (y2 < y1) {
+        qreal x_tmp = x2; x2 = x1; x1 = x_tmp;
+        qreal y_tmp = y2; y2 = y1; y1 = y_tmp;
+        dir = -1;
+    }
+
+    if (y >= y1 && y < y2) {
+        qreal x = x1 + ((x2 - x1) / (y2 - y1)) * (y - y1);
+
+        // count up the winding number if we're
+        if (x<=pos.x()) {
+            (*winding) += dir;
+        }
+    }
+}
+
+/*!
+    \class QPolygon
+    \brief The QPolygon class provides a vector of points using
+    integer precision.
+
+    \reentrant
+
+    \ingroup painting
+    \ingroup shared
+
+    A QPolygon object is a QVector<QPoint>.  The easiest way to add
+    points to a QPolygon is to use QVector's streaming operator, as
+    illustrated below:
+
+    \snippet doc/src/snippets/polygon/polygon.cpp 0
+
+    In addition to the functions provided by QVector, QPolygon
+    provides some point-specific functions.
+
+    Each point in a polygon can be retrieved by passing its index to
+    the point() function. To populate the polygon, QPolygon provides
+    the setPoint() function to set the point at a given index, the
+    setPoints() function to set all the points in the polygon
+    (resizing it to the given number of points), and the putPoints()
+    function which copies a number of given points into the polygon
+    from a specified index (resizing the polygon if necessary).
+
+    QPolygon provides the boundingRect() and translate() functions for
+    geometry functions. Use the QMatrix::map() function for more
+    general transformations of QPolygons.
+
+    The QPolygon class is \l {Implicit Data Sharing}{implicitly
+    shared}.
+
+    \sa QVector, QPolygonF, QLine
+*/
+
+
+/*****************************************************************************
+  QPolygon member functions
+ *****************************************************************************/
+
+/*!
+    \fn QPolygon::QPolygon()
+
+    Constructs a polygon with no points.
+
+    \sa QVector::isEmpty()
+*/
+
+/*!
+    \fn QPolygon::QPolygon(int size)
+
+    Constructs a polygon of the given \a size. Creates an empty
+    polygon if \a size == 0.
+
+    \sa QVector::isEmpty()
+*/
+
+/*!
+    \fn QPolygon::QPolygon(const QPolygon &polygon)
+
+    Constructs a copy of the given \a polygon.
+
+    \sa setPoints()
+*/
+
+/*!
+    \fn QPolygon::QPolygon(const QVector<QPoint> &points)
+
+    Constructs a polygon containing the specified \a points.
+
+    \sa setPoints()
+*/
+
+/*!
+    \fn QPolygon::QPolygon(const QRect &rectangle, bool closed)
+
+    Constructs a polygon from the given \a rectangle.  If \a closed is
+    false, the polygon just contains the four points of the rectangle
+    ordered clockwise, otherwise the polygon's fifth point is set to
+    \a {rectangle}.topLeft().
+
+    Note that the bottom-right corner of the rectangle is located at
+    (rectangle.x() + rectangle.width(), rectangle.y() +
+    rectangle.height()).
+
+    \sa setPoints()
+*/
+
+QPolygon::QPolygon(const QRect &r, bool closed)
+{
+    reserve(closed ? 5 : 4);
+    *this << QPoint(r.x(), r.y())
+          << QPoint(r.x() + r.width(), r.y())
+          << QPoint(r.x() + r.width(), r.y() + r.height())
+          << QPoint(r.x(), r.y() + r.height());
+    if (closed)
+        *this << QPoint(r.left(), r.top());
+}
+
+/*!
+    \internal
+    Constructs a point array with \a nPoints points, taken from the
+    \a points array.
+
+    Equivalent to setPoints(nPoints, points).
+*/
+
+QPolygon::QPolygon(int nPoints, const int *points)
+{
+    setPoints(nPoints, points);
+}
+
+
+/*!
+    \fn QPolygon::~QPolygon()
+
+    Destroys the polygon.
+*/
+
+
+/*!
+    Translates all points in the polygon by (\a{dx}, \a{dy}).
+
+    \sa translated()
+*/
+
+void QPolygon::translate(int dx, int dy)
+{
+    if (dx == 0 && dy == 0)
+        return;
+
+    register QPoint *p = data();
+    register int i = size();
+    QPoint pt(dx, dy);
+    while (i--) {
+        *p += pt;
+        ++p;
+    }
+}
+
+/*!
+    \fn void QPolygon::translate(const QPoint &offset)
+    \overload
+
+    Translates all points in the polygon by the given \a offset.
+
+    \sa translated()
+*/
+
+/*!
+    Returns a copy of the polygon that is translated by (\a{dx}, \a{dy}).
+
+    \since 4.6
+    \sa translate()
+*/
+QPolygon QPolygon::translated(int dx, int dy) const
+{
+    QPolygon copy(*this);
+    copy.translate(dx, dy);
+    return copy;
+}
+
+/*!
+    \fn void QPolygon::translated(const QPoint &offset) const
+    \overload
+    \since 4.6
+
+    Returns a copy of the polygon that is translated by the given \a offset.
+
+    \sa translate()
+*/
+
+/*!
+    Extracts the coordinates of the point at the given \a index to
+    *\a{x} and *\a{y} (if they are valid pointers).
+
+    \sa setPoint()
+*/
+
+void QPolygon::point(int index, int *x, int *y) const
+{
+    QPoint p = at(index);
+    if (x)
+        *x = (int)p.x();
+    if (y)
+        *y = (int)p.y();
+}
+
+/*!
+    \fn QPoint QPolygon::point(int index) const
+    \overload
+
+    Returns the point at the given \a index.
+*/
+
+/*!
+    \fn void QPolygon::setPoint(int index, const QPoint &point)
+    \overload
+
+    Sets the point at the given \a index to the given \a point.
+*/
+
+/*!
+    \fn void QPolygon::setPoint(int index, int x, int y)
+
+    Sets the point at the given \a index to the point specified by
+    (\a{x}, \a{y}).
+
+    \sa point(), putPoints(), setPoints(),
+*/
+
+/*!
+    Resizes the polygon to \a nPoints and populates it with the given
+    \a points.
+
+    The example code creates a polygon with two points (10, 20) and
+    (30, 40):
+
+    \snippet doc/src/snippets/polygon/polygon.cpp 2
+
+    \sa setPoint() putPoints()
+*/
+
+void QPolygon::setPoints(int nPoints, const int *points)
+{
+    resize(nPoints);
+    int i = 0;
+    while (nPoints--) {
+        setPoint(i++, *points, *(points+1));
+        points += 2;
+    }
+}
+
+/*!
+    \overload
+
+    Resizes the polygon to \a nPoints and populates it with the points
+    specified by the variable argument list.  The points are given as a
+    sequence of integers, starting with \a firstx then \a firsty, and
+    so on.
+
+    The example code creates a polygon with two points (10, 20) and
+    (30, 40):
+
+    \snippet doc/src/snippets/polygon/polygon.cpp 3
+*/
+
+void QPolygon::setPoints(int nPoints, int firstx, int firsty, ...)
+{
+    va_list ap;
+    resize(nPoints);
+    setPoint(0, firstx, firsty);
+    int i = 0, x, y;
+    va_start(ap, firsty);
+    while (--nPoints) {
+        x = va_arg(ap, int);
+        y = va_arg(ap, int);
+        setPoint(++i, x, y);
+    }
+    va_end(ap);
+}
+
+/*!
+    \overload
+    \internal
+
+    Copies \a nPoints points from the \a points coord array into this
+    point array, and resizes the point array if \c{index+nPoints}
+    exceeds the size of the array.
+
+    \sa setPoint()
+*/
+
+void QPolygon::putPoints(int index, int nPoints, const int *points)
+{
+    if (index + nPoints > size())
+        resize(index + nPoints);
+    int i = index;
+    while (nPoints--) {
+        setPoint(i++, *points, *(points+1));
+        points += 2;
+    }
+}
+
+/*!
+    Copies \a nPoints points from the variable argument list into this
+    polygon from the given \a index.
+
+    The points are given as a sequence of integers, starting with \a
+    firstx then \a firsty, and so on. The polygon is resized if
+    \c{index+nPoints} exceeds its current size.
+
+    The example code creates a polygon with three points (4,5), (6,7)
+    and (8,9), by expanding the polygon from 1 to 3 points:
+
+    \snippet doc/src/snippets/polygon/polygon.cpp 4
+
+    The following code has the same result, but here the putPoints()
+    function overwrites rather than extends:
+
+    \snippet doc/src/snippets/polygon/polygon.cpp 5
+
+    \sa setPoints()
+*/
+
+void QPolygon::putPoints(int index, int nPoints, int firstx, int firsty, ...)
+{
+    va_list ap;
+    if (index + nPoints > size())
+        resize(index + nPoints);
+    if (nPoints <= 0)
+        return;
+    setPoint(index, firstx, firsty);
+    int i = index, x, y;
+    va_start(ap, firsty);
+    while (--nPoints) {
+        x = va_arg(ap, int);
+        y = va_arg(ap, int);
+        setPoint(++i, x, y);
+    }
+    va_end(ap);
+}
+
+
+/*!
+    \fn void QPolygon::putPoints(int index, int nPoints, const QPolygon &fromPolygon, int fromIndex)
+    \overload
+
+    Copies \a nPoints points from the given \a fromIndex ( 0 by
+    default) in \a fromPolygon into this polygon, starting at the
+    specified \a index. For example:
+
+    \snippet doc/src/snippets/polygon/polygon.cpp 6
+*/
+
+void QPolygon::putPoints(int index, int nPoints, const QPolygon & from, int fromIndex)
+{
+    if (index + nPoints > size())
+        resize(index + nPoints);
+    if (nPoints <= 0)
+        return;
+    int n = 0;
+    while(n < nPoints) {
+        setPoint(index + n, from[fromIndex+n]);
+        ++n;
+    }
+}
+
+
+/*!
+    Returns the bounding rectangle of the polygon, or QRect(0, 0, 0,
+    0) if the polygon is empty.
+
+    \sa QVector::isEmpty()
+*/
+
+QRect QPolygon::boundingRect() const
+{
+    if (isEmpty())
+        return QRect(0, 0, 0, 0);
+    register const QPoint *pd = constData();
+    int minx, maxx, miny, maxy;
+    minx = maxx = pd->x();
+    miny = maxy = pd->y();
+    ++pd;
+    for (int i = 1; i < size(); ++i) {
+        if (pd->x() < minx)
+            minx = pd->x();
+        else if (pd->x() > maxx)
+            maxx = pd->x();
+        if (pd->y() < miny)
+            miny = pd->y();
+        else if (pd->y() > maxy)
+            maxy = pd->y();
+        ++pd;
+    }
+    return QRect(QPoint(minx,miny), QPoint(maxx,maxy));
+}
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug dbg, const QPolygon &a)
+{
+#ifndef Q_BROKEN_DEBUG_STREAM
+    dbg.nospace() << "QPolygon(";
+    for (int i = 0; i < a.count(); ++i)
+        dbg.nospace() << a.at(i);
+    dbg.nospace() << ')';
+    return dbg.space();
+#else
+    qWarning("This compiler doesn't support streaming QPolygon to QDebug");
+    return dbg;
+    Q_UNUSED(a);
+#endif
+}
+#endif
+
+
+/*!
+    \class QPolygonF
+    \brief The QPolygonF class provides a vector of points using
+    floating point precision.
+
+    \reentrant
+    \ingroup painting
+    \ingroup shared
+
+    A QPolygonF is a QVector<QPointF>. The easiest way to add points
+    to a QPolygonF is to use its streaming operator, as illustrated
+    below:
+
+    \snippet doc/src/snippets/polygon/polygon.cpp 1
+
+    In addition to the functions provided by QVector, QPolygonF
+    provides the boundingRect() and translate() functions for geometry
+    operations. Use the QMatrix::map() function for more general
+    transformations of QPolygonFs.
+
+    QPolygonF also provides the isClosed() function to determine
+    whether a polygon's start and end points are the same, and the
+    toPolygon() function returning an integer precision copy of this
+    polygon.
+
+    The QPolygonF class is \l {Implicit Data Sharing}{implicitly
+    shared}.
+
+    \sa QVector, QPolygon, QLineF
+*/
+
+
+/*****************************************************************************
+  QPolygonF member functions
+ *****************************************************************************/
+
+/*!
+    \fn QPolygonF::QPolygonF()
+
+    Constructs a polygon with no points.
+
+    \sa QVector::isEmpty()
+*/
+
+/*!
+    \fn QPolygonF::QPolygonF(int size)
+
+    Constructs a polygon of the given \a size. Creates an empty
+    polygon if \a size == 0.
+
+    \sa QVector::isEmpty()
+*/
+
+/*!
+    \fn QPolygonF::QPolygonF(const QPolygonF &polygon)
+
+    Constructs a copy of the given \a polygon.
+*/
+
+/*!
+    \fn QPolygonF::QPolygonF(const QVector<QPointF> &points)
+
+    Constructs a polygon containing the specified \a points.
+*/
+
+/*!
+    \fn QPolygonF::QPolygonF(const QRectF &rectangle)
+
+    Constructs a closed polygon from the specified \a rectangle.
+
+    The polygon contains the four vertices of the rectangle in
+    clockwise order starting and ending with the top-left vertex.
+
+    \sa isClosed()
+*/
+
+QPolygonF::QPolygonF(const QRectF &r)
+{
+    reserve(5);
+    append(QPointF(r.x(), r.y()));
+    append(QPointF(r.x() + r.width(), r.y()));
+    append(QPointF(r.x() + r.width(), r.y() + r.height()));
+    append(QPointF(r.x(), r.y() + r.height()));
+    append(QPointF(r.x(), r.y()));
+}
+
+/*!
+    \fn QPolygonF::QPolygonF(const QPolygon &polygon)
+
+    Constructs a float based polygon from the specified integer based
+    \a polygon.
+
+    \sa toPolygon()
+*/
+
+QPolygonF::QPolygonF(const QPolygon &a)
+{
+    reserve(a.size());
+    for (int i=0; i<a.size(); ++i)
+        append(a.at(i));
+}
+
+/*!
+    \fn QPolygonF::~QPolygonF()
+
+    Destroys the polygon.
+*/
+
+
+/*!
+    Translate all points in the polygon by the given \a offset.
+
+    \sa translated()
+*/
+
+void QPolygonF::translate(const QPointF &offset)
+{
+    if (offset.isNull())
+        return;
+
+    register QPointF *p = data();
+    register int i = size();
+    while (i--) {
+        *p += offset;
+        ++p;
+    }
+}
+
+/*!
+    \fn void QPolygonF::translate(qreal dx, qreal dy)
+    \overload
+
+    Translates all points in the polygon by (\a{dx}, \a{dy}).
+
+    \sa translated()
+*/
+
+/*!
+    Returns a copy of the polygon that is translated by the given \a offset.
+
+    \since 4.6
+    \sa translate()
+*/
+QPolygonF QPolygonF::translated(const QPointF &offset) const
+{
+    QPolygonF copy(*this);
+    copy.translate(offset);
+    return copy;
+}
+
+/*!
+    \fn void QPolygonF::translated(qreal dx, qreal dy) const
+    \overload
+    \since 4.6
+
+    Returns a copy of the polygon that is translated by (\a{dx}, \a{dy}).
+
+    \sa translate()
+*/
+
+/*!
+    \fn bool QPolygonF::isClosed() const
+
+    Returns true if the polygon is closed; otherwise returns false.
+
+    A polygon is said to be closed if its start point and end point are equal.
+
+    \sa QVector::first(), QVector::last()
+*/
+
+/*!
+    Returns the bounding rectangle of the polygon, or QRectF(0,0,0,0)
+    if the polygon is empty.
+
+    \sa QVector::isEmpty()
+*/
+
+QRectF QPolygonF::boundingRect() const
+{
+    if (isEmpty())
+        return QRectF(0, 0, 0, 0);
+    register const QPointF *pd = constData();
+    qreal minx, maxx, miny, maxy;
+    minx = maxx = pd->x();
+    miny = maxy = pd->y();
+    ++pd;
+    for (int i = 1; i < size(); ++i) {
+        if (pd->x() < minx)
+            minx = pd->x();
+        else if (pd->x() > maxx)
+            maxx = pd->x();
+        if (pd->y() < miny)
+            miny = pd->y();
+        else if (pd->y() > maxy)
+            maxy = pd->y();
+        ++pd;
+    }
+    return QRectF(minx,miny, maxx - minx, maxy - miny);
+}
+
+/*!
+    Creates and returns a QPolygon by converting each QPointF to a
+    QPoint.
+
+    \sa QPointF::toPoint()
+*/
+
+QPolygon QPolygonF::toPolygon() const
+{
+    QPolygon a;
+    a.reserve(size());
+    for (int i=0; i<size(); ++i)
+        a.append(at(i).toPoint());
+    return a;
+}
+
+/*!
+    \fn void QPolygon::swap(QPolygon &other)
+    \since 4.8
+
+    Swaps polygon \a other with this polygon. This operation is very
+    fast and never fails.
+*/
+
+/*!
+    \fn void QPolygonF::swap(QPolygonF &other)
+    \since 4.8
+
+    Swaps polygon \a other with this polygon. This operation is very
+    fast and never fails.
+*/
+
+/*!
+   Returns the polygon as a QVariant
+*/
+QPolygon::operator QVariant() const
+{
+    return QVariant(QVariant::Polygon, this);
+}
+
+/*****************************************************************************
+  QPolygon stream functions
+ *****************************************************************************/
+#ifndef QT_NO_DATASTREAM
+/*!
+    \fn QDataStream &operator<<(QDataStream &stream, const QPolygon &polygon)
+    \since 4.4
+    \relates QPolygon
+
+    Writes the given \a polygon to the given \a stream, and returns a
+    reference to the stream.
+
+    \sa {Serializing Qt Data Types}
+*/
+QDataStream &operator<<(QDataStream &s, const QPolygon &a)
+{
+    const QVector<QPoint> &v = a;
+    return s << v;
+}
+
+/*!
+    \fn QDataStream &operator>>(QDataStream &stream, QPolygon &polygon)
+    \since 4.4
+    \relates QPolygon
+
+    Reads a polygon from the given \a stream into the given \a
+    polygon, and returns a reference to the stream.
+
+    \sa {Serializing Qt Data Types}
+*/
+QDataStream &operator>>(QDataStream &s, QPolygon &a)
+{
+    QVector<QPoint> &v = a;
+    return s >> v;
+}
+#endif // QT_NO_DATASTREAM
+
+/*****************************************************************************
+  QPolygonF stream functions
+ *****************************************************************************/
+#ifndef QT_NO_DATASTREAM
+/*!
+    \fn QDataStream &operator<<(QDataStream &stream, const QPolygonF &polygon)
+    \relates QPolygonF
+
+    Writes the given \a polygon to the given \a stream, and returns a
+    reference to the stream.
+
+    \sa {Serializing Qt Data Types}
+*/
+
+QDataStream &operator<<(QDataStream &s, const QPolygonF &a)
+{
+    quint32 len = a.size();
+    uint i;
+
+    s << len;
+    for (i = 0; i < len; ++i)
+        s << a.at(i);
+    return s;
+}
+
+/*!
+    \fn QDataStream &operator>>(QDataStream &stream, QPolygonF &polygon)
+    \relates QPolygonF
+
+    Reads a polygon from the given \a stream into the given \a
+    polygon, and returns a reference to the stream.
+
+    \sa {Serializing Qt Data Types}
+*/
+
+QDataStream &operator>>(QDataStream &s, QPolygonF &a)
+{
+    quint32 len;
+    uint i;
+
+    s >> len;
+    a.reserve(a.size() + (int)len);
+    QPointF p;
+    for (i = 0; i < len; ++i) {
+        s >> p;
+        a.insert(i, p);
+    }
+    return s;
+}
+#endif //QT_NO_DATASTREAM
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug dbg, const QPolygonF &a)
+{
+#ifndef Q_BROKEN_DEBUG_STREAM
+    dbg.nospace() << "QPolygonF(";
+    for (int i = 0; i < a.count(); ++i)
+        dbg.nospace() << a.at(i);
+    dbg.nospace() << ')';
+    return dbg.space();
+#else
+    qWarning("This compiler doesn't support streaming QPolygonF to QDebug");
+    return dbg;
+    Q_UNUSED(a);
+#endif
+}
+#endif
+
+
+/*!
+    \since 4.3
+
+    \fn bool QPolygonF::containsPoint(const QPointF &point, Qt::FillRule fillRule) const
+
+    Returns true if the given \a point is inside the polygon according to
+    the specified \a fillRule; otherwise returns false.
+*/
+bool QPolygonF::containsPoint(const QPointF &pt, Qt::FillRule fillRule) const
+{
+    if (isEmpty())
+        return false;
+
+    int winding_number = 0;
+
+    QPointF last_pt = at(0);
+    QPointF last_start = at(0);
+    for (int i = 1; i < size(); ++i) {
+        const QPointF &e = at(i);
+        qt_polygon_isect_line(last_pt, e, pt, &winding_number);
+        last_pt = e;
+    }
+
+    // implicitly close last subpath
+    if (last_pt != last_start)
+        qt_polygon_isect_line(last_pt, last_start, pt, &winding_number);
+
+    return (fillRule == Qt::WindingFill
+            ? (winding_number != 0)
+            : ((winding_number % 2) != 0));
+}
+
+/*!
+    \since 4.3
+
+    \fn bool QPolygon::containsPoint(const QPoint &point, Qt::FillRule fillRule) const
+    Returns true if the given \a point is inside the polygon according to
+    the specified \a fillRule; otherwise returns false.
+*/
+bool QPolygon::containsPoint(const QPoint &pt, Qt::FillRule fillRule) const
+{
+    if (isEmpty())
+        return false;
+
+    int winding_number = 0;
+
+    QPoint last_pt = at(0);
+    QPoint last_start = at(0);
+    for (int i = 1; i < size(); ++i) {
+        const QPoint &e = at(i);
+        qt_polygon_isect_line(last_pt, e, pt, &winding_number);
+        last_pt = e;
+    }
+
+    // implicitly close last subpath
+    if (last_pt != last_start)
+        qt_polygon_isect_line(last_pt, last_start, pt, &winding_number);
+
+    return (fillRule == Qt::WindingFill
+            ? (winding_number != 0)
+            : ((winding_number % 2) != 0));
+}
+
+/*!
+    \since 4.3
+
+    Returns a polygon which is the union of this polygon and \a r.
+
+    Set operations on polygons, will treat the polygons as areas, and
+    implicitly close the polygon.
+
+    \sa intersected(), subtracted()
+*/
+
+QPolygon QPolygon::united(const QPolygon &r) const
+{
+    QPainterPath subject; subject.addPolygon(*this);
+    QPainterPath clip; clip.addPolygon(r);
+
+    return subject.united(clip).toFillPolygon().toPolygon();
+}
+
+/*!
+    \since 4.3
+
+    Returns a polygon which is the intersection of this polygon and \a r.
+
+    Set operations on polygons will treat the polygons as
+    areas. Non-closed polygons will be treated as implicitly closed.
+*/
+
+QPolygon QPolygon::intersected(const QPolygon &r) const
+{
+    QPainterPath subject; subject.addPolygon(*this);
+    QPainterPath clip; clip.addPolygon(r);
+
+    return subject.intersected(clip).toFillPolygon().toPolygon();
+}
+
+/*!
+    \since 4.3
+
+    Returns a polygon which is \a r subtracted from this polygon.
+
+    Set operations on polygons will treat the polygons as
+    areas. Non-closed polygons will be treated as implicitly closed.
+
+*/
+
+QPolygon QPolygon::subtracted(const QPolygon &r) const
+{
+    QPainterPath subject; subject.addPolygon(*this);
+    QPainterPath clip; clip.addPolygon(r);
+
+    return subject.subtracted(clip).toFillPolygon().toPolygon();
+}
+
+/*!
+    \since 4.3
+
+    Returns a polygon which is the union of this polygon and \a r.
+
+    Set operations on polygons will treat the polygons as
+    areas. Non-closed polygons will be treated as implicitly closed.
+
+    \sa intersected(), subtracted()
+*/
+
+QPolygonF QPolygonF::united(const QPolygonF &r) const
+{
+    QPainterPath subject; subject.addPolygon(*this);
+    QPainterPath clip; clip.addPolygon(r);
+
+    return subject.united(clip).toFillPolygon();
+}
+
+/*!
+    \since 4.3
+
+    Returns a polygon which is the intersection of this polygon and \a r.
+
+    Set operations on polygons will treat the polygons as
+    areas. Non-closed polygons will be treated as implicitly closed.
+
+*/
+
+QPolygonF QPolygonF::intersected(const QPolygonF &r) const
+{
+    QPainterPath subject; subject.addPolygon(*this);
+    QPainterPath clip; clip.addPolygon(r);
+
+    return subject.intersected(clip).toFillPolygon();
+}
+
+/*!
+    \since 4.3
+
+    Returns a polygon which is \a r subtracted from this polygon.
+
+    Set operations on polygons will treat the polygons as
+    areas. Non-closed polygons will be treated as implicitly closed.
+
+*/
+
+QPolygonF QPolygonF::subtracted(const QPolygonF &r) const
+{
+    QPainterPath subject; subject.addPolygon(*this);
+    QPainterPath clip; clip.addPolygon(r);
+    return subject.subtracted(clip).toFillPolygon();
+}
+
+QT_END_NAMESPACE