Item QML Type

Ein grundlegender visueller QML-Typ. Mehr...

• Liste aller Mitglieder, einschließlich geerbter Mitglieder

Eigenschaften

• activeFocus : bool
• activeFocusOnTab : bool
• anchors
  • anchors.alignWhenCentered : bool
  • anchors.baseline : AnchorLine
  • anchors.baselineOffset : real
  • anchors.bottom : AnchorLine
  • anchors.bottomMargin : real
  • anchors.centerIn : Item
  • anchors.fill : Item
  • anchors.horizontalCenter : AnchorLine
  • anchors.horizontalCenterOffset : real
  • anchors.left : AnchorLine
  • anchors.leftMargin : real
  • anchors.margins : real
  • anchors.right : AnchorLine
  • anchors.rightMargin : real
  • anchors.top : AnchorLine
  • anchors.topMargin : real
  • anchors.verticalCenter : AnchorLine
  • anchors.verticalCenterOffset : real
• antialiasing : bool
• baselineOffset : int
• children : list<Item>
• childrenRect
  • childrenRect.height : real
  • childrenRect.width : real
  • childrenRect.x : real
  • childrenRect.y : real
• clip : bool
• containmentMask : QObject*
• data : list<QtObject>
• enabled : bool
• focus : bool
• focusPolicy : enumeration (since 6.7)
• height : real
• implicitHeight : real
• implicitWidth : real
• layer.effect : Component
• layer.enabled : bool
• layer.format : enumeration
• layer.live : bool (since 6.5)
• layer.mipmap : bool
• layer.samplerName : string
• layer.samples : enumeration
• layer.smooth : bool
• layer.sourceRect : rect
• layer.textureMirroring : enumeration
• layer.textureSize : size
• layer.wrapMode : enumeration
• mutabilityGroup : int (since 6.12)
• opacity : real
• palette : Palette (since 6.0)
• parent : Item
• resources : list<QtObject>
• rotation : real
• scale : real
• smooth : bool
• state : string
• states : list<State>
• transform : list<Transform>
• transformOrigin : enumeration
• transitions : list<Transition>
• visible : bool
• visibleChildren : list<Item>
• width : real
• x : real
• y : real
• z : real

Methoden

• Item childAt(real x, real y)
• bool contains(point point)
• void dumpItemTree() (since 6.3)
• void forceActiveFocus()
• void forceActiveFocus(Qt::FocusReason reason)
• bool grabToImage(callback, targetSize)
• point mapFromGlobal(real x, real y)
• point mapFromItem(Item item, point p)
• rect mapFromItem(Item item, rect r)
• point mapFromItem(Item item, real x, real y)
• rect mapFromItem(Item item, real x, real y, real width, real height)
• point mapToGlobal(real x, real y)
• point mapToItem(Item item, point p)
• rect mapToItem(Item item, rect r)
• point mapToItem(Item item, real x, real y)
• rect mapToItem(Item item, real x, real y, real width, real height)
• Item nextItemInFocusChain(bool forward)

Ausführliche Beschreibung

Der Typ „Item“ ist der Basistyp für alle visuellen Elemente in „ Qt Quick “.

Alle visuellen Elemente in „ Qt Quick “ erben von „Item“. Obwohl ein „Item“-Objekt keine visuelle Darstellung hat, definiert es alle Attribute, die visuellen Elementen gemeinsam sind, wie beispielsweise x- und y-Position, Breite und Höhe, Verankerung sowie Unterstützung für die Tastenbehandlung.

Der Typ „Item“ kann nützlich sein, um mehrere Elemente unter einem einzigen übergeordneten visuellen Element zu gruppieren. Beispiel:

import QtQuick 2.0

Item {
    Image {
        source: "tile.png"
    }
    Image {
        x: 80
        width: 100
        height: 100
        source: "tile.png"
    }
    Image {
        x: 190
        width: 100
        height: 100
        fillMode: Image.Tile
        source: "tile.png"
    }
}

Ereignisbehandlung

Alle auf „Item“ basierenden visuellen Typen können Eingabehandler verwenden, um eingehende Eingabeereignisse (Unterklassen von „ QInputEvent “) wie Maus-, Touch- und Tastenereignisse zu verarbeiten. Dies ist die bevorzugte deklarative Methode zur Ereignisverarbeitung.

Eine alternative Möglichkeit zur Verarbeitung von Touch-Ereignissen besteht darin, eine Unterklasse von ` QQuickItem` zu erstellen, im Konstruktor `setAcceptTouchEvents()` aufzurufen und `touchEvent()` zu überschreiben. Mit ` Accept ` wird das gesamte Ereignis abgefangen, um die Weiterleitung an darunterliegende Elemente zu unterbinden und alle Berührungspunkte des Ereignisses exklusiv zu erfassen. Verwenden Sie ` QPointerEvent::setExclusiveGrabber()`, um nur bestimmte Berührungspunkte zu erfassen und die Weiterleitung des Ereignisses zuzulassen.

Ebenso kann eine Unterklasse von ` QQuickItem ` die Methode `setAcceptedMouseButtons()` aufrufen, um sich für den Empfang von Maustastenereignissen zu registrieren, `setAcceptHoverEvents()`, um Hover-Ereignisse (Mausbewegungen, während keine Taste gedrückt ist) zu empfangen, und die virtuellen Funktionen `mousePressEvent()`, `mouseMoveEvent()` und `mouseReleaseEvent()` überschreiben. Diese können das Ereignis auch annehmen, um eine weitere Weiterleitung zu verhindern und gleichzeitig ein implizites „Grab“ zu erhalten; oder explizit mit ` grab ` das einzelne ` QEventPoint ` abrufen, das das ` QMouseEvent ` enthält.

Die Tastenverarbeitung steht allen auf „Item“ basierenden visuellen Typen über die angehängte Eigenschaft „ Keys “ zur Verfügung. Die angehängte Eigenschaft „Keys“ stellt grundlegende Signale wie „ pressed “ und „ released “ sowie Signale für bestimmte Tasten wie „ spacePressed “ bereit. Das folgende Beispiel weist dem Element den Tastaturfokus zu und verarbeitet die linke Taste über den allgemeinen Handler „ onPressed “ sowie die Eingabetaste über den Handler „ onReturnPressed “:

import QtQuick 2.0

Item {
    focus: true
    Keys.onPressed: (event)=> {
        if (event.key == Qt.Key_Left) {
            console.log("move left");
            event.accepted = true;
        }
    }
    Keys.onReturnPressed: console.log("Pressed return");
}

Ausführliche Informationen finden Sie in der angehängten Eigenschaft „ Keys “.

Layout-Spiegelung

Elementlayouts können mithilfe der angehängten Eigenschaft „ LayoutMirroring “ gespiegelt werden. Dies bewirkt, dass „ anchors “ horizontal umgekehrt wird, und führt außerdem dazu, dass Elemente, die ihre untergeordneten Elemente anordnen oder positionieren (wie z. B. „ ListView “ oder „ Row “), die Richtung ihrer Layouts horizontal umkehren.

Weitere Details finden Sie unter LayoutMirroring.

Elementebenen

Ein Element wird normalerweise direkt in das Fenster gerendert, zu dem es gehört. Durch Setzen von ` layer.enabled` ist es jedoch möglich, das Element und seinen gesamten Unterbaum an eine Offscreen-Oberfläche zu delegieren. Nur die Offscreen-Oberfläche, eine Textur, wird dann in das Fenster gezeichnet.

Sollte eine von der des Elements abweichende Texturgröße gewünscht sein, ist dies mithilfe von ` layer.textureSize` möglich. Um nur einen Ausschnitt des Elements in die Textur zu rendern, verwenden Sie ` layer.sourceRect`. Es ist auch möglich, ` layer.sourceRect ` so festzulegen, dass die Textur über die Grenzen des Elements hinausragt. In diesem Fall wird der äußere Rand mit transparenten Pixeln aufgefüllt.

Das Element verwendet lineare Interpolation für die Skalierung, wenn „ layer.smooth “ auf „ true “ gesetzt ist, und Mipmap für das Downsampling, wenn „ layer.mipmap “ auf „ true “ gesetzt ist. Mipmapping kann die visuelle Qualität von heruntergerechneten Elementen verbessern. Für das Mipmapping einzelner Bildelemente sollte „ Image::mipmap “ bevorzugt werden.

Ebenen-Deckkraft vs. Element-Deckkraft

Bei der Anwendung von „ opacity “ auf eine Elementhierarchie wird die Deckkraft auf jedes Element einzeln angewendet. Dies kann zu unerwünschten visuellen Ergebnissen führen, wenn die Deckkraft auf einen Teilbaum angewendet wird. Betrachten Sie das folgende Beispiel:

Opazität ohne Ebenen Item { id: nonLayered opacity: 0.5 width: 100 height: 100 Rectangle { width: 80; height: 80; border.width: 1 } Rectangle { x: 20; y: 20; width: 80; height: 80; border.width: 1 } }

Eine Ebene wird gerendert, wobei die Deckkraft des Stammelements den Wert 1 hat, und diese Deckkraft wird dann beim Zeichnen auf die Textur angewendet. Das bedeutet, dass ein Überblenden in einer großen Elementhierarchie von transparent zu undurchsichtig oder umgekehrt ohne die Überlappungsartefakte erfolgen kann, die beim normalen Alpha-Blending Element für Element auftreten. Hier ist dasselbe Beispiel mit aktivierter Ebenenstruktur:

Item {
    id: layered

    opacity: 0.5

    layer.enabled: true

    width: 100
    height: 100

    Rectangle { width: 80; height: 80; border.width: 1 }
    Rectangle { x: 20; y: 20; width: 80; height: 80; border.width: 1 }
}

Kombiniert mit ShaderEffects

Wenn „ layer.enabled “ auf „true“ gesetzt wird, wird das Element zu einem „ texture provider “, wodurch es möglich wird, das Element direkt als Textur zu verwenden, beispielsweise in Kombination mit dem Typ „ ShaderEffect “.

Mit „layer.effect“ lässt sich zur Laufzeit ein Effekt auf eine Ebene anwenden:

Item {
    id: layerRoot
    layer.enabled: true
    layer.effect: ShaderEffect {
        fragmentShader: "effect.frag.qsb"
    }
}

Weitere Informationen zur Verwendung von Effekten finden Sie unter „ ShaderEffect “.

Speicher und Leistung

Wenn die Ebene eines Elements aktiviert ist, reserviert der Szenengraph auf der GPU Speicherplatz in der Größe von ` width x height x 4`. In Konfigurationen mit begrenztem Speicher sollten große Ebenen mit Bedacht eingesetzt werden.

In der Welt von „ QPainter “ und „ QWidget “ ist es manchmal vorteilhaft, komplexe Inhalte in einer Pixmap, einem Bild oder einer Textur zwischenzuspeichern. Bei „ Qt Quick “ ist dies aufgrund der bereits vom Szenengraph-Renderer angewandten Techniken in den meisten Fällen nicht der Fall. Übermäßige Zeichenaufrufe werden bereits durch Batching reduziert, und ein Cache führt in den meisten Fällen dazu, dass mehr Pixel gemischt werden als im ursprünglichen Inhalt vorhanden sind. Der Mehraufwand für das Rendern auf einen Offscreen-Bereich und das Mischen beim Zeichnen der resultierenden Textur ist daher oft größer als der Aufwand, das Element und seine untergeordneten Elemente einfach normal zeichnen zu lassen.

Außerdem kann ein Element, das eine Ebene verwendet, beim Rendern nicht gebatcht werden. Das bedeutet, dass eine Szene mit vielen Elementen, die Ebenen verwenden, Leistungsprobleme verursachen kann.

Das Arbeiten mit Ebenen kann für visuelle Effekte praktisch und nützlich sein, sollte jedoch in den meisten Fällen nur für die Dauer des Effekts aktiviert und danach wieder deaktiviert werden.

Dokumentation der Eigenschaften

activeFocus : bool [read-only]

Diese schreibgeschützte Eigenschaft gibt an, ob das Element den aktiven Fokus hat.

Ist `activeFocus` auf `true` gesetzt, ist entweder dieses Element dasjenige, das derzeit Tastatureingaben empfängt, oder es handelt sich um einen ` FocusScope `-Vorgänger des Elements, das derzeit Tastatureingaben empfängt.

In der Regel wird „activeFocus“ erreicht, indem „ focus “ für ein Element und die umgebenden „ FocusScope “-Objekte gesetzt wird. Im folgenden Beispiel haben die Objekte „ input “ und „ focusScope “ den aktiven Fokus, während das oberste „Rectangle“-Objekt keinen Fokus hat.

import QtQuick 2.0

Rectangle {
    width: 100; height: 100

    FocusScope {
        id: focusScope
        focus: true

        TextInput {
            id: input
            focus: true
        }
    }
}

Siehe auch „ focus “ und „Keyboard Focus“ in „ Qt Quick “.

activeFocusOnTab : bool

Diese Eigenschaft gibt an, ob das Element Teil der Tab-Fokus-Kette sein soll. Standardmäßig ist diese Eigenschaft auf „ false “ gesetzt.

Die Tabulator-Fokus-Kette durchläuft Elemente, indem sie zunächst das übergeordnete Element und anschließend dessen untergeordnete Elemente in der Reihenfolge besucht, in der diese in der Eigenschaft „children“ aufgeführt sind. Durch Drücken der Tabulatortaste auf einem Element in der Tabulator-Fokus-Kette wird der Tastaturfokus auf das nächste Element in der Kette verschoben. Durch Drücken der Rücktaste (normalerweise Umschalt+Tab) wird der Fokus auf das vorherige Element verschoben.

Informationen zum Einrichten einer manuellen Tab-Fokus-Kette finden Sie unter KeyNavigation. Tab-Tastenereignisse, die von „Keys“ oder „ KeyNavigation “ verwendet werden, haben Vorrang vor dem Verhalten der Fokus-Kette; ignorieren Sie die Ereignisse in anderen Tastenbehandlungsroutinen, damit sich der Fokus weiterverfolgen lässt.

Siehe auch „ QStyleHints::tabFocusBehavior “ und „ focusPolicy “.

anchors group

Anhänger bieten eine Möglichkeit, ein Element zu positionieren, indem seine Beziehung zu anderen Elementen festgelegt wird.

Ränder gelten für die Anker „top“, „bottom“, „left“, „right“ und „fill“. Mit der Eigenschaft „ anchors.margins “ lassen sich alle verschiedenen Ränder auf einmal auf denselben Wert setzen. Eine zuvor festgelegte spezifische Randerweiterung wird dadurch nicht überschrieben; um eine explizit festgelegte Randerweiterung zu löschen, setzen Sie den Wert auf „ undefined “. Beachten Sie, dass Ränder ankerspezifisch sind und nicht angewendet werden, wenn ein Element keine Anker verwendet.

Versätze gelten für horizontale, vertikale und Basislinien-Anker.

Item {
    Image {
        id: pic
        // ...
    }
    Text {
        id: label
        anchors.horizontalCenter: pic.horizontalCenter
        anchors.top: pic.bottom
        anchors.topMargin: 5
        // ...
    }
}

Item {
    Image {
        id: pic
        // ...
    }
    Text {
        id: label
        anchors.left: pic.right
        anchors.leftMargin: 5
        // ...
    }
}

anchors.fill bietet eine bequeme Möglichkeit, einem Element die gleiche Geometrie wie einem anderen Element zuzuweisen, und entspricht der Verbindung aller vier Richtungsanker.

Um einen Ankerwert zu löschen, setzen Sie ihn auf „ undefined “.

anchors.alignWhenCentered (Standardwert „ true “) erzwingt, dass zentrierte Verankerungen auf ein ganzes Pixel ausgerichtet werden; wenn das zu zentrierende Element eine ungerade „ width “- oder „ height “-Angabe hat, wird das Element auf einem ganzen Pixel positioniert, anstatt auf einem halben Pixel platziert zu werden. Dies stellt sicher, dass das Element scharf gezeichnet wird. Es gibt Fälle, in denen dies nicht erwünscht ist; beispielsweise können beim Drehen des Elements Verwacklungen sichtbar werden, da die Mitte abgerundet ist.

Weitere Informationen finden Sie unter „Anker-Layouts“.

antialiasing : bool

Wird von visuellen Elementen verwendet, um zu entscheiden, ob für das Element Antialiasing angewendet werden soll oder nicht. In manchen Fällen benötigen Elemente mit Antialiasing mehr Speicherplatz und werden möglicherweise langsamer gerendert (weitere Informationen finden Sie unter „Antialiasing“ ).

Der Standardwert ist „false“, kann jedoch von abgeleiteten Elementen überschrieben werden.

baselineOffset : int

Legt die Position der Grundlinie des Elements in lokalen Koordinaten fest.

Die Grundlinie eines „ Text “-Elements ist die imaginäre Linie, auf der der Text steht. Steuerelemente, die Text enthalten, legen ihre Grundlinie in der Regel auf die Grundlinie ihres Textes fest.

Für Nicht-Text-Elemente wird ein Standard-Grundlinienversatz von 0 verwendet.

Die Eigenschaft „children“ enthält die Liste der visuellen untergeordneten Elemente dieses Elements. Die Eigenschaft „resources“ enthält nicht-visuelle Ressourcen, auf die Sie namentlich verweisen möchten.

Im Allgemeinen ist es nicht erforderlich, beim Hinzufügen von untergeordneten Elementen oder Ressourcen auf diese Eigenschaften Bezug zu nehmen, da die Standardeigenschaft „ data “ untergeordnete Objekte automatisch den Eigenschaften „ children “ und „ resources “ entsprechend zuweist. Weitere Informationen finden Sie in der Dokumentation zu „ data “.

childrenRect group

Diese schreibgeschützte Eigenschaft enthält die gesammelte Position und Größe der untergeordneten Elemente des Elements.

Diese Eigenschaft ist nützlich, wenn Sie auf die gesamte Geometrie der untergeordneten Elemente eines Elements zugreifen müssen, um die Größe des Elements korrekt anzupassen.

Die zurückgegebene Geometrie ist lokal für das Element. Beispiel:

Item {
    x: 50
    y: 100

    // prints: QRectF(-10, -20, 30, 40)
    Component.onCompleted: print(childrenRect)

    Item {
        x: -10
        y: -20
        width: 30
        height: 40
    }
}

clip : bool

Diese Eigenschaft gilt unabhängig davon, ob das Clipping aktiviert ist. Der Standardwert für das Clipping lautet „ false “.

Wenn das Clipping aktiviert ist, beschneidet ein Element sowohl seine eigene Darstellung als auch die Darstellung seiner untergeordneten Elemente auf sein Begrenzungsrechteck.

containmentMask : QObject*

Diese Eigenschaft enthält eine optionale Maske für das Element, die in der Methode „ contains()“ verwendet wird. Derzeit dient sie hauptsächlich dazu, festzustellen, ob ein „ pointer event “ im Element gelandet ist oder nicht.

Standardmäßig gibt die Methode ` contains() ` für jeden Punkt innerhalb der Begrenzungsbox des `Item` den Wert `true` zurück. ` containmentMask ` ermöglicht eine feinere Steuerung. Wenn beispielsweise eine benutzerdefinierte C++-Unterklasse von ` QQuickItem ` mit einer spezialisierten Methode ` contains()` als `containmentMask` verwendet wird:

Item { id: item; containmentMask: AnotherItem { id: anotherItem } }

würde die `contains`-Methodedes `item` nur dann ` true ` zurückgeben, wenn die Implementierung von` contains()` des `anotherItem`` true` zurückgibt.

Ein ` Shape ` kann als Maske verwendet werden, damit ein Item nur innerhalb eines nicht-rechteckigen Bereichs auf ` pointer events ` reagiert:

Rectangle { width: 90; height: 100 color: hoverHandler.hovered ? "wheat" : "lightgray" containmentMask: shape HoverHandler { id: hoverHandler } Shape { id: shape containsMode: Shape.FillContains ShapePath { fillColor: "lightsteelblue" startX: 10; startY: 20 PathArc { x: 10; y: 80 radiusX: 40; radiusY: 40 useLargeArc: true } PathLine { x: 10; y: 20 } } } }

Es ist auch möglich, die Methode `contains` in QML zu definieren. Um beispielsweise ein kreisförmiges Element zu erstellen, das nur auf Ereignisse innerhalb seiner tatsächlichen Grenzen reagiert:

Rectangle { id: circle width: 100; height: width radius: width / 2 color: tapHandler.pressed ? "tomato" : hoverHandler.hovered ? "darkgray" : "lightgray" TapHandler { id: tapHandler } HoverHandler { id: hoverHandler } containmentMask: QtObject { property alias radius: circle.radius function contains(point: point) : bool { return (Math.pow(point.x - radius, 2) + Math.pow(point.y - radius, 2)) < Math.pow(radius, 2) } } }

Siehe auch „Qt Quick -Beispiele – Formen“.

data : list<QtObject> [default]

Mit der Eigenschaft „data“ können Sie visuelle untergeordnete Elemente und Ressourcen in einem Element frei mischen. Wenn Sie der Datenliste ein visuelles Element zuweisen, wird dieses zu einem untergeordneten Element; wenn Sie einen anderen Objekttyp zuweisen, wird dieser als Ressource hinzugefügt.

Sie können also schreiben:

Item {
    Text {}
    Rectangle {}
    Timer {}
}

anstatt:

Item {
    children: [
        Text {},
        Rectangle {}
    ]
    resources: [
        Timer {}
    ]
}

Im Allgemeinen sollte es nicht notwendig sein, auf die Eigenschaft „ data “ zu verweisen, da es sich um die Standardeigenschaft für „Item“ handelt und somit alle untergeordneten Elemente automatisch dieser Eigenschaft zugewiesen werden.

enabled : bool

Diese Eigenschaft legt fest, ob das Element Maus- und Tastaturereignisse empfängt. Standardmäßig ist hier „ true “ eingestellt.

Wenn die Eigenschaft auf ` false` gesetzt ist, empfängt das Element keine Tastatur- oder Zeigegeräte-Ereignisse wie „Drücken“, „Loslassen“ oder „Klicken“, kann jedoch weiterhin Hover-Ereignisse empfangen.

Die Einstellung dieser Eigenschaft wirkt sich direkt auf den Wert von „ enabled “ der untergeordneten Elemente aus. Bei der Einstellung auf „ false “ werden die „ enabled “-Werte aller untergeordneten Elemente ebenfalls auf „ false “ gesetzt. Bei der Einstellung auf „ true “ werden die „ enabled “-Werte der untergeordneten Elemente auf „ true “ zurückgesetzt, sofern sie nicht explizit auf „ false “ gesetzt wurden.

Wird diese Eigenschaft auf „ false “ gesetzt, wird „ activeFocus “ automatisch auf „ false “ gesetzt, und dieses Element empfängt keine Tastaturereignisse mehr.

Siehe auch „ visible “.

focus : bool

Diese Eigenschaft legt fest, ob das Element innerhalb des umgebenden FocusScope den Fokus erhält. Ist der Wert „true“, erhält dieses Element den aktiven Fokus, sobald das umgebende FocusScope den aktiven Fokus erhält.

Im folgenden Beispiel erhält „ input “ den aktiven Fokus, sobald „ scope “ den aktiven Fokus erhält:

import QtQuick 2.0

Rectangle {
    width: 100; height: 100

    FocusScope {
        id: scope

        TextInput {
            id: input
            focus: true
        }
    }
}

Für die Zwecke dieser Eigenschaft wird davon ausgegangen, dass die Szene als Ganzes wie ein Fokusbereich fungiert. In der Praxis bedeutet dies, dass der folgende QML-Code „ input “ beim Start den aktiven Fokus zuweist.

Rectangle {
    width: 100; height: 100

    TextInput {
          id: input
          focus: true
    }
}

Siehe auch „ activeFocus “ und „Keyboard Focus“ unter Qt Quick.

focusPolicy : enumeration [since 6.7]

Diese Eigenschaft legt fest, wie das Element den Fokus annimmt.

Diese Eigenschaft wurde in Qt 6.7 eingeführt.

Legt die Position und Größe des Elements fest. Der Standardwert ist 0.

Die (x,y)-Position bezieht sich relativ auf „ parent “.

Item { x: 100; y: 100; width: 100; height: 100 }

Legt die bevorzugte Breite oder Höhe des Elements fest.

Wenn „ width “ oder „ height “ nicht angegeben ist, wird die effektive Größe eines Elements durch „ implicitWidth “ oder „ implicitHeight “ bestimmt.

Ist ein Element jedoch ein untergeordnetes Element eines Layouts, bestimmt das Layout die bevorzugte Größe des Elements anhand seiner impliziten Größe. In einem solchen Fall werden die expliziten Werte für „ width “ oder „ height “ ignoriert.

Die standardmäßige implizite Größe für die meisten Elemente beträgt 0x0, einige Elemente verfügen jedoch über eine inhärente implizite Größe, die nicht überschrieben werden kann, beispielsweise Image und Text.

Die Festlegung der impliziten Größe ist nützlich, um Komponenten zu definieren, die je nach Inhalt eine bevorzugte Größe haben, zum Beispiel:

// Label.qml
import QtQuick 2.0

Item {
    property alias icon: image.source
    property alias label: text.text
    implicitWidth: text.implicitWidth + image.implicitWidth
    implicitHeight: Math.max(text.implicitHeight, image.implicitHeight)
    Image { id: image }
    Text {
        id: text
        wrapMode: Text.Wrap
        anchors.left: image.right; anchors.right: parent.right
        anchors.verticalCenter: parent.verticalCenter
    }
}

layer.effect : Component

Enthält den Effekt, der auf diese Ebene angewendet wird.

Bei dem Effekt handelt es sich in der Regel um eine „ ShaderEffect “-Komponente, es kann jedoch jede beliebige „ Item “-Komponente zugewiesen werden. Der Effekt sollte über eine Eigenschaft „source texture“ verfügen, deren Name mit „ layer.samplerName “ übereinstimmt.

Siehe auch „ layer.samplerName “ und „ Item Layers “.

layer.enabled : bool

Gibt an, ob das Element in Ebenen angeordnet ist oder nicht. Die Ebenenanzeige ist standardmäßig deaktiviert.

Ein Element mit Ebenen wird auf einer Offscreen-Oberfläche gerendert und zwischengespeichert, bis es geändert wird. Das Aktivieren der Ebenen für komplexe QML-Elementhierarchien kann manchmal eine Optimierung darstellen.

Keine der anderen Layer-Eigenschaften hat eine Auswirkung, wenn der Layer deaktiviert ist.

Siehe auch „ Item Layers “.

layer.format : enumeration

Diese Eigenschaft legt das Format der Hintergrundtextur fest. Eine Änderung dieser Eigenschaft ist vor allem dann sinnvoll, wenn auch die „ layer.effect “ angegeben ist.

Siehe auch Item Layers.

layer.live : bool [since 6.5]

Wenn diese Eigenschaft auf „true“ gesetzt ist, wird die Ebene-Textur bei jeder Aktualisierung des Elements aktualisiert. Andernfalls handelt es sich stets um ein festes Bild.

Standardmäßig ist diese Eigenschaft auf „ true “ gesetzt.

Diese Eigenschaft wurde in Qt 6.5 eingeführt.

Siehe auch „ Item Layers “.

layer.mipmap : bool

Wenn diese Eigenschaft auf „true“ gesetzt ist, werden für die Textur Mipmaps generiert.

Siehe auch Item Layers.

layer.samplerName : string

Enthält den Namen der Quelltextur-Eigenschaft des Effekts.

Dieser Wert muss mit dem Namen der Quelltextur-Eigenschaft des Effekts übereinstimmen, damit das Element die Offscreen-Oberfläche der Ebene korrekt an den Effekt übergeben kann.

Siehe auch layer.effect, ShaderEffect und Item Layers.

layer.samples : enumeration

Diese Eigenschaft ermöglicht die Anforderung einer Multisampling-Darstellung in der Ebene.

Standardmäßig ist Multisampling immer dann aktiviert, wenn es für das gesamte Fenster aktiviert ist, vorausgesetzt, der verwendete Szenengraph-Renderer und die zugrunde liegende Grafik-API unterstützen dies.

Durch Setzen des Werts auf 2, 4 usw. kann Multisampling-Rendering für einen Teil der Szene angefordert werden, ohne Multisampling für die gesamte Szene zu aktivieren. Auf diese Weise wird Multisampling nur auf einen bestimmten Teilbaum angewendet, was zu erheblichen Leistungssteigerungen führen kann, da Multisampling nicht auf andere Teile der Szene angewendet wird.

layer.smooth : bool

Gibt an, ob die Ebene glatt transformiert wird. Bei aktivierter Option erfolgt das Abtasten der Textur der Ebene mittels „ linear “-Interpolation, während bei deaktivierter Option der Filtermodus „ nearest “ verwendet wird.

Standardmäßig ist diese Eigenschaft auf „ false “ gesetzt.

Siehe auch „ Item Layers “.

layer.sourceRect : rect

Diese Eigenschaft definiert den rechteckigen Bereich des Elements, der in die Textur gerendert werden soll. Das Quellrechteck kann größer sein als das Element selbst. Ist das Rechteck null (was die Standardeinstellung ist), wird das gesamte Element in die Textur gerendert.

Siehe auch „ Item Layers “.

layer.textureMirroring : enumeration

Diese Eigenschaft legt fest, wie die generierte Textur gespiegelt werden soll. Der Standardwert ist „ ShaderEffectSource.MirrorVertically “. Eine benutzerdefinierte Spiegelung kann nützlich sein, wenn auf die generierte Textur direkt von benutzerdefinierten Shadern zugegriffen wird, wie beispielsweise den unter ShaderEffect angegebenen. Wenn für das Element in der Ebene kein Effekt angegeben ist, hat die Spiegelung keine Auswirkung auf die Darstellung des Elements in der Benutzeroberfläche.

layer.textureSize : size

Diese Eigenschaft enthält die angeforderte Pixelgröße der Textur der Ebenen. Ist sie leer (was die Standardeinstellung ist), wird die Größe des Elements verwendet.

Siehe auch „ Item Layers “.

layer.wrapMode : enumeration

Diese Eigenschaft definiert die mit der Textur verbundenen Umbruchmodi. Eine Änderung dieser Eigenschaft ist vor allem dann sinnvoll, wenn die Option „ layer.effect “ (Textur um die Kanten wickeln) aktiviert ist.

Siehe auch Item Layers.

mutabilityGroup : int [since 6.12]

Dies ist eine erweiterte Eigenschaft, die für Optimierungen auf niedriger Ebene verwendet werden kann. Sie dient dem Renderer als Hinweis darauf, wie oft ein Element aktualisiert wird. In typischen Anwendungsfällen reicht es aus, diese Eigenschaft auf ihrem Standardwert zu belassen (Item.AutoMutabilityGroup (0)).

In bestimmten Fällen kann eine Leistungsanalyse jedoch Engpässe aufdecken, die das Standardverhalten des „ Qt Quick “-Scenegraph-Renderers nicht optimieren konnte. Typischerweise kann dies passieren, wenn sich schnell aktualisierende Geometrie zusammen mit statischer Geometrie gebündelt wird. Um dies zu vermeiden, können Sie beispielsweise versuchen, die sich schnell aktualisierenden Komponenten der `Item.DynamicMutabilityGroup` zuzuweisen. Geometrie aus verschiedenen Mutabilitätsgruppen wird nicht zusammen gebündelt.

Die Mutabilitätsgruppe gilt nur für das Element selbst. Sie wird nicht auf untergeordnete Elemente übertragen.

Weitere Informationen zur Funktionsweise des „ Qt Quick “-Szenengraph-Renderers und zum Batching von Geometrie finden Sie unter „Qt Quick Scene Graph Default Renderer “.

Vordefinierte Werte:

Diese Eigenschaft wurde in Qt 6.12 eingeführt.

opacity : real

Diese Eigenschaft gibt die Deckkraft des Elements an. Die Deckkraft wird als Zahl zwischen 0,0 (vollständig transparent) und 1,0 (vollständig undurchsichtig) angegeben. Der Standardwert ist 1,0.

Wenn diese Eigenschaft festgelegt wird, wird die angegebene Deckkraft auch individuell auf untergeordnete Elemente angewendet. Dies kann unter bestimmten Umständen zu unbeabsichtigten Effekten führen. Beispielsweise wurde im zweiten Satz von Rechtecken unten für das rote Rechteck eine Deckkraft von 0,5 festgelegt, was sich auf die Deckkraft seines blauen untergeordneten Rechtecks auswirkt, obwohl für dieses untergeordnete Element keine Deckkraft festgelegt wurde.

Item {
    Rectangle {
        color: "red"
        width: 100; height: 100
        Rectangle {
            color: "blue"
            x: 50; y: 50; width: 100; height: 100
        }
    }
}

Item {
    Rectangle {
        opacity: 0.5
        color: "red"
        width: 100; height: 100
        Rectangle {
            color: "blue"
            x: 50; y: 50; width: 100; height: 100
        }
    }
}

Das Ändern der Deckkraft eines Elements hat keinen Einfluss darauf, ob das Element Benutzereingabeereignisse empfängt. (Im Gegensatz dazu stoppt die Einstellung der Eigenschaft „ visible “ auf „ false “ Mausereignisse, und die Einstellung der Eigenschaft „ enabled “ auf „ false “ stoppt Maus- und Tastaturereignisse und entfernt zudem den aktiven Fokus vom Element.)

Siehe auch „ visible “.

palette : Palette [since 6.0]

Diese Eigenschaft enthält die derzeit für das Element festgelegte Palette.

Diese Eigenschaft beschreibt die angeforderte Palette des Elements. Die Palette wird vom Stil des Elements beim Rendern aller Steuerelemente verwendet und dient dazu, sicherzustellen, dass benutzerdefinierte Steuerelemente mit dem nativen Look-and-Feel der jeweiligen Plattform konsistent bleiben. Es ist üblich, dass verschiedene Plattformen oder verschiedene Stile unterschiedliche Paletten für eine Anwendung definieren.

Die Standardpalette hängt von der Systemumgebung ab. ` ApplicationWindow ` verwaltet eine System-/Themenpalette, die als Standard für alle Steuerelemente dient. Für bestimmte Arten von Steuerelementen kann es zudem spezielle Standardpaletten geben. Sie können die Standardpalette für Steuerelemente auch auf folgende Weise festlegen:

• eine benutzerdefinierte Palette an ` QGuiApplication::setPalette()` übergeben, bevor QML geladen wird; oder
• die Farben in der Datei `qtquickcontrols2.conf` festlegen.

Elemente geben explizite Paletteneigenschaften von übergeordneten Elementen an untergeordnete Elemente weiter. Wenn Sie eine bestimmte Eigenschaft in der Palette eines Elements ändern, wird diese Eigenschaft an alle untergeordneten Elemente des Elements weitergegeben und überschreibt dabei alle Systemstandardwerte für diese Eigenschaft.

Item {
    palette {
        buttonText: "maroon"
        button: "lavender"
    }

    Button {
        text: "Click Me"
    }
}

Diese Eigenschaft wurde in Qt 6.0 eingeführt.

Siehe auch Window::palette, Popup::palette, ColorGroup, Palette und SystemPalette.

parent : Item

Diese Eigenschaft enthält das visuelle übergeordnete Element des Objekts.

rotation : real

Diese Eigenschaft gibt die Drehung des Elements in Grad im Uhrzeigersinn um seine Achse „ transformOrigin “ an.

Der Standardwert beträgt 0 Grad (d. h. keine Drehung).

Rectangle {
    color: "blue"
    width: 100; height: 100
    Rectangle {
        color: "red"
        x: 25; y: 25; width: 50; height: 50
        rotation: 30
    }
}

Siehe auch „ Transform “ und „ Rotation “.

scale : real

Diese Eigenschaft enthält den Skalierungsfaktor für dieses Element.

Ein Skalierungsfaktor kleiner als 1,0 bewirkt, dass das Element in einer kleineren Größe dargestellt wird, während ein Skalierungsfaktor größer als 1,0 das Element in einer größeren Größe darstellt. Ein negativer Skalierungsfaktor bewirkt, dass das Element bei der Darstellung gespiegelt wird.

Der Standardwert ist 1,0.

Die Skalierung wird über die Eigenschaft „ transformOrigin “ angewendet.

import QtQuick 2.0

Rectangle {
    color: "blue"
    width: 100; height: 100

    Rectangle {
        color: "green"
        width: 25; height: 25
    }

    Rectangle {
        color: "red"
        x: 25; y: 25; width: 50; height: 50
        scale: 1.4
        transformOrigin: Item.TopLeft
    }
}

Siehe auch „ Transform “ und „ Scale “.

smooth : bool

Wird in erster Linie bei bildbasierten Elementen verwendet, um festzulegen, ob für das Element eine glatte Abtastung verwendet werden soll oder nicht. Die glatte Abtastung erfolgt mittels linearer Interpolation, während die nicht-glatte Abtastung mittels „Nearest Neighbor“ durchgeführt wird.

In „ Qt Quick “ 2.0 hat diese Eigenschaft nur minimale Auswirkungen auf die Leistung.

Standardmäßig ist diese Eigenschaft auf „ true “ gesetzt.

state : string

Diese Eigenschaft enthält den Namen des aktuellen Zustands des Elements.

Befindet sich das Element in seinem Standardzustand, d. h., es wurde kein expliziter Zustand festgelegt, enthält diese Eigenschaft eine leere Zeichenkette. Ebenso können Sie ein Element in seinen Standardzustand zurückversetzen, indem Sie diese Eigenschaft auf eine leere Zeichenkette setzen.

Siehe auch „Qt Quick -Zustände“.

states : list<State>

Diese Eigenschaft enthält die Liste der möglichen Zustände für dieses Element. Um den Zustand dieses Elements zu ändern, setzen Sie die Eigenschaft „ state “ auf einen dieser Zustände, oder setzen Sie die Eigenschaft „ state “ auf eine leere Zeichenkette, um das Element in seinen Standardzustand zurückzusetzen.

Diese Eigenschaft wird als Liste von „ State “-Objekten angegeben. Nachfolgend finden Sie beispielsweise ein Element mit den Zuständen „red_color“ und „blue_color“:

import QtQuick 2.0

Rectangle {
    id: root
    width: 100; height: 100

    states: [
        State {
            name: "red_color"
            PropertyChanges { root.color: "red" }
        },
        State {
            name: "blue_color"
            PropertyChanges { root.color: "blue" }
        }
    ]
}

Weitere Informationen zur Verwendung von Zuständen und Übergängen finden Sie unter „Qt Quick -Zustände “ sowie „Animationen und Übergänge“ in „ Qt Quick “.

Siehe auch „ transitions “.

transform : list<Transform> [read-only]

Diese Eigenschaft enthält die Liste der anzuwendenden Transformationen.

Diese Eigenschaft wird als Liste von Objekten angegeben, die von „ Transform “ abgeleitet sind. Beispiel:

import QtQuick

Image {
    source: "images/qt-logo.png"
    transform: [
        Scale { origin.x: 25; origin.y: 25; xScale: 1.25 },
        Rotation { origin.x: 45; origin.y: 55; angle: 45 }
    ]
}

Weitere Informationen finden Sie unter Transform.

transformOrigin : enumeration

Diese Eigenschaft legt den Ursprungspunkt fest, um den sich Skalierung und Drehung ausrichten.

Es stehen neun Transformationsursprungspunkte zur Verfügung, wie in der Abbildung unten dargestellt. Der Standard-Transformationsursprungspunkt ist „ Item.Center “.

In diesem Beispiel wird ein Bild um seine rechte untere Ecke gedreht.

Image {
    source: "myimage.png"
    transformOrigin: Item.BottomRight
    rotation: 45
}

Um einen beliebigen Transformationsursprung festzulegen, verwenden Sie die Transformationstypen „ Scale “ oder „ Rotation “ mit der Eigenschaft „ transform “.

transitions : list<Transition>

Diese Eigenschaft enthält die Liste der Übergänge für dieses Element. Diese definieren die Übergänge, die auf das Element angewendet werden sollen, sobald sich dessen „ state “ ändert.

Diese Eigenschaft wird als Liste von „ Transition “-Objekten angegeben. Beispiel:

import QtQuick 2.0

Item {
    transitions: [
        Transition {
            //...
        },
        Transition {
            //...
        }
    ]
}

Weitere Informationen zur Verwendung von Zuständen und Übergängen finden Sie unter „Qt Quick -Zustände“ sowie „Animation und Übergänge“ unter Qt Quick.

Siehe auch „ states “.

visible : bool

Diese Eigenschaft gibt an, ob das Element sichtbar ist. Standardmäßig ist der Wert „true“.

Das Setzen dieser Eigenschaft wirkt sich direkt auf den Wert von „ visible “ der untergeordneten Elemente aus. Bei der Einstellung „ false “ werden die „ visible “-Werte aller untergeordneten Elemente ebenfalls auf „ false “ gesetzt. Bei der Einstellung „ true “ werden die „ visible “-Werte der untergeordneten Elemente auf „ true “ zurückgesetzt, sofern sie nicht explizit auf „ false “ gesetzt wurden.

(Aufgrund dieses Folgeverhaltens hat die Verwendung der Eigenschaft „ visible “ möglicherweise nicht den beabsichtigten Effekt, wenn eine Eigenschaftsbindung nur auf explizite Eigenschaftsänderungen reagieren soll. In solchen Fällen ist es möglicherweise besser, stattdessen die Eigenschaft „ opacity “ zu verwenden.)

Wird diese Eigenschaft auf „ false “ gesetzt, empfängt das Element keine Mausereignisse mehr, empfängt jedoch weiterhin Tastaturereignisse und behält die Tastatur-„ focus “ bei, sofern diese festgelegt wurde. (Im Gegensatz dazu werden durch das Setzen der Eigenschaft „ enabled “ auf „ false “ sowohl Maus- als auch Tastaturereignisse unterbunden und zudem der Fokus vom Element entfernt.)

Siehe auch „ opacity “ und „ enabled “.

visibleChildren : list<Item>

Diese schreibgeschützte Eigenschaft listet alle derzeit sichtbaren untergeordneten Elemente des Elements auf. Beachten Sie, dass sich die Sichtbarkeit eines untergeordneten Elements explizit geändert haben kann oder weil sich die Sichtbarkeit dieses Elements (seines übergeordneten Elements) oder eines weiteren übergeordneten Elements geändert hat.

z : real

Legt die Stapelreihenfolge von gleichrangigen Elementen fest. Standardmäßig beträgt die Stapelreihenfolge 0.

Elemente mit einem höheren Stapelwert werden über gleichrangige Elemente mit einer niedrigeren Stapelreihenfolge gezeichnet. Elemente mit demselben Stapelwert werden von unten nach oben in der Reihenfolge ihrer Darstellung gezeichnet. Elemente mit einem negativen Stapelwert werden unter dem Inhalt ihres übergeordneten Elements gezeichnet.

Das folgende Beispiel veranschaulicht die verschiedenen Effekte der Stapelreihenfolge.

Item {
    Rectangle {
        color: "red"
        width: 100; height: 100
    }
    Rectangle {
        color: "blue"
        x: 50; y: 50; width: 100; height: 100
    }
}

Item {
    Rectangle {
        z: 1
        color: "red"
        width: 100; height: 100
    }
    Rectangle {
        color: "blue"
        x: 50; y: 50; width: 100; height: 100
    }
}

Item {
    Rectangle {
        color: "red"
        width: 100; height: 100
        Rectangle {
            color: "blue"
            x: 50; y: 50; width: 100; height: 100
        }
    }
}

Item {
    Rectangle {
        color: "red"
        width: 100; height: 100
        Rectangle {
            z: -1
            color: "blue"
            x: 50; y: 50; width: 100; height: 100
        }
    }
}

Methodendokumentation

Item childAt(real x, real y)

Gibt das erste sichtbare untergeordnete Element zurück, das an der Position (x, y) innerhalb des Koordinatensystems dieses Elements gefunden wird.

Gibt „ null “ zurück, wenn kein solches Element vorhanden ist.

bool contains(point point)

Gibt „ true “ zurück, wenn dieses Element „ point “ enthält, das in lokalen Koordinaten angegeben ist; andernfalls wird „ false “ zurückgegeben. Dies ist dieselbe Prüfung, die beim Hit-Testing eines „ QEventPoint “ während der Ereignisübermittlung verwendet wird, und wird von „ containmentMask “ beeinflusst, sofern diese Option gesetzt ist.

[since 6.3] void dumpItemTree()

Gibt rekursiv einige Details zum visuellen Baum der Elemente aus, beginnend mit diesem Element und seinen untergeordneten Elementen.

Die Ausgabe sieht ähnlich aus wie bei diesem QML-Code:

function dump(object, indent) {
    console.log(indent + object)
    for (const i in object.children)
        dump(object.children[i], indent + "    ")
}

dump(myItem, "")

Wenn Sie also weitere Details wünschen, können Sie eine eigene Funktion implementieren und zusätzliche Ausgaben in `console.log` einfügen, beispielsweise die Werte bestimmter Eigenschaften.

Diese Methode wurde in Qt 6.3 eingeführt.

Siehe auch ` QObject::dumpObjectTree()`.

void forceActiveFocus()

Setzt den Fokus aktiv auf das Element.

Diese Methode setzt den Fokus auf das Element und stellt sicher, dass alle übergeordneten „ FocusScope “-Objekte in der Objekthierarchie ebenfalls den Status „ focus “ erhalten.

Der Grund für die Fokusänderung ist „ Qt::OtherFocusReason “. Verwenden Sie die überladene Methode, um den Fokusgrund anzugeben und so eine bessere Handhabung der Fokusänderung zu ermöglichen.

Siehe auch „ activeFocus “.

void forceActiveFocus(Qt::FocusReason reason)

Setzt den aktiven Fokus auf das Element mit der angegebenen reason.

Diese Methode setzt den Fokus auf das Element und stellt sicher, dass alle übergeordneten Objekte vom Typ „ FocusScope “ in der Objekthierarchie ebenfalls den Status „ focus “ erhalten.

Siehe auch „ activeFocus “ und „ Qt::FocusReason “.

bool grabToImage(callback, targetSize)

Lädt das Element in ein Speicherabbild.

Das Laden erfolgt asynchron, und die JavaScript-Funktion „ callback “ wird aufgerufen, sobald der Ladevorgang abgeschlossen ist. Der Callback-Aufruf erwartet ein Argument, nämlich das Ergebnis des Ladevorgangs: ein „ ItemGrabResult “-Objekt.

Verwenden Sie ` targetSize `, um die Größe des Zielbildes festzulegen. Standardmäßig hat das Ergebnis dieselbe Größe wie das Element.

Wenn der Screenshot nicht gestartet werden konnte, gibt die Funktion ` false` zurück.

Der folgende Codeausschnitt zeigt, wie man ein Element erfasst und die Ergebnisse in einer Datei speichert:

Rectangle {
    id: sourceRectangle
    width: 100
    height: 100
    focus: true
    gradient: Gradient {
        GradientStop { position: 0; color: "steelblue" }
        GradientStop { position: 1; color: "black" }
    }

    Keys.onSpacePressed: {
        sourceRectangle.grabToImage(function(result) {
           result.saveToFile("something.png")
        })
    }
}

Der folgende Codeausschnitt zeigt, wie man ein Element erfasst und die Ergebnisse in einem anderen Bildelement verwendet:

Image {
    id: image
}

Keys.onSpacePressed: {
    sourceRectangle.grabToImage(function(result) {
        image.source = result.url
    }, Qt.size(50, 50))
}

point mapFromGlobal(real x, real y)

Ordnet den Punkt (x, y), der sich im globalen Koordinatensystem befindet, dem Koordinatensystem des Elements zu und gibt eine „ point “ zurück, die der zugeordneten Koordinate entspricht.

Die folgenden Eigenschaften des Objekts werden bei der Abbildung verwendet: ` x`, ` y`, ` scale`, ` rotation`, ` transformOrigin` und ` transform`.

Wenn die Elemente Teil verschiedener Szenen sind, umfasst die Zuordnung die relative Position der beiden Szenen.

Ordnet den Punkt (x, y) oder das Rechteck (x, y, width, height), der bzw. das sich im Koordinatensystem von item befindet, dem Koordinatensystem dieses Elements zu und gibt einen point oder rect zurück, der bzw. die der zugeordneten Koordinate entspricht.

Die folgenden Eigenschaften des Elements werden bei der Zuordnung verwendet: x, y, scale, rotation, transformOrigin und transform.

Wenn die Elemente Teil verschiedener Szenen sind, umfasst die Zuordnung die relative Position der beiden Szenen.

Ist „ item “ ein Wert vom Typ „ null “, wird der Punkt oder das Rechteck aus dem Koordinatensystem der Szene abgebildet.

Die Versionen, die „point“ und „rect“ akzeptieren, sind ab Qt 5.15 verfügbar.

point mapToGlobal(real x, real y)

Ordnet den Punkt (x, y), der sich im Koordinatensystem dieses Elements befindet, dem globalen Koordinatensystem zu und gibt eine „ point “ zurück, die der zugeordneten Koordinate entspricht.

Die folgenden Eigenschaften des Elements werden bei der Abbildung verwendet: „ x “, „ y “, „ scale “, „ rotation “, „ transformOrigin “ und „ transform “.

Wenn die Elemente Teil verschiedener Szenen sind, umfasst die Zuordnung die relative Position der beiden Szenen.

Ordnet den Punkt (x, y) oder das Rechteck (x, y, width, height), der bzw. das sich im Koordinatensystem dieses Elements befindet, dem Koordinatensystem von item zu und gibt ein „ point “ oder „ rect “ zurück, das der zugeordneten Koordinate entspricht.

Die folgenden Eigenschaften des Elements werden bei der Zuordnung verwendet: x, y, scale, rotation, transformOrigin und transform.

Wenn die Elemente Teil verschiedener Szenen sind, umfasst die Zuordnung die relative Position der beiden Szenen.

Ist „ item “ ein Wert vom Typ „ null “, wird der Punkt oder das Rechteck auf das Koordinatensystem der Szene abgebildet.

Die Versionen, die „point“ und „rect“ akzeptieren, sind ab Qt 5.15 verfügbar.

Item nextItemInFocusChain(bool forward)

Gibt das Element in der Fokus-Kette zurück, das diesem Element folgt. Wenn „ forward “ auf „ true “ gesetzt ist oder nicht angegeben wird, handelt es sich um das nächste Element in Vorwärtsrichtung. Wenn „ forward “ auf „ false “ gesetzt ist, handelt es sich um das nächste Element in Rückwärtsrichtung.