HoverHandler QML Type

Handler für Maus- und Tablet-Hover. Mehr...

• Liste aller Mitglieder, einschließlich geerbter Mitglieder

Eigenschaften

• acceptedDevices : flags
• acceptedModifiers : flags
• acceptedPointerTypes : flags
• active : bool
• blocking : bool (since 6.3)
• cursorShape : Qt::CursorShape
• enabled : bool
• grabPermissions : flags
• hovered : bool
• margin : real
• parent : Item
• point : handlerPoint
• target : Item

Signale

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

Ausführliche Beschreibung

HoverHandler erkennt, wenn sich der Mauszeiger oder der Cursor eines Tablet-Stifts über einem Element befindet.

Eine Bindung an die Eigenschaft „ hovered “ ist die einfachste Möglichkeit, zu reagieren, wenn der Cursor das „ parent “-Element betritt oder verlässt. Die Eigenschaft „ point “ liefert weitere Details, einschließlich der Cursorposition. Mit den Eigenschaften „ acceptedDevices “, „ acceptedPointerTypes “ und „ acceptedModifiers “ lässt sich das Verhalten so eingrenzen, dass das Schweben bestimmter Gerätetypen oder das Schweben bei gedrückter Modifikatortaste erkannt wird.

Die Eigenschaft „ cursorShape “ ermöglicht es, den Cursor zu ändern, sobald sich „ hovered “ in „ true “ ändert.

Siehe auch „ MouseArea“ , „ PointHandler “ und „Qt Quick “ – Beispiele – Zeiger-Handler.

Dokumentation zur Eigenschaft

acceptedDevices : flags

Die Arten von Zeigegeräten, die den Zeiger-Handler aktivieren können.

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

Beispielsweise könnte ein Element so konfiguriert werden, dass es auf das Bewegen der Maus auf eine bestimmte Weise und auf das Bewegen eines Stifts auf eine andere Weise reagiert, wobei zwei Handler zum Einsatz kommen:

import QtQuick

Rectangle {
    width: 150; height: 50; radius: 3
    color: mouse.hovered ? "goldenrod" : stylus.hovered ? "tomato" : "wheat"

    HoverHandler {
        id: stylus
        acceptedDevices: PointerDevice.Stylus
        cursorShape: Qt.CrossCursor
    }

    HoverHandler {
        id: mouse
        acceptedDevices: PointerDevice.Mouse | PointerDevice.TouchPad
        cursorShape: Qt.PointingHandCursor
    }
}

Die verfügbaren Gerätetypen sind wie folgt:

Siehe auch QInputDevice::DeviceType.

acceptedModifiers : flags

Wenn diese Eigenschaft gesetzt ist, wird ein Hover-Ereignis nur dann verarbeitet, wenn die angegebenen Tastaturmodifikatoren gedrückt sind. Ohne diese Modifikatoren wird das Ereignis ignoriert.

Diese Eigenschaft ist standardmäßig auf „ Qt.KeyboardModifierMask “ gesetzt, was dazu führt, dass Hover-Ereignisse unabhängig von Modifikatortasten verarbeitet werden.

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

import QtQuick

Rectangle {
    width: 150; height: 50; radius: 3
    color: control.hovered ? "goldenrod" : shift.hovered ? "wheat" : "beige"

    HoverHandler {
        id: control
        acceptedModifiers: Qt.ControlModifier
        cursorShape: Qt.PointingHandCursor
    }

    HoverHandler {
        id: shift
        acceptedModifiers: Qt.ShiftModifier
        cursorShape: Qt.CrossCursor
    }
}

Die verfügbaren Modifikatoren sind wie folgt:

Siehe auch Qt::KeyboardModifier.

acceptedPointerTypes : flags

Die Arten von Zeige-Eingabegeräten (allgemein, Stift, Radiergummi usw.), die den Zeiger-Handler auslösen 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 Gerätetypen ignoriert.

Beispielsweise könnten Sie Feedback geben, indem Sie den Cursor je nachdem ändern, ob sich ein Stift oder ein Radierer über einem Grafiktablett befindet:

import QtQuick

Rectangle {
    id: rect
    width: 150; height: 150

    HoverHandler {
        id: stylus
        acceptedPointerTypes: PointerDevice.Pen
        cursorShape: Qt.CrossCursor
    }

    HoverHandler {
        id: eraser
        acceptedPointerTypes: PointerDevice.Eraser
        cursorShape: Qt.BlankCursor
        target: Image {
            parent: rect
            source: "images/cursor-eraser.png"
            visible: eraser.hovered
            x: eraser.point.position.x
            y: eraser.point.position.y - 32
        }
    }
}

Die verfügbaren Zeigertypen sind wie folgt:

Siehe auch „ QPointingDevice::PointerType “.

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.

blocking : bool [since 6.3]

Gibt an, ob dieser Handler verhindert, dass andere Elemente oder Handler, die sich dahinter befinden, gleichzeitig mit der Maus überfahren werden können. Diese Eigenschaft ist standardmäßig auf „ false “ gesetzt.

Diese Eigenschaft wurde in Qt 6.3 eingeführt.

cursorShape : Qt::CursorShape

Diese Eigenschaft enthält die Cursorform, die immer dann angezeigt wird, wenn „ hovered “ auf „ true “ gesetzt ist und kein anderer Handler diese Einstellung überschreibt.

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 dieser Eigenschaft ist nicht festgelegt, wodurch jeder aktive Handler auf demselben übergeordneten Element die Cursorform bestimmen kann. Diese Eigenschaft kann auf den Ausgangszustand zurückgesetzt werden, indem sie auf „ undefined “ gesetzt wird.

Wenn ein Handler mit dem definierten Wert „ cursorShape “ den Wert „ active “ aufweist, wird dieser Cursor angezeigt. Andernfalls wird der Cursor angezeigt, der im „ HoverHandler “ des übergeordneten Elements unter „ cursorShape “ definiert ist. Andernfalls wird der „ cursor “ des übergeordneten Elements angezeigt.

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

enabled : bool

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

Wenn die Eigenschaft „ parent “ eines „ HoverHandler “ auf „ disabled “ gesetzt ist, reagiert das „ HoverHandler “ standardmäßig weiterhin auf Hover-Ereignisse. Dies liegt daran, dass Hover-Feedback-Effekte und Tooltips auch dann nützlich sein können, wenn ein Steuerelement deaktiviert ist. Wenn Sie das „ HoverHandler “ deaktivieren möchten, wenn sein übergeordnetes Element deaktiviert ist, können Sie eine Bindung hinzufügen:

Item {
    HoverHandler {
        enabled: parent.enabled
    }
}

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.

hovered : bool [read-only]

Dies gilt immer dann, wenn sich der Cursor eines beliebigen Zeigegeräts (Maus oder Grafiktablett) innerhalb der Grenzen des Elements „ parent “ befindet, gegebenenfalls erweitert um das Element „ margin “.

margin : real

Der Randbereich außerhalb der Grenzen des „ parent “-Elements, innerhalb dessen ein „ eventPoint “ diesen Handler aktivieren kann. Beispielsweise ist es bei einem „ PinchHandler “, bei dem der „ target “ gleichzeitig der „ parent “ ist, sinnvoll, diesen Wert auf einen Abstand festzulegen, der mindestens der halben Breite eines typischen Benutzerfingers entspricht, damit die Pinch-Geste auch dann noch möglich ist, wenn der „ 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 erkannt, 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()“.

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

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: