src/gui/painting/qpolygon.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
   4 ** Contact: http://www.qt-project.org/
   5 **
   6 ** This file is part of the QtGui module of the Qt Toolkit.
   7 **
   8 ** $QT_BEGIN_LICENSE:LGPL$
   9 ** GNU Lesser General Public License Usage
  10 ** This file may be used under the terms of the GNU Lesser General Public
  11 ** License version 2.1 as published by the Free Software Foundation and
  12 ** appearing in the file LICENSE.LGPL included in the packaging of this
  13 ** file. Please review the following information to ensure the GNU Lesser
  14 ** General Public License version 2.1 requirements will be met:
  15 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  16 **
  17 ** In addition, as a special exception, Nokia gives you certain additional
  18 ** rights. These rights are described in the Nokia Qt LGPL Exception
  19 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  20 **
  21 ** GNU General Public License Usage
  22 ** Alternatively, this file may be used under the terms of the GNU General
  23 ** Public License version 3.0 as published by the Free Software Foundation
  24 ** and appearing in the file LICENSE.GPL included in the packaging of this
  25 ** file. Please review the following information to ensure the GNU General
  26 ** Public License version 3.0 requirements will be met:
  27 ** http://www.gnu.org/copyleft/gpl.html.
  28 **
  29 ** Other Usage
  30 ** Alternatively, this file may be used in accordance with the terms and
  31 ** conditions contained in a signed written agreement between you and Nokia.
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include "qpolygon.h"
  43 #include "qrect.h"
  44 #include "qdatastream.h"
  45 #include "qmatrix.h"
  46 #include "qdebug.h"
  47 #include "qpainterpath.h"
  48 #include "qvariant.h"
  49 #include "qpainterpath_p.h"
  50 #include "qbezier_p.h"
  51
  52 #include <stdarg.h>
  53
  54 QT_BEGIN_NAMESPACE
  55
  56 //same as qt_painterpath_isect_line in qpainterpath.cpp
  57 static void qt_polygon_isect_line(const QPointF &p1, const QPointF &p2, const QPointF &pos,
  58                                   int *winding)
  59 {
  60     qreal x1 = p1.x();
  61     qreal y1 = p1.y();
  62     qreal x2 = p2.x();
  63     qreal y2 = p2.y();
  64     qreal y = pos.y();
  65
  66     int dir = 1;
  67
  68     if (qFuzzyCompare(y1, y2)) {
  69         // ignore horizontal lines according to scan conversion rule
  70         return;
  71     } else if (y2 < y1) {
  72         qreal x_tmp = x2; x2 = x1; x1 = x_tmp;
  73         qreal y_tmp = y2; y2 = y1; y1 = y_tmp;
  74         dir = -1;
  75     }
  76
  77     if (y >= y1 && y < y2) {
  78         qreal x = x1 + ((x2 - x1) / (y2 - y1)) * (y - y1);
  79
  80         // count up the winding number if we're
  81         if (x<=pos.x()) {
  82             (*winding) += dir;
  83         }
  84     }
  85 }
  86
  87 /*!
  88     \class QPolygon
  89     \brief The QPolygon class provides a vector of points using
  90     integer precision.
  91
  92     \reentrant
  93
  94     \ingroup painting
  95     \ingroup shared
  96
  97     A QPolygon object is a QVector<QPoint>.  The easiest way to add
  98     points to a QPolygon is to use QVector's streaming operator, as
  99     illustrated below:
 100
 101     \snippet polygon/polygon.cpp 0
 102
 103     In addition to the functions provided by QVector, QPolygon
 104     provides some point-specific functions.
 105
 106     Each point in a polygon can be retrieved by passing its index to
 107     the point() function. To populate the polygon, QPolygon provides
 108     the setPoint() function to set the point at a given index, the
 109     setPoints() function to set all the points in the polygon
 110     (resizing it to the given number of points), and the putPoints()
 111     function which copies a number of given points into the polygon
 112     from a specified index (resizing the polygon if necessary).
 113
 114     QPolygon provides the boundingRect() and translate() functions for
 115     geometry functions. Use the QMatrix::map() function for more
 116     general transformations of QPolygons.
 117
 118     The QPolygon class is \l {Implicit Data Sharing}{implicitly
 119     shared}.
 120
 121     \sa QVector, QPolygonF, QLine
 122 */
 123
 124
 125 /*****************************************************************************
 126   QPolygon member functions
 127  *****************************************************************************/
 128
 129 /*!
 130     \fn QPolygon::QPolygon()
 131
 132     Constructs a polygon with no points.
 133
 134     \sa QVector::isEmpty()
 135 */
 136
 137 /*!
 138     \fn QPolygon::QPolygon(int size)
 139
 140     Constructs a polygon of the given \a size. Creates an empty
 141     polygon if \a size == 0.
 142
 143     \sa QVector::isEmpty()
 144 */
 145
 146 /*!
 147     \fn QPolygon::QPolygon(const QPolygon &polygon)
 148
 149     Constructs a copy of the given \a polygon.
 150
 151     \sa setPoints()
 152 */
 153
 154 /*!
 155     \fn QPolygon::QPolygon(const QVector<QPoint> &points)
 156
 157     Constructs a polygon containing the specified \a points.
 158
 159     \sa setPoints()
 160 */
 161
 162 /*!
 163     \fn QPolygon::QPolygon(const QRect &rectangle, bool closed)
 164
 165     Constructs a polygon from the given \a rectangle.  If \a closed is
 166     false, the polygon just contains the four points of the rectangle
 167     ordered clockwise, otherwise the polygon's fifth point is set to
 168     \a {rectangle}.topLeft().
 169
 170     Note that the bottom-right corner of the rectangle is located at
 171     (rectangle.x() + rectangle.width(), rectangle.y() +
 172     rectangle.height()).
 173
 174     \sa setPoints()
 175 */
 176
 177 QPolygon::QPolygon(const QRect &r, bool closed)
 178 {
 179     reserve(closed ? 5 : 4);
 180     *this << QPoint(r.x(), r.y())
 181           << QPoint(r.x() + r.width(), r.y())
 182           << QPoint(r.x() + r.width(), r.y() + r.height())
 183           << QPoint(r.x(), r.y() + r.height());
 184     if (closed)
 185         *this << QPoint(r.left(), r.top());
 186 }
 187
 188 /*!
 189     \internal
 190     Constructs a point array with \a nPoints points, taken from the
 191     \a points array.
 192
 193     Equivalent to setPoints(nPoints, points).
 194 */
 195
 196 QPolygon::QPolygon(int nPoints, const int *points)
 197 {
 198     setPoints(nPoints, points);
 199 }
 200
 201
 202 /*!
 203     \fn QPolygon::~QPolygon()
 204
 205     Destroys the polygon.
 206 */
 207
 208
 209 /*!
 210     Translates all points in the polygon by (\a{dx}, \a{dy}).
 211
 212     \sa translated()
 213 */
 214
 215 void QPolygon::translate(int dx, int dy)
 216 {
 217     if (dx == 0 && dy == 0)
 218         return;
 219
 220     register QPoint *p = data();
 221     register int i = size();
 222     QPoint pt(dx, dy);
 223     while (i--) {
 224         *p += pt;
 225         ++p;
 226     }
 227 }
 228
 229 /*!
 230     \fn void QPolygon::translate(const QPoint &offset)
 231     \overload
 232
 233     Translates all points in the polygon by the given \a offset.
 234
 235     \sa translated()
 236 */
 237
 238 /*!
 239     Returns a copy of the polygon that is translated by (\a{dx}, \a{dy}).
 240
 241     \since 4.6
 242     \sa translate()
 243 */
 244 QPolygon QPolygon::translated(int dx, int dy) const
 245 {
 246     QPolygon copy(*this);
 247     copy.translate(dx, dy);
 248     return copy;
 249 }
 250
 251 /*!
 252     \fn void QPolygon::translated(const QPoint &offset) const
 253     \overload
 254     \since 4.6
 255
 256     Returns a copy of the polygon that is translated by the given \a offset.
 257
 258     \sa translate()
 259 */
 260
 261 /*!
 262     Extracts the coordinates of the point at the given \a index to
 263     *\a{x} and *\a{y} (if they are valid pointers).
 264
 265     \sa setPoint()
 266 */
 267
 268 void QPolygon::point(int index, int *x, int *y) const
 269 {
 270     QPoint p = at(index);
 271     if (x)
 272         *x = (int)p.x();
 273     if (y)
 274         *y = (int)p.y();
 275 }
 276
 277 /*!
 278     \fn QPoint QPolygon::point(int index) const
 279     \overload
 280
 281     Returns the point at the given \a index.
 282 */
 283
 284 /*!
 285     \fn void QPolygon::setPoint(int index, const QPoint &point)
 286     \overload
 287
 288     Sets the point at the given \a index to the given \a point.
 289 */
 290
 291 /*!
 292     \fn void QPolygon::setPoint(int index, int x, int y)
 293
 294     Sets the point at the given \a index to the point specified by
 295     (\a{x}, \a{y}).
 296
 297     \sa point(), putPoints(), setPoints(),
 298 */
 299
 300 /*!
 301     Resizes the polygon to \a nPoints and populates it with the given
 302     \a points.
 303
 304     The example code creates a polygon with two points (10, 20) and
 305     (30, 40):
 306
 307     \snippet polygon/polygon.cpp 2
 308
 309     \sa setPoint(), putPoints()
 310 */
 311
 312 void QPolygon::setPoints(int nPoints, const int *points)
 313 {
 314     resize(nPoints);
 315     int i = 0;
 316     while (nPoints--) {
 317         setPoint(i++, *points, *(points+1));
 318         points += 2;
 319     }
 320 }
 321
 322 /*!
 323     \overload
 324
 325     Resizes the polygon to \a nPoints and populates it with the points
 326     specified by the variable argument list.  The points are given as a
 327     sequence of integers, starting with \a firstx then \a firsty, and
 328     so on.
 329
 330     The example code creates a polygon with two points (10, 20) and
 331     (30, 40):
 332
 333     \snippet polygon/polygon.cpp 3
 334 */
 335
 336 void QPolygon::setPoints(int nPoints, int firstx, int firsty, ...)
 337 {
 338     va_list ap;
 339     resize(nPoints);
 340     setPoint(0, firstx, firsty);
 341     int i = 0, x, y;
 342     va_start(ap, firsty);
 343     while (--nPoints) {
 344         x = va_arg(ap, int);
 345         y = va_arg(ap, int);
 346         setPoint(++i, x, y);
 347     }
 348     va_end(ap);
 349 }
 350
 351 /*!
 352     \overload
 353     \internal
 354
 355     Copies \a nPoints points from the \a points coord array into this
 356     point array, and resizes the point array if \c{index+nPoints}
 357     exceeds the size of the array.
 358
 359     \sa setPoint()
 360 */
 361
 362 void QPolygon::putPoints(int index, int nPoints, const int *points)
 363 {
 364     if (index + nPoints > size())
 365         resize(index + nPoints);
 366     int i = index;
 367     while (nPoints--) {
 368         setPoint(i++, *points, *(points+1));
 369         points += 2;
 370     }
 371 }
 372
 373 /*!
 374     Copies \a nPoints points from the variable argument list into this
 375     polygon from the given \a index.
 376
 377     The points are given as a sequence of integers, starting with \a
 378     firstx then \a firsty, and so on. The polygon is resized if
 379     \c{index+nPoints} exceeds its current size.
 380
 381     The example code creates a polygon with three points (4,5), (6,7)
 382     and (8,9), by expanding the polygon from 1 to 3 points:
 383
 384     \snippet polygon/polygon.cpp 4
 385
 386     The following code has the same result, but here the putPoints()
 387     function overwrites rather than extends:
 388
 389     \snippet polygon/polygon.cpp 5
 390
 391     \sa setPoints()
 392 */
 393
 394 void QPolygon::putPoints(int index, int nPoints, int firstx, int firsty, ...)
 395 {
 396     va_list ap;
 397     if (index + nPoints > size())
 398         resize(index + nPoints);
 399     if (nPoints <= 0)
 400         return;
 401     setPoint(index, firstx, firsty);
 402     int i = index, x, y;
 403     va_start(ap, firsty);
 404     while (--nPoints) {
 405         x = va_arg(ap, int);
 406         y = va_arg(ap, int);
 407         setPoint(++i, x, y);
 408     }
 409     va_end(ap);
 410 }
 411
 412
 413 /*!
 414     \fn void QPolygon::putPoints(int index, int nPoints, const QPolygon &fromPolygon, int fromIndex)
 415     \overload
 416
 417     Copies \a nPoints points from the given \a fromIndex ( 0 by
 418     default) in \a fromPolygon into this polygon, starting at the
 419     specified \a index. For example:
 420
 421     \snippet polygon/polygon.cpp 6
 422 */
 423
 424 void QPolygon::putPoints(int index, int nPoints, const QPolygon & from, int fromIndex)
 425 {
 426     if (index + nPoints > size())
 427         resize(index + nPoints);
 428     if (nPoints <= 0)
 429         return;
 430     int n = 0;
 431     while(n < nPoints) {
 432         setPoint(index + n, from[fromIndex+n]);
 433         ++n;
 434     }
 435 }
 436
 437
 438 /*!
 439     Returns the bounding rectangle of the polygon, or QRect(0, 0, 0,
 440     0) if the polygon is empty.
 441
 442     \sa QVector::isEmpty()
 443 */
 444
 445 QRect QPolygon::boundingRect() const
 446 {
 447     if (isEmpty())
 448         return QRect(0, 0, 0, 0);
 449     register const QPoint *pd = constData();
 450     int minx, maxx, miny, maxy;
 451     minx = maxx = pd->x();
 452     miny = maxy = pd->y();
 453     ++pd;
 454     for (int i = 1; i < size(); ++i) {
 455         if (pd->x() < minx)
 456             minx = pd->x();
 457         else if (pd->x() > maxx)
 458             maxx = pd->x();
 459         if (pd->y() < miny)
 460             miny = pd->y();
 461         else if (pd->y() > maxy)
 462             maxy = pd->y();
 463         ++pd;
 464     }
 465     return QRect(QPoint(minx,miny), QPoint(maxx,maxy));
 466 }
 467
 468 #ifndef QT_NO_DEBUG_STREAM
 469 QDebug operator<<(QDebug dbg, const QPolygon &a)
 470 {
 471     dbg.nospace() << "QPolygon(";
 472     for (int i = 0; i < a.count(); ++i)
 473         dbg.nospace() << a.at(i);
 474     dbg.nospace() << ')';
 475     return dbg.space();
 476 }
 477 #endif
 478
 479
 480 /*!
 481     \class QPolygonF
 482     \brief The QPolygonF class provides a vector of points using
 483     floating point precision.
 484
 485     \reentrant
 486     \ingroup painting
 487     \ingroup shared
 488
 489     A QPolygonF is a QVector<QPointF>. The easiest way to add points
 490     to a QPolygonF is to use its streaming operator, as illustrated
 491     below:
 492
 493     \snippet polygon/polygon.cpp 1
 494
 495     In addition to the functions provided by QVector, QPolygonF
 496     provides the boundingRect() and translate() functions for geometry
 497     operations. Use the QMatrix::map() function for more general
 498     transformations of QPolygonFs.
 499
 500     QPolygonF also provides the isClosed() function to determine
 501     whether a polygon's start and end points are the same, and the
 502     toPolygon() function returning an integer precision copy of this
 503     polygon.
 504
 505     The QPolygonF class is \l {Implicit Data Sharing}{implicitly
 506     shared}.
 507
 508     \sa QVector, QPolygon, QLineF
 509 */
 510
 511
 512 /*****************************************************************************
 513   QPolygonF member functions
 514  *****************************************************************************/
 515
 516 /*!
 517     \fn QPolygonF::QPolygonF()
 518
 519     Constructs a polygon with no points.
 520
 521     \sa QVector::isEmpty()
 522 */
 523
 524 /*!
 525     \fn QPolygonF::QPolygonF(int size)
 526
 527     Constructs a polygon of the given \a size. Creates an empty
 528     polygon if \a size == 0.
 529
 530     \sa QVector::isEmpty()
 531 */
 532
 533 /*!
 534     \fn QPolygonF::QPolygonF(const QPolygonF &polygon)
 535
 536     Constructs a copy of the given \a polygon.
 537 */
 538
 539 /*!
 540     \fn QPolygonF::QPolygonF(const QVector<QPointF> &points)
 541
 542     Constructs a polygon containing the specified \a points.
 543 */
 544
 545 /*!
 546     \fn QPolygonF::QPolygonF(const QRectF &rectangle)
 547
 548     Constructs a closed polygon from the specified \a rectangle.
 549
 550     The polygon contains the four vertices of the rectangle in
 551     clockwise order starting and ending with the top-left vertex.
 552
 553     \sa isClosed()
 554 */
 555
 556 QPolygonF::QPolygonF(const QRectF &r)
 557 {
 558     reserve(5);
 559     append(QPointF(r.x(), r.y()));
 560     append(QPointF(r.x() + r.width(), r.y()));
 561     append(QPointF(r.x() + r.width(), r.y() + r.height()));
 562     append(QPointF(r.x(), r.y() + r.height()));
 563     append(QPointF(r.x(), r.y()));
 564 }
 565
 566 /*!
 567     \fn QPolygonF::QPolygonF(const QPolygon &polygon)
 568
 569     Constructs a float based polygon from the specified integer based
 570     \a polygon.
 571
 572     \sa toPolygon()
 573 */
 574
 575 QPolygonF::QPolygonF(const QPolygon &a)
 576 {
 577     reserve(a.size());
 578     for (int i=0; i<a.size(); ++i)
 579         append(a.at(i));
 580 }
 581
 582 /*!
 583     \fn QPolygonF::~QPolygonF()
 584
 585     Destroys the polygon.
 586 */
 587
 588
 589 /*!
 590     Translate all points in the polygon by the given \a offset.
 591
 592     \sa translated()
 593 */
 594
 595 void QPolygonF::translate(const QPointF &offset)
 596 {
 597     if (offset.isNull())
 598         return;
 599
 600     register QPointF *p = data();
 601     register int i = size();
 602     while (i--) {
 603         *p += offset;
 604         ++p;
 605     }
 606 }
 607
 608 /*!
 609     \fn void QPolygonF::translate(qreal dx, qreal dy)
 610     \overload
 611
 612     Translates all points in the polygon by (\a{dx}, \a{dy}).
 613
 614     \sa translated()
 615 */
 616
 617 /*!
 618     Returns a copy of the polygon that is translated by the given \a offset.
 619
 620     \since 4.6
 621     \sa translate()
 622 */
 623 QPolygonF QPolygonF::translated(const QPointF &offset) const
 624 {
 625     QPolygonF copy(*this);
 626     copy.translate(offset);
 627     return copy;
 628 }
 629
 630 /*!
 631     \fn void QPolygonF::translated(qreal dx, qreal dy) const
 632     \overload
 633     \since 4.6
 634
 635     Returns a copy of the polygon that is translated by (\a{dx}, \a{dy}).
 636
 637     \sa translate()
 638 */
 639
 640 /*!
 641     \fn bool QPolygonF::isClosed() const
 642
 643     Returns true if the polygon is closed; otherwise returns false.
 644
 645     A polygon is said to be closed if its start point and end point are equal.
 646
 647     \sa QVector::first(), QVector::last()
 648 */
 649
 650 /*!
 651     Returns the bounding rectangle of the polygon, or QRectF(0,0,0,0)
 652     if the polygon is empty.
 653
 654     \sa QVector::isEmpty()
 655 */
 656
 657 QRectF QPolygonF::boundingRect() const
 658 {
 659     if (isEmpty())
 660         return QRectF(0, 0, 0, 0);
 661     register const QPointF *pd = constData();
 662     qreal minx, maxx, miny, maxy;
 663     minx = maxx = pd->x();
 664     miny = maxy = pd->y();
 665     ++pd;
 666     for (int i = 1; i < size(); ++i) {
 667         if (pd->x() < minx)
 668             minx = pd->x();
 669         else if (pd->x() > maxx)
 670             maxx = pd->x();
 671         if (pd->y() < miny)
 672             miny = pd->y();
 673         else if (pd->y() > maxy)
 674             maxy = pd->y();
 675         ++pd;
 676     }
 677     return QRectF(minx,miny, maxx - minx, maxy - miny);
 678 }
 679
 680 /*!
 681     Creates and returns a QPolygon by converting each QPointF to a
 682     QPoint.
 683
 684     \sa QPointF::toPoint()
 685 */
 686
 687 QPolygon QPolygonF::toPolygon() const
 688 {
 689     QPolygon a;
 690     a.reserve(size());
 691     for (int i=0; i<size(); ++i)
 692         a.append(at(i).toPoint());
 693     return a;
 694 }
 695
 696 /*!
 697     \fn void QPolygon::swap(QPolygon &other)
 698     \since 4.8
 699
 700     Swaps polygon \a other with this polygon. This operation is very
 701     fast and never fails.
 702 */
 703
 704 /*!
 705     \fn void QPolygonF::swap(QPolygonF &other)
 706     \since 4.8
 707
 708     Swaps polygon \a other with this polygon. This operation is very
 709     fast and never fails.
 710 */
 711
 712 /*!
 713    Returns the polygon as a QVariant
 714 */
 715 QPolygon::operator QVariant() const
 716 {
 717     return QVariant(QVariant::Polygon, this);
 718 }
 719
 720 /*****************************************************************************
 721   QPolygon stream functions
 722  *****************************************************************************/
 723 #ifndef QT_NO_DATASTREAM
 724 /*!
 725     \fn QDataStream &operator<<(QDataStream &stream, const QPolygon &polygon)
 726     \since 4.4
 727     \relates QPolygon
 728
 729     Writes the given \a polygon to the given \a stream, and returns a
 730     reference to the stream.
 731
 732     \sa {Serializing Qt Data Types}
 733 */
 734 QDataStream &operator<<(QDataStream &s, const QPolygon &a)
 735 {
 736     const QVector<QPoint> &v = a;
 737     return s << v;
 738 }
 739
 740 /*!
 741     \fn QDataStream &operator>>(QDataStream &stream, QPolygon &polygon)
 742     \since 4.4
 743     \relates QPolygon
 744
 745     Reads a polygon from the given \a stream into the given \a
 746     polygon, and returns a reference to the stream.
 747
 748     \sa {Serializing Qt Data Types}
 749 */
 750 QDataStream &operator>>(QDataStream &s, QPolygon &a)
 751 {
 752     QVector<QPoint> &v = a;
 753     return s >> v;
 754 }
 755 #endif // QT_NO_DATASTREAM
 756
 757 /*****************************************************************************
 758   QPolygonF stream functions
 759  *****************************************************************************/
 760 #ifndef QT_NO_DATASTREAM
 761 /*!
 762     \fn QDataStream &operator<<(QDataStream &stream, const QPolygonF &polygon)
 763     \relates QPolygonF
 764
 765     Writes the given \a polygon to the given \a stream, and returns a
 766     reference to the stream.
 767
 768     \sa {Serializing Qt Data Types}
 769 */
 770
 771 QDataStream &operator<<(QDataStream &s, const QPolygonF &a)
 772 {
 773     quint32 len = a.size();
 774     uint i;
 775
 776     s << len;
 777     for (i = 0; i < len; ++i)
 778         s << a.at(i);
 779     return s;
 780 }
 781
 782 /*!
 783     \fn QDataStream &operator>>(QDataStream &stream, QPolygonF &polygon)
 784     \relates QPolygonF
 785
 786     Reads a polygon from the given \a stream into the given \a
 787     polygon, and returns a reference to the stream.
 788
 789     \sa {Serializing Qt Data Types}
 790 */
 791
 792 QDataStream &operator>>(QDataStream &s, QPolygonF &a)
 793 {
 794     quint32 len;
 795     uint i;
 796
 797     s >> len;
 798     a.reserve(a.size() + (int)len);
 799     QPointF p;
 800     for (i = 0; i < len; ++i) {
 801         s >> p;
 802         a.insert(i, p);
 803     }
 804     return s;
 805 }
 806 #endif //QT_NO_DATASTREAM
 807
 808 #ifndef QT_NO_DEBUG_STREAM
 809 QDebug operator<<(QDebug dbg, const QPolygonF &a)
 810 {
 811     dbg.nospace() << "QPolygonF(";
 812     for (int i = 0; i < a.count(); ++i)
 813         dbg.nospace() << a.at(i);
 814     dbg.nospace() << ')';
 815     return dbg.space();
 816 }
 817 #endif
 818
 819
 820 /*!
 821     \since 4.3
 822
 823     \fn bool QPolygonF::containsPoint(const QPointF &point, Qt::FillRule fillRule) const
 824
 825     Returns true if the given \a point is inside the polygon according to
 826     the specified \a fillRule; otherwise returns false.
 827 */
 828 bool QPolygonF::containsPoint(const QPointF &pt, Qt::FillRule fillRule) const
 829 {
 830     if (isEmpty())
 831         return false;
 832
 833     int winding_number = 0;
 834
 835     QPointF last_pt = at(0);
 836     QPointF last_start = at(0);
 837     for (int i = 1; i < size(); ++i) {
 838         const QPointF &e = at(i);
 839         qt_polygon_isect_line(last_pt, e, pt, &winding_number);
 840         last_pt = e;
 841     }
 842
 843     // implicitly close last subpath
 844     if (last_pt != last_start)
 845         qt_polygon_isect_line(last_pt, last_start, pt, &winding_number);
 846
 847     return (fillRule == Qt::WindingFill
 848             ? (winding_number != 0)
 849             : ((winding_number % 2) != 0));
 850 }
 851
 852 /*!
 853     \since 4.3
 854
 855     \fn bool QPolygon::containsPoint(const QPoint &point, Qt::FillRule fillRule) const
 856     Returns true if the given \a point is inside the polygon according to
 857     the specified \a fillRule; otherwise returns false.
 858 */
 859 bool QPolygon::containsPoint(const QPoint &pt, Qt::FillRule fillRule) const
 860 {
 861     if (isEmpty())
 862         return false;
 863
 864     int winding_number = 0;
 865
 866     QPoint last_pt = at(0);
 867     QPoint last_start = at(0);
 868     for (int i = 1; i < size(); ++i) {
 869         const QPoint &e = at(i);
 870         qt_polygon_isect_line(last_pt, e, pt, &winding_number);
 871         last_pt = e;
 872     }
 873
 874     // implicitly close last subpath
 875     if (last_pt != last_start)
 876         qt_polygon_isect_line(last_pt, last_start, pt, &winding_number);
 877
 878     return (fillRule == Qt::WindingFill
 879             ? (winding_number != 0)
 880             : ((winding_number % 2) != 0));
 881 }
 882
 883 /*!
 884     \since 4.3
 885
 886     Returns a polygon which is the union of this polygon and \a r.
 887
 888     Set operations on polygons, will treat the polygons as areas, and
 889     implicitly close the polygon.
 890
 891     \sa intersected(), subtracted()
 892 */
 893
 894 QPolygon QPolygon::united(const QPolygon &r) const
 895 {
 896     QPainterPath subject; subject.addPolygon(*this);
 897     QPainterPath clip; clip.addPolygon(r);
 898
 899     return subject.united(clip).toFillPolygon().toPolygon();
 900 }
 901
 902 /*!
 903     \since 4.3
 904
 905     Returns a polygon which is the intersection of this polygon and \a r.
 906
 907     Set operations on polygons will treat the polygons as
 908     areas. Non-closed polygons will be treated as implicitly closed.
 909 */
 910
 911 QPolygon QPolygon::intersected(const QPolygon &r) const
 912 {
 913     QPainterPath subject; subject.addPolygon(*this);
 914     QPainterPath clip; clip.addPolygon(r);
 915
 916     return subject.intersected(clip).toFillPolygon().toPolygon();
 917 }
 918
 919 /*!
 920     \since 4.3
 921
 922     Returns a polygon which is \a r subtracted from this polygon.
 923
 924     Set operations on polygons will treat the polygons as
 925     areas. Non-closed polygons will be treated as implicitly closed.
 926
 927 */
 928
 929 QPolygon QPolygon::subtracted(const QPolygon &r) const
 930 {
 931     QPainterPath subject; subject.addPolygon(*this);
 932     QPainterPath clip; clip.addPolygon(r);
 933
 934     return subject.subtracted(clip).toFillPolygon().toPolygon();
 935 }
 936
 937 /*!
 938     \since 4.3
 939
 940     Returns a polygon which is the union of this polygon and \a r.
 941
 942     Set operations on polygons will treat the polygons as
 943     areas. Non-closed polygons will be treated as implicitly closed.
 944
 945     \sa intersected(), subtracted()
 946 */
 947
 948 QPolygonF QPolygonF::united(const QPolygonF &r) const
 949 {
 950     QPainterPath subject; subject.addPolygon(*this);
 951     QPainterPath clip; clip.addPolygon(r);
 952
 953     return subject.united(clip).toFillPolygon();
 954 }
 955
 956 /*!
 957     \since 4.3
 958
 959     Returns a polygon which is the intersection of this polygon and \a r.
 960
 961     Set operations on polygons will treat the polygons as
 962     areas. Non-closed polygons will be treated as implicitly closed.
 963
 964 */
 965
 966 QPolygonF QPolygonF::intersected(const QPolygonF &r) const
 967 {
 968     QPainterPath subject; subject.addPolygon(*this);
 969     QPainterPath clip; clip.addPolygon(r);
 970
 971     return subject.intersected(clip).toFillPolygon();
 972 }
 973
 974 /*!
 975     \since 4.3
 976
 977     Returns a polygon which is \a r subtracted from this polygon.
 978
 979     Set operations on polygons will treat the polygons as
 980     areas. Non-closed polygons will be treated as implicitly closed.
 981
 982 */
 983
 984 QPolygonF QPolygonF::subtracted(const QPolygonF &r) const
 985 {
 986     QPainterPath subject; subject.addPolygon(*this);
 987     QPainterPath clip; clip.addPolygon(r);
 988     return subject.subtracted(clip).toFillPolygon();
 989 }
 990
 991 QT_END_NAMESPACE