MultiPointHandler QML Type

Gestionnaire abstrait pour les événements de pointeur multipoints. 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
• centroid : QtQuick::handlerPoint
• cursorShape : Qt::CursorShape
• dragThreshold : int
• enabled : bool
• grabPermissions : flags
• margin : real
• maximumPointCount : int
• minimumPointCount : int
• 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) destinée à tout type de gestionnaire nécessitant un nombre spécifique de points de contact multiples et agissant sur ceux-ci.

Documentation des propriétés

acceptedButtons : flags

Les boutons de souris permettant d'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 des 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 pourrait ê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 le 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 de périphériques non correspondants devices.

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 un outil « 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 gérer un ou plusieurs « eventPoints », en ayant réussi à obtenir l’exclusivité sur 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).

centroid : QtQuick::handlerPoint [read-only]

Un point situé exactement au milieu des points tactiles actuellement enfoncés. Si un seul point est enfoncé, il s'agit de ce point-là. Un gestionnaire doté d'une fonction « target » effectuera normalement la transformation par rapport à ce point.

cursorShape : Qt::CursorShape

Cette propriété définit la forme du curseur qui s'affichera lorsque la souris survolera l'élément « parent », à condition que la valeur de « active » soit « 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éVertical
• Qt.Cursor à division horizontale
• Qt.CursorMainPointante
• Qt.CursorInterdit
• Qt.Cursor« Qu'est-ce que c'est ? »
• Qt.Curseur-occupé
• Qt.CursorMainOuverte
• Qt.CurseurMainFermée
• Qt.CurseurGlisserCopier
• Qt.CurseurGlissementDéplacement
• Qt.DragLinkCursor

La valeur par défaut n'est pas définie, ce qui permet l'affichage de l'élément « cursor » d'parent. 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 considéré 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 est définie sur « 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 ne 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 page PinchHandler où le « target » correspond également au « parent », il est utile de définir cette distance à au moins la moitié de la largeur du doigt d'un utilisateur type, afin que, même si le « parent » a été réduit à 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.

maximumPointCount : int

Nombre maximal de points de contact que ce gestionnaire peut utiliser.

Si un nombre plus important de points de contact est en contact avec l'parent, le nombre requis de points sera sélectionné dans l'ordre dans lequel ils ont été appuyés, et les points restants seront ignorés.

Tout point ignoré peut activer d’autres gestionnaires d’entrée ayant des contraintes différentes, sur le même élément ou sur d’autres éléments.

La valeur par défaut est identique à celle de ` minimumPointCount`.

minimumPointCount : int

Nombre minimum de points de contact requis pour activer ce gestionnaire.

Si un nombre inférieur de points de contact est en contact avec l’ parent, ceux-ci seront ignorés.

Tout point ignoré peut activer d’autres gestionnaires d’entrée ayant des contraintes différentes, sur le même élément ou sur d’autres éléments.

La valeur par défaut est 2.

parent : Item

L'objet ` Item `, qui correspond au champ 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'une de ses coordonnées de point ( eventPoints ) se situe à 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 au sein duquel 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 lorsqu'un autre gestionnaire de pointeur ou un autre élément lui vole la saisie.

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 :