En esta página

QCanvasPainter Class

La clase QCanvasPainter realiza operaciones de dibujo aceleradas por hardware en QRhi. Más información...

Encabezado: #include <QCanvasPainter>
CMake: find_package(Qt6 REQUIRED COMPONENTS CanvasPainter)
target_link_libraries(mytarget PRIVATE Qt6::CanvasPainter)
Desde: Qt 6.11

Tipos públicos

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 }

Funciones públicas

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(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(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) const
QRectF textBoundingBox(const QString &text, const QRectF &rect) const
QRectF textBoundingBox(const QString &text, QPointF point, qreal maxWidth = 0) const
void transform(const QTransform &transform)
void translate(qreal x, qreal y)
void translate(QPointF point)

Descripción detallada

Qt Canvas Painter (QCanvasPainter) proporciona una API de dibujo optimizada para el dibujo acelerado por hardware (GPU). La API sigue de cerca la especificación HTML Canvas 2D Context, adaptada a Qt C++. También está influenciada por QPainter, pero con una API más compacta.

A continuación se muestra un ejemplo sencillo del uso de QCanvasPainter para crear un botón redondo.

Botón redondeado de color amarillo con la inscripción «¡CLICK!» y una suave sombra proyectada
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);

A continuación se muestra otro ejemplo de cómo dibujar un gráfico sencillo.

Curva en S sombreada que va del verde al rojo sobre una cuadrícula oscura con ejes blancos
// 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();

Características

En su mayor parte, y desde el punto de vista de la nomenclatura, QCanvasPainter sigue el contexto 2D de HTML Canvas (https://html.spec.whatwg.org/multipage/canvas.html#2dcontext). Esto hace que la API resulte familiar para muchos desarrolladores y permite reutilizar fácilmente el código de canvas ya existente. Sin embargo, el objetivo NO es ser 100 % compatible con el canvas de HTML. QCanvasPainter omite algunas de las características para que resulte más sencillo, ofrezca un mejor rendimiento en una API de gráficos acelerad QRhi mente por hardware y se adapte mejor a las necesidades actuales de las interfaces de usuario. Por estas razones, QCanvasPainter también cuenta con características adicionales en comparación con el contexto 2D de HTML Canvas.

Estas son algunas de las funcionalidades que, al menos por el momento, no están disponibles en comparación con HTML Canvas:

  • Recorte: todo el recorte se realiza mediante rectángulos (transformados) y no se admite el recorte según formas de trazado.
  • Trazados discontinuos: los trazos son siempre líneas continuas; no se admiten patrones de trazo discontinuo o punteado.
  • Comprobación de trazados: No existen los métodos isPointInPath() ni isPointInStroke().
  • Trazado de texto: no se admite el trazado de contorno del texto.
  • Filtros: No se admiten los efectos de filtro SVG de Canvas.
  • Modos de composición: El número de modos de composición está limitado a 3, que pueden admitirse sin necesidad de renderizar en búferes adicionales.
  • Sombras: No se admiten los métodos de sombra integrados.

Por otro lado, algunas de las características adicionales que ofrece QCanvasPainter en comparación con HTML Canvas incluyen:

  • Grupos de trazados: QCanvasPainter permite dibujar sobre trazados estáticos y almacenarlos en caché como grupos para un uso óptimo de la GPU.
  • Antialiasing ajustable: gracias al antialiasing de vértices de trazado y al renderizado de texto SDF, la cantidad de píxeles del antialiasing se puede ajustar libremente para obtener un dibujo más suave.
  • Degradado de cuadro: además de los degradados lineales, radiales y cónicos, QCanvasPainter también admite el degradado de cuadro con rectángulo redondeado.
  • Sombra de cuadro: QCanvasPainter también admite pinceles del tipo «box-shadow» de CSS. La representación utiliza un enfoque SDF similar al de Qt Quick RectangularShadow , lo que le confiere un gran rendimiento.
  • Patrones de cuadrícula: QCanvasPainter admite QCanvasGridPattern para estilos dinámicos de cuadrícula y patrones de barras.
  • Pinceles personalizados: QCanvasPainter también permite rellenar y trazar contornos con shaders de vértices y de fragmentos personalizados (QCanvasCustomBrush). Estos pinceles personalizados también se pueden utilizar para el texto.
  • Ajustes de texto: QCanvasPainter admite el ajuste automático del texto en varias líneas, con diferentes modos de ajuste.
  • Efectos de color: además de globalAlpha, QCanvasPainter también admite ajustes globales de brillo, contraste y saturación.
  • Imágenes teñidas: QCanvasPainter añade compatibilidad con colores de tinte para imágenes pintadas y patrones de imagen.

QCanvasPainter es independiente de la arquitectura y se puede utilizar tanto en aplicaciones Qt Quick como Qt Widgets. De hecho, se puede utilizar incluso sin ninguna de ellas, simplemente con QWindow y QRhi. Para utilizar QCanvasPainter, utilízalo desde una de estas clases, dependiendo de la arquitectura de tu aplicación:

Reglas de trazado

QCanvasPainter utiliza por defecto la regla de relleno « NonZero » ({Qt::WindingFill}). Para seleccionar el relleno en función de la dirección de los puntos del trazado, desactiva la imposición de la dirección de trazado llamando a setWindingEnforce(false).

Triángulo verde orientado hacia abajo con un hueco triangular más pequeño y sin rellenar cerca de su vértice superior
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();

Sin embargo, lo más habitual es confiar en la imposición de la dirección de trazado y establecer la dirección preferida mediante las funciones auxiliares setPathWinding() o beginHoleSubPath() y beginSolidSubPath().

Contorno cuadrado redondeado de color verde que enmarca un agujero redondeado en el que se ven una barra y un punto
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();

Documentación sobre tipos de miembros

enum class QCanvasPainter::CompositeOperation

Qt Canvas Painter admite tres operaciones de composición:

ConstanteValorDescripción
QCanvasPainter::CompositeOperation::SourceOver0El valor por defecto. Dibuja nuevas formas sobre el contenido existente.
QCanvasPainter::CompositeOperation::SourceAtop1La nueva forma solo se dibuja donde se superpone al contenido existente.
QCanvasPainter::CompositeOperation::DestinationOut2El contenido existente se mantiene allí donde no se solapa con la nueva forma.

Véase también setGlobalCompositeOperation().

[since 6.12] enum class QCanvasPainter::FillRule

Esta enumeración especifica cómo se rellenan las rutas.

ConstanteValorDescripción
QCanvasPainter::FillRule::NonZero0La ruta se rellena utilizando la regla de enrollamiento distinto de cero. Con esta regla, se determina si un punto se encuentra dentro de la figura mediante el siguiente método: se traza una línea horizontal desde el punto hasta un punto situado fuera de la figura. A continuación, se determina si la dirección de la línea en cada punto de intersección es hacia arriba o hacia abajo. El número de enrollamiento se determina sumando la dirección de cada intersección. Si el número es distinto de cero, el punto se encuentra dentro de la forma. Este modo de relleno también puede considerarse, en la mayoría de los casos, como la intersección de formas cerradas. Este modo es el predeterminado.
QCanvasPainter::FillRule::EvenOdd1La ruta se rellena utilizando la regla de relleno par-impar. Con esta regla, determinamos si un punto se encuentra dentro de la forma mediante el siguiente método: trazamos una línea horizontal desde el punto hasta un punto situado fuera de la forma y contamos el número de intersecciones. Si el número de intersecciones es impar, el punto se encuentra dentro de la forma.

Esta enumeración se introdujo en Qt 6.12.

Véase también fill().

enum class QCanvasPainter::ImageFlag
flags QCanvasPainter::ImageFlags

Esta enumeración especifica los indicadores relacionados con las imágenes. Utilízala con addImage() para establecer los indicadores.

ConstanteValorDescripción
QCanvasPainter::ImageFlag::GenerateMipmaps1 << 0Establezca este valor para generar mipmaps para la imagen. Los mipmaps deben utilizarse cuando se prefiera un resultado más suave para imágenes que se escalan a un tamaño inferior al original.
QCanvasPainter::ImageFlag::RepeatX1 << 1Úsala junto con el patrón de imagen para repetir la imagen en la coordenada X.
QCanvasPainter::ImageFlag::RepeatY1 << 2Úsalo con el patrón de imagen para repetir la imagen en la coordenada Y.
QCanvasPainter::ImageFlag::RepeatRepeatX | RepeatYÚsalo con el patrón de imagen para repetir la imagen en ambas coordenadas.
QCanvasPainter::ImageFlag::FlipY1 << 3Invierte la imagen en la dirección Y al renderizarla.
QCanvasPainter::ImageFlag::Premultiplied1 << 4Los datos de la imagen tienen el alfa premultiplicado.
QCanvasPainter::ImageFlag::Nearest1 << 5La interpolación de la imagen es «Más cercana» en lugar de «Lineal».

El tipo `ImageFlags` es una definición de tipo (`typedef`) para ` QFlags<ImageFlag>`. Almacena una combinación OR de valores de `ImageFlag`.

enum class QCanvasPainter::LineCap

LineCap se utiliza para definir cómo se dibuja el extremo de la línea (cabeza).

ConstanteValorDescripción
QCanvasPainter::LineCap::Butt0(por defecto) Extremo de línea cuadrado que no cubre el punto final de la línea.
QCanvasPainter::LineCap::Round1Extremo de línea redondeado.
QCanvasPainter::LineCap::Square2Extremo de línea cuadrado que cubre el punto final y se extiende más allá de él la mitad del ancho de la línea.

Véase también setLineCap().

enum class QCanvasPainter::LineJoin

LineJoin se utiliza para definir cómo se dibujan las uniones entre dos líneas conectadas.

ConstanteValorDescripción
QCanvasPainter::LineJoin::Round0Se rellena el arco circular entre las dos líneas.
QCanvasPainter::LineJoin::Bevel1Se rellena la muesca triangular entre las dos líneas.
QCanvasPainter::LineJoin::Miter2(por defecto) Los bordes exteriores de las líneas se extienden hasta encontrarse en ángulo, y esta área se rellena.

Véase también setLineJoin() y setMiterLimit().

enum class QCanvasPainter::PathConnection

En algunos métodos de dibujo, se utiliza PathConnection para especificar si la nueva ruta debe conectarse al último punto de la ruta anterior.

ConstanteValorDescripción
QCanvasPainter::PathConnection::NotConnected0No se traza ninguna línea desde el último punto de la ruta anterior hasta el primer punto de la ruta actual.
QCanvasPainter::PathConnection::Connected1El último punto de la ruta anterior se conectará con el primer punto de la ruta actual.

Véase también arc().

enum class QCanvasPainter::PathWinding

PathWinding se utiliza para especificar la dirección de trazado de la ruta. Esta dirección sirve para determinar si una subruta es un segmento cerrado o un hueco en la ruta.

ConstanteValorDescripción
QCanvasPainter::PathWinding::CounterClockWise0(predeterminado) Recorrido en sentido antihorario para formas sólidas.
QCanvasPainter::PathWinding::ClockWise1Enrollado en sentido horario para los agujeros.

Véase también setPathWinding().

enum class QCanvasPainter::TextAlign

TextAlign se utiliza para definir cómo se alinea el texto horizontalmente.

ConstanteValorDescripción
QCanvasPainter::TextAlign::Left0Alinea horizontalmente el lado izquierdo del texto con la posición especificada.
QCanvasPainter::TextAlign::Right1Alinea el lado derecho del texto horizontalmente con la posición especificada.
QCanvasPainter::TextAlign::Center2Alinea el centro del texto horizontalmente con la posición especificada.
QCanvasPainter::TextAlign::Start3(por defecto) El texto se alinea al inicio normal de la línea (alineado a la izquierda para configuraciones regionales de izquierda a derecha, alineado a la derecha para configuraciones regionales de derecha a izquierda).
QCanvasPainter::TextAlign::End4El texto se alinea al final normal de la línea (alineado a la derecha para configuraciones regionales de escritura de izquierda a derecha; alineado a la izquierda para configuraciones regionales de escritura de derecha a izquierda).

Véase también setTextAlign(), setTextDirection() y fillText().

enum class QCanvasPainter::TextBaseline

TextBaseline se utiliza para definir cómo se alinea (se ajusta a la línea de base) el texto en sentido vertical.

ConstanteValorDescripción
QCanvasPainter::TextBaseline::Top0Alinea la parte superior del texto verticalmente con la posición especificada.
QCanvasPainter::TextBaseline::Hanging1Alinea verticalmente la línea de base colgante del texto con la posición especificada.
QCanvasPainter::TextBaseline::Middle2Alinea el centro del texto verticalmente con la posición especificada.
QCanvasPainter::TextBaseline::Alphabetic3(por defecto) Alinea la línea de base del texto verticalmente con la posición especificada.
QCanvasPainter::TextBaseline::Bottom4Alinea la parte inferior del texto verticalmente con la posición especificada.

Véase también setTextBaseline() y fillText().

enum class QCanvasPainter::TextDirection

La propiedad «TextDirection» se utiliza para definir cómo se alinea el texto horizontalmente.

ConstanteValorDescripción
QCanvasPainter::TextDirection::LeftToRight0La dirección del texto es de izquierda a derecha.
QCanvasPainter::TextDirection::RightToLeft1La dirección del texto es de derecha a izquierda.
QCanvasPainter::TextDirection::Inherit2(por defecto) La dirección del texto se hereda de ` QGuiApplication layoutDirection`. Véase https://doc.qt.io/qt-6/qguiapplication.html#layoutDirection-prop.
QCanvasPainter::TextDirection::Auto3La dirección del texto se detecta automáticamente en función de la cadena de texto. Véase QString::isRightToLeft().

Nota: Dado que esto requiere analizar el texto, puede resultar más lento que otras opciones.

Véase también setTextDirection(), setTextAlign() y fillText().

enum class QCanvasPainter::WrapMode

WrapMode se utiliza para definir cómo se distribuye el texto en varias líneas.

ConstanteValorDescripción
QCanvasPainter::WrapMode::NoWrap0(por defecto) No se realizará ningún ajuste de línea. Si el texto no contiene suficientes saltos de línea, contentWidth superará el ancho establecido.
QCanvasPainter::WrapMode::Wrap1Si es posible, el ajuste de línea se produce en el límite de una palabra; de lo contrario, se producirá en el punto adecuado de la línea, incluso en medio de una palabra.
QCanvasPainter::WrapMode::WordWrap2El ajuste de línea se realiza únicamente en los límites de las palabras. Si una palabra es demasiado larga, el ancho del contenido superará el ancho establecido.
QCanvasPainter::WrapMode::WrapAnywhere3El ajuste se realiza en cualquier punto de la línea, incluso si se produce en medio de una palabra.

Véase también setTextWrapMode() y fillText().

Documentación de las funciones miembro

QCanvasPainter::QCanvasPainter()

Crea un «painter».

[noexcept] QCanvasPainter::~QCanvasPainter()

Acaba con el pintor.

qsizetype QCanvasPainter::activeImageCount() const

Devuelve el número de objetos « QCanvasImage » activos registrados con este « QCanvasPainter ». Esto también incluye las imágenes creadas internamente para « gradients ».

QCanvasImage Esta función no tiene en cuenta los objetos creados al registrar instancias de QCanvasOffscreenCanvas ni las texturas gestionadas externamente.

Véase también activeImageMemoryUsage(), addImage() y removeImage().

qsizetype QCanvasPainter::activeImageMemoryUsage() const

Devuelve una aproximación, en kilobytes, de la memoria utilizada por los datos de imagen (píxeles) de todas las instancias activas de ` QCanvasImage ` de este «pintor» que se hayan creado mediante la sobrecarga de ` addImage()` que toma un ` QImage`. También incluye los datos de las imágenes creadas internamente para ` gradients`.

QCanvasPainter No conserva copias de los datos de ` QImage ` del lado de la CPU una vez que ` addImage()` ha devuelto un resultado. Por lo tanto, el resultado de esta función es una aproximación de la memoria de la GPU utilizada para las texturas.

Nota: El valor es solo una estimación basada en el formato y las dimensiones de la imagen. Qt desconoce cómo se almacenan y distribuyen en memoria los datos de las texturas en el lado de la GPU.

Esta función no tiene en cuenta los lienzos fuera de pantalla ni las texturas gestionadas externamente registradas a través de las otras sobrecargas de addImage().

Para cada ` QCanvasImage` válido, siempre se puede consultar el tamaño individual en bytes llamando a ` sizeInBytes()`. Esa función devuelve resultados válidos incluso cuando el ` QCanvasImage ` se ha creado a partir de un ` QCanvasOffscreenCanvas ` o un ` QRhiTexture`, pero no tiene en cuenta los datos de mipmap ni de multimuestra.

Véanse también activeImageCount(), addImage() y removeImage().

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

Añade image con flags disponible para el pintor como textura. Devuelve QCanvasImage con el identificador de la textura y otra información sobre la imagen. El QCanvasImage devuelto se puede utilizar posteriormente con drawImage y QCanvasImagePattern. Tras llamar a este método, no es necesario mantener en memoria el image QImage .

La llamada con el mismo image es una operación de bajo coste, ya que se espera que se produzca un acierto en la caché.

Hay que tener cuidado al optimizar para que addImage() solo se llame una vez. Eso no siempre es suficiente, dependiendo del diseño de la aplicación. Por ejemplo, si se pierden los recursos gráficos subyacentes —por ejemplo, porque el «painter» se asocia internamente a un nuevo QRhi al mover un widget a un nuevo nivel superior—, entonces es esencial llamar a esta función para recrear las texturas gráficas nativas a partir de image.

Véanse también drawImage() y removeImage().

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

Añade ` texture ` con ` flags ` disponible para el pintor como textura. El objeto ` QCanvasImage ` devuelto se puede utilizar con ` drawImage ` y ` QCanvasImagePattern`.

Nota: No se tomala propiedad de texture.

Esta es una función sobrecargada.

Véase también drawImage() y removeImage().

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

Registra ` canvas ` con ` flags ` en el pintor para que esté disponible como imagen. El objeto ` QCanvasImage ` devuelto se puede utilizar con ` drawImage ` y ` QCanvasImagePattern`.

Nota: ` canvas ` sigue gestionando los recursos gráficos nativos subyacentes, lo que significa que ` removeImage()` no invalida ` canvas `.

Esta es una función sobrecargada.

Véase también drawImage() y removeImage().

void QCanvasPainter::addPath(const QPainterPath &path)

Añade path a la ruta actual.

Nota: QCanvasPainter utiliza por defecto la regla de relleno « NonZero » (Qt::WindingFill), mientras que QPainterPath utiliza por defecto « Qt::OddEvenFill ». Así que recuerda cambiar la regla de relleno si es necesario, por ejemplo, utilizando setFillRule().

Nota: Este método está disponible principalmente por motivos de compatibilidad con QPainter y QPainterPath. No mejora el rendimiento en comparación con el trazado directo del trazado mediante los métodos QCanvasPainter.

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

Añade « path » a la ruta actual, utilizando opcionalmente « transform » para modificar los puntos de la ruta. Cuando no se proporciona « transform » (o se trata de una matriz identidad), esta operación es muy rápida, ya que reutiliza los datos de la ruta.

Dos círculos verdes idénticos; el segundo es una copia desplazada del primero
// 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())

Añade path a la ruta actual, empezando por el comando de start e incluyendo count número de comandos. Opcionalmente, se puede utilizar transform para modificar los puntos de la ruta. Se comprueba el rango de start y count, de modo que no se acceda a más de QCanvasPath::commandsSize() comandos. En caso de que la ruta no deba continuar desde la posición actual, llama primero a moveTo(), por ejemplo, con path.positionAt(start - 1).

Onda sinusoidal situada encima de un tramo más corto de la misma onda, copiado debajo de ella
// 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)

Crea un nuevo subtrayecto con forma de arco circular. El centro del arco se encuentra en centerX, centerY, con radius, y el arco se dibuja desde el ángulo a0 hasta a1, y se traza en direction (ClockWise o CounterClockWise). Cuando connection es NotConnected, el arco no añade una línea desde la posición anterior del trazado hasta el inicio del arco. Los ángulos se especifican en radianes.

Una forma de tarta verde que ocupa tres cuartas partes de un círculo, dejando un cuadrante vacío
p->beginPath();
p->moveTo(100, 100);
p->arc(100, 100, 80, 0, 1.5 * M_PI);
p->closePath();
p->fill();
p->stroke();

Nota: Aunque el contexto 2D de HTML Canvas utiliza arc() para dibujar círculos, con QCanvasPainter se recomienda utilizar circle() o ellipse() para ello.

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

Crea un nuevo subtrayecto con forma de arco circular. El centro del arco se encuentra en centerPoint, con radius, y el arco se dibuja desde el ángulo a0 hasta a1, y se traza en direction (ClockWise o CounterClockWise). Cuando connection es NotConnected, el arco no añade una línea desde la posición del trazado anterior hasta el inicio del arco. Los ángulos se especifican en radianes.

Nota: Aunque el contexto 2D de HTML canvas utiliza arc() para dibujar círculos, con QCanvasPainter se recomienda utilizar circle() o ellipse() para ello.

Esta es una función sobrecargada.

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

Añade un segmento de arco en la esquina definida por el último punto de la ruta y dos puntos especificados (x1, y1 y x2, y2) con radius. El arco se conecta automáticamente al último punto de la ruta mediante una línea recta si es necesario.

Trayectoria en forma de gancho con un segmento superior horizontal, una gran curva redondeada y un pequeño rizo al final
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)

Añade un segmento de arco en la esquina definida por el último punto de la ruta y dos puntos especificados (controlPoint1 y controlPoint2) con radius. El arco se conecta automáticamente al último punto de la ruta mediante una línea recta si es necesario.

Esta es una función sobrecargada.

void QCanvasPainter::beginHoleSubPath()

Iniciar una subruta de agujero. Esto equivale a setPathWinding(QCanvasPainter::PathWinding::ClockWise))

Círculo verde con un agujero cuadrado que contiene un círculo verde liso más pequeño
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();

Véase también beginSolidSubPath().

void QCanvasPainter::beginPath()

Empieza a trazar una nueva ruta mientras borra la ruta actual.

void QCanvasPainter::beginSolidSubPath()

Iniciar una subruta sólida. Esto equivale a setPathWinding(QCanvasPainter::PathWinding::CounterClockWise))

Véase también beginHoleSubPath().

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

Añade un segmento de Bézier cúbico desde el último punto de la ruta, pasando por dos puntos de control (cp1X, cp1Y y cp2X, cp2Y), hasta el punto especificado (x, y).

Curva de Bézier cúbica suave en forma de S
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)

Añade un segmento Bézier cúbico desde el último punto de la ruta, pasando por dos puntos de control (controlPoint1 y controlPoint2), hasta el punto especificado endPoint.

Se trata de una función sobrecargada.

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

Crea un nuevo subtrayecto con forma de círculo, centrado en ( centerX, centerY) y con un radio de radius.

Círculo verde con un contorno de color verde azulado oscuro
p->beginPath();
p->circle(100, 100, 80);
p->fill();
p->stroke();

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

Crea un nuevo subtrazo con forma de círculo centrado en centerPoint con radius.

Esta es una función sobrecargada.

void QCanvasPainter::cleanupResources()

Programa la eliminación de texturas no utilizadas de la caché.

Además, al llamar a esta función, es posible que se reduzcan otras cachés y grupos, con el fin de minimizar el uso de memoria. Esto podría dar lugar a llamadas de dibujo más costosas posteriormente.

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

Borra los píxeles de un área rectangular rellenando con negro transparente el rectángulo especificado por x, y, width y height. Dado que el borrado no requiere mezcla de colores, puede resultar más rápido que fillRect().

Círculo verde con una muesca rectangular vertical que le falta la parte superior
p->beginPath();
p->circle(100, 100, 80);
p->fill();
p->stroke();
p->clearRect(60, 0, 80, 120);

void QCanvasPainter::clearRect(const QRectF &rect)

Borra los píxeles de un área rectangular rellenando con negro transparente el rectángulo especificado por ` rect `. Se trata de un método sobrecargado que utiliza ` QRectF`.

Se trata de una función sobrecargada.

void QCanvasPainter::closePath()

Cierra la subtrayectoria actual con un segmento de línea. Esto equivale a utilizar « lineTo » ([punto de inicio]) como último elemento de la trayectoria.

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

Devuelve un nuevo lienzo fuera de pantalla con los valores indicados para pixelSize, sampleCount y flags.

El tamaño del lienzo se especifica en píxeles. Las propiedades pixelSize, sampleCount y flags son inmutables a partir de ese momento. Para obtener un lienzo con un tamaño, número de muestras o indicadores diferentes, crea uno nuevo.

Para dirigir los comandos de dibujo a un lienzo fuera de pantalla, llama a la sobrecarga adecuada de QCanvasRhiPaintDriver::beginPaint() cuando trabajes con la API de bajo nivel, o a QCanvasPainterWidget::beginCanvasPainting() o QCanvasPainterItemRenderer::beginCanvasPainting() cuando utilices las clases de widget de conveniencia o de elemento Qt Quick.

Normalmente, el contenido del lienzo se borra al pintar sobre él. Para desactivar esto, pasa ` PreserveContents ` en ` flags`.

Para solicitar un renderizado con multimuestreo en el lienzo (antialiasing por multimuestreo, MSAA), establece un número de muestras superior a 1, como 4 u 8. Sin embargo, cuando se habilita el multimuestreo, no se admite la conservación del contenido del lienzo entre pasadas de renderizado, y el indicador ` PreserveContents ` no funcionará en este caso.

Nota: Un lienzo fuera de pantalla se respalda con una textura independiente del destino de renderizado principal, y el renderizado en él siempre se realiza con un factor de escala (relación de píxeles del dispositivo) de 1. Por ejemplo, para crear un lienzo que coincida con las dimensiones reales de renderizado de un ` QCanvasPainterWidget`, pasa ` size() * devicePixelRatio() ` como ` pixelSize`, ya que el ` size() ` del widget es solo el tamaño lógico sin incluir el factor de escala.

void QCanvasPainter::destroyCanvas(QCanvasOffscreenCanvas &canvas)

Destruye los recursos asociados a canvas. canvas pasa entonces a ser null canvas.

El «painter» realiza esta operación automáticamente al ser destruido. Por lo tanto, solo es necesario llamar a esta función cuando se desee liberar los recursos asociados de forma inmediata.

void QCanvasPainter::drawBoxShadow(const QCanvasBoxShadow &shadow)

Dibuja un cuadro shadow. La sombra se pintará con la posición, el tamaño, el color, el desenfoque, etc., definidos por shadow. No es necesario llamar a beginPath() antes de este método.

Nota: Para ver visualmente el área cubierta por drawBoxShadow(), configura la variable de entorno QCPAINTER_DEBUG_SHADOW_RECT.

Cuadrado redondeado de color verde que proyecta una suave sombra gris en forma de caja por todos los lados
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();

Véase también QCanvasBoxShadow.

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

Dibuja « image » en « x » y « y » con su tamaño predeterminado.

Logotipo verde de Qt dibujado en su tamaño predeterminado
static QImage logo(":/qt_logo.png");
QCanvasImage image = p->addImage(logo);
p->drawImage(image, 36, 36);

Véase también addImage().

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

Dibuja image con la posición y el tamaño de destinationRect.

Esta es una función sobrecargada.

Véase también addImage().

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

Dibuja « image » con la posición y el tamaño de « destinationRect », a partir del área de la imagen « sourceRect ».

Letra «Q» ampliada, recortada de una zona del logotipo de Qt
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);

Esta es una función sobrecargada.

Véase también addImage().

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

Dibuja « image » en x, y, en las direcciones indicadas: width y height.

El logotipo verde de Qt se ha estirado a lo alto para adaptarse a un ancho y una altura personalizados
static QImage logo(":/qt_logo.png");
QCanvasImage image = p->addImage(logo);
p->drawImage(image, 50, 0, 100, 200);

Se trata de una función sobrecargada.

Véase también addImage().

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

Crea un nuevo subtrayecto con forma de elipse centrado en ( centerX, centerY) con radiusX y radiusY.

Elipse ancha de color verde con un contorno verde azulado oscuro
p->beginPath();
p->ellipse(100, 100, 80, 60);
p->fill();
p->stroke();

void QCanvasPainter::ellipse(const QRectF &rect)

Crea un nuevo subtrazo con forma de elipse dentro de rect. Esta elipse cubrirá el área rect.

Contorno de una elipse alta encajada dentro de un rectángulo verde relleno
QRectF rect(40, 20, 120, 160);
p->fillRect(rect);
p->beginPath();
p->ellipse(rect);
p->stroke();

Se trata de una función sobrecargada.

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

Crea un nuevo subtrayecto con forma de elipse, centrado en centerPoint, con radiusX y radiusY.

Esta es una función sobrecargada.

void QCanvasPainter::fill()

Rellena el trazado actual con el estilo de relleno actual y la regla de relleno actual.

Dos barras verdes y un círculo verde unidos para formar una sola figura compuesta
p->beginPath();
p->rect(20, 20, 40, 160);
p->rect(140, 20, 40, 160);
p->circle(100, 100, 60);
p->fill();

Véase también setFillStyle() y setFillRule().

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

Rellena el trazado actual con el estilo de relleno actual y la regla de relleno « fillRule ».

Esta es una función sobrecargada.

Esta función se introdujo en Qt 6.12.

Véase también ` setFillStyle()` y ` setFillRule()`.

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

Rellena el « path » con el estilo y la regla de relleno actuales, y lo incluye en « pathGroup ». El relleno mediante « QCanvasPath » resulta óptimo cuando el trazado contiene más comandos y es mayoritariamente estático.

Cuando pathGroup es -1, la ruta no se almacenará en la caché del lado de la GPU. Este es el valor por defecto. Para solicitar el almacenamiento en caché de los datos de la ruta, pasa un valor igual o superior a 0. Puedes encontrar más información sobre el uso de grupos de caché de rutas en la documentación de QCanvasPath.

No es necesario llamar a ` beginPath()` antes de este método.

Pila de barras horizontales rellenas de distintos anchos que forman la silueta de un reloj de arena
// 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);

Esta es una función sobrecargada.

Véase también setFillStyle(), setFillRule() y removePathGroup().

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

Rellena el objeto « path » con el estilo y la regla de relleno actuales fillRule

Esta es una función sobrecargada.

Esta función se introdujo en Qt 6.12.

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

Dibuja un rectángulo relleno en la posición especificada ( x, y) con el tamaño width, height.

Nota: Esta función se proporciona por comodidad. Cuando se vaya a rellenar más de un rectángulo, es preferible utilizar rect().

Cuadrado relleno de color verde liso
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)

Dibuja un rectángulo relleno en rect. Se trata de un método sobrecargado que utiliza QRectF.

Nota: Se proporciona por comodidad. Cuando se vaya a rellenar más de un rectángulo, es preferible utilizar rect().

Se trata de una función sobrecargada.

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

Dibuja una cadena « text » en la ubicación especificada ( x, y), con los valores actuales de «textAlign» y «textBaseline». Para que el texto se ajuste a varias líneas, configura el modo de ajuste de texto mediante « setTextWrapMode()» con un valor distinto del predeterminado « NoWrap ». El parámetro opcional « maxWidth » toma por defecto el valor « 0 ». Esto significa que, por ejemplo, si se ha establecido « WordWrap », el texto se ajustará a cada palabra. Establece el parámetro maxWidth en el ancho de línea deseado en píxeles.

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

Véase también setTextAlign(), setTextBaseline() y setTextWrapMode().

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

Dibuja una cadena de tipo « text » dentro de un rectángulo de tipo « rect », con los valores actuales de «textAlign» y «textBaseline». El ancho del parámetro «rect» se utiliza como «maxWidth».

Se trata de un método sobrecargado que utiliza ` QRectF`. A menudo resulta útil establecer la línea de base del texto en ` TextBaseline::Top ` o ` TextBaseline::Middle ` al dibujar texto con este método.

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

Se trata de una función sobrecargada.

Véase también setTextAlign(), setTextBaseline() y setTextWrapMode().

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

Dibuja una cadena « text » en la posición especificada « point », con los valores actuales de «textAlign» y «textBaseline». Para que el texto se ajuste a varias líneas, configura el modo de ajuste de texto mediante « setTextWrapMode()» con un valor distinto del predeterminado « NoWrap ». El parámetro opcional « maxWidth » toma por defecto el valor « 0 ». Esto significa que, por ejemplo, si se ha establecido « WordWrap », el texto se ajustará a cada palabra. Establece el parámetro « maxWidth » en el ancho de línea deseado en píxeles.

Este es un método sobrecargado que utiliza QPointF.

Se trata de una función sobrecargada.

Véase también setTextAlign(), setTextBaseline() y setTextWrapMode().

QTransform QCanvasPainter::getTransform() const

Devuelve la transformación actual.

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

Añade un segmento de recta desde el último punto de la ruta hasta el punto ( x, y).

Dos segmentos de recta que se unen en un punto para formar una esquina
p->beginPath();
p->moveTo(20, 20);
p->lineTo(140, 180);
p->lineTo(180, 120);
p->stroke();

void QCanvasPainter::lineTo(QPointF point)

Añade un segmento de recta desde el último punto de la ruta hasta point.

Esta es una función sobrecargada.

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

Inicia una nueva subruta con ( x, y) como primer punto.

void QCanvasPainter::moveTo(QPointF point)

Inicia una nueva subruta con point como primer punto.

Esta es una función sobrecargada.

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

Añade un segmento Bézier cuadrático desde el último punto de la ruta, pasando por un punto de control (cpX, cpY), hasta el punto especificado (x, y).

Forma de hoja verde puntiaguda formada por dos curvas cuadráticas
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)

Añade un segmento Bézier cuadrático desde el último punto de la ruta, pasando por un punto de control ( controlPoint ), hasta el punto de control especificado ( endPoint).

Se trata de una función sobrecargada.

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

Crea un nuevo subtrayecto con forma de rectángulo en la posición x, y, con las dimensiones width, height.

Cuadrado verde relleno con un contorno de color verde azulado oscuro
p->beginPath();
p->rect(20, 20, 160, 160);
p->fill();
p->stroke();

void QCanvasPainter::rect(const QRectF &rect)

Crea un nuevo subtrazado con forma de rectángulo en rect. Se trata de un método sobrecargado que utiliza QRectF.

Se trata de una función sobrecargada.

void QCanvasPainter::removeImage(const QCanvasImage &image)

Libera los recursos asociados a image y elimina la imagen del pintor.

Nota: Normalmente no es necesario llamar aesta función , ya que los recursos, como las texturas, se liberan de todos modos en el destructor del pintor. Esta función resulta útil cuando es necesario reducir el uso de memoria debido a la gran cantidad de imágenes, y algunas de ellas ya no se utilizan.

Nota: Las imágeneseliminadas ya no se pueden utilizar en operaciones de pintura.

Nota: Es posible querecursos como las texturas creadas con la API 3D subyacente no se liberen de inmediato. Dichas operaciones pueden aplazarse a fotogramas posteriores, normalmente cuando este ` QCanvasPainter ` vuelve a pintar tras haberse enviado el conjunto activo de llamadas de dibujo.

Véase también addImage().

void QCanvasPainter::removePathGroup(int pathGroup)

Elimina « pathGroup » de la caché del pintor. Si a continuación se llama a « fill()» o « stroke()» para « pathGroup », se volverá a generar la ruta en la caché del grupo.

Nota: Normalmente no es necesario llamar aesta función , ya que las rutas se eliminan en el destructor del «painter». Úsala únicamente para reducir el consumo de memoria cuando ya no se necesite pathGroup o, por ejemplo, cuando la ruta tenga muchos menos comandos de los que tenía anteriormente y sea necesario reducir el tamaño del búfer.

Véase también ` fill()` y ` stroke()`.

void QCanvasPainter::reset()

Restablece el estado actual del pintor a los valores predeterminados.

Esto incluye los estilos de trazo y relleno y las propiedades relacionadas, la matriz de transformación, la región de recorte, la configuración relacionada con el texto, las propiedades de composición, la pila de estados de dibujo y la configuración de suavizado.

Nota: Este método difiere del método reset() del contexto 2D de HTML Canvas en que no borra visualmente los búferes del lienzo.

Nota: Los valores de ` setWindingEnforce()` y ` setHighQualityStroking()` no se modifican.

Rectángulo verde redondeado girado, situado encima de un cuadrado relleno de negro y de un cuadrado con contorno dibujado tras el reinicio
// 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);

Véase también save() y restore().

void QCanvasPainter::resetClipping()

Restablece y desactiva el recorte.

Véase también ` setClipRect()`.

void QCanvasPainter::resetTransform()

Restablece la transformada actual a una matriz identidad.

void QCanvasPainter::restore()

Extrae y restaura el estado de renderizado actual. De este modo, se restaurará el estado guardado anteriormente. Si no se ha llamado a ` save()` y la pila de estados está vacía, llamar a esta función no tiene ningún efecto.

Véase también save().

void QCanvasPainter::rotate(qreal angle)

Gira el sistema de coordenadas actual en el sentido de las agujas del reloj un ángulo de angle.

El ángulo se especifica en radianes. Utiliza qDegreesToRadians() para convertir grados a radianes.

Rectángulo redondeado de color verde girado 45 grados con el texto «¡Qué bonito!» girado a lo largo de él
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)

Crea un nuevo subtrayecto con forma de rectángulo redondeado en la posición x, y, con las dimensiones width, height. El redondeo de las esquinas será radius.

Cuadrado redondeado de color verde con un contorno de color verde azulado oscuro
p->beginPath();
p->roundRect(20, 20, 160, 160, 30);
p->fill();
p->stroke();

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

Crea un nuevo subtrayecto con forma de rectángulo redondeado en rect con esquinas radius. Se trata de un método sobrecargado que utiliza QRectF.

Se trata de una función sobrecargada.

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

Crea un nuevo subtrayecto con forma de rectángulo redondeado en rect. El redondeo de las esquinas puede variar según la esquina, con radiusTopLeft, radiusTopRight, radiusBottomRight y radiusBottomLeft.

Se trata de una función sobrecargada.

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

Crea un nuevo subtrayecto con forma de rectángulo redondeado en la posición x, y, con un tamaño de width, height. El redondeo de las esquinas puede variar en cada esquina, con radiusTopLeft, radiusTopRight, radiusBottomRight, radiusBottomLeft.

Cuadrado verde con una esquina superior izquierda puntiaguda y tres esquinas redondeadas de diferentes radios
p->beginPath();
p->roundRect(20, 20, 160, 160,
             0, 40, 20, 80);
p->fill();
p->stroke();

Se trata de una función sobrecargada.

void QCanvasPainter::save()

Inserta y guarda el estado de renderizado actual en una pila de estados. Para restaurar el estado, es necesario utilizar la función correspondiente ` restore()`.

Dos contornos rectangulares con un rectángulo ligeramente girado entre ellos
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);

Véase también restore().

void QCanvasPainter::scale(qreal scale)

Aplica una escala al sistema de coordenadas actual mediante scale. Las coordenadas x e y se escalan de forma uniforme.

Contornos cuadrados anidados que se van reduciendo hacia el centro mediante un escalado repetido
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)

Escala el sistema de coordenadas actual mediante scaleX y scaleY.

Esta es una función sobrecargada.

void QCanvasPainter::setAntialias(qreal antialias)

Establece el nivel actual de suavizado en antialias en píxeles. Un mayor nivel de suavizado se traduce en un trazado más suave. Esto solo afecta al relleno y al trazo, no a las imágenes ni a los textos. El valor por defecto es 1.0 y el valor máximo es 10.0.

El suavizado se puede modificar por cada trazado, por lo que se puede establecer antes de cada trazo o relleno. Para desactivar el suavizado y reducir el coste de renderizado, establece el suavizado en 0.

Conjunto de líneas onduladas que se vuelven cada vez más suaves y borrosas a medida que aumenta el suavizado.
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();
}

Véase también setTextAntialias().

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

Establece el rectángulo de recorte actual en (x, y, width, height). El rectángulo de recorte se transforma mediante la transformación actual.

Nota: El recorte conlleva un cierto coste en el rendimiento y solo debe utilizarse cuando sea necesario.

Un cuarto de círculo verde y el texto «Clip me» recortados en una región cuadrada
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);

Véase también resetClipping().

void QCanvasPainter::setClipRect(const QRectF &rect)

Establece el rectángulo de recorte actual en rect. El rectángulo de recorte se transforma mediante la transformación actual.

Nota: El recorte conlleva un cierto coste de rendimiento y solo debe utilizarse cuando sea necesario.

Esta es una función sobrecargada.

Véase también resetClipping().

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

Establece la regla de relleno de trazados en « fillRule ». Este valor se aplica a todas las llamadas a fill() realizadas tras haber establecido la regla. La regla de relleno predeterminada es QCanvasPainter::FillRule::NonZero

Dos estrellas verdes de cinco puntas superpuestas, una de color liso y otra con el centro abierto
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();

Esta función se introdujo en Qt 6.12.

void QCanvasPainter::setFillStyle(QColor color)

Establece el estilo de relleno en un color sólido color. El estilo de relleno predeterminado es negro sólido (0, 0, 0, 1).

Cuadrados concéntricos rellenos en negro, verde azulado oscuro y verde
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)

Establece el estilo de relleno en « brush ». El estilo de relleno predeterminado es negro sólido (0, 0, 0, 1).

Cuadrado verde con un degradado radial que se va atenuando hasta convertirse en verde azulado oscuro en los bordes
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);

Esta es una función sobrecargada.

void QCanvasPainter::setFont(const QFont &font)

Establece « font » como fuente activa en este momento.

void QCanvasPainter::setGlobalAlpha(qreal alpha)

Establece el valor global de alfa (transparencia) en alpha. Este valor de alfa se aplica a todas las formas renderizadas. Las rutas que ya sean transparentes también se volverán proporcionalmente más transparentes. El valor de alfa debe estar entre 0,0 (totalmente transparente) y 1,0 (totalmente opaco). Por defecto, el valor de alfa es 1.0.

Cuatro logotipos de Qt sobre azulejos verdes que se desvanecen hasta volverse totalmente transparentes a lo largo de la cuadrícula
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)

Establece el brillo global en value. Este brillo se aplica a todas las formas renderizadas. Un valor de 0 hará que el dibujo sea completamente negro. El valor también puede ser superior a 1,0 para aumentar el brillo. Por defecto, el brillo es 1.0.

Cuatro logotipos de Qt sobre azulejos verdes que se oscurecen progresivamente, pasando de un tono claro a casi negro a lo largo de la cuadrícula
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)

Establece el modo de operación de composición global en « operation ». Este modo se aplica a todas las operaciones de dibujo. El modo predeterminado es « QCanvasPainter::CompositeOperation::SourceOver ».

Nota: Para que funcionen correctamente, los modos de composición requieren que se habilite la opción « alphaBlending » y que se utilice un fondo transparente para el lienzo.

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)

Establece el contraste global en value. Este contraste se aplica a todas las formas representadas. Un valor de 0 hará que el dibujo sea completamente gris (0,5; 0,5; 0,5). El valor también puede ser superior a 1,0 para aumentar el contraste. Por defecto, el contraste es 1.0.

Cuatro logotipos de Qt sobre azulejos verdes, que van desde un contraste elevado hasta un gris descolorido
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)

Establece la saturación global en value. Esta saturación se aplica a todas las formas renderizadas. Un valor de 0 desactivará la saturación y hará que el dibujo se muestre completamente en escala de grises. El valor también puede ser superior a 1,0 para aumentar la saturación. Por defecto, la saturación es 1.0.

Cuatro logotipos de Qt sobre azulejos verdes que van pasando de un color intenso a una escala de grises a lo largo de la cuadrícula
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)

Establece el trazo de alta calidad en « enabled ». Si se configura en « true », se obtiene una representación más correcta en algunos casos menos habituales en los que el trazo se superpone y no tiene opacidad total. Al activarlo, aumenta el coste de representación. El valor por defecto es « 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)

Establece el extremo de la línea de los trazos en « cap ». El remate predeterminado es « QCanvasPainter::LineCap::Butt ».

Tres líneas horizontales que muestran remates de línea a tope, en ángulo recto y redondeados
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)

Establece la unión de líneas de los trazos en « join ». La unión de líneas predeterminada es « QCanvasPainter::LineJoin::Miter ».

Tres trazados en zigzag que muestran uniones en inglete, bisel y redondeadas
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);

Véase también setMiterLimit().

void QCanvasPainter::setLineWidth(qreal width)

Establece el grosor de las líneas de los trazos en width en píxeles. El grosor predeterminado es 1.0. Cuando el suavizado está activado, los grosores inferiores a un píxel atenuarán automáticamente la opacidad, creando un resultado suave.

Conjunto de curvas onduladas dibujadas con grosores de línea que aumentan progresivamente
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();
}

Véase también stroke().

void QCanvasPainter::setMiterLimit(qreal limit)

Establece el límite de inglete en limit. El límite de inglete controla cuándo se bisela una esquina afilada. Cuando la longitud de la esquina superaría este límite, se aplicará en su lugar un « QCanvasPainter::LineJoin::Bevel » entre las líneas. Esto solo tiene efecto con la unión de líneas « QCanvasPainter::LineJoin::Miter ». El límite por defecto es 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);

Véase también setLineJoin().

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

Establece la subruta actual winding como CounterClockWise (por defecto) o ClockWise. CounterClockWise dibuja subrutas sólidas, mientras que ClockWise dibuja agujeros.

Cuadrado redondeado de color verde con un pequeño círculo y un rectángulo recortados a modo de agujeros
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();

Véase también beginHoleSubPath() y beginSolidSubPath().

void QCanvasPainter::setStrokeStyle(QColor color)

Establece el estilo del trazo en « color » (sólido). El estilo de trazo predeterminado es el color negro sólido (0, 0, 0, 1).

Tres contornos cuadrados anidados en negro, verde azulado oscuro y verde
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)

Establece el estilo del trazo en « brush ». El estilo predeterminado del trazo es negro sólido (0, 0, 0, 1).

Dos contornos cuadrados anidados con degradados diagonales de verde a negro y de verde a amarillo
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);

Esta es una función sobrecargada.

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

Establece la alineación horizontal del texto en « align ». La alineación predeterminada es « QCanvasPainter::TextAlign::Start ».

Las etiquetas «Izquierda», «Centro», «Derecha», «Inicio» y «Fin» situadas alrededor de una línea de referencia vertical
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);

Véase también setTextBaseline().

void QCanvasPainter::setTextAntialias(qreal antialias)

Establece el nivel actual de suavizado del texto. El valor « antialias » es un multiplicador del suavizado normal, lo que significa que « 0.0 » desactiva el suavizado y «2.0» lo duplica. El valor por defecto es 1.0.

Nota: Debido a la técnica de suavizado de texto utilizada (SDF), el nivel máximo de suavizado es bastante limitado, lo que se nota menos cuando el tamaño de la fuente es pequeño.

Las líneas etiquetadas como «Antialiasing 1.0» a «4.0» se vuelven progresivamente más suaves y borrosas
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)

Establece la alineación vertical (línea de base) del texto en « baseline ». La alineación predeterminada es « QCanvasPainter::TextBaseline::Alphabetic ».

Etiquetas «Abajo», «En medio», «Arriba», «Alfabéticas» y «Colgadas», alineadas con las líneas de base horizontales
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);

Véase también setTextAlign().

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

Establece la dirección del texto en « direction ». La dirección predeterminada es « 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)

Establece el ajuste de la altura de línea, en píxeles, en height para el texto ajustado. La altura de línea predeterminada es 0.

Texto de dos líneas en tres recuadros que muestran una altura de línea de -10, 0 y 10 píxeles
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)

Establece el modo de ajuste de texto en « wrapMode ». El modo de ajuste predeterminado es « QCanvasPainter::WrapMode::NoWrap ».

La misma cadena en tres recuadros que muestran «sin ajuste», «ajuste de línea» y «ajuste en cualquier lugar»
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)

Restablece la transformación actual y utiliza en su lugar « transform ».

Un pequeño cuadrado verde redondeado situado encima de un cuadrado redondeado más grande, girado y a escala
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();

Véase también transform().

void QCanvasPainter::setWindingEnforce(bool enabled)

Establece la aplicación de la dirección de las curvas en « enabled ». Si se establece en « false », se desactiva la aplicación de la dirección de las curvas para que coincida con lo configurado en « setPathWinding()». Desactivarla permite, por ejemplo, crear huecos en las curvas añadiendo los puntos en el sentido de las agujas del reloj. Desactivarla también puede mejorar el rendimiento. El valor por defecto es « 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)

Desplaza (deforma) el sistema de coordenadas actual a lo largo del eje X en un ángulo de angleX y a lo largo del eje Y en un ángulo de angleY. Los ángulos se especifican en radianes.

Rectángulo redondeado verde con el texto «¡Qué mono!» deformado hasta formar un paralelogramo
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()

Traza la ruta actual con el estilo de trazo actual.

Dos contornos de barras verticales con un contorno de círculo superpuesto
p->beginPath();
p->rect(20, 20, 40, 160);
p->rect(140, 20, 40, 160);
p->circle(100, 100, 60);
p->stroke();

Véase también setStrokeStyle().

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

Dibuja el path con el estilo de trazo actual y lo incluye en pathGroup. El dibujo a través de QCanvasPath resulta óptimo cuando la ruta contiene más comandos y es mayoritariamente estática.

Cuando pathGroup es -1, los datos relacionados con la representación de la ruta no se almacenarán en caché. Este es el valor por defecto. Para solicitar el almacenamiento en caché de los datos de la ruta, pasa un valor igual o superior a 0. Puedes encontrar más información sobre el uso de grupos de caché de rutas en la documentación de QCanvasPath.

No es necesario llamar a ` beginPath()` antes de este método.

Fila de contornos de barras verticales estrechas de distintas alturas
// 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);

Esta es una función sobrecargada.

Véase también setStrokeStyle() y removePathGroup().

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

Dibuja un rectángulo con contorno en la posición especificada ( x, y) con el tamaño width, height.

Nota: Esta función se proporciona por comodidad. Cuando se dibujen más de un rectángulo, es preferible utilizar ` rect()`.

Contorno cuadrado de color verde azulado oscuro
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)

Dibuja un rectángulo con contorno en ` rect`. Se trata de un método sobrecargado que utiliza ` QRectF`.

Nota: Se proporciona por comodidad. Cuando se vaya a trazar más de un rectángulo, es preferible utilizar ` rect()`.

Se trata de una función sobrecargada.

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

Mide el cuadro delimitador de una cadena « text » en (x, y).

Para medir texto de varias líneas, configura el modo de ajuste de texto mediante ` setTextWrapMode()` con un valor distinto del predeterminado ` NoWrap`. Además, establece el parámetro opcional ` maxWidth ` con el ancho de línea deseado en píxeles.

Devuelve QRectF con los valores [xmin, ymin, width, height]. Los valores medidos se devuelven en el espacio de coordenadas local.

Texto creado con Qt que se muestra en una línea y se ajusta a dos, cada una dentro de su cuadro delimitador medido
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) const

Mide el rectángulo delimitador de una cadena de tipo « text » en rect. Devuelve un objeto de tipo « QRectF » con los valores [xmin, ymin, width, height]. Los valores medidos se devuelven en el espacio de coordenadas local.

Se trata de una función sobrecargada.

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

Mide el cuadro delimitador de una cadena « text » en point.

Para medir texto de varias líneas, configura el modo de ajuste de texto mediante setTextWrapMode() en un valor distinto del predeterminado NoWrap. Además, establece el parámetro opcional maxWidth en el ancho de línea deseado en píxeles.

Devuelve QRectF con los valores [xmin, ymin, width, height]. Los valores medidos se devuelven en el espacio de coordenadas local.

Esta es una función sobrecargada.

void QCanvasPainter::transform(const QTransform &transform)

Multiplica el sistema de coordenadas actual por el valor especificado en « transform ».

Diez barras verdes redondeadas dispuestas en forma de anillo mediante rotaciones repetidas alrededor de un punto central
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();
}

Véase también setTransform().

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

Traslada el sistema de coordenadas actual mediante x y y.

Dos rectángulos redondeados verdes idénticos, el inferior desplazado hacia abajo por la traslación
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)

Traslada el sistema de coordenadas actual mediante « point ».

Esta es una función sobrecargada.

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.