QPainter Class

Documentación de Funciones Miembro

QPainter::QPainter()

Construye un pintor.

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

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

Construye un pintor que comienza a pintar la pintura device inmediatamente.

Este constructor es conveniente para pintores de corta duración, por ejemplo en un QWidget::paintEvent() y debería usarse sólo una vez. El constructor llama a begin() por ti y el destructor de QPainter llama automáticamente a end().

Aquí tienes un ejemplo usando begin() y end():

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

El mismo ejemplo usando este constructor:

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

Dado que el constructor no puede proporcionar información cuando la inicialización del pintor ha fallado deberías usar begin() y end() para pintar en dispositivos externos, por ejemplo impresoras.

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

[noexcept] QPainter::~QPainter()

Destruye al 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 la pintura device y devuelve true si tiene éxito; en caso contrario devuelve false.

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

Los errores que pueden ocurrir son problemas serios, 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

Tenga en cuenta que la mayoría de las veces, puede utilizar uno de los constructores en lugar de begin(), y que end() se realiza automáticamente en la destrucción.

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

void QPainter::beginNativePainting()

Limpia el canal de pintura y prepara al usuario para emitir comandos directamente al contexto gráfico subyacente. Debe ir seguido de una llamada a endNativePainting().

Ten en cuenta que sólo los estados que cambie el motor de pintura subyacente se restablecerán a sus respectivos estados por defecto. Los estados que restablecemos pueden cambiar de una versión a otra. Los siguientes estados se restablecen actualmente en el motor OpenGL 2:

• la mezcla está desactivada
• las pruebas de profundidad, stencil 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 vuelven a sus valores por defecto
• la máscara de estarcido, el funcionamiento del 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 modo de polígono OpenGL es cambiado por el usuario dentro de un bloque beginNativePaint()/endNativePainting(), no será reseteado al estado por defecto por endNativePainting(). Este es un ejemplo que muestra la mezcla de comandos de pintor 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 text tal y como aparecerá cuando se dibuje dentro del rectangle dado con el flags especificado utilizando el font() actualmente establecido; es decir, la función le indica dónde dibujará la función drawText() cuando se le den 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 un bitwise OR de las siguientes banderas:

• Qt::AlignLeft
• Qt::AlignRight
• Qt::AlignHCenter
• Qt::AlignTop
• Qt::AlignBottom
• Qt::AlignVCenter
• Qt::AlignCenter
• Qt::TextSingleLine
• Qt::TextExpandTabs
• Qt::TextShowMnemonic
• Qt::TextWordWrap
• Qt::TextIncludeTrailingSpaces

Si varias de las banderas de alineación horizontal o varias de las banderas de alineación vertical están activadas, la alineación resultante es indefinida.

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

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

Devuelve el rectángulo delimitador de text tal y como aparecerá cuando se dibuje dentro del rectangle dado con el flags especificado utilizando el font() actualmente establecido.

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

En lugar de especificar las banderas como un OR a nivel de bits de Qt::AlignmentFlag y Qt::TextFlag, esta función sobrecargada toma un argumento option. La clase QTextOption proporciona una descripción de las propiedades generales del texto enriquecido.

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 text dado tal y como aparecerá cuando se dibuje dentro del rectángulo que comienza en el punto (x, y) con anchura w y altura h.

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. Es preferible 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 clip actual si hay un clip; en caso contrario devuelve un rectángulo vacío. Tenga en cuenta que la región de recorte se da 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.

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

QRegion QPainter::clipRegion() const

Devuelve la región de recorte definida actualmente. Tenga en cuenta que la región de recorte se da en coordenadas lógicas.

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

QTransform QPainter::combinedTransform() const

Devuelve la matriz de transformación que combina la ventana/puerta de vista actual y la transformación global.

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 de coordenadas lógicas a coordenadas de dispositivo del dispositivo de pintado dependiente de la plataforma.

Esta función sólo es necesaria cuando se utilizan comandos de pintado de plataforma en el manejador dependiente de plataforma (Qt::HANDLE), y la plataforma no realiza transformaciones de forma nativa.

El enum QPaintEngine::PaintEngineFeature puede ser consultado para determinar si la plataforma realiza las transformaciones o no.

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

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

Dibuja el arco definido por los campos rectangle, startAngle y spanAngle.

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 significan el sentido contrario a las agujas del reloj, mientras que los valores negativos significan el sentido de las agujas del reloj. Cero grados está en la posición de las 3 en punto.

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 rectangle, startAngle y spanAngle.

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

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

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

Dibuja la cuerda definida por rectangle, startAngle y spanAngle. La cuerda se rellena con la dirección brush() actual.

StartAngle y spanAngle deben especificarse en 1/16 de grado, es decir, un círculo completo equivale a 5760 (16 * 360). Los valores positivos para los ángulos significan el sentido contrario a las agujas del reloj, mientras que los valores negativos significan el sentido de las agujas del reloj. Cero grados está en la posición de las 3 en punto.

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éase también drawArc(), drawPie() y Sistema de coordenadas.

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

Dibuja la cuerda definida por rectangle, startAngle y spanAngle.

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

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

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

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

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 al último punto, y el polígono se rellena con el brush actual (). Si el polígono suministrado no es convexo, es decir, 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.

void QPainter::drawConvexPolygon(const QPolygonF &polygon)

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

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

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

void QPainter::drawEllipse(const QRectF &rectangle)

Dibuja la elipse definida por rectangle.

Una elipse rellena tiene un tamaño de rectangle.size(). Una elipse trazada tiene un tamaño de rectangle.size() más el ancho del lápiz.

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 la dirección rectangle.

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

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

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

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

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

Dibuja la elipse definida por el rectángulo que comienza en (x, y) con los valores width y height.

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

Dibuja los glifos representados por glyphs en position. position da el borde de la línea de base para la cadena de glifos. Los glifos se obtendrán de la fuente seleccionada en glyphs y en los desplazamientos dados por las posiciones en glyphs.

Véase 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 porción rectangular source del image dado en el rectángulo target en el dispositivo de pintura.

Si es necesario modificar la imagen para que quepa en un resultado de menor resolución (por ejemplo, convertir de 32 bits a 8 bits), utilice flags para especificar cómo prefiere que se haga.

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éase también drawPixmap() y QImage::devicePixelRatio().

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

Dibuja el image dado en el point dado.

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

Dibuja el image dado en el point dado.

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

Dibuja el image dado en el rectangle dado.

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

Dibuja el image dado en el rectangle dado.

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

Dibuja la porción rectangular source del image dado con su origen en el point dado.

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

Dibuja la porción rectangular source del image dado con su origen en el point dado.

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

Dibuja la porción rectangular source del image dado en el rectángulo target en el dispositivo de pintura.

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

(x, y) especifica el punto superior izquierdo en el dispositivo de pintura sobre el que se va a dibujar. (sx, sy) especifica el punto superior izquierdo en 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. Por defecto, (0, 0) (y negativo) significa todo el camino hasta la parte inferior derecha de la imagen.

void QPainter::drawLine(const QLineF &line)

Dibuja una línea definida por line.

QLineF line(10.0, 80.0, 90.0, 20.0); QPainter painter(this); painter.drawLine(line);

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

void QPainter::drawLine(const QLine &line)

Dibuja una línea definida por line.

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

Dibuja una línea desde p1 hasta p2.

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

Dibuja una línea desde p1 hasta p2.

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

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

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

Dibuja las primeras líneas de lineCount en el array 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 la pluma y el pincel actuales.

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

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

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

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

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.

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

Dibuja las primeras lineCount líneas en el array lines usando el lápiz actual.

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

Dibuja las primeras lineCount líneas en el array pointPairs usando el lápiz actual.

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 al menos lineCount * 2.

void QPainter::drawPath(const QPainterPath &path)

Dibuja el pintor dado path usando el lápiz actual para el contorno y el pincel actual para el relleno.

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éase también el ejemplo Trazados de pintor y el ejemplo Deformación vectorial.

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

Reproduce el picture dado en el point dado.

La clase QPicture es un dispositivo pintor que graba y replica comandos QPainter. Una imagen serializa los comandos del pintor a un dispositivo IO en un formato independiente de la plataforma. Todo lo que se puede pintar en un widget o pixmap también se puede almacenar en una imagen.

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

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 la dirección picture en la dirección point.

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

Dibuja el picture dado en el punto (x, y).

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

Dibuja una tarta definida por los campos rectangle, startAngle y spanAngle.

La tarta se rellena con el brush() actual.

StartAngle y spanAngle deben especificarse en 1/16 de grado, es decir, un círculo completo equivale a 5760 (16 * 360). Los valores positivos para los ángulos significan el sentido contrario a las agujas del reloj, mientras que los valores negativos significan el sentido de las agujas del reloj. Cero grados está en la posición de las 3 en punto.

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 una tarta definida por los campos rectangle, startAngle y spanAngle.

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

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

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

Dibuja la porción rectangular source del pixmap dado en el target dado en el dispositivo de pintura.

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 que están "puestos" usando el color de las plumas. Si backgroundMode es Qt::OpaqueMode, los bits "no establecidos" se dibujan usando el color del pincel de fondo; si backgroundMode es Qt::TransparentMode, los bits "no establecidos" son transparentes. No es posible dibujar mapas de bits con colores de degradado o textura.

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

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

Dibuja el pixmap dado con su origen en el point dado.

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

Dibuja el pixmap dado con su origen en el point dado.

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

Dibuja el pixmap dado en el rectangle dado.

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

Dibuja la porción rectangular source del pixmap dado con su origen en el point dado.

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

Dibuja la porción rectangular source del pixmap dado con su origen en el point dado.

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

Dibuja la porción rectangular source del pixmap dado en el target dado en el dispositivo de pintura.

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

Dibuja el pixmap dado en la posición (x, y).

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

Dibuja el pixmap en el rectángulo en la posición (x, y) con los width y height dados.

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

Dibuja un pixmap en (x, y) copiando una parte del pixmap dado en el dispositivo de pintura.

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

(sw, sh) especifica el tamaño del mapa de píxeles que se va a dibujar. El valor por defecto, (0, 0) (y negativo) significa todo el camino hasta la parte inferior derecha del pixmap.

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

Dibuja la porción rectangular con el origen (sx, sy), anchura sw y altura sh, del pixmap dado, 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 pixmap y se ajusta por el offset sx/sy;

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 sub-rectángulo de pixmap, en múltiples posiciones con diferente escala, rotación y opacidad. fragments es una matriz de elementos fragmentCount que especifica los parámetros utilizados para dibujar cada fragmento de pixmap. El parámetro hints puede utilizarse para pasar pistas de dibujo.

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

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

void QPainter::drawPoint(const QPointF &position)

Dibuja un único punto en la dirección 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 la dirección position utilizando el color del lápiz actual.

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

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

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

Dibuja los primeros pointCount puntos en el array points usando 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.

void QPainter::drawPoints(const QPolygonF &points)

Dibuja los puntos del vector points.

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

Dibuja los primeros pointCount puntos en el array points usando el color del lápiz actual.

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

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

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 al último punto, 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 sinuoso. Si fillRule es Qt::OddEvenFill, el polígono se rellena utilizando el algoritmo de relleno par-impar. Véase Qt::FillRule para 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 la dirección points utilizando la regla de relleno fillRule.

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

Dibuja el polígono definido por la dirección points utilizando la regla de relleno fillRule.

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

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

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.

Observe 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 points utilizando el lápiz actual.

void QPainter::drawPolyline(const QPolygonF &points)

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

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

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

void QPainter::drawRect(const QRectF &rectangle)

Dibuja el rectangle actual con la pluma y el pincel actuales.

Un rectángulo relleno tiene un tamaño de rectangle.size(). Un rectángulo trazado tiene un tamaño de rectangle.size() más el ancho de la pluma.

QRectF rectangle(10.0, 20.0, 80.0, 60.0); QPainter painter(this); painter.drawRect(rectangle);

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

void QPainter::drawRect(const QRect &rectangle)

Dibuja el rectangle actual con la pluma y el pincel actuales.

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

Dibuja un rectángulo con la esquina superior izquierda en (x, y) y con los valores width y height.

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

Dibuja el primer rectCount del rectangles dado utilizando el lápiz y el pincel actuales.

Véase también drawRect().

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

Dibuja la dirección rectangles utilizando el lápiz y el pincel actuales.

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

Dibuja la dirección rectangles utilizando el lápiz y el pincel actuales.

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

Dibuja el primer rectCount del rectangles dado usando la pluma y el pincel actuales.

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

Dibuja el rectángulo dado 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 de la anchura y altura del rectángulo respectivamente, y deben estar en el rango de 0.0 a 100.0.

Un rectángulo relleno tiene un tamaño de rect.size(). Un rectángulo trazado tiene un tamaño de rect.size() más el ancho del lápiz.

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.

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

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

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

Dibuja el texto staticText en la dirección topLeftPosition.

El texto se dibujará utilizando el tipo de letra y la transformación establecidos en el pintor. Si el tipo de letra y/o la transformación establecidos en el pintor son diferentes de los utilizados para inicializar el diseño de QStaticText, entonces el diseño tendrá que ser recalculado. Utilice QStaticText::prepare() para inicializar staticText con el tipo de letra y la transformación con los que se dibujará posteriormente.

Si topLeftPosition no es la misma que cuando se inicializó staticText, o cuando se dibujó por última vez, entonces habrá una ligera sobrecarga al traducir el texto a su nueva posición.

Véase también QStaticText.

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

Dibuja el staticText en el topLeftPosition.

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

Dibuja el staticText en las coordenadas left y top.

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

Dibuja el text dado con la dirección de texto definida actualmente, comenzando en el position dado.

Esta función no maneja el carácter de nueva línea (\n), ya que no puede dividir el texto en múltiples líneas, y no puede mostrar el carácter de nueva línea. Use la sobrecarga QPainter::drawText() que toma un rectángulo en su lugar si quiere dibujar múltiples líneas de texto con el carácter de nueva línea, o si quiere que el texto sea envuelto.

Por defecto, QPainter dibuja el texto con anti-aliasing.

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

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

Dibuja el text dado con la dirección de texto definida actualmente, comenzando en el position dado.

Por defecto, QPainter dibuja el texto con suavizado.

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

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

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

Por defecto, QPainter dibuja el texto con suavizado.

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

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

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

Por defecto, QPainter dibuja el texto con anti-aliasing.

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 ajusta a lo que debe ser el rectángulo delimitador para encerrar todo el texto. Por ejemplo, en la siguiente imagen, la línea de puntos representa boundingRect tal y como lo calcula la función, y la línea discontinua representa rectangle:

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.

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

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

Dibuja el text dado dentro del rectangle proporcionado. El rectangle junto con la alineación flags define las anclas para el text.

QPainter painter(this); painter.drawText(rect, Qt::AlignCenter, tr("Qt\nProject"));

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

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 un OR a nivel de bits de los siguientes indicadores:

• Qt::AlignLeft
• Qt::AlignRight
• Qt::AlignHCenter
• Qt::AlignJustify
• Qt::AlignTop
• Qt::AlignBottom
• Qt::AlignVCenter
• Qt::AlignCenter
• Qt::TextDontClip
• Qt::TextSingleLine
• Qt::TextExpandTabs
• Qt::TextShowMnemonic
• Qt::TextWordWrap
• Qt::TextIncludeTrailingSpaces

Por defecto, QPainter dibuja el texto con suavizado.

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 (x, y), width y height.

boundingRect (si no es nulo) se ajusta a lo que debe ser el rectángulo delimitador para encerrar todo el texto. Por ejemplo, en la siguiente imagen, la línea de puntos 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:

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 un OR a nivel de bits de los siguientes indicadores:

• Qt::AlignLeft
• Qt::AlignRight
• Qt::AlignHCenter
• Qt::AlignJustify
• Qt::AlignTop
• Qt::AlignBottom
• Qt::AlignVCenter
• Qt::AlignCenter
• Qt::TextSingleLine
• Qt::TextExpandTabs
• Qt::TextShowMnemonic
• Qt::TextWordWrap

Por defecto, QPainter dibuja el texto con suavizado.

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 mosaico pixmap, dentro del rectangle dado con su origen en el position dado.

Llamar a drawTiledPixmap() es similar a llamar a drawPixmap() varias veces para rellenar (embaldosar) un área con un pixmap, pero es potencialmente mucho más eficiente dependiendo del sistema de ventanas subyacente.

drawTiledPixmap() producirá el mismo patrón visual de mosaico en pantallas de alta ppp (con devicePixelRatio > 1), en comparación con pantallas de ppp normales. Establezca el devicePixelRatio en pixmap para controlar el tamaño del mosaico. Por ejemplo, si se establece en 2, se reduce a la mitad la anchura y la altura del mosaico (tanto en pantallas 1x como 2x) y se obtiene un resultado de alta resolución en pantallas 2x.

El desplazamiento de position se proporciona en píxeles independientes del dispositivo en relación con la esquina superior izquierda de rectangle. position se puede utilizar para alinear el patrón de repetición dentro de rectangle.

Véase también drawPixmap().

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

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

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

Dibuja un mosaico pixmap en el rectángulo especificado.

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

(sx, sy) especifica el origen dentro del rectángulo especificado donde se dibujará el pixmap. La posición del origen se especifica en píxeles independientes del dispositivo relativos a (x, y). El valor por defecto es (0, 0).

bool QPainter::end()

Finaliza el pintado. Cualquier recurso utilizado mientras se pinta se libera. Normalmente no es necesario llamar a esto ya que es llamado por 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 después de emitir manualmente comandos de pintura nativos. Permite al pintor restaurar cualquier estado nativo del que dependa antes de llamar a cualquier otro comando de pintado.

Véase también beginNativePainting().

void QPainter::eraseRect(const QRectF &rectangle)

Borra el área dentro de la dirección rectangle. Equivale a llamar a

fillRect(rectangle, background());

Véase también fillRect().

void QPainter::eraseRect(const QRect &rectangle)

Borra el área dentro de la dirección rectangle.

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

Borra el área dentro del rectángulo que empieza en (x, y) con los width y height dados.

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

Rellena la dirección path utilizando la dirección brush. El contorno no se dibuja.

Alternativamente, puede 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 drawPath().

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

Rellena el rectangle dado con el brush especificado.

Alternativamente, puede 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 dado con el gradiente especificado preset.

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

Rellena el rectangle dado con el pincel style especificado.

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

Rellena el rectangle dado con el color especificado.

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

Rellena el rectangle dado con el brush especificado.

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

Rellena el rectangle dado con el color especificado.

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

Rellena el rectangle dado con el gradiente especificado preset.

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

Rellena el rectangle dado con el pincel style especificado.

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

Rellena el rectangle dado con el color especificado.

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

Rellena el rectangle dado con el color especificado.

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, usando el gradiente dado preset.

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 datos width y height, utilizando el pincel style especificado.

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 datos width y height, utilizando el dato color.

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 datos width y height, utilizando el dato brush.

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 datos width y height, utilizando el dato color.

const QFont &QPainter::font() const

Devuelve la fuente actualmente utilizada 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 el pintor está activo. En caso contrario, el valor devuelto es indefinido.

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

QFontMetrics QPainter::fontMetrics() const

Devuelve la métrica de la fuente para el pintor si el pintor está activo. En caso contrario, el valor devuelto es indefinido.

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

bool QPainter::hasClipping() const

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

Véase 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 trazado utilizada por el pintor 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 el pintor está operando actualmente si el pintor está activo; en caso contrario 0.

Véase también isActive().

const QPen &QPainter::pen() const

Devuelve la pluma actual del pintor.

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

QPainter::RenderHints QPainter::renderHints() const

Devuelve una bandera que especifica las sugerencias de renderizado establecidas para este pintor.

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

void QPainter::resetTransform()

Restablece las transformaciones realizadas con translate(), scale(), shear(), rotate(), setWorldTransform(), setViewport() y setWindow().

Véase también Coordinate Transformations.

void QPainter::restore()

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

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 dado angle está en grados.

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

void QPainter::save()

Guarda el estado actual del pintor (coloca el estado en una pila). Un save() debe ir seguido del correspondiente restore(); la función end() desenrolla la pila.

Véase también restore().

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

Escala el sistema de coordenadas en (sx, sy).

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

void QPainter::setBackground(const QBrush &brush)

Establece el pincel de fondo del pintor en la dirección brush.

El pincel de fondo es el pincel que se rellena al dibujar texto opaco, líneas punteadas y mapas de bits. El pincel de fondo no tiene 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 dado mode

Qt::TransparentMode (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.

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

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

void QPainter::setBrush(const QBrush &brush)

Establece el pincel del pintor en la dirección brush.

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

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

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

Esta función se introdujo en Qt 6.11.

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

Establece el pincel del pintor en un pincel sólido con la dirección color especificada.

Esta función se introdujo en Qt 6.9.

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

Establece el pincel de pintor en color negro y en la dirección style especificada.

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

Establece el pincel del pintor en un pincel sólido con la dirección color especificada.

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 mientras que brushOrigin() era necesario para adoptar el fondo del padre para un widget en Qt 3, esto ya no es así ya que el pintor de Qt 4 no pinta el fondo a menos que se lo indiques explícitamente estableciendo la propiedad autoFillBackground del widget a true.

Ver también brushOrigin() y Settings.

void QPainter::setBrushOrigin(const QPoint &position)

Establece el origen del pincel en la dirección position.

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

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

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

Activa el recorte y establece la ruta de recorte para el pintor en la dirección path, con el clip operation.

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

Véase 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 la dirección rectangle utilizando la dirección de recorte operation. La operación por defecto es reemplazar el rectángulo de recorte actual.

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

Véase 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 en el rectángulo que comienza en (x, y) con los valores 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 la dirección rectangle utilizando la dirección de recorte operation.

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

Establece la región de recorte en la dirección region utilizando el clip especificado operation. La operación de clip por defecto es reemplazar la región de clip actual.

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

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

void QPainter::setClipping(bool enable)

Activa el recorte si enable es verdadero, o lo desactiva si enable es falso.

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

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

Establece el modo de composición en la dirección mode.

Véase también compositionMode().

void QPainter::setFont(const QFont &font)

Establece el tipo de letra del pintor en font.

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

Si estableces un tipo de letra que no está disponible, Qt encuentra uno similar. font La función fontInfo() devolverá lo que hayas establecido con setFont() y la función () devolverá la fuente que se está utilizando (que puede ser la misma).

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

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

Establece la dirección de trazado utilizada por el pintor al dibujar texto, en el valor especificado direction.

El valor por defecto es Qt::LayoutDirectionAuto, 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 pintor en opacity. El valor debe estar entre 0,0 y 1,0, donde 0,0 es totalmente transparente y 1,0 totalmente opaco.

La opacidad establecida en el pintor se aplica a cada operación de dibujo por separado. Rellenar una forma y dibujar su contorno se tratan como operaciones de dibujo independientes.

Véase también opacity().

void QPainter::setPen(const QPen &pen)

Establece que el lápiz de pintor sea el dado pen.

pen define cómo dibujar líneas y 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 función se introdujo en Qt 6.11.

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

Establece que el lápiz de pintor tenga la dirección style, la anchura 1 y el color negro.

void QPainter::setPen(const QColor &color)

Establece que el lápiz del pintor tenga el estilo Qt::SolidLine, la anchura 1 y el color especificado.

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

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

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

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

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

Ver 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, la matriz especificada transform se combina con la matriz actual; en caso contrario, reemplaza a la matriz actual.

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

void QPainter::setViewTransformEnabled(bool enable)

Activa las transformaciones de vista si enable es verdadero, o desactiva las transformaciones de vista si enable es falso.

Véase también viewTransformEnabled() y Conversión ventana-puerta de vista.

void QPainter::setViewport(const QRect &rectangle)

Establece el rectángulo de la vista del pintor en la dirección rectangle y activa las transformaciones de la vista.

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

Por defecto, el rectángulo de la ventana gráfica es el mismo que el del dispositivo.

Véase también viewport(), viewTransformEnabled() y Conversión ventana-puerta de vista.

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

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

void QPainter::setWindow(const QRect &rectangle)

Establece la ventana del pintor en la dirección rectangle y activa las transformaciones de la 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 hermana, viewport(), especifica el sistema de coordenadas del dispositivo.

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

Véase también window(), viewTransformEnabled() y Conversión ventana-puerta de vista.

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 width y height dados.

void QPainter::setWorldMatrixEnabled(bool enable)

Activa las transformaciones si enable es verdadero, o las desactiva si enable es falso. La matriz de transformación global no se modifica.

Véase 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 verdadero, la matriz especificada matrix se combina con la matriz actual; en caso contrario, reemplaza a la matriz actual.

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

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

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

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

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

Dibuja el contorno (trazos) de la ruta path con la pluma especificada por pen

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

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

Devuelve true si hint está establecido; 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 del mundo.

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

void QPainter::translate(const QPointF &offset)

Traslada el sistema de coordenadas por el offset dado ; es decir, el offset dado se añade a los puntos.

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

void QPainter::translate(const QPoint &offset)

Traslada el sistema de coordenadas mediante la dirección offset.

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

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

bool QPainter::viewTransformEnabled() const

Devuelve true si la transformación de la vista está activada; 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á activada; en caso contrario devuelve false.

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