SinglePointHandler QML Type

Abstrakter Handler für Einpunkt-Pointer-Events. Mehr...

Dieser Typ befindet sich in der Technologievorschau und kann sich noch ändern.

• Liste aller Mitglieder, einschließlich geerbter Mitglieder

Eigenschaften

• 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

Signale

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

Ausführliche Beschreibung

Eine Zwischenklasse (nicht als QML-Typ registriert) für die gängigsten Handler: diejenigen, die nur einen einzigen Punkt erwarten. Die Methode `wantsPointerEvent()` wählt den ersten Punkt aus, der sich innerhalb des Elements ` target ` befindet, und gibt `true` zurück, solange das Ereignis diesen Punkt enthält. Überschreiben Sie die Methode `handleEventPoint()`, um einen Ein-Punkt-Handler zu implementieren.

Dokumentation der Eigenschaften

acceptedButtons : flags

Die Maustasten, mit denen dieser Zeiger-Handler aktiviert werden kann.

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.

Beispielsweise könnte ein Steuerelement so gestaltet werden, dass es auf Links- und Rechtsklicks unterschiedlich reagiert, wobei zwei Handler zum Einsatz kommen:

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

acceptedDevices : flags

Die Arten von Zeigegeräten, die diesen Pointer-Handler 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 Geräten ignoriert.

Beispielsweise könnte ein Steuerelement so konfiguriert werden, dass es auf Maus- und Stiftklicks auf eine bestimmte Weise und auf Touchscreen-Tipps auf eine andere Weise reagiert, wobei zwei Handler zum Einsatz kommen:

Item {
   TapHandler {
       acceptedDevices: PointerDevice.Mouse | PointerDevice.TouchPad | PointerDevice.Stylus
       onTapped: console.log("clicked")
   }
   TapHandler {
       acceptedDevices: PointerDevice.TouchScreen
       onTapped: console.log("tapped")
   }
}

acceptedModifiers : flags

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

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

Beispielsweise könnte ein „ Item “ zwei Handler desselben Typs haben, von denen einer nur aktiviert wird, wenn die erforderlichen Tastenmodifikatoren gedrückt sind:

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

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:

Item {
   TapHandler {
       acceptedModifiers: Qt.ControlModifier | Qt.AltModifier | Qt.ShiftModifier
       onTapped: console.log("control-alt-shift-tapped")
   }
}

Die verfügbaren Modifikatoren sind wie folgt:

Wenn Sie ein noch komplexeres Verhalten benötigen, als es mit Kombinationen aus mehreren Handlern und mehreren Modifikator-Flags erreicht werden kann, können Sie die Modifikatoren im JavaScript-Code überprüfen:

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;
            }
    }
}

Siehe auch Qt::KeyboardModifier.

acceptedPointerTypes : flags

Die Arten von Zeigeinstrumenten (Finger, Stift, Radiergummi usw.), die diesen Pointer-Handler aktivieren können.

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

Beispielsweise könnte ein Steuerelement so gestaltet werden, dass es auf Maus-, Touch- und Stylus-Klicks in gewisser Weise reagiert, sich jedoch löscht, wenn es mit einem Radiergummi-Werkzeug auf einem Grafiktablett angetippt wird – mit zwei Handlern:

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]

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.

cursorShape : Qt::CursorShape

Diese Eigenschaft legt die Cursorform fest, die angezeigt wird, wenn der Mauszeiger über das Element „ parent “ bewegt wird, sofern „ 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 der „ cursor “-Cursor des Elements „ 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 durch die Einstellung auf „undefined“ auf den Standardwert zurückgesetzt werden. Das Verhalten beim Beginn einer Ziehgeste variiert je nach Handler.

enabled : bool

Wenn ein „ PointerHandler “ deaktiviert ist, lehnt er alle Ereignisse ab 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 „ parent “-Elements, innerhalb dessen ein „ eventPoint “ diesen Handler aktivieren kann. Bei einer „ PinchHandler “, bei der der „ target “ gleichzeitig der „ parent “ ist, empfiehlt es sich beispielsweise, diesen Wert auf mindestens die Hälfte der Breite eines typischen Benutzerfingers festzulegen, damit die Pinch-Geste auch dann noch möglich ist, wenn die „ parent “ auf eine sehr kleine Größe verkleinert wurde. Oder wenn eine auf „ TapHandler “ basierende Schaltfläche nahe am Bildschirmrand platziert ist, kann sie dazu verwendet werden, Fitts’ Gesetz zu erfüllen: Reagiere auf Mausklicks am Bildschirmrand, auch wenn die Schaltfläche optisch um einige Pixel vom Rand entfernt ist.

Der Standardwert ist 0.

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. Anfangs ist „ target() “ identisch, kann jedoch neu zugewiesen werden.

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

point : handlerPoint [read-only]

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

target : Item

Das Element, auf das dieser Handler einwirkt.

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

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: