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

La clase « QPainterPath » proporciona un contenedor para operaciones de pintura, lo que permite construir y reutilizar formas gráficas.
Un trazado de pintor es un objeto compuesto por una serie de bloques gráficos (como rectángulos, elipses, líneas y curvas), y puede utilizarse para rellenar, contornear y recortar. La principal ventaja de las rutas de pintura frente a las operaciones de dibujo normales es que las formas complejas solo tienen que crearse una vez, pero pueden dibujarse muchas veces utilizando únicamente llamadas a QPainter::drawPath().
El ejemplo consta de dos clases:
- La clase `
RenderArea`, que es un widget personalizado que muestra una única ruta de pintura. - La clase `
Window`, que es la ventana principal de la aplicación y muestra varios widgets `RenderArea`, permitiendo al usuario manipular el relleno, el trazo, el color y el ángulo de rotación de las trazas de pintura.
En primer lugar, repasaremos la clase ` Window ` y, a continuación, analizaremos la clase ` RenderArea `.
Definición de la clase Window
La clase ` Window ` hereda de ` QWidget` y es la ventana principal de la aplicación, que muestra varios widgets ` RenderArea ` y permite al usuario manipular el relleno, el lápiz, el color y el ángulo de rotación de los trazados del pintor.
class Window : public QWidget
{
Q_OBJECT
public:
Window();
private slots:
void fillRuleChanged();
void fillGradientChanged();
void penColorChanged();Declaramos tres slots privados para responder a las entradas del usuario relativas al relleno y al color: ` fillRuleChanged()`, ` fillGradientChanged() ` y ` penColorChanged()`.
Cuando el usuario cambia el grosor del trazo y el ángulo de rotación, el nuevo valor se transmite directamente a los widgets « RenderArea » mediante la señal « QSpinBox::valueChanged()». La razón por la que debemos implementar ranuras (slots) para actualizar el relleno y el color es que QComboBox no proporciona una señal similar que pase el nuevo valor como argumento; por lo tanto, necesitamos recuperar el nuevo valor, o valores, antes de poder actualizar los widgets RenderArea.
private:
void populateWithColors(QComboBox *comboBox);
QVariant currentItemData(QComboBox *comboBox);También declaramos un par de funciones privadas de conveniencia: populateWithColors() rellena un QComboBox dado con elementos correspondientes a los nombres de colores que Qt reconoce, y currentItemData() devuelve el elemento actual para un QComboBox dado.
QList<RenderArea*> renderAreas;
QLabel *fillRuleLabel;
QLabel *fillGradientLabel;
QLabel *fillToLabel;
QLabel *penWidthLabel;
QLabel *penColorLabel;
QLabel *rotationAngleLabel;
QComboBox *fillRuleComboBox;
QComboBox *fillColor1ComboBox;
QComboBox *fillColor2ComboBox;
QSpinBox *penWidthSpinBox;
QComboBox *penColorComboBox;
QSpinBox *rotationAngleSpinBox;
};A continuación, declaramos los distintos componentes del widget de la ventana principal. También declaramos una constante de conveniencia que especifica el número de widgets RenderArea.
Implementación de la clase Window
En el constructor de Window, definimos las distintas rutas de dibujo y creamos los widgets RenderArea correspondientes que representarán las formas gráficas:
Window::Window()
{
QPainterPath rectPath;
rectPath.moveTo(20.0, 30.0);
rectPath.lineTo(80.0, 30.0);
rectPath.lineTo(80.0, 70.0);
rectPath.lineTo(20.0, 70.0);
rectPath.closeSubpath();Construimos un rectángulo con esquinas afiladas utilizando las funciones ` QPainterPath::moveTo()` y ` QPainterPath::lineTo()`.
QPainterPath::moveTo() desplaza el punto actual al punto pasado como argumento. Una ruta de dibujo es un objeto compuesto por una serie de bloques gráficos, es decir, subrutas. Al desplazar el punto actual también se inicia una nueva subruta (cerrando implícitamente la ruta anterior al iniciarse la nueva). La función QPainterPath::lineTo() añade una línea recta desde el punto actual hasta el punto final dado. Una vez trazada la línea, el punto actual se actualiza para situarse en el punto final de la línea.
Primero movemos el punto actual iniciando un nuevo subtrazo y dibujamos tres de los lados del rectángulo. A continuación, llamamos a la función QPainterPath::closeSubpath(), que dibuja una línea hasta el inicio del subtrazo actual. Se inicia automáticamente un nuevo subtrazo cuando se cierra el subtrazo actual. El punto actual del nuevo trazado es (0, 0). También podríamos haber llamado a ` QPainterPath::lineTo()` para dibujar la última línea y, a continuación, iniciar explícitamente un nuevo subtrazo utilizando la función ` QPainterPath::moveTo()`.
QPainterPath También ofrece la función de conveniencia QPainterPath::addRect(), que añade un rectángulo dado a la ruta como una subruta cerrada. El rectángulo se añade como un conjunto de líneas en el sentido de las agujas del reloj. La posición actual de la ruta de dibujo tras añadir el rectángulo se encuentra en la esquina superior izquierda del mismo.
QPainterPath roundRectPath;
roundRectPath.moveTo(80.0, 35.0);
roundRectPath.arcTo(70.0, 30.0, 10.0, 10.0, 0.0, 90.0);
roundRectPath.lineTo(25.0, 30.0);
roundRectPath.arcTo(20.0, 30.0, 10.0, 10.0, 90.0, 90.0);
roundRectPath.lineTo(20.0, 65.0);
roundRectPath.arcTo(20.0, 60.0, 10.0, 10.0, 180.0, 90.0);
roundRectPath.lineTo(75.0, 70.0);
roundRectPath.arcTo(70.0, 60.0, 10.0, 10.0, 270.0, 90.0);
roundRectPath.closeSubpath();A continuación, construimos un rectángulo con esquinas redondeadas. Al igual que antes, utilizamos las funciones ` QPainterPath::moveTo()` y ` QPainterPath::lineTo()` para dibujar los lados del rectángulo. Para crear las esquinas redondeadas, utilizamos la función ` QPainterPath::arcTo()`.
QPainterPath::arcTo() crea un arco que ocupa el rectángulo dado (especificado mediante un ` QRect ` o las coordenadas del rectángulo), comenzando en el ángulo inicial dado y extendiéndose los grados indicados en sentido antihorario. Los ángulos se especifican en grados. Los arcos en sentido horario se pueden especificar utilizando ángulos negativos. La función conecta el punto actual con el punto inicial del arco si aún no están conectados.
QPainterPath ellipsePath;
ellipsePath.moveTo(80.0, 50.0);
ellipsePath.arcTo(20.0, 30.0, 60.0, 40.0, 0.0, 360.0);También utilizamos la función QPainterPath::arcTo() para construir la trayectoria de la elipse. Primero movemos el punto actual para iniciar una nueva trayectoria. A continuación, llamamos a QPainterPath::arcTo() con un ángulo inicial de 0,0 y 360,0 grados como último argumento, creando así una elipse.
De nuevo, QPainterPath proporciona una función práctica ( QPainterPath::addEllipse()) que crea una elipse dentro de un rectángulo delimitador dado y la añade a la ruta de dibujo. Si la subruta actual está cerrada, se inicia una nueva subruta. La elipse está compuesta por una curva en el sentido de las agujas del reloj, que comienza y termina en cero grados (la posición de las 3 en punto).
QPainterPath piePath;
piePath.moveTo(50.0, 50.0);
piePath.arcTo(20.0, 30.0, 60.0, 40.0, 60.0, 240.0);
piePath.closeSubpath();Al construir la ruta del gráfico circular, seguimos utilizando una combinación de las funciones mencionadas: primero desplazamos el punto actual, iniciando una nueva subruta. A continuación, creamos una línea desde el centro del gráfico hasta el arco, y el propio arco. Al cerrar la subruta, construimos implícitamente la última línea de vuelta al centro del gráfico.
QPainterPath polygonPath;
polygonPath.moveTo(10.0, 80.0);
polygonPath.lineTo(20.0, 10.0);
polygonPath.lineTo(80.0, 30.0);
polygonPath.lineTo(90.0, 70.0);
polygonPath.closeSubpath();Construir un polígono equivale a construir un rectángulo.
QPainterPath También proporciona la función de conveniencia ` QPainterPath::addPolygon()`, que añade el polígono dado a la ruta como una nueva subruta. La posición actual tras añadir el polígono es el último punto del polígono.
QPainterPath groupPath;
groupPath.moveTo(60.0, 40.0);
groupPath.arcTo(20.0, 20.0, 40.0, 40.0, 0.0, 360.0);
groupPath.moveTo(40.0, 40.0);
groupPath.lineTo(40.0, 80.0);
groupPath.lineTo(80.0, 80.0);
groupPath.lineTo(80.0, 40.0);
groupPath.closeSubpath();A continuación, creamos una ruta compuesta por un grupo de subtrayectorias: primero movemos el punto actual y creamos un círculo utilizando la función QPainterPath::arcTo() con un ángulo inicial de 0,0 y 360 grados como último argumento, tal y como hicimos al crear la ruta de la elipse. A continuación, movemos de nuevo el punto actual, iniciando un nuevo subtrazo, y construimos tres lados de un cuadrado utilizando la función QPainterPath::lineTo().
Ahora, al llamar a la función ` QPainterPath::closeSubpath()`, se crea el último lado. Recuerda que la función ` QPainterPath::closeSubpath()` traza una línea hasta el inicio de la subtrayectoria actual, es decir, el cuadrado.
QPainterPath Proporciona una función de conveniencia, ` QPainterPath::addPath()`, que añade una ruta dada a la ruta que invoca la función.
QPainterPath textPath;
QFont timesFont("Times", 50);
timesFont.setStyleStrategy(QFont::ForceOutline);
textPath.addText(10, 70, timesFont, tr("Qt"));Al crear el trazado de texto, primero creamos la fuente. A continuación, configuramos la estrategia de estilo de la fuente, que indica al algoritmo de correspondencia de fuentes qué tipo de fuentes deben utilizarse para encontrar una familia predeterminada adecuada. QFont::ForceOutline obliga a utilizar fuentes de contorno.
Para construir el texto, utilizamos la función QPainterPath::addText(), que añade el texto dado a la ruta como un conjunto de subrutas cerradas creadas a partir de la fuente proporcionada. Las subrutas se colocan de manera que el extremo izquierdo de la línea de base del texto quede en el punto especificado.
QPainterPath bezierPath;
bezierPath.moveTo(20, 30);
bezierPath.cubicTo(80, 0, 50, 50, 80, 80);Para crear la ruta Bézier, utilizamos la función QPainterPath::cubicTo(), que añade una curva Bézier entre el punto actual y el punto final dado con el punto de control indicado. Una vez añadida la curva, el punto actual se actualiza para situarse en el punto final de la curva.
En este caso, omitimos cerrar el subtrazado para que solo tengamos una curva simple. Sin embargo, sigue existiendo una línea lógica desde el extremo final de la curva hasta el inicio del subtrazado; esta se hace visible al rellenar el trazado, tal y como se puede observar en la ventana principal de la aplicación.
QPainterPath starPath;
starPath.moveTo(90, 50);
for (int i = 1; i < 5; ++i) {
starPath.lineTo(50 + 40 * std::cos(0.8 * i * M_PI),
50 + 40 * std::sin(0.8 * i * M_PI));
}
starPath.closeSubpath();El trazado final que construimos demuestra que se puede utilizar QPainterPath para crear formas bastante complejas utilizando únicamente las funciones mencionadas anteriormente: QPainterPath::moveTo(), QPainterPath::lineTo() y QPainterPath::closeSubpath().
renderAreas.push_back(new RenderArea(rectPath));
renderAreas.push_back(new RenderArea(roundRectPath));
renderAreas.push_back(new RenderArea(ellipsePath));
renderAreas.push_back(new RenderArea(piePath));
renderAreas.push_back(new RenderArea(polygonPath));
renderAreas.push_back(new RenderArea(groupPath));
renderAreas.push_back(new RenderArea(textPath));
renderAreas.push_back(new RenderArea(bezierPath));
renderAreas.push_back(new RenderArea(starPath));Ahora que hemos creado todas las rutas de dibujo que necesitamos, creamos un widget « RenderArea » correspondiente para cada una de ellas. Por último, nos aseguramos de que el número de áreas de renderizado sea correcto utilizando la macro « Q_ASSERT()».
fillRuleComboBox = new QComboBox;
fillRuleComboBox->addItem(tr("Odd Even"), Qt::OddEvenFill);
fillRuleComboBox->addItem(tr("Winding"), Qt::WindingFill);
fillRuleLabel = new QLabel(tr("Fill &Rule:"));
fillRuleLabel->setBuddy(fillRuleComboBox);A continuación, creamos los widgets asociados a la regla de relleno de los trazados del pintor.
Hay dos reglas de relleno disponibles en Qt: La regla « Qt::OddEvenFill » determina si un punto se encuentra dentro de la forma trazando una línea horizontal desde el punto hasta un punto situado fuera de la forma y contando el número de intersecciones. Si el número de intersecciones es impar, el punto está dentro de la forma. Esta regla es la predeterminada.
La regla « Qt::WindingFill » determina si un punto se encuentra dentro de la forma trazando una línea horizontal desde el punto hasta un punto situado fuera de la forma. A continuación, determina si la dirección de la línea en cada punto de intersección es hacia arriba o hacia abajo. El número de enrollamiento se determina sumando la dirección de cada intersección. Si el número es distinto de cero, el punto se encuentra dentro de la forma.
La regla « Qt::WindingFill » puede considerarse, en la mayoría de los casos, como la intersección de figuras cerradas.
fillColor1ComboBox = new QComboBox;
populateWithColors(fillColor1ComboBox);
fillColor1ComboBox->setCurrentIndex(fillColor1ComboBox->findText("mediumslateblue"));
fillColor2ComboBox = new QComboBox;
populateWithColors(fillColor2ComboBox);
fillColor2ComboBox->setCurrentIndex(fillColor2ComboBox->findText("cornsilk"));
fillGradientLabel = new QLabel(tr("&Fill Gradient:"));
fillGradientLabel->setBuddy(fillColor1ComboBox);
fillToLabel = new QLabel(tr("to"));
fillToLabel->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
penWidthSpinBox = new QSpinBox;
penWidthSpinBox->setRange(0, 20);
penWidthLabel = new QLabel(tr("&Pen Width:"));
penWidthLabel->setBuddy(penWidthSpinBox);
penColorComboBox = new QComboBox;
populateWithColors(penColorComboBox);
penColorComboBox->setCurrentIndex(penColorComboBox->findText("darkslateblue"));
penColorLabel = new QLabel(tr("Pen &Color:"));
penColorLabel->setBuddy(penColorComboBox);
rotationAngleSpinBox = new QSpinBox;
rotationAngleSpinBox->setRange(0, 359);
rotationAngleSpinBox->setWrapping(true);
rotationAngleSpinBox->setSuffix(QLatin1String("\xB0"));
rotationAngleLabel = new QLabel(tr("&Rotation Angle:"));
rotationAngleLabel->setBuddy(rotationAngleSpinBox);También creamos los demás widgets asociados al relleno, el trazo y el ángulo de rotación.
connect(fillRuleComboBox, &QComboBox::activated,
this, &Window::fillRuleChanged);
connect(fillColor1ComboBox, &QComboBox::activated,
this, &Window::fillGradientChanged);
connect(fillColor2ComboBox, &QComboBox::activated,
this, &Window::fillGradientChanged);
connect(penColorComboBox, &QComboBox::activated,
this, &Window::penColorChanged);
for (RenderArea *area : std::as_const(renderAreas)) {
connect(penWidthSpinBox, &QSpinBox::valueChanged,
area, &RenderArea::setPenWidth);
connect(rotationAngleSpinBox, &QSpinBox::valueChanged,
area, &RenderArea::setRotationAngle);
}Conectamos las señales « activated » () de los cuadros combinados a las ranuras asociadas de la clase « Window », mientras que conectamos la señal « valueChanged » () de los cuadros de selección directamente a las respectivas ranuras del widget « RenderArea ».
QGridLayout *topLayout = new QGridLayout;
int i = 0;
for (RenderArea *area : std::as_const(renderAreas)) {
topLayout->addWidget(area, i / 3, i % 3);
++i;
}
QGridLayout *mainLayout = new QGridLayout;
mainLayout->addLayout(topLayout, 0, 0, 1, 4);
mainLayout->addWidget(fillRuleLabel, 1, 0);
mainLayout->addWidget(fillRuleComboBox, 1, 1, 1, 3);
mainLayout->addWidget(fillGradientLabel, 2, 0);
mainLayout->addWidget(fillColor1ComboBox, 2, 1);
mainLayout->addWidget(fillToLabel, 2, 2);
mainLayout->addWidget(fillColor2ComboBox, 2, 3);
mainLayout->addWidget(penWidthLabel, 3, 0);
mainLayout->addWidget(penWidthSpinBox, 3, 1, 1, 3);
mainLayout->addWidget(penColorLabel, 4, 0);
mainLayout->addWidget(penColorComboBox, 4, 1, 1, 3);
mainLayout->addWidget(rotationAngleLabel, 5, 0);
mainLayout->addWidget(rotationAngleSpinBox, 5, 1, 1, 3);
setLayout(mainLayout);Añadimos los widgets RenderArea a un diseño independiente que, a continuación, incorporamos al diseño principal junto con el resto de widgets.
fillRuleChanged();
fillGradientChanged();
penColorChanged();
penWidthSpinBox->setValue(2);
setWindowTitle(tr("Painter Paths"));
}Por último, inicializamos los widgets « RenderArea » llamando a las ranuras « fillRuleChanged() », « fillGradientChanged() » y « penColorChanged() », y establecemos el ancho inicial del lápiz y el título de la ventana.
void Window::fillRuleChanged()
{
Qt::FillRule rule = (Qt::FillRule)currentItemData(fillRuleComboBox).toInt();
for (RenderArea *area : std::as_const(renderAreas))
area->setFillRule(rule);
}
void Window::fillGradientChanged()
{
QColor color1 = qvariant_cast<QColor>(currentItemData(fillColor1ComboBox));
QColor color2 = qvariant_cast<QColor>(currentItemData(fillColor2ComboBox));
for (RenderArea *area : std::as_const(renderAreas))
area->setFillGradient(color1, color2);
}
void Window::penColorChanged()
{
QColor color = qvariant_cast<QColor>(currentItemData(penColorComboBox));
for (RenderArea *area : std::as_const(renderAreas))
area->setPenColor(color);
}Las ranuras privadas se implementan para recuperar el nuevo valor, o valores, de los cuadros combinados asociados y actualizar los widgets de RenderArea.
En primer lugar, determinamos el nuevo valor o valores utilizando la función privada ` currentItemData() ` y la función de plantilla ` qvariant_cast()`. A continuación, llamamos a la ranura asociada para cada uno de los widgets ` RenderArea ` con el fin de actualizar las rutas de dibujo.
void Window::populateWithColors(QComboBox *comboBox)
{
const QStringList colorNames = QColor::colorNames();
for (const QString &name : colorNames)
comboBox->addItem(name, QColor(name));
}La función ` populateWithColors() ` rellena el cuadro combinado dado con elementos que corresponden a los nombres de colores que Qt reconoce, proporcionados por la función estática ` QColor::colorNames()`.
QVariant Window::currentItemData(QComboBox *comboBox)
{
return comboBox->itemData(comboBox->currentIndex());
}La función ` currentItemData() ` simplemente devuelve el elemento actual del cuadro combinado dado.
Definición de la clase RenderArea
La clase ` RenderArea ` hereda de ` QWidget` y es un widget personalizado que muestra una única ruta de pintura.
class RenderArea : public QWidget
{
Q_OBJECT
public:
explicit RenderArea(const QPainterPath &path, QWidget *parent = nullptr);
QSize minimumSizeHint() const override;
QSize sizeHint() const override;
public slots:
void setFillRule(Qt::FillRule rule);
void setFillGradient(const QColor &color1, const QColor &color2);
void setPenWidth(int width);
void setPenColor(const QColor &color);
void setRotationAngle(int degrees);
protected:
void paintEvent(QPaintEvent *event) override;Declaramos varias ranuras públicas que actualizan la ruta de dibujo asociada al widget ` RenderArea `. Además, reimplementamos las funciones ` QWidget::minimumSizeHint()` y ` QWidget::sizeHint()` para dotar al widget ` RenderArea ` de un tamaño adecuado dentro de nuestra aplicación, y reimplementamos el controlador de eventos ` QWidget::paintEvent()` para dibujar su ruta de dibujo.
private:
QPainterPath path;
QColor fillColor1;
QColor fillColor2;
int penWidth;
QColor penColor;
int rotationAngle;
};Cada instancia de la clase RenderArea tiene un QPainterPath, un par de colores de relleno, un grosor de trazo, un color de trazo y un ángulo de rotación.
Implementación de la clase RenderArea
El constructor toma un ` QPainterPath ` como argumento (además del padre opcional ` QWidget `):
RenderArea::RenderArea(const QPainterPath &path, QWidget *parent)
: QWidget(parent), path(path)
{
penWidth = 1;
rotationAngle = 0;
setBackgroundRole(QPalette::Base);
}En el constructor, inicializamos el widget ` RenderArea ` con el parámetro ` QPainterPath `, además de inicializar el grosor del trazo y el ángulo de rotación. También establecemos el ` background role` del widget; el ` QPalette::Base ` suele ser blanco.
QSize RenderArea::minimumSizeHint() const
{
return QSize(50, 50);
}
QSize RenderArea::sizeHint() const
{
return QSize(100, 100);
}A continuación, reimplementamos las funciones ` QWidget::minimumSizeHint()` y ` QWidget::sizeHint()` para dotar al widget ` RenderArea ` de un tamaño razonable dentro de nuestra aplicación.
void RenderArea::setFillRule(Qt::FillRule rule)
{
path.setFillRule(rule);
update();
}
void RenderArea::setFillGradient(const QColor &color1, const QColor &color2)
{
fillColor1 = color1;
fillColor2 = color2;
update();
}
void RenderArea::setPenWidth(int width)
{
penWidth = width;
update();
}
void RenderArea::setPenColor(const QColor &color)
{
penColor = color;
update();
}
void RenderArea::setRotationAngle(int degrees)
{
rotationAngle = degrees;
update();
}Las distintas ranuras públicas actualizan la ruta de dibujo del widget ` RenderArea ` estableciendo la propiedad asociada y realizando una llamada a la función ` QWidget::update()`, lo que fuerza un redibujado del widget con las nuevas preferencias de renderizado.
La ranura QWidget::update() no provoca un redibujado inmediato; en su lugar, programa un evento de pintura para que se procese cuando Qt vuelva al bucle de eventos principal.
void RenderArea::paintEvent(QPaintEvent *)
{
QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing);Un evento de pintura es una solicitud para volver a pintar todo el widget o partes del mismo. La función `paintEvent()` es un controlador de eventos que se puede reimplementar para recibir los eventos de pintura del widget. Reimplementamos el controlador de eventos para renderizar la ruta de dibujo del widget ` RenderArea `.
En primer lugar, creamos un ` QPainter ` para la instancia ` RenderArea ` y configuramos las sugerencias de renderizado del pintor. Las ` QPainter::RenderHints ` se utilizan para especificar indicadores a ` QPainter ` que pueden ser respetados, o no, por cualquier motor dado. ` QPainter::Antialiasing ` indica que el motor debe aplicar suavizado (anti-aliasing) a los bordes de las primitivas si es posible, es decir, añadir píxeles adicionales alrededor de los originales para suavizar los bordes.
painter.scale(width() / 100.0, height() / 100.0);
painter.translate(50.0, 50.0);
painter.rotate(-rotationAngle);
painter.translate(-50.0, -50.0);A continuación, escalamos el sistema de coordenadas de QPainter para garantizar que la ruta de dibujo se represente con el tamaño correcto, es decir, que crezca junto con el widget RenderArea cuando se cambie el tamaño de la aplicación. Cuando construimos las distintas trayectorias de dibujo, todas se representaban dentro de un cuadrado de 100 píxeles de ancho, lo que equivale a RenderArea::sizeHint(). La función QPainter::scale() escala el sistema de coordenadas dividiendo el ancho y la altura actuales del widget RenderArea entre 100.
Ahora, cuando estamos seguros de que el trazado del pintor tiene el tamaño correcto, podemos traslazar el sistema de coordenadas para que el trazado gire alrededor del centro del widget RenderArea. Una vez realizada la rotación, debemos recordar volver a traslazar el sistema de coordenadas a su posición original.
painter.setPen(QPen(penColor, penWidth, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
QLinearGradient gradient(0, 0, 0, 100);
gradient.setColorAt(0.0, fillColor1);
gradient.setColorAt(1.0, fillColor2);
painter.setBrush(gradient);
painter.drawPath(path);
}A continuación, configuramos el lápiz del widget « QPainter » con las preferencias de renderizado de la instancia. Creamos un objeto « QLinearGradient » y establecemos sus colores de acuerdo con los colores de relleno del widget « RenderArea ». Por último, configuramos el pincel del objeto « QPainter » (el degradado se convierte automáticamente en un « QBrush ») y dibujamos la ruta de dibujo del widget « RenderArea » utilizando la función « QPainter::drawPath()».
© 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.