PointHandler QML Type

Die Maustasten, die diese PointHandler aktivieren können.

Standardmäßig ist diese Eigenschaft auf Qt.LeftButton festgelegt. Sie kann auf eine ODER-Kombination von Maustasten festgelegt werden und ignoriert Ereignisse, bei denen andere Tasten gedrückt oder gehalten werden. Wenn sie auf Qt.NoButton gesetzt ist, bedeutet dies, dass sie sich überhaupt nicht um Tasten kümmert und synthetische Mausereignisse ignoriert, die von einem Gerät kommen, für das sie bereits ein authentisches eventPoint verarbeitet.

import QtQuick

Item {
    width: 480; height: 320

    Rectangle {
        color: handler.active ? "tomato" : "wheat"
        x: handler.point.position.x - width / 2
        y: handler.point.position.y - height / 2
        width: 20; height: width; radius: width / 2
    }

    PointHandler {
        id: handler
        acceptedButtons: Qt.MiddleButton | Qt.RightButton
    }
}

acceptedButtons: \c Qt.NoButton

zu deklarieren, um dieses Problem zu vermeiden. Siehe auch Qt::AA_SynthesizeMouseForUnhandledTouchEvents und Qt::AA_SynthesizeMouseForUnhandledTabletEvents.

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

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

PointHandler {
    id: handler
    acceptedDevices: PointerDevice.TouchScreen | PointerDevice.TouchPad
    target: Rectangle {
        parent: glassPane
        color: "red"
        visible: handler.active
        x: handler.point.position.x - width / 2
        y: handler.point.position.y - height / 2
        width: 20; height: width; radius: width / 2
    }
}

Wenn diese Eigenschaft gesetzt ist, verlangt PointHandler, dass die angegebenen Tastaturmodifikatoren gedrückt werden, um auf PointerEvents zu reagieren, und ignoriert sie ansonsten.

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

Ein Item könnte zum Beispiel zwei Handler haben, von denen einer nur aktiviert wird, wenn der erforderliche Tastaturmodifikator gedrückt wird:

import QtQuick

Item {
    id: feedbackPane
    width: 480; height: 320

    PointHandler {
        id: control
        acceptedModifiers: Qt.ControlModifier
        cursorShape: Qt.PointingHandCursor
        target: Rectangle {
            parent: feedbackPane
            color: control.active ? "indianred" : "khaki"
            x: control.point.position.x - width / 2
            y: control.point.position.y - height / 2
            width: 20; height: width; radius: width / 2
        }
    }

    PointHandler {
        id: shift
        acceptedModifiers: Qt.ShiftModifier | Qt.MetaModifier
        cursorShape: Qt.CrossCursor
        target: Rectangle {
            parent: feedbackPane
            color: shift.active ? "darkslateblue" : "lightseagreen"
            x: shift.point.position.x - width / 2
            y: shift.point.position.y - height / 2
            width: 30; height: width; radius: width / 2
        }
    }
}

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.

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

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:

import QtQuick

Canvas {
    id: canvas
    width: 800
    height: 600
    antialiasing: true
    renderTarget: Canvas.FramebufferObject
    property var points: []
    onPaint: {
        if (points.length < 2)
            return
        var ctx = canvas.getContext('2d');
        ctx.save()
        ctx.strokeStyle = stylusHandler.active ? "blue" : "white"
        ctx.lineCap = "round"
        ctx.beginPath()
        ctx.moveTo(points[0].x, points[0].y)
        for (var i = 1; i < points.length; i++)
            ctx.lineTo(points[i].x, points[i].y)
        ctx.lineWidth = 3
        ctx.stroke()
        points = points.slice(points.length - 2, 1)
        ctx.restore()
    }

    PointHandler {
        id: stylusHandler
        acceptedPointerTypes: PointerDevice.Pen
        onPointChanged: {
            canvas.points.push(point.position)
            canvas.requestPaint()
        }
    }

    PointHandler {
        id: eraserHandler
        acceptedPointerTypes: PointerDevice.Eraser
        onPointChanged: {
            canvas.points.push(point.position)
            canvas.requestPaint()
        }
    }

    Rectangle {
        width: 10; height: 10
        color: stylusHandler.active ? "green" : eraserHandler.active ? "red" : "beige"
    }
}

Die Qt Quick Beispiele - Pointer Handlers enthält ein komplexeres Beispiel für das Zeichnen auf einem Canvas mit einem Grafiktablett.

Dieses hält true immer dann, wenn die Bedingungen erfüllt sind und dieses PointHandler reagiert. Das bedeutet, dass es seine Eigenschaften entsprechend den Bewegungen von eventPoints, die die Bedingungen erfüllen, auf dem neuesten Stand hält.

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.

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

Diese Eigenschaft legt die Berechtigungen fest, 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 Greifens zu genehmigen.

Der Standardwert ist PointerHandler.CanTakeOverFromItems | PointerHandler.CanTakeOverFromHandlersOfDifferentType | PointerHandler.ApprovesTakeOverByAnything, der die meisten Übernahmeszenarien zulässt, aber z. B. verhindert, dass sich zwei PinchHandler um dieselben Touchpoints streiten.

Die Spanne außerhalb der Grenzen des parent Elements, innerhalb derer ein eventPoint diesen Handler aktivieren kann.

Der Standardwert ist 0.

import QtQuick

Item {
    width: 480; height: 320

    Rectangle {
        anchors.fill: handlingContainer
        anchors.margins: -handler.margin
        color: "beige"
    }

    Rectangle {
        id: handlingContainer
        width: 200; height: 200
        anchors.centerIn: parent
        border.color: "green"
        color: handler.active ? "lightsteelblue" : "khaki"

        Text {
            text: "X"
            x: handler.point.position.x - width / 2
            y: handler.point.position.y - height / 2
            visible: handler.active
        }

        PointHandler {
            id: handler
            margin: 30
        }
    }

}

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

Siehe auch target und QObject::parent().

Der eventPoint, der gerade bearbeitet wird. Wenn derzeit kein Punkt bearbeitet wird, wird dieses Objekt auf die Standardwerte zurückgesetzt (alle Koordinaten sind 0).

Eine Eigenschaft, die bequem ein zu bearbeitendes Element enthalten oder eine Rückmeldung anzeigen kann. Im Gegensatz zu anderen Pointer-Handlern macht PointHandler nichts mit target selbst: Sie müssen normalerweise reaktive Bindungen zu Eigenschaften wie SinglePointHandler::point und PointHandler::active erstellen. Wenn Sie hier eine Item-Instanz deklarieren, müssen Sie explizit deren parent setzen, da PointHandler kein Item ist.

Standardmäßig ist es dasselbe wie das parent, das Item, in dem der Handler deklariert ist.

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.

Dieses Signal wird ausgegeben, wenn sich der Grab in irgendeiner Weise geä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: