En esta página

Canvas2DContext QML Type

Proporciona un contexto 2D para dibujar sobre un elemento de « Canvas2D ». Más información...

Import Statement: import QtCanvas2D
Since: Qt 6.12
Status: Technology preview

Este tipo se encuentra en fase de vista previa tecnológica y está sujeto a cambios.

Propiedades

Métodos

  • void addPath(path2d path, transform2d transform)
  • void addPath(path2d path, int start, int count, transform2d transform)
  • void arc(real x, real y, real radius, real startAngle, real endAngle, bool anticlockwise)
  • void arcTo(real x1, real y1, real x2, real y2, real radius)
  • void beginHoleSubPath()
  • void beginPath()
  • void beginSolidSubPath()
  • void bezierCurveTo(real cp1x, real cp1y, real cp2x, real cp2y, real x, real y)
  • void circle(real centerX, real centerY, real radius)
  • void cleanupResources()
  • void clearRect(real x, real y, real width, real height)
  • void closePath()
  • boxgradient2d createBoxGradient(real x, real y, real width, real height, real feather, real radius)
  • boxshadow2d createBoxShadow(real x, real y, real width, real height)
  • boxshadow2d createBoxShadow(real x, real y, real width, real height, real blur, string color, real radius)
  • boxshadow2d createBoxShadow(real x, real y, real width, real height, real blur, string color, real radiusTopLeft, real radiusTopRight, real radiusBottomRight, real radiusBottomLeft)
  • conicalgradient2d createConicalGradient(real x, real y, real angle)
  • gridpattern2d createGridPattern(real x, real y, real width, real height, string lineColor, string backgroundColor, real lineWidth, real feather, real angle)
  • lineargradient2d createLinearGradient(real x0, real y0, real x1, real y1)
  • path2d createPath2D()
  • path2d createPath2D(path2d path)
  • path2d createPath2D(string svgPath)
  • imagepattern2d createPattern(Image image, string repetition)
  • radialgradient2d createRadialGradient(real x0, real y0, real r0, real x1, real y1, real r1)
  • transform2d createTransform2D()
  • void drawBoxShadow(boxshadow2d shadow)
  • void drawImage(variant image, real dx, real dy)
  • void drawImage(variant image, real dx, real dy, real dw, real dh)
  • void drawImage(variant image, real sx, real sy, real sw, real sh, real dx, real dy, real dw, real dh)
  • void ellipse(real centerX, real centerY, real radiusX, real radiusY)
  • void ellipseRect(real x, real y, real width, real height)
  • void fill()
  • void fill(string fillRule)
  • void fill(path2d path, int pathGroup)
  • void fill(path2d path, string fillRule, int pathGroup)
  • void fillRect(real x, real y, real width, real height)
  • void fillText(text, x, y, maxWidth)
  • void fillText(text, x, y, width, height)
  • transform2d getTransform()
  • void lineTo(real x, real y)
  • object measureText(text)
  • void moveTo(real x, real y)
  • void quadraticCurveTo(real cpx, real cpy, real x, real y)
  • void rect(real x, real y, real width, real height)
  • void removePathGroup(int pathGroup)
  • void reset()
  • void resetClipping()
  • void resetTransform()
  • void restore()
  • void rotate(real angle)
  • void roundRect(real x, real y, real width, real height, real radius)
  • void roundRect(real x, real y, real width, real height, real radiusTopLeft, real radiusTopRight, real radiusBottomRight, real radiusBottomLeft)
  • void save()
  • void scale(real scale)
  • void scale(real sx, real sy)
  • void setClipRect(real x, real y, real width, real height)
  • void setPathWinding(string winding)
  • void setTransform(transform2d transform)
  • void setTransform(real a, real b, real c, real d, real e, real f)
  • void skew(real angleX, real angleY)
  • void stroke()
  • void stroke(path2d path, int pathGroup)
  • void strokeRect(real x, real y, real width, real height)
  • void transform(transform2d transform)
  • void transform(real a, real b, real c, real d, real e, real f)
  • void translate(real x, real y)

Descripción detallada

El objeto Canvas2DContext se puede crear mediante el método getContext() del elemento Canvas:

Canvas2D {
  id: canvas
  onPaint: {
     var ctx = canvas.getContext('2d');
     //...
  }
}

La API de Context2D implementa el mismo estándar de la API de contexto 2D de Canvas del W3C con algunas características mejoradas.

La API de Context2D proporciona el contexto de renderizado que define los métodos y atributos necesarios para dibujar en el elemento Canvas. El siguiente código asigna el contexto de renderizado del lienzo a una variable context:

var context = mycanvas.getContext("2d")

A continuación se muestra un ejemplo sencillo del uso de Canvas2D para crear un botón redondo.

let offsetX = 2;
let offsetY = 4;
let shadow = ctx.createBoxShadow(40 + offsetX, 70 + offsetY,
                                 120, 60);
shadow.setRadius(30);
shadow.setBlur(15);
shadow.setColor("#60373F26");
ctx.drawBoxShadow(shadow);
// Paint rounded rect
ctx.beginPath();
ctx.roundRect(40, 70, 120, 60, 30);
ctx.fillStyle = "#DBEB00";
ctx.fill();
// Paint text
ctx.textAlign = "center";
ctx.textBaseline = "middle";
ctx.font = "24px 'Titillium Web'";
ctx.fillStyle = "#373F26";
ctx.fillText("CLICK!", 100, 100);

A continuación se muestra otro ejemplo de cómo dibujar un gráfico sencillo.

// Paint grid
const grid = ctx.createGridPattern(0, 0, 10, 10,
                                   "#404040",
                                   "#202020");
const w = 200;
const h = 200;
ctx.fillStyle = grid;
ctx.fillRect(0, 0, w, h);
// Paint axis
ctx.fillStyle = "white";
ctx.fillRect(0, 0.5 * h - 1, w, 2);
ctx.fillRect(0.5 * w - 1, 0, 2, h);
// Paint shadowed graph
ctx.beginPath();
ctx.moveTo(20, h * 0.8);
ctx.bezierCurveTo(w * 0.2, h * 0.4,
                  w * 0.5, h * 0.8,
                  w - 20, h * 0.2);
ctx.antialias = 10;
ctx.lineWidth = 12;
ctx.strokeStyle = "#D0000000";
ctx.stroke();
ctx.antialias = 1;
ctx.lineWidth = 6;
const lg = ctx.createLinearGradient(0, 0, 0, h);
lg.addColorStop(0, "red");
lg.addColorStop(1, "green");
ctx.strokeStyle = lg;
ctx.stroke();

Documentación de propiedades

antialias : real

Almacena el nivel actual de suavizado. Un mayor nivel de suavizado se traduce en un trazado más suave. Esto solo afecta al relleno y al trazo, no a las imágenes ni a los textos. El valor por defecto es 1.0 y el valor máximo es 10.0.

El suavizado se puede modificar por cada trazado, por lo que se puede configurar antes de cada trazo o relleno.

ctx.lineWidth = 6;
for (let i = 1; i < 10 ; i++) {
    let y = i * 20;
    ctx.antialias = i;
    ctx.beginPath();
    ctx.moveTo(20, y);
    ctx.bezierCurveTo(80, y + 20, 120,
                      y - 20, 180, y);
    ctx.stroke();
}

Véase también textAntialias.

canvas : Canvas2D

Contiene el elemento «canvas» sobre el que dibuja el contexto.

Esta propiedad es de solo lectura.

direction : string

Almacena la dirección actual utilizada para dibujar el texto. Los valores posibles son:

ConstanteDescripción
"inherit"(por defecto) La dirección del texto se hereda de la dirección de diseño de « QGuiApplication ». Véase https://doc.qt.io/qt-6/qguiapplication.html#layoutDirection-prop.
"ltr"La dirección del texto es de izquierda a derecha.
"rtl"La dirección del texto es de derecha a izquierda.
"auto"La dirección del texto se detecta automáticamente en función de la cadena de texto. Véase QString::isRightToLeft().

La dirección por defecto es "inherit".

ctx.textAlign = "center";
ctx.textBaseline = "middle";
ctx.font = "42px 'Titillium Web'";
ctx.fillStyle = "black";
ctx.fillText("Hi!", 100, 50);
ctx.direction = "rtl";
ctx.fillText("Hi!", 100, 150);

fillRule : string

Almacena la regla de relleno actual utilizada para rellenar formas. Este valor se aplica a todas las llamadas a fill() realizadas una vez establecida la regla. La regla de relleno predeterminada es "nonzero"

Se admiten las siguientes reglas de relleno:

ConstanteDescripción
"nonzero"(o «WindingFill») La ruta se rellena utilizando la regla de sentido de giro distinto de cero. Con esta regla, se determina si un punto se encuentra dentro de la forma mediante el siguiente método: se traza una línea horizontal desde el punto hasta una ubicación fuera de la forma. A continuación, se 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. Este modo de relleno también puede considerarse, en la mayoría de los casos, como la intersección de formas cerradas. Este modo es el predeterminado.
"evenodd"(o «OddEvenFill») El trazado se rellena utilizando la regla de relleno par-impar. Con esta regla, determinamos si un punto se encuentra dentro de la figura mediante el siguiente método. Se traza una línea horizontal desde el punto hasta una ubicación fuera de la forma y se cuenta el número de intersecciones. Si el número de intersecciones es impar, el punto se encuentra dentro de la forma.
function paintStar() {
    ctx.beginPath();
    ctx.moveTo(120, 60);
    for (let i = 1; i < 6; ++i) {
        ctx.lineTo(60 + 60 * Math.cos(0.8 * i * Math.PI),
            60 + 60 * Math.sin(0.8 * i * Math.PI));
    }
    ctx.fill();
    ctx.stroke();
};
ctx.fillRule = "nonzero";
paintStar();
ctx.translate(75, 75);
ctx.fillRule = "evenodd";
paintStar();

Véase también fill().

fillStyle : variant

Almacena el estilo actual utilizado para rellenar las formas. El estilo de relleno predeterminado es negro sólido («#000000»). El estilo puede ser una cadena que contenga un color CSS, QML color, o un objeto de pincel de lienzo. Los valores no válidos se ignoran. Esta propiedad admite varias sintaxis de color:

  • 'rgb(rojo, verde, azul)' —por ejemplo: 'rgb(255, 100, 55)' o 'rgb(100%, 70%, 30%)'
  • 'rgba(rojo, verde, azul, alfa)' —por ejemplo: 'rgb(255, 100, 55, 1,0)' o 'rgb(100 %, 70 %, 30 %, 0,5)'
  • «hsl(matiz, saturación, luminosidad)»
  • «hsla(tono, saturación, luminosidad, alfa)»
  • '#RRGGBB' —por ejemplo: '#00FFCC'
  • «#AARRGGBB» —por ejemplo: «#8000FFCC»—
  • Nombre de color SVG: por ejemplo, «black», «green» o «lightsteelblue»
  • Qt.hsla(tono, saturación, luminosidad, alfa) —por ejemplo: Qt.hsla(0,3; 0,7; 1; 1,0)—
  • Qt.rgba(rojo, verde, azul, alfa) —por ejemplo: Qt.rgba(0,3; 0,7; 1; 1,0)—

Si se asigna « fillStyle » o « strokeStyle » varias veces en un bucle, se debe optar por la sintaxis «Qt.rgba()», ya que ofrece el mejor rendimiento, puesto que ya es un valor válido de « QColor » y no es necesario analizarlo cada vez.

ctx.fillStyle = "black";
ctx.fillRect(20, 20, 160, 160);
ctx.fillStyle = Qt.rgba(0, 0.25, 0.3, 1);
ctx.fillRect(40, 40, 120, 120);
ctx.fillStyle = "#2CDE85";
ctx.fillRect(60, 60, 80, 80);
const g2 = ctx.createRadialGradient(140, 40, 0, 300);
g2.addColorStop(0, Qt.rgba(0.2, 0.8, 0.6));
g2.addColorStop(1, Qt.rgba(0, 0.25, 0.3, 1));
ctx.fillStyle = g2;
ctx.fillRect(20, 20, 160, 160);
g2.setCenterPosition(100, 100);
ctx.fillStyle = g2;
ctx.fillRect(40, 40, 120, 120);

Véase también createLinearGradient(), createRadialGradient(), createConicalGradient(), createBoxGradient(), createBoxShadow(), createPattern(), createGridPattern() y strokeStyle.

font : string

Almacena la configuración actual de la fuente.

Se admite un subconjunto del estándar W3C para fuentes en contexto 2D:

  • font-style (opcional): normal | italic | oblique
  • font-variant (opcional): normal | versalitas
  • font-weight (opcional): normal | negrita | 1 ... 1000
  • font-size: Npx | Npt (donde N es un número positivo)
  • font-family: Véase http://www.w3.org/TR/CSS2/fonts.html#propdef-font-family

Nota: Las propiedades «font-size» y «font-family» son obligatorias y deben aparecer en el orden indicado anteriormente. Además, las familias de fuentes cuyo nombre contenga espacios deben ir entre comillas.

El valor predeterminado de la fuente es «10px sans-serif».

globalAlpha : real

Almacena el valor alfa (transparencia) actual aplicado a las operaciones de renderizado. Este valor alfa se aplica a todas las formas renderizadas. Las rutas que ya sean transparentes también se volverán proporcionalmente más transparentes. El valor alfa debe estar entre 0,0 (totalmente transparente) y 1,0 (totalmente opaco). Por defecto, el valor alfa es 1.0.

ctx.fillStyle = "#d9f720";
for (let i = 0; i < 4; i++) {
    let x = 100 * (i % 2);
    let y = 100 * Math.floor(i / 2);
    ctx.globalAlpha = 1.0 - i * 0.3;
    ctx.fillRect(x, y, 100, 100);
    ctx.drawImage("qt_logo2.png", x, y, 100, 100);
}

globalBrightness : real

Almacena el valor actual de brillo aplicado a las operaciones de renderizado. Este brillo se aplica a todas las formas renderizadas. Un valor de 0 hará que el dibujo sea completamente negro. El valor también puede ser superior a 1,0 para aumentar el brillo. Por defecto, el brillo es 1.0.

ctx.fillStyle = "#d9f720";
for (let i = 0; i < 4; i++) {
    let x = 100 * (i % 2);
    let y = 100 * Math.floor(i / 2);
    ctx.globalBrightness = 1.5 - i * 0.45;
    ctx.fillRect(x, y, 100, 100);
    ctx.drawImage("qt_logo2.png", x, y, 100, 100);
}

globalCompositeOperation : string

Mantiene la operación de composición actual. Este modo se aplica a todas las operaciones de pintura. Las operaciones permitidas son:

ConstanteDescripción
"source-atop"A sobre B. Muestra la imagen de origen en todas las zonas en las que ambas imágenes sean opacas. Muestra la imagen de destino en todas las zonas en las que la imagen de destino sea opaca, pero la imagen de origen sea transparente. Muestra transparencia en el resto de zonas.
"source-over"(por defecto) A sobre B. Muestra la imagen de origen en todas las zonas en las que esta sea opaca. Muestra la imagen de destino en el resto de zonas.
"destination-out"B sobre A. Muestra la imagen de destino en todas aquellas zonas donde la imagen de destino sea opaca y la de origen sea transparente. Muestra transparencia en el resto de zonas.

Nota: Para que funcionen correctamente, los modos de composición requieren que se habilite la opción « alphaBlending » y que se utilice un fondo transparente para el lienzo.

const modes = ["source-over", "source-atop", "destination-out"];
for (let i = 0; i < modes.length; i++) {
    // First item - source-over mode
    ctx.globalCompositeOperation = "source-over";
    let y = 5 + i * 65;
    ctx.fillStyle = "#D9F720";
    ctx.fillRect(20, y, 140, 40);
    // Second item - Different modes
    ctx.globalCompositeOperation = modes[i];
    ctx.beginPath();
    ctx.ellipse(130, y + 30, 60, 25);
    ctx.strokeStyle = "#00414A";
    ctx.fillStyle = "#2CDE85";
    ctx.fill();
    ctx.stroke();
}

globalContrast : real

Almacena el valor de contraste actual aplicado a las operaciones de renderizado. Este contraste se aplica a todas las formas renderizadas. Un valor de 0 hará que el dibujo sea completamente gris (0,5; 0,5; 0,5). El valor también puede ser superior a 1,0 para aumentar el contraste. Por defecto, el contraste es de 1.0.

ctx.fillStyle = "#d9f720";
for (let i = 0; i < 4; i++) {
    let x = 100 * (i % 2);
    let y = 100 * Math.floor(i / 2);
    ctx.globalContrast = 1.5 - i * 0.45;
    ctx.fillRect(x, y, 100, 100);
    ctx.drawImage("qt_logo2.png", x, y, 100, 100);
}

globalSaturation : real

Almacena el valor de saturación actual aplicado a las operaciones de renderizado. Esta saturación se aplica a todas las formas renderizadas. Un valor de 0 desactivará la saturación y hará que el dibujo se muestre completamente en escala de grises. El valor también puede ser superior a 1,0 para aumentar la saturación. Por defecto, la saturación es 1.0.

ctx.fillStyle = "#d9f720";
for (let i = 0; i < 4; i++) {
    let x = 100 * (i % 2);
    let y = 100 * Math.floor(i / 2);
    ctx.globalSaturation = 1.5 - i * 0.5;
    ctx.fillRect(x, y, 100, 100);
    ctx.drawImage("qt_logo2.png", x, y, 100, 100);
}

highQualityStroking : bool

Mantiene el estado actual de habilitación del trazado de alta calidad. Si se establece en « true », se obtiene una representación más correcta en algunos casos menos habituales en los que el trazado se superpone y no tiene opacidad total. Habilitarlo conlleva un mayor coste de representación. El valor por defecto es « false ».

// Increase the line width and reduce opacity to get
// the stroking flaws visible.
ctx.lineWidth = 20;
ctx.globalAlpha = 0.5;
if (myPath.isEmpty()) {
    myPath.moveTo(30, 30);
    myPath.lineTo(40, 30);
    myPath.lineTo(80, 170);
    myPath.lineTo(80, 30);
    myPath.lineTo(70, 30);
}
ctx.highQualityStroking = true;
ctx.stroke(myPath);
ctx.highQualityStroking = false;
ctx.translate(90, 0);
ctx.stroke(myPath);

lineCap : string

Almacena el estilo actual del remate de línea. Los estilos de remate de línea posibles son:

ConstanteDescripción
"butt"(por defecto) El extremo de cada línea tiene un borde plano perpendicular a la dirección de la línea.
"round"Se añade al extremo de la línea un semicírculo cuyo diámetro es igual al ancho de la línea.
"square"Un rectángulo cuya longitud es igual al ancho de la línea y cuyo ancho es la mitad del ancho de la línea, colocado a ras del borde perpendicular a la dirección de la línea.
let path = ctx.createPath2D();
path.moveTo(40, 60);
path.lineTo(160, 60);
ctx.lineCap = "butt";
ctx.stroke(path);
ctx.lineCap = "square";
ctx.translate(0, 40);
ctx.stroke(path);
ctx.lineCap = "round";
ctx.translate(0, 40);
ctx.stroke(path);

lineJoin : string

Almacena el estilo de unión de líneas actual. Existe una unión en cualquier punto de una subruta compartida por dos líneas consecutivas. Cuando una subruta está cerrada, también existe una unión en su primer punto (equivalente a su último punto) que conecta la primera y la última línea de la subruta.

Los estilos de unión de líneas posibles son:

ConstanteDescripción
"bevel"Se rellena la muesca triangular entre las dos líneas.
"round"Se rellena un arco circular entre las dos líneas.
"miter"(predeterminado) Los bordes exteriores de las líneas se extienden hasta encontrarse en ángulo, y esta zona se rellena.
let path = ctx.createPath2D();
path.moveTo(40, 20);
path.lineTo(100, 80);
path.lineTo(160, 40);
path.lineTo(160, 70);
ctx.lineJoin = "miter";
ctx.stroke(path);
ctx.lineJoin = "bevel";
ctx.translate(0, 50);
ctx.stroke(path);
ctx.lineJoin = "round";
ctx.translate(0, 50);
ctx.stroke(path);

Véase también miterLimit.

lineWidth : real

Almacena el ancho de línea actual. El ancho de línea por defecto es 1.0. Cuando el suavizado está activado, los anchos de línea que ocupan un solo píxel se difuminan automáticamente, creando un resultado suave.

for (let i = 1; i < 10 ; i++) {
    let y = i * 20;
    ctx.lineWidth = 0.5 * i;
    ctx.beginPath();
    ctx.moveTo(20, y);
    ctx.bezierCurveTo(80, y + 20, 120,
                      y - 20, 180, y);
    ctx.stroke();
}

Véase también stroke().

miterLimit : real

Almacena la longitud límite actual del inglete. El límite del inglete controla cuándo se bisela una esquina afilada. Cuando la longitud de la esquina superaría este límite, se aplicará en su lugar un «bisel» lineJoin entre las líneas. Esto solo tiene efecto con la unión de líneas «inglete». El límite por defecto es 10.0.

let path = ctx.createPath2D();
path.moveTo(20, 40);
path.lineTo(30, 130);
path.lineTo(40, 40);
path.lineTo(55, 80);

ctx.lineJoin = "miter";
ctx.miterLimit = 20;
ctx.stroke(path);

ctx.miterLimit = 8;
ctx.translate(65, 0);
ctx.stroke(path);

ctx.miterLimit = 2;
ctx.translate(65, 0);
ctx.stroke(path);

Véase también lineJoin.

strokeStyle : variant

Almacena el color o estilo actual que se utilizará para las líneas que rodean las formas. El estilo puede ser una cadena que contenga un color CSS, QML color o un objeto de pincel de Canvas. Los valores no válidos se ignoran.

El valor por defecto es el negro («#000000»).

ctx.strokeStyle = "black";
ctx.strokeRect(20, 20, 160, 160);
ctx.strokeStyle = Qt.rgba(0, 0.25, 0.3, 1);
ctx.strokeRect(40, 40, 120, 120);
ctx.strokeStyle = "#2CDE85";
ctx.strokeRect(60, 60, 80, 80);
const g1 = ctx.createLinearGradient(180, 20, 20, 180);
g1.addColorStop(0, Qt.rgba(0.2, 0.8, 0.6));
g1.addColorStop(1, "black");
ctx.strokeStyle = g1;
ctx.strokeRect(20, 20, 160, 160);
g1.addColorStop(1, "yellow");
ctx.strokeStyle = g1;
ctx.strokeRect(40, 40, 120, 120);

Véase también createLinearGradient(), createRadialGradient(), createConicalGradient(), createBoxGradient(), createBoxShadow(), createPattern(), createGridPattern() y fillStyle.

textAlign : string

Almacena la configuración actual de alineación del texto. Los valores posibles son:

ConstanteDescripción
"start"(por defecto) Alinea con el borde inicial del texto (lado izquierdo en textos de izquierda a derecha, lado derecho en textos de derecha a izquierda).
"end"Alinear con el borde final del texto (lado derecho en texto de izquierda a derecha, lado izquierdo en texto de derecha a izquierda).
"left"Alinear a la izquierda.
"right"Alinear a la derecha.
"center"Centrar el texto.
ctx.font = "22px 'Titillium Web'";
ctx.fillRect(100, 0, 1, 200);
ctx.textAlign = "left";
ctx.fillText("Left", 100, 40);
ctx.textAlign = "center";
ctx.fillText("Center", 100, 70);
ctx.textAlign = "right";
ctx.fillText("Right", 100, 100);
ctx.textAlign = "start";
ctx.fillText("Start", 100, 130);
ctx.textAlign = "end";
ctx.fillText("End", 100, 160);

Véase también textBaseline.

textAntialias : real

Almacena el nivel actual de suavizado de texto. El valor es un multiplicador del suavizado normal, lo que significa que « 0.0 » desactiva el suavizado y « 2.0 » lo duplica. El valor por defecto is 1,0.

Nota: Debido a la técnica de suavizado de texto utilizada (SDF), el nivel máximo de suavizado es bastante limitado y esto se nota menos cuando el tamaño de la fuente es pequeño.

ctx.font = "22px 'Titillium Web'";
ctx.textAntialias = 1.0;
ctx.fillText("Antialiasing: 1.0", 100, 25);
ctx.textAntialias = 2.0;
ctx.fillText("Antialiasing: 2.0", 100, 75);
ctx.textAntialias = 3.0;
ctx.fillText("Antialiasing: 3.0", 100, 125);
ctx.textAntialias = 4.0;
ctx.fillText("Antialiasing: 4.0", 100, 175);

textBaseline : string

Almacena la configuración actual de alineación de la línea de base. Los valores posibles son:

ConstanteDescripción
"top"La parte superior del cuadrado «em»
"hanging"La línea de base colgante
"middle"El centro del cuadrado em
"alphabetic"(por defecto) La línea de base alfabética
"bottom"La parte inferior del cuadrado «em»
ctx.font = "22px 'Titillium Web'";
ctx.fillRect(0, 60, 200, 1);
ctx.fillRect(0, 140, 200, 1);
ctx.textBaseline = "bottom";
ctx.fillText("Bottom", 40, 60);
ctx.textBaseline = "middle";
ctx.fillText("Middle", 100, 60);
ctx.textBaseline = "top";
ctx.fillText("Top", 160, 60);
ctx.textBaseline = "alphabetic";
ctx.fillText("Alphabetic", 50, 140);
ctx.textBaseline = "hanging";
ctx.fillText("Hanging", 150, 140);

Véase también textAlign.

textLineHeight : real

Almacena el valor actual de ajuste de la altura de línea del texto en píxeles. La altura de línea predeterminada es 0.

ctx.strokeRect(40, 5, 120, 60);
ctx.strokeRect(40, 70, 120, 60);
ctx.strokeRect(40, 135, 120, 60);
ctx.textLineHeight = -10;
ctx.fillText("Text with line height: -10",
              40, 5, 120, 60);
ctx.textLineHeight = 0;
ctx.fillText("Text with line height: 0",
              40, 70, 120, 60);
ctx.textLineHeight = 10;
ctx.fillText("Text with line height: 10",
              40, 135, 120, 60);

textWrapMode : string

Establece el modo actual de ajuste de texto, es decir, cómo se distribuye el texto en varias líneas. Los valores posibles son:

ConstanteDescripción
"nowrap"(por defecto) No se realizará ningún ajuste de línea. Si el texto no contiene suficientes saltos de línea, contentWidth superará el ancho establecido.
"wrap"Si es posible, el ajuste se realiza en el límite de una palabra; de lo contrario, se realizará en el punto adecuado de la línea, incluso en medio de una palabra.
"wordwrap"El ajuste de línea se realiza únicamente en los límites de las palabras. Si una palabra es demasiado larga, el ancho del contenido superará el ancho establecido.
"wrapanywhere"El ajuste de línea se realiza en cualquier punto de la línea, incluso si se produce en medio de una palabra.

El modo de ajuste de línea predeterminado es « "nowrap" ».

ctx.strokeRect(50, 5, 100, 60);
ctx.strokeRect(50, 70, 100, 60);
ctx.strokeRect(50, 135, 100, 60);
let s = "This is a long string.";
ctx.textWrapMode = "nowrap";
ctx.fillText(s, 50, 5, 100, 60);
ctx.textWrapMode = "wrap";
ctx.fillText(s, 50, 70, 100, 60);
ctx.textWrapMode = "wrapanywhere";
ctx.fillText(s, 50, 135, 100, 60);

windingEnforce : bool

Mantiene el estado actual de activación de la sinuosidad de la ruta. Si se establece en « false », se desactiva la imposición de la sinuosidad de la ruta para que coincida con lo establecido en « setPathWinding()». Desactivarla permite, por ejemplo, crear huecos en las rutas añadiendo los puntos en el sentido de las agujas del reloj. Desactivarla también puede aumentar el rendimiento. El valor por defecto es « true ».

ctx.windingEnforce = false;
ctx.beginPath();
// Outer shape, counterclockwise
ctx.moveTo(20, 20);
ctx.lineTo(100, 180);
ctx.lineTo(180, 20);
ctx.closePath();
// Inner shape, clockwise
ctx.moveTo(100, 40);
ctx.lineTo(125, 90);
ctx.lineTo(75, 90);
ctx.closePath();
ctx.fill();
ctx.stroke();

Documentación del método

void addPath(path2d path, transform2d transform)

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

// myPath is path2d property
if (myPath.isEmpty())
    myPath.circle(60, 60, 40);
ctx.beginPath();
ctx.addPath(myPath);
let t = ctx.createTransform2D();
t.translate(80, 80);
ctx.addPath(myPath, t);
ctx.fill();
ctx.stroke();

void addPath(path2d path, int start, int count, transform2d transform)

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 intervalo entre start y count, de modo que no se acceda a más comandos de los que contiene la ruta. En caso de que la ruta no deba continuar desde la posición actual, llama primero a moveTo().

// myPath is QCanvasPath
if (myPath.isEmpty()) {
    myPath.moveTo(20, 60);
    for (let i = 1; i < 160; i++) {
        myPath.lineTo(20 + i,
            60 + 20 * Math.sin(0.1 * i));
    }
}
ctx.stroke(myPath);
ctx.beginPath();
let t = ctx.createTransform2D();
t.translate(0, 80);
ctx.addPath(myPath, 20, 100, t);
ctx.stroke();

void arc(real x, real y, real radius, real startAngle, real endAngle, bool anticlockwise)

Crea un nuevo subtrayecto con forma de arco circular. El centro del arco se encuentra en x, y, con radius, y el arco se dibuja desde el ángulo startAngle hasta endAngle. La dirección predeterminada de la curva es en el sentido de las agujas del reloj. Para cambiar la dirección a la opuesta, establece anticlockwise en «true». Los ángulos se especifican en radianes.

ctx.beginPath();
ctx.moveTo(100, 100);
ctx.arc(100, 100, 80, 0, 1.5 * Math.PI);
ctx.closePath();
ctx.fill();
ctx.stroke();

Nota: Aunque el contexto 2D de HTML canvas utiliza arc() para dibujar círculos, con Canvas2D se recomienda utilizar circle() o ellipse() para ello.

Véase también arcTo y el estándar de contexto 2D del W3C para arc().

void arcTo(real x1, real y1, real x2, real y2, real radius)

Añade un segmento de arco en la esquina definida por el último punto de la ruta y dos puntos especificados (x1, y1 y x2, y2) con radius. El arco se conecta automáticamente al último punto de la ruta mediante una línea recta si es necesario.

ctx.beginPath();
ctx.moveTo(20, 20);
ctx.arcTo(240, 20, 20, 220, 50);
ctx.arcTo(20, 220, 20, 20, 30);
ctx.stroke();

Véase también arc y el estándar de contexto 2D del W3C para arcTo().

void beginHoleSubPath()

Iniciar una subtrayectoria de agujero. Esto equivale a setPathWinding("clockwise")

ctx.beginPath();
ctx.circle(100, 100, 80);
ctx.beginHoleSubPath();
ctx.rect(60, 60, 80, 80);
ctx.beginSolidSubPath();
ctx.circle(100, 100, 20);
ctx.fill();
ctx.stroke();

Véase también beginSolidSubPath().

void beginPath()

Empieza a trazar una nueva ruta mientras borra la ruta actual.

void beginSolidSubPath()

Iniciar una subtrayectoria sólida. Esto equivale a setPathWinding("counterclockwise")

Véase también beginHoleSubPath().

void bezierCurveTo(real cp1x, real cp1y, real cp2x, real cp2y, real x, real y)

Añade un segmento de Bézier cúbico desde el último punto de la ruta, pasando por dos puntos de control (cp1x, cp1y y cp2x, cp2y), hasta el punto especificado (x, y).

ctx.beginPath();
ctx.moveTo(20, 20);
ctx.bezierCurveTo(150, 50, 50, 250, 180, 120);
ctx.stroke();

Véase también el estándar de contexto 2D del W3C para bezierCurveTo.

void circle(real centerX, real centerY, real radius)

Crea un nuevo subtrayecto con forma de círculo centrado en ( centerX, centerY) con radius.

ctx.beginPath();
ctx.circle(100, 100, 80);
ctx.fill();
ctx.stroke();

Nota: A diferencia de ` arc()`, este método no añade una línea recta desde el último punto del subtrayecto hasta el punto inicial del círculo.

void cleanupResources()

Programa la eliminación de texturas no utilizadas de la caché.

Además, al llamar a esta función, es posible que se reduzcan otros cachés y grupos, con el fin de minimizar el uso de memoria. Esto podría dar lugar a llamadas de dibujo más costosas posteriormente.

void clearRect(real x, real y, real width, real height)

Borra los píxeles de un área rectangular rellenando con negro transparente el rectángulo especificado por x, y, width y height. Dado que el borrado no requiere mezcla de colores, puede resultar más rápido que fillRect().

ctx.beginPath();
ctx.circle(100, 100, 80);
ctx.fill();
ctx.stroke();
ctx.clearRect(60, 0, 80, 120);

void closePath()

Cierra la subtrayectoria actual trazando una línea hasta el inicio de la misma, lo que inicia automáticamente una nueva trayectoria. El punto actual de la nueva trayectoria es el primer punto de la subtrayectoria anterior.

Véase también el estándar de contexto 2D del W3C para closePath.

boxgradient2d createBoxGradient(real x, real y, real width, real height, real feather, real radius)

Devuelve un objeto ` boxgradient2d ` que representa un degradado de cuadro que cubre el área del rectángulo (x, y, width, height) con un difuminado (suavizado) feather y un radio de esquina radius.

const bg = ctx.createBoxGradient(20, 20, 160, 160, 20, 50);
bg.addColorStop(0.0, "#1a2a6c");
bg.addColorStop(0.2, "#fdbb2d");
bg.addColorStop(1.0, "transparent");
ctx.fillStyle = bg;
ctx.fillRect(20, 20, 160, 160);

Véase también boxgradient2d::addColorStop(), fillStyle y strokeStyle.

boxshadow2d createBoxShadow(real x, real y, real width, real height)

Devuelve un objeto ` boxshadow2d ` que representa una sombra de cuadro que cubre el área del rectángulo (x, y, width, height).

let offsetX = -2;
let offsetY = 4;
let shadow = ctx.createBoxShadow(40 + offsetX,
                                 40 + offsetY,
                                 120, 120);
shadow.setBlur(30);
shadow.setColor("black");
ctx.drawBoxShadow(shadow);
ctx.beginPath();
ctx.roundRect(40, 40, 120, 120, 30);
ctx.fillStyle = "#2CDE85";
ctx.fill();

Véase también drawBoxShadow().

boxshadow2d createBoxShadow(real x, real y, real width, real height, real blur, string color, real radius)

Devuelve un objeto ` boxshadow2d ` con el color color, que representa una sombra de cuadro que cubre el área del rectángulo (x, y, width, height) con un desenfoque blur y un radio de esquina radius.

Véase también drawBoxShadow().

boxshadow2d createBoxShadow(real x, real y, real width, real height, real blur, string color, real radiusTopLeft, real radiusTopRight, real radiusBottomRight, real radiusBottomLeft)

Devuelve un objeto ` boxshadow2d ` con el color ` color `, que representa una sombra de cuadro que cubre el área del rectángulo (x, y, width, height) con un desenfoque de ` blur ` y un radio de esquina de (radiusTopLeft, radiusTopRight, radiusBottomRight, radiusBottomLeft).

Véase también drawBoxShadow().

conicalgradient2d createConicalGradient(real x, real y, real angle)

Devuelve un objeto ` conicalgradient2d ` que representa un degradado cónico que interpola colores en sentido antihorario alrededor de un punto central (x, y) con un ángulo inicial angle en radianes.

const cg = ctx.createConicalGradient(100, 100, 1.75 * Math.PI);
cg.addColorStop(0.0, "#fdbb2d");
cg.addColorStop(0.5, "#1a2a6c");
cg.addColorStop(1.0, "#fdbb2d");
ctx.fillStyle = cg;
ctx.beginPath();
ctx.ellipseRect(20, 20, 160, 160);
ctx.fill();

Véase también conicalgradient2d::addColorStop(), createLinearGradient(), createRadialGradient(), createPattern(), fillStyle y strokeStyle.

gridpattern2d createGridPattern(real x, real y, real width, real height, string lineColor, string backgroundColor, real lineWidth, real feather, real angle)

Devuelve un objeto ` gridpattern2d ` que abarca el área del rectángulo (x, y, width, height). La cuadrícula utiliza lineColor para las líneas y backgroundColor para el fondo. El grosor de la línea es lineWidth, el difuminado de la línea es feather y el ángulo de rotación es angle en radianes.

const grid = ctx.createGridPattern(0, 0, 10, 10,
                    "#404040", "#202020");
ctx.fillStyle = grid;
ctx.fillRect(0, 0, 200, 200);

lineargradient2d createLinearGradient(real x0, real y0, real x1, real y1)

Devuelve un objeto ` lineargradient2d ` que representa un degradado lineal en el que el color cambia progresivamente a lo largo de una línea entre el punto inicial (x0, y0) y el punto final (x1, y1).

Los degradados deben tener dos o más paradas de color, que representan cambios de color situados entre 0 y 1 entre los puntos inicial y final del degradado.

const lg = ctx.createLinearGradient(0, 0, 200, 200);
lg.addColorStop(0.0, "#1a2a6c");
lg.addColorStop(0.5, "#b21f1f");
lg.addColorStop(1.0, "#fdbb2d");
ctx.fillStyle = lg;
ctx.fillRect(0, 0, 200, 200);

Véase también lineargradient2d::addColorStop(), createRadialGradient(), createConicalGradient(), createPattern(), fillStyle y strokeStyle.

path2d createPath2D()

Devuelve un nuevo objeto `Path2D`. Llamar a este método equivale al comando «new Path2D()» del lienzo HTML.

Véase también « fill()» y « stroke()».

path2d createPath2D(path2d path)

Devuelve un nuevo objeto `path2d`, con la copia de ` path`. Llamar a esta función equivale al comando «new Path2D(path)» del lienzo HTML.

Véanse también ` fill()` y ` stroke()`.

path2d createPath2D(string svgPath)

Devuelve un nuevo objeto `Path2D`, con el contenido de svgPath. Llamar a esta función equivale al comando HTML de `canvas` «new Path2D(d)».

Véase también fill() y stroke().

imagepattern2d createPattern(Image image, string repetition)

Devuelve un objeto ` imagepattern2d ` que utiliza la imagen indicada y la repite en la dirección o direcciones especificadas por el argumento «repetition».

El parámetro ` image ` debe ser un elemento `Image` válido o una URL de imagen cargada. Si no hay datos de imagen, esta función lanza una excepción `INVALID_STATE_ERR`.

Los valores permitidos para ` repetition ` son:

ConstanteDescripción
"repeat"ambas direcciones
"repeat-xsolo horizontal
"repeat-y"solo vertical
"no-repeat"ninguna

Si el argumento de repetición está vacío o es nulo, se utiliza el valor «repeat».

let ip1 = ctx.createPattern("pattern2.png", "repeat");
let ip2 = ctx.createPattern("pattern3.png", "repeat");
ip1.setImageSize(64, 64);
ip2.setImageSize(32, 32);
ctx.beginPath();
ctx.roundRect(20, 20, 160, 160, 40);
ctx.fillStyle = ip1;
ctx.strokeStyle = ip2;
ctx.fill();
ctx.lineWidth = 20;
ctx.stroke();

Véase también strokeStyle y fillStyle.

radialgradient2d createRadialGradient(real x0, real y0, real r0, real x1, real y1, real r1)

Devuelve un objeto ` radialgradient2d ` que representa un degradado radial que se traza a lo largo del cono definido por el círculo inicial, con origen en (x0, y0) y radio r0, y el círculo final, con origen en (x1, y1) y radio r1.

Al haber solo cuatro parámetros, estos se utilizan como (x, y, r0, r1), donde la posición del centro es la misma tanto para el radio interior como para el exterior.

const rg = ctx.createRadialGradient(100, 100, 0, 100);
rg.addColorStop(0.0, "#fdbb2d");
rg.addColorStop(0.6, "#b21f1f");
rg.addColorStop(1.0, "#1a2a6c");
ctx.fillStyle = rg;
ctx.fillRect(0, 0, 200, 200);
const rg = ctx.createRadialGradient(50, 50, 0,
                                    100, 100, 90);
rg.addColorStop(0.0, "black");
rg.addColorStop(1.0, "white");
ctx.fillStyle = rg;
ctx.fillRect(0, 0, 200, 200);

Véase también radialgradient2d::addColorStop(), createLinearGradient(), createConicalGradient(), createPattern(), fillStyle y strokeStyle.

transform2d createTransform2D()

Devuelve un nuevo objeto `transform2d`, inicializado con la matriz identidad.

Véase también getTransform().

void drawBoxShadow(boxshadow2d shadow)

Dibuja un cuadro dado shadow. La sombra se pintará con la posición, el tamaño, el color, el desenfoque, etc., definidos por shadow. No es necesario llamar a beginPath() antes de este método.

let offsetX = -2;
let offsetY = 4;
let shadow = ctx.createBoxShadow(40 + offsetX,
                                 40 + offsetY,
                                 120, 120,
                                 30, "black", 0);
ctx.drawBoxShadow(shadow);
ctx.beginPath();
ctx.roundRect(40, 40, 120, 120, 30);
ctx.fillStyle = "#2CDE85";
ctx.fill();

Véase también createBoxShadow().

void drawImage(variant image, real dx, real dy)

Dibuja el elemento « image » especificado en el lienzo en la posición (dx, dy). Nota: El tipo « image » puede ser un elemento «Image» o una URL de imagen. Cuando se proporciona como elemento «Image», si la imagen no se ha cargado por completo, este método no dibuja nada. Cuando se proporciona como cadena de URL, la imagen debe cargarse llamando primero al método « Canvas2D::loadImage()» del elemento «Canvas». Este dibujo está sujeto a la ruta de recorte del contexto actual.

ctx.drawImage("qt_logo.png", 36, 36);

Véase también Image, Canvas2D::loadImage, Canvas2D::isImageLoaded, Canvas2D::imageLoaded y el estándar de contexto 2D del W3C para drawImage.

void drawImage(variant image, real dx, real dy, real dw, real dh)

Esta es una función sobrecargada. Dibuja el elemento dado como « image » en el lienzo, en el punto (dx, dy) y con un ancho de dw y una altura de dh.

ctx.drawImage("qt_logo.png", 50, 0, 100, 200);

Véase también Image, Canvas2D::loadImage(), Canvas2D::isImageLoaded, Canvas2D::imageLoaded y el estándar del contexto 2D del W3C para drawImage.

void drawImage(variant image, real sx, real sy, real sw, real sh, real dx, real dy, real dw, real dh)

Esta es una función sobrecargada. Dibuja el elemento dado como un « image » a partir del punto de origen (sx, sy), el ancho de origen sw y la altura de origen sh, sobre el lienzo en el punto (dx, dy) y con un ancho de dw y una altura de dh.

ctx.drawImage("qt_logo.png",
               20, 30, 54, 76,
               0, 0, 200, 200);

Véase también Image, Canvas2D::loadImage(), Canvas2D::isImageLoaded, Canvas2D::imageLoaded y el estándar de contexto 2D del W3C para drawImage.

void ellipse(real centerX, real centerY, real radiusX, real radiusY)

Crea un nuevo subtrayecto con forma de elipse centrado en ( centerX, centerY) con radiusX y radiusY.

ctx.beginPath();
ctx.ellipse(100, 100, 80, 60);
ctx.fill();
ctx.stroke();

void ellipseRect(real x, real y, real width, real height)

Crea un nuevo subtrayecto con forma de elipse dentro del rectángulo: x, y, width, height. Esta elipse cubrirá el área del rectángulo.

ctx.fillRect(40, 20, 120, 160);
ctx.beginPath();
ctx.ellipseRect(40, 20, 120, 160);
ctx.stroke();

Nota: Este método es equivalente a QtQuick::Context2D::ellipse()

void fill()

Rellena el trazado actual con el estilo de relleno actual y la regla de relleno actual.

ctx.beginPath();
ctx.rect(20, 20, 40, 160);
ctx.rect(140, 20, 40, 160);
ctx.circle(100, 100, 60);
ctx.fill();

Véase también fillStyle, fillRule y el estándar del W3C sobre el contexto 2D para el relleno.

void fill(string fillRule)

Rellena el trazado actual con el estilo de relleno actual y la regla de relleno fillRule.

Véase también fillStyle y fillRule.

void fill(path2d path, int pathGroup)

Rellena el ` path ` con el estilo y la regla de relleno actuales, y lo incluye en el ` pathGroup` opcional. El relleno mediante ` QCanvasPath ` resulta óptimo cuando la ruta contiene más comandos y es mayoritariamente estática.

Cuando pathGroup es -1, la ruta no se almacenará en caché en la GPU. Este es el valor por defecto. Para solicitar el almacenamiento en caché de los datos de la ruta, se debe pasar un valor igual o superior a 0. Se puede encontrar más información sobre el uso de grupos de caché de rutas en la documentación de QCanvasPath.

No es necesario llamar a ` beginPath()` antes de este método.

// myPath is path2d
if (myPath.isEmpty()) {
    for (let i = 0; i < 16; i++) {
        let w = 100 + 60 * Math.sin(i);
        myPath.rect(100 - w * 0.5,
                    22 + i * 10,
                    w, 6);
    }
}
ctx.fill(myPath);

Véase también ` fillStyle ` y ` path2d`.

void fill(path2d path, string fillRule, int pathGroup)

Rellena el elemento « path » con el estilo de relleno actual y utilizando « fillRule ». El parámetro del grupo de caché « pathGroup » es opcional.

Véase también fillStyle, fillRule y path2d.

void fillRect(real x, real y, real width, real height)

Dibuja un rectángulo relleno en la posición especificada ( x, y) con el tamaño width, height.

Nota: Esta función se proporciona por comodidad. Cuando se vaya a rellenar más de un rectángulo, es preferible utilizar rect().

ctx.fillRect(20, 20, 160, 160);
// The above code does same as:
// ctx.beginPath();
// ctx.rect(20, 20, 160, 160);
// ctx.fill();

Véase también fillStyle.

void fillText(text, x, y, maxWidth)

Dibuja una cadena de tipo « text » en la ubicación especificada ( x, y), con los valores actuales de « textAlign » y « textBaseline ». Para que el texto se ajuste a varias líneas, configura el modo de ajuste de texto mediante « textWrapMode » con un valor distinto al predeterminado « "nowrap" ». El parámetro opcional « maxWidth » toma por defecto el valor « 0 ». Esto significa que, por ejemplo, si se ha establecido « "wordwrap" », el texto se ajustará a cada palabra. Establece el parámetro « maxWidth » en el ancho de fila deseado en píxeles.

ctx.textAlign = "center";
ctx.textBaseline = "middle";
const text = "Qt Canvas Painter";
ctx.fillText(text, 100, 30);
ctx.textWrapMode = "wordwrap";
ctx.fillText(text, 100, 90);
ctx.fillText(text, 100, 160, 120);

Véase también font, textAlign, textBaseline y textWrapMode.

void fillText(text, x, y, width, height)

Dibuja una cadena « text » dentro del rectángulo (x, y, width, height), con los valores actuales de « textAlign » y « textBaseline ». El ancho del parámetro «rect» se utiliza como «maxWidth».

A menudo resulta útil establecer la línea de base del texto en TextBaseline::Top o TextBaseline::Middle al dibujar texto con este método.

ctx.textAlign = "center";
ctx.textBaseline = "middle";
const text = "Qt Canvas Painter";
ctx.strokeRect(10, 20, 180, 50);
ctx.fillText(text, 10, 20, 180, 50);
ctx.textWrapMode = "wordwrap";
ctx.strokeRect(60, 90, 80, 90);
ctx.fillText(text, 60, 90, 80, 90);

Véase también font, textAlign, textBaseline y textWrapMode.

transform2d getTransform()

Devuelve la matriz de transformación actual.

Véase también setTransform().

void lineTo(real x, real y)

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

ctx.beginPath();
ctx.moveTo(20, 20);
ctx.lineTo(140, 180);
ctx.lineTo(180, 120);
ctx.stroke();

object measureText(text)

Devuelve un objeto con una propiedad ` width `, cuyo valor es equivalente a llamar a ` QFontMetricsF::horizontalAdvance()` con el ` text ` indicado en la fuente actual.

void moveTo(real x, real y)

Crea una nueva subruta con un punto en (x, y).

void quadraticCurveTo(real cpx, real cpy, real x, real y)

Añade un segmento Bézier cuadrático desde el último punto de la ruta, pasando por un punto de control (cpx, cpy), hasta el punto especificado (x, y).

ctx.beginPath();
ctx.moveTo(20, 20);
ctx.quadraticCurveTo(150, 50, 180, 180);
ctx.quadraticCurveTo(20, 220, 20, 20);
ctx.fill();
ctx.stroke();

Véase también el estándar del W3C sobreel contexto 2D para la función quadraticCurveTo.

void rect(real x, real y, real width, real height)

Crea un nuevo subtrayecto con forma de rectángulo en la posición x, y, con las dimensiones width, height.

ctx.beginPath();
ctx.rect(20, 20, 160, 160);
ctx.fill();
ctx.stroke();

void removePathGroup(int pathGroup)

Elimina « pathGroup » de la caché del pintor. Si después de esto se llama a « fill()» o « stroke()» para « pathGroup », se volverá a generar la ruta en la caché del grupo.

Nota: Normalmente no es necesario llamar aesta función , ya que las rutas se eliminan en el destructor del pintor. Utilízala únicamente para reducir el consumo de memoria cuando ya no se necesite pathGroup o, por ejemplo, cuando la ruta tenga muchos menos comandos de los que tenía anteriormente y sea necesario reducir el tamaño del búfer.

Véase también fill() y stroke().

void reset()

Restablece el estado actual del pintor a los valores predeterminados.

Nota: Este método difiere del método reset() del contexto 2D del lienzo HTML, ya que no borra visualmente los búferes del lienzo.

// Adjust the paint state
ctx.strokeStyle = "#00414A";
ctx.fillStyle = "#2CDE85";
ctx.lineWidth = 10;
ctx.translate(100, 65);
ctx.rotate(-0.4);
ctx.translate(-100, -65);
ctx.beginPath();
ctx.roundRect(20, 40, 160, 50, 20);
ctx.fill();
ctx.stroke();
// Reset to default paint state
ctx.reset();
ctx.fillRect(20, 140, 60, 40);
ctx.strokeRect(120, 140, 60, 40);

Véase también ` save()` y ` restore()`.

void resetClipping()

Restablece y desactiva el recorte.

Véase también setClipRect().

void resetTransform()

Restablece la matriz de transformación a su valor por defecto (equivalente a llamar a setTransform(1, 0, 0, 1, 0, 0)).

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

void restore()

Extrae y restaura el estado de renderizado actual. De este modo, se restaurará el estado guardado anteriormente. Si no se ha llamado a save() y la pila de estados está vacía, llamar a esta función no tiene ningún efecto.

Véase también save().

void rotate(real angle)

Gira el sistema de coordenadas actual en el sentido de las agujas del reloj un ángulo de angle.

El ángulo se especifica en radianes.

ctx.translate(100, 100);
ctx.rotate(Math.PI / 4);
ctx.translate(-100, -100);
ctx.beginPath();
ctx.roundRect(20, 70, 160, 60, 10);
ctx.fill();
ctx.stroke();
ctx.fillStyle = "black";
ctx.fillText("Cute!", 100, 100);

void roundRect(real x, real y, real width, real height, real radius)

Crea un nuevo subtrayecto con forma de rectángulo redondeado en la posición x, y, con el tamaño width, height. El redondeo de las esquinas será radius.

ctx.beginPath();
ctx.roundRect(20, 20, 160, 160, 30);
ctx.fill();
ctx.stroke();

void roundRect(real x, real y, real width, real height, real radiusTopLeft, real radiusTopRight, real radiusBottomRight, real radiusBottomLeft)

Crea un nuevo subtrazo con forma de rectángulo redondeado en la posición x, y, con un tamaño de width, height. El redondeo de las esquinas puede variar en cada esquina, con radiusTopLeft, radiusTopRight, radiusBottomRight, radiusBottomLeft.

ctx.beginPath();
ctx.roundRect(20, 20, 160, 160,
              0, 40, 20, 80);
ctx.fill();
ctx.stroke();

void save()

Inserta y guarda el estado de renderizado actual en una pila de estados. Para restaurar el estado, es necesario utilizar la función correspondiente ` restore()`.

Nota: La ruta actual NO forma parte del estado de dibujo. La ruta se puede restablecer llamando al método beginPath().

ctx.strokeRect(20, 20, 160, 40);
// Save and adjust the paint state
ctx.save();
ctx.strokeStyle = "black";
ctx.lineWidth = 3;
ctx.rotate(0.1);
ctx.strokeRect(20, 80, 180, 20);
// Restore the saved paint state
ctx.restore();
ctx.strokeRect(20, 140, 160, 40);

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

void scale(real scale)

Aplica una escala al sistema de coordenadas actual mediante ` scale`. Las coordenadas x e y se escalan de forma uniforme.

for (let i = 0; i < 20; i++) {
    ctx.beginPath();
    ctx.roundRect(20, 20, 160, 160, 10);
    ctx.stroke();
    ctx.translate(100, 100);
    ctx.scale(0.8);
    ctx.translate(-100, -100);
}

void scale(real sx, real sy)

Aumenta o reduce el tamaño de cada unidad de la cuadrícula del lienzo multiplicando los factores de escala por la matriz de transformación actual. sx es el factor de escala en la dirección horizontal y sy es el factor de escala en la dirección vertical.

El siguiente código duplica el tamaño horizontal de un objeto dibujado en el lienzo y reduce a la mitad su tamaño vertical:

ctx.scale(2.0, 0.5);

void setClipRect(real x, real y, real width, real height)

Establece el rectángulo de recorte actual en (x, y, width, height). El rectángulo de recorte se transforma mediante la transformación actual.

Nota: El recorte tiene un cierto coste en cuanto al rendimiento y solo debe utilizarse cuando sea necesario.

ctx.setClipRect(20, 20, 160, 160);
ctx.beginPath();
ctx.circle(40, 40, 110);
ctx.fill();
ctx.fillStyle = "black";
ctx.fillText("Clip me...", 45, 100);
ctx.strokeRect(20, 20, 160, 160);

Véase también resetClipping().

void setPathWinding(string winding)

Establece la subtrayectoria actual winding en «en sentido antihorario» (por defecto) o «en sentido horario». La opción «en sentido antihorario» dibuja subtrayectorias sólidas, mientras que la opción «en sentido horario» dibuja agujeros.

ctx.beginPath();
ctx.roundRect(20, 20, 160, 160, 40);
ctx.setPathWinding("clockwise");
ctx.circle(140, 60, 20);
ctx.rect(60, 120, 80, 30);
ctx.fill();
ctx.stroke();

Véase también beginHoleSubPath() y beginSolidSubPath().

void setTransform(transform2d transform)

Restablece la transformación actual y utiliza en su lugar transform.

ctx.beginPath();
ctx.roundRect(80, 20, 40, 40, 10);
ctx.fill();
ctx.stroke();
let t = ctx.createTransform2D();
t.translate(100, 20);
t.rotate(45);
t.scale(2.0, 2.0);
ctx.setTransform(t);
ctx.beginPath();
ctx.roundRect(20, 20, 40, 40, 10);
ctx.fill();
ctx.stroke();

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

void setTransform(real a, real b, real c, real d, real e, real f)

Cambia la matriz de transformación por la matriz indicada en los argumentos, tal y como se describe a continuación.

Modificar directamente la matriz de transformación te permite realizar transformaciones de escalado, rotación y traslación en un solo paso.

Cada punto del lienzo se multiplica por la matriz antes de que se dibuje nada. La especificación del contexto 2D de HTML Canvas define la matriz de transformación donde:

  • a es el factor de escala en la dirección horizontal (x)
  • c es el factor de inclinación en la dirección x
  • e es la traslación en la dirección x
  • b es el factor de inclinación en la dirección y (vertical)
  • d es el factor de escala en la dirección y
  • f es la traslación en la dirección y
  • la última fila permanece constante

Los factores de escala y los factores de inclinación son múltiplos; e y f son unidades del espacio de coordenadas, al igual que las unidades del método translate(x,y).

Véase también transform().

void skew(real angleX, real angleY)

Desplaza (deforma) el sistema de coordenadas actual a lo largo del eje X en un ángulo de angleX y a lo largo del eje Y en un ángulo de angleY. El valor por defecto de angleY es 0 cuando solo se especifica un parámetro. Los ángulos se expresan en radianes.

ctx.translate(100, 100);
ctx.skew(-0.6);
ctx.translate(-100, -100);
ctx.beginPath();
ctx.roundRect(40, 70, 120, 60, 10);
ctx.fill();
ctx.stroke();
ctx.fillStyle = "black";
ctx.fillText("Cute!", 100, 100);

void stroke()

Traza el trazado actual con el estilo de trazo actual.

ctx.beginPath();
ctx.rect(20, 20, 40, 160);
ctx.rect(140, 20, 40, 160);
ctx.circle(100, 100, 60);
ctx.stroke();

Véase también strokeStyle y la norma del W3C sobre el contexto 2D para el trazo.

void stroke(path2d path, int pathGroup)

Dibuja el « path » con el estilo de trazo actual y lo incluye en « pathGroup ». El trazado mediante « QCanvasPath » resulta óptimo cuando la ruta contiene más comandos y es mayoritariamente estática.

Cuando pathGroup es -1, los datos relacionados con la representación de la ruta no se almacenarán en caché. Este es el valor por defecto. Para solicitar el almacenamiento en caché de los datos de la ruta, pasa un valor igual o superior a 0. Puedes encontrar más información sobre el uso de grupos de caché de rutas en la documentación de QCanvasPath.

No es necesario llamar a ` beginPath()` antes de este método.

// myPath is path2d
if (myPath.isEmpty()) {
    for (let i = 0; i < 16; i++) {
        let h = 100 + 60 * Math.sin(i);
        myPath.rect(22 + i * 10,
                    180 - h,
                    6, h);
    }
}
ctx.stroke(myPath);

Véase también strokeStyle, path2d y la norma del W3C sobre el contexto 2D para el trazo.

void strokeRect(real x, real y, real width, real height)

Dibuja un rectángulo con trazo en la posición especificada ( x, y) con el tamaño width, height.

Nota: Esta función se proporciona por comodidad. Cuando se vayan a trazar más de un rectángulo, es preferible utilizar ` rect()`.

ctx.strokeRect(20, 20, 160, 160);
// The above code does same as:
// ctx.beginPath();
// ctx.rect(20, 20, 160, 160);
// ctx.stroke();

Véase también strokeStyle, lineWidth, lineJoin y miterLimit.

void transform(transform2d transform)

Multiplica el sistema de coordenadas actual por el valor especificado en « transform ».

let t = ctx.createTransform2D();
t.translate(100, 100);
t.rotate(36);
t.translate(-100, -100);
for (let i = 0; i < 10; i++) {
    ctx.transform(t);
    ctx.beginPath();
    ctx.roundRect(80, 15, 40, 20, 10);
    ctx.fill();
    ctx.stroke();
}

Véase también setTransform().

void transform(real a, real b, real c, real d, real e, real f)

Multiplica el sistema de coordenadas actual por la transformación especificada (a, b, c, d, e, f).

Este método es similar a ` setTransform()`, pero en lugar de sustituir la matriz de transformación anterior, este método aplica la matriz de transformación dada a la matriz actual multiplicándola por ella.

Véase también setTransform().

void translate(real x, real y)

Traslada el sistema de coordenadas actual mediante x y y.

function paintRect() {
    ctx.beginPath();
    ctx.roundRect(20, 20, 160, 60, 10);
    ctx.fill();
    ctx.stroke();
};
paintRect();
ctx.translate(0, 100);
paintRect();

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