QPainterPath Class Reference

The QPainterPath class provides a container for painting operations, enabling graphical shapes to be constructed and reused. More...

#include <qpainterpath.h>

Classes
class	Element
	The QPainterPath::Element class specifies the position and type of a subpath. More...

Public Types
enum	ElementType { MoveToElement, LineToElement, CurveToElement, CurveToDataElement }
	This enum describes the types of elements used to connect vertices in subpaths. More...

Public Functions
void	addEllipse (const QRectF &rect)
	Creates an ellipse within the specified boundingRectangle and adds it to the painter path as a closed subpath. More...
void	addEllipse (qreal x, qreal y, qreal w, qreal h)
	Creates an ellipse within the bounding rectangle defined by its top-left corner at (x, y), width and height, and adds it to the painter path as a closed subpath. More...
void	addEllipse (const QPointF &center, qreal rx, qreal ry)
	Creates an ellipse positioned at {center} with radii {rx} and {ry}, and adds it to the painter path as a closed subpath. More...
void	addPath (const QPainterPath &path)
	Adds the given path to this path as a closed subpath. More...
void	addPolygon (const QPolygonF &polygon)
	Adds the given polygon to the path as an (unclosed) subpath. More...
void	addRect (const QRectF &rect)
	Adds the given rectangle to this path as a closed subpath. More...
void	addRect (qreal x, qreal y, qreal w, qreal h)
	Adds a rectangle at position ({x}, {y}), with the given width and height, as a closed subpath. More...
void	addRegion (const QRegion &region)
	Adds the given region to the path by adding each rectangle in the region as a separate closed subpath. More...
void	addRoundedRect (const QRectF &rect, qreal xRadius, qreal yRadius, Qt::SizeMode mode=Qt::AbsoluteSize)
	Adds the given rectangle rect with rounded corners to the path. More...
void	addRoundedRect (qreal x, qreal y, qreal w, qreal h, qreal xRadius, qreal yRadius, Qt::SizeMode mode=Qt::AbsoluteSize)
	Adds the given rectangle x, y, w, h with rounded corners to the path. More...
void	addRoundRect (const QRectF &rect, int xRnd, int yRnd)
	Adds a rectangle r with rounded corners to the path. More...
void	addRoundRect (qreal x, qreal y, qreal w, qreal h, int xRnd, int yRnd)
	Adds a rectangle with rounded corners to the path. More...
void	addRoundRect (const QRectF &rect, int roundness)
	Adds a rounded rectangle, rect, to the path. More...
void	addRoundRect (qreal x, qreal y, qreal w, qreal h, int roundness)
	Adds a rounded rectangle to the path, defined by the coordinates x and y with the specified width and height. More...
void	addText (const QPointF &point, const QFont &f, const QString &text)
	Adds the given text to this path as a set of closed subpaths created from the font supplied. More...
void	addText (qreal x, qreal y, const QFont &f, const QString &text)
	Adds the given text to this path as a set of closed subpaths created from the font supplied. More...
qreal	angleAtPercent (qreal t) const
	Returns the angle of the path tangent at the percentage t. More...
void	arcMoveTo (const QRectF &rect, qreal angle)
	Creates a move to that lies on the arc that occupies the given rectangle at angle. More...
void	arcMoveTo (qreal x, qreal y, qreal w, qreal h, qreal angle)
	Creates a move to that lies on the arc that occupies the QRectF(x, y, width, height) at angle. More...
void	arcTo (const QRectF &rect, qreal startAngle, qreal arcLength)
	Creates an arc that occupies the given rectangle, beginning at the specified startAngle and extending sweepLength degrees counter-clockwise. More...
void	arcTo (qreal x, qreal y, qreal w, qreal h, qreal startAngle, qreal arcLength)
QRectF	boundingRect () const
	Returns the bounding rectangle of this painter path as a rectangle with floating point precision. More...
void	closeSubpath ()
	Closes the current subpath by drawing a line to the beginning of the subpath, automatically starting a new path. More...
void	connectPath (const QPainterPath &path)
	Connects the given path to this path by adding a line from the last element of this path to the first element of the given path. More...
bool	contains (const QPointF &pt) const
	Returns true if the given point is inside the path, otherwise returns false. More...
bool	contains (const QRectF &rect) const
	Returns true if the given rectangle is inside the path, otherwise returns false. More...
bool	contains (const QPainterPath &p) const
	Returns true if the given path p is contained within the current path. More...
QRectF	controlPointRect () const
	Returns the rectangle containing all the points and control points in this path. More...
void	cubicTo (const QPointF &ctrlPt1, const QPointF &ctrlPt2, const QPointF &endPt)
	Adds a cubic Bezier curve between the current position and the given endPoint using the control points specified by c1, and c2. More...
void	cubicTo (qreal ctrlPt1x, qreal ctrlPt1y, qreal ctrlPt2x, qreal ctrlPt2y, qreal endPtx, qreal endPty)
	Adds a cubic Bezier curve between the current position and the end point ({endPointX}, {endPointY}) with control points specified by ({c1X}, {c1Y}) and ({c2X}, {c2Y}). More...
QPointF	currentPosition () const
	Returns the current position of the path. More...
const QPainterPath::Element &	elementAt (int i) const
	Returns the element at the given index in the painter path. More...
int	elementCount () const
	Returns the number of path elements in the painter path. More...
Qt::FillRule	fillRule () const
	Returns the painter path's currently set fill rule. More...
QPainterPath	intersected (const QPainterPath &r) const
	Returns a path which is the intersection of this path's fill area and p's fill area. More...
bool	intersects (const QRectF &rect) const
	Returns true if any point in the given rectangle intersects the path; otherwise returns false. More...
bool	intersects (const QPainterPath &p) const
	Returns true if the current path intersects at any point the given path p. More...
bool	isEmpty () const
	Returns true if either there are no elements in this path, or if the only element is a MoveToElement; otherwise returns false. More...
qreal	length () const
	Returns the length of the current path. More...
void	lineTo (const QPointF &p)
	Adds a straight line from the current position to the given endPoint. More...
void	lineTo (qreal x, qreal y)
	Draws a line from the current position to the point ({x}, {y}). More...
void	moveTo (const QPointF &p)
	Moves the current point to the given point, implicitly starting a new subpath and closing the previous one. More...
void	moveTo (qreal x, qreal y)
	Moves the current position to ({x}, {y}) and starts a new subpath, implicitly closing the previous path. More...
QPainterPath	operator & (const QPainterPath &other) const
QPainterPath &	operator &= (const QPainterPath &other)
bool	operator!= (const QPainterPath &other) const
	Returns true if this painter path differs from the given path. More...
QPainterPath	operator+ (const QPainterPath &other) const
	Returns the union of this path and the other path. More...
QPainterPath &	operator+= (const QPainterPath &other)
	Unites this path with other, and returns a reference to this path. More...
QPainterPath	operator- (const QPainterPath &other) const
	Subtracts the other path from a copy of this path, and returns the copy. More...
QPainterPath &	operator-= (const QPainterPath &other)
	Subtracts other from this path, and returns a reference to this path. More...
QPainterPath &	operator= (const QPainterPath &other)
	Assigns the given path to this painter path. More...
bool	operator== (const QPainterPath &other) const
	Returns true if this painterpath is equal to the given path. More...
QPainterPath	operator| (const QPainterPath &other) const
	Returns the union of this path and the other path. More...
QPainterPath &	operator|= (const QPainterPath &other)
	Unites this path with other and returns a reference to this path. More...
qreal	percentAtLength (qreal t) const
	Returns percentage of the whole path at the specified length len. More...
QPointF	pointAtPercent (qreal t) const
	Returns the point at at the percentage t of the current path. More...
	QPainterPath ()
	Constructs an empty QPainterPath object. More...
	QPainterPath (const QPointF &startPoint)
	Creates a QPainterPath object with the given startPoint as its current position. More...
	QPainterPath (const QPainterPath &other)
	Creates a QPainterPath object that is a copy of the given path. More...
void	quadTo (const QPointF &ctrlPt, const QPointF &endPt)
	Adds a quadratic Bezier curve between the current position and the given endPoint with the control point specified by c. More...
void	quadTo (qreal ctrlPtx, qreal ctrlPty, qreal endPtx, qreal endPty)
	Adds a quadratic Bezier curve between the current point and the endpoint ({endPointX}, {endPointY}) with the control point specified by ({cx}, {cy}). More...
void	setElementPositionAt (int i, qreal x, qreal y)
	Sets the x and y coordinate of the element at index index to x and y. More...
void	setFillRule (Qt::FillRule fillRule)
	Sets the fill rule of the painter path to the given fillRule. More...
QPainterPath	simplified () const
	Returns a simplified version of this path. More...
qreal	slopeAtPercent (qreal t) const
	Returns the slope of the path at the percentage t. More...
QPainterPath	subtracted (const QPainterPath &r) const
	Returns a path which is p's fill area subtracted from this path's fill area. More...
QPainterPath	subtractedInverted (const QPainterPath &r) const
	Use subtracted() instead. More...
void	swap (QPainterPath &other)
	Swaps painter path other with this painter path. More...
QPolygonF	toFillPolygon (const QMatrix &matrix=QMatrix()) const
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
QPolygonF	toFillPolygon (const QTransform &matrix) const
	Converts the path into a polygon using the QTransform matrix, and returns the polygon. More...
QList< QPolygonF >	toFillPolygons (const QMatrix &matrix=QMatrix()) const
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
QList< QPolygonF >	toFillPolygons (const QTransform &matrix) const
	Converts the path into a list of polygons using the QTransform matrix, and returns the list. More...
QPainterPath	toReversed () const
	Creates and returns a reversed copy of the path. More...
QList< QPolygonF >	toSubpathPolygons (const QMatrix &matrix=QMatrix()) const
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
QList< QPolygonF >	toSubpathPolygons (const QTransform &matrix) const
	Converts the path into a list of polygons using the QTransform matrix, and returns the list. More...
void	translate (qreal dx, qreal dy)
	Translates all elements in the path by ({dx}, {dy}). More...
void	translate (const QPointF &offset)
	Translates all elements in the path by the given offset. More...
QPainterPath	translated (qreal dx, qreal dy) const
	Returns a copy of the path that is translated by ({dx}, {dy}). More...
QPainterPath	translated (const QPointF &offset) const
	Returns a copy of the path that is translated by the given offset. More...
QPainterPath	united (const QPainterPath &r) const
	Returns a path which is the union of this path's fill area and p's fill area. More...
	~QPainterPath ()
	Destroys this QPainterPath object. More...

Private Functions
void	computeBoundingRect () const
void	computeControlPointRect () const
QPainterPathData *	d_func () const
void	detach ()
void	detach_helper ()
void	ensureData ()
void	ensureData_helper ()
void	setDirty (bool)

Properties
QScopedPointer< QPainterPathPrivate, QPainterPathPrivateDeleter >	d_ptr

Friends
Q_GUI_EXPORT QDataStream &	operator<< (QDataStream &, const QPainterPath &)
	Writes the given painter path to the given stream, and returns a reference to the stream. More...
Q_GUI_EXPORT QDataStream &	operator>> (QDataStream &, QPainterPath &)
	Reads a painter path from the given stream into the specified path, and returns a reference to the stream. More...
class	QMatrix
class	QPainterPathData
class	QPainterPathStroker
class	QPainterPathStrokerPrivate
class	QTransform
Q_GUI_EXPORT const QVectorPath &	qtVectorPathForPath (const QPainterPath &)
class	QVectorPath

Detailed Description

The QPainterPath class provides a container for painting operations, enabling graphical shapes to be constructed and reused.

A painter path is an object composed of a number of graphical building blocks, such as rectangles, ellipses, lines, and curves. Building blocks can be joined in closed subpaths, for example as a rectangle or an ellipse. A closed path has coinciding start and end points. Or they can exist independently as unclosed subpaths, such as lines and curves.

A QPainterPath object can be used for filling, outlining, and clipping. To generate fillable outlines for a given painter path, use the QPainterPathStroker class. The main advantage of painter paths over normal drawing operations is that complex shapes only need to be created once; then they can be drawn many times using only calls to the QPainter::drawPath() function.

QPainterPath provides a collection of functions that can be used to obtain information about the path and its elements. In addition it is possible to reverse the order of the elements using the toReversed() function. There are also several functions to convert this painter path object into a polygon representation.

Composing a QPainterPath

A QPainterPath object can be constructed as an empty path, with a given start point, or as a copy of another QPainterPath object. Once created, lines and curves can be added to the path using the lineTo(), arcTo(), cubicTo() and quadTo() functions. The lines and curves stretch from the currentPosition() to the position passed as argument.

The currentPosition() of the QPainterPath object is always the end position of the last subpath that was added (or the initial start point). Use the moveTo() function to move the currentPosition() without adding a component. The moveTo() function implicitly starts a new subpath, and closes the previous one. Another way of starting a new subpath is to call the closeSubpath() function which closes the current path by adding a line from the currentPosition() back to the path's start position. Note that the new path will have (0, 0) as its initial currentPosition().

QPainterPath class also provides several convenience functions to add closed subpaths to a painter path: addEllipse(), addPath(), addRect(), addRegion() and addText(). The addPolygon() function adds an unclosed subpath. In fact, these functions are all collections of moveTo(), lineTo() and cubicTo() operations.

In addition, a path can be added to the current path using the connectPath() function. But note that this function will connect the last element of the current path to the first element of given one by adding a line.

Below is a code snippet that shows how a QPainterPath object can be used:

QPainterPath path; path.addRect(20, 20, 60, 60); path.moveTo(0, 0); path.cubicTo(99, 0, 50, 50, 99, 99); path.cubicTo(0, 99, 50, 50, 0, 0); QPainter painter(this); painter.fillRect(0, 0, 100, 100, Qt::white); painter.setPen(QPen(QColor(79, 106, 25), 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin)); painter.setBrush(QColor(122, 163, 39)); painter.drawPath(path);

The painter path is initially empty when constructed. We first add a rectangle, which is a closed subpath. Then we add two bezier curves which together form a closed subpath even though they are not closed individually. Finally we draw the entire path. The path is filled using the default fill rule, Qt::OddEvenFill. Qt provides two methods for filling paths:

Qt::OddEvenFill	Qt::WindingFill

See the Qt::FillRule documentation for the definition of the rules. A painter path's currently set fill rule can be retrieved using the fillRule() function, and altered using the setFillRule() function.

QPainterPath Information

The QPainterPath class provides a collection of functions that returns information about the path and its elements.

The currentPosition() function returns the end point of the last subpath that was added (or the initial start point). The elementAt() function can be used to retrieve the various subpath elements, the number of elements can be retrieved using the elementCount() function, and the isEmpty() function tells whether this QPainterPath object contains any elements at all.

The controlPointRect() function returns the rectangle containing all the points and control points in this path. This function is significantly faster to compute than the exact boundingRect() which returns the bounding rectangle of this painter path with floating point precision.

Finally, QPainterPath provides the contains() function which can be used to determine whether a given point or rectangle is inside the path, and the intersects() function which determines if any of the points inside a given rectangle also are inside this path.

QPainterPath Conversion

For compatibility reasons, it might be required to simplify the representation of a painter path: QPainterPath provides the toFillPolygon(), toFillPolygons() and toSubpathPolygons() functions which convert the painter path into a polygon. The toFillPolygon() returns the painter path as one single polygon, while the two latter functions return a list of polygons.

The toFillPolygons() and toSubpathPolygons() functions are provided because it is usually faster to draw several small polygons than to draw one large polygon, even though the total number of points drawn is the same. The difference between the two is the number of polygons they return: The toSubpathPolygons() creates one polygon for each subpath regardless of intersecting subpaths (i.e. overlapping bounding rectangles), while the toFillPolygons() functions creates only one polygon for overlapping subpaths.

The toFillPolygon() and toFillPolygons() functions first convert all the subpaths to polygons, then uses a rewinding technique to make sure that overlapping subpaths can be filled using the correct fill rule. Note that rewinding inserts additional lines in the polygon so the outline of the fill polygon does not match the outline of the path.

Examples

Qt provides the painting/painterpaths{Painter Paths Example} and the demos/deform{Vector Deformation Demo} which are located in Qt's example and demo directories respectively.

The painting/painterpaths{Painter Paths Example} shows how painter paths can be used to build complex shapes for rendering and lets the user experiment with the filling and stroking. The demos/deform{Vector Deformation Demo} shows how to use QPainterPath to draw text.

painting/painterpaths{Painter Paths Example}	demos/deform{Vector Deformation Demo}

See also

QPainterPathStroker, QPainter, QRegion, {Painter Paths Example}

Definition at line 67 of file qpainterpath.h.

Enumerations

ElementType

enum QPainterPath::ElementType

This enum describes the types of elements used to connect vertices in subpaths.

Note that elements added as closed subpaths using the addEllipse(), addPath(), addPolygon(), addRect(), addRegion() and addText() convenience functions, is actually added to the path as a collection of separate elements using the moveTo(), lineTo() and cubicTo() functions.

• MoveToElement A new subpath. See also moveTo().
• LineToElement A line. See also lineTo().
• CurveToElement A curve. See also cubicTo() and quadTo().
• CurveToDataElement The extra data required to describe a curve in a CurveToElement element.

See also

elementAt(), elementCount()

Enumerator
MoveToElement
LineToElement
CurveToElement
CurveToDataElement

Definition at line 70 of file qpainterpath.h.

                     {
        MoveToElement,
        LineToElement,
        CurveToElement,
        CurveToDataElement
    };

Constructors and Destructors

QPainterPath() [1/3]

QPainterPath::QPainterPath

(

)

Constructs an empty QPainterPath object.

Definition at line 560 of file qpainterpath.cpp.

    : d_ptr(0)
{
}

QPainterPath() [2/3]

QPainterPath::QPainterPath ( const QPointF &  startPoint )

explicit

Creates a QPainterPath object with the given startPoint as its current position.

Definition at line 587 of file qpainterpath.cpp.

    : d_ptr(new QPainterPathData)
{
    Element e = { startPoint.x(), startPoint.y(), MoveToElement };
    d_func()->elements << e;
}

QPainterPath() [3/3]

QPainterPath::QPainterPath

(

const QPainterPath &

path

)

Creates a QPainterPath object that is a copy of the given path.

See also

operator=()

Definition at line 575 of file qpainterpath.cpp.

    : d_ptr(other.d_ptr.data())
{
    if (d_ptr)
        d_ptr->ref.ref();
}

~QPainterPath()

QPainterPath::~QPainterPath

(

)

Destroys this QPainterPath object.

Definition at line 651 of file qpainterpath.cpp.

{
}

Functions

addEllipse() [1/3]

void QPainterPath::addEllipse

(

const QRectF &

boundingRectangle

)

Creates an ellipse within the specified boundingRectangle and adds it to the painter path as a closed subpath.

The ellipse is composed of a clockwise curve, starting and finishing at zero degrees (the 3 o'clock position).

QLinearGradient myGradient; QPen myPen; QRectF boundingRectangle; QPainterPath myPath; myPath.addEllipse(boundingRectangle); QPainter painter(this); painter.setBrush(myGradient); painter.setPen(myPen); painter.drawPath(myPath);

See also

arcTo(), QPainter::drawEllipse(), {QPainterPath::Composing a QPainterPath}{Composing a QPainterPath}

Definition at line 1169 of file qpainterpath.cpp.

Referenced by QSvgEllipse::bounds(), QX11PaintEngine::drawEllipse(), QOpenGLPaintEngine::drawEllipse(), QPaintEngine::drawEllipse(), QPainter::drawEllipse(), ellipseRectToPath(), QRegion::QRegion(), qt_bitmapToRegion(), and QGraphicsEllipseItem::shape().

{
    if (!qt_is_finite(boundingRect.x()) || !qt_is_finite(boundingRect.y())
        || !qt_is_finite(boundingRect.width()) || !qt_is_finite(boundingRect.height())) {
#ifndef QT_NO_DEBUG
        qWarning("QPainterPath::addEllipse: Adding ellipse where a parameter is NaN or Inf, ignoring call");
#endif
        return;
    }

    if (boundingRect.isNull())
        return;

    ensureData();
    detach();

    Q_D(QPainterPath);
    bool first = d_func()->elements.size() < 2;
    d->elements.reserve(d->elements.size() + 13);

    QPointF pts[12];
    int point_count;
    QPointF start = qt_curves_for_arc(boundingRect, 0, -360, pts, &point_count);

    moveTo(start);
    cubicTo(pts[0], pts[1], pts[2]);           // 0 -> 270
    cubicTo(pts[3], pts[4], pts[5]);           // 270 -> 180
    cubicTo(pts[6], pts[7], pts[8]);           // 180 -> 90
    cubicTo(pts[9], pts[10], pts[11]);         // 90 - >0
    d_func()->require_moveTo = true;

    d_func()->convex = first;
}

addEllipse() [2/3]

void QPainterPath::addEllipse ( qreal  x, qreal  y, qreal  width, qreal  height  )

inline

Creates an ellipse within the bounding rectangle defined by its top-left corner at (x, y), width and height, and adds it to the painter path as a closed subpath.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 335 of file qpainterpath.h.

{
    addEllipse(QRectF(x, y, w, h));
}

addEllipse() [3/3]

void QPainterPath::addEllipse ( const QPointF &  center, qreal  rx, qreal  ry  )

inline

Creates an ellipse positioned at {center} with radii {rx} and {ry}, and adds it to the painter path as a closed subpath.

Since

4.4

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 340 of file qpainterpath.h.

{
    addEllipse(QRectF(center.x() - rx, center.y() - ry, 2 * rx, 2 * ry));
}

addPath()

void QPainterPath::addPath

(

const QPainterPath &

path

)

Adds the given path to this path as a closed subpath.

See also

connectPath(), {QPainterPath::Composing a QPainterPath}{Composing a QPainterPath}

Definition at line 1295 of file qpainterpath.cpp.

Referenced by QPathClipper::clip(), and qt_graphicsItem_shapeFromPath().

{
    if (other.isEmpty())
        return;

    ensureData();
    detach();

    QPainterPathData *d = reinterpret_cast<QPainterPathData *>(d_func());
    // Remove last moveto so we don't get multiple moveto's
    if (d->elements.last().type == MoveToElement)
        d->elements.remove(d->elements.size()-1);

    // Locate where our own current subpath will start after the other path is added.
    int cStart = d->elements.size() + other.d_func()->cStart;
    d->elements += other.d_func()->elements;
    d->cStart = cStart;

    d->require_moveTo = other.d_func()->isClosed();
}

addPolygon()

void QPainterPath::addPolygon

(

const QPolygonF &

polygon

)

Adds the given polygon to the path as an (unclosed) subpath.

Note that the current position after the polygon has been added, is the last point in polygon. To draw a line back to the first point, use the closeSubpath() function.

QLinearGradient myGradient; QPen myPen; QPolygonF myPolygon; QPainterPath myPath; myPath.addPolygon(myPolygon); QPainter painter(this); painter.setBrush(myGradient); painter.setPen(myPen); painter.drawPath(myPath);

See also

lineTo(), {QPainterPath::Composing a QPainterPath}{Composing a QPainterPath}

Definition at line 1131 of file qpainterpath.cpp.

Referenced by QSvgPolygon::bounds(), QSvgPolyline::bounds(), QCommonStyle::drawControl(), QAlphaPaintEngine::drawPolygon(), QPolygon::intersected(), QPolygonF::intersected(), QGraphicsSceneIndex::items(), mapProjective(), QGraphicsView::mouseMoveEvent(), QGraphicsView::render(), QGraphicsPolygonItem::shape(), QPolygon::subtracted(), QPolygonF::subtracted(), QPolygon::united(), and QPolygonF::united().

{
    if (polygon.isEmpty())
        return;

    ensureData();
    detach();

    d_func()->elements.reserve(d_func()->elements.size() + polygon.size());

    moveTo(polygon.first());
    for (int i=1; i<polygon.size(); ++i) {
        Element elm = { polygon.at(i).x(), polygon.at(i).y(), LineToElement };
        d_func()->elements << elm;
    }
}

addRect() [1/2]

void QPainterPath::addRect

(

const QRectF &

rectangle

)

Adds the given rectangle to this path as a closed subpath.

The rectangle is added as a clockwise set of lines. The painter path's current position after the rectangle has been added is at the top-left corner of the rectangle.

QLinearGradient myGradient; QPen myPen; QRectF myRectangle; QPainterPath myPath; myPath.addRect(myRectangle); QPainter painter(this); painter.setBrush(myGradient); painter.setPen(myPen); painter.drawPath(myPath);

See also

addRegion(), lineTo(), {QPainterPath::Composing a QPainterPath}{Composing a QPainterPath}

Definition at line 1085 of file qpainterpath.cpp.

Referenced by QGraphicsTextItemPrivate::_q_mouseOnEdge(), QFontEngineBox::addOutlineToPath(), addRegion(), addSelectedRegionsToPath(), addText(), QSvgRect::bounds(), QPathClipper::clip(), QGL2PaintEngineEx::clip(), QOutlineMapper::clipElements(), QPainter::clipPath(), QGraphicsItem::clipPath(), QGraphicsItem::collidesWithPath(), QTextLayout::draw(), QTextLine::draw(), QCDEStyle::drawControl(), QRasterPaintEngine::drawImage(), QOpenGLPaintEnginePrivate::drawImageAsPath(), QMacStyle::drawPrimitive(), QX11PaintEngine::drawRects(), QOpenGLPaintEngine::drawRects(), QPaintEngine::drawRects(), QPdfBaseEngine::drawRects(), QPainter::drawRects(), QOpenGLPaintEnginePrivate::drawTiledImageAsPath(), QRasterPaintEngine::drawTiledPixmap(), QX11PaintEnginePrivate::fillPath(), QRasterPaintEngine::fillRect(), QGraphicsSceneIndexRectIntersector::intersect(), QGraphicsSceneIndexPointIntersector::intersect(), QGraphicsSceneIndexPrivate::itemCollidesWithPath(), QTransform::mapRect(), QGraphicsWidget::paintWindowFrame(), path_for_glyphs(), qt_regionToPath(), QmlJSDebugger::regionToPolygon(), QPainter::setClipRect(), QGraphicsWidget::shape(), QGraphicsItem::shape(), QGraphicsRectItem::shape(), QGraphicsTextItem::shape(), QGraphicsSimpleTextItem::shape(), QFontSubset::toTruetype(), QPdfBaseEngine::updateClipPath(), QOpenGLPaintEngine::updateClipRegion(), QGraphicsPixmapItemPrivate::updateShape(), and QPdfBaseEngine::updateState().

{
    if (!qt_is_finite(r.x()) || !qt_is_finite(r.y()) || !qt_is_finite(r.width()) || !qt_is_finite(r.height())) {
#ifndef QT_NO_DEBUG
        qWarning("QPainterPath::addRect: Adding rect where a parameter is NaN or Inf, ignoring call");
#endif
        return;
    }

    if (r.isNull())
        return;

    ensureData();
    detach();

    bool first = d_func()->elements.size() < 2;

    d_func()->elements.reserve(d_func()->elements.size() + 5);
    moveTo(r.x(), r.y());

    Element l1 = { r.x() + r.width(), r.y(), LineToElement };
    Element l2 = { r.x() + r.width(), r.y() + r.height(), LineToElement };
    Element l3 = { r.x(), r.y() + r.height(), LineToElement };
    Element l4 = { r.x(), r.y(), LineToElement };

    d_func()->elements << l1 << l2 << l3 << l4;
    d_func()->require_moveTo = true;
    d_func()->convex = first;
}

addRect() [2/2]

void QPainterPath::addRect ( qreal  x, qreal  y, qreal  width, qreal  height  )

inline

Adds a rectangle at position ({x}, {y}), with the given width and height, as a closed subpath.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 345 of file qpainterpath.h.

{
    addRect(QRectF(x, y, w, h));
}

addRegion()

void QPainterPath::addRegion

(

const QRegion &

region

)

Adds the given region to the path by adding each rectangle in the region as a separate closed subpath.

See also

addRect(), {QPainterPath::Composing a QPainterPath}{Composing a QPainterPath}

Definition at line 1367 of file qpainterpath.cpp.

Referenced by QGL2PaintEngineEx::clip(), and QGL2PaintEngineExPrivate::systemStateChanged().

{
    ensureData();
    detach();

    QVector<QRect> rects = region.rects();
    d_func()->elements.reserve(rects.size() * 5);
    for (int i=0; i<rects.size(); ++i)
        addRect(rects.at(i));
}

addRoundedRect() [1/2]

void QPainterPath::addRoundedRect	(	const QRectF &	rect,
		qreal	xRadius,
		qreal	yRadius,
		Qt::SizeMode	mode = Qt::AbsoluteSize
	)

Adds the given rectangle rect with rounded corners to the path.

Since

4.4

The xRadius and yRadius arguments specify the radii of the ellipses defining the corners of the rounded rectangle. When mode is Qt::RelativeSize, xRadius and yRadius are specified in percentage of half the rectangle's width and height respectively, and should be in the range 0.0 to 100.0.

See also

addRect()

Definition at line 3209 of file qpainterpath.cpp.

Referenced by QPainter::drawRoundedRect().

{
    QRectF r = rect.normalized();

    if (r.isNull())
        return;

    if (mode == Qt::AbsoluteSize) {
        qreal w = r.width() / 2;
        qreal h = r.height() / 2;

        if (w == 0) {
            xRadius = 0;
        } else {
            xRadius = 100 * qMin(xRadius, w) / w;
        }
        if (h == 0) {
            yRadius = 0;
        } else {
            yRadius = 100 * qMin(yRadius, h) / h;
        }
    } else {
        if (xRadius > 100)                          // fix ranges
            xRadius = 100;

        if (yRadius > 100)
            yRadius = 100;
    }

    if (xRadius <= 0 || yRadius <= 0) {             // add normal rectangle
        addRect(r);
        return;
    }

    qreal x = r.x();
    qreal y = r.y();
    qreal w = r.width();
    qreal h = r.height();
    qreal rxx2 = w*xRadius/100;
    qreal ryy2 = h*yRadius/100;

    ensureData();
    detach();

    bool first = d_func()->elements.size() < 2;

    arcMoveTo(x, y, rxx2, ryy2, 180);
    arcTo(x, y, rxx2, ryy2, 180, -90);
    arcTo(x+w-rxx2, y, rxx2, ryy2, 90, -90);
    arcTo(x+w-rxx2, y+h-ryy2, rxx2, ryy2, 0, -90);
    arcTo(x, y+h-ryy2, rxx2, ryy2, 270, -90);
    closeSubpath();

    d_func()->require_moveTo = true;
    d_func()->convex = first;
}

addRoundedRect() [2/2]

void QPainterPath::addRoundedRect ( qreal  x, qreal  y, qreal  w, qreal  h, qreal  xRadius, qreal  yRadius, Qt::SizeMode  mode = Qt::AbsoluteSize  )

inline

Adds the given rectangle x, y, w, h with rounded corners to the path.

Since

4.4 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 350 of file qpainterpath.h.

{
    addRoundedRect(QRectF(x, y, w, h), xRadius, yRadius, mode);
}

addRoundRect() [1/4]

void QPainterPath::addRoundRect	(	const QRectF &	r,
		int	xRnd,
		int	yRnd
	)

Adds a rectangle r with rounded corners to the path.

The xRnd and yRnd arguments specify how rounded the corners should be. 0 is angled corners, 99 is maximum roundedness.

See also

addRoundedRect()

Definition at line 3291 of file qpainterpath.cpp.

{
    if(xRnd >= 100)                          // fix ranges
        xRnd = 99;
    if(yRnd >= 100)
        yRnd = 99;
    if(xRnd <= 0 || yRnd <= 0) {             // add normal rectangle
        addRect(r);
        return;
    }

    QRectF rect = r.normalized();

    if (rect.isNull())
        return;

    qreal x = rect.x();
    qreal y = rect.y();
    qreal w = rect.width();
    qreal h = rect.height();
    qreal rxx2 = w*xRnd/100;
    qreal ryy2 = h*yRnd/100;

    ensureData();
    detach();

    bool first = d_func()->elements.size() < 2;

    arcMoveTo(x, y, rxx2, ryy2, 180);
    arcTo(x, y, rxx2, ryy2, 180, -90);
    arcTo(x+w-rxx2, y, rxx2, ryy2, 90, -90);
    arcTo(x+w-rxx2, y+h-ryy2, rxx2, ryy2, 0, -90);
    arcTo(x, y+h-ryy2, rxx2, ryy2, 270, -90);
    closeSubpath();

    d_func()->require_moveTo = true;
    d_func()->convex = first;
}

addRoundRect() [2/4]

void QPainterPath::addRoundRect ( qreal  x, qreal  y, qreal  w, qreal  h, int  xRnd, int  yRnd  )

inline

Adds a rectangle with rounded corners to the path.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

The rectangle is constructed from x, y, and the width and height w and h.

The xRnd and yRnd arguments specify how rounded the corners should be. 0 is angled corners, 99 is maximum roundedness.

See also

addRoundedRect()

Definition at line 357 of file qpainterpath.h.

{
    addRoundRect(QRectF(x, y, w, h), xRnd, yRnd);
}

addRoundRect() [3/4]

void QPainterPath::addRoundRect ( const QRectF &  rect, int  roundness  )

inline

Adds a rounded rectangle, rect, to the path.

Since

4.3 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

The roundness argument specifies uniform roundness for the rectangle. Vertical and horizontal roundness factors will be adjusted accordingly to act uniformly around both axes. Use this method if you want a rectangle equally rounded across both the X and Y axis.

See also

addRoundedRect()

Definition at line 363 of file qpainterpath.h.

{
    int xRnd = roundness;
    int yRnd = roundness;
    if (rect.width() > rect.height())
        xRnd = int(roundness * rect.height()/rect.width());
    else
        yRnd = int(roundness * rect.width()/rect.height());
    addRoundRect(rect, xRnd, yRnd);
}

addRoundRect() [4/4]

void QPainterPath::addRoundRect ( qreal  x, qreal  y, qreal  width, qreal  height, int  roundness  )

inline

Adds a rounded rectangle to the path, defined by the coordinates x and y with the specified width and height.

Since

4.3 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

The roundness argument specifies uniform roundness for the rectangle. Vertical and horizontal roundness factors will be adjusted accordingly to act uniformly around both axes. Use this method if you want a rectangle equally rounded across both the X and Y axis.

See also

addRoundedRect()

Definition at line 375 of file qpainterpath.h.

{
    addRoundRect(QRectF(x, y, w, h), roundness);
}

addText() [1/2]

void QPainterPath::addText	(	const QPointF &	point,
		const QFont &	font,
		const QString &	text
	)

Adds the given text to this path as a set of closed subpaths created from the font supplied.

The subpaths are positioned so that the left end of the text's baseline lies at the specified point.

QLinearGradient myGradient; QPen myPen; QFont myFont; QPointF baseline(x, y); QPainterPath myPath; myPath.addText(baseline, myFont, tr("Qt")); QPainter painter(this); painter.setBrush(myGradient); painter.setPen(myPen); painter.drawPath(myPath);

See also

QPainter::drawText(), {QPainterPath::Composing a QPainterPath}{Composing a QPainterPath}

Definition at line 1223 of file qpainterpath.cpp.

{
    if (text.isEmpty())
        return;

    ensureData();
    detach();

    QTextLayout layout(text, f);
    layout.setCacheEnabled(true);
    QTextEngine *eng = layout.engine();
    layout.beginLayout();
    QTextLine line = layout.createLine();
    Q_UNUSED(line);
    layout.endLayout();
    const QScriptLine &sl = eng->lines[0];
    if (!sl.length || !eng->layoutData)
        return;

    int nItems = eng->layoutData->items.size();

    qreal x(point.x());
    qreal y(point.y());

    QVarLengthArray<int> visualOrder(nItems);
    QVarLengthArray<uchar> levels(nItems);
    for (int i = 0; i < nItems; ++i)
        levels[i] = eng->layoutData->items[i].analysis.bidiLevel;
    QTextEngine::bidiReorder(nItems, levels.data(), visualOrder.data());

    for (int i = 0; i < nItems; ++i) {
        int item = visualOrder[i];
        QScriptItem &si = eng->layoutData->items[item];

        if (si.analysis.flags < QScriptAnalysis::TabOrObject) {
            QGlyphLayout glyphs = eng->shapedGlyphs(&si);
            QFontEngine *fe = f.d->engineForScript(si.analysis.script);
            Q_ASSERT(fe);
            fe->addOutlineToPath(x, y, glyphs, this,
                                 si.analysis.bidiLevel % 2
                                 ? QTextItem::RenderFlags(QTextItem::RightToLeft)
                                 : QTextItem::RenderFlags(0));

            const qreal lw = fe->lineThickness().toReal();
            if (f.d->underline) {
                qreal pos = fe->underlinePosition().toReal();
                addRect(x, y + pos, si.width.toReal(), lw);
            }
            if (f.d->overline) {
                qreal pos = fe->ascent().toReal() + 1;
                addRect(x, y - pos, si.width.toReal(), lw);
            }
            if (f.d->strikeOut) {
                qreal pos = fe->ascent().toReal() / 3;
                addRect(x, y - pos, si.width.toReal(), lw);
            }
        }
        x += si.width.toReal();
    }
}

addText() [2/2]

void QPainterPath::addText ( qreal  x, qreal  y, const QFont &  font, const QString &  text  )

inline

Adds the given text to this path as a set of closed subpaths created from the font supplied.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

The subpaths are positioned so that the left end of the text's baseline lies at the point specified by (x, y).

Definition at line 381 of file qpainterpath.h.

{
    addText(QPointF(x, y), f, text);
}

angleAtPercent()

qreal QPainterPath::angleAtPercent

(

qreal

t

)

const

Returns the angle of the path tangent at the percentage t.

The argument t has to be between 0 and 1.

Positive values for the angles mean counter-clockwise while negative values mean the clockwise direction. Zero degrees is at the 3 o'clock position.

Note that similarly to the other percent methods, the percentage measurement is not linear with regards to the length if curves are present in the path. When curves are present the percentage argument is mapped to the t parameter of the Bezier equations.

Definition at line 3124 of file qpainterpath.cpp.

{
    if (t < 0 || t > 1) {
        qWarning("QPainterPath::angleAtPercent accepts only values between 0 and 1");
        return 0;
    }

    qreal totalLength = length();
    qreal curLen = 0;
    qreal bezierLen = 0;
    QBezier bez = bezierAtT(*this, t, &curLen, &bezierLen);
    qreal realT = (totalLength * t - curLen) / bezierLen;

    qreal m1 = slopeAt(realT, bez.x1, bez.x2, bez.x3, bez.x4);
    qreal m2 = slopeAt(realT, bez.y1, bez.y2, bez.y3, bez.y4);

    return QLineF(0, 0, m1, m2).angle();
}

arcMoveTo() [1/2]

void QPainterPath::arcMoveTo	(	const QRectF &	rectangle,
		qreal	angle
	)

Creates a move to that lies on the arc that occupies the given rectangle at angle.

Since

4.2

Angles are specified in degrees. Clockwise arcs can be specified using negative angles.

See also

moveTo(), arcTo()

Definition at line 1024 of file qpainterpath.cpp.

Referenced by QPainter::drawArc(), and QPainter::drawChord().

{
    if (rect.isNull())
        return;

    QPointF pt;
    qt_find_ellipse_coords(rect, angle, 0, &pt, 0);
    moveTo(pt);
}

arcMoveTo() [2/2]

void QPainterPath::arcMoveTo ( qreal  x, qreal  y, qreal  width, qreal  height, qreal  angle  )

inline

Creates a move to that lies on the arc that occupies the QRectF(x, y, width, height) at angle.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Since

4.2

Definition at line 318 of file qpainterpath.h.

{
    arcMoveTo(QRectF(x, y, w, h), angle);
}

arcTo() [1/2]

void QPainterPath::arcTo	(	const QRectF &	rectangle,
		qreal	startAngle,
		qreal	sweepLength
	)

Creates an arc that occupies the given rectangle, beginning at the specified startAngle and extending sweepLength degrees counter-clockwise.

Angles are specified in degrees. Clockwise arcs can be specified using negative angles.

Note that this function connects the starting point of the arc to the current position if they are not already connected. After the arc has been added, the current position is the last point in arc. To draw a line back to the first point, use the closeSubpath() function.

QLinearGradient myGradient; QPen myPen; QPointF center, startPoint; QPainterPath myPath; myPath.moveTo(center); myPath.arcTo(boundingRect, startAngle, sweepLength); QPainter painter(this); painter.setBrush(myGradient); painter.setPen(myPen); painter.drawPath(myPath);

See also

arcMoveTo(), addEllipse(), QPainter::drawArc(), QPainter::drawPie(), {QPainterPath::Composing a QPainterPath}{Composing a QPainterPath}

Definition at line 960 of file qpainterpath.cpp.

Referenced by QBalloonTip::balloon(), QRenderRule::borderClip(), QPainter::drawArc(), QPainter::drawChord(), QPainter::drawPie(), and QGraphicsEllipseItem::shape().

{
#ifdef QPP_DEBUG
    printf("QPainterPath::arcTo() (%.2f, %.2f, %.2f, %.2f, angle=%.2f, sweep=%.2f\n",
           rect.x(), rect.y(), rect.width(), rect.height(), startAngle, sweepLength);
#endif

    if ((!qt_is_finite(rect.x()) && !qt_is_finite(rect.y())) || !qt_is_finite(rect.width()) || !qt_is_finite(rect.height())
        || !qt_is_finite(startAngle) || !qt_is_finite(sweepLength)) {
#ifndef QT_NO_DEBUG
        qWarning("QPainterPath::arcTo: Adding arc where a parameter is NaN or Inf, ignoring call");
#endif
        return;
    }

    if (rect.isNull())
        return;

    ensureData();
    detach();

    int point_count;
    QPointF pts[15];
    QPointF curve_start = qt_curves_for_arc(rect, startAngle, sweepLength, pts, &point_count);

    lineTo(curve_start);
    for (int i=0; i<point_count; i+=3) {
        cubicTo(pts[i].x(), pts[i].y(),
                pts[i+1].x(), pts[i+1].y(),
                pts[i+2].x(), pts[i+2].y());
    }

}

arcTo() [2/2]

void QPainterPath::arcTo ( qreal  x, qreal  y, qreal  w, qreal  h, qreal  startAngle, qreal  arcLength  )

inline

Definition at line 313 of file qpainterpath.h.

{
    arcTo(QRectF(x, y, w, h), startAngle, arcLength);
}

boundingRect()

QRectF QPainterPath::boundingRect

(

)

const

Returns the bounding rectangle of this painter path as a rectangle with floating point precision.

See also

controlPointRect()

Definition at line 1528 of file qpainterpath.cpp.

Referenced by QPathClipper::clip(), QPainter::clipBoundingRect(), QPainterPrivate::draw_helper(), QWin32PrintEngine::drawPath(), QPicturePaintEngine::drawPath(), QPainter::drawPath(), QPainterPrivate::drawStretchedGradient(), QRasterPaintEngine::fillPath(), QWin32PrintEnginePrivate::fillPath_dev(), QGraphicsView::fitInView(), QBlittablePixmapData::markRasterOverlay(), operator==(), QPainter::setClipPath(), and QPicturePaintEngine::updateClipPath().

{
    if (!d_ptr)
        return QRectF();
    QPainterPathData *d = d_func();

    if (d->dirtyBounds)
        computeBoundingRect();
    return d->bounds;
}

closeSubpath()

void QPainterPath::closeSubpath

(

)

Closes the current subpath by drawing a line to the beginning of the subpath, automatically starting a new path.

The current point of the new path is (0, 0).

If the subpath does not contain any elements, this function does nothing.

See also

moveTo(), {QPainterPath::Composing a QPainterPath}{Composing a QPainterPath}

Definition at line 666 of file qpainterpath.cpp.

Referenced by QFreetypeFace::addGlyphToPath(), addGlyphToPath(), QRenderRule::borderClip(), QMacFontPath::closePath(), collectSingleContour(), QPainter::drawChord(), QPainter::drawConvexPolygon(), QPainter::drawPie(), QWin32PrintEngine::drawPolygon(), QX11PaintEngine::drawPolygon(), QSvgPaintEngine::drawPolygon(), QPdfBaseEngine::drawPolygon(), QPainter::drawPolygon(), QCommonStyle::drawPrimitive(), QGraphicsView::mouseMoveEvent(), parsePathDataFast(), and QGraphicsView::render().

{
#ifdef QPP_DEBUG
    printf("QPainterPath::closeSubpath()\n");
#endif
    if (isEmpty())
        return;
    detach();

    d_func()->close();
}

computeBoundingRect()

void QPainterPath::computeBoundingRect ( ) const

private

Definition at line 3548 of file qpainterpath.cpp.

Referenced by boundingRect().

{
    QPainterPathData *d = d_func();
    d->dirtyBounds = false;
    if (!d_ptr) {
        d->bounds = QRect();
        return;
    }

    qreal minx, maxx, miny, maxy;
    minx = maxx = d->elements.at(0).x;
    miny = maxy = d->elements.at(0).y;
    for (int i=1; i<d->elements.size(); ++i) {
        const Element &e = d->elements.at(i);

        switch (e.type) {
        case MoveToElement:
        case LineToElement:
            if (e.x > maxx) maxx = e.x;
            else if (e.x < minx) minx = e.x;
            if (e.y > maxy) maxy = e.y;
            else if (e.y < miny) miny = e.y;
            break;
        case CurveToElement:
            {
                QBezier b = QBezier::fromPoints(d->elements.at(i-1),
                                                e,
                                                d->elements.at(i+1),
                                                d->elements.at(i+2));
                QRectF r = qt_painterpath_bezier_extrema(b);
                qreal right = r.right();
                qreal bottom = r.bottom();
                if (r.x() < minx) minx = r.x();
                if (right > maxx) maxx = right;
                if (r.y() < miny) miny = r.y();
                if (bottom > maxy) maxy = bottom;
                i += 2;
            }
            break;
        default:
            break;
        }
    }
    d->bounds = QRectF(minx, miny, maxx - minx, maxy - miny);
}

computeControlPointRect()

void QPainterPath::computeControlPointRect ( ) const

private

Definition at line 3595 of file qpainterpath.cpp.

Referenced by controlPointRect().

{
    QPainterPathData *d = d_func();
    d->dirtyControlBounds = false;
    if (!d_ptr) {
        d->controlBounds = QRect();
        return;
    }

    qreal minx, maxx, miny, maxy;
    minx = maxx = d->elements.at(0).x;
    miny = maxy = d->elements.at(0).y;
    for (int i=1; i<d->elements.size(); ++i) {
        const Element &e = d->elements.at(i);
        if (e.x > maxx) maxx = e.x;
        else if (e.x < minx) minx = e.x;
        if (e.y > maxy) maxy = e.y;
        else if (e.y < miny) miny = e.y;
    }
    d->controlBounds = QRectF(minx, miny, maxx - minx, maxy - miny);
}

connectPath()

void QPainterPath::connectPath

(

const QPainterPath &

path

)

Connects the given path to this path by adding a line from the last element of this path to the first element of the given path.

See also

addPath(), {QPainterPath::Composing a QPainterPath}{Composing a QPainterPath}

Definition at line 1329 of file qpainterpath.cpp.

{
    if (other.isEmpty())
        return;

    ensureData();
    detach();

    QPainterPathData *d = reinterpret_cast<QPainterPathData *>(d_func());
    // Remove last moveto so we don't get multiple moveto's
    if (d->elements.last().type == MoveToElement)
        d->elements.remove(d->elements.size()-1);

    // Locate where our own current subpath will start after the other path is added.
    int cStart = d->elements.size() + other.d_func()->cStart;
    int first = d->elements.size();
    d->elements += other.d_func()->elements;

    if (first != 0)
        d->elements[first].type = LineToElement;

    // avoid duplicate points
    if (first > 0 && QPointF(d->elements[first]) == QPointF(d->elements[first - 1])) {
        d->elements.remove(first--);
        --cStart;
    }

    if (cStart != first)
        d->cStart = cStart;
}

contains() [1/3]

bool QPainterPath::contains

(

const QPointF &

point

)

const

Returns true if the given point is inside the path, otherwise returns false.

See also

intersects()

Definition at line 1891 of file qpainterpath.cpp.

Referenced by QGraphicsTextItemPrivate::_q_mouseOnEdge(), QGraphicsItem::collidesWithPath(), contains(), QGraphicsItem::contains(), QGraphicsSceneIndexPathIntersector::intersect(), intersects(), QGraphicsSceneIndexPrivate::itemCollidesWithPath(), and QOpenGLPaintEngine::updateClipRegion().

{
    if (isEmpty() || !controlPointRect().contains(pt))
        return false;

    QPainterPathData *d = d_func();

    int winding_number = 0;

    QPointF last_pt;
    QPointF last_start;
    for (int i=0; i<d->elements.size(); ++i) {
        const Element &e = d->elements.at(i);

        switch (e.type) {

        case MoveToElement:
            if (i > 0) // implicitly close all paths.
                qt_painterpath_isect_line(last_pt, last_start, pt, &winding_number);
            last_start = last_pt = e;
            break;

        case LineToElement:
            qt_painterpath_isect_line(last_pt, e, pt, &winding_number);
            last_pt = e;
            break;

        case CurveToElement:
            {
                const QPainterPath::Element &cp2 = d->elements.at(++i);
                const QPainterPath::Element &ep = d->elements.at(++i);
                qt_painterpath_isect_curve(QBezier::fromPoints(last_pt, e, cp2, ep),
                                           pt, &winding_number);
                last_pt = ep;

            }
            break;

        default:
            break;
        }
    }

    // implicitly close last subpath
    if (last_pt != last_start)
        qt_painterpath_isect_line(last_pt, last_start, pt, &winding_number);

    return (d->fillRule == Qt::WindingFill
            ? (winding_number != 0)
            : ((winding_number % 2) != 0));
}

contains() [2/3]

bool QPainterPath::contains

(

const QRectF &

rect

)

const

Returns true if the given rectangle is inside the path, otherwise returns false.

Definition at line 2244 of file qpainterpath.cpp.

{
    Q_D(QPainterPath);

    // the path is empty or the control point rect doesn't completely
    // cover the rectangle we abort stratight away.
    if (isEmpty() || !controlPointRect().contains(rect))
        return false;

    // if there are intersections, chances are that the rect is not
    // contained, except if we have winding rule, in which case it
    // still might.
    if (qt_painterpath_check_crossing(this, rect)) {
        if (fillRule() == Qt::OddEvenFill) {
            return false;
        } else {
            // Do some wague sampling in the winding case. This is not
            // precise but it should mostly be good enough.
            if (!contains(rect.topLeft()) ||
                !contains(rect.topRight()) ||
                !contains(rect.bottomRight()) ||
                !contains(rect.bottomLeft()))
                return false;
        }
    }

    // If there exists a point inside that is not part of the path its
    // because: rectangle lies completely outside path or a subpath
    // excludes parts of the rectangle. Both cases mean that the rect
    // is not contained
    if (!contains(rect.center()))
        return false;

    // If there are any subpaths inside this rectangle we need to
    // check if they are still contained as a result of the fill
    // rule. This can only be the case for WindingFill though. For
    // OddEvenFill the rect will never be contained if it surrounds a
    // subpath. (the case where two subpaths are completely identical
    // can be argued but we choose to neglect it).
    for (int i=0; i<d->elements.size(); ++i) {
        const Element &e = d->elements.at(i);
        if (e.type == QPainterPath::MoveToElement && rect.contains(e)) {
            if (fillRule() == Qt::OddEvenFill)
                return false;

            bool stop = false;
            for (; !stop && i<d->elements.size(); ++i) {
                const Element &el = d->elements.at(i);
                switch (el.type) {
                case MoveToElement:
                    stop = true;
                    break;
                case LineToElement:
                    if (!contains(el))
                        return false;
                    break;
                case CurveToElement:
                    if (!contains(d->elements.at(i+2)))
                        return false;
                    i += 2;
                    break;
                default:
                    break;
                }
            }

            // compensate for the last ++i in the inner for
            --i;
        }
    }

    return true;
}

contains() [3/3]

bool QPainterPath::contains

(

const QPainterPath &

p

)

const

Returns true if the given path p is contained within the current path.

Since

4.3

Returns false if any edges of the current path and p intersect.

Set operations on paths will treat the paths as areas. Non-closed paths will be treated as implicitly closed.

See also

intersects()

Definition at line 3529 of file qpainterpath.cpp.

{
    if (p.elementCount() == 1)
        return contains(p.elementAt(0));
    if (isEmpty() || p.isEmpty())
        return false;
    QPathClipper clipper(*this, p);
    return clipper.contains();
}

controlPointRect()

QRectF QPainterPath::controlPointRect

(

)

const

Returns the rectangle containing all the points and control points in this path.

This function is significantly faster to compute than the exact boundingRect(), and the returned rectangle is always a superset of the rectangle returned by boundingRect().

See also

boundingRect()

Definition at line 1549 of file qpainterpath.cpp.

Referenced by QAlphaPaintEnginePrivate::addPenWidth(), QGraphicsPathItem::boundingRect(), QGraphicsEllipseItem::boundingRect(), QGraphicsPolygonItem::boundingRect(), QGraphicsLineItem::boundingRect(), QGraphicsItem::collidesWithPath(), QGLLineMaskGenerator::computeScreenRect(), QGLRectMaskGenerator::computeScreenRect(), contains(), QRasterPaintEngine::fillPath(), intersects(), QGraphicsSceneIndex::items(), QRasterizer::rasterize(), QGraphicsSceneIndexPrivate::recursive_items_helper(), and QOpenGLPaintEnginePrivate::strokePathFastPen().

{
    if (!d_ptr)
        return QRectF();
    QPainterPathData *d = d_func();

    if (d->dirtyControlBounds)
        computeControlPointRect();
    return d->controlBounds;
}

cubicTo() [1/2]

void QPainterPath::cubicTo	(	const QPointF &	c1,
		const QPointF &	c2,
		const QPointF &	endPoint
	)

Adds a cubic Bezier curve between the current position and the given endPoint using the control points specified by c1, and c2.

After the curve is added, the current position is updated to be at the end point of the curve.

QLinearGradient myGradient; QPen myPen; QPainterPath myPath; myPath.cubicTo(c1, c2, endPoint); QPainter painter(this); painter.setBrush(myGradient); painter.setPen(myPen); painter.drawPath(myPath);

See also

quadTo(), {QPainterPath::Composing a QPainterPath}{Composing a QPainterPath}

Definition at line 821 of file qpainterpath.cpp.

Referenced by addEllipse(), QFreetypeFace::addGlyphToPath(), addGlyphToPath(), QDeclarativePathCubic::addToPath(), arcTo(), QOpenGLPaintEngine::clip(), QOutlineMapper::clipElements(), QMacFontPath::cubicTo(), QPicture::exec(), QPathClipper::handleCrossingEdges(), parsePathDataFast(), pathArcSegment(), qt_painterPathFromVectorPath(), quadTo(), QPainter::setViewTransformEnabled(), and toReversed().

{
#ifdef QPP_DEBUG
    printf("QPainterPath::cubicTo() (%.2f,%.2f), (%.2f,%.2f), (%.2f,%.2f)\n",
           c1.x(), c1.y(), c2.x(), c2.y(), e.x(), e.y());
#endif

    if (!qt_is_finite(c1.x()) || !qt_is_finite(c1.y()) || !qt_is_finite(c2.x()) || !qt_is_finite(c2.y())
        || !qt_is_finite(e.x()) || !qt_is_finite(e.y())) {
#ifndef QT_NO_DEBUG
        qWarning("QPainterPath::cubicTo: Adding point where x or y is NaN or Inf, ignoring call");
#endif
        return;
    }

    ensureData();
    detach();

    QPainterPathData *d = d_func();
    Q_ASSERT(!d->elements.isEmpty());


    // Abort on empty curve as a stroker cannot handle this and the
    // curve is irrelevant anyway.
    if (d->elements.last() == c1 && c1 == c2 && c2 == e)
        return;

    d->maybeMoveTo();

    Element ce1 = { c1.x(), c1.y(), CurveToElement };
    Element ce2 = { c2.x(), c2.y(), CurveToDataElement };
    Element ee = { e.x(), e.y(), CurveToDataElement };
    d->elements << ce1 << ce2 << ee;
}

cubicTo() [2/2]

void QPainterPath::cubicTo ( qreal  c1X, qreal  c1Y, qreal  c2X, qreal  c2Y, qreal  endPointX, qreal  endPointY  )

inline

Adds a cubic Bezier curve between the current position and the end point ({endPointX}, {endPointY}) with control points specified by ({c1X}, {c1Y}) and ({c2X}, {c2Y}).

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 323 of file qpainterpath.h.

{
    cubicTo(QPointF(ctrlPt1x, ctrlPt1y), QPointF(ctrlPt2x, ctrlPt2y),
            QPointF(endPtx, endPty));
}

currentPosition()

QPointF QPainterPath::currentPosition

(

)

const

Returns the current position of the path.

Definition at line 1044 of file qpainterpath.cpp.

{
    return !d_ptr || d_func()->elements.isEmpty()
        ? QPointF()
        : QPointF(d_func()->elements.last().x, d_func()->elements.last().y);
}

d_func()

QPainterPathData* QPainterPath::d_func ( ) const

inlineprivate

Definition at line 221 of file qpainterpath.h.

Referenced by addEllipse(), addPath(), addPolygon(), addRect(), addRegion(), boundingRect(), closeSubpath(), connectPath(), contains(), controlPointRect(), QVectorPath::convertToPainterPath(), cubicTo(), currentPosition(), detach_helper(), fillRule(), lineTo(), moveTo(), operator<<(), operator=(), operator==(), operator>>(), QPainterPath(), qtVectorPathForPath(), setFillRule(), and translate().

{ return reinterpret_cast<QPainterPathData *>(d_ptr.data()); }

detach()

void QPainterPath::detach ( )

inlineprivate

Definition at line 420 of file qpainterpath.h.

Referenced by addEllipse(), addPath(), addPolygon(), addRect(), addRegion(), addText(), arcTo(), closeSubpath(), connectPath(), cubicTo(), lineTo(), QMatrix::map(), QTransform::map(), moveTo(), quadTo(), setFillRule(), and translate().

{
    if (d_ptr->ref != 1)
        detach_helper();
    setDirty(true);
}

detach_helper()

void QPainterPath::detach_helper ( )

private

Warning

This function is not part of the public interface.

Definition at line 597 of file qpainterpath.cpp.

{
    QPainterPathPrivate *data = new QPainterPathData(*d_func());
    d_ptr.reset(data);
}

elementAt()

const QPainterPath::Element & QPainterPath::elementAt ( int  index ) const

inline

Returns the element at the given index in the painter path.

See also

ElementType, elementCount(), isEmpty()

Definition at line 402 of file qpainterpath.h.

Referenced by addGlyphToPath(), addLineTo(), QPathSegments::addPath(), bezierAtT(), charString(), QWin32PrintEnginePrivate::composeGdiPath(), contains(), QOutlineMapper::convertPath(), convertPath(), QX11PaintEngine::drawFreetype(), QSvgPaintEngine::drawPath(), QDirectFBPaintEngine::fill(), QPdf::generatePath(), QGLLineMaskGenerator::generateTrapezoids(), QGLRectMaskGenerator::generateTrapezoids(), QGLStrokeCache::getStrokedPath(), QPathClipper::handleCrossingEdges(), QGLMaskTextureCache::hash(), intersects(), QGraphicsSceneIndexPrivate::itemCollidesWithPath(), mapProjective(), nextBezier(), operator<<(), QVGPaintEnginePrivate::painterPathToVGPath(), pathClosed(), QPathClipper::pathToRect(), QOpenGLPaintEnginePrivate::pathToVertexArrays(), qt_find_ellipse_coords(), qt_ft_outline_cubic_to(), qt_mac_compose_path(), qt_painterpath_check_crossing(), qt_vg_pathToRect(), QRasterizer::rasterize(), QStrokerOps::strokePath(), and QOpenGLPaintEnginePrivate::strokePathFastPen().

{
    Q_ASSERT(d_ptr);
    Q_ASSERT(i >= 0 && i < elementCount());
    return d_ptr->elements.at(i);
}

elementCount()

int QPainterPath::elementCount ( ) const

inline

Returns the number of path elements in the painter path.

See also

ElementType, elementAt(), isEmpty()

Definition at line 397 of file qpainterpath.h.

Referenced by addGlyphToPath(), addLineTo(), QPathSegments::addPath(), bezierAtT(), charString(), QWin32PrintEnginePrivate::composeGdiPath(), contains(), QOutlineMapper::convertPath(), convertPath(), QX11PaintEngine::drawFreetype(), QSvgPaintEngine::drawPath(), QPainter::drawPath(), generateGlyph(), QPdf::generatePath(), QGLLineMaskGenerator::generateTrapezoids(), QGLRectMaskGenerator::generateTrapezoids(), QGLStrokeCache::getStrokedPath(), QPathClipper::handleCrossingEdges(), QGLMaskTextureCache::hash(), intersects(), QMatrix::map(), QTransform::map(), mapProjective(), nextBezier(), operator<<(), QVGPaintEnginePrivate::painterPathToVGPath(), pathClosed(), QPathClipper::pathToRect(), QOpenGLPaintEnginePrivate::pathToVertexArrays(), qt_find_ellipse_coords(), qt_ft_outline_cubic_to(), qt_mac_compose_path(), qt_painterpath_check_crossing(), qt_vg_pathToRect(), quadTo(), QRasterizer::rasterize(), QPainter::setClipPath(), QStrokerOps::strokePath(), QOpenGLPaintEnginePrivate::strokePathFastPen(), and toSubpathPolygons().

{
    return d_ptr ? d_ptr->elements.size() : 0;
}

ensureData()

void QPainterPath::ensureData ( )

inlineprivate

Definition at line 213 of file qpainterpath.h.

Referenced by addEllipse(), addPath(), addPolygon(), addRect(), addRegion(), addText(), arcTo(), connectPath(), QVectorPath::convertToPainterPath(), cubicTo(), lineTo(), moveTo(), operator>>(), quadTo(), and setFillRule().

{ if (!d_ptr) ensureData_helper(); }

ensureData_helper()

void QPainterPath::ensureData_helper ( )

private

Warning

This function is not part of the public interface.

Definition at line 606 of file qpainterpath.cpp.

{
    QPainterPathPrivate *data = new QPainterPathData;
    data->elements.reserve(16);
    QPainterPath::Element e = { 0, 0, QPainterPath::MoveToElement };
    data->elements << e;
    d_ptr.reset(data);
    Q_ASSERT(d_ptr != 0);
}

fillRule()

Qt::FillRule QPainterPath::fillRule

(

)

const

Returns the painter path's currently set fill rule.

See also

setFillRule()

Definition at line 1384 of file qpainterpath.cpp.

Referenced by QPathClipper::clip(), QOpenGLPaintEngine::clip(), QPainter::clipRegion(), QWin32PrintEnginePrivate::composeGdiPath(), contains(), QOutlineMapper::convertPath(), QCoreGraphicsPaintEngine::drawPath(), QVGPaintEngine::drawPath(), QSvgPaintEngine::drawPath(), QRasterPaintEngine::fillPath(), QX11PaintEnginePrivate::fillPath(), QOpenGLPaintEnginePrivate::fillPath(), QPdf::generatePath(), QGLPathMaskGenerator::generateTrapezoids(), mapProjective(), operator>>(), QPathClipper::QPathClipper(), setFillRule(), QCoreGraphicsPaintEngine::updateClipPath(), QX11PaintEngine::updateState(), and QOpenGLPaintEngine::updateState().

{
    return isEmpty() ? Qt::OddEvenFill : d_func()->fillRule;
}

intersected()

QPainterPath QPainterPath::intersected

(

const QPainterPath &

p

)

const

Returns a path which is the intersection of this path's fill area and p's fill area.

Since

4.3

Bezier curves may be flattened to line segments due to numerical instability of doing bezier curve intersections.

Definition at line 3425 of file qpainterpath.cpp.

Referenced by QOutlineMapper::clipElements(), QGraphicsItem::clipPath(), QX11PaintEnginePrivate::fillPath(), QPolygon::intersected(), QPolygonF::intersected(), operator!=(), and QPdfBaseEngine::updateClipPath().

{
    if (isEmpty() || p.isEmpty())
        return QPainterPath();
    QPathClipper clipper(*this, p);
    return clipper.clip(QPathClipper::BoolAnd);
}

intersects() [1/2]

bool QPainterPath::intersects

(

const QRectF &

rectangle

)

const

Returns true if any point in the given rectangle intersects the path; otherwise returns false.

There is an intersection if any of the lines making up the rectangle crosses a part of the path or if any part of the rectangle overlaps with any area enclosed by the path. This function respects the current fillRule to determine what is considered inside the path.

See also

contains()

Definition at line 2134 of file qpainterpath.cpp.

Referenced by QGraphicsItem::collidesWithPath(), QGraphicsSceneIndexPathIntersector::intersect(), and QGraphicsSceneIndexPrivate::itemCollidesWithPath().

{
    if (elementCount() == 1 && rect.contains(elementAt(0)))
        return true;

    if (isEmpty())
        return false;

    QRectF cp = controlPointRect();
    QRectF rn = rect.normalized();

    // QRectF::intersects returns false if one of the rects is a null rect
    // which would happen for a painter path consisting of a vertical or
    // horizontal line
    if (qMax(rn.left(), cp.left()) > qMin(rn.right(), cp.right())
        || qMax(rn.top(), cp.top()) > qMin(rn.bottom(), cp.bottom()))
        return false;

    // If any path element cross the rect its bound to be an intersection
    if (qt_painterpath_check_crossing(this, rect))
        return true;

    if (contains(rect.center()))
        return true;

    Q_D(QPainterPath);

    // Check if the rectangle surounds any subpath...
    for (int i=0; i<d->elements.size(); ++i) {
        const Element &e = d->elements.at(i);
        if (e.type == QPainterPath::MoveToElement && rect.contains(e))
            return true;
    }

    return false;
}

intersects() [2/2]

bool QPainterPath::intersects

(

const QPainterPath &

p

)

const

Returns true if the current path intersects at any point the given path p.

Since

4.3

Also returns true if the current path contains or is contained by any part of p.

Set operations on paths will treat the paths as areas. Non-closed paths will be treated as implicitly closed.

See also

contains()

Definition at line 3504 of file qpainterpath.cpp.

{
    if (p.elementCount() == 1)
        return contains(p.elementAt(0));
    if (isEmpty() || p.isEmpty())
        return false;
    QPathClipper clipper(*this, p);
    return clipper.intersect();
}

isEmpty()

bool QPainterPath::isEmpty ( ) const

inline

Returns true if either there are no elements in this path, or if the only element is a MoveToElement; otherwise returns false.

See also

elementCount()

Definition at line 392 of file qpainterpath.h.

Referenced by addPath(), QTextureGlyphCache::calculateSubPixelPositionCount(), QPaintEngineEx::clip(), QOutlineMapper::clipElements(), QGraphicsItem::clipPath(), closeSubpath(), QGraphicsItem::collidesWithPath(), connectPath(), contains(), QOutlineMapper::convertPath(), QPainterPathStroker::createStroke(), QTextLayout::draw(), QPainterPrivate::draw_helper(), QRenderRule::drawBackground(), QX11PaintEngine::drawPath(), QOpenGLPaintEngine::drawPath(), QPaintEngineEx::drawPath(), QPaintEngine::drawRects(), QPaintEngineEx::drawStaticTextItem(), QPaintEngine::drawTextItem(), QPainter::fillPath(), QOpenGLPaintEnginePrivate::fillPath(), fillRule(), QVGFontEngineCleaner::fontEngineDestroyed(), QPathClipper::handleCrossingEdges(), intersected(), intersects(), QMatrix::map(), operator<<(), QGraphicsPathItem::QGraphicsPathItem(), qt_mac_compose_path(), QRasterizer::rasterize(), QRenderRule::setClip(), QStrokerOps::strokePath(), QWin32PrintEnginePrivate::strokePath(), QPainter::strokePath(), subtracted(), toReversed(), toSubpathPolygons(), united(), QRenderRule::unsetClip(), QWin32PrintEngine::updateClipPath(), QCoreGraphicsPaintEngine::updateClipPath(), and QPdfBaseEngine::updateClipPath().

{
    return !d_ptr || (d_ptr->elements.size() == 1 && d_ptr->elements.first().type == MoveToElement);
}

length()

qreal QPainterPath::length

(

)

const

Returns the length of the current path.

Definition at line 2930 of file qpainterpath.cpp.

Referenced by bezierAtT().

{
    Q_D(QPainterPath);
    if (isEmpty())
        return 0;

    qreal len = 0;
    for (int i=1; i<d->elements.size(); ++i) {
        const Element &e = d->elements.at(i);

        switch (e.type) {
        case MoveToElement:
            break;
        case LineToElement:
        {
            len += QLineF(d->elements.at(i-1), e).length();
            break;
        }
        case CurveToElement:
        {
            QBezier b = QBezier::fromPoints(d->elements.at(i-1),
                                            e,
                                            d->elements.at(i+1),
                                            d->elements.at(i+2));
            len += b.length();
            i += 2;
            break;
        }
        default:
            break;
        }
    }
    return len;
}

lineTo() [1/2]

void QPainterPath::lineTo

(

const QPointF &

endPoint

)

Adds a straight line from the current position to the given endPoint.

After the line is drawn, the current position is updated to be at the end point of the line.

See also

addPolygon(), addRect(), {QPainterPath::Composing a QPainterPath}{Composing a QPainterPath}

Definition at line 758 of file qpainterpath.cpp.

Referenced by QFreetypeFace::addGlyphToPath(), addGlyphToPath(), addLineTo(), QDeclarativePathLine::addToPath(), arcTo(), QBalloonTip::balloon(), QRenderRule::borderClip(), QSvgLine::bounds(), QOpenGLPaintEngine::clip(), QOutlineMapper::clipElements(), collectSingleContour(), QPainter::drawChord(), QPlastiqueStyle::drawComplexControl(), QPainter::drawConvexPolygon(), QOpenGLPaintEnginePrivate::drawFastRect(), QX11PaintEngine::drawLines(), QOpenGLPaintEngine::drawLines(), QPdfBaseEngine::drawLines(), QPainter::drawLines(), QX11PaintEngine::drawPoints(), QPdfBaseEngine::drawPoints(), QPainter::drawPoints(), QWin32PrintEngine::drawPolygon(), QX11PaintEngine::drawPolygon(), QOpenGLPaintEngine::drawPolygon(), QSvgPaintEngine::drawPolygon(), QPdfBaseEngine::drawPolygon(), QPainter::drawPolygon(), QPainter::drawPolyline(), QWindowsCEStyle::drawPrimitive(), QCommonStyle::drawPrimitive(), QWindowsMobileStyle::drawPrimitive(), QMacStyle::drawPrimitive(), QPathClipper::handleCrossingEdges(), QRegion::intersects(), QMacFontPath::lineTo(), lineTo_clipped(), parsePathDataFast(), qt_painterPathFromVectorPath(), QGraphicsLineItem::shape(), and toReversed().

{
#ifdef QPP_DEBUG
    printf("QPainterPath::lineTo() (%.2f,%.2f)\n", p.x(), p.y());
#endif

    if (!qt_is_finite(p.x()) || !qt_is_finite(p.y())) {
#ifndef QT_NO_DEBUG
        qWarning("QPainterPath::lineTo: Adding point where x or y is NaN or Inf, ignoring call");
#endif
        return;
    }

    ensureData();
    detach();

    QPainterPathData *d = d_func();
    Q_ASSERT(!d->elements.isEmpty());
    d->maybeMoveTo();
    if (p == QPointF(d->elements.last()))
        return;
    Element elm = { p.x(), p.y(), LineToElement };
    d->elements.append(elm);

    d->convex = d->elements.size() == 3 || (d->elements.size() == 4 && d->isClosed());
}

lineTo() [2/2]

void QPainterPath::lineTo ( qreal  x, qreal  y  )

inline

Draws a line from the current position to the point ({x}, {y}).

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 308 of file qpainterpath.h.

{
    lineTo(QPointF(x, y));
}

moveTo() [1/2]

void QPainterPath::moveTo

(

const QPointF &

point

)

Moves the current point to the given point, implicitly starting a new subpath and closing the previous one.

See also

closeSubpath(), {QPainterPath::Composing a QPainterPath}{Composing a QPainterPath}

Definition at line 702 of file qpainterpath.cpp.

Referenced by add(), addEllipse(), QFreetypeFace::addGlyphToPath(), addGlyphToPath(), addPolygon(), addRect(), arcMoveTo(), QBalloonTip::balloon(), QRenderRule::borderClip(), QSvgLine::bounds(), QOpenGLPaintEngine::clip(), QOutlineMapper::clipElements(), collectSingleContour(), QPainter::drawChord(), QPlastiqueStyle::drawComplexControl(), QOpenGLPaintEnginePrivate::drawFastRect(), QOpenGLPaintEngine::drawLines(), QPdfBaseEngine::drawLines(), QPainter::drawLines(), QPainter::drawPie(), QX11PaintEngine::drawPoints(), QPdfBaseEngine::drawPoints(), QPainter::drawPoints(), QOpenGLPaintEngine::drawPolygon(), QPdfBaseEngine::drawPolygon(), QWindowsCEStyle::drawPrimitive(), QCommonStyle::drawPrimitive(), QWindowsMobileStyle::drawPrimitive(), QMacStyle::drawPrimitive(), QPicture::exec(), QPathClipper::handleCrossingEdges(), QRegion::intersects(), lineTo_clipped(), QMacFontPath::moveTo(), parsePathDataFast(), qt_painterPathFromVectorPath(), QPainter::setViewTransformEnabled(), QGraphicsEllipseItem::shape(), QGraphicsLineItem::shape(), and toReversed().

{
#ifdef QPP_DEBUG
    printf("QPainterPath::moveTo() (%.2f,%.2f)\n", p.x(), p.y());
#endif

    if (!qt_is_finite(p.x()) || !qt_is_finite(p.y())) {
#ifndef QT_NO_DEBUG
        qWarning("QPainterPath::moveTo: Adding point where x or y is NaN or Inf, ignoring call");
#endif
        return;
    }

    ensureData();
    detach();

    QPainterPathData *d = d_func();
    Q_ASSERT(!d->elements.isEmpty());

    d->require_moveTo = false;

    if (d->elements.last().type == MoveToElement) {
        d->elements.last().x = p.x();
        d->elements.last().y = p.y();
    } else {
        Element elm = { p.x(), p.y(), MoveToElement };
        d->elements.append(elm);
    }
    d->cStart = d->elements.size() - 1;
}

moveTo() [2/2]

void QPainterPath::moveTo ( qreal  x, qreal  y  )

inline

Moves the current position to ({x}, {y}) and starts a new subpath, implicitly closing the previous path.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 303 of file qpainterpath.h.

{
    moveTo(QPointF(x, y));
}

operator &()

QPainterPath QPainterPath::operator&

(

const QPainterPath &

other

)

const

Referenced by operator!=().

operator &=()

QPainterPath& QPainterPath::operator&=

(

const QPainterPath &

other

)

Referenced by operator-().

operator!=()

bool QPainterPath::operator!=

(

const QPainterPath &

path

)

const

Returns true if this painter path differs from the given path.

Note that comparing paths may involve a per element comparison which can be slow for complex paths.

See also

operator==()

Definition at line 2368 of file qpainterpath.cpp.

{
    return !(*this==path);
}

operator+()

QPainterPath QPainterPath::operator+

(

const QPainterPath &

other

)

const

Returns the union of this path and the other path.

Since

4.5

This function is equivalent to operator|().

See also

united(), operator+=(), operator-()

Definition at line 2414 of file qpainterpath.cpp.

{
    return united(other);
}

operator+=()

QPainterPath & QPainterPath::operator+=

(

const QPainterPath &

other

)

Unites this path with other, and returns a reference to this path.

Since

4.5

This is equivalent to operator|=().

See also

united(), operator+(), operator-=()

Definition at line 2475 of file qpainterpath.cpp.

{
    return *this = (*this + other);
}

operator-()

QPainterPath QPainterPath::operator-

(

const QPainterPath &

other

)

const

Subtracts the other path from a copy of this path, and returns the copy.

Since

4.5

See also

subtracted(), operator-=(), operator+()

Definition at line 2429 of file qpainterpath.cpp.

{
    return subtracted(other);
}

operator-=()

QPainterPath & QPainterPath::operator-=

(

const QPainterPath &

other

)

Subtracts other from this path, and returns a reference to this path.

Since

4.5

See also

subtracted(), operator-(), operator+=()

Definition at line 2491 of file qpainterpath.cpp.

{
    return *this = (*this - other);
}

operator=()

QPainterPath & QPainterPath::operator=

(

const QPainterPath &

path

)

Assigns the given path to this painter path.

See also

QPainterPath()

Definition at line 626 of file qpainterpath.cpp.

{
    if (other.d_func() != d_func()) {
        QPainterPathPrivate *data = other.d_func();
        if (data)
            data->ref.ref();
        d_ptr.reset(data);
    }
    return *this;
}

operator==()

bool QPainterPath::operator==

(

const QPainterPath &

path

)

const

Returns true if this painterpath is equal to the given path.

Note that comparing paths may involve a per element comparison which can be slow for complex paths.

See also

operator!=()

Definition at line 2333 of file qpainterpath.cpp.

{
    QPainterPathData *d = reinterpret_cast<QPainterPathData *>(d_func());
    if (path.d_func() == d)
        return true;
    else if (!d || !path.d_func())
        return false;
    else if (d->fillRule != path.d_func()->fillRule)
        return false;
    else if (d->elements.size() != path.d_func()->elements.size())
        return false;

    const qreal qt_epsilon = sizeof(qreal) == sizeof(double) ? 1e-12 : qreal(1e-5);

    QSizeF epsilon = boundingRect().size();
    epsilon.rwidth() *= qt_epsilon;
    epsilon.rheight() *= qt_epsilon;

    for (int i = 0; i < d->elements.size(); ++i)
        if (d->elements.at(i).type != path.d_func()->elements.at(i).type
            || !epsilonCompare(d->elements.at(i), path.d_func()->elements.at(i), epsilon))
            return false;

    return true;
}

operator|()

QPainterPath QPainterPath::operator|

(

const QPainterPath &

other

)

const

Returns the union of this path and the other path.

Since

4.5

See also

united(), operator|=(), intersected(), operator&()

Definition at line 2398 of file qpainterpath.cpp.

{
    return united(other);
}

operator|=()

QPainterPath & QPainterPath::operator|=

(

const QPainterPath &

other

)

Unites this path with other and returns a reference to this path.

Since

4.5

See also

united(), operator|(), operator&=()

Definition at line 2459 of file qpainterpath.cpp.

{
    return *this = (*this | other);
}

percentAtLength()

qreal QPainterPath::percentAtLength

(

qreal

len

)

const

Returns percentage of the whole path at the specified length len.

Note that similarly to other percent methods, the percentage measurement is not linear with regards to the length, if curves are present in the path. When curves are present the percentage argument is mapped to the t parameter of the Bezier equations.

Definition at line 2973 of file qpainterpath.cpp.

{
    Q_D(QPainterPath);
    if (isEmpty() || len <= 0)
        return 0;

    qreal totalLength = length();
    if (len > totalLength)
        return 1;

    qreal curLen = 0;
    for (int i=1; i<d->elements.size(); ++i) {
        const Element &e = d->elements.at(i);

        switch (e.type) {
        case MoveToElement:
            break;
        case LineToElement:
        {
            QLineF line(d->elements.at(i-1), e);
            qreal llen = line.length();
            curLen += llen;
            if (curLen >= len) {
                return len/totalLength ;
            }

            break;
        }
        case CurveToElement:
        {
            QBezier b = QBezier::fromPoints(d->elements.at(i-1),
                                            e,
                                            d->elements.at(i+1),
                                            d->elements.at(i+2));
            qreal blen = b.length();
            qreal prevLen = curLen;
            curLen += blen;

            if (curLen >= len) {
                qreal res = b.tAtLength(len - prevLen);
                return (res * blen + prevLen)/totalLength;
            }

            i += 2;
            break;
        }
        default:
            break;
        }
    }

    return 0;
}

pointAtPercent()

QPointF QPainterPath::pointAtPercent

(

qreal

t

)

const

Returns the point at at the percentage t of the current path.

The argument t has to be between 0 and 1.

Note that similarly to other percent methods, the percentage measurement is not linear with regards to the length, if curves are present in the path. When curves are present the percentage argument is mapped to the t parameter of the Bezier equations.

Definition at line 3090 of file qpainterpath.cpp.

{
    if (t < 0 || t > 1) {
        qWarning("QPainterPath::pointAtPercent accepts only values between 0 and 1");
        return QPointF();
    }

    if (!d_ptr || d_ptr->elements.size() == 0)
        return QPointF();

    if (d_ptr->elements.size() == 1)
        return d_ptr->elements.at(0);

    qreal totalLength = length();
    qreal curLen = 0;
    qreal bezierLen = 0;
    QBezier b = bezierAtT(*this, t, &curLen, &bezierLen);
    qreal realT = (totalLength * t - curLen) / bezierLen;

    return b.pointAt(qBound(qreal(0), realT, qreal(1)));
}

quadTo() [1/2]

void QPainterPath::quadTo	(	const QPointF &	c,
		const QPointF &	endPoint
	)

Adds a quadratic Bezier curve between the current position and the given endPoint with the control point specified by c.

After the curve is added, the current point is updated to be at the end point of the curve.

See also

cubicTo(), {QPainterPath::Composing a QPainterPath}{Composing a QPainterPath}

Definition at line 884 of file qpainterpath.cpp.

Referenced by addGlyphToPath(), QDeclarativePathQuad::addToPath(), generateWavyPixmap(), and parsePathDataFast().

{
#ifdef QPP_DEBUG
    printf("QPainterPath::quadTo() (%.2f,%.2f), (%.2f,%.2f)\n",
           c.x(), c.y(), e.x(), e.y());
#endif

    if (!qt_is_finite(c.x()) || !qt_is_finite(c.y()) || !qt_is_finite(e.x()) || !qt_is_finite(e.y())) {
#ifndef QT_NO_DEBUG
        qWarning("QPainterPath::quadTo: Adding point where x or y is NaN or Inf, ignoring call");
#endif
        return;
    }

    ensureData();
    detach();

    Q_D(QPainterPath);
    Q_ASSERT(!d->elements.isEmpty());
    const QPainterPath::Element &elm = d->elements.at(elementCount()-1);
    QPointF prev(elm.x, elm.y);

    // Abort on empty curve as a stroker cannot handle this and the
    // curve is irrelevant anyway.
    if (prev == c && c == e)
        return;

    QPointF c1((prev.x() + 2*c.x()) / 3, (prev.y() + 2*c.y()) / 3);
    QPointF c2((e.x() + 2*c.x()) / 3, (e.y() + 2*c.y()) / 3);
    cubicTo(c1, c2, e);
}

quadTo() [2/2]

void QPainterPath::quadTo ( qreal  cx, qreal  cy, qreal  endPointX, qreal  endPointY  )

inline

Adds a quadratic Bezier curve between the current point and the endpoint ({endPointX}, {endPointY}) with the control point specified by ({cx}, {cy}).

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 330 of file qpainterpath.h.

{
    quadTo(QPointF(ctrlPtx, ctrlPty), QPointF(endPtx, endPty));
}

setDirty()

void QPainterPath::setDirty ( bool  dirty )

private

Definition at line 3539 of file qpainterpath.cpp.

{
    d_func()->dirtyBounds        = dirty;
    d_func()->dirtyControlBounds = dirty;
    delete d_func()->pathConverter;
    d_func()->pathConverter = 0;
    d_func()->convex = false;
}

setElementPositionAt()

void QPainterPath::setElementPositionAt ( int  index, qreal  x, qreal  y  )

inline

Sets the x and y coordinate of the element at index index to x and y.

Since

4.2

Definition at line 409 of file qpainterpath.h.

Referenced by addLineTo().

{
    Q_ASSERT(d_ptr);
    Q_ASSERT(i >= 0 && i < elementCount());
    detach();
    QPainterPath::Element &e = d_ptr->elements[i];
    e.x = x;
    e.y = y;
}

setFillRule()

void QPainterPath::setFillRule

(

Qt::FillRule

fillRule

)

Sets the fill rule of the painter path to the given fillRule.

Qt provides two methods for filling paths:

Qt::OddEvenFill (default)	Qt::WindingFill

See also

fillRule()

Definition at line 1409 of file qpainterpath.cpp.

Referenced by QOpenGLPaintEngine::clip(), QOutlineMapper::clipElements(), createPathNode(), QPainterPathStroker::createStroke(), createSvgGlyph(), QSvgPath::draw(), QTextLayout::draw(), QTextLine::draw(), QPainter::drawConvexPolygon(), QOpenGLPaintEnginePrivate::drawFastRect(), QOpenGLPaintEngine::drawLines(), QX11PaintEngine::drawPath(), QX11PaintEngine::drawPolygon(), QOpenGLPaintEngine::drawPolygon(), QPdfBaseEngine::drawPolygon(), QPainter::drawPolygon(), QPaintEngineEx::drawStaticTextItem(), QPaintEngine::drawTextItem(), mapProjective(), path_for_glyphs(), qt_painterPathFromVectorPath(), and strokeForPath().

{
    ensureData();
    if (d_func()->fillRule == fillRule)
        return;
    detach();

    d_func()->fillRule = fillRule;
}

simplified()

QPainterPath QPainterPath::simplified

(

)

const

Returns a simplified version of this path.

Since

4.4

This implies merging all subpaths that intersect, and returning a path containing no intersecting edges. Consecutive parallel lines will also be merged. The simplified path will always use the default fill rule, Qt::OddEvenFill. Bezier curves may be flattened to line segments due to numerical instability of doing bezier curve intersections.

Definition at line 3482 of file qpainterpath.cpp.

Referenced by QPathClipper::clip().

{
    if(isEmpty())
        return *this;
    QPathClipper clipper(*this, QPainterPath());
    return clipper.clip(QPathClipper::Simplify);
}

slopeAtPercent()

qreal QPainterPath::slopeAtPercent

(

qreal

t

)

const

Returns the slope of the path at the percentage t.

The argument t has to be between 0 and 1.

Note that similarly to other percent methods, the percentage measurement is not linear with regards to the length, if curves are present in the path. When curves are present the percentage argument is mapped to the t parameter of the Bezier equations.

Definition at line 3156 of file qpainterpath.cpp.

{
    if (t < 0 || t > 1) {
        qWarning("QPainterPath::slopeAtPercent accepts only values between 0 and 1");
        return 0;
    }

    qreal totalLength = length();
    qreal curLen = 0;
    qreal bezierLen = 0;
    QBezier bez = bezierAtT(*this, t, &curLen, &bezierLen);
    qreal realT = (totalLength * t - curLen) / bezierLen;

    qreal m1 = slopeAt(realT, bez.x1, bez.x2, bez.x3, bez.x4);
    qreal m2 = slopeAt(realT, bez.y1, bez.y2, bez.y3, bez.y4);
    //tangent line
    qreal slope = 0;

#define SIGN(x) ((x < 0)?-1:1)
    if (m1)
        slope = m2/m1;
    else {
        //windows doesn't define INFINITY :(
#ifdef INFINITY
        slope = INFINITY*SIGN(m2);
#else
        if (sizeof(qreal) == sizeof(double)) {
            return 1.79769313486231570e+308;
        } else {
            return ((qreal)3.40282346638528860e+38);
        }
#endif
    }

    return slope;
}

subtracted()

QPainterPath QPainterPath::subtracted

(

const QPainterPath &

p

)

const

Returns a path which is p's fill area subtracted from this path's fill area.

Since

4.3

Set operations on paths will treat the paths as areas. Non-closed paths will be treated as implicitly closed. Bezier curves may be flattened to line segments due to numerical instability of doing bezier curve intersections.

Definition at line 3446 of file qpainterpath.cpp.

Referenced by QGraphicsTextItemPrivate::_q_mouseOnEdge(), operator-(), QPolygon::subtracted(), QPolygonF::subtracted(), subtractedInverted(), and QPdfBaseEngine::updateClipPath().

{
    if (isEmpty() || p.isEmpty())
        return *this;
    QPathClipper clipper(*this, p);
    return clipper.clip(QPathClipper::BoolSub);
}

subtractedInverted()

QPainterPath QPainterPath::subtractedInverted

(

const QPainterPath &

p

)

const

Use subtracted() instead.

Since

4.3

See also

subtracted()

Definition at line 3465 of file qpainterpath.cpp.

{
    return p.subtracted(*this);
}

swap()

void QPainterPath::swap ( QPainterPath &  other )

inline

Swaps painter path other with this painter path.

Since

4.8

This operation is very fast and never fails.

Definition at line 103 of file qpainterpath.h.

{ d_ptr.swap(other.d_ptr); }

toFillPolygon() [1/2]

QPolygonF QPainterPath::toFillPolygon

(

const QMatrix &

matrix = QMatrix()

)

const

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2915 of file qpainterpath.cpp.

Referenced by QOpenGLPaintEngine::clip(), clipTransformIsSimple(), QGLPathMaskGenerator::computeScreenRect(), QPaintEngine::drawEllipse(), QOpenGLPaintEnginePrivate::fillPath(), QPolygon::intersected(), QPolygonF::intersected(), QMatrix::map(), QTransform::map(), QmlJSDebugger::regionToPolygon(), QPolygon::subtracted(), QPolygonF::subtracted(), QX11PaintEnginePrivate::systemStateChanged(), QPolygon::united(), QPolygonF::united(), QCoreGraphicsPaintEngine::updateClipPath(), QX11PaintEngine::updateState(), and QOpenGLPaintEngine::updateState().

{
    return toFillPolygon(QTransform(matrix));
}

toFillPolygon() [2/2]

QPolygonF QPainterPath::toFillPolygon

(

const QTransform &

matrix

)

const

Converts the path into a polygon using the QTransform matrix, and returns the polygon.

The polygon is created by first converting all subpaths to polygons, then using a rewinding technique to make sure that overlapping subpaths can be filled using the correct fill rule.

Note that rewinding inserts addition lines in the polygon so the outline of the fill polygon does not match the outline of the path.

See also

toSubpathPolygons(), toFillPolygons(), {QPainterPath::QPainterPath Conversion}{QPainterPath Conversion}

Definition at line 2894 of file qpainterpath.cpp.

{

    QList<QPolygonF> flats = toSubpathPolygons(matrix);
    QPolygonF polygon;
    if (flats.isEmpty())
        return polygon;
    QPointF first = flats.first().first();
    for (int i=0; i<flats.size(); ++i) {
        polygon += flats.at(i);
        if (!flats.at(i).isClosed())
            polygon += flats.at(i).first();
        if (i > 0)
            polygon += first;
    }
    return polygon;
}

toFillPolygons() [1/2]

QList< QPolygonF > QPainterPath::toFillPolygons

(

const QMatrix &

matrix = QMatrix()

)

const

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 1808 of file qpainterpath.cpp.

Referenced by QX11PaintEnginePrivate::fillPath().

{
    return toFillPolygons(QTransform(matrix));
}

toFillPolygons() [2/2]

QList< QPolygonF > QPainterPath::toFillPolygons

(

const QTransform &

matrix

)

const

Converts the path into a list of polygons using the QTransform matrix, and returns the list.

The function differs from the toFillPolygon() function in that it creates several polygons. It is provided because it is usually faster to draw several small polygons than to draw one large polygon, even though the total number of points drawn is the same.

The toFillPolygons() function differs from the toSubpathPolygons() function in that it create only polygon for subpaths that have overlapping bounding rectangles.

Like the toFillPolygon() function, this function uses a rewinding technique to make sure that overlapping subpaths can be filled using the correct fill rule. Note that rewinding inserts addition lines in the polygons so the outline of the fill polygon does not match the outline of the path.

See also

toSubpathPolygons(), toFillPolygon(), {QPainterPath::QPainterPath Conversion}{QPainterPath Conversion}

Definition at line 1710 of file qpainterpath.cpp.

{

    QList<QPolygonF> polys;

    QList<QPolygonF> subpaths = toSubpathPolygons(matrix);
    int count = subpaths.size();

    if (count == 0)
        return polys;

    QList<QRectF> bounds;
    for (int i=0; i<count; ++i)
        bounds += subpaths.at(i).boundingRect();

#ifdef QPP_FILLPOLYGONS_DEBUG
    printf("QPainterPath::toFillPolygons, subpathCount=%d\n", count);
    for (int i=0; i<bounds.size(); ++i)
        qDebug() << " bounds" << i << bounds.at(i);
#endif

    QVector< QList<int> > isects;
    isects.resize(count);

    // find all intersections
    for (int j=0; j<count; ++j) {
        if (subpaths.at(j).size() <= 2)
            continue;
        QRectF cbounds = bounds.at(j);
        for (int i=0; i<count; ++i) {
            if (cbounds.intersects(bounds.at(i))) {
                isects[j] << i;
            }
        }
    }

#ifdef QPP_FILLPOLYGONS_DEBUG
    printf("Intersections before flattening:\n");
    for (int i = 0; i < count; ++i) {
        printf("%d: ", i);
        for (int j = 0; j < isects[i].size(); ++j) {
            printf("%d ", isects[i][j]);
        }
        printf("\n");
    }
#endif

    // flatten the sets of intersections
    for (int i=0; i<count; ++i) {
        const QList<int> &current_isects = isects.at(i);
        for (int j=0; j<current_isects.size(); ++j) {
            int isect_j = current_isects.at(j);
            if (isect_j == i)
                continue;
            for (int k=0; k<isects[isect_j].size(); ++k) {
                int isect_k = isects[isect_j][k];
                if (isect_k != i && !isects.at(i).contains(isect_k)) {
                    isects[i] += isect_k;
                }
            }
            isects[isect_j].clear();
        }
    }

#ifdef QPP_FILLPOLYGONS_DEBUG
    printf("Intersections after flattening:\n");
    for (int i = 0; i < count; ++i) {
        printf("%d: ", i);
        for (int j = 0; j < isects[i].size(); ++j) {
            printf("%d ", isects[i][j]);
        }
        printf("\n");
    }
#endif

    // Join the intersected subpaths as rewinded polygons
    for (int i=0; i<count; ++i) {
        const QList<int> &subpath_list = isects[i];
        if (!subpath_list.isEmpty()) {
            QPolygonF buildUp;
            for (int j=0; j<subpath_list.size(); ++j) {
                const QPolygonF &subpath = subpaths.at(subpath_list.at(j));
                buildUp += subpath;
                if (!subpath.isClosed())
                    buildUp += subpath.first();
                if (!buildUp.isClosed())
                    buildUp += buildUp.first();
            }
            polys += buildUp;
        }
    }

    return polys;
}

toReversed()

QPainterPath QPainterPath::toReversed

(

)

const

Creates and returns a reversed copy of the path.

It is the order of the elements that is reversed: If a QPainterPath is composed by calling the moveTo(), lineTo() and cubicTo() functions in the specified order, the reversed copy is composed by calling cubicTo(), lineTo() and moveTo().

Definition at line 1581 of file qpainterpath.cpp.

{
    Q_D(const QPainterPath);
    QPainterPath rev;

    if (isEmpty()) {
        rev = *this;
        return rev;
    }

    rev.moveTo(d->elements.at(d->elements.size()-1).x, d->elements.at(d->elements.size()-1).y);

    for (int i=d->elements.size()-1; i>=1; --i) {
        const QPainterPath::Element &elm = d->elements.at(i);
        const QPainterPath::Element &prev = d->elements.at(i-1);
        switch (elm.type) {
        case LineToElement:
            rev.lineTo(prev.x, prev.y);
            break;
        case MoveToElement:
            rev.moveTo(prev.x, prev.y);
            break;
        case CurveToDataElement:
            {
                Q_ASSERT(i>=3);
                const QPainterPath::Element &cp1 = d->elements.at(i-2);
                const QPainterPath::Element &sp = d->elements.at(i-3);
                Q_ASSERT(prev.type == CurveToDataElement);
                Q_ASSERT(cp1.type == CurveToElement);
                rev.cubicTo(prev.x, prev.y, cp1.x, cp1.y, sp.x, sp.y);
                i -= 2;
                break;
            }
        default:
            Q_ASSERT(!"qt_reversed_path");
            break;
        }
    }
    //qt_debug_path(rev);
    return rev;
}

toSubpathPolygons() [1/2]

QList< QPolygonF > QPainterPath::toSubpathPolygons

(

const QMatrix &

matrix = QMatrix()

)

const

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 1683 of file qpainterpath.cpp.

Referenced by QX11PaintEngine::drawPath(), QRegion::QRegion(), qt_bitmapToRegion(), and toFillPolygons().

{
    return toSubpathPolygons(QTransform(matrix));
}

toSubpathPolygons() [2/2]

QList< QPolygonF > QPainterPath::toSubpathPolygons

(

const QTransform &

matrix

)

const

Converts the path into a list of polygons using the QTransform matrix, and returns the list.

This function creates one polygon for each subpath regardless of intersecting subpaths (i.e. overlapping bounding rectangles). To make sure that such overlapping subpaths are filled correctly, use the toFillPolygons() function instead.

See also

toFillPolygons(), toFillPolygon(), {QPainterPath::QPainterPath Conversion}{QPainterPath Conversion}

Definition at line 1635 of file qpainterpath.cpp.

{

    Q_D(const QPainterPath);
    QList<QPolygonF> flatCurves;
    if (isEmpty())
        return flatCurves;

    QPolygonF current;
    for (int i=0; i<elementCount(); ++i) {
        const QPainterPath::Element &e = d->elements.at(i);
        switch (e.type) {
        case QPainterPath::MoveToElement:
            if (current.size() > 1)
                flatCurves += current;
            current.clear();
            current.reserve(16);
            current += QPointF(e.x, e.y) * matrix;
            break;
        case QPainterPath::LineToElement:
            current += QPointF(e.x, e.y) * matrix;
            break;
        case QPainterPath::CurveToElement: {
            Q_ASSERT(d->elements.at(i+1).type == QPainterPath::CurveToDataElement);
            Q_ASSERT(d->elements.at(i+2).type == QPainterPath::CurveToDataElement);
            QBezier bezier = QBezier::fromPoints(QPointF(d->elements.at(i-1).x, d->elements.at(i-1).y) * matrix,
                                       QPointF(e.x, e.y) * matrix,
                                       QPointF(d->elements.at(i+1).x, d->elements.at(i+1).y) * matrix,
                                                 QPointF(d->elements.at(i+2).x, d->elements.at(i+2).y) * matrix);
            bezier.addToPolygon(&current);
            i+=2;
            break;
        }
        case QPainterPath::CurveToDataElement:
            Q_ASSERT(!"QPainterPath::toSubpathPolygons(), bad element type");
            break;
        }
    }

    if (current.size()>1)
        flatCurves += current;

    return flatCurves;
}

translate() [1/2]

void QPainterPath::translate	(	qreal	dx,
		qreal	dy
	)

Translates all elements in the path by ({dx}, {dy}).

Since

4.6

See also

translated()

Definition at line 2177 of file qpainterpath.cpp.

Referenced by QGraphicsView::fitInView(), QGraphicsSceneIndexRectIntersector::intersect(), QTransform::map(), and translated().

{
    if (!d_ptr || (dx == 0 && dy == 0))
        return;

    int elementsLeft = d_ptr->elements.size();
    if (elementsLeft <= 0)
        return;

    detach();
    QPainterPath::Element *element = d_func()->elements.data();
    Q_ASSERT(element);
    while (elementsLeft--) {
        element->x += dx;
        element->y += dy;
        ++element;
    }
}

translate() [2/2]

void QPainterPath::translate ( const QPointF &  offset )

inline

Translates all elements in the path by the given offset.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Since

4.6

See also

translated()

Definition at line 386 of file qpainterpath.h.

{ translate(offset.x(), offset.y()); }

translated() [1/2]

QPainterPath QPainterPath::translated	(	qreal	dx,
		qreal	dy
	)		const

Returns a copy of the path that is translated by ({dx}, {dy}).

Since

4.6

See also

translate()

Definition at line 2215 of file qpainterpath.cpp.

Referenced by QGraphicsItem::mapFromParent(), QGraphicsItem::mapFromScene(), QGraphicsItem::mapToParent(), QGraphicsItem::mapToScene(), and QGraphicsSceneIndexPrivate::recursive_items_helper().

{
    QPainterPath copy(*this);
    copy.translate(dx, dy);
    return copy;
}

translated() [2/2]

QPainterPath QPainterPath::translated ( const QPointF &  offset ) const

inline

Returns a copy of the path that is translated by the given offset.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Since

4.6

See also

translate()

Definition at line 389 of file qpainterpath.h.

{ return translated(offset.x(), offset.y()); }

united()

QPainterPath QPainterPath::united

(

const QPainterPath &

p

)

const

Returns a path which is the union of this path's fill area and p's fill area.

Since

4.3

Set operations on paths will treat the paths as areas. Non-closed paths will be treated as implicitly closed. Bezier curves may be flattened to line segments due to numerical instability of doing bezier curve intersections.

See also

intersected(), subtracted()

Definition at line 3407 of file qpainterpath.cpp.

Referenced by operator+(), operator|(), QPolygon::united(), and QPolygonF::united().

{
    if (isEmpty() || p.isEmpty())
        return isEmpty() ? p : *this;
    QPathClipper clipper(*this, p);
    return clipper.clip(QPathClipper::BoolOr);
}

Friends and Related Functions

operator<<

QDataStream & operator<< ( QDataStream &  stream, const QPainterPath &  path  )

friend

Writes the given painter path to the given stream, and returns a reference to the stream.

See also

{Serializing Qt Data Types}

Definition at line 2509 of file qpainterpath.cpp.

{
    if (p.isEmpty()) {
        s << 0;
        return s;
    }

    s << p.elementCount();
    for (int i=0; i < p.d_func()->elements.size(); ++i) {
        const QPainterPath::Element &e = p.d_func()->elements.at(i);
        s << int(e.type);
        s << double(e.x) << double(e.y);
    }
    s << p.d_func()->cStart;
    s << int(p.d_func()->fillRule);
    return s;
}

operator>>

QDataStream & operator>> ( QDataStream &  stream, QPainterPath &  path  )

friend

Reads a painter path from the given stream into the specified path, and returns a reference to the stream.

See also

{Serializing Qt Data Types}

Definition at line 2539 of file qpainterpath.cpp.

{
    int size;
    s >> size;

    if (size == 0)
        return s;

    p.ensureData(); // in case if p.d_func() == 0
    if (p.d_func()->elements.size() == 1) {
        Q_ASSERT(p.d_func()->elements.at(0).type == QPainterPath::MoveToElement);
        p.d_func()->elements.clear();
    }
    p.d_func()->elements.reserve(p.d_func()->elements.size() + size);
    for (int i=0; i<size; ++i) {
        int type;
        double x, y;
        s >> type;
        s >> x;
        s >> y;
        Q_ASSERT(type >= 0 && type <= 3);
        if (!qt_is_finite(x) || !qt_is_finite(y)) {
#ifndef QT_NO_DEBUG
            qWarning("QDataStream::operator>>: NaN or Inf element found in path, skipping it");
#endif
            continue;
        }
        QPainterPath::Element elm = { qreal(x), qreal(y), QPainterPath::ElementType(type) };
        p.d_func()->elements.append(elm);
    }
    s >> p.d_func()->cStart;
    int fillRule;
    s >> fillRule;
    Q_ASSERT(fillRule == Qt::OddEvenFill || Qt::WindingFill);
    p.d_func()->fillRule = Qt::FillRule(fillRule);
    p.d_func()->dirtyBounds = true;
    p.d_func()->dirtyControlBounds = true;
    return s;
}

QMatrix

friend class QMatrix

friend

Definition at line 226 of file qpainterpath.h.

QPainterPathData

friend class QPainterPathData

friend

Definition at line 223 of file qpainterpath.h.

Referenced by detach_helper(), and ensureData_helper().

QPainterPathStroker

friend class QPainterPathStroker

friend

Definition at line 224 of file qpainterpath.h.

QPainterPathStrokerPrivate

friend class QPainterPathStrokerPrivate

friend

Definition at line 225 of file qpainterpath.h.

QTransform

friend class QTransform

friend

Definition at line 227 of file qpainterpath.h.

Referenced by toFillPolygons(), and toSubpathPolygons().

qtVectorPathForPath

Q_GUI_EXPORT const QVectorPath& qtVectorPathForPath ( const QPainterPath &  )

friend

Definition at line 129 of file qpaintengineex.cpp.

{
    Q_ASSERT(path.d_func());
    return path.d_func()->vectorPath();
}

QVectorPath

friend class QVectorPath

friend

Definition at line 228 of file qpainterpath.h.

Properties

d_ptr

QScopedPointer<QPainterPathPrivate, QPainterPathPrivateDeleter> QPainterPath::d_ptr

private

Definition at line 211 of file qpainterpath.h.

Referenced by boundingRect(), controlPointRect(), currentPosition(), detach_helper(), ensureData_helper(), QMatrix::map(), QTransform::map(), QPainterPath::Element::operator!=(), operator=(), QPainterPath(), swap(), and translate().

---

The documentation for this class was generated from the following files:

• /src/gui/painting/qpainterpath.h
• /src/gui/painting/qpainterpath.cpp