QCanvasPainter Class

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

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

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

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 de las funciones miembro

QCanvasPainter::QCanvasPainter()

Construye un pintor.

[noexcept] QCanvasPainter::~QCanvasPainter()

Destruye al 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 Los objetos creados mediante el registro de instancias de QCanvasOffscreenCanvas o texturas gestionadas externamente no son tenidos en cuenta por esta función.

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 la imagen (píxel) para todas las instancias activas de QCanvasImage para este pintor que fueron creadas por la sobrecarga addImage() tomando un QImage. También incluye los datos de las imágenes creadas internamente para gradients.

QCanvasPainter no guarda copias de los datos QImage del lado de la CPU una vez que addImage() ha retornado. Por lo tanto, el resultado de esta función es una aproximación de la memoria de la GPU que se utiliza para las texturas.

Los lienzos fuera de pantalla y las texturas gestionadas externamente registradas a través de otras sobrecargas de addImage() no son tenidas en cuenta por esta función.

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

Véase 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 id de la textura y otra información sobre la imagen. El QCanvasImage devuelto puede ser usado con drawImage y QCanvasImagePattern. Después de llamar a este método, image QImage no necesita ser mantenido en memoria.

Llamar con el mismo image es una operación barata, ya que se espera un golpe de caché.

Hay que tener cuidado al optimizar para llamar a addImage() sólo una vez. Esto no siempre es suficiente, dependiendo del diseño de la aplicación. Por ejemplo, si los recursos gráficos subyacentes se pierden, por ejemplo porque el pintor está asociado con un nuevo QRhi bajo el capó debido a mover un widget a un nuevo nivel superior, entonces llamar a esta función es esencial para volver a crear las texturas gráficas nativas desde image.

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

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

Añade texture con flags disponible para el pintor como textura. La bandera NativeTexture se establece implícitamente. El QCanvasImage devuelto se puede utilizar con drawImage y QCanvasImagePattern.

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

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

Registra canvas con flags al pintor para que esté disponible como imagen. El QCanvasImage devuelto puede utilizarse con drawImage y QCanvasImagePattern.

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

void QCanvasPainter::addPath(const QPainterPath &path)

Añade path a la ruta actual.

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 es matriz de identidad), esta operación es muy rápida, ya que reutiliza los datos de la ruta.

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 en start e incluyendo count cantidad de comandos. Opcionalmente utiliza transform para alterar los puntos de la ruta. Se comprueba el rango de start y count, para que no se acceda a más comandos que QCanvasPath::commandsSize(). En caso de que la ruta no deba continuar desde la posición actual de la ruta, llame primero a moveTo() por ejemplo con path.positionAt(start - 1).

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

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

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

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

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

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

void QCanvasPainter::arcTo(QPointF controlPoint1, QPointF controlPoint2, float radius)

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

void QCanvasPainter::beginHoleSubPath()

Iniciar una subtrayectoria de agujeros. Esto es equivalente a setPathWinding(QCanvasPainter::PathWinding::ClockWise))

Véase también beginSolidSubPath().

void QCanvasPainter::beginPath()

Comienza a dibujar un nuevo trazado mientras borra el trazado actual.

void QCanvasPainter::beginSolidSubPath()

Iniciar un subcamino sólido. Equivale a setPathWinding(QCanvasPainter::PathWinding::CounterClockWise))

Véase también beginHoleSubPath().

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

Añade un segmento bezier cúbico desde el último punto de la trayectoria a través de dos puntos de control (cp1X, cp1Y y cp2X, cp2Y) hasta el punto especificado (x, y).

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

Añade un segmento bezier cúbico desde el último punto de la trayectoria a través de dos puntos de control (controlPoint1 y controlPoint2) hasta el punto especificado endPoint.

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

Crea una nueva sub-ruta en forma de círculo en ( centerX, centerY) con radius.

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

Crea una nueva sub-ruta en forma de círculo en centerPoint con radius.

void QCanvasPainter::cleanupResources()

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

Además, otras cachés y pools pueden ser reducidos al llamar a esta función, con el fin de minimizar el uso de memoria. Esto puede llevar a llamadas de dibujo más caras.

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

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

void QCanvasPainter::clearRect(const QRectF &rect)

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

void QCanvasPainter::closePath()

Cierra la sub-ruta actual con un segmento de línea. Esto equivale a lineTo([punto de partida]) como último elemento de la ruta.

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

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

El tamaño del lienzo se especifica en píxeles. Las propiedades pixelSize, sampleCount, y flags son inmutables después. Para obtener un lienzo con un tamaño, recuento de muestras o banderas diferentes, crea uno nuevo.

Para apuntar a un lienzo fuera de la pantalla con comandos de dibujo, llame a la sobrecarga apropiada QCanvasRhiPaintDriver::beginPaint() cuando trabaje con la API de nivel inferior, o QCanvasPainterWidget::beginCanvasPainting() o QCanvasPainterItemRenderer::beginCanvasPainting() cuando utilice las clases widget de conveniencia o elemento Qt Quick.

Normalmente, el contenido del lienzo se borra cuando se pinta en él. Para desactivar esto, pase PreserveContents en flags.

Para solicitar un renderizado multimuestra sobre el lienzo (antialiasing multimuestra, MSAA), establece un número de muestras mayor que 1, como 4 u 8. Sin embargo, no es posible conservar el contenido del lienzo entre pasadas de renderizado cuando está activado el multimuestreo, y la bandera PreserveContents no funcionará en este caso.

void QCanvasPainter::destroyCanvas(QCanvasOffscreenCanvas &canvas)

Destruye los recursos que respaldan canvas. canvas se convierte entonces en null canvas.

El pintor lo hace automáticamente al destruirlo. Por lo tanto, llamar a esta función sólo es necesario cuando se desea liberar los recursos asociados de inmediato.

float QCanvasPainter::devicePixelRatio() const

Devuelve la proporción entre píxeles físicos y píxeles independientes del dispositivo. El valor por defecto es 1.0.

void QCanvasPainter::drawBoxShadow(const QCanvasBoxShadow &shadow)

Dibuja una caja shadow. La sombra se pintará con la posición, tamaño, color, desenfoque, etc. establecidos en shadow. No es necesario llamar a beginPath() antes de este método.

Véase también QCanvasBoxShadow.

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

Dibuja image en x, y, a su tamaño por defecto.

Véase también addImage().

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

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

Véase también addImage().

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

Dibuja image en la posición y tamaño de destinationRect, desde el área sourceRect de la imagen.

Véase también addImage().

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

Dibuja image en x, y, en width y height dados.

Véase también addImage().

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

Crea una nueva sub-ruta en forma de elipse en ( centerX, centerY) con radiusX y radiusY.

void QCanvasPainter::ellipse(const QRectF &rect)

Crea una nueva sub-ruta en forma de elipse en rect. Esta elipse cubrirá el área de rect.

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

Crea un nuevo subcamino en forma de elipse en centerPoint con radiusX y radiusY.

void QCanvasPainter::fill()

Rellena la ruta actual con el estilo de relleno actual.

Véase también setFillStyle().

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

Rellena path con el estilo de relleno actual y pertenece a pathGroup. Pintar a través de QCanvasPath es óptimo cuando la ruta contiene más comandos es mayoritariamente estática. Por defecto, pathGroup es 0, por lo que utiliza el primer grupo. Cuando pathGroup es -1, la ruta no será cacheada en la GPU. 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.

Véase también setFillStyle().

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

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

void QCanvasPainter::fillRect(const QRectF &rect)

Dibuja un rectángulo relleno en rect. Este es un método sobrecargado que utiliza QRectF.

void QCanvasPainter::fillText(const QString &text, float x, float y, float maxWidth = -1)

Dibuja la cadena text en la ubicación especificada ( x, y), con textAlign y textBaseline actuales. Para que el texto se envuelva en varias líneas, establezca el parámetro opcional maxWidth al ancho de fila preferido en píxeles. Los espacios en blanco se eliminan al principio de las filas, el texto se divide en los límites de palabra o cuando se encuentran caracteres de nueva línea. Las palabras más largas que la anchura máxima se dividen por el carácter más cercano (es decir, sin separación por sílabas).

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

Dibuja la cadena text dentro de rect, con textAlign y textBaseline actuales. La anchura del parámetro rect se utiliza como maxWidth.

Este es un método sobrecargado que utiliza QRectF. A menudo es útil establecer la línea de base del texto en TextBaseline::Top o TextBaseline::Middle cuando se pinta texto con este método.

void QCanvasPainter::fillText(const QString &text, QPointF point, float maxWidth = -1)

Dibuja la cadena text en la dirección point especificada, con las opciones actuales textAlign y textBaseline. Para que el texto se envuelva en varias líneas, establezca el parámetro opcional maxWidth con el ancho de fila preferido en píxeles. Los espacios en blanco se eliminan al principio de las filas, el texto se divide en los límites de palabra o cuando se encuentran caracteres de nueva línea. Las palabras más largas que la anchura máxima se dividen por el carácter más cercano (es decir, sin separación por sílabas).

Se trata de un método sobrecargado que utiliza QPointF.

QTransform QCanvasPainter::getTransform() const

Devuelve la transformación actual.

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

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

void QCanvasPainter::lineTo(QPointF point)

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

[static] float QCanvasPainter::mmToPx(float mm)

Método auxiliar estático para convertir milímetros mm en píxeles. Esto permite hacer dibujos independientes de la resolución. Por ejemplo para establecer el ancho de linea a 2mm usa:

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

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

Inicia una nueva sub-ruta con ( x, y) como primer punto.

void QCanvasPainter::moveTo(QPointF point)

Inicia una nueva sub-ruta con point como primer punto.

[static] float QCanvasPainter::ptToPx(float pt)

Método de ayuda estático para convertir puntos pt en píxeles.

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

Añade un segmento bezier cuadrático desde el último punto de la trayectoria a través de un punto de control (cpX, cpY) hasta el punto especificado (x, y).

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

Añade un segmento de curva cuadrática desde el último punto de la trayectoria a través de controlPoint hasta el punto especificado endPoint.

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

Crea una nueva sub-ruta en forma de rectángulo en la posición x, y con el tamaño width, height.

void QCanvasPainter::rect(const QRectF &rect)

Crea una nueva sub-ruta en forma de rectángulo en rect. Este es un método sobrecargado que utiliza QRectF.

void QCanvasPainter::removeImage(const QCanvasImage &image)

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

Véase también addImage().

void QCanvasPainter::removePathGroup(int pathGroup)

Elimina pathGroup de la caché del pintor. Si se llama a fill() o stroke() para pathGroup después de esto, se regenerará la ruta en la caché del grupo.

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

QCanvasPainter::RenderHints QCanvasPainter::renderHints() const

Devuelve una bandera que especifica los consejos de renderizado que se han establecido para este pintor.

Véase también setRenderHints() y setRenderHint().

void QCanvasPainter::reset()

Restablece el estado actual del pintor a los valores por defecto.

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 transformación actual a una matriz de identidad.

void QCanvasPainter::restore()

Revienta y restaura el estado de renderizado actual. Así que el estado previamente guardado será restaurado. Si no se ha llamado a save() y la pila de estado está vacía, la llamada no hace nada.

Véase también save().

void QCanvasPainter::rotate(float angle)

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

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

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

Crea una nueva sub-ruta en forma de rectángulo redondeado en la posición x, y con el tamaño width, height. El redondeo de las esquinas será radius.

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

Crea una nueva subtrayectoria en forma de rectángulo redondeado en rect con las esquinas de radius. Este es un método sobrecargado que utiliza QRectF.

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

Crea una nueva sub-ruta en forma de rectángulo redondeado en rect. El redondeo de las esquinas puede variar por esquina, con radiusTopLeft, radiusTopRight, radiusBottomRight, radiusBottomLeft.

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

Crea una nueva sub-ruta en forma de rectángulo redondeado en la posición x, y con el tamaño width, height. El redondeo de las esquinas puede variar por esquina, con radiusTopLeft, radiusTopRight, radiusBottomRight, radiusBottomLeft.

void QCanvasPainter::save()

Empuja y guarda el estado de renderizado actual en una pila de estados. Para restaurar el estado se debe utilizar un restore() coincidente.

Véase también restore().

void QCanvasPainter::scale(float scale)

Escala el sistema de coordenadas actual en scale. Las coordenadas x e y se escalan uniformemente.

void QCanvasPainter::scale(float scaleX, float scaleY)

Escala el sistema de coordenadas actual en scaleX y scaleY.

void QCanvasPainter::setAntialias(float antialias)

Establece la cantidad de antialiasing actual en antialias en píxeles. Más antialias significa una pintura más suave. Esto sólo afecta a la pintura de relleno y trazo, no a imágenes o textos. El valor por defecto es 1.0 y el valor máximo es 10.0.

El antialiasing puede modificarse por ruta, de modo que puede establecerse antes de cada trazo/relleno. Para desactivar el antialiasing de todo el lienzo pintado, utilice QCanvasPainter::RenderHint::Antialiasing render hint.

Ver también setRenderHints() y setTextAntialias().

void QCanvasPainter::setBrushTransform(const QTransform &transform)

Establece la transformación actual del pincel en transform. Esta transformación se aplica tanto a los pinceles de trazo como a los de relleno.

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

Establece el rectángulo de tijera actual en (x, y, width, height). El rectángulo de tijera es transformado por la transformación actual.

Véase también resetClipping().

void QCanvasPainter::setClipRect(const QRectF &rect)

Establece el rectángulo de tijera actual en rect. El rectángulo de tijera es transformado por la transformación actual.

Véase también resetClipping().

void QCanvasPainter::setFillStyle(const QColor &color)

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

void QCanvasPainter::setFillStyle(const QCanvasBrush &brush)

Establece el estilo de relleno en brush. El estilo de relleno por defecto es el color negro sólido (0, 0, 0, 1).

void QCanvasPainter::setFont(const QFont &font)

Establece font como fuente activa.

void QCanvasPainter::setGlobalAlpha(float alpha)

Establece el valor alfa global (transparencia) en alpha. Este valor alfa se aplica a todas las formas renderizadas. Los trazados ya transparentes serán proporcionalmente más transparentes. Alfa debe estar entre 0.0 (totalmente transparente) y 1.0 (totalmente opaco). Por defecto alfa es 1.0.

void QCanvasPainter::setGlobalBrightness(float value)

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

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

Establece el modo de operación compuesto global en operation. Este modo se aplica a todas las operaciones de pintura. El modo por defecto es QCanvasPainter::CompositeOperation::SourceOver.

void QCanvasPainter::setGlobalContrast(float value)

Establece el contraste global en value. Este contraste se aplica a todas las formas renderizadas. Un valor de 0 hará que la pintura sea completamente gris (0.5, 0.5, 0.5). El valor también puede ser mayor que 1.0, para aumentar el contraste. Por defecto, el contraste es 1.0.

void QCanvasPainter::setGlobalSaturate(float 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 la pintura sea completamente en escala de grises. El valor también puede ser mayor que 1.0, para aumentar la saturación. Por defecto, la saturación es 1.0.

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

Fija el final de la línea de stoke en cap. El tope de línea por defecto es QCanvasPainter::LineCap::Butt.

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

Establece la línea de unión del trazo en join. La línea de unión por defecto es QCanvasPainter::LineJoin::Miter.

Véase también setMiterLimit().

void QCanvasPainter::setLineWidth(float width)

Establece el ancho de línea del trazo en width en píxeles. El ancho de línea por defecto es 1.0. Cuando el antialiasing está activado, los anchos de línea por debajo de un solo píxel desvanecen automáticamente la opacidad, creando una salida suave.

Véase también stroke().

void QCanvasPainter::setMiterLimit(float 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 sea mayor que este límite, en su lugar se aplicará QCanvasPainter::LineJoin::Bevel entre las líneas. Esto sólo tiene efecto con la unión de líneas QCanvasPainter::LineJoin::Miter. El límite por defecto es 10.0.

Véase también setLineJoin().

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

Establece la subtrayectoria actual winding en CounterClockWise (por defecto) o ClockWise. CounterClockWise dibuja subtrayectorias sólidas mientras que ClockWise dibuja agujeros.

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

void QCanvasPainter::setRenderHint(QCanvasPainter::RenderHint hint, bool on = true)

Establece la representación hint en el pintor si on es verdadero; en caso contrario, borra la sugerencia de representación.

Véase también setRenderHints() y renderHints().

void QCanvasPainter::setRenderHints(QCanvasPainter::RenderHints hints, bool on = true)

Establece la representación hints en el pintor si on es verdadero; en caso contrario, borra las sugerencias de representación.

Véase también setRenderHint() y renderHints().

void QCanvasPainter::setStrokeStyle(const QColor &color)

Establece el estilo de trazo en un sólido color. El estilo de trazo por defecto es de color negro sólido (0, 0, 0, 1).

void QCanvasPainter::setStrokeStyle(const QCanvasBrush &brush)

Establece el estilo de trazo en brush. El estilo de trazo por defecto es el color negro sólido (0, 0, 0, 1).

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

Establece la alineación horizontal del texto en align. La alineación por defecto es QCanvasPainter::TextAlign::Start.

Véase también setTextBaseline().

void QCanvasPainter::setTextAntialias(float antialias)

Establece la cantidad actual de antialiasing del texto. El valor antialias es el multiplicador del antialiasing normal, lo que significa que 0.0 desactiva el antialiasing y 2.0 lo duplica. El valor por defecto es 1.0.

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

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

Véase también setTextAlign().

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

Establece la dirección del texto en direction. La dirección por defecto es QCanvasPainter::TextDirection::Inherit.

void QCanvasPainter::setTextLineHeight(float height)

Establece el ajuste de la altura de línea en píxeles en height para el texto envuelto. La altura de línea por defecto es 0.

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

Establece el modo de ajuste del texto en wrapMode. El modo de ajuste por defecto es QCanvasPainter::WrapMode::NoWrap.

void QCanvasPainter::setTransform(const QTransform &transform)

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

Véase también transform().

void QCanvasPainter::skew(float angleX, float angleY = 0.0f)

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

void QCanvasPainter::stroke()

Traza la ruta actual con el estilo de trazo actual.

Véase también setStrokeStyle().

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

Pinta el path con el estilo de trazo actual y perteneciente a pathGroup. Pintar a través de QCanvasPath es óptimo cuando la ruta contiene más comandos es mayoritariamente estática. Por defecto, pathGroup es 0, por lo que utiliza el primer grupo. Cuando pathGroup es -1, la ruta no será cacheada en la GPU. 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.

Véase también setStrokeStyle().

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

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

void QCanvasPainter::strokeRect(const QRectF &rect)

Dibuja un rectángulo stoked en rect. Este es un método sobrecargado que utiliza QRectF.

QRectF QCanvasPainter::textBoundingBox(const QString &text, float x, float y, float maxWidth = -1)

Mide el cuadro delimitador de una cadena text en (x, y). Para medir texto de varias líneas, establezca el parámetro opcional maxWidth en el ancho de fila preferido en píxeles. Devuelve QRectF con los valores [xmin, ymin, width, height]. Los valores medidos se devuelven en el espacio de coordenadas local.

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

Mide el cuadro delimitador de una cadena text en rect. Devuelve QRectF con valores [xmin, ymin, width, height]. Los valores medidos se devuelven en el espacio de coordenadas local.

QRectF QCanvasPainter::textBoundingBox(const QString &text, QPointF point, float maxWidth = -1)

Mide el cuadro delimitador de una cadena text en point. Para medir texto de varias líneas, establezca el parámetro opcional maxWidth en el ancho de fila preferido en píxeles. Devuelve QRectF con los valores [xmin, ymin, width, height]. Los valores medidos se devuelven en el espacio de coordenadas local.

void QCanvasPainter::transform(const QTransform &transform)

Multiplica el sistema de coordenadas actual por transform.

Véase también setTransform().

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

Traslada el sistema de coordenadas actual en x y y.

void QCanvasPainter::translate(QPointF point)

Traduce el sistema de coordenadas actual en point.