DragHandler QML Type

Handler für das Ziehen. Mehr...

• Liste aller Mitglieder, einschließlich geerbter Mitglieder
• Ausgeschiedene Mitglieder

Eigenschaften

• acceptedButtons : flags
• acceptedDevices : flags
• acceptedModifiers : flags
• acceptedPointerTypes : flags
• active : bool
• activeTranslation : vector2d
• cursorShape : Qt::CursorShape
• dragThreshold : int
• enabled : bool
• grabPermissions : flags
• margin : real
• parent : Item
• persistentTranslation : vector2d
• snapMode : enumeration
• target : Item
• xAxis
  • xAxis.activeValue : real
  • xAxis.enabled : bool
  • xAxis.maximum : real
  • xAxis.minimum : real
• yAxis
  • yAxis.activeValue : real
  • yAxis.enabled : bool
  • yAxis.maximum : real
  • yAxis.minimum : real

Signale

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

Detaillierte Beschreibung

DragHandler ist ein Handler, der verwendet wird, um ein Element interaktiv zu bewegen. Wie andere Input Handler ist er standardmäßig voll funktionsfähig und manipuliert seine target.

import QtQuick

Rectangle {
    width: 100
    height: 100
    color: "lightsteelblue"
    DragHandler { }
}

Er hat Eigenschaften, um den Bereich des Ziehens einzuschränken.

Wenn er innerhalb eines Elements deklariert wird, aber ein anderes target zugewiesen bekommt, dann behandelt er Ereignisse innerhalb der Grenzen des parent Elements, manipuliert aber stattdessen das target Element:

import QtQuick

Item {
    width: 640
    height: 480

    Rectangle {
        id: feedback
        border.color: "red"
        width: Math.max(10, handler.centroid.ellipseDiameters.width)
        height: Math.max(10, handler.centroid.ellipseDiameters.height)
        radius: Math.max(width, height) / 2
        visible: handler.active
    }

    DragHandler {
        id: handler
        target: feedback
    }
}

Eine dritte Möglichkeit besteht darin, target auf null zu setzen und auf eine andere Weise auf Eigenschaftsänderungen zu reagieren:

import QtQuick

Item {
    width: 640
    height: 480

    DragHandler {
        id: handler
        target: null
    }

    Text {
        color: handler.active ? "darkgreen" : "black"
        text: handler.centroid.position.x.toFixed(1) + "," + handler.centroid.position.y.toFixed(1)
        x: handler.centroid.position.x - width / 2
        y: handler.centroid.position.y - height
    }
}

Wenn minimumPointCount und maximumPointCount auf Werte größer als 1 gesetzt sind, muss der Benutzer so viele Finger in dieselbe Richtung ziehen, um mit dem Ziehen zu beginnen. Eine Mehrfinger-Ziehgeste kann unabhängig von einem (Standard-)Einfinger-DragHandler und einer PinchHandler auf demselben Item erkannt werden und kann daher verwendet werden, um ein anderes Feature unabhängig vom üblichen Pinch-Verhalten anzupassen: zum Beispiel eine Neigungs-Transformation oder einen anderen numerischen Wert, wenn target auf null gesetzt ist. Wenn target jedoch ein Element ist, ist centroid der Punkt, an dem das Ziehen beginnt und zu dem target verschoben wird (vorbehaltlich der Einschränkungen).

DragHandler kann zusammen mit der angehängten Eigenschaft Drag verwendet werden, um Drag-and-Drop zu implementieren.

Siehe auch Drag, MouseArea, und Qt Quick Beispiele - Zeiger-Handler.

Dokumentation der Eigenschaft

acceptedButtons : flags

Die Maustasten, die diese DragHandler aktivieren können.

Standardmäßig ist diese Eigenschaft auf Qt.LeftButton gesetzt. Sie kann auf eine ODER-Kombination von Maustasten gesetzt werden und ignoriert Ereignisse von anderen Tasten.

Wenn eine Komponente (z. B. TextEdit) das Ziehen mit der linken Taste bereits auf ihre eigene Art und Weise handhabt, kann sie durch eine DragHandler ergänzt werden, die beim Ziehen mit der rechten Taste etwas anderes tut:

Rectangle {
    id: canvas
    width: 640
    height: 480
    color: "#333"
    property int highestZ: 0

    Repeater {
        model: FolderListModel { nameFilters: ["*.qml"] }

        delegate: Rectangle {
            required property string fileName
            required property url fileUrl
            required property int index

            id: frame
            x: index * 30; y: index * 30
            width: 320; height: 240
            property bool dragging: ldh.active || rdh.active
            onDraggingChanged: if (dragging) z = ++canvas.highestZ
            border { width: 2; color: dragging ? "red" : "steelblue" }
            color: "beige"
            clip: true

            TextEdit {
                // drag to select text
                id: textEdit
                textDocument.source: frame.fileUrl
                x: 3; y: 3

                BoundaryRule on y {
                    id: ybr
                    minimum: textEdit.parent.height - textEdit.height; maximum: 0
                    minimumOvershoot: 200; maximumOvershoot: 200
                    overshootFilter: BoundaryRule.Peak
                }
            }

            DragHandler {
                id: rdh
                // right-drag to position the "window"
                acceptedButtons: Qt.RightButton
            }

            WheelHandler {
                target: textEdit
                property: "y"
                onActiveChanged: if (!active) ybr.returnToBounds()
            }

            Rectangle {
                anchors.right: parent.right
                width: titleText.implicitWidth + 12
                height: titleText.implicitHeight + 6
                border { width: 2; color: parent.border.color }
                bottomLeftRadius: 6
                Text {
                    id: titleText
                    color: "saddlebrown"
                    anchors.centerIn: parent
                    text: frame.fileName
                    textFormat: Text.PlainText
                }
                DragHandler {
                    id: ldh
                    // left-drag to position the "window"
                    target: frame
                }
            }
        }
    }
}

acceptedDevices : flags

Die Typen von Zeigegeräten, die diese DragHandler aktivieren können.

Standardmäßig ist diese Eigenschaft auf PointerDevice.AllDevices eingestellt. Wenn Sie sie auf eine ODER-Kombination von Gerätetypen einstellen, werden Ereignisse von nicht übereinstimmenden Geräten ignoriert.

acceptedModifiers : flags

Wenn diese Eigenschaft gesetzt ist, müssen die angegebenen Tastaturmodifikatoren gedrückt werden, um auf Zeigerereignisse zu reagieren, andernfalls werden sie ignoriert.

Zum Beispiel können zwei DragHandler zwei verschiedene Drag-and-Drop-Operationen durchführen, je nachdem, ob der Control Modifikator gedrückt ist:

GridView {
    id: root
    width: 320
    height: 480
    cellWidth: 80
    cellHeight: 80
    interactive: false

    displaced: Transition {
        NumberAnimation {
            properties: "x,y"
            easing.type: Easing.OutQuad
        }
    }

    model: DelegateModel {
        id: visualModel
        model: 24
        property var dropTarget: undefined
        property bool copy: false
        delegate: DropArea {
            id: delegateRoot

            width: 80
            height: 80

            onEntered: drag => {
                if (visualModel.copy) {
                    if (drag.source !== icon)
                        visualModel.dropTarget = icon
                } else {
                    visualModel.items.move(drag.source.DelegateModel.itemsIndex, icon.DelegateModel.itemsIndex)
                }
            }

            Rectangle {
                id: icon
                objectName: DelegateModel.itemsIndex

                property string text
                Component.onCompleted: {
                    color = Qt.rgba(0.2 + (48 - DelegateModel.itemsIndex) * Math.random() / 48,
                                    0.3 + DelegateModel.itemsIndex * Math.random() / 48,
                                    0.4 * Math.random(),
                                    1.0)
                    text = DelegateModel.itemsIndex
                }
                border.color: visualModel.dropTarget === this ? "black" : "transparent"
                border.width: 2
                radius: 3
                width: 72
                height: 72
                anchors {
                    horizontalCenter: parent.horizontalCenter
                    verticalCenter: parent.verticalCenter
                }

                states: [
                    State {
                        when: dragHandler.active || controlDragHandler.active
                        ParentChange {
                            target: icon
                            parent: root
                        }

                        AnchorChanges {
                            target: icon
                            anchors {
                                horizontalCenter: undefined
                                verticalCenter: undefined
                            }
                        }
                    }
                ]

                Text {
                    anchors.centerIn: parent
                    color: "white"
                    font.pointSize: 14
                    text: controlDragHandler.active ? "+" : icon.text
                }

                DragHandler {
                    id: dragHandler
                    acceptedModifiers: Qt.NoModifier
                    onActiveChanged: if (!active) visualModel.dropTarget = undefined
                }

                DragHandler {
                    id: controlDragHandler
                    acceptedModifiers: Qt.ControlModifier
                    onActiveChanged: {
                        visualModel.copy = active
                        if (!active) {
                            visualModel.dropTarget.text = icon.text
                            visualModel.dropTarget.color = icon.color
                            visualModel.dropTarget = undefined
                        }
                    }
                }

                Drag.active: dragHandler.active || controlDragHandler.active
                Drag.source: icon
                Drag.hotSpot.x: 36
                Drag.hotSpot.y: 36
            }
        }
    }
}

Wenn diese Eigenschaft auf Qt.KeyboardModifierMask gesetzt ist (der Standardwert), dann ignoriert DragHandler die Modifikatortasten.

Wenn Sie acceptedModifiers auf eine ODER-Kombination von Modifikatortasten setzen, bedeutet dies, dass alle diese Modifikatoren gedrückt werden müssen, um den Handler zu aktivieren.

Die verfügbaren Modifikatoren sind wie folgt:

Siehe auch Qt::KeyboardModifier.

acceptedPointerTypes : flags

Die Arten von Zeigeinstrumenten (Finger, Stift, Radiergummi usw.), die dieses DragHandler aktivieren können.

Standardmäßig ist diese Eigenschaft auf PointerDevice.AllPointerTypes eingestellt. Wenn Sie sie auf eine ODER-Kombination von Gerätetypen einstellen, werden Ereignisse von nicht übereinstimmenden devices ignoriert.

active : bool [read-only]

Dies gilt true immer dann, wenn dieser Input Handler die alleinige Verantwortung für die Übergabe eines oder mehrerer eventPoints übernommen hat, indem er erfolgreich einen exklusiven Zugriff auf diese Punkte genommen hat. Das bedeutet, dass er seine Eigenschaften entsprechend den Bewegungen dieser EventPoints auf dem neuesten Stand hält und seine target (falls vorhanden) aktiv manipuliert.

activeTranslation : vector2d [read-only]

Die Verschiebung während der Ausführung der Ziehgeste. Sie lautet 0, 0, wenn die Geste beginnt, und erhöht sich, wenn der/die Ereignispunkt(e) nach unten und nach rechts gezogen werden. Nach Beendigung der Geste bleibt sie unverändert und wird bei Beginn der nächsten Ziehgeste wieder auf 0, 0 zurückgesetzt.

cursorShape : Qt::CursorShape

Diese Eigenschaft enthält die Cursorform, die immer dann erscheint, wenn der Mauszeiger über dem Element parent schwebt, während active true ist.

Die verfügbaren Cursorformen sind:

• 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

Der Standardwert ist nicht gesetzt, so dass das Element cursor von parent erscheinen kann. Diese Eigenschaft kann auf den gleichen Ausgangszustand zurückgesetzt werden, indem sie auf undefiniert gesetzt wird.

Siehe auch Qt::CursorShape, QQuickItem::cursor(), und HoverHandler::cursorShape.

dragThreshold : int

Die Entfernung in Pixeln, die der Benutzer eine eventPoint ziehen muss, damit sie als Ziehgeste behandelt wird.

Der Standardwert hängt von der Plattform und der Bildschirmauflösung ab. Er kann auf den Standardwert zurückgesetzt werden, indem er auf undefiniert gesetzt wird. Das Verhalten, wenn eine Ziehgeste beginnt, variiert in verschiedenen Handlern.

enabled : bool

Wenn ein PointerHandler deaktiviert ist, werden alle Ereignisse zurückgewiesen und es werden keine Signale ausgesendet.

Wenn die parent von PointerHandler disabled ist, wird der Handler ebenfalls deaktiviert, auch wenn die enabled Eigenschaft true bleibt.

grabPermissions : flags

Diese Eigenschaft gibt die Berechtigungen an, wenn die Logik dieses Handlers beschließt, den exklusiven Greifer zu übernehmen, oder wenn er von einem anderen Handler aufgefordert wird, die Übernahme oder den Abbruch des Greifers zu genehmigen.

Die Voreinstellung ist PointerHandler.CanTakeOverFromItems | PointerHandler.CanTakeOverFromHandlersOfDifferentType | PointerHandler.ApprovesTakeOverByAnything, was die meisten Übernahmeszenarien erlaubt, aber z.B. verhindert, dass zwei PinchHandler um dieselben Touchpoints kämpfen.

margin : real

Die Spanne außerhalb der Grenzen des Elements parent, innerhalb derer ein eventPoint diesen Handler aktivieren kann. Sie können z. B. das Ziehen kleiner Elemente erleichtern, indem Sie dem Benutzer erlauben, von einer nahe gelegenen Position aus zu ziehen:

Rectangle {
    width: 24
    height: 24
    border.color: "steelblue"
    Text {
        text: "it's\ntiny"
        font.pixelSize: 7
        rotation: -45
        anchors.centerIn: parent
    }

    DragHandler {
        margin: 12
    }
}

parent : Item

Die Item, die der Anwendungsbereich des Handlers ist; das Item, in dem er deklariert wurde. Der Handler behandelt Ereignisse im Namen dieses Items, was bedeutet, dass ein Zeigerereignis relevant ist, wenn mindestens eines seiner eventPoints im Inneren des Items auftritt. Ursprünglich ist target() derselbe, aber er kann neu zugewiesen werden.

Siehe auch target und QObject::parent().

persistentTranslation : vector2d

Die Übersetzung, die auf target angewendet werden soll, wenn sie nicht null lautet. Andernfalls können Bindungen verwendet werden, um beliebige Dinge mit diesem Wert zu tun. Während die Ziehgeste ausgeführt wird, wird activeTranslation kontinuierlich hinzugefügt; nach Beendigung der Geste bleibt der Wert unverändert.

snapMode : enumeration

Diese Eigenschaft enthält den Fangmodus.

Der Fangmodus konfiguriert das Einrasten der Mitte des Elements target auf eventPoint.

Mögliche Werte:

target : Item

Das Element, das von diesem Handler bearbeitet wird.

Standardmäßig ist es dasselbe wie das parent, das Element, in dem der Handler deklariert ist. Manchmal kann es jedoch nützlich sein, das Ziel auf ein anderes Element zu setzen, um Ereignisse innerhalb eines Elements zu behandeln, aber ein anderes zu manipulieren; oder auf null, um das Standardverhalten zu deaktivieren und stattdessen etwas anderes zu tun.

xAxis group

xAxis steuert die Beschränkungen für das horizontale Ziehen.

minimum ist der minimale akzeptable Wert von x, der auf target anzuwenden ist. maximum ist der maximale akzeptable Wert von x, der auf target anzuwenden ist. Wenn enabled wahr ist, ist horizontales Ziehen erlaubt. activeValue ist dasselbe wie activeTranslation.x.

Das Signal activeValueChanged wird ausgegeben, wenn sich activeValue ändert, um die Schrittweite anzugeben, um die es sich geändert hat. Dies ist für die schrittweise Anpassung einer Eigenschaft über mehrere Handler gedacht.

yAxis group

yAxis steuert die Beschränkungen für das vertikale Ziehen.

minimum ist der minimale akzeptable Wert von y, der auf target anzuwenden ist. maximum ist der maximale akzeptable Wert von y, der auf target anzuwenden ist. Wenn enabled wahr ist, ist vertikales Ziehen erlaubt. activeValue ist dasselbe wie activeTranslation.y.

Das Signal activeValueChanged wird ausgegeben, wenn sich activeValue ändert, um die Schrittweite anzugeben, um die es sich geändert hat. Dies ist für die schrittweise Anpassung einer Eigenschaft über mehrere Handler gedacht:

import QtQuick

Rectangle {
    width: 50; height: 200

    Rectangle {
        id: knob
        width: parent.width; height: width; radius: width / 2
        anchors.centerIn: parent
        color: "lightsteelblue"

        Rectangle {
            antialiasing: true
            width: 4; height: 20
            x: parent.width / 2 - 2
        }

        WheelHandler {
            property: "rotation"
        }
    }

    DragHandler {
        target: null
        dragThreshold: 0
        yAxis.onActiveValueChanged: (delta)=> { knob.rotation -= delta }
    }
}

Signal-Dokumentation

canceled(eventPoint point)

Wenn dieser Handler das angegebene point bereits gegrabbt hat, wird dieses Signal ausgegeben, wenn das Grab von einem anderen Pointer Handler oder Item gestohlen wird.

grabChanged(PointerDevice::GrabTransition transition, eventPoint point)

Dieses Signal wird ausgegeben, wenn sich der Greifer in irgendeiner Weise verändert hat, die für diesen Handler relevant ist.

Das transition (Verb) sagt, was passiert ist. Das point (Objekt) ist der Punkt, der gegriffen oder nicht gegriffen wurde.

Gültige Werte für transition sind: