SinglePointHandler QML Type

Gestionnaire abstrait pour les événements de pointeur à point unique. Plus d'informations...

Ce type est en cours de développement et peut ê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

Une 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. wantsPointerEvent() choisira le premier point qui se trouve à l'intérieur de l'élément target, et renverra vrai tant que l'événement contient ce point. Surchargez handleEventPoint() pour implémenter un gestionnaire de point unique.

Documentation sur les propriétés

acceptedButtons : flags

Les boutons de la souris qui peuvent 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 conçu pour répondre aux clics gauche et droit de manière différente, avec deux gestionnaires :

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

acceptedDevices : flags

Types de dispositifs de pointage pouvant activer ce gestionnaire de pointeurs.

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 de périphériques non correspondants.

Par exemple, un contrôle peut répondre aux clics de souris et de stylet d'une certaine manière, et aux pressions sur l'écran tactile d'une autre manière, avec 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, il faudra appuyer sur les modificateurs de clavier donnés pour réagir aux événements de pointeur, et les ignorer dans le cas contraire.

Si la valeur de cette propriété est Qt.KeyboardModifierMask (valeur par défaut), PointerHandler ignore les touches de modification.

Par exemple, un site Item peut avoir deux gestionnaires du même type, dont l'un n'est activé que si les modificateurs de clavier requis sont enfoncés :

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

Si vous attribuez à acceptedModifiers 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 modificateurs disponibles sont les suivants :

Si vous avez besoin d'un comportement encore plus complexe que celui que l'on peut obtenir en combinant plusieurs gestionnaires avec plusieurs indicateurs de modification, 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.) qui peuvent 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 devices qui ne correspondent pas.

Par exemple, un contrôle pourrait répondre aux clics de la souris, du toucher et du stylet d'une certaine manière, mais s'effacer s'il est tapé avec une gomme sur une tablette graphique, avec 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]

Il s'agit de true chaque fois que ce gestionnaire d'entrée a pris l'entière responsabilité de la transmission d'un ou de plusieurs eventPoints, en s'emparant avec succès de ces points de manière exclusive. Cela signifie qu'il tient ses propriétés à jour en fonction des mouvements de ces eventPoints et qu'il manipule activement son site target (le cas échéant).

cursorShape : Qt::CursorShape

Cette propriété définit la forme du curseur qui apparaîtra lorsque la souris survolera l'élément parent alors que active est true.

Les formes de curseur disponibles sont les suivantes :

• 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.ClosedHandCursor
• Qt.DragCopyCursor
• Qt.DragMoveCursor
• Qt.DragLinkCursor

La valeur par défaut n'est pas définie, ce qui permet à l'élément cursor de parent d'apparaître. Cette propriété peut être ramenée à la même condition initiale en lui attribuant la valeur undefined.

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

dragThreshold : int

La distance en pixels sur laquelle l'utilisateur doit faire glisser une page eventPoint pour que cela soit considéré comme un geste de glissement.

La valeur par défaut dépend de la plate-forme et de la résolution de l'écran. Elle peut être ramenée à la valeur par défaut en lui attribuant la valeur undefined. Le comportement au 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'un PointerHandler est disabled, le gestionnaire sera également désactivé, même si la propriété enabled reste true.

grabPermissions : flags

Cette propriété spécifie les autorisations lorsque la logique de ce gestionnaire décide de prendre en charge la saisie exclusive, ou lorsqu'il lui est demandé d'approuver la prise en charge ou l'annulation de la saisie par un autre gestionnaire.

La valeur par défaut est PointerHandler.CanTakeOverFromItems | PointerHandler.CanTakeOverFromHandlersOfDifferentType | PointerHandler.ApprovesTakeOverByAnything, ce qui permet la plupart des scénarios de prise en charge mais évite, par exemple, que deux PinchHandler ne se disputent les mêmes points de contact.

margin : real

La marge au-delà des limites de l'élément parent dans laquelle un eventPoint peut activer ce gestionnaire. Par exemple, sur un site PinchHandler où le site target est également le site parent, il est utile de fixer cette distance à au moins la moitié de la largeur du doigt d'un utilisateur typique, de sorte que si le site parent a été réduit à une taille très petite, le geste de pincement reste possible. Par ailleurs, si un bouton basé sur TapHandler est placé près du bord de l'écran, il peut être utilisé pour respecter la loi de Fitts : réagir aux clics de souris sur le bord de l'écran même si le bouton est visuellement éloigné du bord de quelques pixels.

La valeur par défaut est 0.

parent : Item

Le Item qui est la portée du gestionnaire ; l'élément dans lequel il a été déclaré. Le gestionnaire traitera les événements au nom de cet élément, 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'élément. Initialement, target() est le même, mais il peut être réaffecté.

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

point : handlerPoint [read-only]

Le site eventPoint en cours de traitement. Si aucun point n'est en cours de traitement, cet objet est réinitialisé aux valeurs par défaut (toutes les coordonnées sont à 0).

target : Item

L'élément que ce gestionnaire manipulera.

Par défaut, il est identique à parent, l'élément dans lequel le gestionnaire est déclaré. Cependant, il peut parfois être utile de définir la cible sur un élément différent, afin de gérer des événements dans un élément mais d'en manipuler un autre ; ou sur null, pour désactiver le comportement par défaut et faire quelque chose d'autre à la place.

Documentation sur les signaux

canceled(eventPoint point)

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

grabChanged(PointerDevice::GrabTransition transition, eventPoint point)

Ce signal est émis lorsque le grab a changé d'une manière ou d'une autre, ce qui est pertinent pour ce gestionnaire.

Le transition (verbe) indique ce qui s'est passé. Le point (objet) est le point qui a été saisi ou désaisi.

Les valeurs valides pour transition sont les suivantes