QPainterPath Class

QPainterPath path;
path.addRect(20, 20, 60, 60);

path.moveTo(0, 0);
path.cubicTo(99, 0,  50, 50,  99, 99);
path.cubicTo(0, 99,  50, 50,  0, 0);

QPainter painter(this);
painter.fillRect(0, 0, 100, 100, Qt::white);
painter.setPen(QPen(QColor(79, 106, 25), 1, Qt::SolidLine,
                    Qt::FlatCap, Qt::MiterJoin));
painter.setBrush(QColor(122, 163, 39));

painter.drawPath(path);

Documentación de las funciones miembro

[noexcept] QPainterPath::QPainterPath()

Construye un objeto QPainterPath vacío.

[explicit] QPainterPath::QPainterPath(const QPointF &startPoint)

Crea un objeto QPainterPath con el startPoint dado como posición actual.

QPainterPath::QPainterPath(const QPainterPath &path)

Crea un objeto QPainterPath que es una copia del dado path.

Véase también operator=().

[noexcept, since 6.10] QPainterPath::QPainterPath(QPainterPath &&other)

Mover-construye una nueva ruta de pintor a partir de other.

El objeto movido-desde other se coloca en el estado por defecto-construido.

Esta función se introdujo en Qt 6.10.

[noexcept] QPainterPath::~QPainterPath()

Destruye este objeto QPainterPath.

void QPainterPath::addEllipse(const QRectF &boundingRectangle)

Crea una elipse dentro de la dirección boundingRectangle especificada y la añade a la ruta del pintor como una sub-ruta cerrada.

La elipse se compone de 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).

Véase también arcTo(), QPainter::drawEllipse() y Composing a QPainterPath.

void QPainterPath::addEllipse(const QPointF &center, qreal rx, qreal ry)

Crea una elipse situada en center con radios rx y ry, y la añade al trazado del pintor como un subtrazado cerrado.

void QPainterPath::addEllipse(qreal x, qreal y, qreal width, qreal height)

Crea una elipse dentro del rectángulo delimitador definido por su esquina superior izquierda en (x, y), width y height, y la añade al trazado del pintor como un subtrazado cerrado.

void QPainterPath::addPath(const QPainterPath &path)

Añade el path dado a este camino como un subcamino cerrado.

Véase también connectPath() y Composing a QPainterPath.

void QPainterPath::addPolygon(const QPolygonF &polygon)

Añade el polygon dado a la ruta como una sub-ruta (no cerrada).

Tenga en cuenta que la posición actual después de añadir el polígono, es el último punto en polygon. Para trazar una línea de vuelta al primer punto, utilice la función closeSubpath().

Véase también lineTo() y Composing a QPainterPath.

void QPainterPath::addRect(const QRectF &rectangle)

Añade el rectangle dado a este camino como un subcamino cerrado.

El rectangle se añade como un conjunto de líneas en el sentido de las agujas del reloj. La posición actual de la ruta del pintor después de añadir rectangle es la esquina superior izquierda del rectángulo.

Véase también addRegion(), lineTo(), y Composing a QPainterPath.

void QPainterPath::addRect(qreal x, qreal y, qreal width, qreal height)

Añade un rectángulo en la posición (x, y), con los datos width y height, como un subcamino cerrado.

void QPainterPath::addRegion(const QRegion &region)

Añade el region dado a la ruta añadiendo cada rectángulo de la región como una sub-ruta cerrada separada.

Véase también addRect() y Composing a QPainterPath.

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

Añade el rectángulo dado rect con esquinas redondeadas a la ruta.

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 la altura del rectángulo, respectivamente, y deben estar comprendidos entre 0,0 y 100,0.

Véase también addRect().

void QPainterPath::addRoundedRect(qreal x, qreal y, qreal w, qreal h, qreal xRadius, qreal yRadius, Qt::SizeMode mode = Qt::AbsoluteSize)

Añade el rectángulo dado x, y, w, h con esquinas redondeadas a la ruta.

void QPainterPath::addText(const QPointF &point, const QFont &font, const QString &text)

Añade el text dado a esta ruta como un conjunto de sub-rutas cerradas creadas a partir del font suministrado. Los subcaminos se colocan de forma que el extremo izquierdo de la línea de base del texto se encuentre en el point especificado.

Algunas fuentes pueden producir subtrayectorias superpuestas y requerirán la regla de relleno Qt::WindingFill para una representación correcta.

Véase también QPainter::drawText(), Composing a QPainterPath, y setFillRule().

void QPainterPath::addText(qreal x, qreal y, const QFont &font, const QString &text)

Añade el text dado a esta ruta como un conjunto de sub-rutas cerradas creadas a partir del font suministrado. Los subcaminos se colocan de modo que el extremo izquierdo de la línea de base del texto se encuentre en el punto especificado por (x, y).

qreal QPainterPath::angleAtPercent(qreal t) const

Devuelve el ángulo de la tangente de la trayectoria en el porcentaje t. El argumento t tiene que estar entre 0 y 1.

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.

Tenga en cuenta que, de forma similar a los otros métodos de porcentaje, la medida del porcentaje no es lineal con respecto a la longitud si hay curvas presentes en la trayectoria. Cuando hay curvas, el argumento del porcentaje se asigna al parámetro t de las ecuaciones de Bézier.

void QPainterPath::arcMoveTo(const QRectF &rectangle, qreal angle)

Crea un movimiento a que se encuentra en el arco que ocupa el rectangle dado en angle.

Los ángulos se especifican en grados. Los arcos en el sentido de las agujas del reloj pueden especificarse utilizando ángulos negativos.

Véase también moveTo() y arcTo().

void QPainterPath::arcMoveTo(qreal x, qreal y, qreal width, qreal height, qreal angle)

Crea un movimiento a que se encuentra en el arco que ocupa el QRectF(x, y, width, height) en angle.

void QPainterPath::arcTo(const QRectF &rectangle, qreal startAngle, qreal sweepLength)

Crea un arco que ocupa el rectangle dado, comenzando en el startAngle especificado y extendiéndose sweepLength grados en sentido contrario a las agujas del reloj.

Los ángulos se especifican en grados. Los arcos en el sentido de las agujas del reloj pueden especificarse utilizando ángulos negativos.

Tenga en cuenta que esta función conecta el punto inicial del arco a la posición actual si no están ya conectados. Una vez añadido el arco, la posición actual es el último punto del arco. Para trazar una línea de vuelta al primer punto, utilice la función closeSubpath().

Véase también arcMoveTo(), addEllipse(), QPainter::drawArc(), QPainter::drawPie() y Composing a QPainterPath.

void QPainterPath::arcTo(qreal x, qreal y, qreal width, qreal height, qreal startAngle, qreal sweepLength)

Crea un arco que ocupa el rectángulo QRectF(x, y, width, height), comenzando en el startAngle especificado y extendiéndose sweepLength grados en sentido contrario a las agujas del reloj.

QRectF QPainterPath::boundingRect() const

Devuelve el rectángulo delimitador de este trazado de pintor como un rectángulo con precisión de coma flotante.

Véase también controlPointRect().

int QPainterPath::capacity() const

Devuelve el número de elementos asignados por QPainterPath.

Véase también clear() y reserve().

void QPainterPath::clear()

Borra los elementos de la ruta almacenados.

Esto permite a la ruta reutilizar asignaciones de memoria anteriores.

Véase también reserve() y capacity().

void QPainterPath::closeSubpath()

Cierra el subtrayecto actual trazando una línea hasta el principio del subtrayecto, iniciando automáticamente un nuevo trayecto. El punto actual del nuevo camino es (0, 0).

Si el subcamino no contiene ningún elemento, esta función no hace nada.

Véase también moveTo() y Composing a QPainterPath.

void QPainterPath::connectPath(const QPainterPath &path)

Conecta el path dado a esta ruta añadiendo una línea desde el último elemento de esta ruta al primer elemento de la ruta dada.

Véase también addPath() y Composing a QPainterPath.

bool QPainterPath::contains(const QPainterPath &p) const

Devuelve true si el camino dado p está contenido dentro del camino actual. Devuelve false si alguna arista del camino actual y p se cruzan.

Las operaciones de conjunto en los recorridos los tratarán como áreas. Los recorridos no cerrados se tratarán como cerrados implícitamente.

Véase también intersects().

bool QPainterPath::contains(const QPointF &point) const

Devuelve true si el point dado está dentro de la ruta, en caso contrario devuelve false.

Véase también intersects().

bool QPainterPath::contains(const QRectF &rectangle) const

Devuelve true si el rectangle dado está dentro de la ruta, en caso contrario devuelve false.

QRectF QPainterPath::controlPointRect() const

Devuelve el rectángulo que contiene todos los puntos y puntos de control de esta ruta.

Esta función es significativamente más rápida de calcular que la exacta boundingRect(), y el rectángulo devuelto es siempre un superconjunto del rectángulo devuelto por boundingRect().

Véase también boundingRect().

void QPainterPath::cubicTo(const QPointF &c1, const QPointF &c2, const QPointF &endPoint)

Añade una curva de Bézier cúbica entre la posición actual y el endPoint dado utilizando los puntos de control especificados por c1, y c2.

Una vez añadida la curva, la posición actual se actualiza para situarse en el punto final de la curva.

Véase también quadTo() y Composing a QPainterPath.

void QPainterPath::cubicTo(qreal c1X, qreal c1Y, qreal c2X, qreal c2Y, qreal endPointX, qreal endPointY)

Añade una curva de Bézier cúbica entre la posición actual y el punto final (endPointX, endPointY) con puntos de control especificados por (c1X, c1Y) y (c2X, c2Y).

QPointF QPainterPath::currentPosition() const

Devuelve la posición actual de la ruta.

QPainterPath::Element QPainterPath::elementAt(int index) const

Devuelve el elemento en el index dado en la ruta del pintor.

Véase también ElementType, elementCount(), y isEmpty().

int QPainterPath::elementCount() const

Devuelve el número de elementos de la ruta del pintor.

Véase también ElementType, elementAt(), y isEmpty().

Qt::FillRule QPainterPath::fillRule() const

Devuelve la regla de relleno actual de la ruta del pintor.

Véase también setFillRule().

QPainterPath QPainterPath::intersected(const QPainterPath &p) const

Devuelve un trazado que es la intersección del área de relleno de este trazado y el área de relleno de p. Las curvas Bézier pueden ser aplanadas a segmentos de línea debido a la inestabilidad numérica de hacer intersecciones de curvas Bézier.

bool QPainterPath::intersects(const QPainterPath &p) const

Devuelve true si el camino actual interseca en cualquier punto el camino dado p. También devuelve true si el camino actual contiene o está contenido por cualquier parte de p.

Las operaciones de conjunto sobre los recorridos los tratarán como áreas. Los caminos no cerrados se tratarán como implícitamente cerrados.

Véase también contains().

bool QPainterPath::intersects(const QRectF &rectangle) const

Devuelve true si algún punto del rectangle dado interseca el camino; en caso contrario devuelve false.

Hay intersección si alguna de las líneas que forman el rectángulo cruza una parte del camino o si alguna parte del rectángulo se solapa con cualquier área encerrada por el camino. Esta función respeta la dirección fillRule actual para determinar lo que se considera dentro del recorrido.

Véase también contains().

[since 6.10] bool QPainterPath::isCachingEnabled() const

Devuelve true si la caché está habilitada; en caso contrario devuelve false.

Esta función se introdujo en Qt 6.10.

Véase también setCachingEnabled().

bool QPainterPath::isEmpty() const

Devuelve true si no hay elementos en este camino, o si el único elemento es un MoveToElement; en caso contrario devuelve false.

Véase también elementCount().

qreal QPainterPath::length() const

Devuelve la longitud de la ruta actual.

void QPainterPath::lineTo(const QPointF &endPoint)

Añade una línea recta desde la posición actual hasta la dirección endPoint. Después de dibujar la línea, la posición actual se actualiza para estar en el punto final de la línea.

Véase también addPolygon(), addRect() y Composing a QPainterPath.

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

Dibuja una línea desde la posición actual hasta el punto (x, y).

void QPainterPath::moveTo(const QPointF &point)

Mueve el punto actual a la dirección point, iniciando implícitamente un nuevo subcamino y cerrando el anterior.

Véase también closeSubpath() y Composing a QPainterPath.

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

Mueve la posición actual a (x, y) e inicia un nuevo subcamino, cerrando implícitamente el camino anterior.

qreal QPainterPath::percentAtLength(qreal len) const

Devuelve el porcentaje de todo el recorrido en la longitud especificada len.

Tenga en cuenta que, de forma similar a otros métodos de porcentaje, la medida del porcentaje no es lineal con respecto a la longitud, si hay curvas presentes en el camino. Cuando hay curvas, el argumento del porcentaje se asigna al parámetro t de las ecuaciones de Bézier.

QPointF QPainterPath::pointAtPercent(qreal t) const

Devuelve el punto en el porcentaje t de la ruta actual. El argumento t tiene que estar entre 0 y 1.

Tenga en cuenta que, de forma similar a otros métodos de porcentaje, la medida del porcentaje no es lineal con respecto a la longitud, si hay curvas presentes en el camino. Cuando hay curvas, el argumento del porcentaje se asigna al parámetro t de las ecuaciones de Bézier.

void QPainterPath::quadTo(const QPointF &c, const QPointF &endPoint)

Añade una curva de Bézier cuadrática entre la posición actual y la endPoint dada con el punto de control especificado por c.

Después de añadir la curva, el punto actual se actualiza para estar en el punto final de la curva.

Véase también cubicTo() y Composing a QPainterPath.

void QPainterPath::quadTo(qreal cx, qreal cy, qreal endPointX, qreal endPointY)

Añade una curva de Bézier cuadrática entre el punto actual y el punto final (endPointX, endPointY) con el punto de control especificado por (cx, cy).

void QPainterPath::reserve(int size)

Reserva una cantidad determinada de elementos en la memoria interna de QPainterPath.

Intenta asignar memoria para al menos size elementos.

Véase también clear(), capacity() y QList::reserve().

[since 6.10] void QPainterPath::setCachingEnabled(bool enabled)

Activa o desactiva el almacenamiento en caché de la longitud según el valor de enabled.

Activar el almacenamiento en caché acelera las llamadas repetidas a las funciones miembro que implican valores de longitud y porcentaje de ruta, como length(), percentAtLength(), pointAtPercent(), etc., a costa de un cierto uso extra de memoria para el almacenamiento de cálculos intermedios. Por defecto está desactivado.

Deshabilitar el almacenamiento en caché liberará cualquier memoria caché asignada.

Esta función se introdujo en Qt 6.10.

Véase también isCachingEnabled(), length(), percentAtLength(), pointAtPercent(), y trimmed().

void QPainterPath::setElementPositionAt(int index, qreal x, qreal y)

Establece las coordenadas x e y del elemento en el índice index a x y y.

void QPainterPath::setFillRule(Qt::FillRule fillRule)

Establece la regla de relleno de la ruta del pintor en la dirección fillRule. Qt proporciona dos métodos para rellenar rutas:

Véase también fillRule().

QPainterPath QPainterPath::simplified() const

Devuelve una versión simplificada de este camino. Esto implica fusionar todos los subcaminos que se cruzan y devolver un camino que no contenga aristas que se crucen. Las líneas paralelas consecutivas también se fusionarán. El trazado simplificado utilizará siempre la regla de relleno por defecto, Qt::OddEvenFill. Las curvas Bézier pueden ser aplanadas a segmentos de línea debido a la inestabilidad numérica de hacer intersecciones de curvas Bézier.

qreal QPainterPath::slopeAtPercent(qreal t) const

Devuelve la pendiente de la trayectoria en el porcentaje t. El argumento t tiene que estar entre 0 y 1.

Tenga en cuenta que, de forma similar a otros métodos de porcentaje, la medida del porcentaje no es lineal con respecto a la longitud, si hay curvas presentes en el camino. Cuando hay curvas, el argumento del porcentaje se asigna al parámetro t de las ecuaciones de Bézier.

QPainterPath QPainterPath::subtracted(const QPainterPath &p) const

Devuelve un trazado que es el área de relleno de p restada del área de relleno de este trazado.

Las operaciones de configuración de trazados se tratarán como áreas. Los trazados no cerrados se tratarán como implícitamente cerrados. Las curvas Bézier pueden aplanarse a segmentos de línea debido a la inestabilidad numérica de las intersecciones de curvas Bézier.

[noexcept] void QPainterPath::swap(QPainterPath &other)

Cambia la ruta de este pintor por other. Esta operación es muy rápida y nunca falla.

QPolygonF QPainterPath::toFillPolygon(const QTransform &matrix = QTransform()) const

Convierte la ruta en un polígono utilizando QTransform matrix , y devuelve el polígono.

El polígono se crea convirtiendo primero todas las subtrayectorias en polígonos y, a continuación, utilizando una técnica de rebobinado para asegurarse de que las subtrayectorias solapadas puedan rellenarse utilizando la regla de relleno correcta.

Tenga en cuenta que el rebobinado inserta líneas de adición en el polígono para que el contorno del polígono de relleno no coincida con el contorno de la ruta.

Véase también toSubpathPolygons(), toFillPolygons(), y QPainterPath Conversion.

QList<QPolygonF> QPainterPath::toFillPolygons(const QTransform &matrix = QTransform()) const

Convierte la ruta en una lista de polígonos utilizando la función QTransform matrix , y devuelve la lista.

La función difiere de la función toFillPolygon() en que crea varios polígonos. Se proporciona porque suele ser más rápido dibujar varios polígonos pequeños que dibujar un polígono grande, aunque el número total de puntos dibujados sea el mismo.

La función toFillPolygons() difiere de la función toSubpathPolygons() en que sólo crea polígonos para las subtrayectorias que tienen rectángulos delimitadores solapados.

Al igual que la función toFillPolygon(), esta función utiliza una técnica de rebobinado para asegurarse de que las subtrayectorias solapadas pueden rellenarse utilizando la regla de relleno correcta. Tenga en cuenta que el rebobinado inserta líneas de adición en los polígonos para que el contorno del polígono de relleno no coincida con el contorno del trazado.

Véase también toSubpathPolygons(), toFillPolygon(), y QPainterPath Conversion.

QPainterPath QPainterPath::toReversed() const

Crea y devuelve una copia invertida de la ruta.

Lo que se invierte es el orden de los elementos: si un QPainterPath se compone llamando a las funciones moveTo(), lineTo() y cubicTo() en el orden especificado, la copia invertida se compone llamando a cubicTo(), lineTo() y moveTo().

QList<QPolygonF> QPainterPath::toSubpathPolygons(const QTransform &matrix = QTransform()) const

Convierte la ruta en una lista de polígonos utilizando QTransform matrix , y devuelve la lista.

Esta función crea un polígono para cada subtrayectoria independientemente de las subtrayectorias que se crucen (es decir, rectángulos delimitadores superpuestos). Para asegurarse de que tales subtrayectorias solapadas se rellenan correctamente, utilice en su lugar la función toFillPolygons().

Véase también toFillPolygons(), toFillPolygon() y QPainterPath Conversion.

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

Traduce todos los elementos de la ruta por (dx, dy).

Véase también translated().

void QPainterPath::translate(const QPointF &offset)

Traduce todos los elementos de la ruta a la dirección offset.

Véase también translated().

QPainterPath QPainterPath::translated(qreal dx, qreal dy) const

Devuelve una copia de la ruta traducida por (dx, dy).

Véase también translate().

QPainterPath QPainterPath::translated(const QPointF &offset) const

Devuelve una copia de la ruta traducida por offset.

Véase también translate().

[since 6.10] QPainterPath QPainterPath::trimmed(qreal fromFraction, qreal toFraction, qreal offset = 0) const

Devuelve la sección del recorrido comprendida entre las fracciones de longitud fromFraction y toFraction. El rango efectivo de las fracciones va de 0, que denota el punto de inicio del camino, a 1, que denota su punto final. Las fracciones son lineales con respecto a la longitud del recorrido, a diferencia de los valores t porcentuales.

El valor de offset se sumará a los valores de las fracciones. Si eso causa un desbordamiento por exceso o por defecto del rango [0, 1], los valores se envolverán, al igual que el camino resultante. El rango efectivo del desplazamiento está entre -1 y 1.

Las llamadas repetidas a esta función pueden optimizarse {habilitando el almacenamiento en caché}{setCachingEnabled()}.

Esta función se introdujo en Qt 6.10.

Véase también length(), percentAtLength(), y setCachingEnabled().

QPainterPath QPainterPath::united(const QPainterPath &p) const

Devuelve un trazado que es la unión del área de relleno de este trazado y el área de relleno de p.

Las operaciones de conjunto en trazados tratarán los trazados como áreas. Los trazados no cerrados se tratarán como implícitamente cerrados. Las curvas Bézier pueden aplanarse a segmentos de línea debido a la inestabilidad numérica de las intersecciones de curvas Bézier.

Véase también intersected() y subtracted().

bool QPainterPath::operator!=(const QPainterPath &path) const

Devuelve true si la ruta de este pintor difiere de la ruta dada path.

Tenga en cuenta que la comparación de rutas puede implicar una comparación por elemento que puede ser lenta para rutas complejas.

Véase también operator==().

QPainterPath QPainterPath::operator&(const QPainterPath &other) const

Devuelve la intersección de esta ruta y la ruta other.

Véase también intersected(), operator&=(), united() y operator|().

QPainterPath &QPainterPath::operator&=(const QPainterPath &other)

Interseca este camino con other y devuelve una referencia a este camino.

Véase también intersected(), operator&() y operator|=().

QPainterPath QPainterPath::operator+(const QPainterPath &other) const

Devuelve la unión de esta ruta y la ruta other. Esta función es equivalente a operator|().

Véase también united(), operator+=() y operator-().

QPainterPath &QPainterPath::operator+=(const QPainterPath &other)

Une esta ruta con other, y devuelve una referencia a esta ruta. Esto es equivalente a operator|=().

Véase también united(), operator+() y operator-=().

QPainterPath QPainterPath::operator-(const QPainterPath &other) const

Resta la ruta other de una copia de esta ruta y devuelve la copia.

Véase también subtracted(), operator-=() y operator+().

QPainterPath &QPainterPath::operator-=(const QPainterPath &other)

Resta other de esta ruta, y devuelve una referencia a esta ruta.

Véase también subtracted(), operator-() y operator+=().

[noexcept] QPainterPath &QPainterPath::operator=(QPainterPath &&other)

Mover-asigna other a esta instancia QPainterPath.

QPainterPath &QPainterPath::operator=(const QPainterPath &path)

Asigna el path dado a esta ruta de pintor.

Véase también QPainterPath().

bool QPainterPath::operator==(const QPainterPath &path) const

Devuelve true si este camino de pintura es igual al dado path.

Tenga en cuenta que la comparación de rutas puede implicar una comparación por elemento que puede ser lenta para rutas complejas.

Véase también operator!=().

QPainterPath QPainterPath::operator|(const QPainterPath &other) const

Devuelve la unión de esta ruta y la ruta other.

Véase también united(), operator|=(), intersected() y operator&().

QPainterPath &QPainterPath::operator|=(const QPainterPath &other)

Une esta ruta con other y devuelve una referencia a esta ruta.

Véase también united(), operator|(), y operator&=().