Context2D QML Type
Proporciona un contexto 2D para las figuras de un elemento «Canvas». Más...
| Import Statement: | import QtQuick |
Propiedades
- canvas : QtQuick::Canvas
- fillRule : enumeration
- fillStyle : variant
- font : string
- globalAlpha : real
- globalCompositeOperation : string
- lineCap : string
- lineDashOffset : real
(since QtQuick 2.11) - lineJoin : string
- lineWidth : real
- miterLimit : real
- shadowBlur : real
- shadowColor : string
- shadowOffsetX : real
- shadowOffsetY : real
- strokeStyle : variant
- textAlign : string
- textBaseline : string
Métodos
- Context2D arc(real x, real y, real radius, real startAngle, real endAngle, bool anticlockwise)
- Context2D arcTo(real x1, real y1, real x2, real y2, real radius)
- Context2D beginPath()
- Context2D bezierCurveTo(real cp1x, real cp1y, real cp2x, real cp2y, real x, real y)
- Context2D clearRect(real x, real y, real w, real h)
- Context2D clip()
- Context2D closePath()
- CanvasGradient createConicalGradient(real x, real y, real angle)
- CanvasImageData createImageData(CanvasImageData imageData)
- CanvasImageData createImageData(Url imageUrl)
- CanvasImageData createImageData(real sw, real sh)
- CanvasGradient createLinearGradient(real x0, real y0, real x1, real y1)
- variant createPattern(Image image, string repetition)
- variant createPattern(color color, enumeration patternMode)
- CanvasGradient createRadialGradient(real x0, real y0, real r0, real x1, real y1, real r1)
- 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)
- Context2D ellipse(real x, real y, real w, real h)
- Context2D fill()
- Context2D fillRect(real x, real y, real w, real h)
- Context2D fillText(text, x, y)
- CanvasImageData getImageData(real x, real y, real w, real h)
- array getLineDash()
(since QtQuick 2.11) - bool isPointInPath(real x, real y)
- Context2D lineTo(real x, real y)
- var measureText(text)
- Context2D moveTo(real x, real y)
- void putImageData(CanvasImageData imageData, real dx, real dy, real dirtyX, real dirtyY, real dirtyWidth, real dirtyHeight)
- Context2D quadraticCurveTo(real cpx, real cpy, real x, real y)
- Context2D rect(real x, real y, real w, real h)
- Context2D reset()
- Context2D resetTransform()
- Context2D restore()
- Context2D rotate(real angle)
- Context2D roundedRect(real x, real y, real w, real h, real xRadius, real yRadius)
- Context2D save()
- Context2D scale(real x, real y)
- void setLineDash(array pattern)
(since QtQuick 2.11) - Context2D setTransform(real a, real b, real c, real d, real e, real f)
- Context2D shear(real sh, real sv)
- Context2D stroke()
- Context2D strokeRect(real x, real y, real w, real h)
- Context2D strokeText(text, x, y)
- Context2D text(string text, real x, real y)
- Context2D transform(real a, real b, real c, real d, real e, real f)
- Context2D translate(real x, real y)
Descripción detallada
El objeto Context2D se puede crear mediante el método ` getContext() ` de un elemento ` Canvas `:
Canvas {
id:canvas
onPaint:{
var ctx = canvas.getContext('2d');
//...
}
}La API de Context2D implementa el mismo estándar de la API de contexto 2D de W3C Canvas, con algunas características mejoradas.
La API de Context2D proporciona el contexto de representación que define los métodos y atributos necesarios para dibujar en el elemento ` Canvas `. El siguiente código asigna el contexto de representación del lienzo a una variable ` context `:
var context = mycanvas.getContext("2d")La API Context2D representa el lienzo como un sistema de coordenadas cuyo origen (0,0) se encuentra en la esquina superior izquierda, tal y como se muestra en la siguiente figura. Las coordenadas aumentan a lo largo del eje x de izquierda a derecha y a lo largo del eje y de arriba abajo del lienzo.

Documentación de propiedades
canvas : QtQuick::Canvas
Contiene el elemento «canvas» sobre el que dibuja el contexto.
Esta propiedad es de solo lectura.
fillRule : enumeration
Almacena la regla de relleno actual que se utiliza para rellenar figuras. Se admiten las siguientes reglas de relleno:
| Constante | Descripción |
|---|---|
Qt.OddEvenFill | Qt::OddEvenFill |
Qt.WindingFill | (por defecto) Qt::WindingFill Nota: A diferencia de « QPainterPath », la API de Canvas utiliza el relleno «winding» como regla de relleno predeterminada. La propiedad «fillRule» forma parte del estado de renderizado del contexto. |
Véase también fillStyle.
fillStyle : variant
Almacena el estilo actual utilizado para rellenar formas. El estilo puede ser una cadena que contenga un color CSS, un objeto ` CanvasGradient ` o un objeto `CanvasPattern`. Se ignoran los valores no válidos. 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(tono, saturación, luminosidad)»
- «hsla(tono, saturación, luminosidad, alfa)»
- '#RRGGBB' —por ejemplo: '#00FFCC'
- 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 elegir la última sintaxis «Qt.rgba()», ya que ofrece el mejor rendimiento, pues ya es un valor válido de « QColor » y no es necesario analizarlo cada vez.
El valor por defecto es «#000000».
Véase también createLinearGradient(), createRadialGradient(), createPattern() y strokeStyle.
font : string
Almacena la configuración actual de la fuente.
Se admite un subconjunto del estándar de contexto 2D del W3C para fuentes:
- 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 en que se muestran arriba. Además, una familia tipográfica cuyo nombre contenga espacios debe ir entre comillas.
El valor predeterminado de la fuente es «10px sans-serif».
globalAlpha : real
Almacena el valor alfa actual aplicado a las operaciones de renderizado. El valor debe estar comprendido entre 0.0 (totalmente transparente) y 1.0 (totalmente opaco). El valor por defecto es 1.0.
globalCompositeOperation : string
Mantiene la operación de composición actual. Las operaciones permitidas son:
| Constante | Descripción |
|---|---|
"source-atop" | QPainter::CompositionMode_SourceAtop A sobre B. Muestra la imagen de origen en todas las zonas en las que ambas imágenes son opacas. Muestra la imagen de destino en todas las zonas en las que la imagen de destino es opaca, pero la de origen es transparente. Muestra transparencia en el resto de zonas. |
"source-in" | QPainter::CompositionMode_SourceIn A en B. Muestra la imagen de origen en todas aquellas zonas en las que tanto la imagen de origen como la de destino sean opacas. Muestra transparencia en el resto de zonas. |
"source-out" | QPainter::CompositionMode_SourceOut A fuera de B. Muestra la imagen de origen en todas las zonas en las que la imagen de origen sea opaca y la de destino sea transparente. Muestra transparencia en el resto de zonas. |
"source-over" | QPainter::CompositionMode_SourceOver (por defecto) A sobre B. Mostrar la imagen de origen en todas las zonas en las que la imagen de origen sea opaca. Mostrar la imagen de destino en el resto de zonas. |
"destination-atop" | QPainter::CompositionMode_DestinationAtop «B atop A». Igual que « source-atop », pero utilizando la imagen de destino en lugar de la de origen, y viceversa. |
"destination-in" | QPainter::CompositionMode_DestinationIn B en A. Igual que « source-in », pero utilizando la imagen de destino en lugar de la de origen, y viceversa. |
"destination-out" | QPainter::CompositionMode_DestinationOut «B fuera de A». Igual que « source-out », pero utilizando la imagen de destino en lugar de la de origen, y viceversa. |
"destination-over" | QPainter::CompositionMode_DestinationOver B sobre A. Igual que « source-over », pero utilizando la imagen de destino en lugar de la de origen, y viceversa. |
"lighter" | QPainter::CompositionMode_Plus A más B. Muestra la suma de la imagen de origen y la imagen de destino, con valores de color que se acercan a 255 (100 %) como límite. |
"copy" | QPainter::CompositionMode_Source A (se ignora B). Muestra la imagen de origen en lugar de la imagen de destino. |
"xor" | QPainter::CompositionMode_Xor A xor B. OR exclusivo de la imagen de origen y la imagen de destino. |
"qt-clear" | QPainter::CompositionMode_Clear |
"qt-destination" | QPainter::CompositionMode_Destination |
"qt-multiply" | QPainter::CompositionMode_Multiply |
"qt-screen" | QPainter::CompositionMode_Screen |
"qt-overlay" | QPainter::CompositionMode_Overlay |
"qt-darken" | QPainter::CompositionMode_Darken |
"qt-lighten" | QPainter::CompositionMode_Lighten |
"qt-color-dodge" | QPainter::CompositionMode_ColorDodge |
"qt-color-burn" | QPainter::CompositionMode_ColorBurn |
"qt-hard-light" | QPainter::CompositionMode_HardLight |
"qt-soft-light" | QPainter::CompositionMode_SoftLight |
"qt-difference" | QPainter::CompositionMode_Difference |
"qt-exclusion" | QPainter::CompositionMode_Exclusion |
De conformidad con el estándar del W3C, los modos de composición ampliados más allá de los modos obligatorios se proporcionan con la sintaxis «nombre del proveedor-nombre de la operación»; por ejemplo: « QPainter::CompositionMode_Exclusion » se proporciona como «qt-exclusion».
lineCap : string
Almacena el estilo actual del remate de línea. Los estilos de remate de línea posibles son:
| Constante | Descripción |
|---|---|
"butt" | (por defecto) Qt::FlatCap el extremo de cada línea tiene un borde plano perpendicular a la dirección de la línea. |
"round" | Qt::RoundCap Se añade al extremo de la línea un semicírculo cuyo diámetro es igual al ancho de la línea. |
"square" | Qt::SquareCap un rectángulo con una longitud igual al ancho de la línea y un ancho igual a la mitad del ancho de la línea, colocado a ras del borde perpendicular a la dirección de la línea. |
Se ignoran los demás valores.
lineDashOffset : real [since QtQuick 2.11]
Almacena el desplazamiento actual del guion de línea. El valor predeterminado del desplazamiento del guion de línea es 0.
Esta propiedad se introdujo en QtQuick 2.11.
Véase también ` getLineDash()` y ` setLineDash()`.
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:
| Constante | Descripción |
|---|---|
"bevel" | Qt::BevelJoin Se rellena la muesca triangular entre las dos líneas. |
"round" | Qt::RoundJoin Se rellena un arco circular entre las dos líneas. |
"miter" | (por defecto) « Qt::MiterJoin » Los bordes exteriores de las líneas se prolongan hasta encontrarse en ángulo, y esta zona se rellena. |
Se ignoran los demás valores.
lineWidth : real
Almacena el ancho de línea actual. Se ignoran los valores que no sean valores finitos mayores que cero.
miterLimit : real
Almacena el valor actual del límite de inglete. El valor predeterminado del límite de inglete es 10,0.
shadowBlur : real
Almacena el nivel actual de desenfoque aplicado a las sombras
shadowColor : string
Almacena el color de sombra actual.
shadowOffsetX : real
Almacena el desplazamiento actual de la sombra en la distancia horizontal positiva.
Véase también shadowOffsetY.
shadowOffsetY : real
Almacena el desplazamiento actual de la sombra en la distancia vertical positiva.
Véase también shadowOffsetX.
strokeStyle : variant
Almacena el color o estilo actual que se utilizará para las líneas que rodean las figuras. El estilo puede ser una cadena que contenga un color CSS, un objeto ` CanvasGradient ` o un objeto `CanvasPattern`. Los valores no válidos se ignoran.
El valor por defecto es «#000000».
Véase también createLinearGradient(), createRadialGradient(), createPattern() y fillStyle.
textAlign : string
Almacena la configuración actual de alineación del texto. Los valores posibles son:
| Constante | Descripción |
|---|---|
"start" | (por defecto) Alinea con el borde inicial del texto (lado izquierdo en texto de izquierda a derecha, lado derecho en texto 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" | Qt::AlignLeft |
"right" | Qt::AlignRight |
"center" | Qt::AlignHCenter |
Se ignoran los demás valores.
textBaseline : string
Almacena la configuración actual de alineación de la línea de base. Los valores posibles son:
| Constante | Descripció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 |
"ideographic" | La línea de base ideográfica inferior |
"bottom" | La parte inferior del cuadrado «em» |
Se ignoran los demás valores. El valor por defecto es «alfabético».
Documentación del método
Context2D arc(real x, real y, real radius, real startAngle, real endAngle, bool anticlockwise)
Añade un arco a la subtrayectoria actual que se encuentra en la circunferencia del círculo cuyo centro está en el punto (x, y) y cuyo radio es radius.
Tanto startAngle como endAngle se miden desde el eje x en radianes.


El parámetro anticlockwise es false para cada arco de la figura anterior, ya que todos se dibujan en el sentido de las agujas del reloj.
Véase también arcTo y el estándar de contexto 2D del W3C para arc().
Context2D arcTo(real x1, real y1, real x2, real y2, real radius)
Añade un arco con los puntos de control y el radio indicados a la subtrayectoria actual, conectado al punto anterior mediante una línea recta. Para dibujar un arco, hay que seguir los mismos pasos que para crear una línea:
- Llama al método ` beginPath()` para establecer una nueva ruta.
- Llama al método moveTo(
x,y) para establecer tu posición inicial en el lienzo en el punto (x,y). - Para dibujar un arco o un círculo, llama al método arcTo(x1, y1, x2, y2, radius). Esto añade un arco con punto inicial (x1, y1), punto final (x2, y2) y radius a la subtrayectoria actual y lo conecta con la subtrayectoria anterior mediante una línea recta.

Véase también arc y el estándar de contexto 2D del W3C para arcTo().
Context2D beginPath()
Restablece la ruta actual a una nueva ruta.
Context2D bezierCurveTo(real cp1x, real cp1y, real cp2x, real cp2y, real x, real y)
Añade una curva Bézier cúbica entre la posición actual y el punto final indicado, utilizando los puntos de control especificados por (cp1x, cp1y) y (cp2x, cp2y). Una vez añadida la curva, la posición actual se actualiza para situarse en el punto final (x, y) de la curva. El siguiente código genera la trayectoria que se muestra a continuación:
ctx.strokeStyle = Qt.rgba(0, 0, 0, 1);
ctx.lineWidth = 1;
ctx.beginPath();
ctx.moveTo(20, 0);//start point
ctx.bezierCurveTo(-10, 90, 210, 90, 180, 0);
ctx.stroke();
Véase también el estándar del contexto 2D del W3C para `bezierCurveTo` y la demostración «The beautiful flower», que utiliza `bezierCurveTo`.
Context2D clearRect(real x, real y, real w, real h)
Borra todos los píxeles del lienzo dentro del rectángulo especificado por (x, y, w, h) y los convierte en negro transparente.
Context2D clip()
Crea la región de recorte a partir de la ruta actual. Las partes de la forma que se encuentren fuera de la ruta de recorte no se muestran. Para crear una forma compleja utilizando el método ` clip() `:
- Llama al método `
context.beginPath()` para establecer la ruta de recorte. - Defina la ruta de recorte llamando a cualquier combinación de los métodos
lineTo,arcTo,arc,moveTo, etc., yclosePath. - Invoca el método
context.clip().
Se muestra la nueva forma. A continuación se muestra cómo una ruta de recorte puede modificar la forma en que se muestra una imagen:

Véase también beginPath(), closePath(), stroke(), fill() y el estándar de contexto 2D del W3C para «clip».
Context2D closePath()
Cierra la subruta actual trazando una línea hasta el inicio de la misma, iniciando automáticamente una nueva ruta. El punto actual de la nueva ruta es el primer punto de la subruta anterior.
Véase también el estándar del W3C sobreel contexto 2D para la función closePath.
CanvasGradient createConicalGradient(real x, real y, real angle)
Devuelve un objeto ` CanvasGradient ` 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.
Véase también CanvasGradient::addColorStop(), createLinearGradient(), createRadialGradient(), createPattern(), fillStyle y strokeStyle.
CanvasImageData createImageData(CanvasImageData imageData)
Crea un objeto ` CanvasImageData ` con las mismas dimensiones que el argumento ` imageData `.
CanvasImageData createImageData(Url imageUrl)
Crea un objeto ` CanvasImageData ` con la imagen indicada cargada desde imageUrl.
Nota: El objeto ` imageUrl ` debe estar ya cargado antes de llamar a esta función; de lo contrario, se devolverá un objeto ` CanvasImageData ` vacío.
Véase también Canvas::loadImage(), QtQuick::Canvas::unloadImage() y QtQuick::Canvas::isImageLoaded.
CanvasImageData createImageData(real sw, real sh)
Crea un objeto ` CanvasImageData ` con las dimensiones indicadas (sw, sh).
CanvasGradient createLinearGradient(real x0, real y0, real x1, real y1)
Devuelve un objeto ` CanvasGradient ` 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).
Un degradado es una transición suave entre colores. Existen dos tipos de degradados: lineales y radiales. Los degradados deben tener dos o más paradas de color, que representan cambios de color situados entre 0 y 1 entre los puntos de inicio y fin del degradado o entre los círculos.
Véase también CanvasGradient::addColorStop(), createRadialGradient(), createConicalGradient(), createPattern(), fillStyle y strokeStyle.
variant createPattern(Image image, string repetition)
Devuelve un objeto `CanvasPattern` que utiliza la imagen proporcionada y se repite en la(s) dirección(es) indicada(s) por el argumento `repetition`.
El parámetro « image » debe ser un elemento «Image» válido, un objeto « CanvasImageData » válido o una URL de imagen cargada. Si no hay datos de imagen, la función lanza una excepción «INVALID_STATE_ERR».
Los valores permitidos para repetition son:
| Constante | Descripción |
|---|---|
"repeat" | ambas direcciones |
"repeat-x | solo 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».
Véase también strokeStyle y fillStyle.
variant createPattern(color color, enumeration patternMode)
Esta es una función sobrecargada. Devuelve un objeto `CanvasPattern` que utiliza los valores especificados para ` color ` y ` patternMode`. Los modos de patrón válidos son:
| Constante | Descripción |
|---|---|
Qt.SolidPattern | Qt::SolidPattern |
Qt.Dense1Pattern | Qt::Dense1Pattern |
Qt.Dense2Pattern | Qt::Dense2Pattern |
Qt.Dense3Pattern | Qt::Dense3Pattern |
Qt.Dense4Pattern | Qt::Dense4Pattern |
Qt.Dense5Pattern | Qt::Dense5Pattern |
Qt.Dense6Pattern | Qt::Dense6Pattern |
Qt.Dense7Pattern | Qt::Dense7Pattern |
Qt.HorPattern | Qt::HorPattern |
Qt.VerPattern | Qt::VerPattern |
Qt.CrossPattern | Qt::CrossPattern |
Qt.BDiagPattern | Qt::BDiagPattern |
Qt.FDiagPattern | Qt::FDiagPattern |
Qt.DiagCrossPattern | Qt::DiagCrossPattern |
Véase también Qt::BrushStyle.
CanvasGradient createRadialGradient(real x0, real y0, real r0, real x1, real y1, real r1)
Devuelve un objeto ` CanvasGradient ` que representa un degradado radial que se dibuja a lo largo del cono definido por el círculo inicial, con origen (x0, y0) y radio r0, y el círculo final, con origen (x1, y1) y radio r1.
Véase también CanvasGradient::addColorStop(), createLinearGradient(), createConicalGradient(), createPattern(), fillStyle y strokeStyle.
void drawImage(variant image, real dx, real dy)
Dibuja la imagen especificada ` image ` en el lienzo en la posición `(dx, dy)`. Nota: El tipo ` image ` puede ser un elemento `Image`, una URL de imagen o un objeto ` CanvasImageData `. 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 ` Canvas::loadImage()` del elemento `Canvas`. La imagen que se dibuja está sujeta a la ruta de recorte del contexto actual, incluso si el ` image ` proporcionado es un objeto ` CanvasImageData `.
Véase también CanvasImageData, Image, Canvas::loadImage, Canvas::isImageLoaded, Canvas::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 un objeto ` image ` en el lienzo, en el punto (dx, dy) y con un ancho de ` dw` y una altura de ` dh`.
Nota: El tipo ` image ` puede ser un elemento `Image`, una URL de imagen o un objeto ` CanvasImageData `. 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 « Canvas::loadImage()» del elemento «Canvas». La imagen que se dibuja está sujeta a la ruta de recorte del contexto actual, incluso si el « image » proporcionado es un objeto « CanvasImageData ».
Véase también CanvasImageData, Image, Canvas::loadImage(), Canvas::isImageLoaded, Canvas::imageLoaded y el estándar W3C 2D Context 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 « image » a partir del punto de origen (sx, sy), el ancho de origen sw y la altura de origen sh en el lienzo, en el punto (dx, dy) y con un ancho de dw y una altura de dh.
Nota: El tipo « image » puede ser un elemento «Image» o «Canvas», una URL de imagen o un objeto « CanvasImageData ». 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 ` Canvas::loadImage()` del elemento `Canvas`. La imagen que se dibuja está sujeta a la ruta de recorte del contexto actual, incluso si el ` image ` proporcionado es un objeto ` CanvasImageData `.
Véase también CanvasImageData, Image, Canvas::loadImage(), Canvas::isImageLoaded, Canvas::imageLoaded y el estándar W3C 2D Context para drawImage.
Context2D ellipse(real x, real y, real w, real h)
Crea una elipse dentro del rectángulo delimitador definido por su esquina superior izquierda en (x, y), con una anchura de w y una altura de h, y la añade a la ruta como una subruta cerrada.
La elipse está formada por una curva en el sentido de las agujas del reloj, que comienza y termina en cero grados (la posición de las 3 en punto).
Context2D fill()
Rellena las subrutas con el estilo de relleno actual.
Véase también el estándar del W3C sobreel contexto 2D para el relleno y fillStyle.
Context2D fillRect(real x, real y, real w, real h)
Pinta un área rectangular especificada por (x, y, w, h) utilizando fillStyle.
Véase también fillStyle.
Context2D fillText(text, x, y)
Rellena el « text » especificado en la posición indicada (x, y).
Véase también font, textAlign, textBaseline y strokeText.
CanvasImageData getImageData(real x, real y, real w, real h)
Devuelve un objeto ` CanvasImageData ` que contiene los datos de imagen del rectángulo del lienzo especificado por (x, y, w, h).
[since QtQuick 2.11] array getLineDash()
Devuelve una matriz de qreals que representa el patrón de guiones de la línea.
Este método se introdujo en QtQuick 2.11.
Véase también setLineDash() y lineDashOffset.
bool isPointInPath(real x, real y)
Devuelve ` true ` si el punto (x, y) se encuentra en la ruta actual.
Véase también el estándar del W3C sobreel contexto 2D para isPointInPath.
Context2D lineTo(real x, real y)
Traza una línea desde la posición actual hasta el punto situado en (x, y).
var measureText(text)
Devuelve un objeto con una propiedad « width », cuyo valor equivale a llamar a « QFontMetrics::horizontalAdvance()» con el « text » indicado en la fuente actual.
Context2D moveTo(real x, real y)
Crea una nueva subruta con un punto en (x, y).
void putImageData(CanvasImageData imageData, real dx, real dy, real dirtyX, real dirtyY, real dirtyWidth, real dirtyHeight)
Dibuja los datos del objeto ` imageData ` proporcionado en el lienzo en las coordenadas (dx, dy).
Si se proporciona un rectángulo de área de pintura (dirtyX, dirtyY, dirtyWidth, dirtyHeight), solo se pintarán los píxeles de ese rectángulo.
Context2D quadraticCurveTo(real cpx, real cpy, real x, real y)
Añade una curva Bézier cuadrática entre el punto actual y el punto final (x, y) con el punto de control especificado por (cpx, cpy).
Véase también el estándar del contexto 2D del W3C para `quadraticCurveTo`.
Context2D rect(real x, real y, real w, real h)
Añade un rectángulo en la posición (x, y), con el ancho w y la altura h indicados, como un subtrazo cerrado.
Context2D reset()
Restablece el estado y las propiedades del contexto a sus valores predeterminados.
Context2D 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().
Context2D restore()
Extrae el estado superior de la pila y restaura el contexto a ese estado.
Véase también save().
Context2D rotate(real angle)
Gira el lienzo alrededor del origen actual un ángulo de angle, en radianes y en sentido horario.
ctx.rotate(Math.PI/2);
La matriz de transformación de rotación es la siguiente:

donde el « angle » de rotación se expresa en radianes.
Context2D roundedRect(real x, real y, real w, real h, real xRadius, real yRadius)
Añade al trazado un rectángulo con esquinas redondeadas, especificado mediante (x, y, w, h). Los argumentos xRadius y yRadius especifican el radio de las elipses que definen las esquinas del rectángulo redondeado.
Context2D save()
Inserta el estado actual en la pila de estados.
Antes de modificar cualquier atributo de estado, debes guardar el estado actual para futuras consultas. El contexto mantiene una pila de estados de dibujo. Cada estado consta de la matriz de transformación actual, la región de recorte y los valores de los siguientes atributos:
- strokeStyle
- fillStyle
- fillRule
- globalAlpha
- lineWidth
- lineCap
- lineJoin
- miterLimit
- shadowOffsetX
- shadowOffsetY
- shadowBlur
- shadowColor
- globalCompositeOperation
- font
- textAlign
- textBaseline
La ruta actual NO forma parte del estado de dibujo. La ruta se puede restablecer llamando al método ` beginPath()`.
Context2D scale(real x, real y)
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. x es el factor de escala en la dirección horizontal y y 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);
[since QtQuick 2.11] void setLineDash(array pattern)
Establece el patrón de guiones según el patrón indicado.
pattern una lista de números que especifica las distancias para dibujar alternativamente una línea y un espacio.
Si el número de elementos del array es impar, los elementos del array se copian y se concatenan. Por ejemplo, [5, 15, 25] se convertirá en [5, 15, 25, 5, 15, 25].
![]() | |
Este método se introdujo en QtQuick 2.11.
Véase también getLineDash() y lineDashOffset.
Context2D 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 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 dibujar nada. La especificación del contexto 2D de HTML Canvas define la matriz de transformación como:

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 de sesgo 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().
Context2D shear(real sh, real sv)
Recorta la matriz de transformación mediante sh en la dirección horizontal y sv en la dirección vertical.
Context2D stroke()
Traza las subrutas con el estilo de trazo actual.
Véase también strokeStyle y el estándar del W3C sobre el contexto 2D para el trazo.
Context2D strokeRect(real x, real y, real w, real h)
Traza el contorno del rectángulo especificado por (x, y, w, h) utilizando los atributos strokeStyle, lineWidth, lineJoin y (si procede) miterLimit.
Véase también strokeStyle, lineWidth, lineJoin y miterLimit.
Context2D strokeText(text, x, y)
Recorre el text dado en una posición especificada por (x, y).
Véase también font, textAlign, textBaseline y fillText.
Context2D text(string text, real x, real y)
Añade el text especificado a la ruta como un conjunto de subrutas cerradas creadas a partir de la fuente del contexto actual proporcionada.
Las subrutas se colocan de manera que el extremo izquierdo de la línea de base del texto quede en el punto especificado por (x, y).
Context2D transform(real a, real b, real c, real d, real e, real f)
Este método es muy 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.
El método ` setTransform` (a, b, c, d, e, f) restablece, en realidad, la transformación actual a la matriz identidad y, a continuación, invoca el método `transform` (a, b, c, d, e, f) con los mismos argumentos.
Véase también setTransform().
Context2D translate(real x, real y)
Traslada el origen del lienzo una distancia horizontal de x y una distancia vertical de y, en unidades del espacio de coordenadas.
La traslación del origen permite dibujar patrones de diferentes objetos en el lienzo sin tener que medir manualmente las coordenadas de cada forma.
© 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.
