DragHandler QML Type

Handler für das Ziehen. Mehr...

• Liste aller Mitglieder, einschließlich geerbter Mitglieder
• Veraltete Elemente

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)

Ausführliche Beschreibung

DragHandler ist ein Handler, der zum interaktiven Verschieben eines Elements verwendet wird. Wie andere Eingabe-Handler ist er standardmäßig voll funktionsfähig und manipuliert sein „ target “.

import QtQuick

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

Er verfügt über Eigenschaften, mit denen der Bereich des Ziehens eingeschränkt werden kann.

Wird er innerhalb eines Elements deklariert, ihm aber ein anderes „ target “ zugewiesen, verarbeitet er Ereignisse innerhalb der Grenzen des Elements „ parent “, manipuliert jedoch stattdessen das Element „ target “:

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 Änderungen der Eigenschaft auf andere Weise 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 das Ziehen zu starten. Eine Mehrfinger-Ziehgeste kann unabhängig sowohl von einem (standardmäßigen) Einfinger-`DragHandler` als auch von einem ` PinchHandler ` auf demselben `Item` erkannt werden und kann somit verwendet werden, um eine andere Funktion unabhängig vom üblichen Pinch-Verhalten anzupassen: zum Beispiel eine Neigungstransformation oder einen anderen numerischen Wert, wenn ` target ` auf `null` gesetzt ist. Ist der „ target “ jedoch ein „Item“, ist „ centroid “ der Punkt, an dem das Ziehen beginnt und zu dem das „ target “ (unter Berücksichtigung von Einschränkungen) verschoben wird.

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 zu den Eigenschaften

acceptedButtons : flags

Die Maustasten, mit denen diese Funktion aktiviert werden kann: DragHandler.

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

Wenn beispielsweise eine Komponente (wie „ TextEdit “) das Ziehen mit der linken Maustaste bereits auf eigene Weise verarbeitet, kann sie um eine „ DragHandler “ erweitert werden, die beim Ziehen mit der rechten Maustaste eine andere Aktion ausführt:

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 Arten von Zeigegeräten, die diese Funktion aktivieren können: DragHandler.

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

acceptedModifiers : flags

Wenn diese Eigenschaft gesetzt ist, müssen die angegebenen Tastaturmodifikatoren gedrückt sein, damit auf Zeigerereignisse reagiert wird; andernfalls werden diese ignoriert.

Beispielsweise können zwei „DragHandler“ zwei unterschiedliche Drag-and-Drop-Vorgänge ausführen, je nachdem, ob die Modifikatortaste „ Control “ 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
            }
        }
    }
}

Ist diese Eigenschaft auf „ Qt.KeyboardModifierMask “ gesetzt (Standardwert), ignoriert der „ DragHandler “ die Modifikatortasten.

Wenn Sie „ acceptedModifiers “ auf eine ODER-Kombination von Modifikatortasten setzen, bedeutet dies, dass alle diese Modifikatortasten gedrückt sein 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.), mit denen diese Funktion aktiviert werden kann: DragHandler.

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

active : bool [read-only]

Dies gilt für true, sobald dieser Input-Handler die alleinige Verantwortung für die Verarbeitung eines oder mehrerer eventPoints übernommen hat, indem er diese Punkte erfolgreich exklusiv erfasst hat. Das bedeutet, dass er seine Eigenschaften entsprechend den Bewegungen dieser eventPoints auf dem neuesten Stand hält und seine target (sofern vorhanden) aktiv bearbeitet.

activeTranslation : vector2d [read-only]

Die Verschiebung während der Ausführung der Ziehgeste. Zu Beginn der Geste beträgt sie 0, 0 und nimmt zu, während der/die Ereignispunkt(e) nach unten und nach rechts gezogen werden. Nach Beendigung der Geste bleibt sie unverändert; und wenn die nächste Ziehgeste beginnt, wird sie wieder auf 0, 0 zurückgesetzt.

cursorShape : Qt::CursorShape

Diese Eigenschaft legt die Cursorform fest, die angezeigt wird, wenn der Mauszeiger über das Element „ parent “ bewegt wird, während „ active “ auf „ true “ gesetzt ist.

Die verfügbaren Cursorformen sind:

• Qt.ArrowCursor
• Qt.UpArrowCursor
• Qt.CrossCursor
• Qt.WaitCursor
• Qt.IBeamCursor
• Qt.Größe-Vertikal-Cursor
• Qt.SizeHorCursor
• Qt.SizeBDiagCursor
• Qt.SizeFDiagCursor
• Qt.SizeAllCursor
• Qt.LeererCursor
• Qt.SplitVCursor
• Qt.SplitHCursor
• Qt.ZeigenderFinger-Cursor
• Qt.VerbotenerCursor
• Qt.Was-ist-das-Cursor
• Qt.Beschäftigt-Cursor
• Qt.Cursor mit offener Hand
• Qt.Geschlossene-Hand-Cursor
• Qt.Ziehen-Kopieren-Cursor
• Qt.Ziehen-Verschieben-Cursor
• Qt.DragLinkCursor

Der Standardwert ist nicht festgelegt, wodurch das Element „ cursor “ von „ parent “ angezeigt wird. Diese Eigenschaft kann auf den ursprünglichen Zustand zurückgesetzt werden, indem sie auf „undefined“ gesetzt wird.

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

dragThreshold : int

Die Entfernung in Pixeln, um die der Benutzer ein „ eventPoint “ ziehen muss, damit dies als Ziehgeste gewertet wird.

Der Standardwert hängt von der Plattform und der Bildschirmauflösung ab. Er kann auf den Standardwert zurückgesetzt werden, indem man ihn auf „undefined“ setzt. Das Verhalten beim Beginn einer Ziehgeste variiert je nach Handler.

enabled : bool

Wenn ein „ PointerHandler “ deaktiviert ist, werden alle Ereignisse abgelehnt und es werden keine Signale ausgegeben.

Wenn die Eigenschaft „ parent “ eines „ PointerHandler “ auf „ disabled “ gesetzt ist, wird der Handler ebenfalls effektiv deaktiviert, selbst wenn die Eigenschaft „ enabled “ weiterhin auf „ true “ gesetzt ist.

grabPermissions : flags

Diese Eigenschaft legt die Berechtigungen fest, wenn die Logik dieses Handlers beschließt, die exklusive Grab-Kontrolle zu übernehmen, oder wenn sie aufgefordert wird, die Übernahme oder Aufhebung der Grab-Kontrolle durch einen anderen Handler zu genehmigen.

Die Standardeinstellung ist „ PointerHandler.CanTakeOverFromItems | PointerHandler.CanTakeOverFromHandlersOfDifferentType | PointerHandler.ApprovesTakeOverByAnything “, was die meisten Übernahme-Szenarien zulässt, aber beispielsweise verhindert, dass sich zwei „PinchHandler“ um dieselben Berührungspunkte streiten.

margin : real

Der Randbereich außerhalb der Grenzen des Elements „ parent “, innerhalb dessen ein „ eventPoint “ diesen Handler auslösen kann. So können Sie beispielsweise das Ziehen kleiner Elemente erleichtern, indem Sie dem Benutzer erlauben, von einer Position in der Nähe 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 den Geltungsbereich des Handlers darstellt; das „Item“, in dem er deklariert wurde. Der Handler verarbeitet Ereignisse im Namen dieses „Item“, was bedeutet, dass ein Zeigerereignis relevant ist, wenn mindestens eines seiner „ eventPoints “ innerhalb des „Item“ auftritt. Anfänglich ist „ target() “ identisch, kann jedoch neu zugewiesen werden.

Siehe auch „ target “ und „ QObject::parent()“.

persistentTranslation : vector2d

Die Übersetzung, die auf die ` target ` angewendet werden soll, sofern diese nicht ` null` ist. Andernfalls können Bindungen verwendet werden, um beliebige Aktionen mit diesem Wert durchzuführen. Während die Ziehgeste ausgeführt wird, wird die ` activeTranslation ` kontinuierlich hinzugefügt; nach Beendigung der Geste bleibt sie unverändert.

snapMode : enumeration

Diese Eigenschaft legt den Ausrichtungsmodus fest.

Der Ausrichtungsmodus legt fest, wie die Mitte des Elements „ target “ an „ eventPoint “ ausgerichtet wird.

Mögliche Werte:

target : Item

Das Item, auf das dieser Handler einwirkt.

Standardmäßig entspricht es dem „ parent “, also dem Element, in dem der Handler deklariert ist. Manchmal kann es jedoch sinnvoll sein, das Ziel auf ein anderes Element festzulegen, um Ereignisse in einem Element zu verarbeiten, aber ein anderes Element zu bearbeiten; oder um „ null “ zu verwenden, um das Standardverhalten zu deaktivieren und stattdessen etwas anderes auszuführen.

xAxis group

xAxis Steuert die Einschränkungen für das horizontale Ziehen.

minimum ist der minimal zulässige Wert von „ x “, der auf „ target “ angewendet werden soll. „ maximum “ ist der maximal zulässige Wert von „ x “, der auf „ target “ angewendet werden soll. Wenn „ enabled “ wahr ist, ist das horizontale Ziehen zulässig. „ activeValue “ entspricht „ activeTranslation.x “.

Das Signal „ activeValueChanged “ wird ausgelöst, wenn sich „ activeValue “ ändert, um den Wert des Inkrements anzugeben, um den sich der Wert geändert hat. Dies ist für die schrittweise Anpassung einer Eigenschaft über mehrere Handler vorgesehen.

yAxis group

yAxis Steuert die Einschränkungen für das vertikale Ziehen.

minimum ist der minimal zulässige Wert von „ y “, der auf „ target “ angewendet werden darf. „ maximum “ ist der maximal zulässige Wert von „ y “, der auf „ target “ angewendet werden darf. Wenn „ enabled “ wahr ist, ist das vertikale Ziehen zulässig. „ activeValue “ entspricht „ activeTranslation.y “.

Das Signal „ activeValueChanged “ wird ausgelöst, wenn sich „ activeValue “ ändert, um den Wert anzugeben, um den es sich geändert hat. Dies ist für die schrittweise Anpassung einer Eigenschaft über mehrere Handler vorgesehen:

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 den angegebenen point bereits ergriffen hat, wird dieses Signal ausgelöst, sobald die Ergreifung von einem anderen Pointer-Handler oder Item übernommen wird.

grabChanged(PointerDevice::GrabTransition transition, eventPoint point)

Dieses Signal wird ausgelöst, wenn sich der „Grab“ in einer Weise verändert hat, die für diesen Handler relevant ist.

Das Verb „ transition “ gibt an, was geschehen ist. Das Objekt „ point “ ist der Punkt, der ergriffen oder freigegeben wurde.

Gültige Werte für „ transition “ sind: