MultiPointHandler QML Type

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

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

• Liste aller Elemente, einschließlich geerbter Elemente

Eigenschaften

• acceptedButtons : flags
• acceptedDevices : flags
• acceptedModifiers : flags
• acceptedPointerTypes : flags
• active : bool
• centroid : QtQuick::handlerPoint
• cursorShape : Qt::CursorShape
• dragThreshold : int
• enabled : bool
• grabPermissions : flags
• margin : real
• maximumPointCount : int
• minimumPointCount : int
• parent : Item
• target : Item

Signale

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

Ausführliche Beschreibung

Eine Zwischenklasse (die nicht als QML-Typ registriert ist) für jede Art von Handler, der eine bestimmte Anzahl von Mehrfachberührungspunkten benötigt und darauf reagiert.

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 mit zwei Handlern unterschiedlich auf Links- und Rechtsklicks reagiert:

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 Zeiger-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 festgelegt 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 werden:

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 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 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 reserviert 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.

centroid : QtQuick::handlerPoint [read-only]

Ein Punkt, der genau in der Mitte der derzeit gedrückten Berührungspunkte liegt. Wenn nur ein Punkt gedrückt wird, entspricht er diesem Punkt. Ein Handler, der über einen „ target “ verfügt, transformiert diesen normalerweise relativ zu diesem Punkt.

cursorShape : Qt::CursorShape

Diese Eigenschaft legt die Cursorform fest, die angezeigt wird, sobald 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 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 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 auslösen 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 skaliert 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.

maximumPointCount : int

Die maximale Anzahl an Berührungspunkten, die dieser Handler nutzen kann.

Wenn eine größere Anzahl von Berührungspunkten mit dem „ parent “ in Kontakt steht, wird die erforderliche Anzahl von Punkten in der Reihenfolge ihrer Betätigung ausgewählt, und die übrigen Punkte werden ignoriert.

Alle ignorierten Berührungspunkte können andere Eingabe-Handler mit anderen Einschränkungen aktivieren – entweder auf demselben Element oder auf anderen Elementen.

Der Standardwert entspricht dem von „ minimumPointCount “.

minimumPointCount : int

Die Mindestanzahl an Berührungspunkten, die erforderlich ist, um diesen Handler auszulösen.

Wenn eine geringere Anzahl von Berührungspunkten mit dem „ parent “ in Kontakt steht, werden diese ignoriert.

Alle ignorierten Berührungspunkte können andere Eingabe-Handler mit anderen Einschränkungen aktivieren – entweder für dasselbe Element oder für andere Elemente.

Der Standardwert beträgt 2.

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`; das bedeutet, dass ein Zeigerereignis relevant ist, wenn mindestens einer 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: