Drag QML Type (Uncreatable)

Pour définir les événements de glisser-déposer pour les éléments déplacés. En savoir plus...

Remarque : il s'agit d'un type non instanciable. Il ne peut pas être instancié en QML.

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

Propriétés associées

• active : bool
• dragType : enumeration
• hotSpot : point
• imageSource : url
• imageSourceSize : size (since 6.8)
• keys : stringlist
• mimeData : var
• proposedAction : enumeration
• source : Object
• supportedActions : flags
• target : Object

Signaux associés

• dragFinished(DropAction dropAction)
• dragStarted()

Méthodes jointes

• void cancel()
• enumeration drop()
• void start(flags supportedActions)
• void startDrag(flags supportedActions)

Description détaillée

Grâce à la propriété associée Drag, n'importe quel élément peut devenir une source d'événements de glisser-déposer au sein d'une scène.

Lorsqu'un glissement est en cours ( active ) sur un élément, tout changement de position de cet élément génère un événement de glissement qui est envoyé à tous les éléments de la zone de glissement ( DropArea ) qui recoupent la nouvelle position de l'élément. D'autres éléments implémentant des gestionnaires d'événements de glisser-déposer peuvent également recevoir ces événements.

L'extrait de code suivant montre comment un élément peut être glissé à l'aide de ` MouseArea`. Cependant, le glissement ne se limite pas aux glissements de souris ; tout ce qui peut déplacer un élément peut générer des événements de glissement, y compris les événements tactiles, les animations et les liaisons.

import QtQuick

Item {
    width: 200; height: 200

    DropArea {
        x: 75; y: 75
        width: 50; height: 50

        Rectangle {
            anchors.fill: parent
            color: "green"

            visible: parent.containsDrag
        }
    }

    Rectangle {
        x: 10; y: 10
        width: 20; height: 20
        color: "red"

        Drag.active: dragArea.drag.active
        Drag.hotSpot.x: 10
        Drag.hotSpot.y: 10

        MouseArea {
            id: dragArea
            anchors.fill: parent

            drag.target: parent
        }
    }
}

Un glissement peut être interrompu soit en l'annulant avec `Drag.cancel()` ou en définissant `Drag.active` sur `false`, soit en déclenchant un événement de dépose via `Drag.drop()`. Si l'événement de dépose est accepté, `Drag.drop()` renverra l'drop action e choisie par le destinataire de l'événement ; dans le cas contraire, elle renverra `Qt.IgnoreAction`.

Voir également Exemples d’Qt Quick s - Glisser-déposer.

Documentation sur les propriétés associées

Drag.active : bool [read-only attached]

Cette propriété indique si une séquence d'événements de glisser-déposer est actuellement active.

En liant cette propriété à la propriété « active » de MouseArea::drag, la méthode startDrag sera appelée lorsque l'utilisateur commencera à faire glisser un élément.

Définir cette propriété sur « true » enverra également un événement QDragEnter à la scène avec la position actuelle de l’élément. La définir sur « false » enverra un événement QDragLeave.

Tant qu’un glissement est actif, tout changement de position de l’élément enverra un événement QDragMove à la scène avec la nouvelle position de l’élément.

Drag.dragType : enumeration [attached]

Cette propriété indique s'il faut lancer automatiquement les glissements, ne rien faire ou utiliser des glissements internes rétrocompatibles. Par défaut, le système utilise les glissements internes rétrocompatibles.

Un glissement peut également être lancé manuellement à l'aide de la fonction ` startDrag`.

Lorsque vous utilisez Drag.Automatic, vous devez également définir mimeData et lier la propriété active à la propriété active de MouseArea: MouseArea::drag.active

Drag.hotSpot : point [attached]

Cette propriété indique la position de glissement par rapport au coin supérieur gauche de l'élément.

Par défaut, elle est définie sur (0, 0).

Toute modification de la propriété hotSpot déclenche un nouveau déplacement avec la position mise à jour.

Drag.imageSource : url [attached]

Cette propriété contient l'URL de l'image qui sera utilisée pour représenter les données pendant l'opération de glisser-déposer. Modifier cette propriété une fois que l'opération de glisser-déposer a commencé n'aura aucun effet.

L'exemple ci-dessous utilise le contenu d'un élément comme image de glisser-déposer :

import QtQuick

Item {
    width: 200; height: 200

    Rectangle {
        anchors.centerIn: parent
        width: text.implicitWidth + 20; height: text.implicitHeight + 10
        color: "green"
        radius: 5

        Drag.dragType: Drag.Automatic
        Drag.supportedActions: Qt.CopyAction
        Drag.mimeData: {
            "text/plain": "Copied text"
        }

        Text {
            id: text
            anchors.centerIn: parent
            text: "Drag me"
        }

        DragHandler {
            id: dragHandler
            onActiveChanged:
                if (active) {
                    parent.grabToImage(function(result) {
                        parent.Drag.imageSource = result.url
                        parent.Drag.active = true
                    })
                } else {
                    parent.Drag.active = false
                }
        }
    }
}

Voir également Item::grabToImage().

Drag.imageSourceSize : size [attached, since 6.8]

Cette propriété définit la taille de l'image qui sera utilisée pour représenter les données pendant l'opération de glisser-déposer. La modification de cette propriété une fois l'opération de glisser-déposer lancée n'aura aucun effet.

Cette propriété définit le nombre maximal de pixels stockés pour l'image chargée, afin que les images volumineuses n'utilisent pas plus de mémoire que nécessaire. Pour plus de détails, consultez Image.sourceSize.

L'exemple ci-dessous montre une image SVG affichée à une certaine taille, puis réaffichée à une taille différente pour l'image de glisser-déposer :

import QtQuick

Item {
    width: 200; height: 200

    Image {
        anchors.centerIn: parent
        source: "images/qt_logo.svg"
        sourceSize.width: 96

        Drag.dragType: Drag.Automatic
        Drag.supportedActions: Qt.CopyAction
        Drag.mimeData: {
            "text/plain": "Qt Quick rocks!"
        }
        Drag.imageSource: "images/qt_logo.svg"
        Drag.imageSourceSize: Qt.size(48, 35)
        Drag.active: dragHandler.active

        DragHandler {
            id: dragHandler
        }
    }
}

Cette propriété a été introduite dans Qt 6.8.

Voir également imageSource et Item::grabToImage().

Drag.keys : stringlist [attached]

Cette propriété contient une liste de clés pouvant être utilisées par un « DropArea » pour filtrer les événements de glisser-déposer.

La modification des clés alors qu'un glissement est en cours réinitialise la séquence des événements de glissement en envoyant un événement « drag leave » suivi d'un événement « drag enter » avec la nouvelle source.

Drag.mimeData : var [attached]

Cette propriété contient une correspondance entre le type MIME et les données, utilisée lors de l'startDrag. Les données MIME doivent être d'un type correspondant au type MIME (par exemple, une chaîne de caractères si le type MIME est « text/plain », ou une image si le type MIME est « image/png »), ou un objet ` ArrayBuffer ` contenant les données encodées conformément au type MIME.

Drag.proposedAction : enumeration [attached]

Cette propriété contient une action recommandée par la source de glisser-déposer comme valeur de retour de la méthode `drop()`.

Toute modification apportée à `proposedAction` déclenchera un événement de déplacement avec la proposition mise à jour.

Drag.source : Object [attached]

Cette propriété contient un objet qui est identifié, pour les destinataires des événements de glisser-déposer, comme la source de ces événements. Par défaut, il s'agit de l'élément auquel la propriété Drag est associée.

La modification de la source alors qu'un glissement est en cours réinitialise la séquence des événements de glissement en envoyant un événement « drag leave » suivi d'un événement « drag enter » avec la nouvelle source.

Drag.supportedActions : flags [attached]

Cette propriété contient les valeurs de retour de la méthode `drop()` de `Drag` prise en charge par la source de glisser-déposer.

La modification de la propriété supportedActions alors qu’un glissement est en cours réinitialise la séquence des événements de glissement en envoyant un événement « drag leave » suivi d’un événement « drag enter » avec la nouvelle source.

Drag.target : Object [attached]

Lorsqu'un glissement est actif, cette propriété contient le dernier objet ayant accepté un événement « enter » provenant de l'élément glissé ; si la position actuelle du glissement ne recoupe aucune cible acceptante, elle est nulle.

Lorsqu'un glissement n'est pas actif, cette propriété contient l'objet qui a accepté l'événement de dépôt ayant mis fin au glissement ; si aucun objet n'a accepté le dépôt ou si le glissement a été annulé, la cible est alors nulle.

Documentation sur les signaux associés

[attached] dragFinished(DropAction dropAction)

Ce signal est émis lorsqu'un glissement prend fin et que celui-ci a été lancé à l'aide de la méthode startDrag() ou déclenché automatiquement via la propriété dragType.

dropAction Contient l'action acceptée par l'élément cible.

Voir également drop().

[attached] dragStarted()

Ce signal est émis lorsqu'un glisser-déposer est lancé à l'aide de la méthode startDrag() ou lorsqu'il est lancé automatiquement via la propriété dragType.

Documentation de la méthode ci-jointe

[attached] void cancel()

Met fin à une séquence de glissement.

[attached] enumeration drop()

Met fin à une séquence de glisser-déposer en envoyant un événement de dépôt à l'élément cible.

Renvoie l'action acceptée par l'élément cible. Si l'élément cible ou un élément parent n'accepte pas l'événement de dépôt, Qt.IgnoreAction est renvoyé.

L'action de dépôt renvoyée peut être l'une des suivantes :

[attached] void start(flags supportedActions)

Lance l'envoi d'événements de glissement. Utilisé pour lancer des glissements internes de l'ancien type. ` startDrag ` est la méthode recommandée, de nouveau type, pour lancer des glissements.

L'argument facultatif ` supportedActions ` peut être utilisé pour remplacer la propriété ` supportedActions ` pour la séquence lancée.

[attached] void startDrag(flags supportedActions)

Commence à envoyer des événements de glissement.

L'argument facultatif « supportedActions » peut être utilisé pour remplacer la propriété « supportedActions » pour la séquence lancée.