PointerDeviceHandler QML Type

Abstrakter Handler für Zeigerereignisse mit gerätespezifischen Einschränkungen. 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
• target : Item

Signale

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

Ausführliche Beschreibung

Eine Zwischenklasse (nicht als QML-Typ registriert) für Handler, die eine Filterung nach Gerätetyp, Zeigertyp oder Tastaturmodifikatoren ermöglichen.

Eigenschaftsdokumentation

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 OR-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, und zwar mit zwei Handlern:

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 Tastaturmodifikatoren 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 werden 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 mit 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 Zeige-Instrumenten (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 Stiftklicks 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 Eingabe-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, während die Einstellung „ active “ auf „ true “ gesetzt ist.

Die verfügbaren Cursorformen sind:

• Qt.ArrowCursor
• Qt.UpArrowCursor
• Qt.CrossCursor
• Qt.WaitCursor
• Qt.IBeamCursor
• Qt.Größenveränderungs-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.Zieh-Verschiebe-Cursor
• Qt.DragLinkCursor

Der Standardwert ist nicht festgelegt, wodurch der „ cursor “ des Elements „ parent “ angezeigt wird. Diese Eigenschaft kann auf denselben Ausgangszustand 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 erkannt 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 „ parent “-Elements, innerhalb dessen ein „ eventPoint “ diesen Handler aktivieren kann. Auf 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 wird, kann dies zur Einhaltung des Fitts’schen Gesetzes genutzt werden: Mausklicks am Bildschirmrand werden auch dann registriert, 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. Anfänglich ist „ target() “ identisch, kann jedoch neu zugewiesen werden.

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

target : Item

Das Element, 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 mit „ null “ 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: