En esta página

QPainter Class

La clase QPainter se encarga del dibujo de bajo nivel en los widgets y otros dispositivos de dibujo. Más información...

Encabezado: #include <QPainter>
CMake: find_package(Qt6 REQUIRED COMPONENTS Gui)
target_link_libraries(mytarget PRIVATE Qt6::Gui)
qmake: QT += gui
Heredado por:

QStylePainter

Nota: Todas las funciones de esta clase son reentrantes.

Tipos públicos

class PixmapFragment
enum CompositionMode { CompositionMode_SourceOver, CompositionMode_DestinationOver, CompositionMode_Clear, CompositionMode_Source, CompositionMode_Destination, …, RasterOp_SourceOrNotDestination }
enum PixmapFragmentHint { OpaqueHint }
flags PixmapFragmentHints
enum RenderHint { Antialiasing, TextAntialiasing, SmoothPixmapTransform, VerticalSubpixelPositioning, LosslessImageRendering, NonCosmeticBrushPatterns }
flags RenderHints

Funciones públicas

QPainter()
QPainter(QPaintDevice*dispositivo)
~QPainter()
const QBrush &background() const
Qt::BGMode backgroundMode() const
bool begin(QPaintDevice*device)
void beginNativePainting()
QRectF boundingRect(const QRectF&rectángulo, int indicadores, const QString&texto)
QRect boundingRect(const QRect&rectángulo, int indicadores, const QString&texto)
QRectF boundingRect(const QRectF&rectángulo, const QString&texto, const QTextOption&opción = QTextOption())
QRect boundingRect(int x, int y, int w, int h, int flags, const QString&text)
const QBrush &brush() const
QPoint brushOrigin() const
(since 6.11) QPointF brushOriginF() const
QRectF clipBoundingRect() const
QPainterPath clipPath() const
QRegion clipRegion() const
QTransform combinedTransform() const
QPainter::CompositionMode compositionMode() const
QPaintDevice *device() const
const QTransform &deviceTransform() const
void drawArc(const QRectF&rectángulo, int ánguloInicial, int ánguloTotal)
void drawArc(const QRect&rectángulo, int ánguloInicial, int ánguloTotal)
void drawArc(int x, int y, int width, int height, int startAngle, int spanAngle)
void drawChord(const QRectF&rectángulo, int ánguloInicial, int ánguloTotal)
void drawChord(const QRect&rectángulo, int ánguloInicial, int ánguloFinal)
void drawChord(int x, int y, int width, int height, int startAngle, int spanAngle)
void drawConvexPolygon(const QPointF*puntos, int númeroDePuntos)
void drawConvexPolygon(const QPolygon&polígono)
void drawConvexPolygon(const QPolygonF&polígono)
void drawConvexPolygon(const QPoint*puntos, int númeroDePuntos)
void drawEllipse(const QRectF&rectángulo)
void drawEllipse(const QRect&rectángulo)
void drawEllipse(const QPoint&center, int rx, int ry)
void drawEllipse(const QPointF&center, qreal rx, qreal ry)
void drawEllipse(int x, int y, int width, int height)
void drawGlyphRun(const QPointF&position, const QGlyphRun&glyphs)
void drawImage(const QRectF&destino, const QImage&imagen, const QRectF&origen, Qt::ImageConversionFlags flags = Qt::AutoColor)
void drawImage(const QPoint&punto, const QImage&imagen)
void drawImage(const QPointF&punto, const QImage&imagen)
void drawImage(const QRect&rectángulo, const QImage&imagen)
void drawImage(const QRectF&rectángulo, const QImage&imagen)
void drawImage(const QPoint&punto, const QImage&imagen, const QRect&origen, Qt::ImageConversionFlags indicadores = Qt::AutoColor)
void drawImage(const QPointF&punto, const QImage&imagen, const QRectF&fuente, Qt::ImageConversionFlags indicadores = Qt::AutoColor)
void drawImage(const QRect&destino, const QImage&imagen, const QRect&origen, Qt::ImageConversionFlags indicadores = Qt::AutoColor)
void drawImage(int x, int y, const QImage&image, int sx = 0, int sy = 0, int sw = -1, int sh = -1, Qt::ImageConversionFlags flags = Qt::AutoColor)
void drawLine(const QLineF&line)
void drawLine(const QLine&line)
void drawLine(const QPoint&p1, const QPoint&p2)
void drawLine(const QPointF&p1, const QPointF&p2)
void drawLine(int x1, int y1, int x2, int y2)
void drawLines(const QLineF*líneas, int númeroDeLíneas)
void drawLines(const QList<QLine>&líneas)
void drawLines(const QList<QLineF>&líneas)
void drawLines(const QList<QPoint>&pointPairs)
void drawLines(const QList<QPointF>&pointPairs)
void drawLines(const QLine*líneas, int númeroDeLíneas)
void drawLines(const QPoint*pointPairs, int lineCount)
void drawLines(const QPointF*pointPairs, int lineCount)
void drawPath(const QPainterPath&path)
void drawPicture(const QPointF&punto, const QPicture&imagen)
void drawPicture(const QPoint&punto, const QPicture&imagen)
void drawPicture(int x, int y, const QPicture&picture)
void drawPie(const QRectF&rectángulo, int ánguloInicial, int ánguloTotal)
void drawPie(const QRect&rectángulo, int ánguloInicial, int ánguloTotal)
void drawPie(int x, int y, int width, int height, int startAngle, int spanAngle)
void drawPixmap(const QRectF&destino, const QPixmap&mapa de píxeles, const QRectF&origen)
void drawPixmap(const QPoint&punto, const QPixmap&pixmap)
void drawPixmap(const QPointF&punto, const QPixmap&mapa de píxeles)
void drawPixmap(const QRect&rectángulo, const QPixmap&mapa de píxeles)
void drawPixmap(const QPoint&punto, const QPixmap&mapa de píxeles, const QRect&fuente)
void drawPixmap(const QPointF&punto, const QPixmap&pixmap, const QRectF&fuente)
void drawPixmap(const QRect&destino, const QPixmap&mapa de píxeles, const QRect&origen)
void drawPixmap(int x, int y, const QPixmap&pixmap)
void drawPixmap(int x, int y, int width, int height, const QPixmap&pixmap)
void drawPixmap(int x, int y, const QPixmap&pixmap, int sx, int sy, int sw, int sh)
void drawPixmap(int x, int y, int w, int h, const QPixmap&pixmap, int sx, int sy, int sw, int sh)
void drawPixmapFragments(const QPainter::PixmapFragment*fragments, int fragmentCount, const QPixmap&pixmap, QPainter::PixmapFragmentHints hints = PixmapFragmentHints())
void drawPoint(const QPointF&position)
void drawPoint(const QPoint&position)
void drawPoint(int x, int y)
void drawPoints(const QPointF*puntos, int númeroDePuntos)
void drawPoints(const QPolygon&puntos)
void drawPoints(const QPolygonF&puntos)
void drawPoints(const QPoint*puntos, int númeroDePuntos)
void drawPolygon(const QPointF*puntos, int recuentoDePuntos, Qt::FillRule reglaDeRelleno = Qt::OddEvenFill)
void drawPolygon(const QPolygon&points, Qt::FillRule fillRule = Qt::OddEvenFill)
void drawPolygon(const QPolygonF&puntos, Qt::FillRule reglaDeRelleno = Qt::OddEvenFill)
void drawPolygon(const QPoint*puntos, int númeroDePuntos, Qt::FillRule reglaDeRelleno = Qt::OddEvenFill)
void drawPolyline(const QPointF*puntos, int númeroDePuntos)
void drawPolyline(const QPolygon&puntos)
void drawPolyline(const QPolygonF&puntos)
void drawPolyline(const QPoint*puntos, int recuentoDePuntos)
void drawRect(const QRectF&rectángulo)
void drawRect(const QRect&rectángulo)
void drawRect(int x, int y, int ancho, int alto)
void drawRects(const QRectF*rectángulos, int recuento)
void drawRects(const QList<QRect>&rectangles)
void drawRects(const QList<QRectF>&rectangles)
void drawRects(const QRect*rectángulos, int recuento)
void drawRoundedRect(const QRectF&rect, qreal xRadius, qreal yRadius, Qt::SizeMode mode = Qt::AbsoluteSize)
void drawRoundedRect(const QRect&rect, qreal xRadius, qreal yRadius, Qt::SizeMode mode = Qt::AbsoluteSize)
void drawRoundedRect(int x, int y, int w, int h, qreal xRadius, qreal yRadius, Qt::SizeMode mode = Qt::AbsoluteSize)
void drawStaticText(const QPointF&topLeftPosition, const QStaticText&staticText)
void drawStaticText(const QPoint&topLeftPosition, const QStaticText&staticText)
void drawStaticText(int left, int top, const QStaticText&staticText)
void drawText(const QPointF&position, const QString&text)
void drawText(const QPoint&position, const QString&text)
void drawText(const QRectF&rectángulo, const QString&texto, const QTextOption&opción = QTextOption())
void drawText(int x, int y, const QString&text)
void drawText(const QRect&rectángulo, int indicadores, const QString&texto, QRect*rectánguloLimite = nullptr)
void drawText(const QRectF&rectángulo, int indicadores, const QString&texto, QRectF*rectánguloLimite = nullptr)
void drawText(int x, int y, int width, int height, int flags, const QString&text, QRect*boundingRect = nullptr)
void drawTiledPixmap(const QRectF&rectangle, const QPixmap&pixmap, const QPointF&position = QPointF())
void drawTiledPixmap(const QRect&rectangle, const QPixmap&pixmap, const QPoint&position = QPoint())
void drawTiledPixmap(int x, int y, int width, int height, const QPixmap&pixmap, int sx = 0, int sy = 0)
bool end()
void endNativePainting()
void eraseRect(const QRectF&rectángulo)
void eraseRect(const QRect&rectángulo)
void eraseRect(int x, int y, int ancho, int alto)
void fillPath(const QPainterPath&path, const QBrush&brush)
void fillRect(const QRectF&rectángulo, const QBrush&pincel)
void fillRect(const QRect&rectángulo, QGradient::Preset preset)
void fillRect(const QRect&rectángulo, Qt::BrushStyle estilo)
void fillRect(const QRect&rectángulo, Qt::GlobalColor color)
void fillRect(const QRect&rectángulo, const QBrush&pincel)
void fillRect(const QRect&rectángulo, const QColor&color)
void fillRect(const QRectF&rectángulo, QGradient::Preset preset)
void fillRect(const QRectF&rectángulo, Qt::BrushStyle estilo)
void fillRect(const QRectF&rectangle, Qt::GlobalColor color)
void fillRect(const QRectF&rectángulo, const QColor&color)
void fillRect(int x, int y, int width, int height, QGradient::Preset preset)
void fillRect(int x, int y, int ancho, int alto, Qt::BrushStyle estilo)
void fillRect(int x, int y, int ancho, int alto, Qt::GlobalColor color)
void fillRect(int x, int y, int ancho, int alto, const QBrush&pincel)
void fillRect(int x, int y, int ancho, int alto, const QColor&color)
const QFont &font() const
QFontInfo fontInfo() const
QFontMetrics fontMetrics() const
bool hasClipping() const
bool isActive() const
Qt::LayoutDirection layoutDirection() const
qreal opacity() const
QPaintEngine *paintEngine() const
const QPen &pen() const
QPainter::RenderHints renderHints() const
void resetTransform()
void restore()
void rotate(qreal ángulo)
void save()
void scale(qreal sx, qreal sy)
void setBackground(const QBrush&brush)
void setBackgroundMode(Qt::BGMode modo)
void setBrush(const QBrush&pincel)
(since 6.11) void setBrush(QBrush&&pincel)
(since 6.9) void setBrush(QColor color)
void setBrush(Qt::BrushStyle estilo)
(since 6.9) void setBrush(Qt::GlobalColor color)
void setBrushOrigin(const QPointF&position)
void setBrushOrigin(const QPoint&posición)
void setBrushOrigin(int x, int y)
void setClipPath(const QPainterPath&path, Qt::ClipOperation operación = Qt::ReplaceClip)
void setClipRect(const QRectF&rectángulo, Qt::ClipOperation operación = Qt::ReplaceClip)
void setClipRect(int x, int y, int width, int height, Qt::ClipOperation operation = Qt::ReplaceClip)
void setClipRect(const QRect&rectángulo, Qt::ClipOperation operación = Qt::ReplaceClip)
void setClipRegion(const QRegion&región, Qt::ClipOperation operación = Qt::ReplaceClip)
void setClipping(bool enable)
void setCompositionMode(QPainter::CompositionMode modo)
void setFont(const QFont&font)
void setLayoutDirection(Qt::LayoutDirection dirección)
void setOpacity(qreal opacidad)
void setPen(const QPen&pen)
(since 6.11) void setPen(QPen&&pen)
void setPen(Qt::PenStyle estilo)
void setPen(const QColor&color)
void setRenderHint(QPainter::RenderHint hint, bool on = true)
void setRenderHints(QPainter::RenderHints hints, bool on = true)
void setTransform(const QTransform&transform, bool combine = false)
void setViewTransformEnabled(bool enable)
void setViewport(const QRect&rectángulo)
void setViewport(int x, int y, int ancho, int alto)
void setWindow(const QRect&rectángulo)
void setWindow(int x, int y, int ancho, int alto)
void setWorldMatrixEnabled(bool enable)
void setWorldTransform(const QTransform&matrix, bool combine = false)
void shear(qreal sh, qreal sv)
void strokePath(const QPainterPath&path, const QPen&pen)
bool testRenderHint(QPainter::RenderHint hint) const
const QTransform &transform() const
void translate(const QPointF&offset)
void translate(const QPoint&offset)
void translate(qreal dx, qreal dy)
bool viewTransformEnabled() const
QRect viewport() const
QRect window() const
bool worldMatrixEnabled() const
const QTransform &worldTransform() const

Descripción detallada

QPainter proporciona funciones altamente optimizadas para realizar la mayor parte de las tareas de dibujo que requieren los programas de interfaz gráfica de usuario. Puede dibujar desde líneas simples hasta formas complejas, como sectores circulares y cuerdas. También puede dibujar texto alineado e imágenes de mapa de píxeles. Normalmente, dibuja en un sistema de coordenadas «natural», pero también puede realizar transformaciones de vista y del mundo. QPainter puede actuar sobre cualquier objeto que herede de la clase QPaintDevice.

El uso habitual de QPainter es dentro del evento de pintura de un widget: crea y personaliza (por ejemplo, configura el lápiz o el pincel) el pintor. A continuación, dibuja. Recuerda destruir el objeto QPainter tras terminar de dibujar. Por ejemplo:

void SimpleExampleWidget::paintEvent(QPaintEvent *)
{
    QPainter painter(this);
    painter.setPen(Qt::blue);
    painter.setFont(QFont("Arial", 30));
    painter.drawText(rect(), Qt::AlignCenter, "Qt");
}

La funcionalidad principal de QPainter es el dibujo, pero la clase también proporciona varias funciones que permiten personalizar la configuración de QPainter y su calidad de renderizado, así como otras que habilitan el recorte. Además, se puede controlar cómo se fusionan las diferentes formas especificando el modo de composición del pintor.

La función ` isActive()` indica si el pintor está activo. Un pintor se activa mediante la función ` begin()` y el constructor que toma un argumento ` QPaintDevice `. La función ` end()` y el destructor lo desactivan.

Junto con las clases QPaintDevice y QPaintEngine, QPainter constituye la base del sistema de dibujo de Qt. QPainter es la clase que se utiliza para realizar operaciones de dibujo. QPaintDevice representa un dispositivo sobre el que se puede dibujar utilizando un QPainter. QPaintEngine proporciona la interfaz que utiliza el «painter» para dibujar en diferentes tipos de dispositivos. Si el pintor está activo, device() devuelve el dispositivo de pintura sobre el que dibuja el pintor, y paintEngine() devuelve el motor de pintura en el que el pintor está trabajando actualmente. Para obtener más información, consulta el sistema de pintura.

A veces resulta conveniente que otro elemento dibuje sobre un « QPaintDevice » inusual. QPainter admite una función estática para ello: setRedirected().

Advertencia: Cuando el dispositivo de dibujo es un widget, QPainter solo se puede utilizar dentro de una función `paintEvent()` o en una función llamada por `paintEvent()`.

Configuración

Hay varios ajustes que puedes personalizar para que QPainter dibuje según tus preferencias:

Tenga en cuenta que algunos de estos ajustes reflejan los ajustes de ciertos dispositivos de pintura, p. ej., QWidget::font(). La función QPainter::begin() (o, de forma equivalente, el constructor de QPainter) copia estos atributos del dispositivo de pintura.

Se puede guardar en cualquier momento el estado de QPainter llamando a la función save(), que guarda todos los ajustes disponibles en una pila interna. La función restore() los recupera de la pila.

Dibujo

QPainter proporciona funciones para dibujar la mayoría de las figuras primitivas: ` drawPoint()`, ` drawPoints()`, ` drawLine()`, ` drawRect()`, ` drawRoundedRect()`, ` drawEllipse()`, ` drawArc()`, ` drawPie()`, ` drawChord()`, ` drawPolyline()`, ` drawPolygon()`, ` drawConvexPolygon()` y `drawCubicBezier()`. Las dos funciones de conveniencia, drawRects() y drawLines(), dibujan el número dado de rectángulos o líneas de la matriz dada de QRects o QLines utilizando el lápiz y el pincel actuales.

La clase `QPainter` también proporciona la función ` fillRect()`, que rellena el ` QRect` especificado con el ` QBrush` especificado, y la función ` eraseRect()`, que borra el área dentro del rectángulo especificado.

Todas estas funciones tienen versiones tanto para números enteros como para números de coma flotante.

Aplicación de dibujo básico con opciones de formas y plumasEjemplo de dibujo básico

El ejemplo «Dibujo básico» muestra cómo representar primitivas gráficas básicas en diversos estilos utilizando la clase `QPainter`.

Si necesitas dibujar una forma compleja, especialmente si tienes que hacerlo de forma repetida, plantéate crear un ` QPainterPath ` y dibujarlo utilizando ` drawPath()`.

Ejemplo de «Painter Paths»

La clase « QPainterPath » proporciona un contenedor para operaciones de dibujo, lo que permite construir y reutilizar formas gráficas.

El ejemplo «Painter Paths » muestra cómo se pueden utilizar las rutas de pintura para crear formas complejas para su representación.

Aplicación «Painter Paths» con diversas formas

QPainter también proporciona la función ` fillPath()` que rellena la ` QPainterPath ` dada con el ` QBrush` indicado, y la función ` strokePath()` que dibuja el contorno de la ruta dada (es decir, traza la ruta).

Véase también el ejemplo «Deformación vectorial», que muestra cómo utilizar técnicas vectoriales avanzadas para dibujar texto utilizando un « QPainterPath »; el ejemplo «Degradados», que muestra los diferentes tipos de degradados disponibles en Qt; y el ejemplo «Trazado de rutas», que muestra los patrones de trazo integrados en Qt y explica cómo se pueden utilizar patrones personalizados para ampliar la gama de patrones disponibles.

El dibujo de texto se realiza mediante ` drawText()`. Cuando se necesita un posicionamiento preciso, ` boundingRect()` indica dónde se dibujará un comando ` drawText()` determinado.

Dibujo de mapas de píxeles e imágenes

Existen funciones para dibujar mapas de píxeles e imágenes, concretamente drawPixmap(), drawImage() y drawTiledPixmap(). Tanto drawPixmap() como drawImage() producen el mismo resultado, salvo que drawPixmap() es más rápido en pantalla, mientras que drawImage() puede ser más rápido en un QPrinter u otros dispositivos.

Existe una función drawPicture() que dibuja el contenido completo de un QPicture. La función drawPicture() es la única que ignora todos los ajustes del pintor, ya que QPicture tiene sus propios ajustes.

Dibujar versiones de alta resolución de mapas de píxeles e imágenes

Las versiones de alta resolución de los pixmaps tienen un valor de relación de píxeles del dispositivo superior a 1 (véase QImageReader, QPixmap::devicePixelRatio()). Si coincide con el valor del QPaintDevice subyacente, se dibuja directamente en el dispositivo sin aplicar ninguna transformación adicional.

Este es, por ejemplo, el caso al dibujar un QPixmap de 64x64 píxeles con una relación de píxeles del dispositivo de 2 en una pantalla de alto DPI que también tiene una relación de píxeles del dispositivo de 2. Tenga en cuenta que, en ese caso, el mapa de píxeles tiene efectivamente un tamaño de 32x32 píxeles en el espacio de usuario. Las rutas de código en Qt que calculan la geometría de diseño basándose en el tamaño del mapa de píxeles utilizarán este tamaño. El efecto neto de esto es que el mapa de píxeles se muestra como un mapa de píxeles de alto DPI en lugar de como un mapa de píxeles de gran tamaño.

Calidad de renderizado

Para obtener un resultado de renderizado óptimo con QPainter, debes utilizar el dispositivo de pintura independiente de la plataforma ` QImage `; es decir, el uso de ` QImage ` garantizará que el resultado tenga una representación de píxeles idéntica en cualquier plataforma.

La clase QPainter también ofrece un medio para controlar la calidad de renderizado a través de su enumeración ` RenderHint ` y la compatibilidad con la precisión de punto flotante: todas las funciones para dibujar primitivas tienen versiones de punto flotante.

painter.drawEllipse(QRectF(-diameter / 2.0, -diameter / 2.0, diameter, diameter));

A menudo se utilizan junto con la indicación de renderizado « QPainter::Antialiasing ».

QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing, true);
Comparación de círculos concéntricos con tipos «int» y «float», y con o sin renderizado suavizado. El uso de las versiones con precisión de coma flotante produce anillos espaciados uniformemente. El renderizado suavizado da como resultado círculos lisos.Círculos concéntricos en los que se comparan imágenes con aliasing y sin aliasing

La enumeración « RenderHint » especifica indicadores para QPainter que cualquier motor dado puede respetar o no. « QPainter::Antialiasing » indica que el motor debe aplicar suavizado a los bordes de las primitivas si es posible, « QPainter::TextAntialiasing » indica que el motor debe aplicar suavizado al texto si es posible, y « QPainter::SmoothPixmapTransform » indica que el motor debe utilizar un algoritmo de transformación de mapas de píxeles suave.

La función renderHints() devuelve un indicador que especifica las sugerencias de renderizado establecidas para este «pintor». Utilice la función setRenderHint() para establecer o borrar el valor RenderHints actualmente establecido.

Transformaciones de coordenadas

Normalmente, el QPainter opera en el propio sistema de coordenadas del dispositivo (normalmente píxeles), pero QPainter ofrece un buen soporte para las transformaciones de coordenadas.

Las transformaciones más habituales son el escalado, la rotación, la traslación y el cizallamiento. Utiliza la función scale() para escalar el sistema de coordenadas en una distancia determinada, la función rotate() para girarlo en el sentido de las agujas del reloj y translate() para trasladarlo (es decir, sumando una distancia determinada a los puntos). También puedes girar el sistema de coordenadas alrededor del origen utilizando la función shear(). Consulta el ejemplo «Transformaciones afines» para ver una visualización de un sistema de coordenadas con cizallamiento.

Consulte también el ejemplo «Transformaciones», que muestra cómo las transformaciones influyen en la forma en que QPainter representa las primitivas gráficas. En concreto, muestra cómo el orden de las transformaciones afecta al resultado.

Ejemplo de transformaciones afines

El ejemplo «Transformaciones afines» muestra la capacidad de Qt para realizar transformaciones afines en las operaciones de dibujo. La demostración también permite al usuario experimentar con las operaciones de transformación y ver los resultados de forma inmediata.

Ejemplo de transformaciones afines con un gráfico de un pingüino

Todas las operaciones de transformación se aplican a la matriz de transformación worldTransform(). Una matriz transforma un punto del plano en otro punto. Para obtener más información sobre la matriz de transformación, consulta la documentación sobre el sistema de coordenadas y QTransform.

La función ` setWorldTransform()` puede sustituir o añadir elementos a la ` worldTransform()` establecida actualmente. La función ` resetTransform()` restablece cualquier transformación realizada mediante las funciones ` translate()`, ` scale()`, ` shear()`, ` rotate()`, ` setWorldTransform()`, ` setViewport()` y ` setWindow()`. La función ` deviceTransform()` devuelve la matriz que transforma las coordenadas lógicas a las coordenadas del dispositivo de pintura dependiente de la plataforma. Esta última función solo es necesaria cuando se utilizan comandos de dibujo de la plataforma en el identificador dependiente de la plataforma, y la plataforma no realiza transformaciones de forma nativa.

Al dibujar con QPainter, especificamos los puntos utilizando coordenadas lógicas que luego se convierten en las coordenadas físicas del dispositivo de dibujo. La correspondencia entre las coordenadas lógicas y las físicas la gestiona la función ` combinedTransform()` de `QPainter`, que combina las funciones ` viewport()`, ` window()` y ` worldTransform()`. La función ` viewport()` representa las coordenadas físicas especificando un rectángulo arbitrario, la función ` window()` describe el mismo rectángulo en coordenadas lógicas, y la función ` worldTransform()` es idéntica a la matriz de transformación.

Véase también «Sistema de coordenadas»

Recorte

QPainter puede recortar cualquier operación de dibujo a un rectángulo, una región o una ruta vectorial. Se puede acceder al recorte actual mediante las funciones clipRegion() y clipPath(). La preferencia por las rutas o las regiones (más rápidas) depende del motor de pintura subyacente paintEngine(). Por ejemplo, el motor de pintura QImage prefiere las rutas, mientras que el motor de pintura X11 prefiere las regiones. La configuración del recorte se realiza en las coordenadas lógicas de QPainter.

Tras el recorte de QPainter, el dispositivo de pintura también puede realizar un recorte. Por ejemplo, la mayoría de los widgets recortan los píxeles utilizados por los widgets hijos, y la mayoría de las impresoras recortan un área cercana a los bordes del papel. Este recorte adicional no se refleja en el valor de retorno de clipRegion() o hasClipping().

Modos de composición

QPainter proporciona la enumeración ` CompositionMode `, que define las reglas de Porter-Duff para la composición de imágenes digitales; describe un modelo para combinar los píxeles de una imagen, la de origen, con los píxeles de otra imagen, la de destino.

Las dos formas más comunes de composición son « Source » y « SourceOver ». « Source » se utiliza para dibujar objetos opacos sobre un dispositivo de pintura. En este modo, cada píxel de la imagen de origen sustituye al píxel correspondiente de la imagen de destino. En el modo de composición « SourceOver », el objeto de origen es transparente y se dibuja sobre el de destino.

Ten en cuenta que la transformación de composición opera píxel a píxel. Por ese motivo, existe una diferencia entre utilizar la propia primitiva gráfica y su rectángulo delimitador: el rectángulo delimitador contiene píxeles con alfa == 0 (es decir, los píxeles que rodean a la primitiva). Estos píxeles sobrescribirán los píxeles de la otra imagen, borrándolos de hecho, mientras que la primitiva solo sobrescribe su propia área.

Ejemplo de modos de composición con imágenes fusionadasEjemplo de modos de composición

El ejemplo «Modo de composición», disponible en el directorio de ejemplos de Qt, te permite experimentar con los distintos modos de composición y ver los resultados al instante.

Limitaciones

Si utilizas coordenadas con el motor de dibujo basado en ráster de Qt, es importante tener en cuenta que, aunque se pueden utilizar coordenadas superiores a +/-215, no se garantiza que se muestre cualquier dibujo realizado con coordenadas fuera de este rango; el dibujo puede quedar recortado. Esto se debe al uso de la función ` short int ` en la implementación.

Los contornos generados por el trazador de Qt son solo una aproximación cuando se trata de formas curvas. En la mayoría de los casos es imposible representar el contorno de un segmento de curva Bézier utilizando otro segmento de curva Bézier, por lo que Qt aproxima los contornos de las curvas utilizando varias curvas más pequeñas. Por motivos de rendimiento, existe un límite en el número de curvas que Qt utiliza para estos contornos, por lo que, al emplear anchos de trazo o escalas elevados, el error en los contornos aumenta. Para generar contornos con menores errores, es posible utilizar la clase ` QPainterPathStroker `, que cuenta con la función miembro `setCurveThreshold`, la cual permite al usuario especificar la tolerancia al error. Otra solución alternativa consiste en convertir primero las rutas en polígonos y, a continuación, dibujar los polígonos en su lugar.

Del mismo modo, Qt aproxima los arcos y las elipses con curvas Bézier cúbicas en lugar de evaluarlos trigonométricamente, por lo que los puntos de un arco se desvían ligeramente de sus posiciones reales. En relación con esto, los ángulos que toman las funciones ` drawArc()`, ` drawPie()` y ` drawChord()` son ángulos excéntricos: miden la dirección desde el centro del rectángulo delimitador solo cuando dicho rectángulo es cuadrado. Consulte Arcs and Ellipses para obtener más detalles sobre ambos.

Rendimiento

QPainter es un completo marco de trabajo que permite a los desarrolladores realizar una gran variedad de operaciones gráficas, como degradados, modos de composición y gráficos vectoriales. Además, QPainter puede llevar a cabo estas operaciones en una amplia variedad de configuraciones de hardware y software. Naturalmente, la combinación subyacente de hardware y software tiene ciertas implicaciones en el rendimiento, y garantizar que cada operación sea rápida en combinación con todas las diversas combinaciones de modos de composición, pinceles, recorte, transformación, etc., es una tarea casi imposible debido al número de permutaciones. Como solución intermedia, hemos seleccionado un subconjunto de la API y los backends de QPainter, en el que se garantiza que el rendimiento sea el mejor que podamos obtener de forma razonable para la combinación concreta de hardware y software.

Los backends en los que nos centramos como motores de alto rendimiento son:

  • Raster: este backend implementa todo el renderizado mediante software puro y siempre se utiliza para renderizar en QImages. Para un rendimiento óptimo, utiliza únicamente los tipos de formato QImage::Format_ARGB32_Premultiplied, QImage::Format_RGB32 o QImage::Format_RGB16. Cualquier otro formato, incluido QImage::Format_ARGB32, presenta un rendimiento significativamente peor. Este motor se utiliza por defecto para QWidget y QPixmap.
  • OpenGL 2.0 (ES): este backend es el principal para los gráficos con aceleración por hardware. Se puede ejecutar en ordenadores de sobremesa y dispositivos integrados que admitan la especificación OpenGL 2.0 u OpenGL/ES 2.0. Esto incluye la mayoría de los chips gráficos fabricados en los últimos años. El motor se puede habilitar utilizando QPainter en un ` QOpenGLWidget`.

Estas operaciones son:

  • Transformaciones simples, es decir, traslación y escalado, además de rotaciones de 0, 90, 180 y 270 grados.
  • drawPixmap() En combinación con transformaciones simples y opacidad con el modo de transformación no suave (QPainter::SmoothPixmapTransform no habilitado como indicación de renderizado).
  • Rellenos de rectángulos con color sólido, degradados lineales de dos colores y transformaciones simples.
  • Recorte rectangular con transformaciones simples y recorte por intersección.
  • Modos de composición « QPainter::CompositionMode_Source » y « QPainter::CompositionMode_SourceOver ».
  • Relleno de rectángulos redondeados con color sólido y degradados lineales de dos colores.
  • Mapas de píxeles de 3x3 con parches, mediante qDrawBorderPixmap.

Esta lista ofrece una indicación de qué funciones se pueden utilizar con seguridad en una aplicación en la que el rendimiento es fundamental. En determinadas configuraciones, otras operaciones también pueden resultar rápidas, pero antes de hacer un uso extensivo de ellas, se recomienda realizar pruebas de rendimiento y verificarlas en el sistema en el que se ejecutará finalmente el software. También hay casos en los que es aceptable utilizar operaciones costosas, por ejemplo, cuando el resultado se almacena en caché en un QPixmap.

Véase también QPaintDevice, QPaintEngine, Qt SVG, Ejemplo básico de dibujo y Drawing Utility Functions.

Documentación sobre tipos de miembros

enum QPainter::CompositionMode

Define los modos compatibles para la composición de imágenes digitales. Los modos de composición se utilizan para especificar cómo se fusionan los píxeles de una imagen (la de origen) con los píxeles de otra imagen (la de destino).

Ten en cuenta que los modos de operación rasterizada bit a bit, indicados con el prefijo «RasterOp», solo son compatibles de forma nativa en los motores X11 y de pintura rasterizada. Esto significa que la única forma de utilizar estos modos en Mac es a través de un « QImage ». Los modos de fusión indicados con «RasterOp» no son compatibles con lápices y pinceles con componentes alfa. Además, al activar la sugerencia de renderizado « QPainter::Antialiasing » (Mezcla de alfa) se desactivarán efectivamente los modos RasterOp.

Ilustración en la que se muestran los modos de composición «Source», «Destination», «SourceOver», «DestinationOver», «SourceIn» y «DestinationIn»

Ilustración en la que se muestran los modos de composición «SourceOut», «DestinationOut», «SourceAtop», «DestinationAtop», «Clear» y «Xor»

El tipo más común es SourceOver (a menudo denominado simplemente «mezcla alfa»), en el que el píxel de origen se superpone al píxel de destino de tal manera que el componente alfa del origen define la translucidez del píxel.

Varios modos de composición requieren un canal alfa en las imágenes de origen o destino para surtir efecto. Para un rendimiento óptimo, se recomienda el formato de imagen Format_ARGB32_Premultiplied.

Cuando se establece un modo de composición, este se aplica a todos los operadores de pintura, plumas, pinceles, degradados y dibujos de mapas de píxeles o imágenes.

ConstanteValorDescripción
QPainter::CompositionMode_SourceOver0Este es el modo predeterminado. Se utiliza el canal alfa de la imagen de origen para fusionar el píxel sobre la imagen de destino.
QPainter::CompositionMode_DestinationOver1Se utiliza el alfa del destino para fusionarlo sobre los píxeles de origen. Este modo es el inverso de CompositionMode_SourceOver.
QPainter::CompositionMode_Clear2Los píxeles del destino se borran (se establecen como totalmente transparentes) independientemente de la fuente.
QPainter::CompositionMode_Source3El resultado es el píxel de origen. (Esto supone una operación básica de copia y es idéntico a SourceOver cuando el píxel de origen es opaco).
QPainter::CompositionMode_Destination4El resultado es el píxel de destino. Esto significa que la mezcla no tiene ningún efecto. Este modo es el inverso de CompositionMode_Source.
QPainter::CompositionMode_SourceIn5El resultado es el píxel de origen, en el que el alfa se reduce en la cantidad correspondiente al alfa del destino.
QPainter::CompositionMode_DestinationIn6El resultado es el destino, donde el alfa se reduce en la cantidad del alfa de la fuente. Este modo es el inverso de CompositionMode_SourceIn.
QPainter::CompositionMode_SourceOut7El resultado es la fuente, donde el alfa se reduce en la inversa del destino.
QPainter::CompositionMode_DestinationOut8El resultado es el destino, donde el alfa se reduce en la inversa del de la fuente. Este modo es el inverso de CompositionMode_SourceOut.
QPainter::CompositionMode_SourceAtop9El píxel de origen se superpone al de destino, y el alfa del píxel de origen se reduce en la cantidad del alfa del píxel de destino.
QPainter::CompositionMode_DestinationAtop10El píxel de destino se superpone al de origen, y el alfa del píxel de destino se reduce en el alfa del píxel de destino. Este modo es el inverso de CompositionMode_SourceAtop.
QPainter::CompositionMode_Xor11La fuente, cuyo alfa se reduce con el inverso del alfa del destino, se fusiona con el destino, cuyo alfa se reduce por el inverso del alfa de la fuente. CompositionMode_Xor no es lo mismo que el XOR bit a bit.
QPainter::CompositionMode_Plus12Tanto el alfa como el color de los píxeles de origen y destino se suman.
QPainter::CompositionMode_Multiply13El resultado es el color de origen multiplicado por el de destino. Multiplicar un color por blanco deja el color sin cambios, mientras que multiplicar un color por negro da como resultado negro.
QPainter::CompositionMode_Screen14Los colores de origen y destino se invierten y, a continuación, se multiplican. La superposición de un color con blanco produce blanco, mientras que la superposición de un color con negro deja el color sin cambios.
QPainter::CompositionMode_Overlay15Multiplica o trama los colores en función del color de destino. El color de destino se mezcla con el color de origen para reflejar la claridad u oscuridad del destino.
QPainter::CompositionMode_Darken16Se selecciona el más oscuro de los colores de origen y de destino.
QPainter::CompositionMode_Lighten17Se selecciona el más claro de los colores de origen y de destino.
QPainter::CompositionMode_ColorDodge18El color de destino se aclara para reflejar el color de origen. Un color de origen negro deja el color de destino sin cambios.
QPainter::CompositionMode_ColorBurn19El color de destino se oscurece para reflejar el color de origen. Un color de origen blanco deja el color de destino sin cambios.
QPainter::CompositionMode_HardLight20Multiplica o superpone los colores en función del color de origen. Un color de origen claro aclarará el color de destino, mientras que un color de origen oscuro lo oscurecerá.
QPainter::CompositionMode_SoftLight21Oscurece o aclara los colores en función del color de origen. Similar a CompositionMode_HardLight.
QPainter::CompositionMode_Difference22Resta el color más oscuro del más claro. Al pintar con blanco se invierte el color de destino, mientras que al pintar con negro el color de destino permanece sin cambios.
QPainter::CompositionMode_Exclusion23Similar a CompositionMode_Difference, pero con un contraste menor. Al pintar con blanco se invierte el color de destino, mientras que al pintar con negro el color de destino permanece inalterado.
QPainter::RasterOp_SourceOrDestination24Realiza una operación OR bit a bit sobre los píxeles de origen y destino (src OR dst).
QPainter::RasterOp_SourceAndDestination25Realiza una operación AND a nivel de bits sobre los píxeles de origen y destino (src AND dst).
QPainter::RasterOp_SourceXorDestination26Realiza una operación XOR a nivel de bits sobre los píxeles de origen y destino (src XOR dst).
QPainter::RasterOp_NotSourceAndNotDestination27Realiza una operación OR a nivel de bits sobre los píxeles de origen y destino ((NOT src) AND (NOT dst)).
QPainter::RasterOp_NotSourceOrNotDestination28Realiza una operación NAND a nivel de bits sobre los píxeles de origen y destino ((NOT src) OR (NOT dst)).
QPainter::RasterOp_NotSourceXorDestination29Realiza una operación bit a bit en la que se invierten los píxeles de origen y, a continuación, se aplica una operación XOR con los de destino ((NOT src) XOR dst).
QPainter::RasterOp_NotSource30Realiza una operación bit a bit en la que se invierten los píxeles de origen (NOT src).
QPainter::RasterOp_NotSourceAndDestination31Realiza una operación bit a bit en la que se invierte la fuente y, a continuación, se aplica una operación AND con el destino ((NOT src) AND dst).
QPainter::RasterOp_SourceAndNotDestination32Realiza una operación bit a bit en la que la fuente se combina mediante AND con los píxeles de destino invertidos (src AND (NOT dst)).
QPainter::RasterOp_NotSourceOrDestination33Realiza una operación bit a bit en la que se invierte la fuente y, a continuación, se aplica una operación OR con el destino ((NOT src) OR dst).
QPainter::RasterOp_ClearDestination35Los píxeles del destino se borran (se establecen en 0) independientemente de la fuente.
QPainter::RasterOp_SetDestination36Los píxeles del destino se establecen (se ponen a 1) independientemente de la fuente.
QPainter::RasterOp_NotDestination37Realiza una operación bit a bit en la que se invierten los píxeles de destino (NOT dst).
QPainter::RasterOp_SourceOrNotDestination34Realiza una operación bit a bit en la que la fuente se combina mediante la operación OR con los píxeles del destino invertidos (src OR (NOT dst)).

Véase también compositionMode(), setCompositionMode(), Composition Modes y Ejemplo de composición de imágenes.

enum QPainter::PixmapFragmentHint
flags QPainter::PixmapFragmentHints

ConstanteValorDescripción
QPainter::OpaqueHint0x01Indica que los fragmentos de mapa de píxeles que se van a dibujar son opacos. Los fragmentos opacos pueden dibujarse más rápido.

El tipo `PixmapFragmentHints` es una definición de tipo para ` QFlags<PixmapFragmentHint>`. Almacena una combinación OR de valores de `PixmapFragmentHint`.

Véase también QPainter::drawPixmapFragments() y QPainter::PixmapFragment.

enum QPainter::RenderHint
flags QPainter::RenderHints

Las «Renderhints» se utilizan para especificar parámetros de « QPainter » que pueden ser respetados o no por un motor concreto.

ConstanteValorDescripción
QPainter::Antialiasing0x01Indica que el motor debe aplicar suavizado a los bordes de las primitivas si es posible.
QPainter::TextAntialiasing0x02Indica que el motor debe aplicar suavizado al texto si es posible. Para desactivar forzosamente el suavizado del texto, no utilices esta indicación. En su lugar, configura « QFont::NoAntialias » en la estrategia de estilo de tu fuente.
QPainter::SmoothPixmapTransform0x04Indica que el motor debe utilizar un algoritmo de transformación de mapas de píxeles suave (como el bilineal) en lugar del de vecino más cercano.
QPainter::VerticalSubpixelPositioning0x08Permite que el texto se posicione en fracciones de píxeles tanto vertical como horizontalmente, si el motor de fuentes lo admite. Actualmente, Freetype lo admite en todas las plataformas cuando la preferencia de hinting es « QFont::PreferNoHinting », y también en macOS. En la mayoría de los casos de uso, esto no mejorará la calidad visual, pero puede aumentar el consumo de memoria y reducir ligeramente el rendimiento de la representación del texto. Por lo tanto, no se recomienda habilitar esta opción a menos que el caso de uso lo requiera. Un caso de uso de este tipo podría ser la alineación de glifos con otras primitivas visuales. Este valor se añadió en Qt 6.1.
QPainter::LosslessImageRendering0x40Utilice una representación de imágenes sin pérdida, siempre que sea posible. Actualmente, esta sugerencia solo se utiliza cuando se emplea « QPainter » para generar un archivo PDF mediante QPrinter o QPdfWriter, donde las llamadas a drawImage()/drawPixmap() codificarán las imágenes utilizando un algoritmo de compresión sin pérdida en lugar de la compresión JPEG con pérdida. Este valor se añadió en Qt 5.13.
QPainter::NonCosmeticBrushPatterns0x80Al pintar con un pincel con uno de los estilos de patrón predefinidos, se transforma también el patrón, junto con el objeto que se está pintando. Por defecto, el patrón se trata como un elemento decorativo, de modo que los píxeles del patrón se asignan directamente a los píxeles del dispositivo, independientemente de cualquier transformación activa. Este valor se añadió en Qt 6.4.

El tipo `RenderHints` es un `typedef` para ` QFlags<RenderHint>`. Almacena una combinación OR de valores de `RenderHint`.

Véase también renderHints(), setRenderHint() y Rendering Quality.

Documentación de las funciones miembro

QPainter::QPainter()

Crea un «painter».

Véase también begin() y end().

[explicit] QPainter::QPainter(QPaintDevice *device)

Crea un «painter» que comienza a pintar inmediatamente el «paint» device.

Este constructor resulta útil para pintores de corta duración, por ejemplo, en un QWidget::paintEvent(), y solo debe utilizarse una vez. El constructor llama a begin() por ti y el destructor de QPainter llama automáticamente a end().

A continuación se muestra un ejemplo en el que se utilizan begin() y end():

void MyWidget::paintEvent(QPaintEvent *)
{
    QPainter p;
    p.begin(this);
    p.drawLine(drawingCode);        // drawing code
    p.end();
}

El mismo ejemplo utilizando este constructor:

void MyWidget::paintEvent(QPaintEvent *)
{
    QPainter p(this);
    p.drawLine(drawingCode);        // drawing code
}

Dado que el constructor no puede proporcionar información cuando falla la inicialización del pintor, es preferible utilizar begin() y end() para dibujar en dispositivos externos, como impresoras.

Véase también begin() y end().

[noexcept] QPainter::~QPainter()

Acaba con el pintor.

const QBrush &QPainter::background() const

Devuelve el pincel de fondo actual.

Véase también setBackground() y Settings.

Qt::BGMode QPainter::backgroundMode() const

Devuelve el modo de fondo actual.

Véase también setBackgroundMode() y Settings.

bool QPainter::begin(QPaintDevice *device)

Comienza a pintar el color device y devuelve true si se realiza correctamente; en caso contrario, devuelve false.

Ten en cuenta que todos los ajustes del pintor (setPen(), setBrush(), etc.) se restablecen a sus valores por defecto cuando se llama a begin().

Los errores que pueden producirse son problemas graves, como estos:

painter->begin(nullptr); // impossible - paint device cannot be null

QPixmap image(0, 0);
painter->begin(&image); // impossible - image.isNull() == true;

painter->begin(myWidget);
painter2->begin(myWidget); // impossible - only one painter at a time

Ten en cuenta que, en la mayoría de los casos, puedes utilizar uno de los constructores en lugar de `begin()`, y que ` end()` se ejecuta automáticamente al destrirse el objeto.

Advertencia: Un dispositivo de dibujo solo puede ser pintado por un pintor a la vez.

Advertencia: No se admitepintar en un ` QImage ` con el formato ` QImage::Format_Indexed8 `.

Véase también end() y QPainter().

void QPainter::beginNativePainting()

Vacíe el canal de dibujo y prepárese para que el usuario envíe comandos directamente al contexto gráfico subyacente. Debe ir seguida de una llamada a ` endNativePainting()`.

Ten en cuenta que solo los estados que modifique el motor de pintura subyacente se restablecerán a sus respectivos estados predeterminados. Los estados que se restablecen pueden variar de una versión a otra. Actualmente, en el motor OpenGL 2 se restablecen los siguientes estados:

  • la mezcla está desactivada
  • las pruebas de profundidad, plantilla y tijera están desactivadas
  • la unidad de textura activa se restablece a 0
  • la máscara de profundidad, la función de profundidad y la profundidad de borrado se restablecen a sus valores predeterminados
  • la máscara de estarcido, la operación de estarcido y la función de estarcido se restablecen a sus valores por defecto
  • el color actual se restablece a blanco sólido

Si, por ejemplo, el usuario cambia el modo de polígono de OpenGL dentro de un bloque `beginNativePaint()`/`endNativePainting()`, este no se restablecerá a su estado predeterminado mediante ` endNativePainting()`. A continuación se muestra un ejemplo que ilustra la combinación de comandos de pintura y comandos OpenGL sin procesar:

QPainter painter(this);
painter.fillRect(0, 0, 128, 128, Qt::green);
painter.beginNativePainting();

glEnable(GL_SCISSOR_TEST);
glScissor(0, 0, 64, 64);

glClearColor(1, 0, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);

glDisable(GL_SCISSOR_TEST);

painter.endNativePainting();

Véase también endNativePainting().

QRectF QPainter::boundingRect(const QRectF &rectangle, int flags, const QString &text)

Devuelve el rectángulo delimitador de la ` text `, tal y como aparecerá al dibujarse dentro del ` rectangle ` dado, con el ` flags ` especificado y utilizando el ` font()` establecido actualmente; es decir, la función indica dónde dibujará la función ` drawText()` cuando se le proporcionen los mismos argumentos.

Si el text no cabe dentro del rectangle dado utilizando el flags especificado, la función devuelve el rectángulo requerido.

El argumento ` flags ` es una operación OR bit a bit de los siguientes indicadores:

Si se establecen varios de los indicadores de alineación horizontal o varios de los de alineación vertical, la alineación resultante no está definida.

Véanse también drawText(), Qt::Alignment y Qt::TextFlag.

QRect QPainter::boundingRect(const QRect &rectangle, int flags, const QString &text)

Devuelve el rectángulo delimitador del objeto ` text ` tal y como aparecerá al dibujarse dentro del objeto ` rectangle ` dado, con el objeto ` flags ` especificado y utilizando el objeto ` font()` establecido actualmente.

Esta es una función sobrecargada.

QRectF QPainter::boundingRect(const QRectF &rectangle, const QString &text, const QTextOption &option = QTextOption())

En lugar de especificar los indicadores como una operación OR bit a bit de ` Qt::AlignmentFlag ` y ` Qt::TextFlag`, esta función sobrecargada toma un argumento de tipo ` option `. La clase ` QTextOption ` proporciona una descripción de las propiedades generales del texto enriquecido.

Esta es una función sobrecargada.

Véase también QTextOption.

QRect QPainter::boundingRect(int x, int y, int w, int h, int flags, const QString &text)

Devuelve el rectángulo delimitador del objeto « text » dado, tal y como aparecerá al dibujarse dentro del rectángulo que tiene su origen en el punto (x, y), con un ancho de w y una altura de h.

Se trata de una función sobrecargada.

const QBrush &QPainter::brush() const

Devuelve el pincel actual del pintor.

Véase también QPainter::setBrush() y Settings.

QPoint QPainter::brushOrigin() const

Devuelve el origen actual del pincel. Se recomienda utilizar QPainter::brushOriginF() para obtener el origen exacto.

Véase también setBrushOrigin() y Settings.

[since 6.11] QPointF QPainter::brushOriginF() const

Devuelve el origen actual del pincel.

Esta función se introdujo en Qt 6.11.

Véase también ` setBrushOrigin()` y ` Settings`.

QRectF QPainter::clipBoundingRect() const

Devuelve el rectángulo delimitador del recorte actual, si hay alguno; en caso contrario, devuelve un rectángulo vacío. Ten en cuenta que la región de recorte se expresa en coordenadas lógicas.

No se garantiza que el rectángulo delimitador sea ajustado.

Véase también setClipRect(), setClipPath() y setClipRegion().

QPainterPath QPainter::clipPath() const

Devuelve la ruta del clip actual en coordenadas lógicas.

Advertencia: ` QPainter ` no almacena el recorte combinado de forma explícita, ya que esto lo gestiona el ` QPaintEngine` subyacente, por lo que la ruta se recrea bajo demanda y se transforma al sistema de coordenadas lógicas actual. Esta operación puede resultar costosa.

Véase también setClipPath(), clipRegion() y setClipping().

QRegion QPainter::clipRegion() const

Devuelve la región de clip establecida actualmente. Ten en cuenta que la región de clip se expresa en coordenadas lógicas.

Advertencia: ` QPainter ` no almacena el recorte combinado de forma explícita, ya que esto lo gestiona el ` QPaintEngine` subyacente, por lo que la ruta se recrea bajo demanda y se transforma al sistema de coordenadas lógicas actual. Esta operación puede resultar costosa.

Véase también setClipRegion(), clipPath() y setClipping().

QTransform QPainter::combinedTransform() const

Devuelve la matriz de transformación que combina la transformación de la ventana o el área de visualización actual con la transformación del mundo.

Véase también setWorldTransform(), setWindow() y setViewport().

QPainter::CompositionMode QPainter::compositionMode() const

Devuelve el modo de composición actual.

Véase también CompositionMode y setCompositionMode().

QPaintDevice *QPainter::device() const

Devuelve el dispositivo de pintura en el que este pintor está pintando actualmente, o « nullptr » si el pintor no está activo.

Véase también isActive().

const QTransform &QPainter::deviceTransform() const

Devuelve la matriz que transforma las coordenadas lógicas en coordenadas del dispositivo de dibujo específico de la plataforma.

Esta función solo es necesaria cuando se utilizan comandos de dibujo de la plataforma en el identificador dependiente de la plataforma (Qt::HANDLE) y la plataforma no realiza las transformaciones de forma nativa.

Se puede consultar la enumeración QPaintEngine::PaintEngineFeature para determinar si la plataforma realiza las transformaciones o no.

Véanse también worldTransform() y QPaintEngine::hasFeature().

void QPainter::drawArc(const QRectF &rectangle, int startAngle, int spanAngle)

Dibuja el arco definido por los valores dados de « rectangle », « startAngle » y « spanAngle ».

Los valores de startAngle y spanAngle deben especificarse en 1/16 de grado; es decir, un círculo completo equivale a 5760 (16 * 360). Los valores positivos de los ángulos indican el sentido antihorario, mientras que los valores negativos indican el sentido horario. Cero grados se encuentra en la posición de las 3 en punto. Si rectangle no es un cuadrado, los ángulos son ángulos excéntricos y no miden la dirección desde el centro del rectángulo, tal y como se describe en Arcs and Ellipses.

Curva de arco
QRectF rectangle(10.0, 20.0, 80.0, 60.0);
int startAngle = 30 * 16;
int spanAngle = 120 * 16;

QPainter painter(this);
painter.drawArc(rectangle, startAngle, spanAngle);

Véase también drawPie(), drawChord() y «Sistema de coordenadas».

void QPainter::drawArc(const QRect &rectangle, int startAngle, int spanAngle)

Dibuja el arco definido por los valores proporcionados en « rectangle », « startAngle » y « spanAngle ».

Esta es una función sobrecargada.

void QPainter::drawArc(int x, int y, int width, int height, int startAngle, int spanAngle)

Dibuja el arco definido por el rectángulo que comienza en (x, y) con los valores especificados para width y height, y los valores dados para startAngle y spanAngle.

Se trata de una función sobrecargada.

void QPainter::drawChord(const QRectF &rectangle, int startAngle, int spanAngle)

Dibuja la cuerda definida por los valores proporcionados: ` rectangle`, ` startAngle ` y ` spanAngle`. La cuerda se rellena con el color actual ` brush()`.

Los parámetros startAngle y spanAngle deben especificarse en 1/16 de grado; es decir, un círculo completo equivale a 5760 (16 * 360). Los valores positivos de los ángulos indican el sentido antihorario, mientras que los valores negativos indican el sentido horario. Cero grados corresponde a la posición de las 3 en punto. Si rectangle no es un cuadrado, los ángulos son ángulos excéntricos y no miden la dirección desde el centro del rectángulo, tal y como se describe en Arcs and Ellipses.

Forma del acorde
QRectF rectangle(10.0, 20.0, 80.0, 60.0);
int startAngle = 30 * 16;
int spanAngle = 120 * 16;

QPainter painter(this);
painter.drawChord(rect, startAngle, spanAngle);

Véanse también drawArc(), drawPie() y Sistema de coordenadas.

void QPainter::drawChord(const QRect &rectangle, int startAngle, int spanAngle)

Dibuja la cuerda definida por los valores proporcionados: rectangle, startAngle y spanAngle.

Esta es una función sobrecargada.

void QPainter::drawChord(int x, int y, int width, int height, int startAngle, int spanAngle)

Dibuja la cuerda definida por el rectángulo que comienza en (x, y) con los valores especificados width y height, y los valores dados startAngle y spanAngle.

Se trata de una función sobrecargada.

void QPainter::drawConvexPolygon(const QPointF *points, int pointCount)

Dibuja el polígono convexo definido por los primeros puntos de « pointCount » de la matriz « points » utilizando el lápiz actual.

Polígono de cuatro lados
static const QPointF points[4] = {
    QPointF(10.0, 80.0),
    QPointF(20.0, 10.0),
    QPointF(80.0, 30.0),
    QPointF(90.0, 70.0)
};

QPainter painter(this);
painter.drawConvexPolygon(points, 4);

El primer punto se conecta implícitamente con el último, y el polígono se rellena con el brush() actual. Si el polígono proporcionado no es convexo, es decir, si contiene al menos un ángulo mayor de 180 grados, los resultados son indefinidos.

En algunas plataformas (por ejemplo, X11), la función drawConvexPolygon() puede ser más rápida que la función drawPolygon().

Véase también drawPolygon(), drawPolyline() y Sistema de coordenadas.

void QPainter::drawConvexPolygon(const QPolygon &polygon)

Dibuja el polígono convexo definido por polygon utilizando el lápiz y el pincel actuales.

Esta es una función sobrecargada.

void QPainter::drawConvexPolygon(const QPolygonF &polygon)

Dibuja el polígono convexo definido por polygon utilizando el lápiz y el pincel actuales.

Esta es una función sobrecargada.

void QPainter::drawConvexPolygon(const QPoint *points, int pointCount)

Dibuja el polígono convexo definido por los primeros puntos de la matriz pointCount en la matriz points utilizando el lápiz actual.

Esta es una función sobrecargada.

void QPainter::drawEllipse(const QRectF &rectangle)

Dibuja la elipse definida por el valor dado rectangle.

Una elipse rellena tiene un tamaño de rectangle.size(). Una elipse con contorno tiene un tamaño de rectangle.size() más el ancho del trazo.

Contorno de una elipse
QRectF rectangle(10.0, 20.0, 80.0, 60.0);

QPainter painter(this);
painter.drawEllipse(rectangle);

Véase también drawPie() y Sistema de coordenadas.

void QPainter::drawEllipse(const QRect &rectangle)

Dibuja la elipse definida por el rectangle proporcionado.

Esta es una función sobrecargada.

void QPainter::drawEllipse(const QPoint &center, int rx, int ry)

Dibuja la elipse situada en center con radios rx y ry.

Esta es una función sobrecargada.

void QPainter::drawEllipse(const QPointF &center, qreal rx, qreal ry)

Dibuja la elipse situada en center con radios rx y ry.

Esta es una función sobrecargada.

void QPainter::drawEllipse(int x, int y, int width, int height)

Dibuja la elipse definida por el rectángulo que tiene como vértices (x, y), con los parámetros width y height.

Esta es una función sobrecargada.

void QPainter::drawGlyphRun(const QPointF &position, const QGlyphRun &glyphs)

Dibuja los glifos representados en glyphs en position. El parámetro position indica el borde de la línea de base de la cadena de glifos. Los glifos se obtendrán de la fuente seleccionada en glyphs y en las posiciones indicadas en glyphs.

Véanse también QGlyphRun::setRawFont(), QGlyphRun::setPositions() y QGlyphRun::setGlyphIndexes().

void QPainter::drawImage(const QRectF &target, const QImage &image, const QRectF &source, Qt::ImageConversionFlags flags = Qt::AutoColor)

Dibuja la parte rectangular source del elemento image dado dentro del rectángulo target del dispositivo de pintura.

Nota: La imagen se escala para ajustarse al rectángulo, si el tamaño de la imagen y el del rectángulo no coinciden.

Nota: Consulta Drawing High Resolution Versions of Pixmaps and Images para saber cómo afecta a esto la función QImage::devicePixelRatio().

Si es necesario modificar la imagen para que quepa en un resultado de menor resolución (por ejemplo, al convertir de 32 bits a 8 bits), utiliza la función flags para especificar cómo prefieres que se realice este proceso.

QRectF target(10.0, 20.0, 80.0, 60.0);
QRectF source(0.0, 0.0, 70.0, 40.0);
QImage image(":/images/myImage.png");

QPainter painter(this);
painter.drawImage(target, image, source);

Véanse también drawPixmap() y QImage::devicePixelRatio().

void QPainter::drawImage(const QPoint &point, const QImage &image)

Dibuja el objeto « image » en la posición « point ».

Esta es una función sobrecargada.

void QPainter::drawImage(const QPointF &point, const QImage &image)

Dibuja el objeto « image » en la posición « point ».

Esta es una función sobrecargada.

void QPainter::drawImage(const QRect &rectangle, const QImage &image)

Dibuja el archivo « image » en el archivo « rectangle ».

Nota: La imagen se escala para ajustarse al rectángulo, si el tamaño de la imagen y el del rectángulo no coinciden.

Esta es una función sobrecargada.

void QPainter::drawImage(const QRectF &rectangle, const QImage &image)

Dibuja el « image » especificado en el « rectangle » especificado.

Nota: La imagen se escala para ajustarse al rectángulo si el tamaño de la imagen y el del rectángulo no coinciden.

Esta es una función sobrecargada.

void QPainter::drawImage(const QPoint &point, const QImage &image, const QRect &source, Qt::ImageConversionFlags flags = Qt::AutoColor)

Dibuja la parte rectangular source del image indicado, con su origen en el point indicado.

Esta es una función sobrecargada.

void QPainter::drawImage(const QPointF &point, const QImage &image, const QRectF &source, Qt::ImageConversionFlags flags = Qt::AutoColor)

Dibuja la parte rectangular source del image indicado, con su origen en el point indicado.

Esta es una función sobrecargada.

void QPainter::drawImage(const QRect &target, const QImage &image, const QRect &source, Qt::ImageConversionFlags flags = Qt::AutoColor)

Dibuja la parte rectangular source de la imagen dada image dentro del rectángulo target en el dispositivo de pintura.

Nota: La imagen se escala para ajustarse al rectángulo, si el tamaño de la imagen y el del rectángulo no coinciden.

Esta es una función sobrecargada.

void QPainter::drawImage(int x, int y, const QImage &image, int sx = 0, int sy = 0, int sw = -1, int sh = -1, Qt::ImageConversionFlags flags = Qt::AutoColor)

Dibuja una imagen en (x, y) copiando una parte de image en el dispositivo de dibujo.

(x, y) especifica el punto superior izquierdo del dispositivo de dibujo sobre el que se va a dibujar. (sx, sy) especifica el punto superior izquierdo de image que se va a dibujar. El valor por defecto es (0, 0).

(sw, sh) especifica el tamaño de la imagen que se va a dibujar. El valor por defecto, (0, 0) (y los valores negativos), significa que se llega hasta la esquina inferior derecha de la imagen.

Esta es una función sobrecargada.

void QPainter::drawLine(const QLineF &line)

Dibuja una línea definida por line.

Línea diagonal
QLineF line(10.0, 80.0, 90.0, 20.0);

QPainter painter(this);
painter.drawLine(line);

Véase también drawLines(), drawPolyline() y Sistema de coordenadas.

void QPainter::drawLine(const QLine &line)

Dibuja una línea definida por line.

Esta es una función sobrecargada.

void QPainter::drawLine(const QPoint &p1, const QPoint &p2)

Traza una línea desde p1 hasta p2.

Esta es una función sobrecargada.

void QPainter::drawLine(const QPointF &p1, const QPointF &p2)

Traza una línea desde p1 hasta p2.

Esta es una función sobrecargada.

void QPainter::drawLine(int x1, int y1, int x2, int y2)

Traza una línea desde (x1, y1) hasta (x2, y2).

Esta es una función sobrecargada.

void QPainter::drawLines(const QLineF *lines, int lineCount)

Dibuja las primeras líneas lineCount en la matriz lines utilizando el lápiz actual.

Véase también drawLine() y drawPolyline().

void QPainter::drawLines(const QList<QLine> &lines)

Dibuja el conjunto de líneas definidas por la lista lines utilizando el lápiz y el pincel actuales.

Esta es una función sobrecargada.

void QPainter::drawLines(const QList<QLineF> &lines)

Dibuja el conjunto de líneas definidas por la lista « lines » utilizando el lápiz y el pincel actuales.

Esta es una función sobrecargada.

void QPainter::drawLines(const QList<QPoint> &pointPairs)

Dibuja una línea para cada par de puntos del vector pointPairs utilizando el lápiz actual.

Esta es una función sobrecargada.

void QPainter::drawLines(const QList<QPointF> &pointPairs)

Dibuja una línea para cada par de puntos del vector ` pointPairs ` utilizando el lápiz actual. Si hay un número impar de puntos en la matriz, se ignorará el último punto.

Esta es una función sobrecargada.

void QPainter::drawLines(const QLine *lines, int lineCount)

Dibuja las primeras lineCount líneas de la matriz lines utilizando el lápiz actual.

Esta es una función sobrecargada.

void QPainter::drawLines(const QPoint *pointPairs, int lineCount)

Dibuja las primeras lineCount líneas de la matriz pointPairs utilizando el lápiz actual.

Esta es una función sobrecargada.

void QPainter::drawLines(const QPointF *pointPairs, int lineCount)

Dibuja las primeras lineCount líneas de la matriz pointPairs utilizando el lápiz actual. Las líneas se especifican como pares de puntos, por lo que el número de entradas en pointPairs debe ser, como mínimo, lineCount * 2.

Esta es una función sobrecargada.

void QPainter::drawPath(const QPainterPath &path)

Dibuja el « path » del pintor especificado utilizando el lápiz actual para el contorno y el pincel actual para el relleno.

Trayectoria de curva de Bézier
QPainterPath path;
path.moveTo(20, 80);
path.lineTo(20, 30);
path.cubicTo(80, 0, 50, 50, 80, 80);

QPainter painter(this);
painter.drawPath(path);

Véanse también los ejemplos «Trazados de Painter » y «Deformación vectorial».

void QPainter::drawPicture(const QPointF &point, const QPicture &picture)

Reproduce el archivo « picture » en la dirección « point ».

La clase ` QPicture ` es un dispositivo de dibujo que graba y reproduce comandos ` QPainter `. Una imagen serializa los comandos de dibujo a un dispositivo de E/S en un formato independiente de la plataforma. Todo lo que se puede dibujar en un widget o en un mapa de píxeles también se puede almacenar en una imagen.

Esta función hace exactamente lo mismo que QPicture::play() cuando se invoca con point = QPointF(0, 0).

Nota: Esta función conservael estado del pintor.

QPicture picture;
QPointF point(10.0, 20.0);
picture.load("drawing.pic");

QPainter painter(this);
painter.drawPicture(0, 0, picture);

Véase también QPicture::play().

void QPainter::drawPicture(const QPoint &point, const QPicture &picture)

Reproduce el archivo « picture » en la ruta « point ».

Esta es una función sobrecargada.

void QPainter::drawPicture(int x, int y, const QPicture &picture)

Dibuja el « picture » especificado en el punto (x, y).

Esta es una función sobrecargada.

void QPainter::drawPie(const QRectF &rectangle, int startAngle, int spanAngle)

Dibuja un gráfico circular definido por los valores proporcionados en rectangle, startAngle y spanAngle.

El sector circular se rellena con el valor actual de brush().

Los parámetros startAngle y spanAngle deben especificarse en 1/16 de grado; es decir, un círculo completo equivale a 5760 (16 * 360). Los valores positivos de los ángulos indican el sentido antihorario, mientras que los valores negativos indican el sentido horario. Cero grados se encuentra en la posición de las 3 en punto. Si rectangle no es un cuadrado, los ángulos son ángulos excéntricos y no miden la dirección desde el centro del rectángulo, tal y como se describe en Arcs and Ellipses.

Con forma de porción de tarta
QRectF rectangle(10.0, 20.0, 80.0, 60.0);
int startAngle = 30 * 16;
int spanAngle = 120 * 16;

QPainter painter(this);
painter.drawPie(rectangle, startAngle, spanAngle);

Véase también drawEllipse(), drawChord() y Sistema de coordenadas.

void QPainter::drawPie(const QRect &rectangle, int startAngle, int spanAngle)

Dibuja un gráfico circular definido por los valores proporcionados en rectangle, startAngle y spanAngle.

Esta es una función sobrecargada.

void QPainter::drawPie(int x, int y, int width, int height, int startAngle, int spanAngle)

Dibuja el sector circular definido por el rectángulo que tiene como puntos de inicio (x, y), con los valores especificados width y height, y los valores dados startAngle y spanAngle.

Se trata de una función sobrecargada.

void QPainter::drawPixmap(const QRectF &target, const QPixmap &pixmap, const QRectF &source)

Dibuja la parte rectangular source del pixmap especificado en el target especificado del dispositivo de pintura.

Nota: El mapa de píxeles se escala para ajustarse al rectángulo, si el tamaño del mapa de píxeles y el del rectángulo no coinciden.

Nota: Consulta Drawing High Resolution Versions of Pixmaps and Images para saber cómo le afecta la función QPixmap::devicePixelRatio().

QRectF target(10.0, 20.0, 80.0, 60.0);
QRectF source(0.0, 0.0, 70.0, 40.0);
QPixmap pixmap(":myPixmap.png");

QPainter painter(this);
painter.drawPixmap(target, pixmap, source);

Si pixmap es un QBitmap, se dibuja con los bits «activados» utilizando el color del lápiz. Si backgroundMode es Qt::OpaqueMode, los bits «desactivados» se dibujan utilizando el color del pincel de fondo; si backgroundMode es Qt::TransparentMode, los bits «desactivados» son transparentes. No se admite el dibujo de mapas de bits con colores degradados o de textura.

Véase también drawImage() y QPixmap::devicePixelRatio().

void QPainter::drawPixmap(const QPoint &point, const QPixmap &pixmap)

Dibuja la curva « pixmap » con su origen en el punto « point ».

Esta es una función sobrecargada.

void QPainter::drawPixmap(const QPointF &point, const QPixmap &pixmap)

Dibuja la función pixmap con su origen en el punto point.

Esta es una función sobrecargada.

void QPainter::drawPixmap(const QRect &rectangle, const QPixmap &pixmap)

Dibuja el mapa de píxeles ( pixmap ) indicado en el rectángulo ( rectangle) indicado.

Nota: El mapa de píxeles se escala para ajustarse al rectángulo, si el tamaño del mapa de píxeles y el del rectángulo no coinciden.

Esta es una función sobrecargada.

void QPainter::drawPixmap(const QPoint &point, const QPixmap &pixmap, const QRect &source)

Dibuja la parte rectangular source de la función dada pixmap con su origen en el punto dado point.

Esta es una función sobrecargada.

void QPainter::drawPixmap(const QPointF &point, const QPixmap &pixmap, const QRectF &source)

Dibuja la parte rectangular source de la función dada pixmap con su origen en el punto dado point.

Esta es una función sobrecargada.

void QPainter::drawPixmap(const QRect &target, const QPixmap &pixmap, const QRect &source)

Dibuja la parte rectangular source de la imagen dada pixmap en la zona dada target del dispositivo de dibujo.

Nota: El mapa de píxeles se escala para ajustarse al rectángulo, si el tamaño del mapa de píxeles y el del rectángulo no coinciden.

Esta es una función sobrecargada.

void QPainter::drawPixmap(int x, int y, const QPixmap &pixmap)

Dibuja el objeto « pixmap » en la posición (x, y).

Esta es una función sobrecargada.

void QPainter::drawPixmap(int x, int y, int width, int height, const QPixmap &pixmap)

Dibuja el « pixmap » dentro del rectángulo situado en la posición (x, y) con los valores « width » y « height » indicados.

Esta es una función sobrecargada.

void QPainter::drawPixmap(int x, int y, const QPixmap &pixmap, int sx, int sy, int sw, int sh)

Dibuja un mapa de píxeles en (x, y) copiando una parte del mapa de píxeles dado pixmap en el dispositivo de dibujo.

(x, y) especifica el punto superior izquierdo del dispositivo de dibujo sobre el que se va a dibujar. (sx, sy) especifica el punto superior izquierdo de pixmap que se va a dibujar. El valor por defecto es (0, 0).

(sw, sh) especifica el tamaño del mapa de píxeles sobre el que se va a dibujar. El valor por defecto, (0, 0) (y los valores negativos), significa que se extendirá hasta la esquina inferior derecha del mapa de píxeles.

Esta es una función sobrecargada.

void QPainter::drawPixmap(int x, int y, int w, int h, const QPixmap &pixmap, int sx, int sy, int sw, int sh)

Dibuja la parte rectangular con origen en (sx, sy), anchura sw y altura sh, del mapa de píxeles dado pixmap, en el punto (x, y), con una anchura de w y una altura de h. Si sw o sh son iguales a cero, se utiliza la anchura/altura del mapa de píxeles y se ajusta mediante el desplazamiento sx/sy;

Esta es una función sobrecargada.

void QPainter::drawPixmapFragments(const QPainter::PixmapFragment *fragments, int fragmentCount, const QPixmap &pixmap, QPainter::PixmapFragmentHints hints = PixmapFragmentHints())

Esta función se utiliza para dibujar pixmap o un subrectángulo de pixmap en varias posiciones con diferente escala, rotación y opacidad. fragments es una matriz de elementos fragmentCount que especifican los parámetros utilizados para dibujar cada fragmento del mapa de píxeles. El parámetro hints puede utilizarse para pasar indicaciones de dibujo.

Esta función es potencialmente más rápida que varias llamadas a ` drawPixmap()`, ya que el backend puede optimizar los cambios de estado.

Véanse también QPainter::PixmapFragment y QPainter::PixmapFragmentHint.

void QPainter::drawPoint(const QPointF &position)

Dibuja un único punto en las coordenadas dadas position utilizando el color del lápiz actual.

Véase también «Sistema de coordenadas».

void QPainter::drawPoint(const QPoint &position)

Dibuja un único punto en las coordenadas dadas ` position ` utilizando el color del lápiz actual.

Esta es una función sobrecargada.

void QPainter::drawPoint(int x, int y)

Dibuja un único punto en la posición (x, y).

Esta es una función sobrecargada.

void QPainter::drawPoints(const QPointF *points, int pointCount)

Dibuja los primeros puntos « pointCount » de la matriz « points » utilizando el color del lápiz actual.

Véase también «Sistema de coordenadas».

void QPainter::drawPoints(const QPolygon &points)

Dibuja los puntos del vector points.

Esta es una función sobrecargada.

void QPainter::drawPoints(const QPolygonF &points)

Dibuja los puntos del vector points.

Esta es una función sobrecargada.

void QPainter::drawPoints(const QPoint *points, int pointCount)

Dibuja los primeros puntos « pointCount » de la matriz « points » utilizando el color del lápiz actual.

Esta es una función sobrecargada.

void QPainter::drawPolygon(const QPointF *points, int pointCount, Qt::FillRule fillRule = Qt::OddEvenFill)

Dibuja el polígono definido por los primeros puntos de pointCount en la matriz points utilizando el lápiz y el pincel actuales.

Polígono de cuatro lados
static const QPointF points[4] = {
    QPointF(10.0, 80.0),
    QPointF(20.0, 10.0),
    QPointF(80.0, 30.0),
    QPointF(90.0, 70.0)
};

QPainter painter(this);
painter.drawPolygon(points, 4);

El primer punto se conecta implícitamente con el último, y el polígono se rellena con el brush() actual.

Si fillRule es Qt::WindingFill, el polígono se rellena utilizando el algoritmo de relleno por sentido de giro. Si fillRule es Qt::OddEvenFill, el polígono se rellena utilizando el algoritmo de relleno par-impar. Consulte Qt::FillRule para obtener una descripción más detallada de estas reglas de relleno.

Véase también drawConvexPolygon(), drawPolyline() y Sistema de coordenadas.

void QPainter::drawPolygon(const QPolygon &points, Qt::FillRule fillRule = Qt::OddEvenFill)

Dibuja el polígono definido por el « points » dado utilizando la regla de relleno « fillRule ».

Esta es una función sobrecargada.

void QPainter::drawPolygon(const QPolygonF &points, Qt::FillRule fillRule = Qt::OddEvenFill)

Dibuja el polígono definido por el « points » dado utilizando la regla de relleno « fillRule ».

Esta es una función sobrecargada.

void QPainter::drawPolygon(const QPoint *points, int pointCount, Qt::FillRule fillRule = Qt::OddEvenFill)

Dibuja el polígono definido por los primeros puntos de la matriz « pointCount » en la matriz « points ».

Esta es una función sobrecargada.

void QPainter::drawPolyline(const QPointF *points, int pointCount)

Dibuja la polilínea definida por los primeros puntos de pointCount en points utilizando el lápiz actual.

Ten en cuenta que, a diferencia de la función drawPolygon(), el último punto no está conectado al primero, ni tampoco se rellena la polilínea.

static const QPointF points[3] = {
    QPointF(10.0, 80.0),
    QPointF(20.0, 10.0),
    QPointF(80.0, 30.0),
};

QPainter painter(this);
painter.drawPolyline(points, 3);

Véase también « drawLines()», « drawPolygon()» y «Sistema de coordenadas».

void QPainter::drawPolyline(const QPolygon &points)

Dibuja la polilínea definida por el « points » indicado utilizando el lápiz actual.

Esta es una función sobrecargada.

void QPainter::drawPolyline(const QPolygonF &points)

Dibuja la polilínea definida por el « points » proporcionado utilizando el lápiz actual.

Esta es una función sobrecargada.

void QPainter::drawPolyline(const QPoint *points, int pointCount)

Dibuja la polilínea definida por los primeros puntos pointCount en points utilizando el lápiz actual.

Esta es una función sobrecargada.

void QPainter::drawRect(const QRectF &rectangle)

Dibuja el rectángulo « rectangle » actual con el lápiz y el pincel actuales.

Un rectángulo relleno tiene un tamaño de rectangle.size(). Un rectángulo con contorno tiene un tamaño de rectangle.size() más el ancho del trazo.

Contorno rectangular
QRectF rectangle(10.0, 20.0, 80.0, 60.0);

QPainter painter(this);
painter.drawRect(rectangle);

Véase también drawRects(), drawPolygon() y Sistema de coordenadas.

void QPainter::drawRect(const QRect &rectangle)

Dibuja el rectangle actual con el lápiz y el pincel actuales.

Esta es una función sobrecargada.

void QPainter::drawRect(int x, int y, int width, int height)

Dibuja un rectángulo cuya esquina superior izquierda se encuentra en (x, y) y cuyos valores de width y height son los indicados.

Esta es una función sobrecargada.

void QPainter::drawRects(const QRectF *rectangles, int rectCount)

Dibuja el primer « rectCount » del « rectangles » indicado utilizando el lápiz y el pincel actuales.

Véase también drawRect().

void QPainter::drawRects(const QList<QRect> &rectangles)

Dibuja el « rectangles » indicado utilizando el lápiz y el pincel actuales.

Esta es una función sobrecargada.

void QPainter::drawRects(const QList<QRectF> &rectangles)

Dibuja el objeto « rectangles » especificado utilizando el lápiz y el pincel actuales.

Esta es una función sobrecargada.

void QPainter::drawRects(const QRect *rectangles, int rectCount)

Dibuja el primer « rectCount » de la « rectangles » indicada utilizando el lápiz y el pincel actuales.

Esta es una función sobrecargada.

void QPainter::drawRoundedRect(const QRectF &rect, qreal xRadius, qreal yRadius, Qt::SizeMode mode = Qt::AbsoluteSize)

Dibuja el rectángulo indicado rect con las esquinas redondeadas.

Los argumentos « xRadius » y « yRadius » especifican los radios de las elipses que definen las esquinas del rectángulo redondeado. Cuando « mode » es « Qt::RelativeSize », « xRadius » y « yRadius » se especifican en porcentaje de la mitad del ancho y la altura del rectángulo, respectivamente, y deben estar comprendidos entre 0,0 y 100,0.

Un rectángulo relleno tiene un tamaño de rect.size(). Un rectángulo con contorno tiene un tamaño de rect.size() más el grosor del trazo.

Contorno de rectángulo redondeado
QRectF rectangle(10.0, 20.0, 80.0, 60.0);

QPainter painter(this);
painter.drawRoundedRect(rectangle, 20.0, 15.0);

Véase también drawRect() y QPen.

void QPainter::drawRoundedRect(const QRect &rect, qreal xRadius, qreal yRadius, Qt::SizeMode mode = Qt::AbsoluteSize)

Dibuja el rectángulo dado rect con las esquinas redondeadas.

Esta es una función sobrecargada.

void QPainter::drawRoundedRect(int x, int y, int w, int h, qreal xRadius, qreal yRadius, Qt::SizeMode mode = Qt::AbsoluteSize)

Dibuja el rectángulo indicado x, y, w, h con las esquinas redondeadas.

Se trata de una función sobrecargada.

void QPainter::drawStaticText(const QPointF &topLeftPosition, const QStaticText &staticText)

Dibuja el « staticText » especificado en la « topLeftPosition » indicada.

El texto se dibujará utilizando la fuente y la transformación establecidas en el pintor. Si la fuente y/o la transformación establecidas en el pintor son diferentes de las utilizadas para inicializar el diseño de QStaticText, será necesario volver a calcular el diseño. Utiliza QStaticText::prepare() para inicializar staticText con la fuente y la transformación con las que se dibujará posteriormente.

Si topLeftPosition no es el mismo que cuando se inicializó staticText, o que cuando se dibujó por última vez, se producirá una ligera sobrecarga al trasladar el texto a su nueva posición.

Nota: Si la transformación del pintor no es afín, entonces staticText se dibujará utilizando llamadas normales a drawText(), perdiéndose así cualquier posibilidad de mejora en el rendimiento.

Nota: La posición y se utiliza como la parte superior de la fuente.

Véase también QStaticText.

void QPainter::drawStaticText(const QPoint &topLeftPosition, const QStaticText &staticText)

Dibuja el « staticText » en topLeftPosition.

Nota: La posición y se utiliza como parte superior de la fuente.

Esta es una función sobrecargada.

void QPainter::drawStaticText(int left, int top, const QStaticText &staticText)

Dibuja la fuente « staticText » en las coordenadas left y top.

Nota: La posición y se utiliza como parte superior de la fuente.

Esta es una función sobrecargada.

void QPainter::drawText(const QPointF &position, const QString &text)

Dibuja el carácter de nueva línea ( text ) especificado con la dirección del texto definida actualmente, comenzando en el punto de inicio ( position) indicado.

Esta función no gestiona el carácter de salto de línea (\n), ya que no puede dividir el texto en varias líneas ni mostrar dicho carácter. Utiliza la sobrecarga de QPainter::drawText() que toma un rectángulo si deseas dibujar varias líneas de texto con el carácter de salto de línea, o si quieres que el texto se ajuste a la línea.

Por defecto, QPainter dibuja el texto con suavizado.

Nota: La posición y se utiliza como línea de base de la fuente.

Véase también ` setFont()` y ` setPen()`.

void QPainter::drawText(const QPoint &position, const QString &text)

Dibuja el texto « text » con la dirección de texto definida actualmente, comenzando por el punto « position ».

Por defecto, QPainter dibuja el texto con suavizado.

Nota: La posición y se utiliza como línea de base de la fuente.

Esta es una función sobrecargada.

Véanse también ` setFont()` y ` setPen()`.

void QPainter::drawText(const QRectF &rectangle, const QString &text, const QTextOption &option = QTextOption())

Dibuja el texto « text » en el objeto « rectangle » especificado, utilizando el objeto « option » para controlar su posición, dirección y orientación. Las opciones indicadas en « option » anulan las establecidas en el propio objeto « QPainter ».

Por defecto, QPainter dibuja el texto con suavizado.

Nota: La coordenada y de rectangle se utiliza como la parte superior de la fuente.

Esta es una función sobrecargada.

Véase también setFont() y setPen().

void QPainter::drawText(int x, int y, const QString &text)

Dibuja el texto dado ` text ` en la posición `(x, y)`, utilizando la dirección de texto definida actualmente por el pintor.

Por defecto, QPainter dibuja el texto con suavizado.

Nota: La posición y se utiliza como línea de base de la fuente.

Esta es una función sobrecargada.

Véase también setFont() y setPen().

void QPainter::drawText(const QRect &rectangle, int flags, const QString &text, QRect *boundingRect = nullptr)

Dibuja el « text » dado dentro del « rectangle » proporcionado, de acuerdo con el « flags » especificado.

El boundingRect (si no es nulo) se establece en el valor que debe tener el rectángulo delimitador para abarcar todo el texto. Por ejemplo, en la siguiente imagen, la línea punteada representa boundingRect tal y como lo calcula la función, y la línea discontinua representa rectangle:

Texto con rectángulos delimitadores
QPainter painter(this);
QFont font = painter.font();
font.setPixelSize(48);
painter.setFont(font);

const QRect rectangle = QRect(0, 0, 100, 50);
QRect boundingRect;
painter.drawText(rectangle, 0, tr("Hello"), &boundingRect);

QPen pen = painter.pen();
pen.setStyle(Qt::DotLine);
painter.setPen(pen);
painter.drawRect(boundingRect.adjusted(0, 0, -pen.width(), -pen.width()));

pen.setStyle(Qt::DashLine);
painter.setPen(pen);
painter.drawRect(rectangle.adjusted(0, 0, -pen.width(), -pen.width()));

Por defecto, QPainter dibuja el texto con suavizado.

Nota: La coordenada y de rectangle se utiliza como la parte superior de la fuente.

Esta es una función sobrecargada.

Véase también « setFont()» y « setPen()».

void QPainter::drawText(const QRectF &rectangle, int flags, const QString &text, QRectF *boundingRect = nullptr)

Dibuja el « text » especificado dentro del « rectangle » proporcionado. El « rectangle », junto con la alineación « flags », define los puntos de anclaje del « text ».

Texto que muestra el Proyecto Qt
QPainter painter(this);
painter.drawText(rect, Qt::AlignCenter, tr("Qt\nProject"));

El boundingRect (si no es nulo) se establece en lo que debería ser el rectángulo delimitador para abarcar todo el texto. Por ejemplo, en la siguiente imagen, la línea punteada representa boundingRect tal y como lo calcula la función, y la línea discontinua representa rectangle:

Texto con rectángulos delimitadores
QPainter painter(this);
QFont font = painter.font();
font.setPixelSize(48);
painter.setFont(font);

const QRect rectangle = QRect(0, 0, 100, 50);
QRect boundingRect;
painter.drawText(rectangle, 0, tr("Hello"), &boundingRect);

QPen pen = painter.pen();
pen.setStyle(Qt::DotLine);
painter.setPen(pen);
painter.drawRect(boundingRect.adjusted(0, 0, -pen.width(), -pen.width()));

pen.setStyle(Qt::DashLine);
painter.setPen(pen);
painter.drawRect(rectangle.adjusted(0, 0, -pen.width(), -pen.width()));

El argumento ` flags ` es una operación OR bit a bit de los siguientes indicadores:

Por defecto, QPainter dibuja el texto con suavizado.

Nota: La coordenada y de ` rectangle ` se utiliza como la parte superior de la fuente.

Esta es una función sobrecargada.

Véase también Qt::AlignmentFlag, Qt::TextFlag, boundingRect() y layoutDirection().

void QPainter::drawText(int x, int y, int width, int height, int flags, const QString &text, QRect *boundingRect = nullptr)

Dibuja el texto « text » dentro del rectángulo con origen en (x, y), width y height.

El argumento boundingRect (si no es nulo) se establece en el valor que debe tener el rectángulo delimitador para que abarque todo el texto. Por ejemplo, en la siguiente imagen, la línea punteada representa boundingRect tal y como lo calcula la función, y la línea discontinua representa el rectángulo definido por x, y, width y height:

Texto con rectángulos delimitadores
QPainter painter(this);
QFont font = painter.font();
font.setPixelSize(48);
painter.setFont(font);

const QRect rectangle = QRect(0, 0, 100, 50);
QRect boundingRect;
painter.drawText(rectangle, 0, tr("Hello"), &boundingRect);

QPen pen = painter.pen();
pen.setStyle(Qt::DotLine);
painter.setPen(pen);
painter.drawRect(boundingRect.adjusted(0, 0, -pen.width(), -pen.width()));

pen.setStyle(Qt::DashLine);
painter.setPen(pen);
painter.drawRect(rectangle.adjusted(0, 0, -pen.width(), -pen.width()));

El argumento « flags » es una operación OR bit a bit de los siguientes indicadores:

Por defecto, QPainter dibuja el texto con suavizado.

Nota: La posición y se utiliza como la parte superior de la fuente.

Esta es una función sobrecargada.

Véase también Qt::AlignmentFlag, Qt::TextFlag, setFont() y setPen().

void QPainter::drawTiledPixmap(const QRectF &rectangle, const QPixmap &pixmap, const QPointF &position = QPointF())

Dibuja un mapa de píxeles en mosaico ( pixmap) dentro del rectángulo dado ( rectangle ), con su origen en el punto dado ( position).

Llamar a drawTiledPixmap() es similar a llamar varias veces a drawPixmap() para rellenar (mosaicar) un área con un mapa de píxeles, pero puede resultar mucho más eficiente dependiendo del sistema de ventanas subyacente.

drawTiledPixmap() producirá el mismo patrón visual de mosaico en pantallas de alta resolución (con devicePixelRatio > 1) que en pantallas de resolución normal. Establece el valor de devicePixelRatio en ` pixmap ` para controlar el tamaño de los mosaicos. Por ejemplo, si se establece en 2, se reduce a la mitad el ancho y la altura de los mosaicos (tanto en pantallas 1x como 2x) y se obtiene una salida de alta resolución en pantallas 2x.

El desplazamiento de « position » se proporciona en píxeles independientes del dispositivo (DIP) con respecto a la esquina superior izquierda de « rectangle ». El « position » se puede utilizar para alinear el patrón repetitivo dentro de « rectangle ».

Véase también drawPixmap().

void QPainter::drawTiledPixmap(const QRect &rectangle, const QPixmap &pixmap, const QPoint &position = QPoint())

Dibuja un pixmap en mosaico, dentro del rectangle especificado, con su origen en el position especificado.

Esta es una función sobrecargada.

void QPainter::drawTiledPixmap(int x, int y, int width, int height, const QPixmap &pixmap, int sx = 0, int sy = 0)

Dibuja un « pixmap » en mosaico en el rectángulo especificado.

(x, y) especifica el punto superior izquierdo del dispositivo de pintura sobre el que se va a dibujar; con los valores dados width y height.

(sx, sy) especifica el origen dentro del rectángulo indicado donde se dibujará el mapa de píxeles. La posición del origen se especifica en píxeles independientes del dispositivo, en relación con (x, y). El valor por defecto es (0, 0).

Se trata de una función sobrecargada.

bool QPainter::end()

Finaliza el proceso de pintura. Se liberan todos los recursos utilizados durante el proceso de pintura. Normalmente no es necesario llamar a esta función, ya que la invoca el destructor.

Devuelve ` true ` si el pintor ya no está activo; en caso contrario, devuelve ` false`.

Véase también begin() y isActive().

void QPainter::endNativePainting()

Restaura el pintor tras ejecutar manualmente comandos de pintura nativos. Permite al pintor restablecer cualquier estado nativo del que dependa antes de llamar a cualquier otro comando del pintor.

Véase también beginNativePainting().

void QPainter::eraseRect(const QRectF &rectangle)

Borra el área situada dentro de la zona especificada rectangle. Equivale a llamar a

fillRect(rectangle, background());

Véase también fillRect().

void QPainter::eraseRect(const QRect &rectangle)

Borra el área situada dentro de la forma dada rectangle.

Se trata de una función sobrecargada.

void QPainter::eraseRect(int x, int y, int width, int height)

Borra el área dentro del rectángulo que tiene como vértices (x, y) con los valores dados de « width » y « height ».

Se trata de una función sobrecargada.

void QPainter::fillPath(const QPainterPath &path, const QBrush &brush)

Rellena el « path » indicado utilizando el « brush » indicado. No se dibuja el contorno.

Como alternativa, puedes especificar un « QColor » en lugar de un « QBrush »; el constructor « QBrush » (que admite un argumento « QColor ») creará automáticamente un pincel de patrón sólido.

Véase también drawPath().

void QPainter::fillRect(const QRectF &rectangle, const QBrush &brush)

Rellena el archivo « rectangle » indicado con el contenido especificado en « brush ».

Como alternativa, puedes especificar un ` QColor ` en lugar de un ` QBrush`; el constructor ` QBrush ` (que toma un argumento ` QColor `) creará automáticamente un pincel de patrón sólido.

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

void QPainter::fillRect(const QRect &rectangle, QGradient::Preset preset)

Rellena el « rectangle » indicado con el degradado especificado « preset ».

Se trata de una función sobrecargada.

void QPainter::fillRect(const QRect &rectangle, Qt::BrushStyle style)

Rellena el objeto « rectangle » indicado con el pincel « style » especificado.

Se trata de una función sobrecargada.

void QPainter::fillRect(const QRect &rectangle, Qt::GlobalColor color)

Rellena el objeto ` rectangle ` dado con el objeto ` color` especificado.

Se trata de una función sobrecargada.

void QPainter::fillRect(const QRect &rectangle, const QBrush &brush)

Rellena el objeto ` rectangle ` dado con el objeto ` brush` especificado.

Se trata de una función sobrecargada.

void QPainter::fillRect(const QRect &rectangle, const QColor &color)

Rellena el ` rectangle ` indicado con el ` color ` especificado.

Se trata de una función sobrecargada.

void QPainter::fillRect(const QRectF &rectangle, QGradient::Preset preset)

Rellena el elemento « rectangle » indicado con el degradado especificado « preset ».

Se trata de una función sobrecargada.

void QPainter::fillRect(const QRectF &rectangle, Qt::BrushStyle style)

Rellena el objeto ` rectangle ` indicado con el pincel ` style ` especificado.

Se trata de una función sobrecargada.

void QPainter::fillRect(const QRectF &rectangle, Qt::GlobalColor color)

Rellena el objeto ` rectangle ` proporcionado con el objeto ` color` especificado.

Se trata de una función sobrecargada.

void QPainter::fillRect(const QRectF &rectangle, const QColor &color)

Rellena el objeto ` rectangle ` indicado con el objeto ` color ` especificado.

Se trata de una función sobrecargada.

void QPainter::fillRect(int x, int y, int width, int height, QGradient::Preset preset)

Rellena el rectángulo que comienza en (x, y) con los valores dados width y height, utilizando el degradado dado preset.

Esta es una función sobrecargada.

void QPainter::fillRect(int x, int y, int width, int height, Qt::BrushStyle style)

Rellena el rectángulo que comienza en (x, y) con los valores width y height, utilizando el pincel style especificado.

Se trata de una función sobrecargada.

void QPainter::fillRect(int x, int y, int width, int height, Qt::GlobalColor color)

Rellena el rectángulo que comienza en (x, y) con los valores dados width y height, utilizando el valor dado color.

Se trata de una función sobrecargada.

void QPainter::fillRect(int x, int y, int width, int height, const QBrush &brush)

Rellena el rectángulo que comienza en (x, y) con los valores dados width y height, utilizando el valor dado brush.

Se trata de una función sobrecargada.

void QPainter::fillRect(int x, int y, int width, int height, const QColor &color)

Rellena el rectángulo que comienza en (x, y) con los valores width y height, utilizando color.

Se trata de una función sobrecargada.

const QFont &QPainter::font() const

Devuelve la fuente actualmente configurada que se utiliza para dibujar texto.

Véase también setFont(), drawText() y Settings.

QFontInfo QPainter::fontInfo() const

Devuelve la información de la fuente del pintor si este está activo. De lo contrario, el valor devuelto es indefinido.

Véase también font(), isActive() y Settings.

QFontMetrics QPainter::fontMetrics() const

Devuelve las métricas de fuente del pintor si este está activo. De lo contrario, el valor devuelto es indefinido.

Véase también font(), isActive() y Settings.

bool QPainter::hasClipping() const

Devuelve true si se ha configurado el recorte; en caso contrario, devuelve false.

Véanse también setClipping() y Clipping.

bool QPainter::isActive() const

Devuelve « true » si se ha llamado a « begin()» y aún no se ha llamado a « end()»; en caso contrario, devuelve « false ».

Véase también begin() y QPaintDevice::paintingActive().

Qt::LayoutDirection QPainter::layoutDirection() const

Devuelve la dirección de maquetación que utiliza el «painter» al dibujar texto.

Véase también QTextOption::textDirection(), setLayoutDirection(), drawText() y Settings.

qreal QPainter::opacity() const

Devuelve la opacidad del pintor. El valor por defecto es 1.

Véase también setOpacity().

QPaintEngine *QPainter::paintEngine() const

Devuelve el motor de pintura en el que está trabajando actualmente el pintor, si este está activo; en caso contrario, devuelve 0.

Véase también isActive().

const QPen &QPainter::pen() const

Devuelve el lápiz actual del pintor.

Véase también setPen() y Settings.

QPainter::RenderHints QPainter::renderHints() const

Devuelve un indicador que especifica las sugerencias de representación establecidas para este pintor.

Véase también setRenderHints(), testRenderHint() y Rendering Quality.

void QPainter::resetTransform()

Restablece cualquier transformación realizada mediante las funciones translate(), scale(), shear(), rotate(), setWorldTransform(), setViewport() y setWindow().

Véase también Coordinate Transformations.

void QPainter::restore()

Restaura el estado actual del pintor (extrae un estado guardado de la pila).

Véase también save().

void QPainter::rotate(qreal angle)

Gira el sistema de coordenadas en el sentido de las agujas del reloj. El parámetro « angle » indicado se expresa en grados.

Véase también setWorldTransform() y Coordinate Transformations.

void QPainter::save()

Guarda el estado actual del pintor (empuja el estado a una pila). Una llamada a `save()` debe ir seguida de la correspondiente llamada a ` restore()`; la función ` end()` desmonta la pila.

Véase también restore().

void QPainter::scale(qreal sx, qreal sy)

Escala el sistema de coordenadas según (sx, sy).

Véase también setWorldTransform() y Coordinate Transformations.

void QPainter::setBackground(const QBrush &brush)

Establece el pincel de fondo del pintor en el valor indicado brush.

El pincel de fondo es el que se utiliza para rellenar al dibujar texto opaco, líneas punteadas e imágenes de mapa de bits. El pincel de fondo no tiene ningún efecto en el modo de fondo transparente (que es el predeterminado).

Véase también background(), setBackgroundMode() y Settings.

void QPainter::setBackgroundMode(Qt::BGMode mode)

Establece el modo de fondo del pintor en el valor indicado mode

Qt::TransparentMode (el valor por defecto) dibuja líneas punteadas y texto sin establecer los píxeles de fondo. Qt::OpaqueMode rellena estos espacios con el color de fondo actual.

Ten en cuenta que, para dibujar un mapa de bits o un mapa de píxeles de forma transparente, debes utilizar QPixmap::setMask().

Véase también backgroundMode(), setBackground() y Settings.

void QPainter::setBrush(const QBrush &brush)

Establece el pincel del pintor en el valor indicado brush.

El pincel del pintor define cómo se rellenan las formas.

Véanse también brush() y Settings.

[since 6.11] void QPainter::setBrush(QBrush &&brush)

Esta es una función sobrecargada.

Esta función se introdujo en Qt 6.11.

[since 6.9] void QPainter::setBrush(QColor color)

Establece el pincel del pintor como un pincel de color liso con el valor especificado en ` color`.

Esta es una función sobrecargada.

Esta función se introdujo en Qt 6.9.

void QPainter::setBrush(Qt::BrushStyle style)

Establece el color del pincel del pintor en negro y la propiedad « style » especificada.

Esta es una función sobrecargada.

[since 6.9] void QPainter::setBrush(Qt::GlobalColor color)

Establece el pincel del pintor como un pincel de color liso con el valor especificado en « color ».

Esta es una función sobrecargada.

Esta función se introdujo en Qt 6.9.

void QPainter::setBrushOrigin(const QPointF &position)

Establece el origen del pincel en position.

El origen del pincel especifica la coordenada (0, 0) del pincel del pintor.

Ten en cuenta que, aunque en Qt 3 era necesario utilizar brushOrigin() para que un widget adoptara el fondo de su elemento padre, esto ya no es así, ya que el pintor de Qt 4 no dibuja el fondo a menos que se le indique explícitamente que lo haga estableciendo la propiedad autoFillBackground del widget en true.

Véase también brushOrigin() y Settings.

void QPainter::setBrushOrigin(const QPoint &position)

Establece el origen del pincel en el punto indicado position.

Esta es una función sobrecargada.

void QPainter::setBrushOrigin(int x, int y)

Establece el origen del pincel en el punto (x, y).

Esta es una función sobrecargada.

void QPainter::setClipPath(const QPainterPath &path, Qt::ClipOperation operation = Qt::ReplaceClip)

Activa el recorte y establece la ruta de recorte para el pintor en el valor dado path, con el recorte operation.

Ten en cuenta que la ruta de recorte se especifica en coordenadas lógicas (del pintor).

Véanse también clipPath(), clipRegion() y Clipping.

void QPainter::setClipRect(const QRectF &rectangle, Qt::ClipOperation operation = Qt::ReplaceClip)

Activa el recorte y establece la región de recorte en el rectángulo de recorte ( rectangle ) indicado, utilizando el rectángulo de recorte ( operation) especificado. La operación predeterminada consiste en sustituir el rectángulo de recorte actual.

Ten en cuenta que el rectángulo de recorte se especifica en coordenadas lógicas (de pintor).

Véanse también clipRegion(), setClipping() y Clipping.

void QPainter::setClipRect(int x, int y, int width, int height, Qt::ClipOperation operation = Qt::ReplaceClip)

Activa el recorte y establece la región de recorte como el rectángulo que comienza en (x, y) con los valores indicados para width y height.

void QPainter::setClipRect(const QRect &rectangle, Qt::ClipOperation operation = Qt::ReplaceClip)

Activa el recorte y establece la región de recorte en el « rectangle » indicado utilizando el «clip operation » indicado.

Esta es una función sobrecargada.

void QPainter::setClipRegion(const QRegion &region, Qt::ClipOperation operation = Qt::ReplaceClip)

Establece la región de recorte en el « region » indicado utilizando el « operation » de recorte especificado. La operación de recorte predeterminada consiste en sustituir la región de recorte actual.

Ten en cuenta que la región de recorte se indica en coordenadas lógicas.

Véanse también clipRegion(), setClipRect() y Clipping.

void QPainter::setClipping(bool enable)

Activa el recorte si « enable » es «true», o desactiva el recorte si « enable » es «false».

Véase también hasClipping() y Clipping.

void QPainter::setCompositionMode(QPainter::CompositionMode mode)

Establece el modo de composición en el valor dado mode.

Advertencia: Solo un « QPainter » que opere sobre un « QImage » es compatible con todos los modos de composición. Los modos «RasterOp» son compatibles con X11 tal y como se describe en « compositionMode()».

Véase también compositionMode().

void QPainter::setFont(const QFont &font)

Establece la fuente del pintor en la especificada en font.

Esta fuente será utilizada por las funciones drawText() posteriores. El color del texto es el mismo que el del lápiz.

Si se establece una fuente que no está disponible, Qt busca una que se acerque lo más posible. La función ` font()` devolverá la fuente establecida mediante `setFont()`, mientras que ` fontInfo()` devuelve la fuente que se está utilizando realmente (que puede ser la misma).

Véase también font(), drawText() y Settings.

void QPainter::setLayoutDirection(Qt::LayoutDirection direction)

Establece la dirección de maquetación que utiliza el «painter» al dibujar texto, en la dirección especificada direction.

El valor predeterminado es ` Qt::LayoutDirectionAuto`, lo que determinará implícitamente la dirección a partir del texto dibujado.

Véase también QTextOption::setTextDirection(), layoutDirection(), drawText() y Settings.

void QPainter::setOpacity(qreal opacity)

Establece la opacidad del pincel en opacity. El valor debe estar comprendido entre 0,0 y 1,0, donde 0,0 corresponde a una transparencia total y 1,0 a una opacidad total.

La opacidad establecida para el pincel se aplica a cada operación de dibujo por separado. Rellenar una forma y dibujar su contorno se consideran operaciones de dibujo independientes.

Véase también opacity().

void QPainter::setPen(const QPen &pen)

Establece el lápiz del pintor como el « pen » indicado.

El pen define cómo se dibujan las líneas y los contornos, y también define el color del texto.

Véase también « pen()» y « Settings ».

[since 6.11] void QPainter::setPen(QPen &&pen)

Esta es una función sobrecargada.

Esta función se introdujo en Qt 6.11.

void QPainter::setPen(Qt::PenStyle style)

Establece el lápiz del pintor con el « style » indicado, un ancho de 1 y el color negro.

Esta es una función sobrecargada.

void QPainter::setPen(const QColor &color)

Establece el lápiz del pintor con el estilo « Qt::SolidLine », un ancho de 1 y el valor especificado « color ».

Esta es una función sobrecargada.

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

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

Véanse también setRenderHints(), renderHints() y Rendering Quality.

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

Establece las indicaciones de renderizado hints en el pintor si on es verdadero; en caso contrario, borra las indicaciones de renderizado.

Véase también setRenderHint(), renderHints() y Rendering Quality.

void QPainter::setTransform(const QTransform &transform, bool combine = false)

Establece la matriz de transformación global. Si combine es verdadero, el transform especificado se combina con la matriz actual; en caso contrario, sustituye a la matriz actual.

Véase también transform() y setWorldTransform().

void QPainter::setViewTransformEnabled(bool enable)

Habilita las transformaciones de vista si enable es verdadero, o las deshabilita si enable es falso.

Véase también viewTransformEnabled() y Conversión de ventana a ventana de visualización.

void QPainter::setViewport(const QRect &rectangle)

Establece el rectángulo de la ventana de visualización del pintor en el ` rectangle` indicado y habilita las transformaciones de vista.

El rectángulo de la ventana de visualización forma parte de la transformación de la vista. La ventana de visualización especifica el sistema de coordenadas del dispositivo. Su equivalente, la función window(), especifica el sistema de coordenadas lógico.

El rectángulo de la ventana de visualización predeterminado es el mismo que el rectángulo del dispositivo.

Véase también ` viewport()`, ` viewTransformEnabled()` y «Conversión entre ventana y área de visualización».

void QPainter::setViewport(int x, int y, int width, int height)

Establece el rectángulo de la ventana de visualización del pintor como el rectángulo que comienza en (x, y) con los valores dados de width y height.

Esta es una función sobrecargada.

void QPainter::setWindow(const QRect &rectangle)

Establece la ventana del pintor en el sistema de coordenadas de la ventana ( rectangle) indicado y habilita las transformaciones de vista.

El rectángulo de la ventana forma parte de la transformación de la vista. La ventana especifica el sistema de coordenadas lógico. Su contraparte, la función viewport(), especifica el sistema de coordenadas del dispositivo.

El rectángulo de ventana por defecto es el mismo que el rectángulo del dispositivo.

Véase también ` window()`, ` viewTransformEnabled()` y «Conversión entre ventana y ventana de visualización».

void QPainter::setWindow(int x, int y, int width, int height)

Establece la ventana del pintor en el rectángulo que comienza en (x, y) y los valores proporcionados width y height.

Esta es una función sobrecargada.

void QPainter::setWorldMatrixEnabled(bool enable)

Habilita las transformaciones si enable es verdadero, o deshabilita las transformaciones si enable es falso. La matriz de transformación del mundo no se modifica.

Véanse también worldMatrixEnabled(), worldTransform() y Coordinate Transformations.

void QPainter::setWorldTransform(const QTransform &matrix, bool combine = false)

Establece la matriz de transformación global. Si « combine » es «true», la matriz « matrix » especificada se combina con la matriz actual; en caso contrario, sustituye a la matriz actual.

Véanse también worldTransform(), transform() y setTransform().

void QPainter::shear(qreal sh, qreal sv)

Corta el sistema de coordenadas por (sh, sv).

Véanse también setWorldTransform() y Coordinate Transformations.

void QPainter::strokePath(const QPainterPath &path, const QPen &pen)

Dibuja el contorno (trazos) de la ruta path con el lápiz especificado por pen

Véase también fillPath() y Drawing.

bool QPainter::testRenderHint(QPainter::RenderHint hint) const

Devuelve « true » si « hint » está activado; en caso contrario, devuelve « false ».

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

const QTransform &QPainter::transform() const

Alias de worldTransform(). Devuelve la matriz de transformación global.

Véase también setTransform() y worldTransform().

void QPainter::translate(const QPointF &offset)

Traslada el sistema de coordenadas según la offset indicada; es decir, se suma a los puntos la offset indicada.

Véanse también setWorldTransform() y Coordinate Transformations.

void QPainter::translate(const QPoint &offset)

Traslada el sistema de coordenadas según el valor dado offset.

Esta es una función sobrecargada.

void QPainter::translate(qreal dx, qreal dy)

Traslada el sistema de coordenadas mediante el vector (dx, dy).

Esta es una función sobrecargada.

bool QPainter::viewTransformEnabled() const

Devuelve ` true ` si la transformación de vista está habilitada; en caso contrario, devuelve `false`.

Véase también ` setViewTransformEnabled()` y ` worldTransform()`.

QRect QPainter::viewport() const

Devuelve el rectángulo de la ventana gráfica.

Véase también setViewport() y setViewTransformEnabled().

QRect QPainter::window() const

Devuelve el rectángulo de la ventana.

Véase también setWindow() y setViewTransformEnabled().

bool QPainter::worldMatrixEnabled() const

Devuelve « true » si la transformación del mundo está habilitada; en caso contrario, devuelve «false».

Véase también setWorldMatrixEnabled(), worldTransform() y Sistema de coordenadas.

const QTransform &QPainter::worldTransform() const

Devuelve la matriz de transformación del mundo.

Véase también setWorldTransform().

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