QCPainterPath Class

Member Function Documentation

QCPainterPath::QCPainterPath()

Constructs an empty path.

QCPainterPath::QCPainterPath(qsizetype commandsSize, qsizetype commandsDataSize = -1)

Constructs an empty path, allocating space for commandsSize amount of commands and optionally commandsDataSize amount of data. If commandsDataSize parameter is not given, space is automatically reserved for 2 * commandsSize amount of data, which is optimal amount when the path commands are straight lines (moveTo(), lineTo(), rect()).

Reserving correct space is an optimization for path creation and memory usage. It isn't mandatory as sufficient space will automatically be ensured while adding commands into the path.

See also reserve().

[noexcept] QCPainterPath::QCPainterPath(const QCPainterPath &path)

Constructs a path that is a copy of the given path.

[constexpr noexcept] QCPainterPath::QCPainterPath(QCPainterPath &&other)

Move-constructs a new QCPainterPath from other.

[noexcept] QCPainterPath::~QCPainterPath()

Destroys the path.

void QCPainterPath::addPath(const QCPainterPath &path, const QTransform &transform = QTransform())

Adds path into this path, optionally using transform to alter the path points. When transform is not provided (or it is identity matrix), this operation is very fast as it reuses the path data.

void QCPainterPath::addPath(const QCPainterPath &path, qsizetype start, qsizetype count, const QTransform &transform = QTransform())

Adds path into the current path, starting from the command at start and including count amount of commands. Optionally using transform to alter the path points. The range of start and count is checked, so that commands are not accessed more than QCPainterPath::commandsSize(). In case the path shouldn't continue from the current path position, call first moveTo() with path.positionAt(start - 1).

void QCPainterPath::arc(float centerX, float centerY, float radius, float a0, float a1, QCPainter::PathWinding direction = QCPainter::PathWinding::ClockWise, bool isConnected = true)

Creates an arc centered on QPointF(centerX, centerY) with the given radius, starting at an angle of a0 radians and ending at a1 radians. The arc spans the given direction. If isConnected is false, the previous path is closed and a new sub-path is started.

void QCPainterPath::arc(QPointF centerPoint, float radius, float a0, float a1, QCPainter::PathWinding direction = QCPainter::PathWinding::ClockWise, bool isConnected = true)

Creates an arc centered on centerPoint with the given radius, starting at an angle of a0 radians and ending at a1 radians. The arc spans the given direction. If isConnected is false, the previous path is closed and a new sub-path is started.

void QCPainterPath::arcTo(QPointF point1, QPointF point2, float radius)

Creates an arc using the points point1 and point2 with the given radius.

void QCPainterPath::arcTo(float x1, float y1, float x2, float y2, float radius)

Creates an arc using the points QPointF(x1, y1) and QPointF(x2, y2) with the given radius.

void QCPainterPath::bezierCurveTo(QPointF controlPoint1, QPointF controlPoint2, QPointF endPoint)

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

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

void QCPainterPath::bezierCurveTo(float cp1X, float cp1Y, float cp2X, float cp2Y, float x, float y)

void QCPainterPath::circle(float x, float y, float radius)

Adds a circle with center at QPointF(x, y) and the given radius to the path.

void QCPainterPath::circle(QPointF centerPoint, float radius)

Adds a circle with center at centerPoint and the given radius to the path.

void QCPainterPath::clear()

Clears the path commands and data.

Call this when the path commands change to recreate the path. This does not affect the memory usage, use reserve() and squeeze() for that.

See also reserve() and squeeze().

void QCPainterPath::closePath()

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

qsizetype QCPainterPath::commandsCapacity() const

Returns the capacity of commands in the path.

See also commandsDataCapacity() and reserve().

qsizetype QCPainterPath::commandsDataCapacity() const

Returns the capacity of commands data in the path.

See also commandsCapacity() and reserve().

qsizetype QCPainterPath::commandsDataSize() const

Returns the amount of commands data in the path.

Commands data basically means the points required by the commands.

qsizetype QCPainterPath::commandsSize() const

Returns the amount of commands in the path.

QPointF QCPainterPath::currentPosition() const

Returns the current position of the path. This means position where previous path command (moveTo, lineTo, bezierCurveTo etc.) has ended. When the path is empty, returns (0.0, 0.0).

void QCPainterPath::ellipse(float x, float y, float radiusX, float radiusY)

Creates an ellipse centered at (x, y), with radii defined by radiusX, radiusY and adds it to the path as a closed subpath.

void QCPainterPath::ellipse(const QRectF &rect)

Creates an ellipse within the rectangle rect and adds it to the path as a closed subpath.

bool QCPainterPath::isEmpty() const

Returns true when the path is empty.

See also clear.

void QCPainterPath::lineTo(QPointF point)

Adds a straight line from the current position to the given point. After the line is drawn, the current position is updated to be at the end point of the line.

void QCPainterPath::lineTo(float x, float y)

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

void QCPainterPath::moveTo(QPointF point)

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

void QCPainterPath::moveTo(float x, float y)

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

QPointF QCPainterPath::positionAt(qsizetype index) const

Returns the position of the path at index. This means position where path command (moveTo, lineTo, bezierCurveTo etc.) is at index. The index need to be between 0 and commandsSize() - 1. When the path is empty, returns (0.0, 0.0).

void QCPainterPath::quadraticCurveTo(QPointF controlPoint, QPointF endPoint)

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

void QCPainterPath::quadraticCurveTo(float cpX, float cpY, float x, float y)

Adds a quadratic Bezier curve between the current point and the endpoint (x, y) with the control point specified by (cpX, cpY).

void QCPainterPath::rect(float x, float y, float width, float height)

Creates a rectangle positioned at QPointF(x, y) with the given width and height.

void QCPainterPath::rect(const QRectF &rect)

Creates a rectangle specified by rect

void QCPainterPath::reserve(qsizetype commandsSize, qsizetype commandsDataSize = -1)

Reserves a given amounts of space in QCPainterPath's internal memory.

Attempts to allocate memory for at least commandsSize commands and commandsDataSize data points. Some path elements require multiple commands, see commandsSize() and commandsDataSize(). If commandsDataSize parameter is not given, space is automatically reserved for 2 * commandsSize amount of data, which is optimal amount when the path commands are straight lines (moveTo(), lineTo(), rect()).

Reserving correct space is an optimization for path creation and memory usage. It isn't mandatory as sufficient space will automatically be ensured while adding commands into the path.

See also squeeze(), commandsCapacity(), and commandsDataCapacity().

void QCPainterPath::roundRect(float x, float y, float width, float height, float radius)

Adds the given rectangle x, y, width, height with rounded corners to the path. The corners are quarter circles with the given radius.

void QCPainterPath::roundRect(float x, float y, float width, float height, float radiusTopLeft, float radiusTopRight, float radiusBottomRight, float radiusBottomLeft)

Adds the rectangle x, y, width, height with rounded corners to the path. The corners are quarter circles with radius radiusTopLeft, radiusTopRight radiusBottomRight and radiusBottomLeft, respectively.

void QCPainterPath::roundRect(const QRectF &rect, float radius)

Adds the given rectangle rect with rounded corners to the path. The corners are quarter circles with the given radius.

void QCPainterPath::roundRect(const QRectF &rect, float radiusTopLeft, float radiusTopRight, float radiusBottomRight, float radiusBottomLeft)

Adds the rectangle rect with rounded corners to the path. The corners are quarter circles with radius radiusTopLeft, radiusTopRight radiusBottomRight and radiusBottomLeft, respectively.

void QCPainterPath::setPathWinding(QCPainter::PathWinding winding)

Sets the current sub-path winding to either QCPainter::CounterClockWise (default) or QCPainter::ClockWise. CounterClockWise draws solid subpaths while ClockWise draws holes.

QCPainterPath QCPainterPath::sliced(qsizetype start, qsizetype count, const QTransform &transform = QTransform()) const &

Return this path, starting from the command at start and including count amount of commands. Optionally using transform to alter the path points. The range of start and count is checked, so that commands are not accessed more than commandsSize(). In case the command at start is not MoveTo, the first command will be replaced with MoveTo so that this slice is an individual path.

void QCPainterPath::squeeze()

Releases any memory not required to store the path commands and data. This can be used to reduce the memory usage after calling the reserve().

Normally this is not needed to be used, but it can be useful when the path size has been big due to reserving or adding many elements (lineTo, bezierCurveTo etc.) and then size is expected to be much smaller in future so calling first reserve() and then squeeze(), will release some memory.

See also reserve().

[noexcept] void QCPainterPath::swap(QCPainterPath &other)

Swaps this path with other. This operation is very fast and never fails.

QVariant QCPainterPath::operator QVariant() const

Returns the path as a QVariant.

bool QCPainterPath::operator!=(const QCPainterPath &path) const

Returns true if the path is different from the given path; otherwise false.

See also operator==().

[noexcept] QCPainterPath &QCPainterPath::operator=(QCPainterPath &&other)

Move-assigns other to this QCPainterPath instance.

[noexcept] QCPainterPath &QCPainterPath::operator=(const QCPainterPath &path)

Assigns the given path to this path and returns a reference to this path.

bool QCPainterPath::operator==(const QCPainterPath &path) const

Returns true if the path is equal to the given path; otherwise false.

See also operator!=().