PinchHandler QML Type
Manejo de gestos de pellizco. Más...
| Import Statement: | import QtQuick |
| Inherits: |
Propiedades
- acceptedDevices : flags
- acceptedModifiers : flags
- acceptedPointerTypes : flags
- active : bool
- activeRotation : real
- activeScale : real
- activeTranslation : point
- centroid : QtQuick::handlerPoint
- cursorShape : Qt::CursorShape
- dragThreshold : int
- enabled : bool
- grabPermissions : flags
- margin : real
- parent : Item
- persistentRotation : real
- persistentScale : real
- persistentTranslation : point
- rotationAxis
- rotationAxis.activeValue : real
- rotationAxis.enabled : bool
- rotationAxis.maximum : real
- rotationAxis.minimum : real
- scaleAxis
- scaleAxis.activeValue : real
- scaleAxis.enabled : bool
- scaleAxis.maximum : real
- scaleAxis.minimum : real
- target : Item
- xAxis
- xAxis.activeValue : real
- xAxis.enabled : bool
- xAxis.maximum : real
- xAxis.minimum : real
- yAxis
- yAxis.activeValue : real
- yAxis.enabled : bool
- yAxis.maximum : real
- yAxis.minimum : real
Señales
- canceled(eventPoint point)
- grabChanged(PointerDevice::GrabTransition transition, eventPoint point)
- rotationChanged(qreal delta)
- scaleChanged(qreal delta)
- translationChanged(QVector2D delta)
Descripción detallada
PinchHandler es un controlador que interpreta un gesto con varios dedos para girar, ampliar y arrastrar un elemento de forma interactiva. Al igual que otros controladores de entrada, por defecto es totalmente funcional y manipula su target, que es el elemento dentro del cual está declarado.
import QtQuick
Rectangle {
width: 400
height: 300
color: "lightsteelblue"
PinchHandler { }
}Dispone de propiedades para restringir el rango de arrastre, rotación y zoom.
Si se declara dentro de un elemento pero se le asigna un ` target` diferente, gestiona los eventos dentro de los límites del elemento exterior, pero manipula en su lugar el elemento ` target `:
import QtQuick
Item {
width: 640
height: 480
Rectangle {
id: map
color: "aqua"
width: 400
height: 300
}
PinchHandler {
target: map
}
}Una tercera forma de utilizarlo es establecer target en null y reaccionar a los cambios de propiedad de alguna otra manera:
import QtQuick
Window {
width: 320; height: 240
visible: true
title: handler.persistentRotation.toFixed(1) + "° " +
handler.persistentTranslation.x.toFixed(1) + ", " +
handler.persistentTranslation.y.toFixed(1) + " " +
(handler.persistentScale * 100).toFixed(1) + "%"
PinchHandler {
id: handler
target: null
persistentScale: 0.25
onTranslationChanged: (delta) => {
image.x -= delta.x
image.y -= delta.y
}
}
Image {
id: image
source: "images/album-cover.jpg"
scale: handler.persistentScale
x: -600; y: -450
}
}
Nota: El gesto de pellizco comienza cuando el número de dedos pulsados está comprendido entre ` minimumPointCount ` y ` maximumPointCount`, ambos inclusive. Hasta entonces, `PinchHandler` realiza un seguimiento de las posiciones de los dedos pulsados, pero si se trata de un número no permitido, no escala ni gira su ` target`, y la propiedad ` active ` permanece en ` false`.
Véase también PinchArea, QPointerEvent::pointCount(), QNativeGestureEvent::fingerCount() y Qt Quick Ejemplos: controladores de puntero.
Documentación de la propiedad
acceptedDevices : flags
Los tipos de dispositivos señaladores que pueden activar este gestor de puntero.
De forma predeterminada, esta propiedad está establecida en « PointerDevice.AllDevices ». Si se establece en una combinación «O» de tipos de dispositivos, ignorará los eventos procedentes de dispositivos que no coincidan.
Por ejemplo, se podría hacer que un control respondiera a los clics del ratón y del lápiz óptico de una forma, y a los toques en la pantalla táctil de otra, con dos controladores:
Item {
TapHandler {
acceptedDevices: PointerDevice.Mouse | PointerDevice.TouchPad | PointerDevice.Stylus
onTapped: console.log("clicked")
}
TapHandler {
acceptedDevices: PointerDevice.TouchScreen
onTapped: console.log("tapped")
}
}Nota: Todavíano todas las plataformas son capaces de distinguir entre ratón y panel táctil; y en aquellas que sí lo hacen, a menudo se desea que el comportamiento del ratón y del panel táctil sea el mismo.
acceptedModifiers : flags
Si se establece esta propiedad, será necesario pulsar los modificadores de teclado indicados para que la aplicación reaccione a los eventos del puntero; de lo contrario, los ignorará.
Si esta propiedad se establece en « Qt.KeyboardModifierMask » (el valor por defecto), el elemento « PointerHandler » ignorará las teclas modificadoras.
Por ejemplo, un « Item » podría tener dos controladores del mismo tipo, uno de los cuales solo se activaría si se pulsaran los modificadores de teclado requeridos:
Item {
TapHandler {
acceptedModifiers: Qt.ControlModifier
onTapped: console.log("control-tapped")
}
TapHandler {
acceptedModifiers: Qt.NoModifier
onTapped: console.log("tapped")
}
}Si se establece « acceptedModifiers » en una combinación «O» de teclas modificadoras, significa que deben pulsarse todas esas teclas modificadoras para activar el controlador:
Item {
TapHandler {
acceptedModifiers: Qt.ControlModifier | Qt.AltModifier | Qt.ShiftModifier
onTapped: console.log("control-alt-shift-tapped")
}
}Los modificadores disponibles son los siguientes:
| Constante | Descripción |
|---|---|
NoModifier | No se permite ninguna tecla modificadora. |
ShiftModifier | Se debe pulsar la tecla «Shift» del teclado. |
ControlModifier | Se debe pulsar la tecla Ctrl del teclado. |
AltModifier | Se debe pulsar la tecla Alt del teclado. |
MetaModifier | Se debe pulsar la tecla Meta del teclado. |
KeypadModifier | Se debe pulsar una tecla del teclado numérico. |
GroupSwitchModifier | Solo en X11 (a menos que se active en Windows mediante un argumento de línea de comandos). Se debe pulsar una tecla Mode_switch del teclado. |
KeyboardModifierMask | Al controlador no le importa qué modificadores se pulsen. |
Si necesitas un comportamiento aún más complejo del que se puede lograr con combinaciones de varios controladores con múltiples indicadores de modificadores, puedes comprobar los modificadores en código JavaScript:
Item {
TapHandler {
onTapped:
switch (point.modifiers) {
case Qt.ControlModifier | Qt.AltModifier:
console.log("CTRL+ALT");
break;
case Qt.ControlModifier | Qt.AltModifier | Qt.MetaModifier:
console.log("CTRL+META+ALT");
break;
default:
console.log("other modifiers", point.modifiers);
break;
}
}
}Véase también Qt::KeyboardModifier.
acceptedPointerTypes : flags
Los tipos de instrumentos de señalación (dedo, lápiz óptico, borrador, etc.) que pueden activar este controlador de puntero.
Por defecto, esta propiedad está establecida en « PointerDevice.AllPointerTypes ». Si se establece en una combinación «OR» de tipos de dispositivos, ignorará los eventos procedentes de « devices » que no coincidan.
Por ejemplo, se podría hacer que un control respondiera de alguna forma a los clics del ratón, táctiles y del lápiz óptico, pero que se borrara si se pulsaba con una herramienta de borrado en una tableta gráfica, mediante dos controladores:
Rectangle {
id: rect
TapHandler {
acceptedPointerTypes: PointerDevice.Generic | PointerDevice.Finger | PointerDevice.Pen
onTapped: console.log("clicked")
}
TapHandler {
acceptedPointerTypes: PointerDevice.Eraser
onTapped: rect.destroy()
}
}active : bool [read-only]
Esta propiedad es « true » cuando se cumplen todas las restricciones (especialmente minimumPointCount y maximumPointCount) y se está manipulando el « target », si lo hubiera.
activeRotation : real [read-only]
La rotación del gesto de pellizco en grados, donde los valores positivos corresponden al sentido de las agujas del reloj. Se trata de un ` 0 ` cuando comienza el gesto. Si ` target ` no es nulo, este valor se añadirá automáticamente a su ` rotation`. De lo contrario, se pueden utilizar enlaces para realizar acciones arbitrarias con este valor.
Véase también QtQuick::PinchHandler::rotationAxis.activeValue.
activeScale : real [read-only]
El factor de escala mientras se realiza el gesto de pellizco. Es 1,0 cuando comienza el gesto, aumenta a medida que se separan los puntos de contacto y disminuye a medida que se acercan. Si target no es nulo, su scale se multiplicará automáticamente por este valor. De lo contrario, se pueden utilizar enlaces para realizar acciones arbitrarias con este valor.
Véase también QtQuick::PinchHandler::scaleAxis.activeValue.
activeTranslation : point [read-only]
La traslación del conjunto de puntos mientras se realiza el gesto de pellizco. Al inicio del gesto, su valor es 0, 0, y aumenta a medida que se arrastran los « eventPoint(s) » hacia abajo y hacia la derecha. Una vez finalizado el gesto, el valor se mantiene; y cuando comienza el siguiente gesto de pellizco, vuelve a establecerse en 0, 0.
Nota: En algunos paneles táctiles, como el trackpad de macOS, los gestos nativos no generan ningún valor de traslación, y esta propiedad permanece en (0, 0).
centroid : QtQuick::handlerPoint [read-only]
Un punto situado exactamente en el centro de los puntos táctiles pulsados en ese momento. El « target » girará alrededor de este punto.
cursorShape : Qt::CursorShape
Esta propiedad define la forma del cursor que aparecerá cada vez que el ratón se sitúe sobre el elemento « parent », siempre que « active » tenga el valor « true ».
Las formas de cursor disponibles son:
- Qt.ArrowCursor
- Qt.UpArrowCursor
- Qt.CrossCursor
- Qt.WaitCursor
- Qt.IBeamCursor
- Qt.CursorVerticalDeTamaño
- Qt.CursorDeTamañoHorizontal
- Qt.SizeBDiagCursor
- Qt.SizeFDiagCursor
- Qt.SizeAllCursor
- Qt.Cursor en blanco
- Qt.CursorDivisiónVertical
- Qt.CursorDivisiónHorizontal
- Qt.CursorManoSeñalando
- Qt.CursorProhibido
- Qt.CursorDeInformación
- Qt.CursorOcupado
- Qt.Cursor de mano abierta
- Qt.Cursor de mano cerrada
- Qt.CursorDeArrastrarYCopiar
- Qt.CursorArrastrarMover
- Qt.DragLinkCursor
El valor por defecto no está establecido, lo que permite que aparezca el elemento « cursor » de « parent ». Esta propiedad se puede restablecer a su estado inicial asignándole el valor «undefined».
Nota: Cuando esta propiedad no se ha establecido, o se ha establecido en ` undefined`, si se lee el valor, devolverá ` Qt.ArrowCursor`.
Véase también « Qt::CursorShape », « QQuickItem::cursor()» y « HoverHandler::cursorShape ».
dragThreshold : int
La distancia en píxeles que el usuario debe arrastrar un « eventPoint » para que se considere un gesto de arrastre.
El valor por defecto depende de la plataforma y de la resolución de la pantalla. Se puede restablecer al valor por defecto estableciéndolo en «undefined». El comportamiento al iniciar un gesto de arrastre varía según los distintos controladores.
enabled : bool
Si se desactiva un « PointerHandler », rechazará todos los eventos y no se emitirá ninguna señal.
Si la propiedad « parent » de un « PointerHandler » tiene el valor « disabled », el controlador también quedará desactivado de forma efectiva, incluso cuando la propiedad « enabled » siga teniendo el valor « true ».
Nota: HoverHandler se comporta de forma diferente: consulta la documentación de su propiedad enabled para obtener más información.
grabPermissions : flags
Esta propiedad especifica los permisos cuando la lógica de este controlador decide hacerse cargo del control exclusivo, o cuando otro controlador le solicita que apruebe la toma de control o la cancelación del mismo.
| Constante | Descripción |
|---|---|
PointerHandler.TakeOverForbidden | Este controlador no toma ni concede permiso de control a ningún tipo de elemento o controlador. |
PointerHandler.CanTakeOverFromHandlersOfSameType | Este controlador puede hacerse cargo del control exclusivo de otro controlador de la misma clase. |
PointerHandler.CanTakeOverFromHandlersOfDifferentType | Este controlador puede tomar el control exclusivo de cualquier tipo de controlador. |
PointerHandler.CanTakeOverFromItems | Este controlador puede tomar el control exclusivo de cualquier tipo de elemento. |
PointerHandler.CanTakeOverFromAnything | Este controlador puede tomar el control exclusivo de cualquier tipo de elemento o controlador. |
PointerHandler.ApprovesTakeOverByHandlersOfSameType | Este controlador concede permiso a otro controlador de la misma clase para que obtenga el control. |
PointerHandler.ApprovesTakeOverByHandlersOfDifferentType | Este controlador permite que cualquier tipo de controlador obtenga el control exclusivo. |
PointerHandler.ApprovesTakeOverByItems | Este controlador permite que cualquier tipo de elemento adquiera el control. |
PointerHandler.ApprovesCancellation | Este controlador permitirá que su control se establezca en nulo. |
PointerHandler.ApprovesTakeOverByAnything | Este controlador permite que cualquier tipo de elemento o controlador tome el control. |
El valor por defecto es « PointerHandler.CanTakeOverFromItems | PointerHandler.CanTakeOverFromHandlersOfDifferentType | PointerHandler.ApprovesTakeOverByAnything », lo que permite la mayoría de los casos de toma de control, pero evita, por ejemplo, que dos «PinchHandlers» compitan por los mismos puntos táctiles.
margin : real
El margen más allá de los límites del elemento « parent » dentro del cual un « eventPoint » puede activar este controlador. Por ejemplo, en un « PinchHandler » en el que el « target » es también el « parent », resulta útil establecer este valor en una distancia equivalente al menos a la mitad del ancho del dedo de un usuario típico, de modo que, si el « parent » se ha reducido a un tamaño muy pequeño, el gesto de pellizcar siga siendo posible. O bien, si se coloca un botón basado en TapHandler cerca del borde de la pantalla, puede utilizarse para cumplir con la Ley de Fitts: reaccionar a los clics del ratón en el borde de la pantalla aunque el botón esté visualmente separado del borde por unos pocos píxeles.
El valor por defecto es 0.

parent : Item
El ` Item `, que es el ámbito del controlador; el `Item` en el que se declaró. El controlador gestionará los eventos en nombre de este `Item`, lo que significa que un evento de puntero es relevante si al menos una de sus ` eventPoints ` tiene lugar dentro del interior del `Item`. Inicialmente, ` target() ` es el mismo, pero se puede reasignar.
Véase también target y QObject::parent().
persistentRotation : real
La rotación que se aplicará a « target » si no es nulo. De lo contrario, se pueden utilizar enlaces para realizar acciones arbitrarias con este valor. Mientras se realiza el gesto de pellizco, « activeRotation » se va sumando de forma continua; una vez finalizado el gesto, se mantiene igual; y cuando comienza el siguiente gesto de pellizco, vuelve a modificarse mediante « activeRotation ».
Es posible establecer esta propiedad como forma de sincronizar la rotación de la base con una rotación que se haya establecido de otra manera, por ejemplo, mediante otro controlador. Si se establece esta propiedad directamente, activeRotation no cambia y se emite rotationChanged(0).
persistentScale : real
El factor de escala que se establecerá automáticamente en el ` target ` si no es nulo. De lo contrario, se pueden utilizar enlaces para realizar acciones arbitrarias con este valor. Mientras se realiza el gesto de pellizco, se multiplica continuamente por ` activeScale`; una vez finalizado el gesto, se mantiene igual; y cuando comienza el siguiente gesto de pellizco, vuelve a multiplicarse por ` activeScale `.
Es posible establecer esta propiedad como forma de sincronizar la escala base con una escala que se haya establecido de otra manera, por ejemplo, mediante otro controlador. Si se establece esta propiedad directamente, activeScale no cambia y se emite scaleChanged(1).
persistentTranslation : point
La traducción que se aplicará a « target » si no es « null ». De lo contrario, se pueden utilizar enlaces para realizar acciones arbitrarias con este valor. Mientras se realiza el gesto de pellizco, se le va sumando continuamente « activeTranslation »; una vez finalizado el gesto, el valor permanece igual.
Es posible establecer esta propiedad como forma de sincronizar la traslación base con una traslación que se haya establecido de otra manera, por ejemplo, mediante otro controlador. Si se establece esta propiedad directamente, activeTranslation no cambia y se emite translationChanged({0, 0}).
Nota: En algunos paneles táctiles, como el trackpad de macOS, los gestos nativos no generan ningún valor de traslación, y esta propiedad permanece en (0, 0).
rotationAxis group
rotationAxis.activeValue : real [read-only]
rotationAxis.enabled : bool
rotationAxis.maximum : real
rotationAxis.minimum : real
rotationAxis Controla las restricciones para establecer el valor de « rotation » del elemento « target » en función de la rotación del grupo de puntos táctiles.
minimum es la rotación mínima aceptable. maximum es la rotación máxima aceptable. Si enabled es verdadero, se permite la rotación. activeValue es lo mismo que QtQuick::PinchHandler::activeRotation.
La señal « activeValueChanged » se emite cuando « activeValue » cambia, para indicar el incremento en el que ha variado. Esto está pensado para ajustar de forma incremental una propiedad mediante varios controladores.
import QtQuick
Rectangle {
width: 100; height: 100
color: "lightsteelblue"; antialiasing: true
PinchHandler {
id: handler
target: null
xAxis.onActiveValueChanged: (delta) => parent.radius -= delta
yAxis.onActiveValueChanged: (delta) => parent.border.width += delta
rotationAxis.onActiveValueChanged: (delta) => parent.rotation += delta // add
scaleAxis.onActiveValueChanged: (delta) => parent.scale *= delta // multiply
}
WheelHandler {
acceptedModifiers: Qt.NoModifier
property: "rotation"
}
WheelHandler {
acceptedModifiers: Qt.ControlModifier
property: "scale"
}
}Nota: El fragmento de código es artificial: « PinchHandler » ya sabe cómo desplazar, escalar y rotar su elemento padre, pero este código consigue un comportamiento diferente de una forma menos declarativa, para ilustrar cómo utilizar « activeValueChanged » en casos especiales.
scaleAxis group
scaleAxis.activeValue : real [read-only]
scaleAxis.enabled : bool
scaleAxis.maximum : real
scaleAxis.minimum : real
scaleAxis controla las restricciones para establecer el valor de « scale » del elemento « target » en función de la distancia entre los puntos táctiles.
minimum es la escala mínima aceptable. « maximum » es la escala máxima aceptable. Si « enabled » es verdadero, se permite el escalado. « activeValue » es lo mismo que « QtQuick::PinchHandler::activeScale ».
La señal activeValueChanged se emite cuando activeValue cambia, para proporcionar el multiplicador del cambio incremental. Esto está pensado para ajustar de forma incremental una propiedad a través de múltiples controladores.
import QtQuick
Rectangle {
width: 100; height: 100
color: "lightsteelblue"; antialiasing: true
PinchHandler {
id: handler
target: null
xAxis.onActiveValueChanged: (delta) => parent.radius -= delta
yAxis.onActiveValueChanged: (delta) => parent.border.width += delta
rotationAxis.onActiveValueChanged: (delta) => parent.rotation += delta // add
scaleAxis.onActiveValueChanged: (delta) => parent.scale *= delta // multiply
}
WheelHandler {
acceptedModifiers: Qt.NoModifier
property: "rotation"
}
WheelHandler {
acceptedModifiers: Qt.ControlModifier
property: "scale"
}
}Nota: El fragmento de código es artificial: PinchHandler ya sabe cómo desplazar, escalar y rotar su elemento padre, pero este código logra un comportamiento diferente de una forma menos declarativa, para ilustrar cómo utilizar activeValueChanged en casos especiales.
target : Item
El elemento que este controlador manipulará.
Por defecto, es el mismo que el « parent », es decir, el «Item» en el que se declara el controlador. Sin embargo, a veces puede resultar útil establecer el destino en un «Item» diferente, para gestionar eventos dentro de un elemento pero manipular otro; o para « null », con el fin de desactivar el comportamiento predeterminado y realizar otra acción en su lugar.
xAxis group
xAxis controla las restricciones para la traslación horizontal del elemento « target ».
minimum es la coordenada x mínima aceptable de la traslación. « maximum » es la coordenada x máxima aceptable de la traslación. Si « enabled » es verdadero, se permite el arrastre horizontal.
La señal « activeValueChanged » se emite cuando « activeValue » cambia, para proporcionar el incremento en el que ha variado. Esto está pensado para ajustar de forma incremental una propiedad a través de múltiples controladores.
import QtQuick
Rectangle {
width: 100; height: 100
color: "lightsteelblue"; antialiasing: true
PinchHandler {
id: handler
target: null
xAxis.onActiveValueChanged: (delta) => parent.radius -= delta
yAxis.onActiveValueChanged: (delta) => parent.border.width += delta
rotationAxis.onActiveValueChanged: (delta) => parent.rotation += delta // add
scaleAxis.onActiveValueChanged: (delta) => parent.scale *= delta // multiply
}
WheelHandler {
acceptedModifiers: Qt.NoModifier
property: "rotation"
}
WheelHandler {
acceptedModifiers: Qt.ControlModifier
property: "scale"
}
}Nota: El fragmento de código es artificial: « PinchHandler » ya sabe cómo mover, escalar y rotar su elemento padre, pero este código consigue un comportamiento diferente de una forma menos declarativa, para ilustrar cómo utilizar « activeValueChanged » en casos especiales.
yAxis group
yAxis controla las restricciones para la traslación vertical del elemento « target ».
minimum es la coordenada y mínima aceptable de la traslación. ` maximum ` es la coordenada y máxima aceptable de la traslación. Si ` enabled ` es verdadero, se permite el arrastre vertical.
La señal « activeValueChanged » se emite cuando « activeValue » cambia, para indicar el incremento en el que ha variado. Esto está pensado para ajustar de forma incremental una propiedad mediante múltiples controladores.
import QtQuick
Rectangle {
width: 100; height: 100
color: "lightsteelblue"; antialiasing: true
PinchHandler {
id: handler
target: null
xAxis.onActiveValueChanged: (delta) => parent.radius -= delta
yAxis.onActiveValueChanged: (delta) => parent.border.width += delta
rotationAxis.onActiveValueChanged: (delta) => parent.rotation += delta // add
scaleAxis.onActiveValueChanged: (delta) => parent.scale *= delta // multiply
}
WheelHandler {
acceptedModifiers: Qt.NoModifier
property: "rotation"
}
WheelHandler {
acceptedModifiers: Qt.ControlModifier
property: "scale"
}
}Nota: El fragmento de código es artificial: « PinchHandler » ya sabe cómo mover, escalar y rotar su elemento padre, pero este código consigue un comportamiento diferente de una forma menos declarativa, para ilustrar cómo utilizar « activeValueChanged » en casos especiales.
Documentación de Signal
canceled(eventPoint point)
Si este gestor ya ha capturado el point indicado, esta señal se emite cuando otro gestor de punteros o elemento le arrebata la captura.
Nota: El controlador correspondiente es onCanceled.
grabChanged(PointerDevice::GrabTransition transition, eventPoint point)
Esta señal se emite cuando el «grab» ha sufrido algún cambio relevante para este controlador.
El verbo « transition » indica lo que ha ocurrido. El objeto « point » es el punto que se ha seleccionado o deseleccionado.
Los valores válidos para « transition » son:
| Constante | Descripción |
|---|---|
PointerDevice.GrabExclusive | Este controlador ha asumido la responsabilidad principal de gestionar el point. |
PointerDevice.UngrabExclusive | Este controlador ha renunciado a su control exclusivo anterior. |
PointerDevice.CancelGrabExclusive | El control exclusivo de este controlador ha sido asumido o cancelado. |
PointerDevice.GrabPassive | Este controlador ha adquirido un control pasivo para supervisar el point. |
PointerDevice.UngrabPassive | Este controlador ha cedido su control pasivo anterior. |
PointerDevice.CancelGrabPassive | El control pasivo anterior de este controlador ha finalizado de forma anómala. |
Nota: El controlador correspondiente es onGrabChanged.
rotationChanged(qreal delta)
La señal « rotationChanged » se emite cuando cambia « activeRotation » (y, por lo tanto, « persistentRotation »). El valor de « delta » indica el cambio aditivo en la rotación. Por ejemplo, si el usuario mueve los dedos para cambiar la distancia de pellizco, de modo que « activeRotation » pase de 10 a 30 grados, se emitirá « rotationChanged(20) ». Puedes utilizarlo para cambiar de forma incremental la rotación de un elemento:
import QtQuick
Rectangle {
width: 100; height: 100
color: "lightsteelblue"
PinchHandler {
id: handler
target: null
onRotationChanged: (delta) => parent.rotation += delta // add
onScaleChanged: (delta) => parent.scale *= delta // multiply
}
}Nota: Si se establece directamente la propiedad persistentRotation, delta es 0.
Nota: El controlador correspondiente es onRotationChanged.
scaleChanged(qreal delta)
La señal « scaleChanged » se emite cuando cambia « activeScale » (y, por lo tanto, « persistentScale »). El valor « delta » indica el cambio multiplicativo en la escala. Por ejemplo, si el usuario mueve los dedos para cambiar la distancia entre ellos, de modo que « activeScale » pase de 2 a 2,5, se emitirá « scaleChanged(1.25) ». Puedes utilizarlo para cambiar de forma incremental la escala de un elemento:
import QtQuick
Rectangle {
width: 100; height: 100
color: "lightsteelblue"
PinchHandler {
id: handler
target: null
onRotationChanged: (delta) => parent.rotation += delta // add
onScaleChanged: (delta) => parent.scale *= delta // multiply
}
}Nota: Si se establece directamente la propiedad persistentScale, delta es 1.
Nota: El controlador correspondiente es onScaleChanged.
translationChanged(QVector2D delta)
La señal « translationChanged » se emite cuando cambia « activeTranslation » (y, por lo tanto, « persistentTranslation »). El vector « delta » indica el cambio en la traslación. Puedes utilizarlo para modificar de forma incremental la posición de un elemento:
import QtQuick
Window {
width: 320; height: 240
visible: true
title: handler.persistentRotation.toFixed(1) + "° " +
handler.persistentTranslation.x.toFixed(1) + ", " +
handler.persistentTranslation.y.toFixed(1) + " " +
(handler.persistentScale * 100).toFixed(1) + "%"
PinchHandler {
id: handler
target: null
persistentScale: 0.25
onTranslationChanged: (delta) => {
image.x -= delta.x
image.y -= delta.y
}
}
Image {
id: image
source: "images/album-cover.jpg"
scale: handler.persistentScale
x: -600; y: -450
}
}Nota: Si se establece directamente la propiedad persistentTranslation, delta es 0, 0.
Nota: El controlador correspondiente es onTranslationChanged.
© 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.