PointerDeviceHandler QML Type

Gestor abstracto para eventos de puntero con restricciones específicas del dispositivo. Más...

Este tipo está en desarrollo y está sujeto a cambios.

• Lista de todos los miembros, incluidos los heredados

Propiedades

• acceptedButtons : flags
• acceptedDevices : flags
• acceptedModifiers : flags
• acceptedPointerTypes : flags
• active : bool
• cursorShape : Qt::CursorShape
• dragThreshold : int
• enabled : bool
• grabPermissions : flags
• margin : real
• parent : Item
• target : Item

Señales

• canceled(eventPoint point)
• grabChanged(PointerDevice::GrabTransition transition, eventPoint point)

Descripción detallada

Una clase intermedia (no registrada como tipo QML) para manejadores que permiten el filtrado basado en el tipo de dispositivo, tipo de puntero o modificadores de teclado.

Documentación de propiedades

acceptedButtons : flags

Los botones del ratón que pueden activar este manejador de puntero.

Por defecto, esta propiedad se establece en Qt.LeftButton. Puede establecerse en una combinación OR de botones del ratón, e ignorará los eventos de otros botones.

Por ejemplo, se puede hacer que un control responda a los clicks izquierdo y derecho de diferentes maneras, con dos manejadores:

Item {
    TapHandler {
        onTapped: console.log("left clicked")
    }
    TapHandler {
        acceptedButtons: Qt.RightButton
        onTapped: console.log("right clicked")
    }
}

acceptedDevices : flags

Los tipos de dispositivos señaladores que pueden activar este Manejador de Punteros.

Por defecto, esta propiedad se establece en PointerDevice.AllDevices. Si se establece en una combinación OR de tipos de dispositivos, se ignorarán los eventos de los dispositivos que no coincidan.

Por ejemplo, se puede hacer que un control responda a los clics del ratón y del lápiz de una manera, y a los toques de la pantalla táctil de otra, con dos manejadores:

Item {
   TapHandler {
       acceptedDevices: PointerDevice.Mouse | PointerDevice.TouchPad | PointerDevice.Stylus
       onTapped: console.log("clicked")
   }
   TapHandler {
       acceptedDevices: PointerDevice.TouchScreen
       onTapped: console.log("tapped")
   }
}

acceptedModifiers : flags

Si se establece esta propiedad, requerirá que se pulsen los modificadores de teclado dados para reaccionar a los eventos de puntero, y en caso contrario los ignorará.

Si esta propiedad está establecida a Qt.KeyboardModifierMask (el valor por defecto), entonces el PointerHandler ignora las teclas modificadoras.

Por ejemplo, un Item podría tener dos manejadores del mismo tipo, uno de los cuales se activa sólo si se pulsan los modificadores de teclado requeridos:

Item {
   TapHandler {
       acceptedModifiers: Qt.ControlModifier
       onTapped: console.log("control-tapped")
   }
   TapHandler {
       acceptedModifiers: Qt.NoModifier
       onTapped: console.log("tapped")
   }
}

Si configuras acceptedModifiers con una combinación OR de teclas modificadoras, significa que todos esos modificadores deben estar pulsados para activar el manejador:

Item {
   TapHandler {
       acceptedModifiers: Qt.ControlModifier | Qt.AltModifier | Qt.ShiftModifier
       onTapped: console.log("control-alt-shift-tapped")
   }
}

Los modificadores disponibles son los siguientes

Si necesita un comportamiento aún más complejo que el que se puede conseguir con combinaciones de varios manejadores con varios indicadores de modificador, puede 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 señaladores (dedo, stylus, borrador, etc.) que pueden activar este Manejador de Punteros.

Por defecto, esta propiedad se establece en PointerDevice.AllPointerTypes. Si se establece en una combinación OR de tipos de dispositivos, ignorará los eventos de los que no coincidan devices.

Por ejemplo, se puede hacer que un control responda de alguna manera a los clics del ratón, el tacto y el lápiz óptico, pero que se borre si se toca con una herramienta de borrado en una tableta gráfica, con dos manejadores:

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]

Esto se mantiene true siempre que este Manejador de Entrada haya tomado la responsabilidad exclusiva de manejar uno o más eventPoints, tomando con éxito un agarre exclusivo de esos puntos. Esto significa que está manteniendo sus propiedades actualizadas de acuerdo con los movimientos de esos eventPoints y manipulando activamente su target (si existe).

cursorShape : Qt::CursorShape

Esta propiedad contiene la forma del cursor que aparecerá siempre que el ratón se sitúe sobre el elemento parent mientras active esté true.

Las formas de cursor disponibles son:

• Qt.ArrowCursor
• Qt.UpArrowCursor
• Qt.CrossCursor
• Qt.WaitCursor
• Qt.IBeamCursor
• Qt.SizeVerCursor
• Qt.SizeHorCursor
• Qt.SizeBDiagCursor
• Qt.SizeFDiagCursor
• Qt.SizeAllCursor
• Qt.BlankCursor
• Qt.SplitVCursor
• Qt.SplitHCursor
• Qt.PointingHandCursor
• Qt.ForbiddenCursor
• Qt.WhatsThisCursor
• Qt.BusyCursor
• Qt.OpenHandCursor
• Qt.CursorManoCerrada
• Qt.DragCopyCursor
• Qt.DragMoveCursor
• Qt.DragLinkCursor

El valor por defecto no está establecido, lo que permite que aparezca el elemento cursor de parent. Esta propiedad puede restablecerse a la misma condición inicial estableciéndola a undefined.

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 trate como un gesto de arrastre.

El valor por defecto depende de la plataforma y de la resolución de pantalla. Se puede restablecer al valor por defecto estableciéndolo como indefinido. El comportamiento cuando comienza un gesto de arrastre varía en los distintos manejadores.

enabled : bool

Si un PointerHandler está desactivado, rechazará todos los eventos y no se emitirá ninguna señal.

Si un PointerHandler's parent es disabled, el manejador también será efectivamente desactivado, incluso cuando la propiedad enabled permanezca true.

grabPermissions : flags

Esta propiedad especifica los permisos cuando la lógica de este manejador decide hacerse cargo de la toma exclusiva, o cuando se le pide que apruebe la toma o cancelación de la toma por parte de otro manejador.

El valor predeterminado es PointerHandler.CanTakeOverFromItems | PointerHandler.CanTakeOverFromHandlersOfDifferentType | PointerHandler.ApprovesTakeOverByAnything que permite la mayoría de los escenarios de toma, pero evita, por ejemplo, dos PinchHandlers luchando por los mismos puntos de contacto.

margin : real

El margen más allá de los límites del elemento parent dentro del cual un eventPoint puede activar este manejador. Por ejemplo, en un PinchHandler en el que el target es también el parent, es útil establecerlo a una distancia de al menos la mitad de la anchura 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, si se coloca un botón basado en TapHandler cerca del borde de la pantalla, puede utilizarse para cumplir 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 manejador; el Item en el que fue declarado. El manejador manejará eventos en nombre de este Item, lo que significa que un evento de puntero es relevante si al menos uno de sus eventPoints ocurre dentro del interior del Item. Inicialmente target() es el mismo, pero puede ser reasignado.

Véase también target y QObject::parent().

target : Item

Elemento que manipulará este controlador.

Por defecto, es el mismo que parent, el Item dentro del cual se declara el manejador. Sin embargo, a veces puede ser útil establecer el objetivo a un Item diferente, para manejar eventos dentro de un item pero manipular otro; o a null, para desactivar el comportamiento por defecto y hacer otra cosa en su lugar.

Documentación sobre señales

canceled(eventPoint point)

Si este manejador ya ha agarrado el point dado, esta señal es emitida cuando el agarre es robado por un Manejador de Punteros o Item diferente.

grabChanged(PointerDevice::GrabTransition transition, eventPoint point)

Esta señal se emite cuando la cuchara ha cambiado de alguna manera que es relevante para este controlador.

El transition (verbo) dice lo que ha pasado. El point (objeto) es el punto que fue agarrado o no agarrado.

Los valores válidos para transition son: