En esta página

PinchHandler QML Type

Manejo de gestos de pellizco. Más...

Import Statement: import QtQuick
Inherits:

MultiPointHandler

Propiedades

Señales

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
    }
}

Puntos de contacto, centro de selección y centro de pellizco durante una rotación y un cambio de escala con dos dedos

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:

ConstanteDescripción
NoModifierNo se permite ninguna tecla modificadora.
ShiftModifierSe debe pulsar la tecla «Shift» del teclado.
ControlModifierSe debe pulsar la tecla Ctrl del teclado.
AltModifierSe debe pulsar la tecla Alt del teclado.
MetaModifierSe debe pulsar la tecla Meta del teclado.
KeypadModifierSe debe pulsar una tecla del teclado numérico.
GroupSwitchModifierSolo 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.
KeyboardModifierMaskAl 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.

ConstanteDescripción
PointerHandler.TakeOverForbiddenEste controlador no toma ni concede permiso de control a ningún tipo de elemento o controlador.
PointerHandler.CanTakeOverFromHandlersOfSameTypeEste controlador puede hacerse cargo del control exclusivo de otro controlador de la misma clase.
PointerHandler.CanTakeOverFromHandlersOfDifferentTypeEste controlador puede tomar el control exclusivo de cualquier tipo de controlador.
PointerHandler.CanTakeOverFromItemsEste controlador puede tomar el control exclusivo de cualquier tipo de elemento.
PointerHandler.CanTakeOverFromAnythingEste controlador puede tomar el control exclusivo de cualquier tipo de elemento o controlador.
PointerHandler.ApprovesTakeOverByHandlersOfSameTypeEste controlador concede permiso a otro controlador de la misma clase para que obtenga el control.
PointerHandler.ApprovesTakeOverByHandlersOfDifferentTypeEste controlador permite que cualquier tipo de controlador obtenga el control exclusivo.
PointerHandler.ApprovesTakeOverByItemsEste controlador permite que cualquier tipo de elemento adquiera el control.
PointerHandler.ApprovesCancellationEste controlador permitirá que su control se establezca en nulo.
PointerHandler.ApprovesTakeOverByAnythingEste 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.

Rectángulo con un margen alrededor para ampliar la detección táctil

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.activeValue : real [read-only]

xAxis.enabled : bool

xAxis.maximum : real

xAxis.minimum : real

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.activeValue : real [read-only]

yAxis.enabled : bool

yAxis.maximum : real

yAxis.minimum : real

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:

ConstanteDescripción
PointerDevice.GrabExclusiveEste controlador ha asumido la responsabilidad principal de gestionar el point.
PointerDevice.UngrabExclusiveEste controlador ha renunciado a su control exclusivo anterior.
PointerDevice.CancelGrabExclusiveEl control exclusivo de este controlador ha sido asumido o cancelado.
PointerDevice.GrabPassiveEste controlador ha adquirido un control pasivo para supervisar el point.
PointerDevice.UngrabPassiveEste controlador ha cedido su control pasivo anterior.
PointerDevice.CancelGrabPassiveEl 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.