TapHandler QML Type
Manejador de toques y clics. Más...
| Import Statement: | import QtQuick |
| Inherits: |
Propiedades
- acceptedButtons : flags
- acceptedDevices : flags
- acceptedModifiers : flags
- acceptedPointerTypes : flags
- active : bool
- cursorShape : Qt::CursorShape
- dragThreshold : int
- enabled : bool
- exclusiveSignals : enumeration
(since 6.5) - gesturePolicy : enumeration
- grabPermissions : flags
- longPressThreshold : real
- margin : real
- parent : Item
- point : handlerPoint
- pressed : bool
- tapCount : int
- target : Item
- timeHeld : real
Señales
- canceled(eventPoint point)
- doubleTapped(eventPoint eventPoint, Qt::MouseButton button)
- grabChanged(PointerDevice::GrabTransition transition, eventPoint point)
- longPressed()
- singleTapped(eventPoint eventPoint, Qt::MouseButton button)
- tapCountChanged()
- tapped(eventPoint eventPoint, Qt::MouseButton button)
Descripción detallada
TapHandler es un controlador para toques en una pantalla táctil o clics con el ratón.
La detección de un gesto de toque válido depende de ` gesturePolicy`. El valor por defecto es `DragThreshold`, lo que requiere que la pulsación y la liberación estén muy próximas entre sí, tanto en el espacio como en el tiempo. En este caso, TapHandler puede funcionar utilizando únicamente una captura pasiva y, por lo tanto, no interfiere en la entrega de eventos a ningún otro elemento (Item) ni a ningún controlador de entrada (Input Handler). Por lo tanto, el valor predeterminado de « gesturePolicy » resulta útil cuando se desea modificar el comportamiento de un control o elemento ya existente añadiendo un TapHandler con enlaces y/o funciones de devolución de llamada de JavaScript.
Ten en cuenta que los botones (como QPushButton) suelen implementarse de tal forma que no les importa si la pulsación y la liberación se producen muy seguidas: si pulsas el botón y luego cambias de opinión, tienes que arrastrar el dedo hasta fuera del borde del botón para cancelar el clic. Para este caso de uso, configura el gesturePolicy en TapHandler.ReleaseWithinBounds.
import QtQuick
Rectangle {
id: button
signal clicked
property alias text: buttonLabel.text
height: Math.max(Screen.pixelDensity * 7, buttonLabel.implicitHeight * 1.2)
width: Math.max(Screen.pixelDensity * 11, buttonLabel.implicitWidth * 1.3)
radius: 3
property color dark: Qt.darker(palette.button, 1.3)
gradient: Gradient {
GradientStop { position: 0.0; color: tapHandler.pressed ? dark : palette.button }
GradientStop { position: 1.0; color: dark }
}
TapHandler {
id: tapHandler
gesturePolicy: TapHandler.ReleaseWithinBounds
onTapped: button.clicked()
}
Text {
id: buttonLabel
text: "Click Me"
color: palette.buttonText
anchors.centerIn: parent
}
}En el caso de los gestos de pulsaciones múltiples (doble pulsación, triple pulsación, etc.), la distancia recorrida no debe superar QStyleHints::mouseDoubleClickDistance() con el ratón y QStyleHints::touchDoubleTapDistance() con la pantalla táctil, y el tiempo entre pulsaciones no debe superar QStyleHints::mouseDoubleClickInterval().
Véase también MouseArea y Qt Quick Ejemplos: controladores de puntero.
Documentación de la propiedad
acceptedButtons : flags
Los botones del ratón que pueden activar este controlador de puntero.
Por defecto, esta propiedad está establecida en « Qt.LeftButton ». Se puede configurar con una combinación OR de botones del ratón, y se ignorarán los eventos procedentes de otros botones.
Por ejemplo, se podría hacer que un control respondiera de forma diferente a los clics con el botón izquierdo y con el derecho, mediante dos controladores:
Item {
TapHandler {
onTapped: console.log("left clicked")
}
TapHandler {
acceptedButtons: Qt.RightButton
onTapped: console.log("right clicked")
}
}Nota: Al tocar una pantalla táctil o al pulsar con el lápiz óptico en una tableta gráfica se emula el clic con el botón izquierdo del ratón. Este comportamiento se puede modificar mediante « acceptedDevices » o « acceptedPointerTypes ».
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 el ratón y el panel táctil; y en aquellas que sí lo hacen, a menudo es preferible 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 « 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 Mayús 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 gestor de puntero.
Por defecto, esta propiedad está configurada como « PointerDevice.AllPointerTypes ». Si se configura como 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 manera a los clics del ratón, táctiles y del lápiz óptico, pero que se borrara si se pulsara 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]
Esto se cumple true siempre que este gestor de entrada haya asumido la responsabilidad exclusiva de gestionar uno o varios « eventPoints », tras haber conseguido la adquisición exclusiva de dichos puntos. Esto significa que mantiene sus propiedades actualizadas en función de los movimientos de dichos «eventPoints» y que manipula activamente sus « target » (si los hay).
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 » sea « 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.CursorDeAyuda
- 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 « cursor » del elemento « 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.
exclusiveSignals : enumeration [since 6.5]
Determina la exclusividad de las señales singleTapped() y doubleTapped().
| Constante | Descripción |
|---|---|
NotExclusive | (valor predeterminado) Se emiten las señales singleTapped() y doubleTapped() inmediatamente cuando el usuario pulsa una o dos veces, respectivamente. |
SingleTap | singleTapped() se emite inmediatamente cuando el usuario pulsa una vez, y doubleTapped() nunca se emite. |
DoubleTap | doubleTapped() se emite inmediatamente cuando el usuario pulsa dos veces, y singleTapped() nunca se emite. |
(SingleTap | DoubleTap) | Ambas señales se retrasan hasta « QStyleHints::mouseDoubleClickInterval()», de modo que puede emitirse « singleTapped()» o « doubleTapped()», pero no ambas. Sin embargo, si se producen tres o más toques dentro de « mouseDoubleClickInterval », no se emite ninguna de las señales.Nota: Las demás señales, como tapped() y tapCountChanged(), siempre se emiten de forma inmediata, independientemente de esta propiedad. |
Esta propiedad se introdujo en Qt 6.5.
gesturePolicy : enumeration
La restricción espacial para que se reconozca un gesto de toque o de pulsación prolongada, además de la restricción de que la liberación debe producirse antes de que haya transcurrido un « longPressThreshold ». Si no se cumplen estas restricciones, no se emite la señal « tapped » y no se incrementa el « tapCount ». Si se incumple la restricción espacial, « pressed » pasa inmediatamente de «true» a «false», independientemente del tiempo de pulsación.
La variable « gesturePolicy » también influye en el comportamiento de la sujeción, tal y como se describe a continuación.
| Constante | Descripción |
|---|---|
TapHandler.DragThreshold
Captura al pulsar: pasiva | (valor por defecto) El « eventPoint » no debe moverse de forma significativa. Si el ratón, el dedo o el lápiz óptico se desplaza más allá del umbral de arrastre del sistema (QStyleHints::startDragDistance), se cancela el gesto de toque, incluso si el dispositivo o el dedo siguen pulsados. Esta política puede resultar útil siempre que TapHandler necesite cooperar con otros controladores de entrada (por ejemplo, DragHandler) o elementos que gestionan eventos (por ejemplo, controlesQt Quick ), ya que en este caso TapHandler no tomará el control exclusivo, sino que se limitará a un passive grab. Es decir, DragThreshold resulta especialmente útil para ampliar el comportamiento existente: reacciona al toque, al clic o a la pulsación prolongada incluso cuando otro elemento o controlador ya está reaccionando, quizá incluso en una capa diferente de la interfaz de usuario. El siguiente fragmento de código muestra un TapHandler tal y como se utiliza en un componente; pero si apilamos dos instancias del componente, verás que los controladores de ambos reaccionan simultáneamente cuando se produce una pulsación sobre ambos, ya que la captura pasiva no detiene la propagación de eventos: |
TapHandler.WithinBounds
Agarre al pulsar: exclusivo | Si la « eventPoint » sale de los límites del elemento « parent », se cancela el gesto de toque. La « TapHandler » aceptará la « exclusive grab » al pulsar, pero liberará la «grab» tan pronto como deje de cumplirse la restricción de límites. |
TapHandler.ReleaseWithinBounds
Sujeción al pulsar: exclusiva | En el momento de soltar (al soltar el botón del ratón o levantar el dedo), si el « eventPoint » se encuentra fuera de los límites del elemento « parent », no se reconoce el gesto de pulsación. Esto se corresponde con el comportamiento típico de los widgets de botón: puedes cancelar un clic arrastrando fuera del botón, y también puedes cambiar de opinión arrastrando de nuevo dentro del botón antes de soltar. Ten en cuenta que, para detectar este gesto, es necesario que « TapHandler » reciba el « exclusive grab » al pulsar y lo mantenga hasta que se suelte. |
TapHandler.DragWithinBounds
Captura al pulsar: exclusiva | Al pulsar, TapHandler toma el exclusive grab; a partir de ese momento, el eventPoint puede arrastrarse dentro de los límites del elemento parent, mientras que la propiedad timeHeld sigue contando y se emitirá la señal longPressed() independientemente de la distancia de arrastre. Sin embargo, al igual que WithinBounds, si el punto sale de los límites, el gesto de toque pasa a ser canceled(), active() pasa a ser false y timeHeld deja de contar. Esto resulta adecuado para implementar componentes de «pulsar-arrastrar-soltar», como los menús, en los que un único ` TapHandler ` detecta la pulsación, ` timeHeld ` activa una animación de «apertura» y, a continuación, el usuario puede arrastrar hasta un elemento del menú y soltarlo, sin salir nunca de los límites de la escena principal que contiene el menú. Este valor se añadió en Qt 6.3. |
La sección «Qt Quick Examples - Pointer Handlers» muestra algunos casos de uso de estos elementos.
Nota: Si observas que TapHandler reacciona en casos que entran en conflicto con algún otro comportamiento, lo primero que debes hacer es plantearte qué gesturePolicy es el adecuado. Si no puedes solucionarlo cambiando gesturePolicy, en algunos casos es mejor ajustar grabPermissions, ya sea en este controlador o en otro que impida que TapHandler reaccione.
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 de dicho control.
| 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 tomar el 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 obtener 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 adquiera el control. |
PointerHandler.ApprovesTakeOverByHandlersOfDifferentType | Este controlador permite que cualquier tipo de controlador adquiera 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.
longPressThreshold : real
El tiempo, en segundos, durante el que se debe mantener pulsado un eventPoint para activar un gesto de pulsación prolongada y emitir la señal longPressed(), siempre que el valor sea mayor que 0. Si se suelta el punto antes de que transcurra este tiempo, se puede detectar un toque si se cumple la restricción gesturePolicy. Si longPressThreshold es 0, el temporizador queda desactivado y no se emitirá la señal. Si longPressThreshold se establece en undefined, se utilizará el valor por defecto, que puede consultarse a través de esta propiedad.
El valor por defecto es QStyleHints::mousePressAndHoldInterval() convertido a segundos.
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, como mínimo, 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, se puede utilizar 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 uno de sus « eventPoints » tiene lugar dentro del «Item». Inicialmente, « target() » es el mismo, pero se puede reasignar.
Véase también target y QObject::parent().
point : handlerPoint [read-only]
El objeto « eventPoint » que se está gestionando actualmente. Cuando no hay ningún punto en proceso, este objeto se restablece a sus valores por defecto (todas las coordenadas son 0).
pressed : bool [read-only]
Se mantiene verdadero siempre que se pulse el ratón o el punto táctil, y cualquier movimiento desde el momento de la pulsación cumpla con la política actual gesturePolicy. Cuando se suelte el eventPoint o se incumpla la política, el valor de «pressed» pasará a ser falso.
tapCount : int [read-only]
El número de toques que se han producido dentro de los límites de tiempo y espacio para que se consideren un único gesto. El contador se pone a 1 si el botón cambia de estado. Por ejemplo, para detectar un triple toque, puedes escribir:
Rectangle {
width: 100; height: 30
signal tripleTap
TapHandler {
acceptedButtons: Qt.AllButtons
onTapped: if (tapCount == 3) tripleTap()
}
}target : Item
El elemento que este controlador manipulará.
Por defecto, es el mismo que el « parent », es decir, el elemento dentro del cual se declara el controlador. Sin embargo, a veces puede resultar útil establecer el destino en un elemento diferente, con el fin de gestionar eventos dentro de un elemento pero manipular otro; o para « null », es decir, desactivar el comportamiento predeterminado y realizar otra acción en su lugar.
timeHeld : real [read-only]
El tiempo, en segundos, que se ha mantenido pulsado un punto, sin sobrepasar el umbral de arrastre. Se actualizará al menos una vez por fotograma renderizado, lo que permite renderizar una animación que muestre el progreso hacia una acción que se activará al mantener pulsado durante un tiempo prolongado. También es posible activar una de una serie de acciones en función del tiempo que se mantenga pulsado.
Un valor inferior a cero significa que no hay ningún punto mantenido dentro del « Item » de este controlador.
Nota: Si gesturePolicy está establecido en TapHandler.DragWithinBounds, timeHeld no deja de contar incluso cuando el punto pulsado se desplaza más allá del umbral de arrastre, sino solo cuando el punto sale de la zona de « bounds » del elemento « parent ».
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 gestor correspondiente es onCanceled.
doubleTapped(eventPoint eventPoint, Qt::MouseButton button)
Esta señal se emite cuando se pulsa dos veces sobre el elemento « parent » en un breve intervalo de tiempo (QStyleHints::mouseDoubleClickInterval()) y a una distancia (QStyleHints::mouseDoubleClickDistance() o QStyleHints::touchDoubleTapDistance()). Esta señal siempre se produce después de singleTapped, tapped y tapCountChanged. El parámetro de señal eventPoint contiene información del evento de liberación sobre el punto en el que se pulsó, y button es el mouse button sobre el que se hizo clic, o NoButton en una pantalla táctil.
Nota: El controlador correspondiente es onDoubleTapped.
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 por otro o se ha cancelado. |
PointerDevice.GrabPassive | Este controlador ha adquirido una retención pasiva para supervisar el point. |
PointerDevice.UngrabPassive | Este controlador ha renunciado a su control pasivo anterior. |
PointerDevice.CancelGrabPassive | El control pasivo anterior de este controlador ha finalizado de forma anómala. |
Nota: El gestor correspondiente es onGrabChanged.
longPressed()
Esta señal se emite cuando se mantiene pulsado el elemento « parent » durante un periodo de tiempo superior a longPressThreshold. Es decir, si se mantiene pulsado un punto táctil o un botón, y ningún movimiento supera el umbral de arrastre, la señal « longPressed » se emitirá en el momento en que timeHeld supere longPressThreshold.
Nota: El controlador correspondiente es onLongPressed.
singleTapped(eventPoint eventPoint, Qt::MouseButton button)
Esta señal se emite cuando se pulsa una vez el elemento « parent ». Transcurrido un tiempo superior a « QStyleHints::mouseDoubleClickInterval », se puede volver a pulsar; pero si el tiempo hasta la siguiente pulsación es menor, « tapCount » aumentará. El parámetro de señal « eventPoint » contiene información del evento de liberación sobre el punto en el que se pulsó, y « button » es el « mouse button » en el que se hizo clic, o « NoButton » en una pantalla táctil.
Nota: El controlador correspondiente es onSingleTapped.
tapCountChanged()
Esta señal se emite cuando se pulsa una o más veces el elemento « parent » (dentro de un intervalo de tiempo y distancia especificados) y cuando el valor actual de « tapCount » difiere del anterior de « tapCount ».
Nota: El controlador correspondiente es onTapCountChanged.
tapped(eventPoint eventPoint, Qt::MouseButton button)
Esta señal se emite cada vez que se pulsa el elemento « parent ».
Es decir, si pulsas y sueltas un punto táctil o un botón en un intervalo de tiempo inferior a longPressThreshold, siempre que ningún movimiento supere el umbral de arrastre, se emitirá la señal tapped en el momento de la suelta. El parámetro de la señal eventPoint contiene información del evento de suelta sobre el punto en el que se pulsó, y button es el mouse button en el que se hizo clic, o NoButton en una pantalla táctil.
import QtQuick
Rectangle {
width: 100
height: 100
TapHandler {
acceptedButtons: Qt.LeftButton | Qt.RightButton
onTapped: (eventPoint, button)=> console.log("tapped", eventPoint.device.name,
"button", button,
"@", eventPoint.scenePosition)
}
}Nota: El controlador correspondiente es onTapped.
© 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.



