1/****************************************************************************
2**
3** Copyright (C) 2016 The Qt Company Ltd.
4** Contact: https://www.qt.io/licensing/
5**
6** This file is part of the QtGui module of the Qt Toolkit.
7**
8** $QT_BEGIN_LICENSE:LGPL$
9** Commercial License Usage
10** Licensees holding valid commercial Qt licenses may use this file in
11** accordance with the commercial license agreement provided with the
12** Software or, alternatively, in accordance with the terms contained in
13** a written agreement between you and The Qt Company. For licensing terms
14** and conditions see https://www.qt.io/terms-conditions. For further
15** information use the contact form at https://www.qt.io/contact-us.
16**
17** GNU Lesser General Public License Usage
18** Alternatively, this file may be used under the terms of the GNU Lesser
19** General Public License version 3 as published by the Free Software
20** Foundation and appearing in the file LICENSE.LGPL3 included in the
21** packaging of this file. Please review the following information to
22** ensure the GNU Lesser General Public License version 3 requirements
23** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
24**
25** GNU General Public License Usage
26** Alternatively, this file may be used under the terms of the GNU
27** General Public License version 2.0 or (at your option) the GNU General
28** Public license version 3 or any later version approved by the KDE Free
29** Qt Foundation. The licenses are as published by the Free Software
30** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
31** included in the packaging of this file. Please review the following
32** information to ensure the GNU General Public License requirements will
33** be met: https://www.gnu.org/licenses/gpl-2.0.html and
34** https://www.gnu.org/licenses/gpl-3.0.html.
35**
36** $QT_END_LICENSE$
37**
38****************************************************************************/
39
40#include "qpainterpath.h"
41#include "qpainterpath_p.h"
42
43#include <qbitmap.h>
44#include <qdebug.h>
45#include <qiodevice.h>
46#include <qlist.h>
47#include <qmatrix.h>
48#include <qpen.h>
49#include <qpolygon.h>
50#include <qtextlayout.h>
51#include <qvarlengtharray.h>
52#include <qmath.h>
53
54#include <private/qbezier_p.h>
55#include <private/qfontengine_p.h>
56#include <private/qnumeric_p.h>
57#include <private/qobject_p.h>
58#include <private/qpathclipper_p.h>
59#include <private/qstroker_p.h>
60#include <private/qtextengine_p.h>
61
62#include <limits.h>
63
64#if 0
65#include <performance.h>
66#else
67#define PM_INIT
68#define PM_MEASURE(x)
69#define PM_DISPLAY
70#endif
71
72QT_BEGIN_NAMESPACE
73
74static inline bool isValidCoord(qreal c)
75{
76 if (sizeof(qreal) >= sizeof(double))
77 return qIsFinite(d: c) && fabs(x: c) < 1e128;
78 else
79 return qIsFinite(d: c) && fabsf(x: float(c)) < 1e16f;
80}
81
82static bool hasValidCoords(QPointF p)
83{
84 return isValidCoord(c: p.x()) && isValidCoord(c: p.y());
85}
86
87static bool hasValidCoords(QRectF r)
88{
89 return isValidCoord(c: r.x()) && isValidCoord(c: r.y()) && isValidCoord(c: r.width()) && isValidCoord(c: r.height());
90}
91
92struct QPainterPathPrivateDeleter
93{
94 static inline void cleanup(QPainterPathPrivate *d)
95 {
96 // note - we must downcast to QPainterPathData since QPainterPathPrivate
97 // has a non-virtual destructor!
98 if (d && !d->ref.deref())
99 delete static_cast<QPainterPathData *>(d);
100 }
101};
102
103// This value is used to determine the length of control point vectors
104// when approximating arc segments as curves. The factor is multiplied
105// with the radius of the circle.
106
107// #define QPP_DEBUG
108// #define QPP_STROKE_DEBUG
109//#define QPP_FILLPOLYGONS_DEBUG
110
111QPainterPath qt_stroke_dash(const QPainterPath &path, qreal *dashes, int dashCount);
112
113void qt_find_ellipse_coords(const QRectF &r, qreal angle, qreal length,
114 QPointF* startPoint, QPointF *endPoint)
115{
116 if (r.isNull()) {
117 if (startPoint)
118 *startPoint = QPointF();
119 if (endPoint)
120 *endPoint = QPointF();
121 return;
122 }
123
124 qreal w2 = r.width() / 2;
125 qreal h2 = r.height() / 2;
126
127 qreal angles[2] = { angle, angle + length };
128 QPointF *points[2] = { startPoint, endPoint };
129
130 for (int i = 0; i < 2; ++i) {
131 if (!points[i])
132 continue;
133
134 qreal theta = angles[i] - 360 * qFloor(v: angles[i] / 360);
135 qreal t = theta / 90;
136 // truncate
137 int quadrant = int(t);
138 t -= quadrant;
139
140 t = qt_t_for_arc_angle(angle: 90 * t);
141
142 // swap x and y?
143 if (quadrant & 1)
144 t = 1 - t;
145
146 qreal a, b, c, d;
147 QBezier::coefficients(t, a, b, c, d);
148 QPointF p(a + b + c*QT_PATH_KAPPA, d + c + b*QT_PATH_KAPPA);
149
150 // left quadrants
151 if (quadrant == 1 || quadrant == 2)
152 p.rx() = -p.x();
153
154 // top quadrants
155 if (quadrant == 0 || quadrant == 1)
156 p.ry() = -p.y();
157
158 *points[i] = r.center() + QPointF(w2 * p.x(), h2 * p.y());
159 }
160}
161
162#ifdef QPP_DEBUG
163static void qt_debug_path(const QPainterPath &path)
164{
165 const char *names[] = {
166 "MoveTo ",
167 "LineTo ",
168 "CurveTo ",
169 "CurveToData"
170 };
171
172 printf("\nQPainterPath: elementCount=%d\n", path.elementCount());
173 for (int i=0; i<path.elementCount(); ++i) {
174 const QPainterPath::Element &e = path.elementAt(i);
175 Q_ASSERT(e.type >= 0 && e.type <= QPainterPath::CurveToDataElement);
176 printf(" - %3d:: %s, (%.2f, %.2f)\n", i, names[e.type], e.x, e.y);
177 }
178}
179#endif
180
181/*!
182 \class QPainterPath
183 \ingroup painting
184 \ingroup shared
185 \inmodule QtGui
186
187 \brief The QPainterPath class provides a container for painting operations,
188 enabling graphical shapes to be constructed and reused.
189
190 A painter path is an object composed of a number of graphical
191 building blocks, such as rectangles, ellipses, lines, and curves.
192 Building blocks can be joined in closed subpaths, for example as a
193 rectangle or an ellipse. A closed path has coinciding start and
194 end points. Or they can exist independently as unclosed subpaths,
195 such as lines and curves.
196
197 A QPainterPath object can be used for filling, outlining, and
198 clipping. To generate fillable outlines for a given painter path,
199 use the QPainterPathStroker class. The main advantage of painter
200 paths over normal drawing operations is that complex shapes only
201 need to be created once; then they can be drawn many times using
202 only calls to the QPainter::drawPath() function.
203
204 QPainterPath provides a collection of functions that can be used
205 to obtain information about the path and its elements. In addition
206 it is possible to reverse the order of the elements using the
207 toReversed() function. There are also several functions to convert
208 this painter path object into a polygon representation.
209
210 \tableofcontents
211
212 \section1 Composing a QPainterPath
213
214 A QPainterPath object can be constructed as an empty path, with a
215 given start point, or as a copy of another QPainterPath object.
216 Once created, lines and curves can be added to the path using the
217 lineTo(), arcTo(), cubicTo() and quadTo() functions. The lines and
218 curves stretch from the currentPosition() to the position passed
219 as argument.
220
221 The currentPosition() of the QPainterPath object is always the end
222 position of the last subpath that was added (or the initial start
223 point). Use the moveTo() function to move the currentPosition()
224 without adding a component. The moveTo() function implicitly
225 starts a new subpath, and closes the previous one. Another way of
226 starting a new subpath is to call the closeSubpath() function
227 which closes the current path by adding a line from the
228 currentPosition() back to the path's start position. Note that the
229 new path will have (0, 0) as its initial currentPosition().
230
231 QPainterPath class also provides several convenience functions to
232 add closed subpaths to a painter path: addEllipse(), addPath(),
233 addRect(), addRegion() and addText(). The addPolygon() function
234 adds an \e unclosed subpath. In fact, these functions are all
235 collections of moveTo(), lineTo() and cubicTo() operations.
236
237 In addition, a path can be added to the current path using the
238 connectPath() function. But note that this function will connect
239 the last element of the current path to the first element of given
240 one by adding a line.
241
242 Below is a code snippet that shows how a QPainterPath object can
243 be used:
244
245 \table 70%
246 \row
247 \li \inlineimage qpainterpath-construction.png
248 \li
249 \snippet code/src_gui_painting_qpainterpath.cpp 0
250 \endtable
251
252 The painter path is initially empty when constructed. We first add
253 a rectangle, which is a closed subpath. Then we add two bezier
254 curves which together form a closed subpath even though they are
255 not closed individually. Finally we draw the entire path. The path
256 is filled using the default fill rule, Qt::OddEvenFill. Qt
257 provides two methods for filling paths:
258
259 \table
260 \header
261 \li Qt::OddEvenFill
262 \li Qt::WindingFill
263 \row
264 \li \inlineimage qt-fillrule-oddeven.png
265 \li \inlineimage qt-fillrule-winding.png
266 \endtable
267
268 See the Qt::FillRule documentation for the definition of the
269 rules. A painter path's currently set fill rule can be retrieved
270 using the fillRule() function, and altered using the setFillRule()
271 function.
272
273 \section1 QPainterPath Information
274
275 The QPainterPath class provides a collection of functions that
276 returns information about the path and its elements.
277
278 The currentPosition() function returns the end point of the last
279 subpath that was added (or the initial start point). The
280 elementAt() function can be used to retrieve the various subpath
281 elements, the \e number of elements can be retrieved using the
282 elementCount() function, and the isEmpty() function tells whether
283 this QPainterPath object contains any elements at all.
284
285 The controlPointRect() function returns the rectangle containing
286 all the points and control points in this path. This function is
287 significantly faster to compute than the exact boundingRect()
288 which returns the bounding rectangle of this painter path with
289 floating point precision.
290
291 Finally, QPainterPath provides the contains() function which can
292 be used to determine whether a given point or rectangle is inside
293 the path, and the intersects() function which determines if any of
294 the points inside a given rectangle also are inside this path.
295
296 \section1 QPainterPath Conversion
297
298 For compatibility reasons, it might be required to simplify the
299 representation of a painter path: QPainterPath provides the
300 toFillPolygon(), toFillPolygons() and toSubpathPolygons()
301 functions which convert the painter path into a polygon. The
302 toFillPolygon() returns the painter path as one single polygon,
303 while the two latter functions return a list of polygons.
304
305 The toFillPolygons() and toSubpathPolygons() functions are
306 provided because it is usually faster to draw several small
307 polygons than to draw one large polygon, even though the total
308 number of points drawn is the same. The difference between the two
309 is the \e number of polygons they return: The toSubpathPolygons()
310 creates one polygon for each subpath regardless of intersecting
311 subpaths (i.e. overlapping bounding rectangles), while the
312 toFillPolygons() functions creates only one polygon for
313 overlapping subpaths.
314
315 The toFillPolygon() and toFillPolygons() functions first convert
316 all the subpaths to polygons, then uses a rewinding technique to
317 make sure that overlapping subpaths can be filled using the
318 correct fill rule. Note that rewinding inserts additional lines in
319 the polygon so the outline of the fill polygon does not match the
320 outline of the path.
321
322 \section1 Examples
323
324 Qt provides the \l {painting/painterpaths}{Painter Paths Example}
325 and the \l {painting/deform}{Vector Deformation example} which are
326 located in Qt's example directory.
327
328 The \l {painting/painterpaths}{Painter Paths Example} shows how
329 painter paths can be used to build complex shapes for rendering
330 and lets the user experiment with the filling and stroking. The
331 \l {painting/deform}{Vector Deformation Example} shows how to use
332 QPainterPath to draw text.
333
334 \table
335 \header
336 \li \l {painting/painterpaths}{Painter Paths Example}
337 \li \l {painting/deform}{Vector Deformation Example}
338 \row
339 \li \inlineimage qpainterpath-example.png
340 \li \inlineimage qpainterpath-demo.png
341 \endtable
342
343 \sa QPainterPathStroker, QPainter, QRegion, {Painter Paths Example}
344*/
345
346/*!
347 \enum QPainterPath::ElementType
348
349 This enum describes the types of elements used to connect vertices
350 in subpaths.
351
352 Note that elements added as closed subpaths using the
353 addEllipse(), addPath(), addPolygon(), addRect(), addRegion() and
354 addText() convenience functions, is actually added to the path as
355 a collection of separate elements using the moveTo(), lineTo() and
356 cubicTo() functions.
357
358 \value MoveToElement A new subpath. See also moveTo().
359 \value LineToElement A line. See also lineTo().
360 \value CurveToElement A curve. See also cubicTo() and quadTo().
361 \value CurveToDataElement The extra data required to describe a curve in
362 a CurveToElement element.
363
364 \sa elementAt(), elementCount()
365*/
366
367/*!
368 \class QPainterPath::Element
369 \inmodule QtGui
370
371 \brief The QPainterPath::Element class specifies the position and
372 type of a subpath.
373
374 Once a QPainterPath object is constructed, subpaths like lines and
375 curves can be added to the path (creating
376 QPainterPath::LineToElement and QPainterPath::CurveToElement
377 components).
378
379 The lines and curves stretch from the currentPosition() to the
380 position passed as argument. The currentPosition() of the
381 QPainterPath object is always the end position of the last subpath
382 that was added (or the initial start point). The moveTo() function
383 can be used to move the currentPosition() without adding a line or
384 curve, creating a QPainterPath::MoveToElement component.
385
386 \sa QPainterPath
387*/
388
389/*!
390 \variable QPainterPath::Element::x
391 \brief the x coordinate of the element's position.
392
393 \sa {operator QPointF()}
394*/
395
396/*!
397 \variable QPainterPath::Element::y
398 \brief the y coordinate of the element's position.
399
400 \sa {operator QPointF()}
401*/
402
403/*!
404 \variable QPainterPath::Element::type
405 \brief the type of element
406
407 \sa isCurveTo(), isLineTo(), isMoveTo()
408*/
409
410/*!
411 \fn bool QPainterPath::Element::operator==(const Element &other) const
412 \since 4.2
413
414 Returns \c true if this element is equal to \a other;
415 otherwise returns \c false.
416
417 \sa operator!=()
418*/
419
420/*!
421 \fn bool QPainterPath::Element::operator!=(const Element &other) const
422 \since 4.2
423
424 Returns \c true if this element is not equal to \a other;
425 otherwise returns \c false.
426
427 \sa operator==()
428*/
429
430/*!
431 \fn bool QPainterPath::Element::isCurveTo () const
432
433 Returns \c true if the element is a curve, otherwise returns \c false.
434
435 \sa type, QPainterPath::CurveToElement
436*/
437
438/*!
439 \fn bool QPainterPath::Element::isLineTo () const
440
441 Returns \c true if the element is a line, otherwise returns \c false.
442
443 \sa type, QPainterPath::LineToElement
444*/
445
446/*!
447 \fn bool QPainterPath::Element::isMoveTo () const
448
449 Returns \c true if the element is moving the current position,
450 otherwise returns \c false.
451
452 \sa type, QPainterPath::MoveToElement
453*/
454
455/*!
456 \fn QPainterPath::Element::operator QPointF () const
457
458 Returns the element's position.
459
460 \sa x, y
461*/
462
463/*!
464 \fn void QPainterPath::addEllipse(qreal x, qreal y, qreal width, qreal height)
465 \overload
466
467 Creates an ellipse within the bounding rectangle defined by its top-left
468 corner at (\a x, \a y), \a width and \a height, and adds it to the
469 painter path as a closed subpath.
470*/
471
472/*!
473 \since 4.4
474
475 \fn void QPainterPath::addEllipse(const QPointF &center, qreal rx, qreal ry)
476 \overload
477
478 Creates an ellipse positioned at \a{center} with radii \a{rx} and \a{ry},
479 and adds it to the painter path as a closed subpath.
480*/
481
482/*!
483 \fn void QPainterPath::addText(qreal x, qreal y, const QFont &font, const QString &text)
484 \overload
485
486 Adds the given \a text to this path as a set of closed subpaths created
487 from the \a font supplied. The subpaths are positioned so that the left
488 end of the text's baseline lies at the point specified by (\a x, \a y).
489*/
490
491/*!
492 \fn int QPainterPath::elementCount() const
493
494 Returns the number of path elements in the painter path.
495
496 \sa ElementType, elementAt(), isEmpty()
497*/
498
499int QPainterPath::elementCount() const
500{
501 return d_ptr ? d_ptr->elements.size() : 0;
502}
503
504/*!
505 \fn QPainterPath::Element QPainterPath::elementAt(int index) const
506
507 Returns the element at the given \a index in the painter path.
508
509 \sa ElementType, elementCount(), isEmpty()
510*/
511
512QPainterPath::Element QPainterPath::elementAt(int i) const
513{
514 Q_ASSERT(d_ptr);
515 Q_ASSERT(i >= 0 && i < elementCount());
516 return d_ptr->elements.at(i);
517}
518
519/*!
520 \fn void QPainterPath::setElementPositionAt(int index, qreal x, qreal y)
521 \since 4.2
522
523 Sets the x and y coordinate of the element at index \a index to \a
524 x and \a y.
525*/
526
527void QPainterPath::setElementPositionAt(int i, qreal x, qreal y)
528{
529 Q_ASSERT(d_ptr);
530 Q_ASSERT(i >= 0 && i < elementCount());
531 detach();
532 QPainterPath::Element &e = d_ptr->elements[i];
533 e.x = x;
534 e.y = y;
535}
536
537
538/*###
539 \fn QPainterPath &QPainterPath::operator +=(const QPainterPath &other)
540
541 Appends the \a other painter path to this painter path and returns a
542 reference to the result.
543*/
544
545/*!
546 Constructs an empty QPainterPath object.
547*/
548QPainterPath::QPainterPath() noexcept
549 : d_ptr(nullptr)
550{
551}
552
553/*!
554 \fn QPainterPath::QPainterPath(const QPainterPath &path)
555
556 Creates a QPainterPath object that is a copy of the given \a path.
557
558 \sa operator=()
559*/
560QPainterPath::QPainterPath(const QPainterPath &other)
561 : d_ptr(other.d_ptr.data())
562{
563 if (d_ptr)
564 d_ptr->ref.ref();
565}
566
567/*!
568 Creates a QPainterPath object with the given \a startPoint as its
569 current position.
570*/
571
572QPainterPath::QPainterPath(const QPointF &startPoint)
573 : d_ptr(new QPainterPathData)
574{
575 Element e = { .x: startPoint.x(), .y: startPoint.y(), .type: MoveToElement };
576 d_func()->elements << e;
577}
578
579void QPainterPath::detach()
580{
581 if (d_ptr->ref.loadRelaxed() != 1)
582 detach_helper();
583 setDirty(true);
584}
585
586/*!
587 \internal
588*/
589void QPainterPath::detach_helper()
590{
591 QPainterPathPrivate *data = new QPainterPathData(*d_func());
592 d_ptr.reset(other: data);
593}
594
595/*!
596 \internal
597*/
598void QPainterPath::ensureData_helper()
599{
600 QPainterPathPrivate *data = new QPainterPathData;
601 data->elements.reserve(asize: 16);
602 QPainterPath::Element e = { .x: 0, .y: 0, .type: QPainterPath::MoveToElement };
603 data->elements << e;
604 d_ptr.reset(other: data);
605 Q_ASSERT(d_ptr != nullptr);
606}
607
608/*!
609 \fn QPainterPath &QPainterPath::operator=(const QPainterPath &path)
610
611 Assigns the given \a path to this painter path.
612
613 \sa QPainterPath()
614*/
615QPainterPath &QPainterPath::operator=(const QPainterPath &other)
616{
617 if (other.d_func() != d_func()) {
618 QPainterPathPrivate *data = other.d_func();
619 if (data)
620 data->ref.ref();
621 d_ptr.reset(other: data);
622 }
623 return *this;
624}
625
626/*!
627 \fn QPainterPath &QPainterPath::operator=(QPainterPath &&other)
628
629 Move-assigns \a other to this QPainterPath instance.
630
631 \since 5.2
632*/
633
634/*!
635 \fn void QPainterPath::swap(QPainterPath &other)
636 \since 4.8
637
638 Swaps painter path \a other with this painter path. This operation is very
639 fast and never fails.
640*/
641
642/*!
643 Destroys this QPainterPath object.
644*/
645QPainterPath::~QPainterPath()
646{
647}
648
649/*!
650 Clears the path elements stored.
651
652 This allows the path to reuse previous memory allocations.
653
654 \sa reserve(), capacity()
655 \since 5.13
656*/
657void QPainterPath::clear()
658{
659 if (!d_ptr)
660 return;
661
662 detach();
663 d_func()->clear();
664 d_func()->elements.append( t: {.x: 0, .y: 0, .type: MoveToElement} );
665}
666
667/*!
668 Reserves a given amount of elements in QPainterPath's internal memory.
669
670 Attempts to allocate memory for at least \a size elements.
671
672 \sa clear(), capacity(), QVector::reserve()
673 \since 5.13
674*/
675void QPainterPath::reserve(int size)
676{
677 Q_D(QPainterPath);
678 if ((!d && size > 0) || (d && d->elements.capacity() < size)) {
679 ensureData();
680 detach();
681 d_func()->elements.reserve(asize: size);
682 }
683}
684
685/*!
686 Returns the number of elements allocated by the QPainterPath.
687
688 \sa clear(), reserve()
689 \since 5.13
690*/
691int QPainterPath::capacity() const
692{
693 Q_D(QPainterPath);
694 if (d)
695 return d->elements.capacity();
696
697 return 0;
698}
699
700/*!
701 Closes the current subpath by drawing a line to the beginning of
702 the subpath, automatically starting a new path. The current point
703 of the new path is (0, 0).
704
705 If the subpath does not contain any elements, this function does
706 nothing.
707
708 \sa moveTo(), {QPainterPath#Composing a QPainterPath}{Composing
709 a QPainterPath}
710 */
711void QPainterPath::closeSubpath()
712{
713#ifdef QPP_DEBUG
714 printf("QPainterPath::closeSubpath()\n");
715#endif
716 if (isEmpty())
717 return;
718 detach();
719
720 d_func()->close();
721}
722
723/*!
724 \fn void QPainterPath::moveTo(qreal x, qreal y)
725
726 \overload
727
728 Moves the current position to (\a{x}, \a{y}) and starts a new
729 subpath, implicitly closing the previous path.
730*/
731
732/*!
733 \fn void QPainterPath::moveTo(const QPointF &point)
734
735 Moves the current point to the given \a point, implicitly starting
736 a new subpath and closing the previous one.
737
738 \sa closeSubpath(), {QPainterPath#Composing a
739 QPainterPath}{Composing a QPainterPath}
740*/
741void QPainterPath::moveTo(const QPointF &p)
742{
743#ifdef QPP_DEBUG
744 printf("QPainterPath::moveTo() (%.2f,%.2f)\n", p.x(), p.y());
745#endif
746
747 if (!hasValidCoords(p)) {
748#ifndef QT_NO_DEBUG
749 qWarning(msg: "QPainterPath::moveTo: Adding point with invalid coordinates, ignoring call");
750#endif
751 return;
752 }
753
754 ensureData();
755 detach();
756
757 QPainterPathData *d = d_func();
758 Q_ASSERT(!d->elements.isEmpty());
759
760 d->require_moveTo = false;
761
762 if (d->elements.constLast().type == MoveToElement) {
763 d->elements.last().x = p.x();
764 d->elements.last().y = p.y();
765 } else {
766 Element elm = { .x: p.x(), .y: p.y(), .type: MoveToElement };
767 d->elements.append(t: elm);
768 }
769 d->cStart = d->elements.size() - 1;
770}
771
772/*!
773 \fn void QPainterPath::lineTo(qreal x, qreal y)
774
775 \overload
776
777 Draws a line from the current position to the point (\a{x},
778 \a{y}).
779*/
780
781/*!
782 \fn void QPainterPath::lineTo(const QPointF &endPoint)
783
784 Adds a straight line from the current position to the given \a
785 endPoint. After the line is drawn, the current position is updated
786 to be at the end point of the line.
787
788 \sa addPolygon(), addRect(), {QPainterPath#Composing a
789 QPainterPath}{Composing a QPainterPath}
790 */
791void QPainterPath::lineTo(const QPointF &p)
792{
793#ifdef QPP_DEBUG
794 printf("QPainterPath::lineTo() (%.2f,%.2f)\n", p.x(), p.y());
795#endif
796
797 if (!hasValidCoords(p)) {
798#ifndef QT_NO_DEBUG
799 qWarning(msg: "QPainterPath::lineTo: Adding point with invalid coordinates, ignoring call");
800#endif
801 return;
802 }
803
804 ensureData();
805 detach();
806
807 QPainterPathData *d = d_func();
808 Q_ASSERT(!d->elements.isEmpty());
809 d->maybeMoveTo();
810 if (p == QPointF(d->elements.constLast()))
811 return;
812 Element elm = { .x: p.x(), .y: p.y(), .type: LineToElement };
813 d->elements.append(t: elm);
814
815 d->convex = d->elements.size() == 3 || (d->elements.size() == 4 && d->isClosed());
816}
817
818/*!
819 \fn void QPainterPath::cubicTo(qreal c1X, qreal c1Y, qreal c2X,
820 qreal c2Y, qreal endPointX, qreal endPointY);
821
822 \overload
823
824 Adds a cubic Bezier curve between the current position and the end
825 point (\a{endPointX}, \a{endPointY}) with control points specified
826 by (\a{c1X}, \a{c1Y}) and (\a{c2X}, \a{c2Y}).
827*/
828
829/*!
830 \fn void QPainterPath::cubicTo(const QPointF &c1, const QPointF &c2, const QPointF &endPoint)
831
832 Adds a cubic Bezier curve between the current position and the
833 given \a endPoint using the control points specified by \a c1, and
834 \a c2.
835
836 After the curve is added, the current position is updated to be at
837 the end point of the curve.
838
839 \table 100%
840 \row
841 \li \inlineimage qpainterpath-cubicto.png
842 \li
843 \snippet code/src_gui_painting_qpainterpath.cpp 1
844 \endtable
845
846 \sa quadTo(), {QPainterPath#Composing a QPainterPath}{Composing
847 a QPainterPath}
848*/
849void QPainterPath::cubicTo(const QPointF &c1, const QPointF &c2, const QPointF &e)
850{
851#ifdef QPP_DEBUG
852 printf("QPainterPath::cubicTo() (%.2f,%.2f), (%.2f,%.2f), (%.2f,%.2f)\n",
853 c1.x(), c1.y(), c2.x(), c2.y(), e.x(), e.y());
854#endif
855
856 if (!hasValidCoords(p: c1) || !hasValidCoords(p: c2) || !hasValidCoords(p: e)) {
857#ifndef QT_NO_DEBUG
858 qWarning(msg: "QPainterPath::cubicTo: Adding point with invalid coordinates, ignoring call");
859#endif
860 return;
861 }
862
863 ensureData();
864 detach();
865
866 QPainterPathData *d = d_func();
867 Q_ASSERT(!d->elements.isEmpty());
868
869
870 // Abort on empty curve as a stroker cannot handle this and the
871 // curve is irrelevant anyway.
872 if (d->elements.constLast() == c1 && c1 == c2 && c2 == e)
873 return;
874
875 d->maybeMoveTo();
876
877 Element ce1 = { .x: c1.x(), .y: c1.y(), .type: CurveToElement };
878 Element ce2 = { .x: c2.x(), .y: c2.y(), .type: CurveToDataElement };
879 Element ee = { .x: e.x(), .y: e.y(), .type: CurveToDataElement };
880 d->elements << ce1 << ce2 << ee;
881}
882
883/*!
884 \fn void QPainterPath::quadTo(qreal cx, qreal cy, qreal endPointX, qreal endPointY);
885
886 \overload
887
888 Adds a quadratic Bezier curve between the current point and the endpoint
889 (\a{endPointX}, \a{endPointY}) with the control point specified by
890 (\a{cx}, \a{cy}).
891*/
892
893/*!
894 \fn void QPainterPath::quadTo(const QPointF &c, const QPointF &endPoint)
895
896 Adds a quadratic Bezier curve between the current position and the
897 given \a endPoint with the control point specified by \a c.
898
899 After the curve is added, the current point is updated to be at
900 the end point of the curve.
901
902 \sa cubicTo(), {QPainterPath#Composing a QPainterPath}{Composing a
903 QPainterPath}
904*/
905void QPainterPath::quadTo(const QPointF &c, const QPointF &e)
906{
907#ifdef QPP_DEBUG
908 printf("QPainterPath::quadTo() (%.2f,%.2f), (%.2f,%.2f)\n",
909 c.x(), c.y(), e.x(), e.y());
910#endif
911
912 if (!hasValidCoords(p: c) || !hasValidCoords(p: e)) {
913#ifndef QT_NO_DEBUG
914 qWarning(msg: "QPainterPath::quadTo: Adding point with invalid coordinates, ignoring call");
915#endif
916 return;
917 }
918
919 ensureData();
920 detach();
921
922 Q_D(QPainterPath);
923 Q_ASSERT(!d->elements.isEmpty());
924 const QPainterPath::Element &elm = d->elements.at(i: elementCount()-1);
925 QPointF prev(elm.x, elm.y);
926
927 // Abort on empty curve as a stroker cannot handle this and the
928 // curve is irrelevant anyway.
929 if (prev == c && c == e)
930 return;
931
932 QPointF c1((prev.x() + 2*c.x()) / 3, (prev.y() + 2*c.y()) / 3);
933 QPointF c2((e.x() + 2*c.x()) / 3, (e.y() + 2*c.y()) / 3);
934 cubicTo(c1, c2, e);
935}
936
937/*!
938 \fn void QPainterPath::arcTo(qreal x, qreal y, qreal width, qreal
939 height, qreal startAngle, qreal sweepLength)
940
941 \overload
942
943 Creates an arc that occupies the rectangle QRectF(\a x, \a y, \a
944 width, \a height), beginning at the specified \a startAngle and
945 extending \a sweepLength degrees counter-clockwise.
946
947*/
948
949/*!
950 \fn void QPainterPath::arcTo(const QRectF &rectangle, qreal startAngle, qreal sweepLength)
951
952 Creates an arc that occupies the given \a rectangle, beginning at
953 the specified \a startAngle and extending \a sweepLength degrees
954 counter-clockwise.
955
956 Angles are specified in degrees. Clockwise arcs can be specified
957 using negative angles.
958
959 Note that this function connects the starting point of the arc to
960 the current position if they are not already connected. After the
961 arc has been added, the current position is the last point in
962 arc. To draw a line back to the first point, use the
963 closeSubpath() function.
964
965 \table 100%
966 \row
967 \li \inlineimage qpainterpath-arcto.png
968 \li
969 \snippet code/src_gui_painting_qpainterpath.cpp 2
970 \endtable
971
972 \sa arcMoveTo(), addEllipse(), QPainter::drawArc(), QPainter::drawPie(),
973 {QPainterPath#Composing a QPainterPath}{Composing a
974 QPainterPath}
975*/
976void QPainterPath::arcTo(const QRectF &rect, qreal startAngle, qreal sweepLength)
977{
978#ifdef QPP_DEBUG
979 printf("QPainterPath::arcTo() (%.2f, %.2f, %.2f, %.2f, angle=%.2f, sweep=%.2f\n",
980 rect.x(), rect.y(), rect.width(), rect.height(), startAngle, sweepLength);
981#endif
982
983 if (!hasValidCoords(r: rect) || !isValidCoord(c: startAngle) || !isValidCoord(c: sweepLength)) {
984#ifndef QT_NO_DEBUG
985 qWarning(msg: "QPainterPath::arcTo: Adding point with invalid coordinates, ignoring call");
986#endif
987 return;
988 }
989
990 if (rect.isNull())
991 return;
992
993 ensureData();
994 detach();
995
996 int point_count;
997 QPointF pts[15];
998 QPointF curve_start = qt_curves_for_arc(rect, startAngle, sweepLength, controlPoints: pts, point_count: &point_count);
999
1000 lineTo(p: curve_start);
1001 for (int i=0; i<point_count; i+=3) {
1002 cubicTo(ctrlPt1x: pts[i].x(), ctrlPt1y: pts[i].y(),
1003 ctrlPt2x: pts[i+1].x(), ctrlPt2y: pts[i+1].y(),
1004 endPtx: pts[i+2].x(), endPty: pts[i+2].y());
1005 }
1006
1007}
1008
1009
1010/*!
1011 \fn void QPainterPath::arcMoveTo(qreal x, qreal y, qreal width, qreal height, qreal angle)
1012 \overload
1013 \since 4.2
1014
1015 Creates a move to that lies on the arc that occupies the
1016 QRectF(\a x, \a y, \a width, \a height) at \a angle.
1017*/
1018
1019
1020/*!
1021 \fn void QPainterPath::arcMoveTo(const QRectF &rectangle, qreal angle)
1022 \since 4.2
1023
1024 Creates a move to that lies on the arc that occupies the given \a
1025 rectangle at \a angle.
1026
1027 Angles are specified in degrees. Clockwise arcs can be specified
1028 using negative angles.
1029
1030 \sa moveTo(), arcTo()
1031*/
1032
1033void QPainterPath::arcMoveTo(const QRectF &rect, qreal angle)
1034{
1035 if (rect.isNull())
1036 return;
1037
1038 QPointF pt;
1039 qt_find_ellipse_coords(r: rect, angle, length: 0, startPoint: &pt, endPoint: nullptr);
1040 moveTo(p: pt);
1041}
1042
1043
1044
1045/*!
1046 \fn QPointF QPainterPath::currentPosition() const
1047
1048 Returns the current position of the path.
1049*/
1050QPointF QPainterPath::currentPosition() const
1051{
1052 return !d_ptr || d_func()->elements.isEmpty()
1053 ? QPointF()
1054 : QPointF(d_func()->elements.constLast().x, d_func()->elements.constLast().y);
1055}
1056
1057
1058/*!
1059 \fn void QPainterPath::addRect(qreal x, qreal y, qreal width, qreal height)
1060
1061 \overload
1062
1063 Adds a rectangle at position (\a{x}, \a{y}), with the given \a
1064 width and \a height, as a closed subpath.
1065*/
1066
1067/*!
1068 \fn void QPainterPath::addRect(const QRectF &rectangle)
1069
1070 Adds the given \a rectangle to this path as a closed subpath.
1071
1072 The \a rectangle is added as a clockwise set of lines. The painter
1073 path's current position after the \a rectangle has been added is
1074 at the top-left corner of the rectangle.
1075
1076 \table 100%
1077 \row
1078 \li \inlineimage qpainterpath-addrectangle.png
1079 \li
1080 \snippet code/src_gui_painting_qpainterpath.cpp 3
1081 \endtable
1082
1083 \sa addRegion(), lineTo(), {QPainterPath#Composing a
1084 QPainterPath}{Composing a QPainterPath}
1085*/
1086void QPainterPath::addRect(const QRectF &r)
1087{
1088 if (!hasValidCoords(r)) {
1089#ifndef QT_NO_DEBUG
1090 qWarning(msg: "QPainterPath::addRect: Adding point with invalid coordinates, ignoring call");
1091#endif
1092 return;
1093 }
1094
1095 if (r.isNull())
1096 return;
1097
1098 ensureData();
1099 detach();
1100
1101 bool first = d_func()->elements.size() < 2;
1102
1103 moveTo(x: r.x(), y: r.y());
1104
1105 Element l1 = { .x: r.x() + r.width(), .y: r.y(), .type: LineToElement };
1106 Element l2 = { .x: r.x() + r.width(), .y: r.y() + r.height(), .type: LineToElement };
1107 Element l3 = { .x: r.x(), .y: r.y() + r.height(), .type: LineToElement };
1108 Element l4 = { .x: r.x(), .y: r.y(), .type: LineToElement };
1109
1110 d_func()->elements << l1 << l2 << l3 << l4;
1111 d_func()->require_moveTo = true;
1112 d_func()->convex = first;
1113}
1114
1115/*!
1116 Adds the given \a polygon to the path as an (unclosed) subpath.
1117
1118 Note that the current position after the polygon has been added,
1119 is the last point in \a polygon. To draw a line back to the first
1120 point, use the closeSubpath() function.
1121
1122 \table 100%
1123 \row
1124 \li \inlineimage qpainterpath-addpolygon.png
1125 \li
1126 \snippet code/src_gui_painting_qpainterpath.cpp 4
1127 \endtable
1128
1129 \sa lineTo(), {QPainterPath#Composing a QPainterPath}{Composing
1130 a QPainterPath}
1131*/
1132void QPainterPath::addPolygon(const QPolygonF &polygon)
1133{
1134 if (polygon.isEmpty())
1135 return;
1136
1137 ensureData();
1138 detach();
1139
1140 moveTo(p: polygon.constFirst());
1141 for (int i=1; i<polygon.size(); ++i) {
1142 Element elm = { .x: polygon.at(i).x(), .y: polygon.at(i).y(), .type: LineToElement };
1143 d_func()->elements << elm;
1144 }
1145}
1146
1147/*!
1148 \fn void QPainterPath::addEllipse(const QRectF &boundingRectangle)
1149
1150 Creates an ellipse within the specified \a boundingRectangle
1151 and adds it to the painter path as a closed subpath.
1152
1153 The ellipse is composed of a clockwise curve, starting and
1154 finishing at zero degrees (the 3 o'clock position).
1155
1156 \table 100%
1157 \row
1158 \li \inlineimage qpainterpath-addellipse.png
1159 \li
1160 \snippet code/src_gui_painting_qpainterpath.cpp 5
1161 \endtable
1162
1163 \sa arcTo(), QPainter::drawEllipse(), {QPainterPath#Composing a
1164 QPainterPath}{Composing a QPainterPath}
1165*/
1166void QPainterPath::addEllipse(const QRectF &boundingRect)
1167{
1168 if (!hasValidCoords(r: boundingRect)) {
1169#ifndef QT_NO_DEBUG
1170 qWarning(msg: "QPainterPath::addEllipse: Adding point with invalid coordinates, ignoring call");
1171#endif
1172 return;
1173 }
1174
1175 if (boundingRect.isNull())
1176 return;
1177
1178 ensureData();
1179 detach();
1180
1181 bool first = d_func()->elements.size() < 2;
1182
1183 QPointF pts[12];
1184 int point_count;
1185 QPointF start = qt_curves_for_arc(rect: boundingRect, startAngle: 0, sweepLength: -360, controlPoints: pts, point_count: &point_count);
1186
1187 moveTo(p: start);
1188 cubicTo(c1: pts[0], c2: pts[1], e: pts[2]); // 0 -> 270
1189 cubicTo(c1: pts[3], c2: pts[4], e: pts[5]); // 270 -> 180
1190 cubicTo(c1: pts[6], c2: pts[7], e: pts[8]); // 180 -> 90
1191 cubicTo(c1: pts[9], c2: pts[10], e: pts[11]); // 90 - >0
1192 d_func()->require_moveTo = true;
1193
1194 d_func()->convex = first;
1195}
1196
1197/*!
1198 \fn void QPainterPath::addText(const QPointF &point, const QFont &font, const QString &text)
1199
1200 Adds the given \a text to this path as a set of closed subpaths
1201 created from the \a font supplied. The subpaths are positioned so
1202 that the left end of the text's baseline lies at the specified \a
1203 point.
1204
1205 \table 100%
1206 \row
1207 \li \inlineimage qpainterpath-addtext.png
1208 \li
1209 \snippet code/src_gui_painting_qpainterpath.cpp 6
1210 \endtable
1211
1212 \sa QPainter::drawText(), {QPainterPath#Composing a
1213 QPainterPath}{Composing a QPainterPath}
1214*/
1215void QPainterPath::addText(const QPointF &point, const QFont &f, const QString &text)
1216{
1217 if (text.isEmpty())
1218 return;
1219
1220 ensureData();
1221 detach();
1222
1223 QTextLayout layout(text, f);
1224 layout.setCacheEnabled(true);
1225
1226 QTextOption opt = layout.textOption();
1227 opt.setUseDesignMetrics(true);
1228 layout.setTextOption(opt);
1229
1230 QTextEngine *eng = layout.engine();
1231 layout.beginLayout();
1232 QTextLine line = layout.createLine();
1233 Q_UNUSED(line);
1234 layout.endLayout();
1235 const QScriptLine &sl = eng->lines[0];
1236 if (!sl.length || !eng->layoutData)
1237 return;
1238
1239 int nItems = eng->layoutData->items.size();
1240
1241 qreal x(point.x());
1242 qreal y(point.y());
1243
1244 QVarLengthArray<int> visualOrder(nItems);
1245 QVarLengthArray<uchar> levels(nItems);
1246 for (int i = 0; i < nItems; ++i)
1247 levels[i] = eng->layoutData->items.at(i).analysis.bidiLevel;
1248 QTextEngine::bidiReorder(numRuns: nItems, levels: levels.data(), visualOrder: visualOrder.data());
1249
1250 for (int i = 0; i < nItems; ++i) {
1251 int item = visualOrder[i];
1252 const QScriptItem &si = eng->layoutData->items.at(i: item);
1253
1254 if (si.analysis.flags < QScriptAnalysis::TabOrObject) {
1255 QGlyphLayout glyphs = eng->shapedGlyphs(si: &si);
1256 QFontEngine *fe = f.d->engineForScript(script: si.analysis.script);
1257 Q_ASSERT(fe);
1258 fe->addOutlineToPath(x, y, glyphs, this,
1259 flags: si.analysis.bidiLevel % 2
1260 ? QTextItem::RenderFlags(QTextItem::RightToLeft)
1261 : QTextItem::RenderFlags{});
1262
1263 const qreal lw = fe->lineThickness().toReal();
1264 if (f.d->underline) {
1265 qreal pos = fe->underlinePosition().toReal();
1266 addRect(x, y: y + pos, w: si.width.toReal(), h: lw);
1267 }
1268 if (f.d->overline) {
1269 qreal pos = fe->ascent().toReal() + 1;
1270 addRect(x, y: y - pos, w: si.width.toReal(), h: lw);
1271 }
1272 if (f.d->strikeOut) {
1273 qreal pos = fe->ascent().toReal() / 3;
1274 addRect(x, y: y - pos, w: si.width.toReal(), h: lw);
1275 }
1276 }
1277 x += si.width.toReal();
1278 }
1279}
1280
1281/*!
1282 \fn void QPainterPath::addPath(const QPainterPath &path)
1283
1284 Adds the given \a path to \e this path as a closed subpath.
1285
1286 \sa connectPath(), {QPainterPath#Composing a
1287 QPainterPath}{Composing a QPainterPath}
1288*/
1289void QPainterPath::addPath(const QPainterPath &other)
1290{
1291 if (other.isEmpty())
1292 return;
1293
1294 ensureData();
1295 detach();
1296
1297 QPainterPathData *d = reinterpret_cast<QPainterPathData *>(d_func());
1298 // Remove last moveto so we don't get multiple moveto's
1299 if (d->elements.constLast().type == MoveToElement)
1300 d->elements.remove(i: d->elements.size()-1);
1301
1302 // Locate where our own current subpath will start after the other path is added.
1303 int cStart = d->elements.size() + other.d_func()->cStart;
1304 d->elements += other.d_func()->elements;
1305 d->cStart = cStart;
1306
1307 d->require_moveTo = other.d_func()->isClosed();
1308}
1309
1310
1311/*!
1312 \fn void QPainterPath::connectPath(const QPainterPath &path)
1313
1314 Connects the given \a path to \e this path by adding a line from the
1315 last element of this path to the first element of the given path.
1316
1317 \sa addPath(), {QPainterPath#Composing a QPainterPath}{Composing
1318 a QPainterPath}
1319*/
1320void QPainterPath::connectPath(const QPainterPath &other)
1321{
1322 if (other.isEmpty())
1323 return;
1324
1325 ensureData();
1326 detach();
1327
1328 QPainterPathData *d = reinterpret_cast<QPainterPathData *>(d_func());
1329 // Remove last moveto so we don't get multiple moveto's
1330 if (d->elements.constLast().type == MoveToElement)
1331 d->elements.remove(i: d->elements.size()-1);
1332
1333 // Locate where our own current subpath will start after the other path is added.
1334 int cStart = d->elements.size() + other.d_func()->cStart;
1335 int first = d->elements.size();
1336 d->elements += other.d_func()->elements;
1337
1338 if (first != 0)
1339 d->elements[first].type = LineToElement;
1340
1341 // avoid duplicate points
1342 if (first > 0 && QPointF(d->elements.at(i: first)) == QPointF(d->elements.at(i: first - 1))) {
1343 d->elements.remove(i: first--);
1344 --cStart;
1345 }
1346
1347 if (cStart != first)
1348 d->cStart = cStart;
1349}
1350
1351/*!
1352 Adds the given \a region to the path by adding each rectangle in
1353 the region as a separate closed subpath.
1354
1355 \sa addRect(), {QPainterPath#Composing a QPainterPath}{Composing
1356 a QPainterPath}
1357*/
1358void QPainterPath::addRegion(const QRegion &region)
1359{
1360 ensureData();
1361 detach();
1362
1363 for (const QRect &rect : region)
1364 addRect(r: rect);
1365}
1366
1367
1368/*!
1369 Returns the painter path's currently set fill rule.
1370
1371 \sa setFillRule()
1372*/
1373Qt::FillRule QPainterPath::fillRule() const
1374{
1375 return !d_func() ? Qt::OddEvenFill : d_func()->fillRule;
1376}
1377
1378/*!
1379 \fn void QPainterPath::setFillRule(Qt::FillRule fillRule)
1380
1381 Sets the fill rule of the painter path to the given \a
1382 fillRule. Qt provides two methods for filling paths:
1383
1384 \table
1385 \header
1386 \li Qt::OddEvenFill (default)
1387 \li Qt::WindingFill
1388 \row
1389 \li \inlineimage qt-fillrule-oddeven.png
1390 \li \inlineimage qt-fillrule-winding.png
1391 \endtable
1392
1393 \sa fillRule()
1394*/
1395void QPainterPath::setFillRule(Qt::FillRule fillRule)
1396{
1397 ensureData();
1398 if (d_func()->fillRule == fillRule)
1399 return;
1400 detach();
1401
1402 d_func()->fillRule = fillRule;
1403}
1404
1405#define QT_BEZIER_A(bezier, coord) 3 * (-bezier.coord##1 \
1406 + 3*bezier.coord##2 \
1407 - 3*bezier.coord##3 \
1408 +bezier.coord##4)
1409
1410#define QT_BEZIER_B(bezier, coord) 6 * (bezier.coord##1 \
1411 - 2*bezier.coord##2 \
1412 + bezier.coord##3)
1413
1414#define QT_BEZIER_C(bezier, coord) 3 * (- bezier.coord##1 \
1415 + bezier.coord##2)
1416
1417#define QT_BEZIER_CHECK_T(bezier, t) \
1418 if (t >= 0 && t <= 1) { \
1419 QPointF p(b.pointAt(t)); \
1420 if (p.x() < minx) minx = p.x(); \
1421 else if (p.x() > maxx) maxx = p.x(); \
1422 if (p.y() < miny) miny = p.y(); \
1423 else if (p.y() > maxy) maxy = p.y(); \
1424 }
1425
1426
1427static QRectF qt_painterpath_bezier_extrema(const QBezier &b)
1428{
1429 qreal minx, miny, maxx, maxy;
1430
1431 // initialize with end points
1432 if (b.x1 < b.x4) {
1433 minx = b.x1;
1434 maxx = b.x4;
1435 } else {
1436 minx = b.x4;
1437 maxx = b.x1;
1438 }
1439 if (b.y1 < b.y4) {
1440 miny = b.y1;
1441 maxy = b.y4;
1442 } else {
1443 miny = b.y4;
1444 maxy = b.y1;
1445 }
1446
1447 // Update for the X extrema
1448 {
1449 qreal ax = QT_BEZIER_A(b, x);
1450 qreal bx = QT_BEZIER_B(b, x);
1451 qreal cx = QT_BEZIER_C(b, x);
1452 // specialcase quadratic curves to avoid div by zero
1453 if (qFuzzyIsNull(d: ax)) {
1454
1455 // linear curves are covered by initialization.
1456 if (!qFuzzyIsNull(d: bx)) {
1457 qreal t = -cx / bx;
1458 QT_BEZIER_CHECK_T(b, t);
1459 }
1460
1461 } else {
1462 const qreal tx = bx * bx - 4 * ax * cx;
1463
1464 if (tx >= 0) {
1465 qreal temp = qSqrt(v: tx);
1466 qreal rcp = 1 / (2 * ax);
1467 qreal t1 = (-bx + temp) * rcp;
1468 QT_BEZIER_CHECK_T(b, t1);
1469
1470 qreal t2 = (-bx - temp) * rcp;
1471 QT_BEZIER_CHECK_T(b, t2);
1472 }
1473 }
1474 }
1475
1476 // Update for the Y extrema
1477 {
1478 qreal ay = QT_BEZIER_A(b, y);
1479 qreal by = QT_BEZIER_B(b, y);
1480 qreal cy = QT_BEZIER_C(b, y);
1481
1482 // specialcase quadratic curves to avoid div by zero
1483 if (qFuzzyIsNull(d: ay)) {
1484
1485 // linear curves are covered by initialization.
1486 if (!qFuzzyIsNull(d: by)) {
1487 qreal t = -cy / by;
1488 QT_BEZIER_CHECK_T(b, t);
1489 }
1490
1491 } else {
1492 const qreal ty = by * by - 4 * ay * cy;
1493
1494 if (ty > 0) {
1495 qreal temp = qSqrt(v: ty);
1496 qreal rcp = 1 / (2 * ay);
1497 qreal t1 = (-by + temp) * rcp;
1498 QT_BEZIER_CHECK_T(b, t1);
1499
1500 qreal t2 = (-by - temp) * rcp;
1501 QT_BEZIER_CHECK_T(b, t2);
1502 }
1503 }
1504 }
1505 return QRectF(minx, miny, maxx - minx, maxy - miny);
1506}
1507
1508/*!
1509 Returns the bounding rectangle of this painter path as a rectangle with
1510 floating point precision.
1511
1512 \sa controlPointRect()
1513*/
1514QRectF QPainterPath::boundingRect() const
1515{
1516 if (!d_ptr)
1517 return QRectF();
1518 QPainterPathData *d = d_func();
1519
1520 if (d->dirtyBounds)
1521 computeBoundingRect();
1522 return d->bounds;
1523}
1524
1525/*!
1526 Returns the rectangle containing all the points and control points
1527 in this path.
1528
1529 This function is significantly faster to compute than the exact
1530 boundingRect(), and the returned rectangle is always a superset of
1531 the rectangle returned by boundingRect().
1532
1533 \sa boundingRect()
1534*/
1535QRectF QPainterPath::controlPointRect() const
1536{
1537 if (!d_ptr)
1538 return QRectF();
1539 QPainterPathData *d = d_func();
1540
1541 if (d->dirtyControlBounds)
1542 computeControlPointRect();
1543 return d->controlBounds;
1544}
1545
1546
1547/*!
1548 \fn bool QPainterPath::isEmpty() const
1549
1550 Returns \c true if either there are no elements in this path, or if the only
1551 element is a MoveToElement; otherwise returns \c false.
1552
1553 \sa elementCount()
1554*/
1555
1556bool QPainterPath::isEmpty() const
1557{
1558 return !d_ptr || (d_ptr->elements.size() == 1 && d_ptr->elements.first().type == MoveToElement);
1559}
1560
1561/*!
1562 Creates and returns a reversed copy of the path.
1563
1564 It is the order of the elements that is reversed: If a
1565 QPainterPath is composed by calling the moveTo(), lineTo() and
1566 cubicTo() functions in the specified order, the reversed copy is
1567 composed by calling cubicTo(), lineTo() and moveTo().
1568*/
1569QPainterPath QPainterPath::toReversed() const
1570{
1571 Q_D(const QPainterPath);
1572 QPainterPath rev;
1573
1574 if (isEmpty()) {
1575 rev = *this;
1576 return rev;
1577 }
1578
1579 rev.moveTo(x: d->elements.at(i: d->elements.size()-1).x, y: d->elements.at(i: d->elements.size()-1).y);
1580
1581 for (int i=d->elements.size()-1; i>=1; --i) {
1582 const QPainterPath::Element &elm = d->elements.at(i);
1583 const QPainterPath::Element &prev = d->elements.at(i: i-1);
1584 switch (elm.type) {
1585 case LineToElement:
1586 rev.lineTo(x: prev.x, y: prev.y);
1587 break;
1588 case MoveToElement:
1589 rev.moveTo(x: prev.x, y: prev.y);
1590 break;
1591 case CurveToDataElement:
1592 {
1593 Q_ASSERT(i>=3);
1594 const QPainterPath::Element &cp1 = d->elements.at(i: i-2);
1595 const QPainterPath::Element &sp = d->elements.at(i: i-3);
1596 Q_ASSERT(prev.type == CurveToDataElement);
1597 Q_ASSERT(cp1.type == CurveToElement);
1598 rev.cubicTo(ctrlPt1x: prev.x, ctrlPt1y: prev.y, ctrlPt2x: cp1.x, ctrlPt2y: cp1.y, endPtx: sp.x, endPty: sp.y);
1599 i -= 2;
1600 break;
1601 }
1602 default:
1603 Q_ASSERT(!"qt_reversed_path");
1604 break;
1605 }
1606 }
1607 //qt_debug_path(rev);
1608 return rev;
1609}
1610
1611/*!
1612 Converts the path into a list of polygons using the QTransform
1613 \a matrix, and returns the list.
1614
1615 This function creates one polygon for each subpath regardless of
1616 intersecting subpaths (i.e. overlapping bounding rectangles). To
1617 make sure that such overlapping subpaths are filled correctly, use
1618 the toFillPolygons() function instead.
1619
1620 \sa toFillPolygons(), toFillPolygon(), {QPainterPath#QPainterPath
1621 Conversion}{QPainterPath Conversion}
1622*/
1623QList<QPolygonF> QPainterPath::toSubpathPolygons(const QTransform &matrix) const
1624{
1625
1626 Q_D(const QPainterPath);
1627 QList<QPolygonF> flatCurves;
1628 if (isEmpty())
1629 return flatCurves;
1630
1631 QPolygonF current;
1632 for (int i=0; i<elementCount(); ++i) {
1633 const QPainterPath::Element &e = d->elements.at(i);
1634 switch (e.type) {
1635 case QPainterPath::MoveToElement:
1636 if (current.size() > 1)
1637 flatCurves += current;
1638 current.clear();
1639 current.reserve(asize: 16);
1640 current += QPointF(e.x, e.y) * matrix;
1641 break;
1642 case QPainterPath::LineToElement:
1643 current += QPointF(e.x, e.y) * matrix;
1644 break;
1645 case QPainterPath::CurveToElement: {
1646 Q_ASSERT(d->elements.at(i+1).type == QPainterPath::CurveToDataElement);
1647 Q_ASSERT(d->elements.at(i+2).type == QPainterPath::CurveToDataElement);
1648 QBezier bezier = QBezier::fromPoints(p1: QPointF(d->elements.at(i: i-1).x, d->elements.at(i: i-1).y) * matrix,
1649 p2: QPointF(e.x, e.y) * matrix,
1650 p3: QPointF(d->elements.at(i: i+1).x, d->elements.at(i: i+1).y) * matrix,
1651 p4: QPointF(d->elements.at(i: i+2).x, d->elements.at(i: i+2).y) * matrix);
1652 bezier.addToPolygon(p: &current);
1653 i+=2;
1654 break;
1655 }
1656 case QPainterPath::CurveToDataElement:
1657 Q_ASSERT(!"QPainterPath::toSubpathPolygons(), bad element type");
1658 break;
1659 }
1660 }
1661
1662 if (current.size()>1)
1663 flatCurves += current;
1664
1665 return flatCurves;
1666}
1667
1668#if QT_DEPRECATED_SINCE(5, 15)
1669/*!
1670 \overload
1671 \obsolete
1672
1673 Use toSubpathPolygons(const QTransform &matrix) instead.
1674 */
1675QList<QPolygonF> QPainterPath::toSubpathPolygons(const QMatrix &matrix) const
1676{
1677 return toSubpathPolygons(matrix: QTransform(matrix));
1678}
1679#endif // QT_DEPRECATED_SINCE(5, 15)
1680
1681/*!
1682 Converts the path into a list of polygons using the
1683 QTransform \a matrix, and returns the list.
1684
1685 The function differs from the toFillPolygon() function in that it
1686 creates several polygons. It is provided because it is usually
1687 faster to draw several small polygons than to draw one large
1688 polygon, even though the total number of points drawn is the same.
1689
1690 The toFillPolygons() function differs from the toSubpathPolygons()
1691 function in that it create only polygon for subpaths that have
1692 overlapping bounding rectangles.
1693
1694 Like the toFillPolygon() function, this function uses a rewinding
1695 technique to make sure that overlapping subpaths can be filled
1696 using the correct fill rule. Note that rewinding inserts addition
1697 lines in the polygons so the outline of the fill polygon does not
1698 match the outline of the path.
1699
1700 \sa toSubpathPolygons(), toFillPolygon(),
1701 {QPainterPath#QPainterPath Conversion}{QPainterPath Conversion}
1702*/
1703QList<QPolygonF> QPainterPath::toFillPolygons(const QTransform &matrix) const
1704{
1705
1706 QList<QPolygonF> polys;
1707
1708 QList<QPolygonF> subpaths = toSubpathPolygons(matrix);
1709 int count = subpaths.size();
1710
1711 if (count == 0)
1712 return polys;
1713
1714 QVector<QRectF> bounds;
1715 bounds.reserve(asize: count);
1716 for (int i=0; i<count; ++i)
1717 bounds += subpaths.at(i).boundingRect();
1718
1719#ifdef QPP_FILLPOLYGONS_DEBUG
1720 printf("QPainterPath::toFillPolygons, subpathCount=%d\n", count);
1721 for (int i=0; i<bounds.size(); ++i)
1722 qDebug() << " bounds" << i << bounds.at(i);
1723#endif
1724
1725 QVector< QVector<int> > isects;
1726 isects.resize(asize: count);
1727
1728 // find all intersections
1729 for (int j=0; j<count; ++j) {
1730 if (subpaths.at(i: j).size() <= 2)
1731 continue;
1732 QRectF cbounds = bounds.at(i: j);
1733 for (int i=0; i<count; ++i) {
1734 if (cbounds.intersects(r: bounds.at(i))) {
1735 isects[j] << i;
1736 }
1737 }
1738 }
1739
1740#ifdef QPP_FILLPOLYGONS_DEBUG
1741 printf("Intersections before flattening:\n");
1742 for (int i = 0; i < count; ++i) {
1743 printf("%d: ", i);
1744 for (int j = 0; j < isects[i].size(); ++j) {
1745 printf("%d ", isects[i][j]);
1746 }
1747 printf("\n");
1748 }
1749#endif
1750
1751 // flatten the sets of intersections
1752 for (int i=0; i<count; ++i) {
1753 const QVector<int> &current_isects = isects.at(i);
1754 for (int j=0; j<current_isects.size(); ++j) {
1755 int isect_j = current_isects.at(i: j);
1756 if (isect_j == i)
1757 continue;
1758 const QVector<int> &isects_j = isects.at(i: isect_j);
1759 for (int k = 0, size = isects_j.size(); k < size; ++k) {
1760 int isect_k = isects_j.at(i: k);
1761 if (isect_k != i && !isects.at(i).contains(t: isect_k)) {
1762 isects[i] += isect_k;
1763 }
1764 }
1765 isects[isect_j].clear();
1766 }
1767 }
1768
1769#ifdef QPP_FILLPOLYGONS_DEBUG
1770 printf("Intersections after flattening:\n");
1771 for (int i = 0; i < count; ++i) {
1772 printf("%d: ", i);
1773 for (int j = 0; j < isects[i].size(); ++j) {
1774 printf("%d ", isects[i][j]);
1775 }
1776 printf("\n");
1777 }
1778#endif
1779
1780 // Join the intersected subpaths as rewinded polygons
1781 for (int i=0; i<count; ++i) {
1782 const QVector<int> &subpath_list = isects.at(i);
1783 if (!subpath_list.isEmpty()) {
1784 QPolygonF buildUp;
1785 for (int j=0; j<subpath_list.size(); ++j) {
1786 const QPolygonF &subpath = subpaths.at(i: subpath_list.at(i: j));
1787 buildUp += subpath;
1788 if (!subpath.isClosed())
1789 buildUp += subpath.first();
1790 if (!buildUp.isClosed())
1791 buildUp += buildUp.constFirst();
1792 }
1793 polys += buildUp;
1794 }
1795 }
1796
1797 return polys;
1798}
1799
1800#if QT_DEPRECATED_SINCE(5, 15)
1801/*!
1802 \overload
1803 \obsolete
1804
1805 Use toFillPolygons(const QTransform &matrix) instead.
1806 */
1807QList<QPolygonF> QPainterPath::toFillPolygons(const QMatrix &matrix) const
1808{
1809 return toFillPolygons(matrix: QTransform(matrix));
1810}
1811#endif // QT_DEPRECATED_SINCE(5, 15)
1812
1813//same as qt_polygon_isect_line in qpolygon.cpp
1814static void qt_painterpath_isect_line(const QPointF &p1,
1815 const QPointF &p2,
1816 const QPointF &pos,
1817 int *winding)
1818{
1819 qreal x1 = p1.x();
1820 qreal y1 = p1.y();
1821 qreal x2 = p2.x();
1822 qreal y2 = p2.y();
1823 qreal y = pos.y();
1824
1825 int dir = 1;
1826
1827 if (qFuzzyCompare(p1: y1, p2: y2)) {
1828 // ignore horizontal lines according to scan conversion rule
1829 return;
1830 } else if (y2 < y1) {
1831 qreal x_tmp = x2; x2 = x1; x1 = x_tmp;
1832 qreal y_tmp = y2; y2 = y1; y1 = y_tmp;
1833 dir = -1;
1834 }
1835
1836 if (y >= y1 && y < y2) {
1837 qreal x = x1 + ((x2 - x1) / (y2 - y1)) * (y - y1);
1838
1839 // count up the winding number if we're
1840 if (x<=pos.x()) {
1841 (*winding) += dir;
1842 }
1843 }
1844}
1845
1846static void qt_painterpath_isect_curve(const QBezier &bezier, const QPointF &pt,
1847 int *winding, int depth = 0)
1848{
1849 qreal y = pt.y();
1850 qreal x = pt.x();
1851 QRectF bounds = bezier.bounds();
1852
1853 // potential intersection, divide and try again...
1854 // Please note that a sideeffect of the bottom exclusion is that
1855 // horizontal lines are dropped, but this is correct according to
1856 // scan conversion rules.
1857 if (y >= bounds.y() && y < bounds.y() + bounds.height()) {
1858
1859 // hit lower limit... This is a rough threshold, but its a
1860 // tradeoff between speed and precision.
1861 const qreal lower_bound = qreal(.001);
1862 if (depth == 32 || (bounds.width() < lower_bound && bounds.height() < lower_bound)) {
1863 // We make the assumption here that the curve starts to
1864 // approximate a line after while (i.e. that it doesn't
1865 // change direction drastically during its slope)
1866 if (bezier.pt1().x() <= x) {
1867 (*winding) += (bezier.pt4().y() > bezier.pt1().y() ? 1 : -1);
1868 }
1869 return;
1870 }
1871
1872 // split curve and try again...
1873 const auto halves = bezier.split();
1874 qt_painterpath_isect_curve(bezier: halves.first, pt, winding, depth: depth + 1);
1875 qt_painterpath_isect_curve(bezier: halves.second, pt, winding, depth: depth + 1);
1876 }
1877}
1878
1879/*!
1880 \fn bool QPainterPath::contains(const QPointF &point) const
1881
1882 Returns \c true if the given \a point is inside the path, otherwise
1883 returns \c false.
1884
1885 \sa intersects()
1886*/
1887bool QPainterPath::contains(const QPointF &pt) const
1888{
1889 if (isEmpty() || !controlPointRect().contains(p: pt))
1890 return false;
1891
1892 QPainterPathData *d = d_func();
1893
1894 int winding_number = 0;
1895
1896 QPointF last_pt;
1897 QPointF last_start;
1898 for (int i=0; i<d->elements.size(); ++i) {
1899 const Element &e = d->elements.at(i);
1900
1901 switch (e.type) {
1902
1903 case MoveToElement:
1904 if (i > 0) // implicitly close all paths.
1905 qt_painterpath_isect_line(p1: last_pt, p2: last_start, pos: pt, winding: &winding_number);
1906 last_start = last_pt = e;
1907 break;
1908
1909 case LineToElement:
1910 qt_painterpath_isect_line(p1: last_pt, p2: e, pos: pt, winding: &winding_number);
1911 last_pt = e;
1912 break;
1913
1914 case CurveToElement:
1915 {
1916 const QPainterPath::Element &cp2 = d->elements.at(i: ++i);
1917 const QPainterPath::Element &ep = d->elements.at(i: ++i);
1918 qt_painterpath_isect_curve(bezier: QBezier::fromPoints(p1: last_pt, p2: e, p3: cp2, p4: ep),
1919 pt, winding: &winding_number);
1920 last_pt = ep;
1921
1922 }
1923 break;
1924
1925 default:
1926 break;
1927 }
1928 }
1929
1930 // implicitly close last subpath
1931 if (last_pt != last_start)
1932 qt_painterpath_isect_line(p1: last_pt, p2: last_start, pos: pt, winding: &winding_number);
1933
1934 return (d->fillRule == Qt::WindingFill
1935 ? (winding_number != 0)
1936 : ((winding_number % 2) != 0));
1937}
1938
1939enum PainterDirections { Left, Right, Top, Bottom };
1940
1941static bool qt_painterpath_isect_line_rect(qreal x1, qreal y1, qreal x2, qreal y2,
1942 const QRectF &rect)
1943{
1944 qreal left = rect.left();
1945 qreal right = rect.right();
1946 qreal top = rect.top();
1947 qreal bottom = rect.bottom();
1948
1949 // clip the lines, after cohen-sutherland, see e.g. http://www.nondot.org/~sabre/graphpro/line6.html
1950 int p1 = ((x1 < left) << Left)
1951 | ((x1 > right) << Right)
1952 | ((y1 < top) << Top)
1953 | ((y1 > bottom) << Bottom);
1954 int p2 = ((x2 < left) << Left)
1955 | ((x2 > right) << Right)
1956 | ((y2 < top) << Top)
1957 | ((y2 > bottom) << Bottom);
1958
1959 if (p1 & p2)
1960 // completely inside
1961 return false;
1962
1963 if (p1 | p2) {
1964 qreal dx = x2 - x1;
1965 qreal dy = y2 - y1;
1966
1967 // clip x coordinates
1968 if (x1 < left) {
1969 y1 += dy/dx * (left - x1);
1970 x1 = left;
1971 } else if (x1 > right) {
1972 y1 -= dy/dx * (x1 - right);
1973 x1 = right;
1974 }
1975 if (x2 < left) {
1976 y2 += dy/dx * (left - x2);
1977 x2 = left;
1978 } else if (x2 > right) {
1979 y2 -= dy/dx * (x2 - right);
1980 x2 = right;
1981 }
1982
1983 p1 = ((y1 < top) << Top)
1984 | ((y1 > bottom) << Bottom);
1985 p2 = ((y2 < top) << Top)
1986 | ((y2 > bottom) << Bottom);
1987
1988 if (p1 & p2)
1989 return false;
1990
1991 // clip y coordinates
1992 if (y1 < top) {
1993 x1 += dx/dy * (top - y1);
1994 y1 = top;
1995 } else if (y1 > bottom) {
1996 x1 -= dx/dy * (y1 - bottom);
1997 y1 = bottom;
1998 }
1999 if (y2 < top) {
2000 x2 += dx/dy * (top - y2);
2001 y2 = top;
2002 } else if (y2 > bottom) {
2003 x2 -= dx/dy * (y2 - bottom);
2004 y2 = bottom;
2005 }
2006
2007 p1 = ((x1 < left) << Left)
2008 | ((x1 > right) << Right);
2009 p2 = ((x2 < left) << Left)
2010 | ((x2 > right) << Right);
2011
2012 if (p1 & p2)
2013 return false;
2014
2015 return true;
2016 }
2017 return false;
2018}
2019
2020static bool qt_isect_curve_horizontal(const QBezier &bezier, qreal y, qreal x1, qreal x2, int depth = 0)
2021{
2022 QRectF bounds = bezier.bounds();
2023
2024 if (y >= bounds.top() && y < bounds.bottom()
2025 && bounds.right() >= x1 && bounds.left() < x2) {
2026 const qreal lower_bound = qreal(.01);
2027 if (depth == 32 || (bounds.width() < lower_bound && bounds.height() < lower_bound))
2028 return true;
2029
2030 const auto halves = bezier.split();
2031 if (qt_isect_curve_horizontal(bezier: halves.first, y, x1, x2, depth: depth + 1)
2032 || qt_isect_curve_horizontal(bezier: halves.second, y, x1, x2, depth: depth + 1))
2033 return true;
2034 }
2035 return false;
2036}
2037
2038static bool qt_isect_curve_vertical(const QBezier &bezier, qreal x, qreal y1, qreal y2, int depth = 0)
2039{
2040 QRectF bounds = bezier.bounds();
2041
2042 if (x >= bounds.left() && x < bounds.right()
2043 && bounds.bottom() >= y1 && bounds.top() < y2) {
2044 const qreal lower_bound = qreal(.01);
2045 if (depth == 32 || (bounds.width() < lower_bound && bounds.height() < lower_bound))
2046 return true;
2047
2048 const auto halves = bezier.split();
2049 if (qt_isect_curve_vertical(bezier: halves.first, x, y1, y2, depth: depth + 1)
2050 || qt_isect_curve_vertical(bezier: halves.second, x, y1, y2, depth: depth + 1))
2051 return true;
2052 }
2053 return false;
2054}
2055
2056static bool pointOnEdge(const QRectF &rect, const QPointF &point)
2057{
2058 if ((point.x() == rect.left() || point.x() == rect.right()) &&
2059 (point.y() >= rect.top() && point.y() <= rect.bottom()))
2060 return true;
2061 if ((point.y() == rect.top() || point.y() == rect.bottom()) &&
2062 (point.x() >= rect.left() && point.x() <= rect.right()))
2063 return true;
2064 return false;
2065}
2066
2067/*
2068 Returns \c true if any lines or curves cross the four edges in of rect
2069*/
2070static bool qt_painterpath_check_crossing(const QPainterPath *path, const QRectF &rect)
2071{
2072 QPointF last_pt;
2073 QPointF last_start;
2074 enum { OnRect, InsideRect, OutsideRect} edgeStatus = OnRect;
2075 for (int i=0; i<path->elementCount(); ++i) {
2076 const QPainterPath::Element &e = path->elementAt(i);
2077
2078 switch (e.type) {
2079
2080 case QPainterPath::MoveToElement:
2081 if (i > 0
2082 && qFuzzyCompare(p1: last_pt.x(), p2: last_start.x())
2083 && qFuzzyCompare(p1: last_pt.y(), p2: last_start.y())
2084 && qt_painterpath_isect_line_rect(x1: last_pt.x(), y1: last_pt.y(),
2085 x2: last_start.x(), y2: last_start.y(), rect))
2086 return true;
2087 last_start = last_pt = e;
2088 break;
2089
2090 case QPainterPath::LineToElement:
2091 if (qt_painterpath_isect_line_rect(x1: last_pt.x(), y1: last_pt.y(), x2: e.x, y2: e.y, rect))
2092 return true;
2093 last_pt = e;
2094 break;
2095
2096 case QPainterPath::CurveToElement:
2097 {
2098 QPointF cp2 = path->elementAt(i: ++i);
2099 QPointF ep = path->elementAt(i: ++i);
2100 QBezier bezier = QBezier::fromPoints(p1: last_pt, p2: e, p3: cp2, p4: ep);
2101 if (qt_isect_curve_horizontal(bezier, y: rect.top(), x1: rect.left(), x2: rect.right())
2102 || qt_isect_curve_horizontal(bezier, y: rect.bottom(), x1: rect.left(), x2: rect.right())
2103 || qt_isect_curve_vertical(bezier, x: rect.left(), y1: rect.top(), y2: rect.bottom())
2104 || qt_isect_curve_vertical(bezier, x: rect.right(), y1: rect.top(), y2: rect.bottom()))
2105 return true;
2106 last_pt = ep;
2107 }
2108 break;
2109
2110 default:
2111 break;
2112 }
2113 // Handle crossing the edges of the rect at the end-points of individual sub-paths.
2114 // A point on on the edge itself is considered neither inside nor outside for this purpose.
2115 if (!pointOnEdge(rect, point: last_pt)) {
2116 bool contained = rect.contains(p: last_pt);
2117 switch (edgeStatus) {
2118 case OutsideRect:
2119 if (contained)
2120 return true;
2121 break;
2122 case InsideRect:
2123 if (!contained)
2124 return true;
2125 break;
2126 case OnRect:
2127 edgeStatus = contained ? InsideRect : OutsideRect;
2128 break;
2129 }
2130 } else {
2131 if (last_pt == last_start)
2132 edgeStatus = OnRect;
2133 }
2134 }
2135
2136 // implicitly close last subpath
2137 if (last_pt != last_start
2138 && qt_painterpath_isect_line_rect(x1: last_pt.x(), y1: last_pt.y(),
2139 x2: last_start.x(), y2: last_start.y(), rect))
2140 return true;
2141
2142 return false;
2143}
2144
2145/*!
2146 \fn bool QPainterPath::intersects(const QRectF &rectangle) const
2147
2148 Returns \c true if any point in the given \a rectangle intersects the
2149 path; otherwise returns \c false.
2150
2151 There is an intersection if any of the lines making up the
2152 rectangle crosses a part of the path or if any part of the
2153 rectangle overlaps with any area enclosed by the path. This
2154 function respects the current fillRule to determine what is
2155 considered inside the path.
2156
2157 \sa contains()
2158*/
2159bool QPainterPath::intersects(const QRectF &rect) const
2160{
2161 if (elementCount() == 1 && rect.contains(p: elementAt(i: 0)))
2162 return true;
2163
2164 if (isEmpty())
2165 return false;
2166
2167 QRectF cp = controlPointRect();
2168 QRectF rn = rect.normalized();
2169
2170 // QRectF::intersects returns false if one of the rects is a null rect
2171 // which would happen for a painter path consisting of a vertical or
2172 // horizontal line
2173 if (qMax(a: rn.left(), b: cp.left()) > qMin(a: rn.right(), b: cp.right())
2174 || qMax(a: rn.top(), b: cp.top()) > qMin(a: rn.bottom(), b: cp.bottom()))
2175 return false;
2176
2177 // If any path element cross the rect its bound to be an intersection
2178 if (qt_painterpath_check_crossing(path: this, rect))
2179 return true;
2180
2181 if (contains(pt: rect.center()))
2182 return true;
2183
2184 Q_D(QPainterPath);
2185
2186 // Check if the rectangle surounds any subpath...
2187 for (int i=0; i<d->elements.size(); ++i) {
2188 const Element &e = d->elements.at(i);
2189 if (e.type == QPainterPath::MoveToElement && rect.contains(p: e))
2190 return true;
2191 }
2192
2193 return false;
2194}
2195
2196/*!
2197 Translates all elements in the path by (\a{dx}, \a{dy}).
2198
2199 \since 4.6
2200 \sa translated()
2201*/
2202void QPainterPath::translate(qreal dx, qreal dy)
2203{
2204 if (!d_ptr || (dx == 0 && dy == 0))
2205 return;
2206
2207 int elementsLeft = d_ptr->elements.size();
2208 if (elementsLeft <= 0)
2209 return;
2210
2211 detach();
2212 QPainterPath::Element *element = d_func()->elements.data();
2213 Q_ASSERT(element);
2214 while (elementsLeft--) {
2215 element->x += dx;
2216 element->y += dy;
2217 ++element;
2218 }
2219}
2220
2221/*!
2222 \fn void QPainterPath::translate(const QPointF &offset)
2223 \overload
2224 \since 4.6
2225
2226 Translates all elements in the path by the given \a offset.
2227
2228 \sa translated()
2229*/
2230
2231/*!
2232 Returns a copy of the path that is translated by (\a{dx}, \a{dy}).
2233
2234 \since 4.6
2235 \sa translate()
2236*/
2237QPainterPath QPainterPath::translated(qreal dx, qreal dy) const
2238{
2239 QPainterPath copy(*this);
2240 copy.translate(dx, dy);
2241 return copy;
2242}
2243
2244/*!
2245 \fn QPainterPath QPainterPath::translated(const QPointF &offset) const;
2246 \overload
2247 \since 4.6
2248
2249 Returns a copy of the path that is translated by the given \a offset.
2250
2251 \sa translate()
2252*/
2253
2254/*!
2255 \fn bool QPainterPath::contains(const QRectF &rectangle) const
2256
2257 Returns \c true if the given \a rectangle is inside the path,
2258 otherwise returns \c false.
2259*/
2260bool QPainterPath::contains(const QRectF &rect) const
2261{
2262 Q_D(QPainterPath);
2263
2264 // the path is empty or the control point rect doesn't completely
2265 // cover the rectangle we abort stratight away.
2266 if (isEmpty() || !controlPointRect().contains(r: rect))
2267 return false;
2268
2269 // if there are intersections, chances are that the rect is not
2270 // contained, except if we have winding rule, in which case it
2271 // still might.
2272 if (qt_painterpath_check_crossing(path: this, rect)) {
2273 if (fillRule() == Qt::OddEvenFill) {
2274 return false;
2275 } else {
2276 // Do some wague sampling in the winding case. This is not
2277 // precise but it should mostly be good enough.
2278 if (!contains(pt: rect.topLeft()) ||
2279 !contains(pt: rect.topRight()) ||
2280 !contains(pt: rect.bottomRight()) ||
2281 !contains(pt: rect.bottomLeft()))
2282 return false;
2283 }
2284 }
2285
2286 // If there exists a point inside that is not part of the path its
2287 // because: rectangle lies completely outside path or a subpath
2288 // excludes parts of the rectangle. Both cases mean that the rect
2289 // is not contained
2290 if (!contains(pt: rect.center()))
2291 return false;
2292
2293 // If there are any subpaths inside this rectangle we need to
2294 // check if they are still contained as a result of the fill
2295 // rule. This can only be the case for WindingFill though. For
2296 // OddEvenFill the rect will never be contained if it surrounds a
2297 // subpath. (the case where two subpaths are completely identical
2298 // can be argued but we choose to neglect it).
2299 for (int i=0; i<d->elements.size(); ++i) {
2300 const Element &e = d->elements.at(i);
2301 if (e.type == QPainterPath::MoveToElement && rect.contains(p: e)) {
2302 if (fillRule() == Qt::OddEvenFill)
2303 return false;
2304
2305 bool stop = false;
2306 for (; !stop && i<d->elements.size(); ++i) {
2307 const Element &el = d->elements.at(i);
2308 switch (el.type) {
2309 case MoveToElement:
2310 stop = true;
2311 break;
2312 case LineToElement:
2313 if (!contains(pt: el))
2314 return false;
2315 break;
2316 case CurveToElement:
2317 if (!contains(pt: d->elements.at(i: i+2)))
2318 return false;
2319 i += 2;
2320 break;
2321 default:
2322 break;
2323 }
2324 }
2325
2326 // compensate for the last ++i in the inner for
2327 --i;
2328 }
2329 }
2330
2331 return true;
2332}
2333
2334static inline bool epsilonCompare(const QPointF &a, const QPointF &b, const QSizeF &epsilon)
2335{
2336 return qAbs(t: a.x() - b.x()) <= epsilon.width()
2337 && qAbs(t: a.y() - b.y()) <= epsilon.height();
2338}
2339
2340/*!
2341 Returns \c true if this painterpath is equal to the given \a path.
2342
2343 Note that comparing paths may involve a per element comparison
2344 which can be slow for complex paths.
2345
2346 \sa operator!=()
2347*/
2348
2349bool QPainterPath::operator==(const QPainterPath &path) const
2350{
2351 QPainterPathData *d = reinterpret_cast<QPainterPathData *>(d_func());
2352 QPainterPathData *other_d = path.d_func();
2353 if (other_d == d) {
2354 return true;
2355 } else if (!d || !other_d) {
2356 if (!other_d && isEmpty() && elementAt(i: 0) == QPointF() && d->fillRule == Qt::OddEvenFill)
2357 return true;
2358 if (!d && path.isEmpty() && path.elementAt(i: 0) == QPointF() && other_d->fillRule == Qt::OddEvenFill)
2359 return true;
2360 return false;
2361 }
2362 else if (d->fillRule != other_d->fillRule)
2363 return false;
2364 else if (d->elements.size() != other_d->elements.size())
2365 return false;
2366
2367 const qreal qt_epsilon = sizeof(qreal) == sizeof(double) ? 1e-12 : qreal(1e-5);
2368
2369 QSizeF epsilon = boundingRect().size();
2370 epsilon.rwidth() *= qt_epsilon;
2371 epsilon.rheight() *= qt_epsilon;
2372
2373 for (int i = 0; i < d->elements.size(); ++i)
2374 if (d->elements.at(i).type != other_d->elements.at(i).type
2375 || !epsilonCompare(a: d->elements.at(i), b: other_d->elements.at(i), epsilon))
2376 return false;
2377
2378 return true;
2379}
2380
2381/*!
2382 Returns \c true if this painter path differs from the given \a path.
2383
2384 Note that comparing paths may involve a per element comparison
2385 which can be slow for complex paths.
2386
2387 \sa operator==()
2388*/
2389
2390bool QPainterPath::operator!=(const QPainterPath &path) const
2391{
2392 return !(*this==path);
2393}
2394
2395/*!
2396 \since 4.5
2397
2398 Returns the intersection of this path and the \a other path.
2399
2400 \sa intersected(), operator&=(), united(), operator|()
2401*/
2402QPainterPath QPainterPath::operator&(const QPainterPath &other) const
2403{
2404 return intersected(r: other);
2405}
2406
2407/*!
2408 \since 4.5
2409
2410 Returns the union of this path and the \a other path.
2411
2412 \sa united(), operator|=(), intersected(), operator&()
2413*/
2414QPainterPath QPainterPath::operator|(const QPainterPath &other) const
2415{
2416 return united(r: other);
2417}
2418
2419/*!
2420 \since 4.5
2421
2422 Returns the union of this path and the \a other path. This function is equivalent
2423 to operator|().
2424
2425 \sa united(), operator+=(), operator-()
2426*/
2427QPainterPath QPainterPath::operator+(const QPainterPath &other) const
2428{
2429 return united(r: other);
2430}
2431
2432/*!
2433 \since 4.5
2434
2435 Subtracts the \a other path from a copy of this path, and returns the copy.
2436
2437 \sa subtracted(), operator-=(), operator+()
2438*/
2439QPainterPath QPainterPath::operator-(const QPainterPath &other) const
2440{
2441 return subtracted(r: other);
2442}
2443
2444/*!
2445 \since 4.5
2446
2447 Intersects this path with \a other and returns a reference to this path.
2448
2449 \sa intersected(), operator&(), operator|=()
2450*/
2451QPainterPath &QPainterPath::operator&=(const QPainterPath &other)
2452{
2453 return *this = (*this & other);
2454}
2455
2456/*!
2457 \since 4.5
2458
2459 Unites this path with \a other and returns a reference to this path.
2460
2461 \sa united(), operator|(), operator&=()
2462*/
2463QPainterPath &QPainterPath::operator|=(const QPainterPath &other)
2464{
2465 return *this = (*this | other);
2466}
2467
2468/*!
2469 \since 4.5
2470
2471 Unites this path with \a other, and returns a reference to this path. This
2472 is equivalent to operator|=().
2473
2474 \sa united(), operator+(), operator-=()
2475*/
2476QPainterPath &QPainterPath::operator+=(const QPainterPath &other)
2477{
2478 return *this = (*this + other);
2479}
2480
2481/*!
2482 \since 4.5
2483
2484 Subtracts \a other from this path, and returns a reference to this
2485 path.
2486
2487 \sa subtracted(), operator-(), operator+=()
2488*/
2489QPainterPath &QPainterPath::operator-=(const QPainterPath &other)
2490{
2491 return *this = (*this - other);
2492}
2493
2494#ifndef QT_NO_DATASTREAM
2495/*!
2496 \fn QDataStream &operator<<(QDataStream &stream, const QPainterPath &path)
2497 \relates QPainterPath
2498
2499 Writes the given painter \a path to the given \a stream, and
2500 returns a reference to the \a stream.
2501
2502 \sa {Serializing Qt Data Types}
2503*/
2504QDataStream &operator<<(QDataStream &s, const QPainterPath &p)
2505{
2506 if (p.isEmpty()) {
2507 s << 0;
2508 return s;
2509 }
2510
2511 s << p.elementCount();
2512 for (int i=0; i < p.d_func()->elements.size(); ++i) {
2513 const QPainterPath::Element &e = p.d_func()->elements.at(i);
2514 s << int(e.type);
2515 s << double(e.x) << double(e.y);
2516 }
2517 s << p.d_func()->cStart;
2518 s << int(p.d_func()->fillRule);
2519 return s;
2520}
2521
2522/*!
2523 \fn QDataStream &operator>>(QDataStream &stream, QPainterPath &path)
2524 \relates QPainterPath
2525
2526 Reads a painter path from the given \a stream into the specified \a path,
2527 and returns a reference to the \a stream.
2528
2529 \sa {Serializing Qt Data Types}
2530*/
2531QDataStream &operator>>(QDataStream &s, QPainterPath &p)
2532{
2533 bool errorDetected = false;
2534 int size;
2535 s >> size;
2536
2537 if (size == 0)
2538 return s;
2539
2540 p.ensureData(); // in case if p.d_func() == 0
2541 if (p.d_func()->elements.size() == 1) {
2542 Q_ASSERT(p.d_func()->elements.at(0).type == QPainterPath::MoveToElement);
2543 p.d_func()->elements.clear();
2544 }
2545 for (int i=0; i<size; ++i) {
2546 int type;
2547 double x, y;
2548 s >> type;
2549 s >> x;
2550 s >> y;
2551 Q_ASSERT(type >= 0 && type <= 3);
2552 if (!isValidCoord(c: qreal(x)) || !isValidCoord(c: qreal(y))) {
2553#ifndef QT_NO_DEBUG
2554 qWarning(msg: "QDataStream::operator>>: Invalid QPainterPath coordinates read, skipping it");
2555#endif
2556 errorDetected = true;
2557 continue;
2558 }
2559 QPainterPath::Element elm = { .x: qreal(x), .y: qreal(y), .type: QPainterPath::ElementType(type) };
2560 p.d_func()->elements.append(t: elm);
2561 }
2562 s >> p.d_func()->cStart;
2563 int fillRule;
2564 s >> fillRule;
2565 Q_ASSERT(fillRule == Qt::OddEvenFill || fillRule == Qt::WindingFill);
2566 p.d_func()->fillRule = Qt::FillRule(fillRule);
2567 p.d_func()->dirtyBounds = true;
2568 p.d_func()->dirtyControlBounds = true;
2569 if (errorDetected)
2570 p = QPainterPath(); // Better than to return path with possibly corrupt datastructure, which would likely cause crash
2571 return s;
2572}
2573#endif // QT_NO_DATASTREAM
2574
2575
2576/*******************************************************************************
2577 * class QPainterPathStroker
2578 */
2579
2580void qt_path_stroke_move_to(qfixed x, qfixed y, void *data)
2581{
2582 ((QPainterPath *) data)->moveTo(qt_fixed_to_real(x), qt_fixed_to_real(y));
2583}
2584
2585void qt_path_stroke_line_to(qfixed x, qfixed y, void *data)
2586{
2587 ((QPainterPath *) data)->lineTo(qt_fixed_to_real(x), qt_fixed_to_real(y));
2588}
2589
2590void qt_path_stroke_cubic_to(qfixed c1x, qfixed c1y,
2591 qfixed c2x, qfixed c2y,
2592 qfixed ex, qfixed ey,
2593 void *data)
2594{
2595 ((QPainterPath *) data)->cubicTo(qt_fixed_to_real(c1x), qt_fixed_to_real(c1y),
2596 qt_fixed_to_real(c2x), qt_fixed_to_real(c2y),
2597 qt_fixed_to_real(ex), qt_fixed_to_real(ey));
2598}
2599
2600/*!
2601 \since 4.1
2602 \class QPainterPathStroker
2603 \ingroup painting
2604 \inmodule QtGui
2605
2606 \brief The QPainterPathStroker class is used to generate fillable
2607 outlines for a given painter path.
2608
2609 By calling the createStroke() function, passing a given
2610 QPainterPath as argument, a new painter path representing the
2611 outline of the given path is created. The newly created painter
2612 path can then be filled to draw the original painter path's
2613 outline.
2614
2615 You can control the various design aspects (width, cap styles,
2616 join styles and dash pattern) of the outlining using the following
2617 functions:
2618
2619 \list
2620 \li setWidth()
2621 \li setCapStyle()
2622 \li setJoinStyle()
2623 \li setDashPattern()
2624 \endlist
2625
2626 The setDashPattern() function accepts both a Qt::PenStyle object
2627 and a vector representation of the pattern as argument.
2628
2629 In addition you can specify a curve's threshold, controlling the
2630 granularity with which a curve is drawn, using the
2631 setCurveThreshold() function. The default threshold is a well
2632 adjusted value (0.25), and normally you should not need to modify
2633 it. However, you can make the curve's appearance smoother by
2634 decreasing its value.
2635
2636 You can also control the miter limit for the generated outline
2637 using the setMiterLimit() function. The miter limit describes how
2638 far from each join the miter join can extend. The limit is
2639 specified in the units of width so the pixelwise miter limit will
2640 be \c {miterlimit * width}. This value is only used if the join
2641 style is Qt::MiterJoin.
2642
2643 The painter path generated by the createStroke() function should
2644 only be used for outlining the given painter path. Otherwise it
2645 may cause unexpected behavior. Generated outlines also require the
2646 Qt::WindingFill rule which is set by default.
2647
2648 \sa QPen, QBrush
2649*/
2650
2651QPainterPathStrokerPrivate::QPainterPathStrokerPrivate()
2652 : dashOffset(0)
2653{
2654 stroker.setMoveToHook(qt_path_stroke_move_to);
2655 stroker.setLineToHook(qt_path_stroke_line_to);
2656 stroker.setCubicToHook(qt_path_stroke_cubic_to);
2657}
2658
2659/*!
2660 Creates a new stroker.
2661 */
2662QPainterPathStroker::QPainterPathStroker()
2663 : d_ptr(new QPainterPathStrokerPrivate)
2664{
2665}
2666
2667/*!
2668 Creates a new stroker based on \a pen.
2669
2670 \since 5.3
2671 */
2672QPainterPathStroker::QPainterPathStroker(const QPen &pen)
2673 : d_ptr(new QPainterPathStrokerPrivate)
2674{
2675 setWidth(pen.widthF());
2676 setCapStyle(pen.capStyle());
2677 setJoinStyle(pen.joinStyle());
2678 setMiterLimit(pen.miterLimit());
2679 setDashOffset(pen.dashOffset());
2680
2681 if (pen.style() == Qt::CustomDashLine)
2682 setDashPattern(pen.dashPattern());
2683 else
2684 setDashPattern(pen.style());
2685}
2686
2687/*!
2688 Destroys the stroker.
2689*/
2690QPainterPathStroker::~QPainterPathStroker()
2691{
2692}
2693
2694
2695/*!
2696 Generates a new path that is a fillable area representing the
2697 outline of the given \a path.
2698
2699 The various design aspects of the outline are based on the
2700 stroker's properties: width(), capStyle(), joinStyle(),
2701 dashPattern(), curveThreshold() and miterLimit().
2702
2703 The generated path should only be used for outlining the given
2704 painter path. Otherwise it may cause unexpected
2705 behavior. Generated outlines also require the Qt::WindingFill rule
2706 which is set by default.
2707*/
2708QPainterPath QPainterPathStroker::createStroke(const QPainterPath &path) const
2709{
2710 QPainterPathStrokerPrivate *d = const_cast<QPainterPathStrokerPrivate *>(d_func());
2711 QPainterPath stroke;
2712 if (path.isEmpty())
2713 return path;
2714 if (d->dashPattern.isEmpty()) {
2715 d->stroker.strokePath(path, data: &stroke, matrix: QTransform());
2716 } else {
2717 QDashStroker dashStroker(&d->stroker);
2718 dashStroker.setDashPattern(d->dashPattern);
2719 dashStroker.setDashOffset(d->dashOffset);
2720 dashStroker.setClipRect(d->stroker.clipRect());
2721 dashStroker.strokePath(path, data: &stroke, matrix: QTransform());
2722 }
2723 stroke.setFillRule(Qt::WindingFill);
2724 return stroke;
2725}
2726
2727/*!
2728 Sets the width of the generated outline painter path to \a width.
2729
2730 The generated outlines will extend approximately 50% of \a width
2731 to each side of the given input path's original outline.
2732*/
2733void QPainterPathStroker::setWidth(qreal width)
2734{
2735 Q_D(QPainterPathStroker);
2736 if (width <= 0)
2737 width = 1;
2738 d->stroker.setStrokeWidth(qt_real_to_fixed(width));
2739}
2740
2741/*!
2742 Returns the width of the generated outlines.
2743*/
2744qreal QPainterPathStroker::width() const
2745{
2746 return qt_fixed_to_real(d_func()->stroker.strokeWidth());
2747}
2748
2749
2750/*!
2751 Sets the cap style of the generated outlines to \a style. If a
2752 dash pattern is set, each segment of the pattern is subject to the
2753 cap \a style.
2754*/
2755void QPainterPathStroker::setCapStyle(Qt::PenCapStyle style)
2756{
2757 d_func()->stroker.setCapStyle(style);
2758}
2759
2760
2761/*!
2762 Returns the cap style of the generated outlines.
2763*/
2764Qt::PenCapStyle QPainterPathStroker::capStyle() const
2765{
2766 return d_func()->stroker.capStyle();
2767}
2768
2769/*!
2770 Sets the join style of the generated outlines to \a style.
2771*/
2772void QPainterPathStroker::setJoinStyle(Qt::PenJoinStyle style)
2773{
2774 d_func()->stroker.setJoinStyle(style);
2775}
2776
2777/*!
2778 Returns the join style of the generated outlines.
2779*/
2780Qt::PenJoinStyle QPainterPathStroker::joinStyle() const
2781{
2782 return d_func()->stroker.joinStyle();
2783}
2784
2785/*!
2786 Sets the miter limit of the generated outlines to \a limit.
2787
2788 The miter limit describes how far from each join the miter join
2789 can extend. The limit is specified in units of the currently set
2790 width. So the pixelwise miter limit will be \c { miterlimit *
2791 width}.
2792
2793 This value is only used if the join style is Qt::MiterJoin.
2794*/
2795void QPainterPathStroker::setMiterLimit(qreal limit)
2796{
2797 d_func()->stroker.setMiterLimit(qt_real_to_fixed(limit));
2798}
2799
2800/*!
2801 Returns the miter limit for the generated outlines.
2802*/
2803qreal QPainterPathStroker::miterLimit() const
2804{
2805 return qt_fixed_to_real(d_func()->stroker.miterLimit());
2806}
2807
2808
2809/*!
2810 Specifies the curve flattening \a threshold, controlling the
2811 granularity with which the generated outlines' curve is drawn.
2812
2813 The default threshold is a well adjusted value (0.25), and
2814 normally you should not need to modify it. However, you can make
2815 the curve's appearance smoother by decreasing its value.
2816*/
2817void QPainterPathStroker::setCurveThreshold(qreal threshold)
2818{
2819 d_func()->stroker.setCurveThreshold(qt_real_to_fixed(threshold));
2820}
2821
2822/*!
2823 Returns the curve flattening threshold for the generated
2824 outlines.
2825*/
2826qreal QPainterPathStroker::curveThreshold() const
2827{
2828 return qt_fixed_to_real(d_func()->stroker.curveThreshold());
2829}
2830
2831/*!
2832 Sets the dash pattern for the generated outlines to \a style.
2833*/
2834void QPainterPathStroker::setDashPattern(Qt::PenStyle style)
2835{
2836 d_func()->dashPattern = QDashStroker::patternForStyle(style);
2837}
2838
2839/*!
2840 \overload
2841
2842 Sets the dash pattern for the generated outlines to \a
2843 dashPattern. This function makes it possible to specify custom
2844 dash patterns.
2845
2846 Each element in the vector contains the lengths of the dashes and spaces
2847 in the stroke, beginning with the first dash in the first element, the
2848 first space in the second element, and alternating between dashes and
2849 spaces for each following pair of elements.
2850
2851 The vector can contain an odd number of elements, in which case the last
2852 element will be extended by the length of the first element when the
2853 pattern repeats.
2854*/
2855void QPainterPathStroker::setDashPattern(const QVector<qreal> &dashPattern)
2856{
2857 d_func()->dashPattern.clear();
2858 for (int i=0; i<dashPattern.size(); ++i)
2859 d_func()->dashPattern << qt_real_to_fixed(dashPattern.at(i));
2860}
2861
2862/*!
2863 Returns the dash pattern for the generated outlines.
2864*/
2865QVector<qreal> QPainterPathStroker::dashPattern() const
2866{
2867 return d_func()->dashPattern;
2868}
2869
2870/*!
2871 Returns the dash offset for the generated outlines.
2872 */
2873qreal QPainterPathStroker::dashOffset() const
2874{
2875 return d_func()->dashOffset;
2876}
2877
2878/*!
2879 Sets the dash offset for the generated outlines to \a offset.
2880
2881 See the documentation for QPen::setDashOffset() for a description of the
2882 dash offset.
2883 */
2884void QPainterPathStroker::setDashOffset(qreal offset)
2885{
2886 d_func()->dashOffset = offset;
2887}
2888
2889/*!
2890 Converts the path into a polygon using the QTransform
2891 \a matrix, and returns the polygon.
2892
2893 The polygon is created by first converting all subpaths to
2894 polygons, then using a rewinding technique to make sure that
2895 overlapping subpaths can be filled using the correct fill rule.
2896
2897 Note that rewinding inserts addition lines in the polygon so
2898 the outline of the fill polygon does not match the outline of
2899 the path.
2900
2901 \sa toSubpathPolygons(), toFillPolygons(),
2902 {QPainterPath#QPainterPath Conversion}{QPainterPath Conversion}
2903*/
2904QPolygonF QPainterPath::toFillPolygon(const QTransform &matrix) const
2905{
2906
2907 const QList<QPolygonF> flats = toSubpathPolygons(matrix);
2908 QPolygonF polygon;
2909 if (flats.isEmpty())
2910 return polygon;
2911 QPointF first = flats.first().first();
2912 for (int i=0; i<flats.size(); ++i) {
2913 polygon += flats.at(i);
2914 if (!flats.at(i).isClosed())
2915 polygon += flats.at(i).first();
2916 if (i > 0)
2917 polygon += first;
2918 }
2919 return polygon;
2920}
2921
2922#if QT_DEPRECATED_SINCE(5, 15)
2923/*!
2924 \overload
2925 \obsolete
2926
2927 Use toFillPolygon(const QTransform &matrix) instead.
2928*/
2929QPolygonF QPainterPath::toFillPolygon(const QMatrix &matrix) const
2930{
2931 return toFillPolygon(matrix: QTransform(matrix));
2932}
2933#endif // QT_DEPRECATED_SINCE(5, 15)
2934
2935//derivative of the equation
2936static inline qreal slopeAt(qreal t, qreal a, qreal b, qreal c, qreal d)
2937{
2938 return 3*t*t*(d - 3*c + 3*b - a) + 6*t*(c - 2*b + a) + 3*(b - a);
2939}
2940
2941/*!
2942 Returns the length of the current path.
2943*/
2944qreal QPainterPath::length() const
2945{
2946 Q_D(QPainterPath);
2947 if (isEmpty())
2948 return 0;
2949
2950 qreal len = 0;
2951 for (int i=1; i<d->elements.size(); ++i) {
2952 const Element &e = d->elements.at(i);
2953
2954 switch (e.type) {
2955 case MoveToElement:
2956 break;
2957 case LineToElement:
2958 {
2959 len += QLineF(d->elements.at(i: i-1), e).length();
2960 break;
2961 }
2962 case CurveToElement:
2963 {
2964 QBezier b = QBezier::fromPoints(p1: d->elements.at(i: i-1),
2965 p2: e,
2966 p3: d->elements.at(i: i+1),
2967 p4: d->elements.at(i: i+2));
2968 len += b.length();
2969 i += 2;
2970 break;
2971 }
2972 default:
2973 break;
2974 }
2975 }
2976 return len;
2977}
2978
2979/*!
2980 Returns percentage of the whole path at the specified length \a len.
2981
2982 Note that similarly to other percent methods, the percentage measurement
2983 is not linear with regards to the length, if curves are present
2984 in the path. When curves are present the percentage argument is mapped
2985 to the t parameter of the Bezier equations.
2986*/
2987qreal QPainterPath::percentAtLength(qreal len) const
2988{
2989 Q_D(QPainterPath);
2990 if (isEmpty() || len <= 0)
2991 return 0;
2992
2993 qreal totalLength = length();
2994 if (len > totalLength)
2995 return 1;
2996
2997 qreal curLen = 0;
2998 for (int i=1; i<d->elements.size(); ++i) {
2999 const Element &e = d->elements.at(i);
3000
3001 switch (e.type) {
3002 case MoveToElement:
3003 break;
3004 case LineToElement:
3005 {
3006 QLineF line(d->elements.at(i: i-1), e);
3007 qreal llen = line.length();
3008 curLen += llen;
3009 if (curLen >= len) {
3010 return len/totalLength ;
3011 }
3012
3013 break;
3014 }
3015 case CurveToElement:
3016 {
3017 QBezier b = QBezier::fromPoints(p1: d->elements.at(i: i-1),
3018 p2: e,
3019 p3: d->elements.at(i: i+1),
3020 p4: d->elements.at(i: i+2));
3021 qreal blen = b.length();
3022 qreal prevLen = curLen;
3023 curLen += blen;
3024
3025 if (curLen >= len) {
3026 qreal res = b.tAtLength(len: len - prevLen);
3027 return (res * blen + prevLen)/totalLength;
3028 }
3029
3030 i += 2;
3031 break;
3032 }
3033 default:
3034 break;
3035 }
3036 }
3037
3038 return 0;
3039}
3040
3041static inline QBezier bezierAtT(const QPainterPath &path, qreal t, qreal *startingLength, qreal *bezierLength)
3042{
3043 *startingLength = 0;
3044 if (t > 1)
3045 return QBezier();
3046
3047 qreal curLen = 0;
3048 qreal totalLength = path.length();
3049
3050 const int lastElement = path.elementCount() - 1;
3051 for (int i=0; i <= lastElement; ++i) {
3052 const QPainterPath::Element &e = path.elementAt(i);
3053
3054 switch (e.type) {
3055 case QPainterPath::MoveToElement:
3056 break;
3057 case QPainterPath::LineToElement:
3058 {
3059 QLineF line(path.elementAt(i: i-1), e);
3060 qreal llen = line.length();
3061 curLen += llen;
3062 if (i == lastElement || curLen/totalLength >= t) {
3063 *bezierLength = llen;
3064 QPointF a = path.elementAt(i: i-1);
3065 QPointF delta = e - a;
3066 return QBezier::fromPoints(p1: a, p2: a + delta / 3, p3: a + 2 * delta / 3, p4: e);
3067 }
3068 break;
3069 }
3070 case QPainterPath::CurveToElement:
3071 {
3072 QBezier b = QBezier::fromPoints(p1: path.elementAt(i: i-1),
3073 p2: e,
3074 p3: path.elementAt(i: i+1),
3075 p4: path.elementAt(i: i+2));
3076 qreal blen = b.length();
3077 curLen += blen;
3078
3079 if (i + 2 == lastElement || curLen/totalLength >= t) {
3080 *bezierLength = blen;
3081 return b;
3082 }
3083
3084 i += 2;
3085 break;
3086 }
3087 default:
3088 break;
3089 }
3090 *startingLength = curLen;
3091 }
3092 return QBezier();
3093}
3094
3095/*!
3096 Returns the point at at the percentage \a t of the current path.
3097 The argument \a t has to be between 0 and 1.
3098
3099 Note that similarly to other percent methods, the percentage measurement
3100 is not linear with regards to the length, if curves are present
3101 in the path. When curves are present the percentage argument is mapped
3102 to the t parameter of the Bezier equations.
3103*/
3104QPointF QPainterPath::pointAtPercent(qreal t) const
3105{
3106 if (t < 0 || t > 1) {
3107 qWarning(msg: "QPainterPath::pointAtPercent accepts only values between 0 and 1");
3108 return QPointF();
3109 }
3110
3111 if (!d_ptr || d_ptr->elements.size() == 0)
3112 return QPointF();
3113
3114 if (d_ptr->elements.size() == 1)
3115 return d_ptr->elements.at(i: 0);
3116
3117 qreal totalLength = length();
3118 qreal curLen = 0;
3119 qreal bezierLen = 0;
3120 QBezier b = bezierAtT(path: *this, t, startingLength: &curLen, bezierLength: &bezierLen);
3121 qreal realT = (totalLength * t - curLen) / bezierLen;
3122
3123 return b.pointAt(t: qBound(min: qreal(0), val: realT, max: qreal(1)));
3124}
3125
3126/*!
3127 Returns the angle of the path tangent at the percentage \a t.
3128 The argument \a t has to be between 0 and 1.
3129
3130 Positive values for the angles mean counter-clockwise while negative values
3131 mean the clockwise direction. Zero degrees is at the 3 o'clock position.
3132
3133 Note that similarly to the other percent methods, the percentage measurement
3134 is not linear with regards to the length if curves are present
3135 in the path. When curves are present the percentage argument is mapped
3136 to the t parameter of the Bezier equations.
3137*/
3138qreal QPainterPath::angleAtPercent(qreal t) const
3139{
3140 if (t < 0 || t > 1) {
3141 qWarning(msg: "QPainterPath::angleAtPercent accepts only values between 0 and 1");
3142 return 0;
3143 }
3144
3145 qreal totalLength = length();
3146 qreal curLen = 0;
3147 qreal bezierLen = 0;
3148 QBezier bez = bezierAtT(path: *this, t, startingLength: &curLen, bezierLength: &bezierLen);
3149 qreal realT = (totalLength * t - curLen) / bezierLen;
3150
3151 qreal m1 = slopeAt(t: realT, a: bez.x1, b: bez.x2, c: bez.x3, d: bez.x4);
3152 qreal m2 = slopeAt(t: realT, a: bez.y1, b: bez.y2, c: bez.y3, d: bez.y4);
3153
3154 return QLineF(0, 0, m1, m2).angle();
3155}
3156
3157
3158/*!
3159 Returns the slope of the path at the percentage \a t. The
3160 argument \a t has to be between 0 and 1.
3161
3162 Note that similarly to other percent methods, the percentage measurement
3163 is not linear with regards to the length, if curves are present
3164 in the path. When curves are present the percentage argument is mapped
3165 to the t parameter of the Bezier equations.
3166*/
3167qreal QPainterPath::slopeAtPercent(qreal t) const
3168{
3169 if (t < 0 || t > 1) {
3170 qWarning(msg: "QPainterPath::slopeAtPercent accepts only values between 0 and 1");
3171 return 0;
3172 }
3173
3174 qreal totalLength = length();
3175 qreal curLen = 0;
3176 qreal bezierLen = 0;
3177 QBezier bez = bezierAtT(path: *this, t, startingLength: &curLen, bezierLength: &bezierLen);
3178 qreal realT = (totalLength * t - curLen) / bezierLen;
3179
3180 qreal m1 = slopeAt(t: realT, a: bez.x1, b: bez.x2, c: bez.x3, d: bez.x4);
3181 qreal m2 = slopeAt(t: realT, a: bez.y1, b: bez.y2, c: bez.y3, d: bez.y4);
3182 //tangent line
3183 qreal slope = 0;
3184
3185 if (m1)
3186 slope = m2/m1;
3187 else {
3188 if (std::numeric_limits<qreal>::has_infinity) {
3189 slope = (m2 < 0) ? -std::numeric_limits<qreal>::infinity()
3190 : std::numeric_limits<qreal>::infinity();
3191 } else {
3192 if (sizeof(qreal) == sizeof(double)) {
3193 return 1.79769313486231570e+308;
3194 } else {
3195 return ((qreal)3.40282346638528860e+38);
3196 }
3197 }
3198 }
3199
3200 return slope;
3201}
3202
3203/*!
3204 \since 4.4
3205
3206 Adds the given rectangle \a rect with rounded corners to the path.
3207
3208 The \a xRadius and \a yRadius arguments specify the radii of
3209 the ellipses defining the corners of the rounded rectangle.
3210 When \a mode is Qt::RelativeSize, \a xRadius and
3211 \a yRadius are specified in percentage of half the rectangle's
3212 width and height respectively, and should be in the range 0.0 to 100.0.
3213
3214 \sa addRect()
3215*/
3216void QPainterPath::addRoundedRect(const QRectF &rect, qreal xRadius, qreal yRadius,
3217 Qt::SizeMode mode)
3218{
3219 QRectF r = rect.normalized();
3220
3221 if (r.isNull())
3222 return;
3223
3224 if (mode == Qt::AbsoluteSize) {
3225 qreal w = r.width() / 2;
3226 qreal h = r.height() / 2;
3227
3228 if (w == 0) {
3229 xRadius = 0;
3230 } else {
3231 xRadius = 100 * qMin(a: xRadius, b: w) / w;
3232 }
3233 if (h == 0) {
3234 yRadius = 0;
3235 } else {
3236 yRadius = 100 * qMin(a: yRadius, b: h) / h;
3237 }
3238 } else {
3239 if (xRadius > 100) // fix ranges
3240 xRadius = 100;
3241
3242 if (yRadius > 100)
3243 yRadius = 100;
3244 }
3245
3246 if (xRadius <= 0 || yRadius <= 0) { // add normal rectangle
3247 addRect(r);
3248 return;
3249 }
3250
3251 qreal x = r.x();
3252 qreal y = r.y();
3253 qreal w = r.width();
3254 qreal h = r.height();
3255 qreal rxx2 = w*xRadius/100;
3256 qreal ryy2 = h*yRadius/100;
3257
3258 ensureData();
3259 detach();
3260
3261 bool first = d_func()->elements.size() < 2;
3262
3263 arcMoveTo(x, y, w: rxx2, h: ryy2, angle: 180);
3264 arcTo(x, y, w: rxx2, h: ryy2, startAngle: 180, arcLength: -90);
3265 arcTo(x: x+w-rxx2, y, w: rxx2, h: ryy2, startAngle: 90, arcLength: -90);
3266 arcTo(x: x+w-rxx2, y: y+h-ryy2, w: rxx2, h: ryy2, startAngle: 0, arcLength: -90);
3267 arcTo(x, y: y+h-ryy2, w: rxx2, h: ryy2, startAngle: 270, arcLength: -90);
3268 closeSubpath();
3269
3270 d_func()->require_moveTo = true;
3271 d_func()->convex = first;
3272}
3273
3274/*!
3275 \fn void QPainterPath::addRoundedRect(qreal x, qreal y, qreal w, qreal h, qreal xRadius, qreal yRadius, Qt::SizeMode mode = Qt::AbsoluteSize);
3276 \since 4.4
3277 \overload
3278
3279 Adds the given rectangle \a x, \a y, \a w, \a h with rounded corners to the path.
3280 */
3281
3282#if QT_DEPRECATED_SINCE(5, 13)
3283/*!
3284 \obsolete
3285
3286 Adds a rectangle \a r with rounded corners to the path.
3287
3288 The \a xRnd and \a yRnd arguments specify how rounded the corners
3289 should be. 0 is angled corners, 99 is maximum roundedness.
3290
3291 \sa addRoundedRect()
3292*/
3293void QPainterPath::addRoundRect(const QRectF &r, int xRnd, int yRnd)
3294{
3295 if(xRnd >= 100) // fix ranges
3296 xRnd = 99;
3297 if(yRnd >= 100)
3298 yRnd = 99;
3299 if(xRnd <= 0 || yRnd <= 0) { // add normal rectangle
3300 addRect(r);
3301 return;
3302 }
3303
3304 QRectF rect = r.normalized();
3305
3306 if (rect.isNull())
3307 return;
3308
3309 qreal x = rect.x();
3310 qreal y = rect.y();
3311 qreal w = rect.width();
3312 qreal h = rect.height();
3313 qreal rxx2 = w*xRnd/100;
3314 qreal ryy2 = h*yRnd/100;
3315
3316 ensureData();
3317 detach();
3318
3319 bool first = d_func()->elements.size() < 2;
3320
3321 arcMoveTo(x, y, w: rxx2, h: ryy2, angle: 180);
3322 arcTo(x, y, w: rxx2, h: ryy2, startAngle: 180, arcLength: -90);
3323 arcTo(x: x+w-rxx2, y, w: rxx2, h: ryy2, startAngle: 90, arcLength: -90);
3324 arcTo(x: x+w-rxx2, y: y+h-ryy2, w: rxx2, h: ryy2, startAngle: 0, arcLength: -90);
3325 arcTo(x, y: y+h-ryy2, w: rxx2, h: ryy2, startAngle: 270, arcLength: -90);
3326 closeSubpath();
3327
3328 d_func()->require_moveTo = true;
3329 d_func()->convex = first;
3330}
3331
3332/*!
3333 \obsolete
3334
3335 \fn bool QPainterPath::addRoundRect(const QRectF &rect, int roundness);
3336 \since 4.3
3337 \overload
3338
3339 Adds a rounded rectangle, \a rect, to the path.
3340
3341 The \a roundness argument specifies uniform roundness for the
3342 rectangle. Vertical and horizontal roundness factors will be
3343 adjusted accordingly to act uniformly around both axes. Use this
3344 method if you want a rectangle equally rounded across both the X and
3345 Y axis.
3346
3347 \sa addRoundedRect()
3348*/
3349void QPainterPath::addRoundRect(const QRectF &rect,
3350 int roundness)
3351{
3352 int xRnd = roundness;
3353 int yRnd = roundness;
3354 if (rect.width() > rect.height())
3355 xRnd = int(roundness * rect.height()/rect.width());
3356 else
3357 yRnd = int(roundness * rect.width()/rect.height());
3358 addRoundedRect(rect, xRadius: xRnd, yRadius: yRnd, mode: Qt::RelativeSize);
3359}
3360
3361/*!
3362 \obsolete
3363
3364 \fn void QPainterPath::addRoundRect(qreal x, qreal y, qreal w, qreal h, int xRnd, int yRnd);
3365 \overload
3366
3367 Adds a rectangle with rounded corners to the path. The rectangle
3368 is constructed from \a x, \a y, and the width and height \a w
3369 and \a h.
3370
3371 The \a xRnd and \a yRnd arguments specify how rounded the corners
3372 should be. 0 is angled corners, 99 is maximum roundedness.
3373
3374 \sa addRoundedRect()
3375 */
3376void QPainterPath::addRoundRect(qreal x, qreal y, qreal w, qreal h,
3377 int xRnd, int yRnd)
3378{
3379 addRoundedRect(rect: QRectF(x, y, w, h), xRadius: xRnd, yRadius: yRnd, mode: Qt::RelativeSize);
3380}
3381
3382/*!
3383 \obsolete
3384
3385 \fn bool QPainterPath::addRoundRect(qreal x, qreal y, qreal width, qreal height, int roundness);
3386 \since 4.3
3387 \overload
3388
3389 Adds a rounded rectangle to the path, defined by the coordinates \a
3390 x and \a y with the specified \a width and \a height.
3391
3392 The \a roundness argument specifies uniform roundness for the
3393 rectangle. Vertical and horizontal roundness factors will be
3394 adjusted accordingly to act uniformly around both axes. Use this
3395 method if you want a rectangle equally rounded across both the X and
3396 Y axis.
3397
3398 \sa addRoundedRect()
3399*/
3400void QPainterPath::addRoundRect(qreal x, qreal y, qreal w, qreal h,
3401 int roundness)
3402{
3403 addRoundedRect(rect: QRectF(x, y, w, h), xRadius: roundness, yRadius: Qt::RelativeSize);
3404}
3405#endif
3406
3407/*!
3408 \since 4.3
3409
3410 Returns a path which is the union of this path's fill area and \a p's fill area.
3411
3412 Set operations on paths will treat the paths as areas. Non-closed
3413 paths will be treated as implicitly closed.
3414 Bezier curves may be flattened to line segments due to numerical instability of
3415 doing bezier curve intersections.
3416
3417 \sa intersected(), subtracted()
3418*/
3419QPainterPath QPainterPath::united(const QPainterPath &p) const
3420{
3421 if (isEmpty() || p.isEmpty())
3422 return isEmpty() ? p : *this;
3423 QPathClipper clipper(*this, p);
3424 return clipper.clip(op: QPathClipper::BoolOr);
3425}
3426
3427/*!
3428 \since 4.3
3429
3430 Returns a path which is the intersection of this path's fill area and \a p's fill area.
3431 Bezier curves may be flattened to line segments due to numerical instability of
3432 doing bezier curve intersections.
3433*/
3434QPainterPath QPainterPath::intersected(const QPainterPath &p) const
3435{
3436 if (isEmpty() || p.isEmpty())
3437 return QPainterPath();
3438 QPathClipper clipper(*this, p);
3439 return clipper.clip(op: QPathClipper::BoolAnd);
3440}
3441
3442/*!
3443 \since 4.3
3444
3445 Returns a path which is \a p's fill area subtracted from this path's fill area.
3446
3447 Set operations on paths will treat the paths as areas. Non-closed
3448 paths will be treated as implicitly closed.
3449 Bezier curves may be flattened to line segments due to numerical instability of
3450 doing bezier curve intersections.
3451*/
3452QPainterPath QPainterPath::subtracted(const QPainterPath &p) const
3453{
3454 if (isEmpty() || p.isEmpty())
3455 return *this;
3456 QPathClipper clipper(*this, p);
3457 return clipper.clip(op: QPathClipper::BoolSub);
3458}
3459
3460#if QT_DEPRECATED_SINCE(5, 13)
3461/*!
3462 \since 4.3
3463 \obsolete
3464
3465 Use subtracted() instead.
3466
3467 \sa subtracted()
3468*/
3469QPainterPath QPainterPath::subtractedInverted(const QPainterPath &p) const
3470{
3471 return p.subtracted(p: *this);
3472}
3473#endif
3474
3475/*!
3476 \since 4.4
3477
3478 Returns a simplified version of this path. This implies merging all subpaths that intersect,
3479 and returning a path containing no intersecting edges. Consecutive parallel lines will also
3480 be merged. The simplified path will always use the default fill rule, Qt::OddEvenFill.
3481 Bezier curves may be flattened to line segments due to numerical instability of
3482 doing bezier curve intersections.
3483*/
3484QPainterPath QPainterPath::simplified() const
3485{
3486 if(isEmpty())
3487 return *this;
3488 QPathClipper clipper(*this, QPainterPath());
3489 return clipper.clip(op: QPathClipper::Simplify);
3490}
3491
3492/*!
3493 \since 4.3
3494
3495 Returns \c true if the current path intersects at any point the given path \a p.
3496 Also returns \c true if the current path contains or is contained by any part of \a p.
3497
3498 Set operations on paths will treat the paths as areas. Non-closed
3499 paths will be treated as implicitly closed.
3500
3501 \sa contains()
3502 */
3503bool QPainterPath::intersects(const QPainterPath &p) const
3504{
3505 if (p.elementCount() == 1)
3506 return contains(pt: p.elementAt(i: 0));
3507 if (isEmpty() || p.isEmpty())
3508 return false;
3509 QPathClipper clipper(*this, p);
3510 return clipper.intersect();
3511}
3512
3513/*!
3514 \since 4.3
3515
3516 Returns \c true if the given path \a p is contained within
3517 the current path. Returns \c false if any edges of the current path and
3518 \a p intersect.
3519
3520 Set operations on paths will treat the paths as areas. Non-closed
3521 paths will be treated as implicitly closed.
3522
3523 \sa intersects()
3524 */
3525bool QPainterPath::contains(const QPainterPath &p) const
3526{
3527 if (p.elementCount() == 1)
3528 return contains(pt: p.elementAt(i: 0));
3529 if (isEmpty() || p.isEmpty())
3530 return false;
3531 QPathClipper clipper(*this, p);
3532 return clipper.contains();
3533}
3534
3535void QPainterPath::setDirty(bool dirty)
3536{
3537 d_func()->dirtyBounds = dirty;
3538 d_func()->dirtyControlBounds = dirty;
3539 d_func()->pathConverter.reset();
3540 d_func()->convex = false;
3541}
3542
3543void QPainterPath::computeBoundingRect() const
3544{
3545 QPainterPathData *d = d_func();
3546 d->dirtyBounds = false;
3547 if (!d_ptr) {
3548 d->bounds = QRect();
3549 return;
3550 }
3551
3552 qreal minx, maxx, miny, maxy;
3553 minx = maxx = d->elements.at(i: 0).x;
3554 miny = maxy = d->elements.at(i: 0).y;
3555 for (int i=1; i<d->elements.size(); ++i) {
3556 const Element &e = d->elements.at(i);
3557
3558 switch (e.type) {
3559 case MoveToElement:
3560 case LineToElement:
3561 if (e.x > maxx) maxx = e.x;
3562 else if (e.x < minx) minx = e.x;
3563 if (e.y > maxy) maxy = e.y;
3564 else if (e.y < miny) miny = e.y;
3565 break;
3566 case CurveToElement:
3567 {
3568 QBezier b = QBezier::fromPoints(p1: d->elements.at(i: i-1),
3569 p2: e,
3570 p3: d->elements.at(i: i+1),
3571 p4: d->elements.at(i: i+2));
3572 QRectF r = qt_painterpath_bezier_extrema(b);
3573 qreal right = r.right();
3574 qreal bottom = r.bottom();
3575 if (r.x() < minx) minx = r.x();
3576 if (right > maxx) maxx = right;
3577 if (r.y() < miny) miny = r.y();
3578 if (bottom > maxy) maxy = bottom;
3579 i += 2;
3580 }
3581 break;
3582 default:
3583 break;
3584 }
3585 }
3586 d->bounds = QRectF(minx, miny, maxx - minx, maxy - miny);
3587}
3588
3589
3590void QPainterPath::computeControlPointRect() const
3591{
3592 QPainterPathData *d = d_func();
3593 d->dirtyControlBounds = false;
3594 if (!d_ptr) {
3595 d->controlBounds = QRect();
3596 return;
3597 }
3598
3599 qreal minx, maxx, miny, maxy;
3600 minx = maxx = d->elements.at(i: 0).x;
3601 miny = maxy = d->elements.at(i: 0).y;
3602 for (int i=1; i<d->elements.size(); ++i) {
3603 const Element &e = d->elements.at(i);
3604 if (e.x > maxx) maxx = e.x;
3605 else if (e.x < minx) minx = e.x;
3606 if (e.y > maxy) maxy = e.y;
3607 else if (e.y < miny) miny = e.y;
3608 }
3609 d->controlBounds = QRectF(minx, miny, maxx - minx, maxy - miny);
3610}
3611
3612#ifndef QT_NO_DEBUG_STREAM
3613QDebug operator<<(QDebug s, const QPainterPath &p)
3614{
3615 s.nospace() << "QPainterPath: Element count=" << p.elementCount() << Qt::endl;
3616 const char *types[] = {"MoveTo", "LineTo", "CurveTo", "CurveToData"};
3617 for (int i=0; i<p.elementCount(); ++i) {
3618 s.nospace() << " -> " << types[p.elementAt(i).type] << "(x=" << p.elementAt(i).x << ", y=" << p.elementAt(i).y << ')' << Qt::endl;
3619
3620 }
3621 return s;
3622}
3623#endif
3624
3625QT_END_NAMESPACE
3626

source code of qtbase/src/gui/painting/qpainterpath.cpp