ListView QML Type

Bietet eine Listenansicht der von einem Modell bereitgestellten Elemente. Mehr...

• Liste aller Elemente, einschließlich geerbter Elemente

Eigenschaften

• add : Transition
• addDisplaced : Transition
• cacheBuffer : int
• count : int
• currentIndex : int
• currentItem : Item
• currentSection : string
• delegate : Component
• delegateModelAccess : enumeration (since 6.10)
• displaced : Transition
• displayMarginBeginning : int (since QtQuick 2.3)
• displayMarginEnd : int (since QtQuick 2.3)
• effectiveLayoutDirection : enumeration
• footer : Component
• footerItem : Item
• footerPositioning : enumeration (since Qt 5.4)
• header : Component
• headerItem : Item
• headerPositioning : enumeration (since Qt 5.4)
• highlight : Component
• highlightFollowsCurrentItem : bool
• highlightItem : Item
• highlightMoveDuration : int
• highlightMoveVelocity : real
• highlightRangeMode : enumeration
• highlightResizeDuration : int
• highlightResizeVelocity : real
• keyNavigationEnabled : bool
• keyNavigationWraps : bool
• layoutDirection : enumeration
• model : model
• move : Transition
• moveDisplaced : Transition
• orientation : enumeration
• populate : Transition
• preferredHighlightBegin : real
• preferredHighlightEnd : real
• remove : Transition
• removeDisplaced : Transition
• reuseItems : bool
• section
  • section.criteria : enumeration
  • section.delegate : Component
  • section.labelPositioning : enumeration
  • section.property : string
• snapMode : enumeration
• spacing : real
• verticalLayoutDirection : enumeration

Zugehörige Eigenschaften

• delayRemove : bool
• isCurrentItem : bool
• nextSection : string
• previousSection : string
• section : string
• view : ListView

Angehängte Signale

• add()
• pooled()
• remove()
• reused()

Methoden

• void decrementCurrentIndex()
• void forceLayout()
• void incrementCurrentIndex()
• int indexAt(real x, real y)
• Item itemAt(real x, real y)
• Item itemAtIndex(int index)
• void positionViewAtBeginning()
• void positionViewAtEnd()
• void positionViewAtIndex(int index, PositionMode mode)

Ausführliche Beschreibung

Eine ListView zeigt Daten aus Modellen an, die aus integrierten QML-Typen wie „ ListModel “ und „ XmlListModel “ erstellt wurden oder aus benutzerdefinierten Modellklassen, die in C++ definiert sind und von „ QAbstractItemModel “ oder „ QAbstractListModel “ erben.

Eine ListView verfügt über ein „ model “, das die anzuzeigenden Daten definiert, und ein „ delegate “, das festlegt, wie die Daten dargestellt werden sollen. Die Elemente in einer ListView werden horizontal oder vertikal angeordnet. ListViews sind von Natur aus blätterbar, da ListView von „ Flickable “ erbt.

Anwendungsbeispiel

Das folgende Beispiel zeigt die Definition eines einfachen Listenmodells, das in einer Datei namens „ ContactModel.qml “ definiert ist:

import QtQuick

ListModel {
    ListElement {
        name: "Bill Smith"
        number: "555 3264"
    }
    ListElement {
        name: "John Brown"
        number: "555 8426"
    }
    ListElement {
        name: "Sam Wise"
        number: "555 0473"
    }
}

Eine andere Komponente kann diese Modelldaten wie folgt in einer ListView anzeigen:

import QtQuick

ListView {
    width: 180; height: 200

    model: ContactModel {}
    delegate: Text {
        required property string name
        required property string number
        text: name + ": " + number
    }
}

Hier erstellt die ListView eine „ ContactModel “-Komponente für ihr Modell und ein „ Text “-Element für ihren Delegaten. Die Ansicht erstellt für jedes Element im Modell eine neue „ Text “-Komponente. Beachten Sie, dass der Delegat direkt auf die Daten „ name “ und „ number “ des Modells zugreifen kann.

Nachfolgend wird eine verbesserte Listenansicht gezeigt. Der Delegat wurde optisch optimiert und in eine separate „ contactDelegate “-Komponente ausgelagert.

Rectangle {
    width: 180; height: 200

    Component {
        id: contactDelegate
        Item {
            id: myItem
            required property string name
            required property string number
            width: 180; height: 40
            Column {
                Text { text: '<b>Name:</b> ' + myItem.name }
                Text { text: '<b>Number:</b> ' + myItem.number }
            }
        }
    }

    ListView {
        anchors.fill: parent
        model: ContactModel {}
        delegate: contactDelegate
        highlight: Rectangle { color: "lightsteelblue"; radius: 5 }
        focus: true
    }
}

Das aktuell ausgewählte Element wird mithilfe der Eigenschaft „ highlight “ mit einem blauen „ Rectangle “ hervorgehoben, und „ focus “ wird auf „ true “ gesetzt, um die Tastaturnavigation für die Listenansicht zu ermöglichen. Die Listenansicht selbst ist ein Fokusbereich (weitere Details finden Sie unter „Tastaturfokus“ in „ Qt Quick “ ).

Delegaten werden nach Bedarf instanziiert und können jederzeit zerstört werden. Daher state should never be stored in a delegate. Delegaten sind in der Regel dem „ contentItem “ der ListView untergeordnet, doch je nachdem, ob sie in der Ansicht sichtbar sind oder nicht, kann sich das übergeordnete Element ändern und manchmal auch „ null “ sein. Aus diesem Grund wird davon abgeraten, innerhalb des Delegaten Bindungen an die Eigenschaften des übergeordneten Elements herzustellen. Wenn Sie möchten, dass der Delegat die gesamte Breite der ListView einnimmt, sollten Sie stattdessen einen der folgenden Ansätze in Betracht ziehen:

ListView {
    id: listView
    // ...

    delegate: Item {
        // Incorrect.
        width: parent.width

        // Correct.
        width: listView.width
        width: ListView.view.width
        // ...
    }
}

Die `ListView` fügt dem Stammelement des Delegaten eine Reihe von Eigenschaften hinzu, zum Beispiel ` ListView.isCurrentItem`. Im folgenden Beispiel kann das Stammelement des Delegaten direkt auf diese angefügte Eigenschaft als ` ListView.isCurrentItem` zugreifen, während das untergeordnete ` contactInfo `-Objekt auf diese Eigenschaft als ` wrapper.ListView.isCurrentItem` verweisen muss.

ListView {
    width: 180; height: 200

    Component {
        id: contactsDelegate
        Rectangle {
            id: wrapper
            width: 180
            height: contactInfo.height
            color: ListView.isCurrentItem ? "black" : "red"
            Text {
                id: contactInfo
                text: name + ": " + number
                color: wrapper.ListView.isCurrentItem ? "red" : "black"
            }
        }
    }

    model: ContactModel {}
    delegate: contactsDelegate
    focus: true
}

ListView-Layouts

Das Layout der Elemente in einer ListView lässt sich über folgende Eigenschaften steuern:

• orientation - Legt fest, ob Elemente horizontal oder vertikal angeordnet werden. Der Wert kann entweder Qt.Horizontal oder Qt.Vertical sein.
• layoutDirection - steuert die horizontale Ausrichtungsrichtung für eine horizontal ausgerichtete Ansicht: Das heißt, ob Elemente von der linken Seite der Ansicht nach rechts oder umgekehrt angeordnet werden. Dieser Wert kann entweder Qt.LeftToRight oder Qt.RightToLeft sein.
• verticalLayoutDirection - Steuert die vertikale Ausrichtungsrichtung für eine vertikal ausgerichtete Ansicht: Das heißt, ob die Elemente vom oberen Rand der Ansicht nach unten oder umgekehrt angeordnet werden. Dieser Wert kann entweder „ListView.TopToBottom“ oder „ListView.BottomToTop“ sein.

Standardmäßig ist eine ListView vertikal ausgerichtet, und die Elemente werden von oben nach unten angeordnet. Die folgende Tabelle zeigt die verschiedenen Layouts, die eine ListView je nach den Werten der oben aufgeführten Eigenschaften annehmen kann.

Flick-Richtung

Standardmäßig setzt eine vertikale ListView „ flickableDirection “ auf „Flickable.Vertical“ und eine horizontale ListView auf „Flickable.Horizontal“. Darüber hinaus berechnet (schätzt) eine vertikale ListView nur „ contentHeight “, während eine horizontale ListView nur „ contentWidth “ berechnet. Die jeweils andere Dimension wird auf -1 gesetzt.

Seit Qt 5.9 (Qt Quick 2.9) ist es möglich, eine ListView zu erstellen, die in beide Richtungen gewischt werden kann. Dazu kann die Eigenschaft „ flickableDirection “ auf „Flickable.AutoFlickDirection“ oder „Flickable.AutoFlickIfNeeded“ gesetzt werden, und die gewünschte „contentWidth“ oder „contentHeight“ muss angegeben werden.

ListView {
    width: 180; height: 200

    contentWidth: 320
    flickableDirection: Flickable.AutoFlickDirection

    model: ContactModel {}
    delegate: Row {
        Text { text: '<b>Name:</b> ' + name; width: 160 }
        Text { text: '<b>Number:</b> ' + number; width: 160 }
    }
}

Stapelreihenfolge in der ListView

Die „ Z value “ der Elemente bestimmt, ob sie über oder unter anderen Elementen dargestellt werden. Die ListView verwendet je nach Art des erstellten Elements verschiedene Standard-Z-Werte:

Diese Standardwerte werden festgelegt, wenn der Z-Wert des Elements „ 0 “ lautet; daher hat die Einstellung des Z-Werts dieser Elemente auf „ 0 “ keine Auswirkung. Beachten Sie, dass der Z-Wert vom Typ „ real “ ist, sodass es möglich ist, Bruchwerte wie „ 0.1 “ festzulegen.

Wiederverwendung von Elementen

Seit Version 5.15 kann ListView so konfiguriert werden, dass Elemente wiederverwendet werden, anstatt sie bei jedem Einblenden neuer Zeilen aus dem „ delegate “ neu zu instanziieren. Dieser Ansatz verbessert die Leistung, abhängig von der Komplexität des Delegaten. Die Wiederverwendung von Elementen ist standardmäßig deaktiviert (aus Gründen der Abwärtskompatibilität), kann jedoch durch Setzen der Eigenschaft „ reuseItems “ auf „ true “ aktiviert werden.

Wenn ein Element aus dem Bild gewischt wird, wird es in den Wiederverwendungspool verschoben, bei dem es sich um einen internen Cache für ungenutzte Elemente handelt. In diesem Fall wird das Signal „ ListView::pooled “ ausgelöst, um das Element darüber zu informieren. Ebenso wird das Signal „ ListView::reused “ ausgelöst, wenn das Element aus dem Pool zurückverschoben wird.

Alle aus dem Modell stammenden Element-Eigenschaften werden aktualisiert, wenn das Element wiederverwendet wird. Dazu gehören „ index “ und „ row “, aber auch alle Modellrollen.

Wenn ein Element Timer oder Animationen enthält, sollten Sie in Erwägung ziehen, diese beim Empfang des Signals „ ListView::pooled “ anzuhalten. Auf diese Weise vermeiden Sie den Verbrauch von CPU-Ressourcen für Elemente, die nicht sichtbar sind. Ebenso können Ressourcen, die nicht wiederverwendet werden können, freigegeben werden.

Das folgende Beispiel zeigt einen Delegaten, der ein sich drehendes Rechteck animiert. Wenn es in den Pool verschoben wird, wird die Animation vorübergehend angehalten:

Component {
    id: listViewDelegate
    Rectangle {
        width: 100
        height: 50

        ListView.onPooled: rotationAnimation.pause()
        ListView.onReused: rotationAnimation.resume()

        Rectangle {
            id: rect
            anchors.centerIn: parent
            width: 40
            height: 5
            color: "green"

            RotationAnimation {
                id: rotationAnimation
                target: rect
                duration: (Math.random() * 2000) + 200
                from: 0
                to: 359
                running: true
                loops: Animation.Infinite
            }
        }
    }
}

Variable Delegatgröße und Abschnittsbezeichnungen

Variable Delegatgrößen können dazu führen, dass angehängte ` ScrollBar` in der Größe angepasst oder übersprungen werden. Dies liegt daran, dass `ListView` die Größe seines Inhalts anhand der zugewiesenen Elemente schätzt (in der Regel nur die sichtbaren Elemente; bei den übrigen wird von einer ähnlichen Größe ausgegangen), und variable Delegatgrößen verhindern eine genaue Schätzung. Um diesen Effekt zu verringern, kann „ cacheBuffer “ auf höhere Werte gesetzt werden, wodurch effektiv mehr Elemente erstellt werden und die Größenschätzung nicht zugewiesener Elemente verbessert wird – allerdings auf Kosten eines höheren Speicherbedarfs. „ Sections “ haben denselben Effekt, da sie die Abschnittsbezeichnung an das erste Element innerhalb des Abschnitts anhängen und dieses verlängern.

Vermeiden Sie das Speichern von Zuständen in Delegaten

Die Delegaten von `ListView` werden bei Bedarf instanziiert und können zerstört werden, wenn sie nicht mehr im Sichtbereich sind. Um dies zu veranschaulichen, führen Sie das folgende Beispiel aus:

ListView {
    anchors.fill: parent
    model: 3
    delegate: CheckDelegate {
        text: qsTr("Channel %1").arg(index + 1)

        required property int index
        property bool channelActivated

        onClicked: channelActivated = checked
    }
}

Wenn auf ein Element geklickt wird, wird „ channelActivated “ auf „ true “ gesetzt. Da Delegaten jedoch „ reused “ sein und zerstört werden können, geht der gesamte Zustand verloren, wenn die Ansicht weit genug verschoben wird. Wenn der Delegat wieder sichtbar wird, hat er seinen standardmäßigen, unveränderten Zustand (oder, im Falle eines wiederverwendeten Elements, den alten Zustand eines vorherigen Elements).

Um dies zu vermeiden, sollte der Zustand im Modell gespeichert werden:

ListView {
    anchors.fill: parent
    model: ListModel {
        ListElement {
            channelActivated: true
        }
        // ...
    }
    delegate: CheckDelegate {
        text: qsTr("Channel %1").arg(index + 1)
        checked: model.channelActivated

        required property int index
        required property var model

        onClicked: model.channelActivated = checked
    }
}

Delegaten ausblenden

Wenn die Eigenschaft „ visible “ eines Delegaten auf „ false “ gesetzt wird, wird dieses Element ausgeblendet, der Platz, den es in der Ansicht eingenommen hat, bleibt jedoch erhalten. Es ist möglich, die Eigenschaft „ height “ des Elements auf „ 0 “ zu setzen (für eine „ vertical “-ListView):

ListView {
    anchors.fill: parent
    model: ListModel {
        ListElement { hidden: false }
        ListElement { hidden: false }
        ListElement { hidden: false }
        // ...
    }
    delegate: ItemDelegate {
        text: qsTr("Item %1").arg(index)
        visible: !model.hidden
        height: visible ? implicitHeight : 0

        required property int index
        required property var model

        onClicked: model.hidden = true
    }
}

Beachten Sie, dass der ausgeblendete Zustand gemäß den Empfehlungen im Abschnitt „ Avoid Storing State in Delegates “ im Modell gespeichert wird.

Wenn „ spacing “ jedoch ungleich Null ist, entstehen ungleichmäßige Lücken zwischen den Delegaten.

Eine bessere Option ist es, Ihr Modell so zu filtern, dass Elemente, die nicht sichtbar sein sollen, von der Ansicht gar nicht erst geladen werden. Dies lässt sich mit ` QSortFilterProxyModel` erreichen.

Eine weitere Möglichkeit besteht darin, den Delegaten mit ` disable ` zu filtern, anstatt ihn auszublenden.

Siehe auch „QML-Datenmodelle“, „ GridView “, „ PathView “ und „Qt Quick -Beispiele – Ansichten“.

Dokumentation zu Eigenschaften

add : Transition

Diese Eigenschaft legt fest, welcher Übergang auf Elemente angewendet werden soll, die der Ansicht hinzugefügt werden.

Hier ist beispielsweise eine Ansicht, die einen solchen Übergang festlegt:

ListView {
    ...
    add: Transition {
        NumberAnimation { properties: "x,y"; from: 100; duration: 1000 }
    }
}

Immer wenn ein Element zur obigen Ansicht hinzugefügt wird, wird das Element über einen Zeitraum von einer Sekunde von der Position (100,100) zu seiner endgültigen x- und y-Position innerhalb der Ansicht animiert. Der Übergang gilt nur für die neuen Elemente, die der Ansicht hinzugefügt werden; er gilt nicht für die darunter liegenden Elemente, die durch das Hinzufügen der neuen Elemente verschoben werden. Um die verschobenen Elemente zu animieren, legen Sie die Eigenschaften „ displaced “ oder „ addDisplaced “ fest.

Weitere Details und Beispiele zur Verwendung von Ansichtsübergängen finden Sie in der Dokumentation zu „ ViewTransition “.

Siehe auch „ addDisplaced “, „ populate “ und „ ViewTransition “.

addDisplaced : Transition

Diese Eigenschaft legt den Übergang fest, der auf Elemente innerhalb der Ansicht angewendet werden soll, die durch das Hinzufügen weiterer Elemente zur Ansicht verschoben werden.

Hier ist beispielsweise eine Ansicht, die einen solchen Übergang festlegt:

ListView {
    ...
    addDisplaced: Transition {
        NumberAnimation { properties: "x,y"; duration: 1000 }
    }
}

Immer wenn ein Element zur obigen Ansicht hinzugefügt wird, werden alle Elemente unterhalb des neuen Elements verschoben, wodurch sie sich innerhalb der Ansicht nach unten (oder seitwärts, falls horizontal ausgerichtet) bewegen. Während dieser Verschiebung wird die Bewegung der Elemente zu ihren neuen x-, y-Positionen innerhalb der Ansicht, wie angegeben, durch einen „ NumberAnimation “-Übergang über eine Sekunde hinweg animiert. Dieser Übergang wird nicht auf das neue Element angewendet, das der Ansicht hinzugefügt wurde; um die hinzugefügten Elemente zu animieren, setzen Sie die Eigenschaft „ add “.

Wird ein Element durch mehrere Arten von Operationen gleichzeitig verschoben, ist nicht festgelegt, ob der Übergang „addDisplaced“, „ moveDisplaced “ oder „ removeDisplaced “ angewendet wird. Wenn es zudem nicht erforderlich ist, je nachdem, ob ein Element durch eine Hinzufügungs-, Verschiebungs- oder Entfernungsoperation verschoben wird, unterschiedliche Übergänge festzulegen, sollten Sie stattdessen die Eigenschaft „ displaced “ setzen.

Weitere Details und Beispiele zur Verwendung von Ansichtsübergängen finden Sie in der Dokumentation zu „ ViewTransition “.

Siehe auch „ displaced“ , „ add “, „ populate “ und „ ViewTransition “.

cacheBuffer : int

Diese Eigenschaft legt fest, ob Delegaten außerhalb des sichtbaren Bereichs der Ansicht beibehalten werden.

Ist dieser Wert größer als Null, kann die Ansicht so viele Delegaten instanziiert halten, wie in den angegebenen Puffer passen. Wenn beispielsweise in einer vertikalen Ansicht der Delegat 20 Pixel hoch ist und „ cacheBuffer “ auf 40 gesetzt ist, können bis zu 2 Delegaten oberhalb und 2 Delegaten unterhalb des sichtbaren Bereichs erstellt bzw. beibehalten werden. Die gepufferten Delegaten werden asynchron erstellt, wodurch die Erstellung über mehrere Frames hinweg erfolgen kann und die Wahrscheinlichkeit von Frame-Übersprüngen verringert wird. Um die Darstellungsleistung zu verbessern, werden Delegaten außerhalb des sichtbaren Bereichs nicht dargestellt.

Der Standardwert dieser Eigenschaft ist plattformabhängig, beträgt jedoch in der Regel einen Wert größer als Null. Negative Werte werden ignoriert.

Beachten Sie, dass „cacheBuffer“ kein Pixelpuffer ist – er verwaltet lediglich zusätzlich instanziierte Delegaten.

Der `cacheBuffer` arbeitet außerhalb der durch ` displayMarginBeginning ` oder ` displayMarginEnd` festgelegten Anzeigeränder.

count : int [read-only]

Die Eigenschaft gibt die Anzahl der Elemente im Modell des „ ListView “ wieder, unabhängig davon, ob diese sichtbar sind oder als „ Item “ einer Delegate-Komponente instanziiert wurden.

Die Eigenschaft „ currentIndex “ enthält den Index des aktuellen Elements, und „ currentItem “ enthält das aktuelle Element. Wenn „ currentIndex “ auf -1 gesetzt wird, wird die Hervorhebung aufgehoben und „ currentItem “ auf null gesetzt.

Wenn „ highlightFollowsCurrentItem “ gleich „ true “ ist, bewirkt das Setzen einer dieser Eigenschaften ein sanftes Scrollen des „ ListView “, sodass das aktuelle Element sichtbar wird.

Beachten Sie, dass die Position des aktuellen Elements möglicherweise nur ungefähr ist, bis es in der Ansicht sichtbar wird.

Da „ currentItem “ mit jedem beliebigen Delegaten funktionieren muss, ist sein Typ „ Item “. Häufig wird eine „ ListView “ jedoch mit genau einem Delegatentyp verwendet. In diesem Fall kann das Umwandeln von „ currentItem “ in den Typ des Delegaten die Tool-Unterstützung verbessern und zu effizienterem Code führen:

component Message : Item {
    required property string sender
    required property string text
}
ListView {
    id: messageView
    delegate: Message {}
    model: messageModel
}
Button {
    text: "Reply to %1".arg((messageView.currentItem) as Message).sender
}

currentSection : string [read-only]

Diese Eigenschaft enthält den Abschnitt, der sich derzeit am Anfang der Ansicht befindet.

delegate : Component

Der Delegat stellt eine Vorlage bereit, die jedes von der Ansicht instanziierte Element definiert. Der Index wird als zugängliche Eigenschaft „ index “ bereitgestellt. Je nach Typ des Datenmodells stehen auch Eigenschaften des Modells zur Verfügung.

Die Anzahl der Objekte und Bindungen im Delegaten wirkt sich direkt auf die Flicking-Leistung der Ansicht aus. Platzieren Sie nach Möglichkeit Funktionen, die für die normale Darstellung des Delegaten nicht benötigt werden, in einem „ Loader “, der bei Bedarf zusätzliche Komponenten laden kann.

Der „ ListView “ ordnet die Elemente basierend auf der Größe des Stammelements im Delegaten an.

Es wird empfohlen, die Größe des Delegaten als ganze Zahl festzulegen, um eine Subpixel-Ausrichtung der Elemente zu vermeiden.

Der Standard- stacking order für Delegate-Instanzen ist 1.

Siehe auch Stacking Order in ListView.

delegateModelAccess : enumeration [since 6.10]

Diese Eigenschaft legt fest, wie Delegaten auf das Modell zugreifen können.

Die Standardeinstellung ist „ DelegateModel.Qt5ReadWrite “.

Diese Eigenschaft wurde in Qt 6.10 eingeführt.

Siehe auch „Modelle und Ansichten“ in „ Qt Quick “ unter „Ändern von Modelldaten“.

displaced : Transition

Diese Eigenschaft enthält den generischen Übergang, der auf Elemente angewendet werden soll, die durch eine beliebige Modelloperation, die sich auf die Ansicht auswirkt, verschoben wurden.

Dies ist eine Erleichterung bei der Angabe des generischen Übergangs, der auf alle Elemente angewendet werden soll, die durch eine Hinzufügungs-, Verschiebungs- oder Entfernungsoperation verschoben werden, ohne dass die einzelnen Eigenschaften „ addDisplaced “, „ moveDisplaced “ und „ removeDisplaced “ angegeben werden müssen. Hier ist beispielsweise eine Ansicht, die einen „displaced“-Übergang festlegt:

ListView {
    ...
    displaced: Transition {
        NumberAnimation { properties: "x,y"; duration: 1000 }
    }
}

Wenn innerhalb der obigen Ansicht ein Element hinzugefügt, verschoben oder entfernt wird, werden die darunter liegenden Elemente verschoben, wodurch sie sich innerhalb der Ansicht nach unten (oder seitlich, falls horizontal ausgerichtet) bewegen. Während dieser Verschiebung wird die Bewegung der Elemente zu ihren neuen x-, y-Positionen innerhalb der Ansicht, wie angegeben, durch eine „ NumberAnimation “-Animation über einen Zeitraum von einer Sekunde animiert.

Wenn eine Ansicht sowohl diesen generischen „displaced“-Übergang als auch einen spezifischen Übergang vom Typ „ addDisplaced “, „ moveDisplaced “ oder „ removeDisplaced “ festlegt, wird bei Auftreten der entsprechenden Operation der spezifischere Übergang anstelle des generischen „displaced“-Übergangs verwendet, vorausgesetzt, der spezifischere Übergang wurde nicht deaktiviert (durch Setzen von ` enabled ` auf `false`). Wurde er tatsächlich deaktiviert, wird stattdessen der generische „displaced“-Übergang angewendet.

Weitere Details und Beispiele zur Verwendung von Ansichtsübergängen finden Sie in der Dokumentation unter ViewTransition.

Siehe auch addDisplaced, moveDisplaced, removeDisplaced und ViewTransition.

Diese Eigenschaft ermöglicht es, Delegaten außerhalb der Ansichtsgeometrie anzuzeigen.

Ist dieser Wert ungleich Null, erstellt die Ansicht zusätzliche Delegaten vor dem Beginn der Ansicht oder nach deren Ende. Die Ansicht erstellt so viele Delegaten, wie in die angegebene Pixelgröße passen.

Wenn beispielsweise in einer vertikalen Ansicht der Delegat 20 Pixel hoch ist und sowohl „ displayMarginBeginning “ als auch „ displayMarginEnd “ auf 40 gesetzt sind, werden 2 Delegaten oberhalb und 2 Delegaten unterhalb erstellt und angezeigt.

Der Standardwert ist 0.

Diese Eigenschaft dient dazu, bestimmte UI-Konfigurationen zu ermöglichen, und nicht der Leistungsoptimierung. Wenn Sie aus Leistungsgründen Delegaten außerhalb der Ansichtsgeometrie erstellen möchten, sollten Sie stattdessen wahrscheinlich die Eigenschaft „ cacheBuffer “ verwenden.

Diese Eigenschaften wurden in QtQuick 2.3 eingeführt.

effectiveLayoutDirection : enumeration [read-only]

Diese Eigenschaft legt die tatsächliche Layout-Richtung einer horizontal ausgerichteten Liste fest.

Bei Verwendung der angehängten Eigenschaft „ LayoutMirroring::enabled “ für lokalisierte Layouts wird die visuelle Ausrichtungsrichtung der horizontalen Liste gespiegelt. Die Eigenschaft „ layoutDirection “ bleibt jedoch unverändert.

Siehe auch „ ListView::layoutDirection “ und „ LayoutMirroring “.

footer : Component

Diese Eigenschaft enthält die Komponente, die als Fußzeile verwendet werden soll.

Für jede Ansicht wird eine Instanz der Fußzeilenkomponente erstellt. Die Fußzeile wird am Ende der Ansicht, nach allen Elementen, positioniert. Die Standard- stacking order der Fußzeile lautet 1.

Siehe auch „ header “, „ footerItem “ und „ Stacking Order in ListView “.

footerItem : Item [read-only]

Hier wird das Fußzeilenelement gespeichert, das aus der Komponente „ footer “ erstellt wurde.

Für jede Ansicht wird eine Instanz der Fußzeilenkomponente erstellt. Die Fußzeile wird am Ende der Ansicht, nach allen Elementen, positioniert. Der Standard- stacking order der Fußzeile lautet 1.

Siehe auch „ footer “, „ headerItem “ und „ Stacking Order in ListView “.

footerPositioning : enumeration [since Qt 5.4]

Diese Eigenschaft bestimmt die Positionierung des „ footer item “.

Diese Eigenschaft wurde in Qt 5.4 eingeführt.

header : Component

Diese Eigenschaft enthält die Komponente, die als Kopfzeile verwendet werden soll.

Für jede Ansicht wird eine Instanz der Kopfzeilenkomponente erstellt. Die Kopfzeile wird am Anfang der Ansicht vor allen Elementen positioniert. Die Standard- stacking order der Kopfzeile lautet „ 1 “.

Siehe auch „ footer “, „ headerItem “ und „ Stacking Order in ListView “.

headerItem : Item [read-only]

Hier wird das aus der Komponente „ header “ erstellte Kopfzeilenelement gespeichert.

Für jede Ansicht wird eine Instanz der Kopfzeilenkomponente erstellt. Die Kopfzeile wird am Anfang der Ansicht vor allen Elementen positioniert. Die Standard- stacking order der Kopfzeile lautet 1.

Siehe auch „ header “, „ footerItem “ und „ Stacking Order in ListView “.

headerPositioning : enumeration [since Qt 5.4]

Diese Eigenschaft bestimmt die Positionierung des „ header item “.

Diese Eigenschaft wurde in Qt 5.4 eingeführt.

highlight : Component

Diese Eigenschaft enthält die Komponente, die als Hervorhebung verwendet werden soll.

Für jede Liste wird eine Instanz der Hervorhebungskomponente erstellt. Die Geometrie der resultierenden Komponenteninstanz wird von der Liste so verwaltet, dass sie dem aktuellen Element folgt, es sei denn, die Eigenschaft „ highlightFollowsCurrentItem “ ist auf „false“ gesetzt. Die Standardausrichtung „ stacking order “ des hervorgehobenen Elements ist „ 0 “.

Siehe auch „ highlightItem“ , „ highlightFollowsCurrentItem “, „ListView-Highlight-Beispiel“ und „ Stacking Order in ListView “.

highlightFollowsCurrentItem : bool

Diese Eigenschaft gibt an, ob die Markierung von der Ansicht verwaltet wird.

Ist diese Eigenschaft auf „true“ gesetzt (Standardwert), wird die Markierung sanft verschoben, um dem aktuellen Element zu folgen. Andernfalls wird die Markierung nicht von der Ansicht verschoben, und jede Bewegung muss von der Markierung selbst implementiert werden.

Hier ist eine Markierung, deren Bewegung durch ein „ SpringAnimation “-Element definiert wird:

Component {
    id: highlight
    Rectangle {
        width: 180; height: 40
        color: "lightsteelblue"; radius: 5
        y: list.currentItem.y
        Behavior on y {
            SpringAnimation {
                spring: 3
                damping: 0.2
            }
        }
    }
}

ListView {
    id: list
    width: 180; height: 200
    model: ContactModel {}
    delegate: Text { text: name }

    highlight: highlight
    highlightFollowsCurrentItem: false
    focus: true
}

Beachten Sie, dass die Animation der Markierung auch Einfluss darauf hat, wie die Ansicht gescrollt wird. Dies liegt daran, dass die Ansicht so verschoben wird, dass die Markierung innerhalb des bevorzugten Markierungsbereichs (oder des sichtbaren Ansichtsbereichs) bleibt.

Siehe auch „ highlight “ und „ highlightMoveVelocity “.

highlightItem : Item [read-only]

Hier wird das Highlight-Element gespeichert, das von der Komponente „ highlight “ erstellt wurde.

Die „ highlightItem “ wird von der Ansicht verwaltet, sofern „ highlightFollowsCurrentItem “ nicht auf „false“ gesetzt ist. Die Standard-„ stacking order “ des Hervorhebungselements lautet „ 0 “.

Siehe auch „ highlight “, „ highlightFollowsCurrentItem “ und „ Stacking Order in ListView “.

Diese Eigenschaften steuern die Geschwindigkeit der Bewegungs- und Größenänderungsanimationen für den Highlight-Delegaten.

highlightFollowsCurrentItem muss auf „true“ gesetzt sein, damit diese Eigenschaften wirksam werden.

Der Standardwert für die Geschwindigkeitseigenschaften beträgt 400 Pixel/Sekunde. Der Standardwert für die Dauer-Eigenschaften ist -1, d. h., die Markierung benötigt so viel Zeit wie nötig, um sich mit der eingestellten Geschwindigkeit zu bewegen.

Diese Eigenschaften weisen dieselben Merkmale auf wie ein „ SmoothedAnimation “: Sind sowohl die Geschwindigkeit als auch die Dauer festgelegt, verwendet die Animation den Wert, der die kürzere Dauer ergibt.

Die Eigenschaften „move velocity“ und „duration“ dienen zur Steuerung der Bewegung aufgrund von Indexänderungen; beispielsweise wenn „ incrementCurrentIndex()“ aufgerufen wird. Wenn der Benutzer auf ein „ ListView “ wischt, wird stattdessen die Geschwindigkeit aus dem Wischvorgang zur Steuerung der Bewegung verwendet.

Um nur eine Eigenschaft festzulegen, kann die andere auf ` -1` gesetzt werden. Wenn Sie beispielsweise nur die Dauer und nicht die Geschwindigkeit animieren möchten, verwenden Sie den folgenden Code:

highlightMoveDuration: 1000
highlightMoveVelocity: -1

Siehe auch highlightFollowsCurrentItem.

Diese Eigenschaften legen den bevorzugten Bereich für die Hervorhebung (des aktuellen Elements) innerhalb der Ansicht fest. Der Wert für „ preferredHighlightBegin “ muss kleiner sein als der Wert für „ preferredHighlightEnd “.

Diese Eigenschaften beeinflussen die Position des aktuellen Elements beim Scrollen der Liste. Wenn beispielsweise das aktuell ausgewählte Element beim Scrollen der Ansicht in der Mitte der Liste bleiben soll, setzen Sie die Werte für „ preferredHighlightBegin “ und „ preferredHighlightEnd “ auf die oberen und unteren Koordinaten der Stelle, an der sich das mittlere Element befinden würde. Wird die „ currentItem “ programmgesteuert geändert, scrollt die Liste automatisch so, dass sich das aktuelle Element in der Mitte der Ansicht befindet. Darüber hinaus tritt das Verhalten des aktuellen Elementindex unabhängig davon auf, ob eine Hervorhebung vorhanden ist oder nicht.

Gültige Werte für „ highlightRangeMode “ sind:

keyNavigationEnabled : bool

Diese Eigenschaft gibt an, ob die Tastenbedienung der Liste aktiviert ist.

Ist der Wert „ true “, kann der Benutzer mit der Tastatur durch die Ansicht navigieren. Dies ist nützlich für Anwendungen, bei denen die Interaktion mit Maus und Tastatur selektiv aktiviert oder deaktiviert werden muss.

Standardmäßig ist der Wert dieser Eigenschaft an „ interactive “ gebunden, um die Kompatibilität mit bestehenden Anwendungen zu gewährleisten. Bei expliziter Festlegung wird die Bindung an die Eigenschaft „interactive“ aufgehoben.

Siehe auch „ interactive “.

keyNavigationWraps : bool

Diese Eigenschaft gibt an, ob die Liste bei der Tasten-Navigation umbricht.

Ist dies der Fall, springt die Tasten-Navigation, die die aktuelle Auswahl über das Ende der Liste hinaus verschieben würde, stattdessen an den Anfang der Liste zurück – und umgekehrt.

Standardmäßig erfolgt bei der Tasten-Navigation kein Umbruch.

layoutDirection : enumeration

Diese Eigenschaft legt die Ausrichtungsrichtung einer horizontal ausgerichteten Liste fest.

Mögliche Werte:

Die Einstellung dieser Eigenschaft hat keine Auswirkung, wenn „ orientation “ auf „Qt.Vertical“ gesetzt ist.

Siehe auch „ ListView::effectiveLayoutDirection “ und „ ListView::verticalLayoutDirection “.

model : model

Diese Eigenschaft enthält das Modell, das die Daten für die Liste bereitstellt.

Das Modell stellt den Datensatz bereit, der zur Erstellung der Elemente in der Ansicht verwendet wird. Modelle können direkt in QML mithilfe von ` ListModel` und ` ObjectModel` erstellt oder durch C++-Modellklassen bereitgestellt werden. Wenn eine C++-Modellklasse verwendet wird, muss es sich um eine Unterklasse von ` QAbstractItemModel ` oder um eine einfache Liste handeln.

Siehe auch Datenmodelle.

move : Transition

Diese Eigenschaft enthält den Übergang, der auf Elemente in der Ansicht angewendet werden soll, die aufgrund einer Verschiebungsoperation im „ model “ der Ansicht verschoben werden.

Hier ist beispielsweise eine Ansicht, die einen solchen Übergang festlegt:

ListView {
    ...
    move: Transition {
        NumberAnimation { properties: "x,y"; duration: 1000 }
    }
}

Immer wenn der „ model “ eine Verschiebungsoperation durchführt, um eine bestimmte Gruppe von Indizes zu verschieben, werden die entsprechenden Elemente in der Ansicht über einen Zeitraum von einer Sekunde an ihre neuen Positionen in der Ansicht animiert. Der Übergang gilt nur für die Elemente, die Gegenstand der Verschiebungsoperation im Modell sind; er gilt nicht für darunter liegende Elemente, die durch die Verschiebungsoperation verdrängt werden. Um die verdrängten Elemente zu animieren, legen Sie die Eigenschaften „ displaced “ oder „ moveDisplaced “ fest.

Weitere Details und Beispiele zur Verwendung von Ansichtsübergängen finden Sie in der Dokumentation unter „ ViewTransition “.

Siehe auch „ moveDisplaced “ und „ ViewTransition “.

moveDisplaced : Transition

Diese Eigenschaft legt fest, welcher Übergang auf Elemente angewendet werden soll, die durch eine Verschiebungsoperation im „ model “ der Ansicht verschoben werden.

Hier ist beispielsweise eine Ansicht, die einen solchen Übergang festlegt:

ListView {
    ...
    moveDisplaced: Transition {
        NumberAnimation { properties: "x,y"; duration: 1000 }
    }
}

Immer wenn der „ model “ eine Verschiebungsoperation durchführt, um eine bestimmte Gruppe von Indizes zu verschieben, werden die Elemente zwischen dem Quell- und dem Zielindex der Verschiebungsoperation verschoben, wodurch sie sich innerhalb der Ansicht nach oben oder unten (oder seitwärts, falls horizontal ausgerichtet) bewegen. Während dieser Verschiebung wird die Bewegung der Elemente zu ihren neuen x-, y-Positionen innerhalb der Ansicht durch einen „ NumberAnimation “ über eine Sekunde hinweg animiert, wie angegeben. Dieser Übergang wird nicht auf die Elemente angewendet, die tatsächlich Gegenstand der Verschiebungsoperation sind; um die verschobenen Elemente zu animieren, setzen Sie die Eigenschaft „ move “.

Wird ein Element gleichzeitig durch mehrere Arten von Operationen verschoben, ist nicht festgelegt, ob der Übergang „ addDisplaced “, „moveDisplaced“ oder „ removeDisplaced “ angewendet wird. Wenn es zudem nicht erforderlich ist, je nachdem, ob ein Element durch eine Hinzufügungs-, Verschiebungs- oder Entfernungsoperation verschoben wird, unterschiedliche Übergänge festzulegen, sollten Sie stattdessen die Eigenschaft „ displaced “ setzen.

Weitere Details und Beispiele zur Verwendung von Ansichtsübergängen finden Sie in der Dokumentation zu „ ViewTransition “.

Siehe auch displaced, move und ViewTransition.

orientation : enumeration

Diese Eigenschaft gibt die Ausrichtung der Liste an.

Mögliche Werte:

Konstante	Beschreibung
ListView.Horizontal	Die Elemente werden horizontal angeordnet
ListView.Vertical	(Standard) Die Elemente werden vertikal angeordnet

Siehe auch Flickable Direction.

populate : Transition

Diese Eigenschaft legt fest, welcher Übergang auf die Elemente angewendet werden soll, die ursprünglich für eine Ansicht erstellt wurden.

Sie gilt für alle Elemente, die zu folgenden Zeitpunkten erstellt werden:

• die Ansicht zum ersten Mal erstellt wird
• sich die „ model “ der Ansicht so ändert, dass die sichtbaren Delegaten vollständig ersetzt werden
• Die „ model “ der Ansicht lautet „ reset “, wenn das Modell eine Unterklasse von „ QAbstractItemModel “ ist

Hier ist beispielsweise eine Ansicht, die einen solchen Übergang festlegt:

ListView {
    ...
    populate: Transition {
        NumberAnimation { properties: "x,y"; duration: 1000 }
    }
}

Bei der Initialisierung der Ansicht erstellt diese alle erforderlichen Elemente und animiert sie dann innerhalb einer Sekunde an ihre korrekten Positionen innerhalb der Ansicht.

Beim späteren Scrollen der Ansicht wird der „populate“-Übergang jedoch nicht ausgeführt, obwohl Delegaten instanziiert werden, sobald sie sichtbar werden. Wenn sich das Modell so ändert, dass neue Delegaten sichtbar werden, wird stattdessen der „ add “-Übergang ausgeführt. Sie sollten sich daher nicht darauf verlassen, dass der „ populate “-Übergang die Eigenschaften im Delegaten initialisiert, da er nicht für jeden Delegaten gilt. Wenn Ihre Animation den Wert „ to “ einer Eigenschaft festlegt, sollte die Eigenschaft zunächst den Wert „ to “ haben, und die Animation sollte den Wert „ from “ festlegen, falls dieser animiert wird:

ListView {
    ...
    delegate: Rectangle {
        opacity: 1 // not necessary because it's the default
    }
    populate: Transition {
        NumberAnimation { property: "opacity"; from: 0; to: 1; duration: 1000 }
    }
}

Weitere Details und Beispiele zur Verwendung von Ansichtsübergängen finden Sie in der Dokumentation unter ViewTransition.

Siehe auch „ add “ und „ ViewTransition “.

remove : Transition

Diese Eigenschaft legt fest, welcher Übergang auf Elemente angewendet werden soll, die aus der Ansicht entfernt werden.

Hier ist beispielsweise eine Ansicht, die einen solchen Übergang festlegt:

ListView {
    ...
    remove: Transition {
        ParallelAnimation {
            NumberAnimation { property: "opacity"; to: 0; duration: 1000 }
            NumberAnimation { properties: "x,y"; to: 100; duration: 1000 }
        }
    }
}

Immer wenn ein Element aus der obigen Ansicht entfernt wird, wird es innerhalb einer Sekunde an die Position (100,100) animiert und gleichzeitig wird seine Deckkraft auf 0 gesetzt. Der Übergang gilt nur für die Elemente, die aus der Ansicht entfernt werden; er gilt nicht für die darunter liegenden Elemente, die durch das Entfernen der Elemente verschoben werden. Um die verschobenen Elemente zu animieren, legen Sie die Eigenschaften „ displaced “ oder „ removeDisplaced “ fest.

Beachten Sie, dass das Element zum Zeitpunkt der Anwendung des Übergangs bereits aus dem Modell entfernt wurde; alle Verweise auf die Modelldaten für den entfernten Index sind nicht mehr gültig.

Wenn zudem die angehängte Eigenschaft „ delayRemove “ für ein Delegat-Element festgelegt wurde, wird der „remove“-Übergang erst angewendet, wenn „ delayRemove “ wieder den Wert „false“ annimmt.

Weitere Details und Beispiele zur Verwendung von Ansichtsübergängen finden Sie in der Dokumentation zu „ ViewTransition “.

Siehe auch „ removeDisplaced “ und „ ViewTransition “.

removeDisplaced : Transition

Diese Eigenschaft legt den Übergang fest, der auf Elemente in der Ansicht angewendet werden soll, die durch das Entfernen anderer Elemente in der Ansicht verschoben werden.

Hier ist beispielsweise eine Ansicht, die einen solchen Übergang festlegt:

ListView {
    ...
    removeDisplaced: Transition {
        NumberAnimation { properties: "x,y"; duration: 1000 }
    }
}

Immer wenn ein Element aus der obigen Ansicht entfernt wird, werden alle darunter liegenden Elemente verschoben, wodurch sie sich innerhalb der Ansicht nach oben (oder seitwärts, falls horizontal ausgerichtet) bewegen. Während dieser Verschiebung wird die Bewegung der Elemente zu ihren neuen x-, y-Positionen innerhalb der Ansicht, wie angegeben, durch einen „ NumberAnimation “-Übergang über eine Sekunde hinweg animiert. Dieser Übergang wird nicht auf das Element angewendet, das tatsächlich aus der Ansicht entfernt wurde; um die entfernten Elemente zu animieren, setzen Sie die Eigenschaft „ remove “.

Wird ein Element durch mehrere Arten von Operationen gleichzeitig verschoben, ist nicht festgelegt, ob der Übergang „ addDisplaced “, „ moveDisplaced “ oder „removeDisplaced“ angewendet wird. Wenn es zudem nicht erforderlich ist, unterschiedliche Übergänge je nachdem festzulegen, ob ein Element durch eine Hinzufügungs-, Verschiebungs- oder Entfernungsoperation verschoben wird, sollten Sie stattdessen die Eigenschaft „ displaced “ festlegen.

Weitere Details und Beispiele zur Verwendung von Ansichtsübergängen finden Sie in der Dokumentation zu „ ViewTransition “.

Siehe auch displaced, remove und ViewTransition.

reuseItems : bool

Mit dieser Eigenschaft können Sie Elemente wiederverwenden, die aus dem „ delegate “ instanziiert wurden. Wenn der Wert auf „ false “ gesetzt ist, werden alle derzeit im Pool befindlichen Elemente gelöscht.

Diese Eigenschaft ist standardmäßig auf „ false “ gesetzt.

Siehe auch „ Reusing items“ , „ pooled()“ und „ reused()“.

section group

Diese Eigenschaften legen den auszuwertenden Ausdruck sowie das Erscheinungsbild der Abschnittsbezeichnungen fest.

section.property Enthält den Namen der Eigenschaft, die die Grundlage für jeden Abschnitt bildet.

section.criteria Enthält die Kriterien für die Bildung der einzelnen Abschnitte auf der Grundlage von section.property. Dieser Wert kann einer der folgenden sein:

Bei der Festlegung der Abschnittsgrenzen wird ein Vergleich ohne Berücksichtigung der Groß-/Kleinschreibung verwendet.

section.delegate Enthält die Delegate-Komponente für jeden Abschnitt. Die Standard- stacking order -Methode von Abschnitt-Delegate-Instanzen lautet „ 2 “. Wenn Sie darin eine „ required “-Eigenschaft namens „section“ deklarieren, enthält diese Eigenschaft den Titel des Abschnitts.

section.labelPositioning Legt fest, ob die Beschriftungen des aktuellen und/oder nächsten Abschnitts am Anfang bzw. Ende der Ansicht fixiert sind und ob die Beschriftungen inline angezeigt werden. Dieser Wert kann eine Kombination aus folgenden Elementen sein:

Jedes Element in der Liste verfügt über die Eigenschaften „ ListView.section “, „ ListView.previousSection “ und „ ListView.nextSection “.

Hier ist beispielsweise ein „ ListView “, der eine Liste von Tieren anzeigt, die in Abschnitte unterteilt ist. Jedes Element in der „ ListView “ wird je nach der Eigenschaft „size“ des Modellelements in einen anderen Abschnitt eingeordnet. Die Delegate-Komponente „ sectionHeading “ stellt den hellblauen Balken bereit, der den Anfang jedes Abschnitts markiert.

    // The delegate for each section header
    Component {
        id: sectionHeading
        Rectangle {
            width: ListView.view.width
            height: childrenRect.height
            color: "lightsteelblue"

            required property string section

            Text {
                text: parent.section
                font.bold: true
                font.pixelSize: 20
            }
        }
    }

    ListView {
        id: view
        anchors.top: parent.top
        anchors.bottom: buttonBar.top
        width: parent.width
        model: animalsModel
        delegate: Text {
            required property string name

            text: name
            font.pixelSize: 18
        }

        section.property: "size"
        section.criteria: ViewSection.FullString
        section.delegate: sectionHeading
    }

Siehe auch „ListView“-Beispiele und „ Stacking Order in ListView “.

snapMode : enumeration

Diese Eigenschaft legt fest, wie sich die Ansicht nach einem Ziehen oder Wischen stabilisiert. Mögliche Werte sind:

snapMode hat keine Auswirkungen auf den „ currentIndex “. Um den „ currentIndex “ beim Verschieben der Liste zu aktualisieren, setzen Sie „ highlightRangeMode “ auf „ ListView.StrictlyEnforceRange “.

Siehe auch „ highlightRangeMode “.

spacing : real

Diese Eigenschaft legt den Abstand zwischen den Elementen fest.

Der Standardwert ist 0.

verticalLayoutDirection : enumeration

Diese Eigenschaft legt die Ausrichtungsrichtung einer vertikal ausgerichteten Liste fest.

Mögliche Werte:

Die Einstellung dieser Eigenschaft hat keine Auswirkung, wenn „ orientation “ auf „Qt.Horizontal“ gesetzt ist.

Siehe auch „ ListView::layoutDirection “.

Dokumentation zu den angehängten Eigenschaften

ListView.delayRemove : bool [attached]

Diese angehängte Eigenschaft gibt an, ob der Delegat zerstört werden darf. Sie ist an jede Instanz des Delegaten angehängt. Der Standardwert ist „false“.

Manchmal ist es erforderlich, die Löschung eines Elements so lange zu verzögern, bis eine Animation abgeschlossen ist. Der im Folgenden gezeigte Beispiel-Delegat stellt sicher, dass die Animation abgeschlossen ist, bevor das Element aus der Liste entfernt wird.

Component {
    id: delegate
    Item {
        SequentialAnimation {
            id: removeAnimation
            PropertyAction { target: wrapper; property: "ListView.delayRemove"; value: true }
            NumberAnimation { target: wrapper; property: "scale"; to: 0; duration: 250; easing.type: Easing.InOutQuad }
            PropertyAction { target: wrapper; property: "ListView.delayRemove"; value: false }
        }
        ListView.onRemove: removeAnimation.start()
    }
}

Wenn ein Übergang vom Typ „ remove “ festgelegt wurde, wird dieser erst angewendet, wenn „delayRemove“ den Wert „ false “ zurückgibt.

ListView.isCurrentItem : bool [read-only attached]

Diese Eigenschaft ist „true“, wenn dieser Delegat das aktuelle Element ist; andernfalls „false“.

Sie ist an jede Instanz des Delegaten angehängt.

Diese Eigenschaft kann verwendet werden, um das Erscheinungsbild des aktuellen Elements anzupassen, zum Beispiel:

ListView {
    width: 180; height: 200

    Component {
        id: contactsDelegate
        Rectangle {
            id: wrapper
            width: 180
            height: contactInfo.height
            color: ListView.isCurrentItem ? "black" : "red"
            Text {
                id: contactInfo
                text: name + ": " + number
                color: wrapper.ListView.isCurrentItem ? "red" : "black"
            }
        }
    }

    model: ContactModel {}
    delegate: contactsDelegate
    focus: true
}

ListView.nextSection : string [read-only attached]

Diese zugehörige Eigenschaft enthält den Abschnitt des nächsten Elements.

Sie ist an jede Instanz des Delegaten angehängt.

Der Abschnitt wird mithilfe der Eigenschaften „ section “ ausgewertet.

ListView.previousSection : string [read-only attached]

Diese angehängte Eigenschaft enthält den Abschnitt des vorherigen Elements.

Sie ist an jede Instanz des Delegaten angehängt.

Der Abschnitt wird mithilfe der Eigenschaften „ section “ ausgewertet.

ListView.section : string [read-only attached]

Diese angehängte Eigenschaft enthält den Abschnitt dieses Elements.

Sie ist an jede Instanz des Delegaten angehängt.

Der Abschnitt wird mithilfe der Eigenschaften „ section “ ausgewertet.

ListView.view : ListView [read-only attached]

Diese angehängte Eigenschaft enthält die Ansicht, die diese Delegat-Instanz verwaltet.

Sie ist an jede Instanz des Delegaten sowie an die Delegaten für Kopfzeile, Fußzeile, Abschnitt und Hervorhebung angehängt.

Dokumentation zu „Attached Signal“

[attached] add()

Dieses angehängte Signal wird unmittelbar nach dem Hinzufügen eines Elements zur Ansicht ausgelöst.

Wenn ein Hinzufügungsübergang festgelegt ist, wird dieser unmittelbar nach der Verarbeitung dieses Signals angewendet.

[attached] pooled()

Dieses Signal wird ausgelöst, nachdem ein Element dem Wiederverwendungspool hinzugefügt wurde. Sie können es verwenden, um laufende Timer oder Animationen innerhalb des Elements anzuhalten oder Ressourcen freizugeben, die nicht wiederverwendet werden können.

Dieses Signal wird nur ausgegeben, wenn die Eigenschaft „ reuseItems “ auf „ true “ gesetzt ist.

Siehe auch „ Reusing items“ , „ reuseItems “ und „ reused()“.

[attached] remove()

Dieses angehängte Signal wird unmittelbar vor dem Entfernen eines Elements aus der Ansicht ausgelöst.

Wenn ein „remove“-Übergang festgelegt wurde, wird dieser angewendet, nachdem dieses Signal verarbeitet wurde, vorausgesetzt, dass „ delayRemove “ den Wert „false“ hat.

[attached] reused()

Dieses Signal wird ausgelöst, nachdem ein Element wiederverwendet wurde. Zu diesem Zeitpunkt wurde das Element aus dem Pool entnommen und in die Inhaltsansicht eingefügt, und die Modelleigenschaften wie „ index “ und „ row “ wurden aktualisiert.

Andere Eigenschaften, die nicht vom Modell bereitgestellt werden, ändern sich nicht, wenn ein Element wiederverwendet wird. Sie sollten es vermeiden, Zustände in einem Delegaten zu speichern; falls Sie dies dennoch tun, setzen Sie diesen Zustand beim Empfang dieses Signals manuell zurück.

Dieses Signal wird ausgelöst, wenn das Element wiederverwendet wird, nicht jedoch beim ersten Erstellen des Elements.

Dieses Signal wird nur ausgelöst, wenn die Eigenschaft „ reuseItems “ den Wert „ true “ hat.

Siehe auch „ Reusing items“ , „ reuseItems “ und „ pooled()“.

Methodendokumentation

void decrementCurrentIndex()

Verringert den aktuellen Index. Der aktuelle Index springt an den Anfang zurück, wenn „ keyNavigationWraps “ auf „true“ gesetzt ist und er sich gerade am Anfang befindet. Diese Methode hat keine Auswirkung, wenn der Wert von „ count “ Null ist.

Hinweis: Methoden sollten erst aufgerufen werden, nachdem die Komponente fertiggestellt wurde.

void forceLayout()

Die Reaktion auf Änderungen am Modell erfolgt in der Regel gebündelt und findet nur einmal pro Frame statt. Das bedeutet, dass sich das zugrunde liegende Modell innerhalb von Skriptblöcken möglicherweise bereits geändert hat, der „ ListView “ diese Änderungen jedoch noch nicht nachverarbeitet hat.

Diese Methode zwingt den „ ListView “, sofort auf alle ausstehenden Änderungen im Modell zu reagieren.

Hinweis: Methoden sollten erst aufgerufen werden, nachdem die Komponente ihre Ausführung abgeschlossen hat.

void incrementCurrentIndex()

Erhöht den aktuellen Index. Der aktuelle Index springt an den Anfang, wenn „ keyNavigationWraps “ auf „true“ gesetzt ist und er sich gerade am Ende befindet. Diese Methode hat keine Wirkung, wenn der Wert von „ count “ Null ist.

Hinweis: Methoden sollten erst aufgerufen werden, nachdem die Komponente fertiggestellt ist.

int indexAt(real x, real y)

Gibt den Index des sichtbaren Elements zurück, das den Punkt x, y in Inhaltskoordinaten enthält. Befindet sich an dem angegebenen Punkt kein Element oder ist das Element nicht sichtbar, wird -1 zurückgegeben.

Befindet sich das Element außerhalb des sichtbaren Bereichs, wird -1 zurückgegeben, unabhängig davon, ob an dieser Stelle ein Element vorhanden sein wird, sobald es durch Scrollen in den sichtbaren Bereich gelangt.

Hinweis: Methoden sollten erst aufgerufen werden, nachdem die Komponente fertiggestellt wurde.

Item itemAt(real x, real y)

Gibt das sichtbare Element zurück, das den Punkt x, y in Inhaltskoordinaten enthält. Befindet sich an dem angegebenen Punkt kein Element oder ist das Element nicht sichtbar, wird null zurückgegeben.

Befindet sich das Element außerhalb des sichtbaren Bereichs, wird null zurückgegeben, unabhängig davon, ob an dieser Stelle ein Element vorhanden sein wird, wenn der Bereich durch Scrollen in den sichtbaren Bereich gerät.

Hinweis: Methoden sollten erst aufgerufen werden, nachdem die Komponente fertiggestellt ist.

Item itemAtIndex(int index)

Gibt das Element für „ index “ zurück. Wenn für diesen Index kein Element vorhanden ist – beispielsweise, weil es noch nicht erstellt wurde oder weil es durch Verschieben aus dem sichtbaren Bereich herausgerückt und aus dem Cache entfernt wurde –, wird „null“ zurückgegeben.

Hinweis: Diese Methode sollte erst aufgerufen werden, nachdem die Komponente fertiggestellt ist. Der zurückgegebene Wert sollte zudem nicht gespeichert werden, da er auf `null` gesetzt werden kann, sobald die Steuerung den aufrufenden Bereich verlässt, falls die Ansicht dieses Element freigibt.

Positioniert die Ansicht am Anfang oder am Ende, wobei etwaige Kopf- und Fußzeilen berücksichtigt werden.

Es wird nicht empfohlen, „ contentX “ oder „ contentY “ zu verwenden, um die Ansicht an einem bestimmten Index zu positionieren. Dies ist unzuverlässig, da das Entfernen von Elementen am Anfang der Liste nicht dazu führt, dass alle anderen Elemente neu positioniert werden, und da der tatsächliche Anfang der Ansicht je nach Größe der Delegaten variieren kann.

Hinweis: Methoden sollten erst aufgerufen werden, nachdem die Komponente fertiggestellt wurde. Um die Ansicht beim Start zu positionieren, sollte diese Methode von `Component.onCompleted` aufgerufen werden. Um die Ansicht beispielsweise beim Start am Ende zu positionieren:

Component.onCompleted: positionViewAtEnd()

void positionViewAtIndex(int index, PositionMode mode)

Positioniert die Ansicht so, dass sich „ index “ an der durch „ mode “ angegebenen Position befindet:

Wenn die Positionierung der Ansicht auf „ index “ dazu führen würde, dass am Anfang oder Ende der Ansicht Leerräume angezeigt werden, wird die Ansicht an der Grenze positioniert.

Es wird nicht empfohlen, „ contentX “ oder „ contentY “ zu verwenden, um die Ansicht an einem bestimmten Index zu positionieren. Dies ist unzuverlässig, da das Entfernen von Elementen am Anfang der Liste nicht dazu führt, dass alle anderen Elemente neu positioniert werden, und da der tatsächliche Anfang der Ansicht je nach Größe der Delegaten variieren kann. Der korrekte Weg, ein Element in die Ansicht zu bringen, ist „ positionViewAtIndex “.

Hinweis: Methoden sollten erst aufgerufen werden, nachdem die Komponente fertiggestellt wurde. Um die Ansicht beim Start zu positionieren, sollte diese Methode von `Component.onCompleted` aufgerufen werden. Um die Ansicht beispielsweise am Ende zu positionieren:

Component.onCompleted: positionViewAtIndex(count - 1, ListView.Beginning)