En esta página

QCanvasPath Class

QCanvasPath es el formato de ruta nativo de QCanvasPainter. Más información...

Encabezado: #include <QCanvasPath>
CMake: find_package(Qt6 REQUIRED COMPONENTS CanvasPainter)
target_link_libraries(mytarget PRIVATE Qt6::CanvasPainter)
Desde: Qt 6.11

Funciones públicas

QCanvasPath()
QCanvasPath(qsizetype commandsSize, qsizetype commandsDataSize = -1)
QCanvasPath(const QCanvasPath &path)
QCanvasPath(QCanvasPath &&other)
~QCanvasPath()
(since 6.12) void addPath(QStringView svgPath, const QTransform &transform = QTransform())
void addPath(const QCanvasPath &path, const QTransform &transform = QTransform())
void addPath(const QCanvasPath &path, qsizetype start, qsizetype count, const QTransform &transform = QTransform())
void arc(qreal centerX, qreal centerY, qreal radius, qreal a0, qreal a1, QCanvasPainter::PathWinding direction = QCanvasPainter::PathWinding::ClockWise, QCanvasPainter::PathConnection connection = QCanvasPainter::PathConnection::Connected)
void arc(QPointF centerPoint, qreal radius, qreal a0, qreal a1, QCanvasPainter::PathWinding direction = QCanvasPainter::PathWinding::ClockWise, QCanvasPainter::PathConnection connection = QCanvasPainter::PathConnection::Connected)
void arcTo(qreal x1, qreal y1, qreal x2, qreal y2, qreal radius)
void arcTo(QPointF point1, QPointF point2, qreal radius)
void beginHoleSubPath()
void beginSolidSubPath()
void bezierCurveTo(qreal cp1X, qreal cp1Y, qreal cp2X, qreal cp2Y, qreal x, qreal y)
void bezierCurveTo(QPointF controlPoint1, QPointF controlPoint2, QPointF endPoint)
void circle(qreal x, qreal y, qreal radius)
void circle(QPointF centerPoint, qreal radius)
void clear()
void closePath()
qsizetype commandsCapacity() const
qsizetype commandsDataCapacity() const
qsizetype commandsDataSize() const
qsizetype commandsSize() const
QPointF currentPosition() const
void ellipse(qreal x, qreal y, qreal radiusX, qreal radiusY)
void ellipse(const QRectF &rect)
bool isEmpty() const
void lineTo(QPointF point)
void lineTo(qreal x, qreal y)
void moveTo(QPointF point)
void moveTo(qreal x, qreal y)
QPointF positionAt(qsizetype index) const
void quadraticCurveTo(qreal cpX, qreal cpY, qreal x, qreal y)
void quadraticCurveTo(QPointF controlPoint, QPointF endPoint)
void rect(qreal x, qreal y, qreal width, qreal height)
void rect(const QRectF &rect)
void reserve(qsizetype commandsSize, qsizetype commandsDataSize = -1)
void roundRect(qreal x, qreal y, qreal width, qreal height, qreal radius)
void roundRect(qreal x, qreal y, qreal width, qreal height, qreal radiusTopLeft, qreal radiusTopRight, qreal radiusBottomRight, qreal radiusBottomLeft)
void roundRect(const QRectF &rect, qreal radius)
void roundRect(const QRectF &rect, qreal radiusTopLeft, qreal radiusTopRight, qreal radiusBottomRight, qreal radiusBottomLeft)
void setPathWinding(QCanvasPainter::PathWinding winding)
QCanvasPath sliced(qsizetype start, qsizetype count, const QTransform &transform = QTransform()) const
void squeeze()
void swap(QCanvasPath &other)
operator QVariant() const
QCanvasPath &operator=(QCanvasPath &&other)
QCanvasPath &operator=(const QCanvasPath &path)
bool operator!=(const QCanvasPath &lhs, const QCanvasPath &rhs)
bool operator==(const QCanvasPath &lhs, const QCanvasPath &rhs)

Descripción detallada

Una ruta de dibujo es un objeto compuesto por una serie de elementos gráficos básicos, como rectángulos, elipses, líneas y curvas. La API de QCanvasPath se adapta a la forma de dibujar con rut QCanvasPainter, lo que facilita el ajuste del código tanto para dibujar directamente como para dibujar dentro de una ruta. La razón principal para utilizar QCanvasPath es evitar tener que recrear trazados que son estáticos y se utilizan en cada fotograma del renderizado, así como permitir, en la medida de lo posible, el almacenamiento en caché de los datos de renderizado relacionados con el trazado (como los datos de vértices e índices generados a partir de él), en lugar de regenerarlos cada vez que se rellena o se traza el trazado.

En comparación con QPainterPath, QCanvasPath está más optimizado para el renderizado y cuenta con menos funciones para comparar o ajustar los trazados. En concreto:

  • No hay métodos para la intersección o la sustracción entre dos trazados.
  • No hay ningún método para trasladar la ruta.
  • No hay ningún método para añadir texto.

Desde el punto de vista de la funcionalidad, QCanvasPath se asemeja más a HTML Canvas Path2D, con algunas adiciones y una API que se ajusta a QCanvasPainter.

Grupos de trazados y almacenamiento en caché

Dibujar trazados mediante QCanvasPath permite al motor almacenar en caché la geometría del trazado (vértices). Esto mejora el rendimiento de los trazados estáticos, aunque puede aumentar el consumo de memoria de la CPU y la GPU.

Al trazar trazados utilizando fill() o stroke(), que toman QCanvasPath como parámetro, es posible establecer un pathGroup como segundo parámetro.

Por defecto, pathGroup es -1, lo que significa que no se intentará almacenar en caché los datos de la ruta, por lo que el renderizado se produce de forma prácticamente idéntica a cuando se dibuja directamente utilizando beginPath(), seguido de los comandos de definición de la ruta y, finalmente, un relleno o un trazo.

Establecer ` pathGroup ` en el valor ` 0 ` o en cualquier número superior habilitará el almacenamiento en caché y la reutilización de la geometría generada por la ruta. Organizar las rutas en grupos de rutas permite optimizar de forma eficiente el rendimiento del renderizado y el uso de la memoria. Las rutas que pertenecen al mismo conjunto y que suelen cambiar al mismo tiempo deben estar en el mismo grupo para obtener resultados óptimos.

Cuando la ruta cambia, sus datos, aunque estuvieran almacenados en caché, se actualizan automáticamente. Los factores que provocan una actualización de la geometría del grupo de rutas son:

Ten en cuenta que cambiar la transformación de estado (QCanvasPainter::transform(), QCanvasPainter::rotate() etc.) no invalida la ruta, por lo que mover, escalar o rotar una ruta almacenada en caché resulta muy eficiente.

A modo de ejemplo, consideremos un QCanvasPath p que contenga un número muy elevado de comandos. Trazar o rellenar esta ruta p puede ser una operación costosa debido a la cantidad de trabajo que se realiza en la CPU. Los datos de los vértices pueden regenerarse y cargarse en los búferes de la GPU para cada una de esas operaciones de trazo o relleno, en cada fotograma. Esto no es lo ideal cuando el trazado es estático y lo único que queremos es dibujarlo una y otra vez en cada fotograma de la forma más eficiente posible.

Cuando se especifica un grupo de trazados, por ejemplo, sustituyendo stroke(p) por stroke(p, 5), el renderizador tiene la opción de mantener búferes de vértices e índices dedicados para el trazado p y cualquier otro trazado que tenga el mismo grupo (5) especificado en un comando de trazo o relleno.

Suponiendo que la ruta p (los comandos del QCanvasPath) no cambie, rellenar o trazar repetidamente esta ruta se convertirá en una operación de bajo coste, ya que todos los datos ya se encuentran en los búferes de la GPU dedicados al grupo de rutas 5. La transformación también es de bajo coste, ya que, con los grupos de rutas almacenados en caché, las transformaciones se producen en el sombreador de vértices, no en la propia geometría.

En el siguiente fragmento de código, cuando m_path es lo suficientemente complejo, sus comandos no cambian y se traza con el mismo ancho de trazo, nivel de suavizado, etc., en cada fotograma; en ese caso, lo siguiente puede resultar significativamente más eficiente que no utilizar grupos de trazados:

// m_path is QCanvasPath with lots of commands in it
const int pathGroup = 5;

// in every frame:
  painter->stroke(m_path, pathGroup);
  // ... other draw commands
  painter->translate(100, 0);
  painter->stroke(m_path, pathGroup);
  // ... other draw commands

Al trazar m_path por segunda, tercera y siguientes veces, el renderizado será muy económico en comparación con no utilizar grupos de trazados, ya que no será necesario realizar ningún procesamiento de la geometría del trazado en la CPU. Cambiar la transformación aplicando una traslación no invalida los datos del grupo de trazados almacenados en caché, por lo que la llamada a stroke() trasladada es igual de rápida.

¿Qué ocurre si cambia uno de los estados relevantes mencionados anteriormente? Por ejemplo, si la ruta se dibuja con dos anchos de trazo diferentes:

// m_path is QCanvasPath with lots of commands in it
const int pathGroup = 5;

// in every frame:
  painter->setStrokeWidth(4);
  painter->stroke(m_path, pathGroup);
  // ... other draw commands
  painter->translate(100, 0);
  painter->setStrokeWidth(8);
  painter->stroke(m_path, pathGroup);
  // ... other draw commands

Esto sigue siendo muy eficiente, ya que los datos de los vértices de la ruta se almacenarán en caché y se reutilizarán tanto para el ancho de trazo 4 como para el 8, pero el uso de recursos aumentará ligeramente, ya que el búfer de la GPU para el grupo de rutas 5 contendrá ahora tanto la versión de la geometría de la ruta con ancho de trazo 4 como la de ancho 8.

Una forma de concebir los grupos de trazados es como un mecanismo de almacenamiento en caché en el que el valor del grupo de trazados se trata como la clave de caché de primer nivel, mientras que el objeto `QCanvasPath`, el nivel de suavizado, las indicaciones de renderizado y, en caso de trazo, el grosor del trazo, el remate de la línea y la unión de la línea forman la clave de caché de segundo nivel (dentro del grupo de trazados).

Modificar los comandos de la ruta (los elementos del QCanvasPath) siempre supone un coste elevado, ya que ello conlleva reconstruir los datos asociados tanto en la CPU como en la GPU. Como ejemplo un tanto extremo, si un `QCanvasPath` cambia sus comandos en cada fotograma, entonces no tiene sentido utilizar grupos de trazados (ni siquiera `QCanvasPath`) para ese trazado en concreto, ya que no hay ventajas en comparación con el dibujo directo del trazado mediante las funciones ` QCanvasPainter `.

En los casos en los que el grupo de trazados ya no se vaya a utilizar en el dibujo, o la aplicación quiera liberar tanta memoria como sea posible, la caché se puede liberar llamando a QCanvasPainter::removePathGroup(). Esto no suele ser necesario, ya que los trazados almacenados en caché se liberan automáticamente durante el destructor del pintor.

Véase también QCanvasPainter::addPath() y QCanvasPainter::removePathGroup().

Documentación de funciones miembro

QCanvasPath::QCanvasPath()

Crea una ruta vacía.

[explicit] QCanvasPath::QCanvasPath(qsizetype commandsSize, qsizetype commandsDataSize = -1)

Crea una ruta vacía, asignando espacio para una cantidad de comandos commandsSize y, opcionalmente, una cantidad de datos commandsDataSize. Si no se especifica el parámetro commandsDataSize, se reserva automáticamente espacio para una cantidad de datos 2 * commandsSize, que es la cantidad óptima cuando los comandos de la ruta son líneas rectas (moveTo(), lineTo(), rect()).

Reservar el espacio adecuado supone una optimización para la creación de la ruta y el uso de la memoria. No es obligatorio, ya que se garantizará automáticamente el espacio suficiente al añadir comandos a la ruta.

Véase también reserve().

QCanvasPath::QCanvasPath(const QCanvasPath &path)

Crea una ruta que es una copia de la ruta indicada path.

[noexcept] QCanvasPath::QCanvasPath(QCanvasPath &&other)

Crea un nuevo objeto `QCanvasPath` a partir de ` other`.

[noexcept] QCanvasPath::~QCanvasPath()

Elimina la ruta.

[since 6.12] void QCanvasPath::addPath(QStringView svgPath, const QTransform &transform = QTransform())

Añade « svgPath » a esta ruta, utilizando opcionalmente « transform » para modificar los puntos de la ruta. Si se conoce el tamaño estimado de la ruta, se recomienda llamar a « reserve()» antes de esto.

Dos formas curvas verdes idénticas creadas a partir de una ruta SVG; la segunda es una copia desplazada.
// m_path is QCanvasPath
if (m_path.isEmpty()) {
    QString path("M 20 20 C 40 120, 80 120, 100 20 Z");
    m_path.addPath(path);
    m_path.addPath(path, QTransform::fromTranslate(80, 80));
}
p->fill(m_path);
p->stroke(m_path);

Consulte «W3C SVG Path Data» para obtener más detalles sobre este formato.

Esta función se introdujo en Qt 6.12.

void QCanvasPath::addPath(const QCanvasPath &path, const QTransform &transform = QTransform())

Añade « path » a esta ruta, utilizando opcionalmente « transform » para modificar los puntos de la ruta. Cuando no se proporciona « transform » (o se trata de una matriz identidad), esta operación es muy rápida, ya que reutiliza los datos de la ruta.

void QCanvasPath::addPath(const QCanvasPath &path, qsizetype start, qsizetype count, const QTransform &transform = QTransform())

Añade path a la ruta actual, empezando por el comando de start e incluyendo count número de comandos. Opcionalmente, se puede utilizar transform para modificar los puntos de la ruta. Se comprueba el rango de start y count, de modo que no se acceda a más de QCanvasPath::commandsSize() comandos. En caso de que la ruta no deba continuar desde la posición actual de la ruta, llama primero a moveTo() con path.positionAt(start - 1).

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

Crea un arco centrado en QPointF(centerX, centerY) con el valor dado radius, que comienza en un ángulo de a0 radianes y termina en a1 radianes. El arco abarca el valor dado direction. Cuando connection es NotConnected, se cierra la ruta anterior y se inicia una nueva subruta.

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

Crea un arco centrado en centerPoint con el radius dado, que comienza en un ángulo de a0 radianes y termina en a1 radianes. El arco abarca el direction dado. Cuando connection es NotConnected, se cierra la ruta anterior y se inicia una nueva subruta.

Esta es una función sobrecargada.

void QCanvasPath::arcTo(qreal x1, qreal y1, qreal x2, qreal y2, qreal radius)

Crea un arco utilizando los puntos QPointF(x1, y1) y QPointF(x2, y2) con el radius especificado.

void QCanvasPath::arcTo(QPointF point1, QPointF point2, qreal radius)

Crea un arco utilizando los puntos point1 y point2 con el radius indicado.

Esta es una función sobrecargada.

void QCanvasPath::beginHoleSubPath()

Iniciar una subruta de agujero. Esto equivale a setPathWinding(QCanvasPainter::PathWinding::ClockWise))

Véase también beginSolidSubPath().

void QCanvasPath::beginSolidSubPath()

Iniciar una subruta sólida. Esto equivale a setPathWinding(QCanvasPainter::PathWinding::CounterClockWise))

Véase también beginHoleSubPath().

void QCanvasPath::bezierCurveTo(qreal cp1X, qreal cp1Y, qreal cp2X, qreal cp2Y, qreal x, qreal y)

Añade una curva de Bézier cúbica entre la posición actual y el punto final especificado por x y y, utilizando los puntos de control especificados por cp1X, cp1Y, cp2X y cp2Y.

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

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

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

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

Esta es una función sobrecargada.

void QCanvasPath::circle(qreal x, qreal y, qreal radius)

Añade a la ruta un círculo cuyo centro se encuentra en QPointF(x, y) y cuyo radio es el indicado en radius.

void QCanvasPath::circle(QPointF centerPoint, qreal radius)

Añade al trazado un círculo cuyo centro se encuentra en centerPoint y cuyo radio dado es radius.

Esta es una función sobrecargada.

void QCanvasPath::clear()

Borra los comandos y los datos de la ruta.

Llama a esta función cuando cambien los comandos de ruta para volver a crear la ruta. Esto no afecta al uso de memoria; para ello, utiliza reserve() y squeeze().

Véanse también reserve() y squeeze().

void QCanvasPath::closePath()

Cierra el subtrazo actual trazando una línea hasta el inicio del mismo, con lo que se inicia automáticamente un nuevo trazado.

qsizetype QCanvasPath::commandsCapacity() const

Devuelve la capacidad de los comandos de la ruta.

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

qsizetype QCanvasPath::commandsDataCapacity() const

Devuelve la capacidad de los datos de comandos en la ruta.

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

qsizetype QCanvasPath::commandsDataSize() const

Devuelve la cantidad de datos de comandos que hay en la ruta.

Los datos de los comandos se refieren básicamente a los puntos que requieren dichos comandos.

Nota: Algunos elementos de la ruta requieren varios puntos de datos. Por ejemplo, « closePath » requiere « 0 », « moveTo » y « lineTo » requieren « 2 », « bezierCurveTo » requiere 6 y « roundRect » requiere « 34 » puntos de datos.

qsizetype QCanvasPath::commandsSize() const

Devuelve el número de comandos que hay en la ruta.

Nota: Algunos elementos de la ruta requieren varios comandos. Por ejemplo, moveTo y lineTo requieren los comandos 1; bezierCurveTo requiere los comandos 6; y roundRect requiere los comandos 10.

QPointF QCanvasPath::currentPosition() const

Devuelve la posición actual de la ruta. Es decir, la posición en la que ha finalizado el comando de ruta anterior (moveTo, lineTo, bezierCurveTo, etc.). Cuando la ruta está vacía, devuelve (0,0; 0,0).

void QCanvasPath::ellipse(qreal x, qreal y, qreal radiusX, qreal radiusY)

Crea una elipse centrada en (x, y), con radios definidos por radiusX y radiusY, y la añade a la ruta como una subruta cerrada.

void QCanvasPath::ellipse(const QRectF &rect)

Crea una elipse dentro del rectángulo « rect » y la añade a la ruta como una subruta cerrada.

Esta es una función sobrecargada.

bool QCanvasPath::isEmpty() const

Devuelve «true» cuando la ruta está vacía.

Véase también clear.

void QCanvasPath::lineTo(QPointF point)

Añade una línea recta desde la posición actual hasta el punto dado point. Una vez trazada la línea, la posición actual se actualiza para situarse en el punto final de la línea.

Esta es una función sobrecargada.

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

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

Esta es una función sobrecargada.

void QCanvasPath::moveTo(QPointF point)

Mueve el punto actual a la posición dada ` point`, iniciando implícitamente una nueva subruta y cerrando la anterior.

Esta es una función sobrecargada.

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

Mueve la posición actual a (x, y) e inicia una nueva subruta, cerrando implícitamente la ruta anterior.

Se trata de una función sobrecargada.

QPointF QCanvasPath::positionAt(qsizetype index) const

Devuelve la posición de la ruta en index. Es decir, la posición en la que se encuentra el comando de ruta (moveTo, lineTo, bezierCurveTo, etc.) en index. El índice debe estar comprendido entre 0 y commandsSize() - 1. Si la ruta está vacía, devuelve (0,0, 0,0).

void QCanvasPath::quadraticCurveTo(qreal cpX, qreal cpY, qreal x, qreal y)

Añade una curva de Bézier cuadrática entre el punto actual y el punto final (x, y) con el punto de control especificado por (cpX, cpY).

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

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

Esta es una función sobrecargada.

void QCanvasPath::rect(qreal x, qreal y, qreal width, qreal height)

Crea un rectángulo situado en QPointF(x, y) con los valores indicados para width y height.

void QCanvasPath::rect(const QRectF &rect)

Crea un rectángulo definido por rect

Esta es una función sobrecargada.

void QCanvasPath::reserve(qsizetype commandsSize, qsizetype commandsDataSize = -1)

Reserva una cantidad determinada de espacio en la memoria interna de QCanvasPath.

Intenta asignar memoria para, como mínimo, commandsSize comandos y commandsDataSize puntos de datos. Algunos elementos de ruta requieren varios comandos; véase commandsSize() y commandsDataSize().

Si no se especifica ` commandsDataSize `, se reserva automáticamente espacio para la cantidad de datos ` 2 * commandsSize `, que es la cantidad óptima cuando los comandos de la ruta son líneas rectas (`moveTo()`, ` lineTo()`, ` rect()`).

Reservar el espacio adecuado supone una optimización para la creación de rutas y el uso de la memoria. No es obligatorio, ya que se garantizará automáticamente el espacio suficiente al añadir comandos a la ruta.

Véase también squeeze(), commandsCapacity() y commandsDataCapacity().

void QCanvasPath::roundRect(qreal x, qreal y, qreal width, qreal height, qreal radius)

Añade al trazado el rectángulo especificado x, y, width, height con las esquinas redondeadas. Las esquinas son cuartos de círculo con las características especificadas en radius.

void QCanvasPath::roundRect(qreal x, qreal y, qreal width, qreal height, qreal radiusTopLeft, qreal radiusTopRight, qreal radiusBottomRight, qreal radiusBottomLeft)

Añade al trazado los rectángulos x, y, width y height con esquinas redondeadas. Las esquinas son cuartos de círculo con un radio de radiusTopLeft, radiusTopRight, radiusBottomRight y radiusBottomLeft, respectivamente.

void QCanvasPath::roundRect(const QRectF &rect, qreal radius)

Añade al trazado el rectángulo dado rect con esquinas redondeadas. Las esquinas son cuartos de círculo con el valor dado radius.

Se trata de una función sobrecargada.

void QCanvasPath::roundRect(const QRectF &rect, qreal radiusTopLeft, qreal radiusTopRight, qreal radiusBottomRight, qreal radiusBottomLeft)

Añade al trazado el rectángulo rect con esquinas redondeadas. Las esquinas son cuartos de círculo con radios radiusTopLeft, radiusTopRight, radiusBottomRight y radiusBottomLeft, respectivamente.

Se trata de una función sobrecargada.

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

Establece la subruta actual « winding » como « QCanvasPainter::CounterClockWise » (por defecto) o « QCanvasPainter::ClockWise ». «CounterClockWise» dibuja subrutas sólidas, mientras que «ClockWise» dibuja agujeros.

Nota: Se tratade un comando similar a lineTo, moveTo, etc., por lo que la configuración del sentido de enrollado debe realizarse antes que el resto de los comandos a los que se pretende aplicar dicho cambio.

QCanvasPath QCanvasPath::sliced(qsizetype start, qsizetype count, const QTransform &transform = QTransform()) const

Devuelve una nueva ruta que contiene los comandos de esta ruta, empezando por el comando de start e incluyendo count número de comandos, utilizando opcionalmente transform para modificar los puntos de la ruta.

Se comprueba el rango de start y count, de modo que no se acceda a más de commandsSize(). En caso de que el comando en start no sea MoveTo, el primer comando se sustituirá por MoveTo para que este fragmento sea una ruta independiente.

void QCanvasPath::squeeze()

Libera toda la memoria que no sea necesaria para almacenar los comandos y los datos de la ruta. Esto puede utilizarse para reducir el consumo de memoria tras llamar a la función reserve().

Normalmente no es necesario utilizar esta función, pero puede resultar útil cuando el tamaño de la ruta ha sido grande debido a la reserva o adición de muchos elementos (lineTo, bezierCurveTo, etc.) y se espera que el tamaño sea mucho menor en el futuro; en ese caso, llamar primero a reserve() y luego a squeeze() liberará algo de memoria.

Véase también reserve().

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

Intercambia esta ruta con other. Esta operación es muy rápida y nunca falla.

QCanvasPath::operator QVariant() const

Devuelve la ruta como un objeto ` QVariant`.

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

Asigna other a esta instancia de QCanvasPath.

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

Asigna el objeto ` path ` indicado a esta ruta y devuelve una referencia a dicha ruta.

Elementos no miembros relacionados

[noexcept] bool operator!=(const QCanvasPath &lhs, const QCanvasPath &rhs)

Devuelve true si la ruta lhs es diferente de rhs; en caso contrario, devuelve false.

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

[noexcept] bool operator==(const QCanvasPath &lhs, const QCanvasPath &rhs)

Devuelve « true » si la ruta « lhs » es igual a « rhs »; en caso contrario, devuelve « false ».

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

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