PySide6.QtCanvasPainter.QCanvasPainter

class QCanvasPainter

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

Synopsis

Methods

• def __init__()

• def activeImageCount()

• def activeImageMemoryUsage()

• def addImage()

• def addPath()

• def arc()

• def arcTo()

• def beginHoleSubPath()

• def beginPath()

• def beginSolidSubPath()

• def bezierCurveTo()

• def circle()

• def cleanupResources()

• def clearRect()

• def closePath()

• def createCanvas()

• def destroyCanvas()

• def devicePixelRatio()

• def drawBoxShadow()

• def drawImage()

• def ellipse()

• def fill()

• def fillRect()

• def fillText()

• def getTransform()

• def lineTo()

• def moveTo()

• def quadraticCurveTo()

• def rect()

• def removeImage()

• def removePathGroup()

• def renderHints()

• def reset()

• def resetClipping()

• def resetTransform()

• def restore()

• def rotate()

• def roundRect()

• def save()

• def scale()

• def setAntialias()

• def setBrushTransform()

• def setClipRect()

• def setFillStyle()

• def setFont()

• def setGlobalAlpha()

• def setGlobalBrightness()

• def setGlobalCompositeOperation()

• def setGlobalContrast()

• def setGlobalSaturate()

• def setLineCap()

• def setLineJoin()

• def setLineWidth()

• def setMiterLimit()

• def setPathWinding()

• def setRenderHint()

• def setRenderHints()

• def setStrokeStyle()

• def setTextAlign()

• def setTextAntialias()

• def setTextBaseline()

• def setTextDirection()

• def setTextLineHeight()

• def setTextWrapMode()

• def setTransform()

• def skew()

• def stroke()

• def strokeRect()

• def textBoundingBox()

• def transform()

• def translate()

Static functions

• def mmToPx()

• def ptToPx()

Note

This documentation may contain snippets that were automatically translated from C++ to Python. We always welcome contributions to the snippet translation. If you see an issue with the translation, you can also let us know by creating a ticket on https:/bugreports.qt.io/projects/PYSIDE

Detailed Description

Qt Canvas Painter ( QCanvasPainter ) provides painting API optimized for harware-accelerated (GPU) painting. The API follows closely 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, 30, 15, "#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, "#404040", "#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();

For the most parts and from the naming perspective, QCanvasPainter follow closely the 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 misses 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 we are at least currently missing compared to HTML canvas:

• Clipping: All clipping is (transformed) rectangle and clipping to path shapes are not supported.

• Fill mode: Only the default Non-zero fillrule is supported, no support for Even-odd fillrule.

• 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 amount 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 supports also rounded rectangle box gradient.

• Box Shadow: QCanvasPainter supports also CSS box-shadow type of brush. The rendering uses 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: With addition to globalAlpha, QCanvasPainter supports also 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, dending 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 .

QCanvasPainter uses nonzero (WindingFill) fillrule. To select the filling based on the path points direction, disable the winding forcing by setting DisableWindingEnforce rendering hint with setRenderHint() .

p->setRenderHint(QCanvasPainter::RenderHint::DisableWindingEnforce); 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();

class 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	Description
QCanvasPainter.PathWinding.PathWinding.CounterClockWise	(default) Counter-clockwise winding for solid shapes.
QCanvasPainter.PathWinding.PathWinding.ClockWise	Clockwise winding for holes.

See also

setPathWinding()

class 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	Description
QCanvasPainter.PathConnection.PathConnection.NotConnected	There is no line drawn from the last point of the previous path to the first point of the current path.
QCanvasPainter.PathConnection.PathConnection.Connected	The last point of the previous path will be connected to the first point of the current path.

See also

arc()

class LineCap

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

Constant	Description
QCanvasPainter.LineCap.LineCap.Butt	(default) Square line ending that does not cover the end point of the line.
QCanvasPainter.LineCap.LineCap.Round	Round line ending.
QCanvasPainter.LineCap.LineCap.Square	Square line ending that covers the end point and extends beyond it by half the line width.

See also

setLineCap()

class LineJoin

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

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

See also

setLineJoin() setMiterLimit()

class TextAlign

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

Constant	Description
QCanvasPainter.TextAlign.TextAlign.Left	Align the left side of the text horizontally to the specified position.
QCanvasPainter.TextAlign.TextAlign.Right	Align the right side of the text horizontally to the specified position.
QCanvasPainter.TextAlign.TextAlign.Center	Align the center of the text horizontally to the specified position.
QCanvasPainter.TextAlign.TextAlign.Start	(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.TextAlign.End	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() fillText()

class TextBaseline

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

Constant	Description
QCanvasPainter.TextBaseline.TextBaseline.Top	Align the top of the text vertically to the specified position.
QCanvasPainter.TextBaseline.TextBaseline.Hanging	Align the hanging baseline of the text vertically to the specified position.
QCanvasPainter.TextBaseline.TextBaseline.Middle	Align the middle of the text vertically to the specified position.
QCanvasPainter.TextBaseline.TextBaseline.Alphabetic	(default) Align the baseline of the text vertically to the specified position.
QCanvasPainter.TextBaseline.TextBaseline.Bottom	Align the bottom of the text vertically to the specified position.

See also

setTextBaseline() fillText()

class TextDirection

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

Constant	Description
QCanvasPainter.TextDirection.TextDirection.LeftToRight	The text direction is left-to-right.
QCanvasPainter.TextDirection.TextDirection.RightToLeft	The text direction is right-to-left.
QCanvasPainter.TextDirection.TextDirection.Inherit	(default) The text direction is inherited from QGuiApplication layoutDirection. See https://doc.qt.io/qt-6/qguiapplication.html#layoutDirection-prop.
QCanvasPainter.TextDirection.TextDirection.Auto	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 that other options.

See also

setTextDirection() setTextAlign() fillText()

class CompositeOperation

Qt Canvas Painter supports 3 composite operations:

Constant	Description
QCanvasPainter.CompositeOperation.CompositeOperation.SourceOver	The default value. Draws new shapes on top of the existing content.
QCanvasPainter.CompositeOperation.CompositeOperation.SourceAtop	The new shape is only drawn where it overlaps the existing content.
QCanvasPainter.CompositeOperation.CompositeOperation.DestinationOut	The existing content is kept where it doesn’t overlap with the new shape.

See also

setGlobalCompositeOperation()

class WrapMode

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

Constant	Description
QCanvasPainter.WrapMode.WrapMode.NoWrap	(default) No wrapping will be performed. If the text contains insufficient newlines, then contentWidth will exceed a set width.
QCanvasPainter.WrapMode.WrapMode.Wrap	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.WrapMode.WordWrap	Wrapping is done on word boundaries only. If a word is too long, content width will exceed a set width.
QCanvasPainter.WrapMode.WrapMode.WrapAnywhere	Wrapping is done at any point on a line, even if it occurs in the middle of a word.

See also

setTextWrapMode() fillText()

class ImageFlag

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

Constant	Description
QCanvasPainter.ImageFlag.ImageFlag.GenerateMipmaps	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.ImageFlag.RepeatX	Use with image pattern to repeate image in X-coordinate.
QCanvasPainter.ImageFlag.ImageFlag.RepeatY	Use with image pattern to repeate image in Y-coordinate.
QCanvasPainter.ImageFlag.ImageFlag.Repeat	Use with image pattern to repeate image in both coordinates.
QCanvasPainter.ImageFlag.ImageFlag.FlipY	Flips (inverses) image in Y direction when rendered.
QCanvasPainter.ImageFlag.ImageFlag.Premultiplied	Image data has premultiplied alpha.
QCanvasPainter.ImageFlag.ImageFlag.Nearest	Image interpolation is Nearest instead Linear
QCanvasPainter.ImageFlag.ImageFlag.NativeTexture	Signifies this is a texture outside of QCanvasPainter .

class RenderHint

(inherits enum.Flag) This enum specifies flags to QCanvasPainter related to rendering. Use setRenderHint() to set the flags.

Constant	Description
QCanvasPainter.RenderHint.RenderHint.Antialiasing	Setting this to false disables antialiasing. Enabling it results into higher rendering cost. The default value is true.
QCanvasPainter.RenderHint.RenderHint.HighQualityStroking	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.
QCanvasPainter.RenderHint.RenderHint.DisableWindingEnforce	Setting this to true 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.

__init__()

Constructs a painter.

activeImageCount()

Return type:

int

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() removeImage()

activeImageMemoryUsage()

Return type:

int

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() removeImage()

addImage(texture[, flags={}])

Parameters:

• texture – QRhiTexture

• flags – Combination of ImageFlag

Return type:

QCanvasImage

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

Note

The ownership of texture is not taken.

See also

drawImage() removeImage()

addImage(canvas[, flags={}])

Parameters:

• canvas – QCanvasOffscreenCanvas

• flags – Combination of ImageFlag

Return type:

QCanvasImage

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.

See also

drawImage() removeImage()

addImage(image[, flags={}])

Parameters:

• image – QImage

• flags – Combination of ImageFlag

Return type:

QCanvasImage

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, image QImage does not need 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() removeImage()

addPath(path)

Parameters:

path – QPainterPath

Adds path into the current path.

Note

QCanvasPainter uses WindingFill (nonzero) fillrule, which means that all QPainterPaths don’t render correctly. This is notable for example when path contains text characters with holes in them.

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.

addPath(path[, transform=QTransform()])

Parameters:

• path – QCanvasPath

• 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();

addPath(path, start, count[, transform=QTransform()])

Parameters:

• path – QCanvasPath

• start – int

• count – int

• 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 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();

arc(centerPoint, radius, a0, a1[, direction=QCanvasPainter.PathWinding.ClockWise[, connection=QCanvasPainter.PathConnection.Connected]])

Parameters:

• centerPoint – QPointF

• radius – float

• a0 – float

• a1 – float

• direction – PathWinding

• connection – PathConnection

Creates 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.

arc(centerX, centerY, radius, a0, a1[, direction=QCanvasPainter.PathWinding.ClockWise[, connection=QCanvasPainter.PathConnection.Connected]])

Parameters:

• centerX – float

• centerY – float

• radius – float

• a0 – float

• a1 – float

• direction – PathWinding

• connection – PathConnection

Creates 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.

arcTo(controlPoint1, controlPoint2, radius)

Parameters:

• controlPoint1 – QPointF

• controlPoint2 – QPointF

• radius – float

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.

arcTo(x1, y1, x2, y2, radius)

Parameters:

• x1 – float

• y1 – float

• x2 – float

• y2 – float

• radius – float

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();

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()

beginPath()

Begins drawing a new path while clearing the current path.

beginSolidSubPath()

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

See also

beginHoleSubPath()

bezierCurveTo(controlPoint1, controlPoint2, endPoint)

Parameters:

• controlPoint1 – QPointF

• controlPoint2 – QPointF

• endPoint – QPointF

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

bezierCurveTo(cp1X, cp1Y, cp2X, cp2Y, x, y)

Parameters:

• cp1X – float

• cp1Y – float

• cp2X – float

• cp2Y – float

• x – float

• y – float

Adds cubic bezier segment from 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();

circle(centerPoint, radius)

Parameters:

• centerPoint – QPointF

• radius – float

Creates new circle shaped sub-path into centerPoint with radius.

circle(centerX, centerY, radius)

Parameters:

• centerX – float

• centerY – float

• radius – float

Creates new circle shaped sub-path into ( centerX, centerY) with radius.

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

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.

clearRect(rect)

Parameters:

rect – QRectF

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

clearRect(x, y, width, height)

Parameters:

• x – float

• y – float

• width – float

• height – float

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);

