SinglePointHandler QML Type

Gestionnaire d'abstraits pour les événements de pointeur à point unique. 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
• point : handlerPoint
• 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 les plus courants : ceux qui n'attendent qu'un seul point. La méthode `wantsPointerEvent()` choisira le premier point situé à l'intérieur de l'élément ` target ` et renverra `true` tant que l'événement contient ce point. Redéfinissez la méthode `handleEventPoint()` pour implémenter un gestionnaire à point unique.

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 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 ne correspondant pas à cette combinaison.

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 touches de modification spécifiées devront être enfoncées pour que le système réagisse aux événements du pointeur ; dans le cas contraire, il les ignorera.

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

Item Par exemple, une pourrait 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 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 un outil « gomme » sur une tablette graphique, à l’aide de 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 du traitement d’un ou plusieurs « eventPoints », après avoir réussi à les «saisir» de manière exclusive. 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 chaque fois que la souris survolera l’élément « parent » lorsque « active » est défini sur « 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.CursorMainOverte
• Qt.CurseurMainFermée
• Qt.Curseur de glisser-copier
• Qt.CurseurGlisserDéplacer
• Qt.DragLinkCursor

La valeur par défaut n’est pas définie, ce qui permet d’afficher l’élément « cursor » de l’ 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 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 est définie sur « disabled », le gestionnaire sera également désactivé de fait, 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 « PinchHandler » où le « target » est également le « 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 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.

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'un de ses « eventPoints » se produit à l'intérieur de l'« Item ». Au départ, « target() » est identique, mais il peut être réattribué.

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

point : handlerPoint [read-only]

L'eventPoint e actuellement sélectionné. Lorsqu'aucun point n'est sélectionné, cet objet est réinitialisé à ses valeurs par défaut (toutes les coordonnées sont égales à 0).

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