- Qt 6.12
- Qt Canvas Painter
- C++ Classes
- QCanvasPainter
- Qt Canvas Painter | Commercial or GPLv3

# QCanvasPainter Class

The QCanvasPainter class performs hardware-accelerated painting on QRhi. More...

Header: | `#include <QCanvasPainter>`
CMake: | `find_package(Qt6 REQUIRED COMPONENTS CanvasPainter)` `target_link_libraries(mytarget PRIVATE Qt6::CanvasPainter)`
Since: | Qt 6.11

- List of all members, including inherited members

## Public Types

enum class | CompositeOperation { SourceOver, SourceAtop, DestinationOut }
`(since 6.12)` enum class | FillRule { NonZero, EvenOdd }
enum class | ImageFlag { GenerateMipmaps, RepeatX, RepeatY, Repeat, FlipY, …, Nearest }
flags | ImageFlags
enum class | LineCap { Butt, Round, Square }
enum class | LineJoin { Round, Bevel, Miter }
enum class | PathConnection { NotConnected, Connected }
enum class | PathWinding { CounterClockWise, ClockWise }
enum class | TextAlign { Left, Right, Center, Start, End }
enum class | TextBaseline { Top, Hanging, Middle, Alphabetic, Bottom }
enum class | TextDirection { LeftToRight, RightToLeft, Inherit, Auto }
enum class | WrapMode { NoWrap, Wrap, WordWrap, WrapAnywhere }

## Public Functions

| QCanvasPainter()
| ~QCanvasPainter()
qsizetype | activeImageCount() const
qsizetype | activeImageMemoryUsage() const
QCanvasImage | addImage(const QImage &image, QCanvasPainter::ImageFlags flags = {})
QCanvasImage | addImage(QRhiTexture *texture, QCanvasPainter::ImageFlags flags = {})
QCanvasImage | addImage(const QCanvasOffscreenCanvas &canvas, QCanvasPainter::ImageFlags flags = {})
void | addPath(const QPainterPath &path)
void | addPath(const QCanvasPath &path, const QTransform &transform = QTransform())
void | addPath(const QCanvasPath &path, qsizetype start, qsizetype count, const QTransform &transform = QTransform())
void | arc(qreal centerX, qreal centerY, qreal radius, qreal a0, qreal a1, QCanvasPainter::PathWinding direction = PathWinding::ClockWise, QCanvasPainter::PathConnection connection = PathConnection::Connected)
void | arc(QPointF centerPoint, qreal radius, qreal a0, qreal a1, QCanvasPainter::PathWinding direction = PathWinding::ClockWise, QCanvasPainter::PathConnection connection = PathConnection::Connected)
void | arcTo(qreal x1, qreal y1, qreal x2, qreal y2, qreal radius)
void | arcTo(QPointF controlPoint1, QPointF controlPoint2, qreal radius)
void | beginHoleSubPath()
void | beginPath()
void | beginSolidSubPath()
void | bezierCurveTo(qreal cp1X, qreal cp1Y, qreal cp2X, qreal cp2Y, qreal x, qreal y)
void | bezierCurveTo(QPointF controlPoint1, QPointF controlPoint2, QPointF endPoint)
void | circle(qreal centerX, qreal centerY, qreal radius)
void | circle(QPointF centerPoint, qreal radius)
void | cleanupResources()
void | clearRect(qreal x, qreal y, qreal width, qreal height)
void | clearRect(const QRectF &rect)
void | closePath()
QCanvasOffscreenCanvas | createCanvas(QSize pixelSize, int sampleCount = 1, QCanvasOffscreenCanvas::Flags flags = {})
void | destroyCanvas(QCanvasOffscreenCanvas &canvas)
void | drawBoxShadow(const QCanvasBoxShadow &shadow)
void | drawImage(const QCanvasImage &image, qreal x, qreal y)
void | drawImage(const QCanvasImage &image, const QRectF &destinationRect)
void | drawImage(const QCanvasImage &image, const QRectF &sourceRect, const QRectF &destinationRect)
void | drawImage(const QCanvasImage &image, qreal x, qreal y, qreal width, qreal height)
void | ellipse(qreal centerX, qreal centerY, qreal radiusX, qreal radiusY)
void | ellipse(const QRectF &rect)
void | ellipse(QPointF centerPoint, qreal radiusX, qreal radiusY)
void | fill()
`(since 6.12)` void | fill(QCanvasPainter::FillRule fillRule)
void | fill(const QCanvasPath &path, int pathGroup = -1)
`(since 6.12)` void | fill(const QCanvasPath &path, QCanvasPainter::FillRule fillRule, int pathGroup = -1)
void | fillRect(qreal x, qreal y, qreal width, qreal height)
void | fillRect(const QRectF &rect)
void | fillText(const QString &text, qreal x, qreal y, qreal maxWidth = 0)
void | fillText(const QString &text, const QRectF &rect)
void | fillText(const QString &text, QPointF point, qreal maxWidth = 0)
QTransform | getTransform() const
void | lineTo(qreal x, qreal y)
void | lineTo(QPointF point)
void | moveTo(qreal x, qreal y)
void | moveTo(QPointF point)
void | quadraticCurveTo(qreal cpX, qreal cpY, qreal x, qreal y)
void | quadraticCurveTo(QPointF controlPoint, QPointF endPoint)
void | rect(qreal x, qreal y, qreal width, qreal height)
void | rect(const QRectF &rect)
void | removeImage(const QCanvasImage &image)
void | removePathGroup(int pathGroup)
void | reset()
void | resetClipping()
void | resetTransform()
void | restore()
void | rotate(qreal angle)
void | roundRect(qreal x, qreal y, qreal width, qreal height, qreal radius)
void | roundRect(const QRectF &rect, qreal radius)
void | roundRect(const QRectF &rect, qreal radiusTopLeft, qreal radiusTopRight, qreal radiusBottomRight, qreal radiusBottomLeft)
void | roundRect(qreal x, qreal y, qreal width, qreal height, qreal radiusTopLeft, qreal radiusTopRight, qreal radiusBottomRight, qreal radiusBottomLeft)
void | save()
void | scale(qreal scale)
void | scale(qreal scaleX, qreal scaleY)
void | setAntialias(qreal antialias)
void | setClipRect(qreal x, qreal y, qreal width, qreal height)
void | setClipRect(const QRectF &rect)
`(since 6.12)` void | setFillRule(QCanvasPainter::FillRule fillRule)
void | setFillStyle(const QColor &color)
void | setFillStyle(const QCanvasBrush &brush)
void | setFont(const QFont &font)
void | setGlobalAlpha(qreal alpha)
void | setGlobalBrightness(qreal value)
void | setGlobalCompositeOperation(QCanvasPainter::CompositeOperation operation)
void | setGlobalContrast(qreal value)
void | setGlobalSaturation(qreal value)
void | setHighQualityStroking(bool enabled)
void | setLineCap(QCanvasPainter::LineCap cap)
void | setLineJoin(QCanvasPainter::LineJoin join)
void | setLineWidth(qreal width)
void | setMiterLimit(qreal limit)
void | setPathWinding(QCanvasPainter::PathWinding winding)
void | setStrokeStyle(const QColor &color)
void | setStrokeStyle(const QCanvasBrush &brush)
void | setTextAlign(QCanvasPainter::TextAlign align)
void | setTextAntialias(qreal antialias)
void | setTextBaseline(QCanvasPainter::TextBaseline baseline)
void | setTextDirection(QCanvasPainter::TextDirection direction)
void | setTextLineHeight(qreal height)
void | setTextWrapMode(QCanvasPainter::WrapMode wrapMode)
void | setTransform(const QTransform &transform)
void | setWindingEnforce(bool enabled)
void | skew(qreal angleX, qreal angleY = 0.0)
void | stroke()
void | stroke(const QCanvasPath &path, int pathGroup = -1)
void | strokeRect(qreal x, qreal y, qreal width, qreal height)
void | strokeRect(const QRectF &rect)
QRectF | textBoundingBox(const QString &text, qreal x, qreal y, qreal maxWidth = 0)
QRectF | textBoundingBox(const QString &text, const QRectF &rect)
QRectF | textBoundingBox(const QString &text, QPointF point, qreal maxWidth = 0)
void | transform(const QTransform &transform)
void | translate(qreal x, qreal y)
void | translate(QPointF point)

## Detailed Description

Qt Canvas Painter (QCanvasPainter) provides painting API optimized for hardware-accelerated (GPU) painting. The API closely follows the HTML Canvas 2D Context specification, ported to Qt C++. It is also influenced by QPainter, but with a more compact API.

Here is a simple example of using QCanvasPainter to create a round button.

     QRectF rect(40, 70, 120, 60);
     QRectF shadowRect = rect.translated(2, 4);
     // Paint shadow
     QCanvasBoxShadow shadow(shadowRect);
     shadow.setRadius(30);
     shadow.setBlur(15);
     shadow.setColor("#60373F26");
     p->drawBoxShadow(shadow);
     // Paint rounded rect
     p->beginPath();
     p->roundRect(rect, 30);
     p->setFillStyle("#DBEB00");
     p->fill();
     // Paint text
     p->setTextAlign(QCanvasPainter::TextAlign::Center);
     p->setTextBaseline(QCanvasPainter::TextBaseline::Middle);
     QFont font("Titillium Web", 18);
     p->setFont(font);
     p->setFillStyle("#373F26");
     p->fillText("CLICK!", rect);

Here is another example of painting a simple graph.

     // Paint grid
     QCanvasGridPattern grid(0, 0, 10, 10);
     grid.setLineColor("#404040");
     grid.setBackgroundColor("#202020");
     p->setFillStyle(grid);
     p->fillRect(0, 0, width(), height());
     // Paint axis
     p->setFillStyle(QColorConstants::White);
     p->fillRect(0, 0.5 * height() - 1, width(), 2);
     p->fillRect(0.5 * width() - 1, 0, 2, height());
     // Paint shadowed graph
     p->beginPath();
     p->moveTo(20, height() * 0.8);
     p->bezierCurveTo(width() * 0.2, height() * 0.4,
                      width() * 0.5, height() * 0.8,
                      width() - 20, height() * 0.2);
     p->setAntialias(10);
     p->setLineWidth(12);
     p->setStrokeStyle("#D0000000");
     p->stroke();
     p->setAntialias(1);
     p->setLineWidth(6);
     QCanvasLinearGradient lg(0, 0, 0, height());
     lg.setStartColor(QColorConstants::Red);
     lg.setEndColor(QColorConstants::Green);
     p->setStrokeStyle(lg);
     p->stroke();

### Features

For the most part, and from the naming perspective, QCanvasPainter follows HTML Canvas 2D Context (https://html.spec.whatwg.org/multipage/canvas.html#2dcontext). This makes the API familiar to use for many developers, and with the ability to easily reuse existing canvas code. But the aim is NOT to be 100% compatible with the HTML canvas. QCanvasPainter omits some of the features to make it simpler, more performant on QRhi hardware accelerated graphics API, and to better target modern UI needs. Due to these reasons, QCanvasPainter also has additional features compared to HTML Canvas 2D Context.

These are some of the functionality that are at least currently missing compared to HTML Canvas:

- Clipping: All clipping is (transformed) rectangle and clipping to path shapes is not supported.
- Dashes: Strokes are always solid lines, dashed/dotted stroke patterns are not supported.
- Path testing: There are no isPointInPath() or isPointInStroke() methods.
- Text stroking: No support for outline stroking of text.
- Filter: Canvas SVG filter effects are not supported.
- CompositeModes: The number of composite modes is limited to 3, which can be supported without rendering into extra buffers.
- Shadows: Built-in shadow methods are not supported.

On the other hand, some of the additional features QCanvasPainter offers compared to HTML Canvas include:

- Path groups: QCanvasPainter allows painting to static paths and caching these paths as groups for optimal GPU usage.
- Adjustable antialiasing: Due to path vertex antialiasing and SDF text rendering, the pixel amount of antialiasing can be freely adjusted for smoother painting.
- Box Gradient: In addition to linear, radial and conical gradients, QCanvasPainter also supports rounded rectangle box gradient.
- Box Shadow: QCanvasPainter also supports CSS box-shadow type of brush. The rendering uses a SDF approach similar to Qt Quick RectangularShadow, making it very performant.
- Grid patterns: QCanvasPainter supports QCanvasGridPattern for dynamic grid and bar pattern styles.
- Custom brushes: QCanvasPainter also allows filling & stroking with custom vertex and fragment shaders (QCanvasCustomBrush). These custom brushes can also be used for text.
- Text wrapping: QCanvasPainter supports automatic wrapping of text into multiple lines, with different wrapping modes.
- Color effects: In addition to globalAlpha, QCanvasPainter also supports global brightness, contrast and saturation.
- Tinted images: QCanvasPainter adds tint color support for painted images and image patterns.

QCanvasPainter is architecture agnostic, and usable for both Qt Quick and Qt Widgets applications. Actually, it is usable even without either of those, with just QWindow and QRhi. To utilize QCanvasPainter, use it from one of these classes, depending on the architecture of your application:

- Qt Quick: Use QCanvasPainterItem and QCanvasPainterItemRenderer.
- Qt Widgets: Use QCanvasPainterWidget.
- QRhi-based QWindow, or offscreen QRhi buffers: Use QCanvasPainterFactory and QCanvasRhiPaintDriver.

### Winding rules

QCanvasPainter uses NonZero ({Qt::WindingFill}) fillrule by default. To select the filling based on the path points direction, disable the winding forcing by calling setWindingEnforce(false).

     p->setWindingEnforce(false);
     p->beginPath();
     // Outer shape, counterclockwise
     p->moveTo(20, 20);
     p->lineTo(100, 180);
     p->lineTo(180, 20);
     p->closePath();
     // Inner shape, clockwise
     p->moveTo(100, 40);
     p->lineTo(125, 90);
     p->lineTo(75, 90);
     p->closePath();
     p->fill();
     p->stroke();

However, a more common case is relying on winding enforcing and setting the preferred winding using setPathWinding() or beginHoleSubPath() and beginSolidSubPath() helpers.

     p->beginPath();
     p->roundRect(20, 20, 160, 160, 30);
     // Start painting holes
     p->beginHoleSubPath();
     p->roundRect(40, 40, 120, 120, 10);
     // Start painting solid
     p->beginSolidSubPath();
     p->rect(60, 60, 80, 20);
     p->circle(100, 120, 20);
     p->fill();
     p->stroke();

## Member Type Documentation

### enum class QCanvasPainter::CompositeOperation

Qt Canvas Painter supports 3 composite operations:

Constant | Value | Description
--- | --- | ---
`QCanvasPainter::CompositeOperation::SourceOver` | `0` | The default value. Draws new shapes on top of the existing content.
`QCanvasPainter::CompositeOperation::SourceAtop` | `1` | The new shape is only drawn where it overlaps the existing content.
`QCanvasPainter::CompositeOperation::DestinationOut` | `2` | The existing content is kept where it doesn't overlap with the new shape.

See also setGlobalCompositeOperation().

### `[since 6.12]` enum class QCanvasPainter::FillRule

This enum specifies how paths are filled.

Constant | Value | Description
--- | --- | ---
`QCanvasPainter::FillRule::NonZero` | `0` | The path is filled using the non zero winding rule. With this rule, we determine whether a point is inside the shape by using the following method. Draw a horizontal line from the point to a location outside the shape. Determine whether the direction of the line at each intersection point is up or down. The winding number is determined by summing the direction of each intersection. If the number is non zero, the point is inside the shape. This fill mode can also in most cases be considered as the intersection of closed shapes. This mode is the default.
`QCanvasPainter::FillRule::EvenOdd` | `1` | The path is filled using the odd even fill rule. With this rule, we determine whether a point is inside the shape by using the following method. Draw a horizontal line from the point to a location outside the shape, and count the number of intersections. If the number of intersections is an odd number, the point is inside the shape.

This enum was introduced in Qt 6.12.

See also fill().

### enum class QCanvasPainter::ImageFlag
flags QCanvasPainter::ImageFlags

This enum specifies flags related to images. Use with addImage() to set the flags.

Constant | Value | Description
--- | --- | ---
`QCanvasPainter::ImageFlag::GenerateMipmaps` | `1 << 0` | Set this to generate mipmaps for the image. Mipmaps should be used when smoother output is preferred for images which are scaled to smaller than the original size.
`QCanvasPainter::ImageFlag::RepeatX` | `1 << 1` | Use with image pattern to repeat image in X-coordinate.
`QCanvasPainter::ImageFlag::RepeatY` | `1 << 2` | Use with image pattern to repeat image in Y-coordinate.
`QCanvasPainter::ImageFlag::Repeat` | `RepeatX | RepeatY` | Use with image pattern to repeat image in both coordinates.
`QCanvasPainter::ImageFlag::FlipY` | `1 << 3` | Flips (inverses) image in Y direction when rendered.
`QCanvasPainter::ImageFlag::Premultiplied` | `1 << 4` | Image data has premultiplied alpha.
`QCanvasPainter::ImageFlag::Nearest` | `1 << 5` | Image interpolation is Nearest instead Linear

The ImageFlags type is a typedef for QFlags<ImageFlag>. It stores an OR combination of ImageFlag values.

### enum class QCanvasPainter::LineCap

LineCap is used to define how the end of the line (cap) is drawn.

Constant | Value | Description
--- | --- | ---
`QCanvasPainter::LineCap::Butt` | `0` | (default) Square line ending that does not cover the end point of the line.
`QCanvasPainter::LineCap::Round` | `1` | Round line ending.
`QCanvasPainter::LineCap::Square` | `2` | Square line ending that covers the end point and extends beyond it by half the line width.

See also setLineCap().

### enum class QCanvasPainter::LineJoin

LineJoin is used to define how the joins between two connected lines are drawn.

Constant | Value | Description
--- | --- | ---
`QCanvasPainter::LineJoin::Round` | `0` | Circular arc between the two lines is filled.
`QCanvasPainter::LineJoin::Bevel` | `1` | The triangular notch between the two lines is filled.
`QCanvasPainter::LineJoin::Miter` | `2` | (default) The outer edges of the lines are extended to meet at an angle, and this area is filled.

See also setLineJoin() and setMiterLimit().

### enum class QCanvasPainter::PathConnection

With some drawing methods PathConnection is used to specify if the new path should be connected to the last point of the previous path.

Constant | Value | Description
--- | --- | ---
`QCanvasPainter::PathConnection::NotConnected` | `0` | There is no line drawn from the last point of the previous path to the first point of the current path.
`QCanvasPainter::PathConnection::Connected` | `1` | The last point of the previous path will be connected to the first point of the current path.

See also arc().

### enum class QCanvasPainter::PathWinding

PathWinding is used to specify the direction of path drawing. This direction is used to determine if a subpath is solid or hole in the path.

Constant | Value | Description
--- | --- | ---
`QCanvasPainter::PathWinding::CounterClockWise` | `0` | (default) Counter-clockwise winding for solid shapes.
`QCanvasPainter::PathWinding::ClockWise` | `1` | Clockwise winding for holes.

See also setPathWinding().

### enum class QCanvasPainter::TextAlign

TextAlign is used to define how the text is aligned horizontally.

Constant | Value | Description
--- | --- | ---
`QCanvasPainter::TextAlign::Left` | `0` | Align the left side of the text horizontally to the specified position.
`QCanvasPainter::TextAlign::Right` | `1` | Align the right side of the text horizontally to the specified position.
`QCanvasPainter::TextAlign::Center` | `2` | Align the center of the text horizontally to the specified position.
`QCanvasPainter::TextAlign::Start` | `3` | (default) The text is aligned at the normal start of the line (left-aligned for left-to-right locales, right-aligned for right-to-left locales).
`QCanvasPainter::TextAlign::End` | `4` | The text is aligned at the normal end of the line (right-aligned for left-to-right locales, left-aligned for right-to-left locales).

See also setTextAlign(), setTextDirection(), and fillText().

### enum class QCanvasPainter::TextBaseline

TextBaseline is used to define how the text is aligned (baselined) vertically.

Constant | Value | Description
--- | --- | ---
`QCanvasPainter::TextBaseline::Top` | `0` | Align the top of the text vertically to the specified position.
`QCanvasPainter::TextBaseline::Hanging` | `1` | Align the hanging baseline of the text vertically to the specified position.
`QCanvasPainter::TextBaseline::Middle` | `2` | Align the middle of the text vertically to the specified position.
`QCanvasPainter::TextBaseline::Alphabetic` | `3` | (default) Align the baseline of the text vertically to the specified position.
`QCanvasPainter::TextBaseline::Bottom` | `4` | Align the bottom of the text vertically to the specified position.

See also setTextBaseline() and fillText().

### enum class QCanvasPainter::TextDirection

TextDirection is used to define how the text is aligned horizontally.

Constant | Value | Description
--- | --- | ---
`QCanvasPainter::TextDirection::LeftToRight` | `0` | The text direction is left-to-right.
`QCanvasPainter::TextDirection::RightToLeft` | `1` | The text direction is right-to-left.
`QCanvasPainter::TextDirection::Inherit` | `2` | (default) The text direction is inherited from QGuiApplication layoutDirection. See https://doc.qt.io/qt-6/qguiapplication.html#layoutDirection-prop.
`QCanvasPainter::TextDirection::Auto` | `3` | The text direction is detected automatically based from the text string. See QString::isRightToLeft(). Note: As this requires analyzing the text, it is potentially slower than other options.

See also setTextDirection(), setTextAlign(), and fillText().

### enum class QCanvasPainter::WrapMode

WrapMode is used to define how the text is wrapped to multiple lines.

Constant | Value | Description
--- | --- | ---
`QCanvasPainter::WrapMode::NoWrap` | `0` | (default) No wrapping will be performed. If the text contains insufficient newlines, then contentWidth will exceed a set width.
`QCanvasPainter::WrapMode::Wrap` | `1` | If possible, wrapping occurs at a word boundary; otherwise it will occur at the appropriate point on the line, even in the middle of a word.
`QCanvasPainter::WrapMode::WordWrap` | `2` | Wrapping is done on word boundaries only. If a word is too long, content width will exceed a set width.
`QCanvasPainter::WrapMode::WrapAnywhere` | `3` | Wrapping is done at any point on a line, even if it occurs in the middle of a word.

See also setTextWrapMode() and fillText().

## Member Function Documentation

### QCanvasPainter::QCanvasPainter()

Constructs a painter.

### `[noexcept]` QCanvasPainter::~QCanvasPainter()

Destroys the painter.

### qsizetype QCanvasPainter::activeImageCount() const

Returns the number of active QCanvasImage objects registered with this QCanvasPainter. This also includes the internally created images for gradients.

QCanvasImage objects created by registering QCanvasOffscreenCanvas instances or externally managed textures are not taken into account by this function.

See also activeImageMemoryUsage(), addImage(), and removeImage().

### qsizetype QCanvasPainter::activeImageMemoryUsage() const

Returns an approximation in kilobytes of the memory used by the image (pixel) data for all active QCanvasImage instances for this painter that were created by the addImage() overload taking a QImage. It also includes the data from internally created images for gradients.

QCanvasPainter does not keep copies of the CPU-side QImage data once addImage() has returned. Therefore, the result of this function is an approximation of the GPU memory that is used for textures.

Note: The value is only an estimate based on the image format and dimensions. Qt has no knowledge of how the data for textures is stored and laid out in memory on the GPU side.

Offscreen canvases and externally managed textures registered via the other addImage() overloads are not taken into account by this function.

For every valid QCanvasImage, the individual size in bytes can always be queried by calling sizeInBytes(). That function returns valid results also when the QCanvasImage was created from a QCanvasOffscreenCanvas or QRhiTexture, but it does not consider mipmap or multisample data.

See also activeImageCount(), addImage(), and removeImage().

### QCanvasImage QCanvasPainter::addImage(const QImage &image, QCanvasPainter::ImageFlags flags = {})

Adds image with flags available for the painter as a texture. Returns QCanvasImage with the texture id and other information about the image. Returned QCanvasImage can then be used with drawImage and QCanvasImagePattern. After calling this method, the image QImage does not need to be kept in memory.

Calling with the same image is a cheap operation, since a cache hit is expected.

Care must be taken when optimizing to call addImage() only once. That is not always sufficient, depending on the application design. For example, if the underlying graphics resources are lost, e.g. because the painter is associated with a new QRhi under the hood due to moving a widget to a new top-level, then calling this function is essential in order to re-create the native graphics textures from image.

See also drawImage() and removeImage().

### QCanvasImage QCanvasPainter::addImage(QRhiTexture *texture, QCanvasPainter::ImageFlags flags = {})

Adds texture with flags available for the painter as a texture. The returned QCanvasImage can be used with drawImage and QCanvasImagePattern.

Note: The ownership of texture is not taken.

This is an overloaded function.

See also drawImage() and removeImage().

### QCanvasImage QCanvasPainter::addImage(const QCanvasOffscreenCanvas &canvas, QCanvasPainter::ImageFlags flags = {})

Registers canvas with flags to the painter so that it is available as an image. The returned QCanvasImage can be used with drawImage and QCanvasImagePattern.

Note: canvas continues to manage the underlying native graphics resources, meaning removeImage() does not render canvas invalid.

This is an overloaded function.

See also drawImage() and removeImage().

### void QCanvasPainter::addPath(const QPainterPath &path)

Adds path into the current path.

Note: QCanvasPainter uses NonZero (Qt::WindingFill) fillrule by default, while QPainterPath defaults to Qt::OddEvenFill. So remember to switch the fillRule if needed, for example, by using setFillRule().

Note: This method is available mostly for the compatibility with QPainter and QPainterPath. It does not increase performance compared to painting the path directly with QCanvasPainter methods.

### void QCanvasPainter::addPath(const QCanvasPath &path, const QTransform &transform = QTransform())

Adds path into the current 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.

     // m_path is QCanvasPath
     if (m_path.isEmpty())
         m_path.circle(60, 60, 40);
     p->beginPath();
     p->addPath(m_path);
     p->addPath(m_path, QTransform::fromTranslate(80, 80));
     p->fill();
     p->stroke();

### void QCanvasPainter::addPath(const QCanvasPath &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 QCanvasPath::commandsSize(). In case the path shouldn't continue from the current path position, call first moveTo() e.g. with `path.positionAt(start - 1)`.

     // m_path is QCanvasPath
     if (m_path.isEmpty()) {
         m_path.moveTo(20, 60);
         for (int i = 1; i < 160; i++) {
             m_path.lineTo(20 + i,
                           60 + 20 * sin(0.1 * i));
         }
     }
     p->stroke(m_path);
     p->beginPath();
     p->addPath(m_path, 20, 100,
                QTransform::fromTranslate(0, 80));
     p->stroke();

### void QCanvasPainter::arc(qreal centerX, qreal centerY, qreal radius, qreal a0, qreal a1, QCanvasPainter::PathWinding direction = PathWinding::ClockWise, QCanvasPainter::PathConnection connection = PathConnection::Connected)

Creates a new circle arc shaped sub-path. The arc center is at centerX, centerY, with radius, and the arc is drawn from angle a0 to a1, and swept in direction (ClockWise or CounterClockWise). When connection is NotConnected, arc does not add a line from the previous path position to the start of the arc. Angles are specified in radians.

     p->beginPath();
     p->moveTo(100, 100);
     p->arc(100, 100, 80, 0, 1.5 * M_PI);
     p->closePath();
     p->fill();
     p->stroke();

Note: While HTML canvas 2D context uses arc() for painting circles, with QCanvasPainter it is recommended to use circle() or ellipse() for those.

### void QCanvasPainter::arc(QPointF centerPoint, qreal radius, qreal a0, qreal a1, QCanvasPainter::PathWinding direction = PathWinding::ClockWise, QCanvasPainter::PathConnection connection = PathConnection::Connected)

Creates a new circle arc shaped sub-path. The arc center is at centerPoint, with radius, and the arc is drawn from angle a0 to a1, and swept in direction (ClockWise or CounterClockWise). When connection is NotConnected, arc does not add a line from the previous path position to the start of the arc. Angles are specified in radians.

Note: While HTML canvas 2D context uses arc() for painting circles, with QCanvasPainter it is recommended to use circle() or ellipse() for those.

This is an overloaded function.

### void QCanvasPainter::arcTo(qreal x1, qreal y1, qreal x2, qreal y2, qreal radius)

Adds an arc segment at the corner defined by the last path point, and two specified points (x1, y1 and x2, y2) with radius. The arc is automatically connected to the path's latest point with a straight line if necessary.

     p->beginPath();
     p->moveTo(20, 20);
     p->arcTo(240, 20, 20, 220, 50);
     p->arcTo(20, 220, 20, 20, 30);
     p->stroke();

### void QCanvasPainter::arcTo(QPointF controlPoint1, QPointF controlPoint2, qreal radius)

Adds an arc segment at the corner defined by the last path point, and two specified points (controlPoint1 and controlPoint2) with radius. The arc is automatically connected to the path's latest point with a straight line if necessary.

This is an overloaded function.

### void QCanvasPainter::beginHoleSubPath()

Start a hole subpath. This is equivalent to `setPathWinding(QCanvasPainter::PathWinding::ClockWise)`)

     p->beginPath();
     p->circle(100, 100, 80);
     p->beginHoleSubPath();
     p->rect(60, 60, 80, 80);
     p->beginSolidSubPath();
     p->circle(100, 100, 20);
     p->fill();
     p->stroke();

See also beginSolidSubPath().

### void QCanvasPainter::beginPath()

Begins drawing a new path while clearing the current path.

### void QCanvasPainter::beginSolidSubPath()

Start a solid subpath. This is equivalent to `setPathWinding(QCanvasPainter::PathWinding::CounterClockWise)`)

See also beginHoleSubPath().

### void QCanvasPainter::bezierCurveTo(qreal cp1X, qreal cp1Y, qreal cp2X, qreal cp2Y, qreal x, qreal y)

Adds a cubic bezier segment from the last point in the path via two control points (cp1X, cp1Y and cp2X, cp2Y) to the specified point (x, y).

     p->beginPath();
     p->moveTo(20, 20);
     p->bezierCurveTo(150, 50, 50, 250, 180, 120);
     p->stroke();

### void QCanvasPainter::bezierCurveTo(QPointF controlPoint1, QPointF controlPoint2, QPointF endPoint)

Adds a cubic bezier segment from the last point in the path via two control points (controlPoint1 and controlPoint2) to the specified point endPoint.

This is an overloaded function.

### void QCanvasPainter::circle(qreal centerX, qreal centerY, qreal radius)

Creates a new circle shaped sub-path centered at ( centerX, centerY) with radius.

     p->beginPath();
     p->circle(100, 100, 80);
     p->fill();
     p->stroke();

### void QCanvasPainter::circle(QPointF centerPoint, qreal radius)

Creates a new circle shaped sub-path centered at centerPoint with radius.

This is an overloaded function.

### void QCanvasPainter::cleanupResources()

Schedules dropping unused textures from the cache.

Additionally, other caches and pools may get shrunk upon calling this function, in order to minimize memory usage. This may potentially lead to more expensive drawing calls afterwards.

### void QCanvasPainter::clearRect(qreal x, qreal y, qreal width, qreal height)

Erases the pixels in a rectangular area by filling the rectangle specified by x, y, width, height with transparent black. As clearing does not need blending, it can be faster than fillRect().

     p->beginPath();
     p->circle(100, 100, 80);
     p->fill();
     p->stroke();
     p->clearRect(60, 0, 80, 120);

### void QCanvasPainter::clearRect(const QRectF &rect)

Erases the pixels in a rectangular area by filling the rectangle specified by rect with transparent black. This is an overloaded method using QRectF.

This is an overloaded function.

### void QCanvasPainter::closePath()

Closes the current sub-path with a line segment. This is equivalent to lineTo([starting point]) as the last path element.

### QCanvasOffscreenCanvas QCanvasPainter::createCanvas(QSize pixelSize, int sampleCount = 1, QCanvasOffscreenCanvas::Flags flags = {})

Returns a new offscreen canvas with the given pixelSize, sampleCount, and flags.

The size of the canvas is specified in pixels. The pixelSize, sampleCount, and flags properties are immutable afterwards. To get a canvas with a different size, sample count, or flags, create a new one.

To target an offscreen canvas with with draw commands, call the appropriate QCanvasRhiPaintDriver::beginPaint() overload when working with the lower level API, or QCanvasPainterWidget::beginCanvasPainting() or QCanvasPainterItemRenderer::beginCanvasPainting() when using the convenience widget or Qt Quick item classes.

Normally the contents of the canvas is cleared when painting to it. To disable this, pass PreserveContents in flags.

To request multisample rendering onto the canvas (multisample antialiasing, MSAA), set a sample count larger than 1, such as 4 or 8. Preserving the canvas contents between render passes is not supported however when multisampling is enabled, and the PreserveContents flag will not work in this case.

Note: An offscreen canvas is backed by a texture independent from the main render target, and rendering to it always happens with a scale factor (device pixel ratio) of 1. For example, to create a canvas matching the true rendering dimensions of a QCanvasPainterWidget, pass `size() * devicePixelRatio()` as pixelSize, because the `size()` of the widget is just the logical size without the scale factor included.

### void QCanvasPainter::destroyCanvas(QCanvasOffscreenCanvas &canvas)

Destroys the resources backing canvas. canvas becomes a null canvas then.

The painter automatically does this upon its destruction. Therefore, calling this function is only necessary when releasing the associated resources is desired right away.

### void QCanvasPainter::drawBoxShadow(const QCanvasBoxShadow &shadow)

Draws a box shadow. The shadow will be painted with position, size, color, blur etc. defined by shadow. Calling beginPath() before this method is not required.

Note: To visually see the area covered by drawBoxShadow(), set `QCPAINTER_DEBUG_SHADOW_RECT` environment variable.

     QRectF rect(40, 40, 120, 120);
     QRectF shadowRect = rect.translated(-2, 4);
     QCanvasBoxShadow shadow(shadowRect);
     shadow.setBlur(30);
     p->drawBoxShadow(shadow);
     p->beginPath();
     p->roundRect(rect, 30);
     p->setFillStyle("#2CDE85");
     p->fill();

See also QCanvasBoxShadow.

### void QCanvasPainter::drawImage(const QCanvasImage &image, qreal x, qreal y)

Draw image into x, y, at its default size.

     static QImage logo(":/qt_logo.png");
     QCanvasImage image = p->addImage(logo);
     p->drawImage(image, 36, 36);

See also addImage().

### void QCanvasPainter::drawImage(const QCanvasImage &image, const QRectF &destinationRect)

Draw image into position and size of destinationRect.

This is an overloaded function.

See also addImage().

### void QCanvasPainter::drawImage(const QCanvasImage &image, const QRectF &sourceRect, const QRectF &destinationRect)

Draw image into position and size of destinationRect, from sourceRect area of image.

     static QImage logo(":/qt_logo.png");
     QCanvasImage image = p->addImage(logo);
     QRectF sourceRect(20, 30, 54, 76);
     QRectF destinationRect(0, 0, 200, 200);
     p->drawImage(image, sourceRect, destinationRect);

This is an overloaded function.

See also addImage().

### void QCanvasPainter::drawImage(const QCanvasImage &image, qreal x, qreal y, qreal width, qreal height)

Draw image into x, y, at given width and height.

     static QImage logo(":/qt_logo.png");
     QCanvasImage image = p->addImage(logo);
     p->drawImage(image, 50, 0, 100, 200);

This is an overloaded function.

See also addImage().

### void QCanvasPainter::ellipse(qreal centerX, qreal centerY, qreal radiusX, qreal radiusY)

Creates a new ellipse shaped sub-path centered at ( centerX, centerY) with radiusX and radiusY.

     p->beginPath();
     p->ellipse(100, 100, 80, 60);
     p->fill();
     p->stroke();

### void QCanvasPainter::ellipse(const QRectF &rect)

Creates a new ellipse shaped sub-path into rect. This ellipse will cover the rect area.

     QRectF rect(40, 20, 120, 160);
     p->fillRect(rect);
     p->beginPath();
     p->ellipse(rect);
     p->stroke();

This is an overloaded function.

### void QCanvasPainter::ellipse(QPointF centerPoint, qreal radiusX, qreal radiusY)

Creates a new ellipse shaped sub-path centered at centerPoint with radiusX and radiusY.

This is an overloaded function.

### void QCanvasPainter::fill()

Fills the current path with the current fill style, and the current fill rule.

     p->beginPath();
     p->rect(20, 20, 40, 160);
     p->rect(140, 20, 40, 160);
     p->circle(100, 100, 60);
     p->fill();

See also setFillStyle() and setFillRule().

### `[since 6.12]` void QCanvasPainter::fill(QCanvasPainter::FillRule fillRule)

Fills the current path with the current fill style, and fill rule fillRule.

This is an overloaded function.

This function was introduced in Qt 6.12.

See also setFillStyle() and setFillRule().

### void QCanvasPainter::fill(const QCanvasPath &path, int pathGroup = -1)

Fills the path with the current fill style and fill rule, and belonging into pathGroup. Painting through QCanvasPath is optimal when the path contains more commands and is mostly static.

When pathGroup is `-1`, the path will not be cached on the GPU side. This is the default. To request caching of path data, pass a value equal to or greater than `0`. More information about using path cache groups can be found in the QCanvasPath documentation.

Calling beginPath() before this method is not required.

     // m_path is QCanvasPath
     if (m_path.isEmpty()) {
         for (int i = 0; i < 16; i++) {
             qreal w = 100 + 60 * sin(i);
             m_path.rect(100 - w * 0.5,
                         22 + i * 10,
                         w, 6);
         }
     }
     p->fill(m_path);

This is an overloaded function.

See also setFillStyle(), setFillRule(), and removePathGroup().

### `[since 6.12]` void QCanvasPainter::fill(const QCanvasPath &path, QCanvasPainter::FillRule fillRule, int pathGroup = -1)

Fills the path with the current fill style and fill rule fillRule

This is an overloaded function.

This function was introduced in Qt 6.12.

### void QCanvasPainter::fillRect(qreal x, qreal y, qreal width, qreal height)

Draws a filled rectangle into the specified position ( x, y) with size width, height.

Note: This is provided for convenience. When filling more than just a single rect, prefer using rect().

     p->fillRect(20, 20, 160, 160);
     // The above code does same as:
     //  p->beginPath();
     //  p->rect(20, 20, 160, 160);
     //  p->fill();

### void QCanvasPainter::fillRect(const QRectF &rect)

Draws a filled rectangle into rect. This is an overloaded method using QRectF.

Note: This is provided for convenience. When filling more than just a single rect, prefer using rect().

This is an overloaded function.

### void QCanvasPainter::fillText(const QString &text, qreal x, qreal y, qreal maxWidth = 0)

Draws text string at the specified location ( x, y), with current textAlign and textBaseline. To make the text wrap into multiple lines, set the text wrap mode using setTextWrapMode() to something else than the default `NoWrap`. Optional maxWidth parameter defaults to `0`. Meaning that when e.g. `WordWrap` has been set, text is wrapped on every word. Set the maxWidth parameter to preferred row width in pixels.

     p->setTextAlign(QCanvasPainter::TextAlign::Center);
     p->setTextBaseline(QCanvasPainter::TextBaseline::Middle);
     QString text("Qt Canvas Painter");
     p->fillText(text, 100, 30);
     p->setTextWrapMode(QCanvasPainter::WrapMode::WordWrap);
     p->fillText(text, 100, 90);
     p->fillText(text, 100, 160, 120);

See also setTextAlign(), setTextBaseline(), and setTextWrapMode().

### void QCanvasPainter::fillText(const QString &text, const QRectF &rect)

Draws text string inside rect, with current textAlign and textBaseline. Width of the rect parameter is used as maxWidth.

This is an overloaded method using QRectF. It is often useful to set the text baseline to TextBaseline::Top or TextBaseline::Middle when painting text with this method.

     p->setTextAlign(QCanvasPainter::TextAlign::Center);
     p->setTextBaseline(QCanvasPainter::TextBaseline::Middle);
     QString text("Qt Canvas Painter");
     QRectF rect1(10, 20, 180, 50);
     p->strokeRect(rect1);
     p->fillText(text, rect1);
     p->setTextWrapMode(QCanvasPainter::WrapMode::WordWrap);
     QRectF rect2(60, 90, 80, 90);
     p->strokeRect(rect2);
     p->fillText(text, rect2);

This is an overloaded function.

See also setTextAlign(), setTextBaseline(), and setTextWrapMode().

### void QCanvasPainter::fillText(const QString &text, QPointF point, qreal maxWidth = 0)

Draws text string at the specified point, with current textAlign and textBaseline. To make the text wrap into multiple lines, set the text wrap mode using setTextWrapMode() to something else than the default `NoWrap`. Optional maxWidth parameter defaults to `0`. Meaning that when e.g. `WordWrap` has been set, text is wrapped on every word. Set the maxWidth parameter to preferred row width in pixels.

This is an overloaded method using QPointF.

This is an overloaded function.

See also setTextAlign(), setTextBaseline(), and setTextWrapMode().

### QTransform QCanvasPainter::getTransform() const

Returns the current transform.

### void QCanvasPainter::lineTo(qreal x, qreal y)

Adds line segment from the last point in the path to the ( x, y) point.

     p->beginPath();
     p->moveTo(20, 20);
     p->lineTo(140, 180);
     p->lineTo(180, 120);
     p->stroke();

### void QCanvasPainter::lineTo(QPointF point)

Adds line segment from the last point in the path to the point.

This is an overloaded function.

### void QCanvasPainter::moveTo(qreal x, qreal y)

Starts a new sub-path with ( x, y) as the first point.

### void QCanvasPainter::moveTo(QPointF point)

Starts a new sub-path with point as the first point.

This is an overloaded function.

### void QCanvasPainter::quadraticCurveTo(qreal cpX, qreal cpY, qreal x, qreal y)

Adds a quadratic bezier segment from the last point in the path via a control point (cpX, cpY) to the specified point (x, y).

     p->beginPath();
     p->moveTo(20, 20);
     p->quadraticCurveTo(150, 50, 180, 180);
     p->quadraticCurveTo(20, 220, 20, 20);
     p->fill();
     p->stroke();

### void QCanvasPainter::quadraticCurveTo(QPointF controlPoint, QPointF endPoint)

Adds a quadratic bezier segment from the last point in the path via a controlPoint to the specified endPoint.

This is an overloaded function.

### void QCanvasPainter::rect(qreal x, qreal y, qreal width, qreal height)

Creates a new rectangle shaped sub-path in position x, y with size width, height.

     p->beginPath();
     p->rect(20, 20, 160, 160);
     p->fill();
     p->stroke();

### void QCanvasPainter::rect(const QRectF &rect)

Creates a new rectangle shaped sub-path at rect. This is an overloaded method using QRectF.

This is an overloaded function.

### void QCanvasPainter::removeImage(const QCanvasImage &image)

Releases the resources associated with image and removes the image from the painter.

Note: This does not need to be normally called, because resources such as textures are released in the painter destructor anyway. This function is useful when there is a need to reduce memory usage due to having a lot images, and some of them are not used anymore.

Note: Removed images can not be used in paint operations anymore.

Note: Resources such as the textures created with the underlying 3D API may not get released immediately. Such operations may get deferred to subsequent frames, typically when this QCanvasPainter begins painting again after the active set of draw calls has been submitted.

See also addImage().

### void QCanvasPainter::removePathGroup(int pathGroup)

Removes pathGroup from the painter cache. Calling fill() or stroke() for pathGroup after this, will regenerate the path into the group cache.

Note: This does not need to be normally called as paths are removed in the painter destructor. Only use this to reduce memory usage when pathGroup is not needed anymore or e.g. when the path has a lot less commands that it has had in the past and buffer size should be reduced.

See also fill() and stroke().

### void QCanvasPainter::reset()

Resets the current painter state to default values.

This includes the stroke and fill styles and the related properties, the transformation matrix, the clipping region, the text-related settings, the compositing properties, the drawing state stack, the antialiasing settings.

Note: This method differs from the HTML Canvas 2D Context reset() method in that it doesn't visually clear the canvas buffers.

Note: The values of setWindingEnforce() and setHighQualityStroking() are not changed.

     // Adjust the paint state
     p->setStrokeStyle("#00414A");
     p->setFillStyle("#2CDE85");
     p->setLineWidth(10);
     QRectF rect(20, 40, 160, 50);
     p->translate(rect.center());
     p->rotate(qDegreesToRadians(-25));
     p->translate(-rect.center());
     p->beginPath();
     p->roundRect(rect, 20);
     p->fill();
     p->stroke();
     // Reset to default paint state
     p->reset();
     p->fillRect(20, 140, 60, 40);
     p->strokeRect(120, 140, 60, 40);

See also save() and restore().

### void QCanvasPainter::resetClipping()

Resets and disables clipping.

See also setClipRect().

### void QCanvasPainter::resetTransform()

Resets the current transform to an identity matrix.

### void QCanvasPainter::restore()

Pops and restores the current render state. So previously saved state will be restored. If save() has not been called and the state stack is empty, calling this does nothing.

See also save().

### void QCanvasPainter::rotate(qreal angle)

Rotates the current coordinate system clockwise by angle.

The angle is specified in radians. Use qDegreesToRadians() to convert from degrees to radians.

     QRectF rect(20, 70, 160, 60);
     p->translate(rect.center());
     p->rotate(-M_PI / 4);
     p->translate(-rect.center());
     p->beginPath();
     p->roundRect(rect, 10);
     p->fill();
     p->stroke();
     p->setFillStyle(QColorConstants::Black);
     p->fillText("Cute!", rect);

### void QCanvasPainter::roundRect(qreal x, qreal y, qreal width, qreal height, qreal radius)

Creates a new rounded rectangle shaped sub-path in position x, y with size width, height. Corners rounding will be radius.

     p->beginPath();
     p->roundRect(20, 20, 160, 160, 30);
     p->fill();
     p->stroke();

### void QCanvasPainter::roundRect(const QRectF &rect, qreal radius)

Creates a new rounded rectangle shaped sub-path at rect with radius corners. This is an overloaded method using QRectF.

This is an overloaded function.

### void QCanvasPainter::roundRect(const QRectF &rect, qreal radiusTopLeft, qreal radiusTopRight, qreal radiusBottomRight, qreal radiusBottomLeft)

Creates a new rounded rectangle shaped sub-path at rect. Corners rounding can be varying per-corner, with radiusTopLeft, radiusTopRight, radiusBottomRight, radiusBottomLeft.

This is an overloaded function.

### void QCanvasPainter::roundRect(qreal x, qreal y, qreal width, qreal height, qreal radiusTopLeft, qreal radiusTopRight, qreal radiusBottomRight, qreal radiusBottomLeft)

Creates a new rounded rectangle shaped sub-path in position x, y with size width, height. Corners rounding can be varying per-corner, with radiusTopLeft, radiusTopRight, radiusBottomRight, radiusBottomLeft.

     p->beginPath();
     p->roundRect(20, 20, 160, 160,
                  0, 40, 20, 80);
     p->fill();
     p->stroke();

This is an overloaded function.

### void QCanvasPainter::save()

Pushes and saves the current render state into a state stack. A matching restore() must be used to restore the state.

     p->strokeRect(20, 20, 160, 40);
     // Save and adjust the paint state
     p->save();
     p->setStrokeStyle(QColorConstants::Black);
     p->setLineWidth(3);
     p->rotate(0.1);
     p->strokeRect(20, 80, 180, 20);
     // Restore the saved paint state
     p->restore();
     p->strokeRect(20, 140, 160, 40);

See also restore().

### void QCanvasPainter::scale(qreal scale)

Scales the current coordinate system by scale. Both x and y coordinates are scaled evenly.

     QRectF rect(20, 20, 160, 160);
     for (int i = 0; i < 20; i++) {
         p->beginPath();
         p->roundRect(rect, 10);
         p->stroke();
         p->translate(rect.center());
         p->scale(0.8);
         p->translate(-rect.center());
     }

### void QCanvasPainter::scale(qreal scaleX, qreal scaleY)

Scales the current coordinate system by scaleX and scaleY.

This is an overloaded function.

### void QCanvasPainter::setAntialias(qreal antialias)

Sets the current antialiasing amount to antialias in pixels. More antialias means smoother painting. This only affects fill and stroke painting, not images or texts. The default value is `1.0` and the maximum value is `10.0`.

Antialiasing can be modified per-path so it can be set before each stroke/fill. To disable antialiasing and reduce the rendering cost, set the antialias to `0`.

     p->setLineWidth(6);
     for (int i = 1; i < 10 ; i++) {
         int y = i * 20;
         p->setAntialias(i);
         p->beginPath();
         p->moveTo(20, y);
         p->bezierCurveTo(80, y + 20, 120,
                          y - 20, 180, y);
         p->stroke();
     }

See also setTextAntialias().

### void QCanvasPainter::setClipRect(qreal x, qreal y, qreal width, qreal height)

Sets the current scissor rectangle to (x, y, width, height). The scissor rectangle is transformed by the current transform.

Note: Clipping has some performance cost and it should only be used when needed.

     QRectF viewArea(20, 20, 160, 160);
     p->setClipRect(viewArea);
     p->beginPath();
     p->circle(40, 40, 110);
     p->fill();
     p->setFillStyle(Qt::black);
     p->fillText("Clip me...", 40, 100);
     p->strokeRect(viewArea);

See also resetClipping().

### void QCanvasPainter::setClipRect(const QRectF &rect)

Sets the current scissor rectangle to rect. The scissor rectangle is transformed by the current transform.

Note: Clipping has some performance cost and it should only be used when needed.

This is an overloaded function.

See also resetClipping().

### `[since 6.12]` void QCanvasPainter::setFillRule(QCanvasPainter::FillRule fillRule)

Sets the path fill rule to fillRule. This value is applied to all fill() calls after the rule has been set. The default fill rule is `QCanvasPainter::FillRule::NonZero`

     auto paintStar = [p]() {
         p->beginPath();
         p->moveTo(120, 60);
         for (int i = 1; i < 6; ++i) {
             p->lineTo(60 + 60 * cos(0.8 * i * M_PI),
                       60 + 60 * sin(0.8 * i * M_PI));
         }
         p->fill();
         p->stroke();
     };
     p->setFillRule(QCanvasPainter::FillRule::NonZero);
     paintStar();
     p->translate(75, 75);
     p->setFillRule(QCanvasPainter::FillRule::EvenOdd);
     paintStar();

This function was introduced in Qt 6.12.

### void QCanvasPainter::setFillStyle(const QColor &color)

Sets the fill style to a solid color. The default fill style is solid black (0, 0, 0, 1).

     p->setFillStyle(QColorConstants::Black);
     p->fillRect(20, 20, 160, 160);
     p->setFillStyle(QColor(0, 65, 74));
     p->fillRect(40, 40, 120, 120);
     p->setFillStyle("#2CDE85");
     p->fillRect(60, 60, 80, 80);

### void QCanvasPainter::setFillStyle(const QCanvasBrush &brush)

Sets the fill style to brush. The default fill style is solid black (0, 0, 0, 1).

     QCanvasRadialGradient g2(140, 40, 0, 300);
     g2.setStartColor(QColor(44, 222, 133));
     g2.setEndColor(QColor(0, 65, 74));
     p->setFillStyle(g2);
     p->fillRect(20, 20, 160, 160);
     g2.setCenterPosition(100, 100);
     p->setFillStyle(g2);
     p->fillRect(40, 40, 120, 120);

This is an overloaded function.

### void QCanvasPainter::setFont(const QFont &font)

Sets the font as currently active font.

### void QCanvasPainter::setGlobalAlpha(qreal alpha)

Sets the global alpha (transparency) value to alpha. This alpha value is applied to all rendered shapes. Already transparent paths will get proportionally more transparent as well. Alpha should be between 0.0 (fully transparent) and 1.0 (fully opaque). By default alpha is `1.0`.

     static QImage logo(":/qt_logo2.png");
     QCanvasImage image = p->addImage(logo);
     p->setFillStyle("#d9f720");
     for (int i = 0; i < 4; i++) {
         qreal x = 100 * (i % 2);
         qreal y = 100 * (i / 2);
         QRectF rect(x, y, 100, 100);
         p->setGlobalAlpha(1.0 - i * 0.3);
         p->fillRect(rect);
         p->drawImage(image, rect);
     }

### void QCanvasPainter::setGlobalBrightness(qreal value)

Sets the global brightness to value. This brightness is applied to all rendered shapes. A value of 0 will cause painting to be completely black. Value can also be bigger than 1.0, to increase the brightness. By default, brightness is `1.0`.

     static QImage logo(":/qt_logo2.png");
     QCanvasImage image = p->addImage(logo);
     p->setFillStyle("#d9f720");
     for (int i = 0; i < 4; i++) {
         qreal x = 100 * (i % 2);
         qreal y = 100 * (i / 2);
         QRectF rect(x, y, 100, 100);
         p->setGlobalBrightness(1.5 - i * 0.45);
         p->fillRect(rect);
         p->drawImage(image, rect);
     }

### void QCanvasPainter::setGlobalCompositeOperation(QCanvasPainter::CompositeOperation operation)

Sets the global composite operation mode to operation. This mode is applied to all painting operations. The default mode is `QCanvasPainter::CompositeOperation::SourceOver`.

Note: To work properly, composite modes require enabling `alphaBlending` and using a transparent background for the canvas.

     QList<QCanvasPainter::CompositeOperation> modes = {
         QCanvasPainter::CompositeOperation::SourceOver,
         QCanvasPainter::CompositeOperation::SourceAtop,
         QCanvasPainter::CompositeOperation::DestinationOut
     };
     for (int i = 0; i < modes.size(); i++) {
         // First item - SourceOver mode
         p->setGlobalCompositeOperation(QCanvasPainter::CompositeOperation::SourceOver);
         qreal y = 5 + i * 65;
         p->setFillStyle("#D9F720");
         p->fillRect(20, y, 140, 40);
         // Second item - Different modes
         p->setGlobalCompositeOperation(modes[i]);
         p->beginPath();
         p->ellipse(130, y + 30, 60, 25);
         p->setStrokeStyle("#00414A");
         p->setFillStyle("#2CDE85");
         p->fill();
         p->stroke();
     }

### void QCanvasPainter::setGlobalContrast(qreal value)

Sets the global contrast to value. This contrast is applied to all rendered shapes. A value of 0 will cause painting to be completely gray (0.5, 0.5, 0.5). Value can also be bigger than 1.0, to increase the contrast. By default, contrast is `1.0`.

     static QImage logo(":/qt_logo2.png");
     QCanvasImage image = p->addImage(logo);
     p->setFillStyle("#d9f720");
     for (int i = 0; i < 4; i++) {
         qreal x = 100 * (i % 2);
         qreal y = 100 * (i / 2);
         QRectF rect(x, y, 100, 100);
         p->setGlobalContrast(1.5 - i * 0.45);
         p->fillRect(rect);
         p->drawImage(image, rect);
     }

### void QCanvasPainter::setGlobalSaturation(qreal value)

Sets the global saturation to value. This saturation is applied to all rendered shapes. A value of 0 will disable saturation and cause painting to be completely grayscale. Value can also be bigger than 1.0, to increase the saturation. By default, saturation is `1.0`.

     static QImage logo(":/qt_logo2.png");
     QCanvasImage image = p->addImage(logo);
     p->setFillStyle("#d9f720");
     for (int i = 0; i < 4; i++) {
         qreal x = 100 * (i % 2);
         qreal y = 100 * (i / 2);
         QRectF rect(x, y, 100, 100);
         p->setGlobalSaturation(1.5 - i * 0.5);
         p->fillRect(rect);
         p->drawImage(image, rect);
     }

### void QCanvasPainter::setHighQualityStroking(bool enabled)

Sets the high quality stroking to enabled. Setting this to `true` gives a more correct rendering in some less common cases where stroking overlaps and doesn't have full opacity. Enabling it results into higher rendering cost. The default value is `false`.

     // Increase the line width and reduce opacity to get
     // the stroking flaws visible.
     p->setLineWidth(20);
     p->setGlobalAlpha(0.5);
     if (m_path.isEmpty()) {
         m_path.moveTo(30, 30);
         m_path.lineTo(40, 30);
         m_path.lineTo(80, 170);
         m_path.lineTo(80, 30);
         m_path.lineTo(70, 30);
     }
     p->setHighQualityStroking(true);
     p->stroke(m_path);
     p->setHighQualityStroking(false);
     p->translate(90, 0);
     p->stroke(m_path);

### void QCanvasPainter::setLineCap(QCanvasPainter::LineCap cap)

Sets the end of the line for strokes to cap. The default line cap is `QCanvasPainter::LineCap::Butt`.

     QCanvasPath path;
     path.moveTo(40, 60);
     path.lineTo(160, 60);
     p->setLineCap(QCanvasPainter::LineCap::Butt);
     p->stroke(path, -1);
     p->setLineCap(QCanvasPainter::LineCap::Square);
     p->translate(0, 40);
     p->stroke(path, -1);
     p->setLineCap(QCanvasPainter::LineCap::Round);
     p->translate(0, 40);
     p->stroke(path, -1);

### void QCanvasPainter::setLineJoin(QCanvasPainter::LineJoin join)

Sets the line join of strokes to join. The default line join is `QCanvasPainter::LineJoin::Miter`.

     QCanvasPath path;
     path.moveTo(40, 20);
     path.lineTo(100, 80);
     path.lineTo(160, 40);
     path.lineTo(160, 70);
     p->setLineJoin(QCanvasPainter::LineJoin::Miter);
     p->stroke(path, -1);
     p->setLineJoin(QCanvasPainter::LineJoin::Bevel);
     p->translate(0, 50);
     p->stroke(path, -1);
     p->setLineJoin(QCanvasPainter::LineJoin::Round);
     p->translate(0, 50);
     p->stroke(path, -1);

See also setMiterLimit().

### void QCanvasPainter::setLineWidth(qreal width)

Sets the line width of strokes to width in pixels. The default line width is `1.0`. When antialiasing is enabled, widths thinner than a single pixel will automatically fade the opacity, creating a smooth output.

     for (int i = 1; i < 10 ; i++) {
         int y = i * 20;
         p->setLineWidth(0.5 * i);
         p->beginPath();
         p->moveTo(20, y);
         p->bezierCurveTo(80, y + 20, 120,
                          y - 20, 180, y);
         p->stroke();
     }

See also stroke().

### void QCanvasPainter::setMiterLimit(qreal limit)

Sets the miter limit to limit. Miter limit controls when a sharp corner is beveled. When the corner length would become longer than this limit, QCanvasPainter::LineJoin::Bevel will be applied between the lines instead. This only has effect with the QCanvasPainter::LineJoin::Miter line join. The default limit is `10.0`.

     QCanvasPath path;
     path.moveTo(20, 40);
     path.lineTo(30, 130);
     path.lineTo(40, 40);
     path.lineTo(55, 80);

     p->setLineJoin(QCanvasPainter::LineJoin::Miter);
     p->setMiterLimit(20);
     p->stroke(path);

     p->setMiterLimit(8);
     p->translate(65, 0);
     p->stroke(path);

     p->setMiterLimit(2);
     p->translate(65, 0);
     p->stroke(path);

See also setLineJoin().

### void QCanvasPainter::setPathWinding(QCanvasPainter::PathWinding winding)

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

     p->beginPath();
     p->roundRect(20, 20, 160, 160, 40);
     p->setPathWinding(QCanvasPainter::PathWinding::ClockWise);
     p->circle(140, 60, 20);
     p->rect(60, 120, 80, 30);
     p->fill();
     p->stroke();

See also beginHoleSubPath() and beginSolidSubPath().

### void QCanvasPainter::setStrokeStyle(const QColor &color)

Sets the stroke style to a solid color. The default stroke style is solid black color (0, 0, 0, 1).

     p->setStrokeStyle(QColorConstants::Black);
     p->strokeRect(20, 20, 160, 160);
     p->setStrokeStyle(QColor(0, 65, 74));
     p->strokeRect(40, 40, 120, 120);
     p->setStrokeStyle("#2CDE85");
     p->strokeRect(60, 60, 80, 80);

### void QCanvasPainter::setStrokeStyle(const QCanvasBrush &brush)

Sets the stroke style to brush. The default stroke style is solid black (0, 0, 0, 1).

     QCanvasLinearGradient g1(180, 20, 20, 180);
     g1.setStartColor(QColor(44, 222, 133));
     g1.setEndColor(Qt::black);
     p->setStrokeStyle(g1);
     p->strokeRect(20, 20, 160, 160);
     g1.setEndColor(Qt::yellow);
     p->setStrokeStyle(g1);
     p->strokeRect(40, 40, 120, 120);

This is an overloaded function.

### void QCanvasPainter::setTextAlign(QCanvasPainter::TextAlign align)

Sets the horizontal alignment of text to align. The default alignment is `QCanvasPainter::TextAlign::Start`.

     QFont font("Titillium Web", 22);
     p->setFont(font);
     p->fillRect(100, 0, 1, 200);
     p->setTextAlign(QCanvasPainter::TextAlign::Left);
     p->fillText("Left", 100, 40);
     p->setTextAlign(QCanvasPainter::TextAlign::Center);
     p->fillText("Center", 100, 70);
     p->setTextAlign(QCanvasPainter::TextAlign::Right);
     p->fillText("Right", 100, 100);
     p->setTextAlign(QCanvasPainter::TextAlign::Start);
     p->fillText("Start", 100, 130);
     p->setTextAlign(QCanvasPainter::TextAlign::End);
     p->fillText("End", 100, 160);

See also setTextBaseline().

### void QCanvasPainter::setTextAntialias(qreal antialias)

Sets the current text antialiasing amount. The value antialias is a multiplier to normal antialiasing, meaning that `0.0` disables antialiasing and 2.0 doubles it. The default value is 1.0.

Note: Due to the text antialiasing technique used (SDF), the maximum antialiasing amount is quite limited and this affects less when the font size is small.

     QFont font("Titillium Web", 20);
     p->setFont(font);
     p->setTextAntialias(1.0);
     p->fillText("Antialiasing: 1.0", 100, 25);
     p->setTextAntialias(2.0);
     p->fillText("Antialiasing: 2.0", 100, 75);
     p->setTextAntialias(3.0);
     p->fillText("Antialiasing: 3.0", 100, 125);
     p->setTextAntialias(4.0);
     p->fillText("Antialiasing: 4.0", 100, 175);

### void QCanvasPainter::setTextBaseline(QCanvasPainter::TextBaseline baseline)

Sets the vertical alignment (baseline) of text to baseline. The default alignment is `QCanvasPainter::TextBaseline::Alphabetic`.

     QFont font("Titillium Web", 16);
     p->setFont(font);
     p->fillRect(0, 60, 200, 1);
     p->fillRect(0, 140, 200, 1);
     p->setTextBaseline(QCanvasPainter::TextBaseline::Bottom);
     p->fillText("Bottom", 40, 60);
     p->setTextBaseline(QCanvasPainter::TextBaseline::Middle);
     p->fillText("Middle", 100, 60);
     p->setTextBaseline(QCanvasPainter::TextBaseline::Top);
     p->fillText("Top", 160, 60);
     p->setTextBaseline(QCanvasPainter::TextBaseline::Alphabetic);
     p->fillText("Alphabetic", 50, 140);
     p->setTextBaseline(QCanvasPainter::TextBaseline::Hanging);
     p->fillText("Hanging", 150, 140);

See also setTextAlign().

### void QCanvasPainter::setTextDirection(QCanvasPainter::TextDirection direction)

Sets the direction of text to direction. The default direction is `QCanvasPainter::TextDirection::Inherit`.

     p->setTextAlign(QCanvasPainter::TextAlign::Center);
     p->setTextBaseline(QCanvasPainter::TextBaseline::Middle);
     QFont font("Titillium Web", 32);
     p->setFont(font);
     p->setFillStyle(QColorConstants::Black);
     p->fillText("Hi!", 100, 50);
     p->setTextDirection(QCanvasPainter::TextDirection::RightToLeft);
     p->fillText("Hi!", 100, 150);

### void QCanvasPainter::setTextLineHeight(qreal height)

Sets the line height adjustment in pixels to height for wrapped text. The default line height is `0`.

     QRectF r1(40, 5, 120, 60);
     QRectF r2(40, 70, 120, 60);
     QRectF r3(40, 135, 120, 60);
     p->strokeRect(r1);
     p->strokeRect(r2);
     p->strokeRect(r3);
     p->setTextLineHeight(-10);
     p->fillText("Text with line height: -10", r1);
     p->setTextLineHeight(0);
     p->fillText("Text with line height: 0", r2);
     p->setTextLineHeight(10);
     p->fillText("Text with line height: 10", r3);

### void QCanvasPainter::setTextWrapMode(QCanvasPainter::WrapMode wrapMode)

Sets the text wrap mode to wrapMode. The default wrap mode is `QCanvasPainter::WrapMode::NoWrap`.

     QRectF r1(50, 5, 100, 60);
     QRectF r2(50, 70, 100, 60);
     QRectF r3(50, 135, 100, 60);
     p->strokeRect(r1);
     p->strokeRect(r2);
     p->strokeRect(r3);
     QString s("This is a long string.");
     p->setTextWrapMode(QCanvasPainter::WrapMode::NoWrap);
     p->fillText(s, r1);
     p->setTextWrapMode(QCanvasPainter::WrapMode::Wrap);
     p->fillText(s, r2);
     p->setTextWrapMode(QCanvasPainter::WrapMode::WrapAnywhere);
     p->fillText(s, r3);

### void QCanvasPainter::setTransform(const QTransform &transform)

Resets the current transform and uses transform instead.

     p->beginPath();
     p->roundRect(80, 20, 40, 40, 10);
     p->fill();
     p->stroke();
     QTransform t;
     t.translate(100, 20);
     t.rotate(45);
     t.scale(2.0, 2.0);
     p->setTransform(t);
     p->beginPath();
     p->roundRect(20, 20, 40, 40, 10);
     p->fill();
     p->stroke();

See also transform().

### void QCanvasPainter::setWindingEnforce(bool enabled)

Sets the winding enforcing to enabled. Setting this to `false` disables enforcing of path winding to match what has been set into setPathWinding(). Disabling allows e.g. creating holes into paths by adding the points in clock wise order. Disabling can also increase the performance. The default value is `true`.

     p->setWindingEnforce(false);
     p->beginPath();
     // Outer shape, counterclockwise
     p->moveTo(20, 20);
     p->lineTo(100, 180);
     p->lineTo(180, 20);
     p->closePath();
     // Inner shape, clockwise
     p->moveTo(100, 40);
     p->lineTo(125, 90);
     p->lineTo(75, 90);
     p->closePath();
     p->fill();
     p->stroke();

### void QCanvasPainter::skew(qreal angleX, qreal angleY = 0.0)

Skews (shears) the current coordinate system along X axis by angleX and along Y axis by angleY. Angles are specified in radians.

     QRectF rect(40, 70, 120, 60);
     p->translate(rect.center());
     p->skew(-0.6);
     p->translate(-rect.center());
     p->beginPath();
     p->roundRect(rect, 10);
     p->fill();
     p->stroke();
     p->setFillStyle(QColorConstants::Black);
     p->fillText("Cute!", rect);

### void QCanvasPainter::stroke()

Strokes the current path with the current stroke style.

     p->beginPath();
     p->rect(20, 20, 40, 160);
     p->rect(140, 20, 40, 160);
     p->circle(100, 100, 60);
     p->stroke();

See also setStrokeStyle().

### void QCanvasPainter::stroke(const QCanvasPath &path, int pathGroup = -1)

Strokes the path with the current stroke style and belonging into pathGroup. Painting through QCanvasPath is optimal when the path contains more commands and is mostly static.

When pathGroup is `-1`, the path's rendering-related data will not be cached. This is the default. To request caching of path data, pass a value equal to or greater than `0`. More information about using path cache groups can be found in the QCanvasPath documentation.

Calling beginPath() before this method is not required.

     // m_path is QCanvasPath
     if (m_path.isEmpty()) {
         for (int i = 0; i < 16; i++) {
             int h = 100 + 60 * sin(i);
             m_path.rect(22 + i * 10,
                         180 - h,
                         6, h);
         }
     }
     p->stroke(m_path);

This is an overloaded function.

See also setStrokeStyle() and removePathGroup().

### void QCanvasPainter::strokeRect(qreal x, qreal y, qreal width, qreal height)

Draws a stroked rectangle into the specified position ( x, y) with size width, height.

Note: This is provided for convenience. When stroking more than just a single rect, prefer using rect().

     p->strokeRect(20, 20, 160, 160);
     // The above code does same as:
     // p->beginPath();
     // p->rect(20, 20, 160, 160);
     // p->stroke();

### void QCanvasPainter::strokeRect(const QRectF &rect)

Draws a stroked rectangle into rect. This is an overloaded method using QRectF.

Note: This is provided for convenience. When stroking more than just a single rect, prefer using rect().

This is an overloaded function.

### QRectF QCanvasPainter::textBoundingBox(const QString &text, qreal x, qreal y, qreal maxWidth = 0)

Measures bounding box of a text string at (x, y).

To measure multi-line text, set the text wrap mode using setTextWrapMode() to something else than the default `NoWrap`. Also set the optional maxWidth parameter to preferred row width in pixels.

Returns QRectF with values [xmin, ymin, width, height]. Measured values are returned in local coordinate space.

     QString s("Built with Qt");
     QPointF pos1(20, 20);
     QRectF box1 = p->textBoundingBox(s, pos1);
     p->strokeRect(box1);
     p->fillText(s, pos1);
     p->setTextWrapMode(QCanvasPainter::WrapMode::WordWrap);
     p->setTextAlign(QCanvasPainter::TextAlign::Center);
     QPointF pos2(100, 80);
     QRectF box2 = p->textBoundingBox(s, pos2, 100);
     p->strokeRect(box2);
     p->fillText(s, pos2, 100);

### QRectF QCanvasPainter::textBoundingBox(const QString &text, const QRectF &rect)

Measures bounding box of a text string at rect. Returns QRectF with values [xmin, ymin, width, height]. Measured values are returned in local coordinate space.

This is an overloaded function.

### QRectF QCanvasPainter::textBoundingBox(const QString &text, QPointF point, qreal maxWidth = 0)

Measures bounding box of a text string at point.

To measure multi-line text, set the text wrap mode using setTextWrapMode() to something else than the default `NoWrap`. Also set the optional maxWidth parameter to preferred row width in pixels.

Returns QRectF with values [xmin, ymin, width, height]. Measured values are returned in local coordinate space.

This is an overloaded function.

### void QCanvasPainter::transform(const QTransform &transform)

Multiplies the current coordinate system by the specified transform.

     QTransform t;
     t.translate(100, 100);
     t.rotate(36);
     t.translate(-100, -100);
     for (int i = 0; i < 10; i++) {
         p->transform(t);
         p->beginPath();
         p->roundRect(80, 15, 40, 20, 10);
         p->fill();
         p->stroke();
     }

See also setTransform().

### void QCanvasPainter::translate(qreal x, qreal y)

Translates the current coordinate system by x and y.

     auto paintRect = [p]() {
         p->beginPath();
         p->roundRect(20, 20, 160, 60, 10);
         p->fill();
         p->stroke();
     };
     paintRect();
     p->translate(0, 100);
     paintRect();

### void QCanvasPainter::translate(QPointF point)

Translates the current coordinate system by point.

This is an overloaded function.