closePath()

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

createCanvas(pixelSize[, sampleCount=1[, flags={}]])

Parameters:

• pixelSize – QSize

• sampleCount – int

• flags – Combination of Flag

Return type:

QCanvasOffscreenCanvas

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 beginPaint() overload when working with the lower level API, or beginCanvasPainting() or 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.

destroyCanvas(canvas)

Parameters:

canvas – QCanvasOffscreenCanvas

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.

devicePixelRatio()

Return type:

float

Returns the ratio between physical pixels and device-independent pixels. The default value is 1.0.

drawBoxShadow(shadow)

Parameters:

shadow – QCanvasBoxShadow

Draws a box shadow. The shadow will be painted with the position, size, color, blur etc. set in the 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, 0, 30); p->drawBoxShadow(shadow); p->beginPath(); p->roundRect(rect, 30); p->setFillStyle("#2CDE85"); p->fill();

See also

QCanvasBoxShadow

drawImage(image, destinationRect)

Parameters:

• image – QCanvasImage

• destinationRect – QRectF

Draw image into position and size of destinationRect.

See also

addImage()

drawImage(image, sourceRect, destinationRect)

Parameters:

• image – QCanvasImage

• sourceRect – QRectF

• destinationRect – QRectF

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);

See also

addImage()

drawImage(image, x, y)

Parameters:

• image – QCanvasImage

• x – float

• y – float

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()

drawImage(image, x, y, width, height)

Parameters:

• image – QCanvasImage

• x – float

• y – float

• width – float

• height – float

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);

See also

addImage()

ellipse(rect)

Parameters:

rect – QRectF

Creates 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();

ellipse(centerPoint, radiusX, radiusY)

Parameters:

• centerPoint – QPointF

• radiusX – float

• radiusY – float

Creates new ellipse shaped sub-path into centerPoint with radiusX and radiusY.

ellipse(centerX, centerY, radiusX, radiusY)

Parameters:

• centerX – float

• centerY – float

• radiusX – float

• radiusY – float

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

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

fill()

Fills the current path with current fill style.

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

See also

setFillStyle()

fill(path[, pathGroup=0])

Parameters:

• path – QCanvasPath

• pathGroup – int

Fills the path with current fill style and belonging into pathGroup. Painting through QCanvasPath is optimal when the path contains more commands is mostly static. By default, pathGroup is 0, so using the first group. When pathGroup is -1, the path will not be cached on GPU side. More information about using path cache groups in 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++) { float w = 100 + 60 * sin(i); m_path.rect(100 - w * 0.5, 22 + i * 10, w, 6); } } p->fill(m_path);

See also

setFillStyle()

fillRect(rect)

Parameters:

rect – QRectF

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() .

fillRect(x, y, width, height)

Parameters:

• x – float

• y – float

• width – float

• height – float

Draws a filled rectangle into specified position ( x, y) at 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();

fillText(text, rect)

Parameters:

• text – str

• rect – QRectF

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 Top or Middle when painting text with this method.

fillText(text, point[, maxWidth=-1])

Parameters:

• text – str

• point – QPointF

• maxWidth – float

Draws text string at specified point, with current textAlign and textBaseline. To make the text wrap into multiple lines, set optional maxWidth parameter to preferred row width in pixels. White space is stripped at the beginning of the rows, the text is split at word boundaries or when new-line characters are encountered. Words longer than the max width are split at nearest character (i.e. no hyphenation).

This is an overloaded method using QPointF.

fillText(text, x, y[, maxWidth=-1])

Parameters:

• text – str

• x – float

• y – float

• maxWidth – float

Draws text string at specified location ( x, y), with current textAlign and textBaseline. To make the text wrap into multiple lines, set optional maxWidth parameter to preferred row width in pixels. White space is stripped at the beginning of the rows, the text is split at word boundaries or when new-line characters are encountered. Words longer than the max width are split at nearest character (i.e. no hyphenation).

getTransform()

Return type:

QTransform

Returns the current transform.

lineTo(point)

Parameters:

point – QPointF

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

lineTo(x, y)

Parameters:

• x – float

• y – float

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();

static mmToPx(mm)

Parameters:

mm – float

Return type:

float

Static helper method to convert millimeters mm into pixels. This allows doing resolution independent drawing. For example to set the line width to 2mm use:

painter-> setLineWidth (QCanvasPainter::mmToPx(2));

moveTo(point)

Parameters:

point – QPointF

Starts new sub-path with point as first point.

moveTo(x, y)

Parameters:

• x – float

• y – float

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

static ptToPx(pt)

Parameters:

pt – float

Return type:

float

Static helper method to convert points pt into pixels.

quadraticCurveTo(controlPoint, endPoint)

Parameters:

• controlPoint – QPointF

• endPoint – QPointF

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

quadraticCurveTo(cpX, cpY, x, y)

Parameters:

• cpX – float

• cpY – float

• x – float

• y – float

Adds quadratic bezier segment from 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();

rect(rect)

Parameters:

rect – QRectF

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

rect(x, y, width, height)

Parameters:

• x – float

• y – float

• width – float

• height – float

Creates 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();

removeImage(image)

Parameters:

image – QCanvasImage

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 defered to subsequent frames, typically when this QCanvasPainter begins painting again after the active set of draw calls has been submitted.

See also

addImage()

removePathGroup(pathGroup)

Parameters:

pathGroup – int

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() stroke()

renderHints()

Return type:

Combination of RenderHint

Returns a flag that specifies the rendering hints that are set for this painter.

See also

setRenderHints() setRenderHint()

reset()

Resets the current painter state to default values.

Note

This method differs from the HTML canvas 2D context reset() method so that it doesn’t visually clear the canvas buffers.

// 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() restore()

resetClipping()

Resets and disables clipping.

See also

setClipRect()

resetTransform()

Resets current transform to a identity matrix.

restore()

Pops and restores 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()

rotate(angle)

Parameters:

angle – float

Rotates 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);

roundRect(rect, radius)

Parameters:

• rect – QRectF

• radius – float

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

roundRect(rect, radiusTopLeft, radiusTopRight, radiusBottomRight, radiusBottomLeft)

Parameters:

• rect – QRectF

• radiusTopLeft – float

• radiusTopRight – float

• radiusBottomRight – float

• radiusBottomLeft – float

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

roundRect(x, y, width, height, radius)

Parameters:

• x – float

• y – float

• width – float

• height – float

• radius – float

Creates 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();

roundRect(x, y, width, height, radiusTopLeft, radiusTopRight, radiusBottomRight, radiusBottomLeft)

Parameters:

• x – float

• y – float

• width – float

• height – float

• radiusTopLeft – float

• radiusTopRight – float

• radiusBottomRight – float

• radiusBottomLeft – float

Creates 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();

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()

scale(scale)

Parameters:

scale – float

Scales the current coordinat 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()); }

scale(scaleX, scaleY)

Parameters:

• scaleX – float

• scaleY – float

Scales the current coordinat system by scaleX and scaleY.

setAntialias(antialias)

Parameters:

antialias – float

Set 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 from the whole canvas painter, use Antialiasing render hint.

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

setRenderHints() setTextAntialias()

setBrushTransform(transform)

Parameters:

transform – QTransform

Sets the current brush transform to transform. This transform is applied to both stroke and fill brushes.

setClipRect(rect)

Parameters:

rect – QRectF

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.

See also

resetClipping()

setClipRect(x, y, width, height)

Parameters:

• x – float

• y – float

• width – float

• height – float

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()

setFillStyle(brush)

Parameters:

brush – QCanvasBrush

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

QCanvasRadialGradient g2(140, 40, 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);

setFillStyle(color)

Parameters:

color – QColor

Sets the fill style to a solid color. The default fill style is solid black color (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);

setFont(font)

Parameters:

font – QFont

Sets the font as currently active font.

setGlobalAlpha(alpha)

Parameters:

alpha – float

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++) { float x = 100 * (i % 2); float y = 100 * (i / 2); QRectF rect(x, y, 100, 100); p->setGlobalAlpha(1.0 - i * 0.3); p->fillRect(rect); p->drawImage(image, rect); }

setGlobalBrightness(value)

Parameters:

value – float

Sets the global brightness to value. This brightess 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++) { float x = 100 * (i % 2); float y = 100 * (i / 2); QRectF rect(x, y, 100, 100); p->setGlobalBrightness(1.5 - i * 0.45); p->fillRect(rect); p->drawImage(image, rect); }

setGlobalCompositeOperation(operation)

Parameters:

operation – CompositeOperation

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

setGlobalContrast(value)

Parameters:

value – float

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++) { float x = 100 * (i % 2); float y = 100 * (i / 2); QRectF rect(x, y, 100, 100); p->setGlobalContrast(1.5 - i * 0.45); p->fillRect(rect); p->drawImage(image, rect); }

setGlobalSaturate(value)

Parameters:

value – float

Sets the global saturations to value. This saturations 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++) { float x = 100 * (i % 2); float y = 100 * (i / 2); QRectF rect(x, y, 100, 100); p->setGlobalSaturate(1.5 - i * 0.5); p->fillRect(rect); p->drawImage(image, rect); }

setLineCap(cap)

Parameters:

cap – LineCap

Sets the end of the line of stoke 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);

setLineJoin(join)

Parameters:

join – LineJoin

Sets the line join of stroke 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()

setLineWidth(width)

Parameters:

width – float

Sets the line width of stroke to width in pixels. The default line width is 1.0. When the antialiasing is enabled, the line widths under a single pixel 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()

setMiterLimit(limit)

Parameters:

limit – float

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, Bevel will be applied between the lines instead. This has only effect with the Miter line join. The default limit is 10.0.

See also

setLineJoin()

setPathWinding(winding)

Parameters:

winding – PathWinding

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() beginSolidSubPath()

setRenderHint(hint[, on=true])

Parameters:

• hint – RenderHint

• on – bool

Sets the given render hint on the painter if on is true; otherwise clears the render hint.

See also

setRenderHints() renderHints()

setRenderHints(hints[, on=true])

Parameters:

• hints – Combination of RenderHint

• on – bool

Sets the given render hints on the painter if on is true; otherwise clears the render hints.

See also

setRenderHint() renderHints()

setStrokeStyle(brush)

Parameters:

brush – QCanvasBrush

Sets the stroke style to brush. The default stroke style is solid black color (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);

setStrokeStyle(color)

Parameters:

color – QColor

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);

setTextAlign(align)

Parameters:

align – TextAlign

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()

setTextAntialias(antialias)

Parameters:

antialias – float

Set the current text antialiasing amount. The value antialias is 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 used text antialiasing technique (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);

setTextBaseline(baseline)

Parameters:

baseline – TextBaseline

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()

setTextDirection(direction)

Parameters:

direction – TextDirection

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

setTextLineHeight(height)

Parameters:

height – float

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);

setTextWrapMode(wrapMode)

Parameters:

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);

setTransform(transform)

Parameters:

transform – QTransform

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()

skew(angleX[, angleY=0.0f])

Parameters:

• angleX – float

• angleY – float

Skews (shears) the current coordinate system along X axis by angleX and along Y axis by angleY. Angles are specifid 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);

stroke()

Strokes the current path with 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()

stroke(path[, pathGroup=0])

Parameters:

• path – QCanvasPath

• pathGroup – int

Strokes the path with current stroke style and belonging into pathGroup. Painting through QCanvasPath is optimal when the path contains more commands is mostly static. By default, pathGroup is 0, so using the first group. When pathGroup is -1, the path will not be cached on GPU side. More information about using path cache groups in 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);

See also

setStrokeStyle()

strokeRect(rect)

Parameters:

rect – QRectF

Draws a stoked 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() .

strokeRect(x, y, width, height)

Parameters:

• x – float

• y – float

• width – float

• height – float

Draws a stoked rectangle into specified position ( x, y) at 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();

textBoundingBox(text, rect)

Parameters:

• text – str

• rect – QRectF

Return type:

QRectF

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.

textBoundingBox(text, point[, maxWidth=-1])

Parameters:

• text – str

• point – QPointF

• maxWidth – float

Return type:

QRectF

Measures bounding box of a text string at point. To measure multi-line text, set 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.

textBoundingBox(text, x, y[, maxWidth=-1])

Parameters:

• text – str

• x – float

• y – float

• maxWidth – float

Return type:

QRectF

Measures bounding box of a text string at (x, y). To measure multi-line text, set 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);

transform(transform)

Parameters:

transform – QTransform

Multiplies the current coordinate system by 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()

translate(point)

Parameters:

point – QPointF

Translates current coordinate system by point.

translate(x, y)

Parameters:

• x – float

• y – float

Translates 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();