PointerDeviceHandler QML Type

Gestionnaire abstrait des événements de pointeur avec des contraintes spécifiques à l'appareil. En savoir plus...

Ce type est en préversion technologique et est susceptible d'être modifié.

• Liste de tous les membres, y compris les membres hérités

Propriétés

• 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

Signaux

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

Description détaillée

Classe intermédiaire (non enregistrée en tant que type QML) pour les gestionnaires permettant un filtrage en fonction du type d'appareil, du type de pointeur ou des modificateurs du clavier.

Documentation des propriétés

acceptedButtons : flags

Les boutons de la souris pouvant activer ce gestionnaire de pointeur.

Par défaut, cette propriété est définie sur « Qt.LeftButton ». Elle peut être définie sur une combinaison OU de boutons de souris et ignorera les événements provenant d'autres boutons.

Par exemple, un contrôle peut être configuré pour réagir différemment aux clics gauche et droit, à l’aide de deux gestionnaires :

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

acceptedDevices : flags

Les types de périphériques de pointage pouvant activer ce gestionnaire de pointeur.

Par défaut, cette propriété est définie sur « PointerDevice.AllDevices ». Si vous la définissez sur une combinaison « OU » de types de périphériques, elle ignorera les événements provenant des périphériques qui ne correspondent pas.

Par exemple, un contrôle peut être configuré pour répondre d’une certaine manière aux clics de souris et de stylet, et d’une autre manière aux tapotements sur un écran tactile, à l’aide de deux gestionnaires :

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

acceptedModifiers : flags

Si cette propriété est définie, les événements liés au pointeur ne seront pris en compte que si les touches de modification spécifiées sont enfoncées ; dans le cas contraire, ils seront ignorés.

Si cette propriété est définie sur « Qt.KeyboardModifierMask » (valeur par défaut), l’ PointerHandler ignore les touches de modification.

Par exemple, une « Item » peut comporter deux gestionnaires du même type, dont l’un n’est activé que si les touches de modification requises sont enfoncées :

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

Si vous définissez « acceptedModifiers » sur une combinaison « OU » de touches de modification, cela signifie que toutes ces touches doivent être enfoncées pour activer le gestionnaire :

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

Les touches de modification disponibles sont les suivantes :

Si vous avez besoin d'un comportement encore plus complexe que celui pouvant être obtenu avec des combinaisons de plusieurs gestionnaires et de plusieurs indicateurs de modificateurs, vous pouvez vérifier les modificateurs dans du code 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;
            }
    }
}

Voir également Qt::KeyboardModifier.

acceptedPointerTypes : flags

Les types d'instruments de pointage (doigt, stylet, gomme, etc.) pouvant activer ce gestionnaire de pointeur.

Par défaut, cette propriété est définie sur « PointerDevice.AllPointerTypes ». Si vous la définissez sur une combinaison «OU» de types de périphériques, elle ignorera les événements provenant d’ devices non correspondants.

Par exemple, un contrôle pourrait être configuré pour répondre d’une certaine manière aux clics de souris, aux touches tactiles et aux clics de stylet, mais s’effacer s’il est touché avec une gomme sur une tablette graphique, grâce à deux gestionnaires :

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]

Cette propriété prend la valeur « true » dès lors que ce gestionnaire d’entrée a pris la responsabilité exclusive de la gestion d’un ou plusieurs « eventPoints », en ayant réussi à obtenir le contrôle exclusif de ces points. Cela signifie qu’il maintient ses propriétés à jour en fonction des mouvements de ces «eventPoints» et qu’il manipule activement ses « target » (le cas échéant).

cursorShape : Qt::CursorShape

Cette propriété définit la forme du curseur qui s'affichera lorsque la souris survolera l'élément « parent » et que la propriété « active » aura la valeur « true ».

Les formes de curseur disponibles sont les suivantes :

• Qt.ArrowCursor
• Qt.UpArrowCursor
• Qt.CrossCursor
• Qt.WaitCursor
• Qt.IBeamCursor
• Qt.CursorTailleVerticale
• Qt.CursorTailleHoriz
• Qt.SizeBDiagCursor
• Qt.SizeFDiagCursor
• Qt.SizeAllCursor
• Qt.CurseurVide
• Qt.CursorDiviséVerticalement
• Qt.Cursor à division horizontale
• Qt.CursorMainPointante
• Qt.CurseurInterdit
• Qt.Cursor« Qu'est-ce que c'est ? »
• Qt.Curseur-occupé
• Qt.CursorMainOuverte
• Qt.CurseurMainFermée
• Qt.CurseurGlisserCopier
• Qt.CurseurGlisserDéplacer
• Qt.DragLinkCursor

La valeur par défaut n'est pas définie, ce qui permet à l'élément « cursor » d'parent d'apparaître. Cette propriété peut être réinitialisée à son état initial en lui attribuant la valeur « undefined ».

Voir également Qt::CursorShape, QQuickItem::cursor() et HoverHandler::cursorShape.

dragThreshold : int

Distance en pixels sur laquelle l'utilisateur doit faire glisser un élément « eventPoint » pour que ce mouvement soit interprété comme un geste de glissement.

La valeur par défaut dépend de la plateforme et de la résolution de l'écran. Elle peut être réinitialisée à sa valeur par défaut en la définissant sur « undefined ». Le comportement lors du début d’un geste de glissement varie selon les gestionnaires.

enabled : bool

Si un « PointerHandler » est désactivé, il rejettera tous les événements et aucun signal ne sera émis.

Si la propriété « parent » d’une PointerHandler a la valeur « disabled », le gestionnaire sera également désactivé, même si la propriété « enabled » reste définie sur « true ».

grabPermissions : flags

Cette propriété définit les autorisations lorsque la logique de ce gestionnaire décide de prendre le contrôle exclusif, ou lorsqu'il est invité à approuver la prise de contrôle ou l'annulation de celle-ci par un autre gestionnaire.

La valeur par défaut est « PointerHandler.CanTakeOverFromItems | PointerHandler.CanTakeOverFromHandlersOfDifferentType | PointerHandler.ApprovesTakeOverByAnything », ce qui autorise la plupart des scénarios de prise de contrôle tout en évitant, par exemple, que deux PinchHandlers se disputent les mêmes points de contact.

margin : real

La marge située au-delà des limites de l'élément « parent », à l'intérieur de laquelle un « eventPoint » peut activer ce gestionnaire. Par exemple, sur une « PinchHandler » où le « target » est également l’« parent », il est utile de définir cette valeur à une distance correspondant au moins à la moitié de la largeur du doigt d’un utilisateur type, afin que, si l’« parent » a été réduite à une très petite taille, le geste de pincement reste possible. De même, si un bouton basé sur l’ TapHandler est placé près du bord de l’écran, cela permet de respecter la loi de Fitts : réagir aux clics de souris au bord de l’écran même si le bouton est visuellement espacé de quelques pixels par rapport à ce bord.

La valeur par défaut est 0.

parent : Item

L'objet ` Item `, qui correspond au périmètre d'application du gestionnaire ; l'`Item` dans lequel il a été déclaré. Le gestionnaire traitera les événements pour le compte de cet `Item`, ce qui signifie qu'un événement de pointeur est pertinent si au moins l'un de ses ` eventPoints ` se produit à l'intérieur de l'`Item`. Au départ, ` target() ` est identique, mais il peut être réaffecté.

Voir également target et QObject::parent().

target : Item

L'élément que ce gestionnaire va manipuler.

Par défaut, il s’agit de l’ parent, c’est-à-dire l’élément dans lequel le gestionnaire est déclaré. Cependant, il peut parfois être utile de définir la cible sur un autre élément, afin de gérer les événements au sein d’un élément tout en manipulant un autre ; ou d’ null, pour désactiver le comportement par défaut et effectuer une autre action à la place.

Documentation sur les signaux

canceled(eventPoint point)

Si ce gestionnaire a déjà saisi l'point donné, ce signal est émis lorsque la saisie est détournée par un autre gestionnaire de pointeur ou un autre élément.

grabChanged(PointerDevice::GrabTransition transition, eventPoint point)

Ce signal est émis lorsque le « grab » a subi une modification pertinente pour ce gestionnaire.

Le verbe « transition » indique ce qui s'est passé. L'objet « point » correspond au point qui a été sélectionné ou désélectionné.

Les valeurs valides pour « transition » sont :