StackView QML Type

Bietet ein stapelbasiertes Navigationsmodell. Mehr...

• Liste aller Mitglieder, einschließlich vererbter Mitglieder

Eigenschaften

• busy : bool
• currentItem : Item
• depth : int
• empty : bool (since QtQuick.Controls 2.3 (Qt 5.10))
• initialItem : var
• popEnter : Transition
• popExit : Transition
• pushEnter : Transition
• pushExit : Transition
• replaceEnter : Transition
• replaceExit : Transition

Zugehörige Eigenschaften

• index : int
• status : enumeration
• view : StackView
• visible : bool (since QtQuick.Controls 2.2 (Qt 5.9))

Angehängte Signale

• activated() (since QtQuick.Controls 2.1 (Qt 5.8))
• activating() (since QtQuick.Controls 2.1 (Qt 5.8))
• deactivated() (since QtQuick.Controls 2.1 (Qt 5.8))
• deactivating() (since QtQuick.Controls 2.1 (Qt 5.8))
• removed() (since QtQuick.Controls 2.1 (Qt 5.8))

Methoden

• void clear(transition)
• Item find(callback, behavior)
• Item get(index, behavior)
• Item pop(item, operation)
• Item popCurrentItem(operation) (since 6.7)
• Item popToIndex(index, operation) (since 6.7)
• Item popToItem(item, operation) (since 6.7)
• Item push(item, properties, operation)
• Item pushItem(item, properties, operation) (since 6.7)
• Item pushItem(component, properties, operation) (since 6.7)
• Item pushItem(url, properties, operation) (since 6.7)
• Item pushItems(items, operation) (since 6.7)
• Item replace(target, item, properties, operation)
• Item replaceCurrentItem(items, operation) (since 6.7)
• Item replaceCurrentItem(item, properties, operation) (since 6.7)
• Item replaceCurrentItem(component, properties, operation) (since 6.7)
• Item replaceCurrentItem(url, properties, operation) (since 6.7)

Ausführliche Beschreibung

StackView kann mit einer Reihe miteinander verknüpfter Informationsseiten verwendet werden. Ein Beispiel hierfür ist eine E-Mail-Anwendung mit separaten Ansichten zum Anzeigen der neuesten E-Mails, zum Anzeigen einer bestimmten E-Mail sowie zum Anzeigen der Anhänge. Die E-Mail-Listenansicht wird auf den Stack geschoben, wenn Benutzer eine E-Mail öffnen, und wieder vom Stack entfernt, wenn sie zurückgehen möchten.

Der folgende Codeausschnitt veranschaulicht einen einfachen Anwendungsfall, bei dem die „ mainView “ durch Klicken auf die entsprechende Schaltfläche auf den Stapel gelegt und wieder vom Stapel entfernt wird:

ApplicationWindow {
    title: qsTr("Hello World")
    width: 640
    height: 480
    visible: true

    StackView {
        id: stack
        initialItem: mainView
        anchors.fill: parent
    }

    Component {
        id: mainView

        Row {
            spacing: 10

            Button {
                text: "Push"
                onClicked: stack.push(mainView)
            }
            Button {
                text: "Pop"
                enabled: stack.depth > 1
                onClicked: stack.pop()

            }
            Text {
                text: stack.depth
            }
        }
    }
}

Verwendung von StackView in einer Anwendung

Die Verwendung von StackView in einer Anwendung ist so einfach wie das Hinzufügen als untergeordnetes Element zu einem Fenster. Der Stack wird in der Regel an den Rändern des Fensters verankert, außer am oberen oder unteren Rand, wo er möglicherweise an einer Statusleiste oder einer ähnlichen UI-Komponente verankert wird. Der Stapel kann dann durch Aufruf seiner Navigationsmethoden verwendet werden. Das erste Element, das in der „StackView“ angezeigt wird, ist dasjenige, das „ initialItem “ zugewiesen wurde, oder das oberste Element, falls „ initialItem “ nicht festgelegt ist.

Grundlegende Navigation

Die `StackView` unterstützt drei primäre Navigationsoperationen: ` push()`, ` pop()` und ` replace()`. Diese entsprechen den klassischen Stapeloperationen, bei denen „push“ ein Element oben auf den Stapel legt, „pop“ das oberste Element vom Stapel entfernt und „replace“ wie ein „pop“ gefolgt von einem „push“ funktioniert, wodurch das oberste Element durch das neue Element ersetzt wird. Das oberste Element im Stapel entspricht demjenigen, das auf dem Bildschirm sichtbar ist ( currently ). Logisch gesehen navigiert „push“ vorwärts oder tiefer in die Benutzeroberfläche der Anwendung, „pop“ navigiert rückwärts und „replace“ ersetzt das currentItem.

Elemente auf den Stapel schieben

In der folgenden Animation werden drei Steuerelemente Label mithilfe der Funktion push() auf eine Stack-Ansicht geschoben:

Der Stack enthält nun die folgenden Elemente: [A, B, C].

Elemente entfernen

Anknüpfend an das obige Beispiel wird das oberste Element des Stacks durch einen Aufruf von ` pop()` entfernt:

Der Stapel enthält nun die folgenden Elemente: „ [A, B] “.

Elemente über „Pop“ zurückholen

Manchmal ist es notwendig, mehr als einen Schritt im Stapel zurückzugehen. Beispielsweise, um zu einem „Haupt“-Element oder einem bestimmten Abschnitts-Element in der Anwendung zurückzukehren. In solchen Fällen ist es möglich, ein Element als Parameter für ` pop()` anzugeben. Dies wird als „Unwind“-Operation bezeichnet, bei der der Stapel bis zum angegebenen Element zurückgespult wird. Wird das Element nicht gefunden, wird der Stapel so lange abgewickelt, bis nur noch ein Element übrig ist, das dann zum „ currentItem “ wird. Um explizit bis zum Ende des Stapels abzuwickeln, wird empfohlen, ` pop(null)` zu verwenden, obwohl jedes nicht vorhandene Element ausreicht.

In der folgenden Animation wickeln wir den Stapel bis zum ersten Element ab, indem wir ` pop(null)` aufrufen:

Der Stapel enthält nun ein einziges Element: „ [A] “.

Elemente ersetzen

replace In der folgenden Animation ersetzen wir das oberste Element durch „ D “:

Der Stapel enthält nun die folgenden Elemente: „ [A, B, D] “.

Deep Linking

Deep Linking bedeutet, eine Anwendung in einem bestimmten Zustand zu starten. Beispielsweise könnte eine Zeitungs-App so gestartet werden, dass sie einen bestimmten Artikel anzeigt und dabei das oberste Element überspringt. Im Zusammenhang mit StackView bedeutet Deep Linking die Möglichkeit, den Zustand des Stacks so zu verändern, dass eine Reihe von Elementen an den Anfang des Stacks geschoben oder der Stack vollständig auf einen bestimmten Zustand zurückgesetzt werden kann.

Die API für Deep Linking in StackView entspricht der für die grundlegende Navigation. Durch das Einfügen eines Arrays anstelle eines einzelnen Elements werden alle Elemente dieses Arrays in den Stapel eingefügt. Die Übergangsanimation wird jedoch nur für das letzte Element im Array angewendet. Für das Deep Linking gilt die normale Semantik von ` push()`: Es wird alles hinzugefügt, was auf den Stapel geschoben wird.

Dies führt bei folgendem Stapel [A, B, C] zu folgendem Ergebnis:

• push([D, E, F]) => [A, B, C, D, E, F] – „Push“-Übergangsanimation zwischen C und F
• replace([D, E, F]) => [A, B, D, E, F] – „Ersetzen“-Übergangsanimation zwischen C und F
• clear() gefolgt von ` push` ([D, E, F]) => [D, E, F] – keine Übergangsanimation für das Einfügen von Elementen, da der Stapel leer war.

Elemente finden

Ein Element, auf das die Anwendung keinen Verweis hat, kann durch den Aufruf von ` find()` gefunden werden. Die Methode benötigt eine Callback-Funktion, die für jedes Element im Stapel (beginnend mit dem obersten) aufgerufen wird, bis eine Übereinstimmung gefunden wird. Wenn der Callback ` true` zurückgibt, bricht ` find()` ab und gibt das übereinstimmende Element zurück; andernfalls wird ` null ` zurückgegeben.

Der folgende Code durchsucht den Stapel nach einem Element namens „order_id“ und springt zu diesem Element.

stackView.pop(stackView.find(function(item) {
    return item.name == "order_id";
}));

Sie können ein Element im Stapel auch über ` get(index)` erreichen.

previousItem = stackView.get(myItem.StackView.index - 1));

Übergänge

Bei jedem Push- oder Pop-Vorgang werden unterschiedliche Übergangsanimationen auf die ein- und ausgehenden Elemente angewendet. Diese Animationen legen fest, wie das eintretende Element animiert werden soll und wie das austretende Element animiert werden soll. Die Animationen lassen sich anpassen, indem verschiedene ` Transitions ` den Eigenschaften ` pushEnter`, ` pushExit`, ` popEnter`, ` popExit`, ` replaceEnter` und ` replaceExit ` von `StackView` zugewiesen werden.

Der folgende Codeausschnitt definiert einen einfachen Überblend-Übergang für „Push“- und „Pop“-Operationen:

StackView {
    id: stackview
    anchors.fill: parent

    pushEnter: Transition {
        PropertyAnimation {
            property: "opacity"
            from: 0
            to:1
            duration: 200
        }
    }
    pushExit: Transition {
        PropertyAnimation {
            property: "opacity"
            from: 1
            to:0
            duration: 200
        }
    }
    popEnter: Transition {
        PropertyAnimation {
            property: "opacity"
            from: 0
            to:1
            duration: 200
        }
    }
    popExit: Transition {
        PropertyAnimation {
            property: "opacity"
            from: 1
            to:0
            duration: 200
        }
    }
}

Eigentumsverhältnisse der Elemente

StackView übernimmt nur die Eigentümerschaft an Elementen, die es selbst erstellt. Das bedeutet, dass ein Element, das auf eine „StackView“ geschoben wird, niemals von der „StackView“ zerstört wird; nur Elemente, die die „StackView“ über „ Components “ oder „ URLs “ erstellt, werden von der „StackView“ zerstört. Um dies zu veranschaulichen, werden die Meldungen im folgenden Beispiel erst dann ausgegeben, wenn die „StackView“ zerstört wird, nicht jedoch, wenn die Elemente vom Stapel entfernt werden:

Component {
    id: itemComponent

    Item {
        Component.onDestruction: print("Destroying second item")
    }
}

StackView {
    initialItem: Item {
        Component.onDestruction: print("Destroying initial item")
    }

    Component.onCompleted: push(itemComponent.createObject(window))
}

Die beiden Elemente, die im folgenden Beispiel über die URL und die Komponente erstellt wurden, werden jedoch von der StackView zerstört, sobald sie von ihr entfernt werden:

Component {
    id: itemComponent

    Item {
        Component.onDestruction: print("Destroying second item")
    }
}

StackView {
    initialItem: "Item1.qml"

    Component.onCompleted: push(itemComponent)
}

Größe

StackView erbt keine implizite Größe von Elementen, die auf den Stapel gelegt werden. Das bedeutet, dass die Verwendung als „ contentItem “ eines „ Dialog “, beispielsweise, nicht wie erwartet funktioniert:

Dialog {
    StackView {
        initialItem: Rectangle {
            width: 200
            height: 200
            color: "salmon"
        }
    }
}

Es gibt mehrere Möglichkeiten, um sicherzustellen, dass die „StackView“ in dieser Situation eine Größe hat:

• Legen Sie „ implicitWidth “ und „ implicitHeight “ direkt für das StackView selbst fest.
• Legen Sie „ implicitWidth “ und „ implicitHeight “ im „ Rectangle “ fest.
• Legen Sie „ contentWidth “ und „ contentHeight “ im Dialogfeld fest.
• Legen Sie die Größe des Dialogs fest.

Siehe auch „Anpassen von StackView“, „Navigieren mit StackView“, „Navigationssteuerelemente“, „Container-Steuerelemente“ und „Fokusverwaltung“ in „ Qt Quick Controls “.

Dokumentation zu den Eigenschaften

busy : bool [read-only]

Diese Eigenschaft gibt an, ob gerade ein Übergang läuft.

currentItem : Item [read-only]

Diese Eigenschaft enthält das aktuell oberste Element im Stapel.

depth : int [read-only]

Diese Eigenschaft enthält die Anzahl der Elemente, die derzeit auf dem Stapel liegen.

empty : bool [read-only, since QtQuick.Controls 2.3 (Qt 5.10)]

Diese Eigenschaft gibt an, ob der Stapel leer ist.

Diese Eigenschaft wurde in QtQuick.Controls 2.3 (Qt 5.10) eingeführt.

Siehe auch „ depth “.

initialItem : var

Diese Eigenschaft enthält das Anfangselement, das beim Erstellen der „ StackView “ angezeigt werden soll. Das Anfangselement kann ein „ Item “, ein „ Component “ oder ein „ url “ sein. Die Angabe eines Anfangselements entspricht folgendem Befehl:

Component.onCompleted: stackView.push(myInitialItem)

Siehe auch „ push()“.

popEnter : Transition

Diese Eigenschaft enthält den Übergang, der auf das Element angewendet wird, das in den Stapel aufgenommen wird, wenn ein anderes Element aus diesem entfernt wird.

Siehe auch „StackView anpassen“.

popExit : Transition

Diese Eigenschaft enthält den Übergang, der auf das Element angewendet wird, das den Stapel verlässt, wenn es vom Stapel entfernt wird.

Siehe auch „StackView anpassen“.

pushEnter : Transition

Diese Eigenschaft enthält den Übergang, der auf das Element angewendet wird, das in den Stapel aufgenommen wird, wenn es auf den Stapel geschoben wird.

Siehe auch „StackView anpassen“.

pushExit : Transition

Diese Eigenschaft enthält den Übergang, der auf das Element angewendet wird, das den Stapel verlässt, wenn ein anderes Element auf den Stapel gelegt wird.

Siehe auch „StackView anpassen“.

replaceEnter : Transition

Diese Eigenschaft enthält den Übergang, der auf das Element angewendet wird, das in den Stapel aufgenommen wird, wenn ein anderes Element durch dieses ersetzt wird.

Siehe auch „StackView anpassen“.

replaceExit : Transition

Diese Eigenschaft enthält den Übergang, der auf das Element angewendet wird, das den Stapel verlässt, wenn es durch ein anderes Element ersetzt wird.

Siehe auch „StackView anpassen“.

Dokumentation zu angehängten Eigenschaften

StackView.index : int [read-only attached]

Diese zugehörige Eigenschaft enthält den Stapelindex des Elements, an das sie angehängt ist, oder den Wert „ -1 “, falls sich das Element nicht in einem Stapel befindet.

StackView.status : enumeration [read-only attached]

Diese zugeordnete Eigenschaft enthält den Stapelstatus des Elements, an das sie angehängt ist, oder den Wert „ StackView.Inactive “, falls sich das Element nicht in einem Stapel befindet.

Mögliche Werte:

StackView.view : StackView [read-only attached]

Diese angehängte Eigenschaft enthält die Stack-Ansicht des Elements, an das sie angehängt ist, oder „ null “, falls sich das Element nicht in einem Stack befindet.

StackView.visible : bool [attached, since QtQuick.Controls 2.2 (Qt 5.9)]

Diese zugeordnete Eigenschaft übernimmt die Sichtbarkeit des Elements, an das sie angehängt ist. Der Wert entspricht dem Wert von „ Item::visible “.

Standardmäßig zeigt „ StackView “ eingehende Elemente an, sobald der „Enter“-Übergang beginnt, und blendet ausgehende Elemente aus, sobald der „Exit“-Übergang endet. Durch die explizite Festlegung dieser Eigenschaft lässt sich das Standardverhalten überschreiben, sodass Elemente, die sich unterhalb des obersten Elements befinden, sichtbar bleiben.

StackView {
    id: stackView
    property real offset: 10
    width: 100; height: 100

    initialItem: Component {
        id: page
        Rectangle {
            property real pos: StackView.index * stackView.offset
            property real hue: Math.random()
            color: Qt.hsla(hue, 0.5, 0.8, 0.6)
            border.color: Qt.hsla(hue, 0.5, 0.5, 0.9)
            StackView.visible: true
        }
    }

    pushEnter: Transition {
        id: pushEnter
        ParallelAnimation {
            PropertyAction { property: "x"; value: pushEnter.ViewTransition.item.pos }
            NumberAnimation { properties: "y"; from: pushEnter.ViewTransition.item.pos + stackView.offset; to: pushEnter.ViewTransition.item.pos; duration: 400; easing.type: Easing.OutCubic }
            NumberAnimation { property: "opacity"; from: 0; to: 1; duration: 400; easing.type: Easing.OutCubic }
        }
    }
    popExit: Transition {
        id: popExit
        ParallelAnimation {
            PropertyAction { property: "x"; value: popExit.ViewTransition.item.pos }
            NumberAnimation { properties: "y"; from: popExit.ViewTransition.item.pos; to: popExit.ViewTransition.item.pos + stackView.offset; duration: 400; easing.type: Easing.OutCubic }
            NumberAnimation { property: "opacity"; from: 1; to: 0; duration: 400; easing.type: Easing.OutCubic }
        }
    }

    pushExit: Transition {
        id: pushExit
        PropertyAction { property: "x"; value: pushExit.ViewTransition.item.pos }
        PropertyAction { property: "y"; value: pushExit.ViewTransition.item.pos }
    }
    popEnter: Transition {
        id: popEnter
        PropertyAction { property: "x"; value: popEnter.ViewTransition.item.pos }
        PropertyAction { property: "y"; value: popEnter.ViewTransition.item.pos }
    }
}

Diese Eigenschaft wurde in QtQuick.Controls 2.2 (Qt 5.9) eingeführt.

Dokumentation zu den zugehörigen Signalen

[attached, since QtQuick.Controls 2.1 (Qt 5.8)] activated()

Dieses angehängte Signal wird ausgelöst, wenn das Element, an das es angehängt ist, im Stack aktiviert wird.

Dieses Signal wurde in QtQuick.Controls 2.1 (Qt 5.8) eingeführt.

Siehe auch status.

[attached, since QtQuick.Controls 2.1 (Qt 5.8)] activating()

Dieses angehängte Signal wird ausgelöst, wenn das Element, an das es angehängt ist, gerade im Stapel aktiviert wird.

Dieses Signal wurde in QtQuick.Controls 2.1 (Qt 5.8) eingeführt.

Siehe auch status.

[attached, since QtQuick.Controls 2.1 (Qt 5.8)] deactivated()

Dieses angehängte Signal wird ausgelöst, wenn das Element, an das es angehängt ist, im Stapel deaktiviert wird.

Dieses Signal wurde in QtQuick.Controls 2.1 (Qt 5.8) eingeführt.

Siehe auch status.

[attached, since QtQuick.Controls 2.1 (Qt 5.8)] deactivating()

Dieses angehängte Signal wird ausgelöst, wenn das Element, an das es angehängt ist, gerade im Stapel deaktiviert wird.

Dieses Signal wurde in QtQuick.Controls 2.1 (Qt 5.8) eingeführt.

Siehe auch status.

[attached, since QtQuick.Controls 2.1 (Qt 5.8)] removed()

Dieses angehängte Signal wird ausgelöst, wenn das Element, an das es angehängt ist, vom Stapel entfernt wurde. Es kann verwendet werden, um ein Element, das auf den Stapel gelegt wurde, sicher zu löschen, zum Beispiel:

Item {
    StackView.onRemoved: destroy() // Will be destroyed sometime after this call.
}

Dieses Signal wurde in QtQuick.Controls 2.1 (Qt 5.8) eingeführt.

Siehe auch status.

Methodendokumentation

void clear(transition)

Entfernt alle Elemente aus dem Stapel.

Nur Elemente, die von „ StackView “ selbst erstellt wurden (aus einem „ Component “ oder „ url “), werden beim Entfernen aus dem Stapel zerstört. Weitere Informationen finden Sie unter Item Ownership.

Seit QtQuick.Controls 2.3 kann optional ein „ transition “ angegeben werden. Unterstützte Übergänge:

Item find(callback, behavior)

Suche nach einem bestimmten Element innerhalb des Stacks. Die Funktion „ callback “ wird für jedes Element im Stack aufgerufen (mit dem Element und dem Index als Argumente), bis die Callback-Funktion „ true “ zurückgibt. Der Rückgabewert ist das gefundene Element. Beispiel:

stackView.find(function(item, index) {
    return item.isTheOne
})

Unterstützte Werte für „ behavior “:

Item get(index, behavior)

Gibt das Element an der Position „ index “ im Stack zurück oder „ null “, wenn der Index außerhalb des zulässigen Bereichs liegt.

Unterstützte Werte für „ behavior “:

Item pop(item, operation)

Entnimmt ein oder mehrere Elemente vom Stapel. Gibt das zuletzt vom Stapel entfernte Element zurück.

Wenn das Argument „ item “ angegeben wird, werden alle Elemente bis einschließlich „ item “ (jedoch nicht das Element selbst) entfernt. Wenn „ item “ gleich „ null “ ist, werden alle Elemente bis einschließlich des ersten Elements (jedoch nicht das Element selbst) entfernt. Wenn kein Argument angegeben wird, wird nur das aktuelle Element entfernt.

Nur Elemente, die von „ StackView “ selbst erstellt wurden (aus einem „ Component “ oder „ url “), werden beim Entfernen zerstört. Weitere Informationen finden Sie unter Item Ownership.

Optional kann ein ` operation ` als letztes Argument angegeben werden. Unterstützte Operationen:

Wird keine Operation angegeben, wird „ PopTransition “ verwendet.

Beispiele:

stackView.pop()
stackView.pop(someItem, StackView.Immediate)
stackView.pop(StackView.Immediate)
stackView.pop(null)

Siehe auch „ clear()“, „ Popping Items “ und „ Unwinding Items via Pop “.

[since 6.7] Item popCurrentItem(operation)

Entnimmt „ currentItem “ vom Stapel. Gibt das zuletzt vom Stapel entfernte Element zurück oder „ null “, falls „ depth “ den Wert „ 1 “ hatte.

Nur Elemente, die „ StackView “ selbst erstellt hat (aus einem „ Component “ oder „ url “), werden beim Entnehmen zerstört. Weitere Informationen finden Sie unter Item Ownership.

Optional kann ein „ operation “ als letztes Argument angegeben werden. Unterstützte Operationen:

Wird keine Operation angegeben, wird „ PopTransition “ verwendet.

Diese Funktion entspricht „ popToIndex(stackView.currentIndex - 1) “.

Diese Methode wurde in Qt 6.7 eingeführt.

Siehe auch „ clear()“, „ Popping Items “ und „ Unwinding Items via Pop “.

[since 6.7] Item popToIndex(index, operation)

Entnimmt alle Elemente bis einschließlich (jedoch nicht einschließlich) index. Gibt das zuletzt vom Stapel entfernte Element zurück.

Liegt „ index “ außerhalb des zulässigen Bereichs, wird eine Warnung ausgegeben und „ null “ zurückgegeben.

Nur Elemente, die von „ StackView “ selbst erstellt wurden (aus einem „ Component “ oder „ url “), werden beim Entnehmen zerstört. Weitere Informationen finden Sie unter Item Ownership.

Optional kann ein ` operation ` als letztes Argument angegeben werden. Unterstützte Operationen:

Wenn keine Operation angegeben wird, wird „ PopTransition “ verwendet.

stackView.popToIndex(stackView.depth - 2, StackView.Immediate)

Diese Methode wurde in Qt 6.7 eingeführt.

Siehe auch „ clear()“, „ Popping Items “ und „ Unwinding Items via Pop “.

[since 6.7] Item popToItem(item, operation)

Entnimmt alle Elemente bis einschließlich (aber nicht einschließlich) item. Gibt das zuletzt vom Stapel entfernte Element zurück.

Wenn „ item “ gleich „ null “ ist, wird eine Warnung ausgegeben und „ null “ zurückgegeben.

Nur Elemente, die von „ StackView “ selbst erstellt wurden (aus einem „ Component “ oder „ url “), werden beim Entnehmen zerstört. Weitere Informationen finden Sie unter Item Ownership.

Optional kann ein ` operation ` als letztes Argument angegeben werden. Unterstützte Operationen:

Wenn keine Operation angegeben wird, wird „ PopTransition “ verwendet.

stackView.popToItem(someItem, StackView.Immediate)

Diese Methode wurde in Qt 6.7 eingeführt.

Siehe auch „ clear()“, „ Popping Items “ und „ Unwinding Items via Pop “.

Item push(item, properties, operation)

Schiebt ein „ item “ mithilfe eines optionalen „ operation “ auf den Stack und wendet optional eine Reihe von „ properties “ auf das Element an. Das Element kann ein „ Item “, ein „ Component “ oder ein „ url “ sein. Gibt das Element zurück, das nun aktuell ist.

StackView Erstellt automatisch eine Instanz, wenn das auf den Stapel geschobene Element ein „ Component “ oder ein „ url “ ist, und die Instanz wird zerstört, wenn sie vom Stapel entfernt wird. Weitere Informationen finden Sie unter Item Ownership.

Das optionale Argument ` properties ` gibt eine Zuordnung der anfänglichen Eigenschaftswerte für das auf den Stapel geschobene Element an. Bei dynamisch erstellten Elementen werden diese Werte vor Abschluss der Erstellung angewendet. Dies ist effizienter als das Setzen von Eigenschaftswerten nach der Erstellung, insbesondere wenn große Mengen an Eigenschaftswerten definiert werden, und ermöglicht zudem das Einrichten von Eigenschaftsbindungen (mithilfe von ` Qt.binding()`) vor der Erstellung des Elements.

Ein einzelnes Element hinzufügen:

stackView.push(rect)

// or with properties:
stackView.push(rect, {"color": "red"})

Es können mehrere Elemente gleichzeitig hinzugefügt werden, indem sie entweder als zusätzliche Argumente oder als Array übergeben werden. Das letzte Element wird zum aktuellen Element. Jedem Element kann eine Reihe von Eigenschaften folgen, die angewendet werden sollen.

Übergabe einer variablen Anzahl von Argumenten:

stackView.push(rect1, rect2, rect3)

// or with properties:
stackView.push(rect1, {"color": "red"}, rect2, {"color": "green"}, rect3, {"color": "blue"})

Ein Array von Elementen hinzufügen:

stackView.push([rect1, rect2, rect3])

// or with properties:
stackView.push([rect1, {"color": "red"}, rect2, {"color": "green"}, rect3, {"color": "blue"}])

Optional kann als letztes Argument ein „ operation “ angegeben werden. Unterstützte Operationen:

Wird keine Operation angegeben, wird „ Immediate “ verwendet, wenn der Stapel leer ist, andernfalls „ PushTransition “.

Siehe auch „ initialItem “ und „ Pushing Items “.

[since 6.7] Item pushItem(item, properties, operation)

Schiebt ein ` item ` auf den Stack und wendet dabei optional eine Reihe von ` properties` an, wobei die optionale ` operation` verwendet wird. Gibt das Element zurück, das nun aktuell ist (das letzte Element).

Optional kann ein ` operation ` als letztes Argument angegeben werden. Unterstützte Operationen:

Wird keine Operation angegeben, wird „ PushTransition “ verwendet.

Um mehrere Elemente auf den Stapel zu schieben, verwenden Sie „ pushItems()“.

Diese Methode wurde in Qt 6.7 eingeführt.

Siehe auch „ initialItem “ und „ Pushing Items “.

[since 6.7] Item pushItem(component, properties, operation)

Schiebt ein ` component ` auf den Stack und wendet dabei optional eine Reihe von ` properties` an, wobei die optionale ` operation` verwendet wird. Gibt das Element zurück, das zum aktuellen Element geworden ist (das letzte Element).

Optional kann ein ` operation ` als letztes Argument angegeben werden. Unterstützte Operationen:

Wird keine Operation angegeben, wird „ PushTransition “ verwendet.

Um mehrere Elemente auf den Stapel zu schieben, verwenden Sie „ pushItems()“.

Diese Methode wurde in Qt 6.7 eingeführt.

Siehe auch „ initialItem “ und „ Pushing Items “.

[since 6.7] Item pushItem(url, properties, operation)

Schiebt ein ` url ` auf den Stack und wendet dabei optional eine Reihe von ` properties` an, wobei die optionale ` operation` verwendet wird. Gibt das Element zurück, das zum aktuellen Element geworden ist (das letzte Element).

Optional kann ein ` operation ` als letztes Argument angegeben werden. Unterstützte Operationen:

Wird keine Operation angegeben, wird „ PushTransition “ verwendet.

Um mehrere Elemente auf den Stapel zu schieben, verwenden Sie „ pushItems()“.

Diese Methode wurde in Qt 6.7 eingeführt.

Siehe auch „ initialItem “ und „ Pushing Items “.

[since 6.7] Item pushItems(items, operation)

Fügt „ items “ mithilfe eines optionalen „ operation “ auf den Stack ein und wendet optional eine Reihe von Eigenschaften auf jedes Element an. „ items “ ist ein Array aus Elementen. Jedes Element kann ein „ Item “, „ Component “ oder „ url “ sein und kann von einem optionalen Eigenschaftenargument gefolgt werden (siehe unten). Gibt das Element zurück, das zum aktuellen Element geworden ist (das letzte Element).

StackView Erstellt automatisch eine Instanz, wenn das auf den Stapel gelegte Element ein ` Component ` oder ` url` ist, und die Instanz wird zerstört, wenn sie vom Stapel entfernt wird. Weitere Informationen finden Sie unter Item Ownership.

Die optionalen „properties“-Argumente folgen auf jedes Element und geben eine Zuordnung der anfänglichen Eigenschaftswerte an. Bei dynamisch erstellten Elementen werden diese Werte vor Abschluss der Erstellung angewendet. Dies ist effizienter als das Setzen von Eigenschaftswerten nach der Erstellung, insbesondere wenn große Mengen von Eigenschaftswerten definiert werden, und ermöglicht zudem die Einrichtung von Eigenschaftsbindungen (mithilfe von ` Qt.binding()`), bevor das Element erstellt wird.

stackView.push([item, rectComponent, Qt.resolvedUrl("MyItem.qml")])

// With properties:
stackView.pushItems([
    item, { "color": "red" },
    rectComponent, { "color": "green" },
    Qt.resolvedUrl("MyItem.qml"), { "color": "blue" }
])

// With properties for only some items:
stackView.pushItems([
    item, { "color": "yellow" },
    rectComponent
])

Optional kann als letztes Argument ein ` operation ` angegeben werden. Unterstützte Operationen:

Wenn keine Operation angegeben wird, wird „ PushTransition “ verwendet.

Um ein einzelnes Element einzufügen, verwenden Sie die entsprechende Funktion von „ pushItem “:

• pushItem(Element, Eigenschaften, Operation)
• pushItem(component, properties, operation)
• pushItem(URL, Eigenschaften, Operation)

Diese Methode wurde in Qt 6.7 eingeführt.

Siehe auch initialItem, pushItem und Pushing Items.

Item replace(target, item, properties, operation)

Ersetzt ein oder mehrere Elemente auf dem Stapel durch das angegebene ` item ` und optional ` operation` und wendet optional eine Reihe von ` properties ` auf das Element an. Das Element kann ein ` Item`, ` Component` oder ein ` url` sein. Gibt das Element zurück, das nun das aktuelle Element ist.

Nur Elemente, die StackView selbst erstellt hat (aus einem Component oder url), werden beim Entfernen zerstört. Weitere Informationen finden Sie unter Item Ownership.

Wenn das Argument „ target “ angegeben ist, werden alle Elemente bis hinunter zum Element „ target “ ersetzt. Ist „ target “ gleich „ null “, werden alle Elemente im Stapel ersetzt. Wird kein Argument angegeben, wird nur das oberste Element ersetzt.

StackView Erzeugt automatisch eine Instanz, wenn das zu ersetzende Element ein „ Component “ oder ein „ url “ ist. Das optionale Argument „ properties “ gibt eine Zuordnung der anfänglichen Eigenschaftswerte für das zu ersetzende Element an. Bei dynamisch erstellten Elementen werden diese Werte vor Abschluss der Erstellung angewendet. Dies ist effizienter als das Festlegen von Eigenschaftswerten nach der Erstellung, insbesondere wenn große Mengen von Eigenschaftswerten definiert sind, und ermöglicht zudem die Einrichtung von Eigenschaftsbindungen (mithilfe von ` Qt.binding()`) vor der Erstellung des Elements.

Das oberste Element ersetzen:

stackView.replace(rect)

// or with properties:
stackView.replace(rect, {"color": "red"})

Es können mehrere Elemente gleichzeitig ersetzt werden, indem sie entweder als zusätzliche Argumente oder als Array übergeben werden. Jedem Element kann eine Reihe von anzuwendenden Eigenschaften folgen.

Übergabe einer variablen Anzahl von Argumenten:

stackView.replace(rect1, rect2, rect3)

// or with properties:
stackView.replace(rect1, {"color": "red"}, rect2, {"color": "green"}, rect3, {"color": "blue"})

Ersetzen eines Arrays von Elementen:

stackView.replace([rect1, rect2, rect3])

// or with properties:
stackView.replace([rect1, {"color": "red"}, rect2, {"color": "green"}, rect3, {"color": "blue"}])

Optional kann als letztes Argument ein ` operation ` angegeben werden. Unterstützte Operationen:

Wird keine Operation angegeben, wird „ Immediate “ verwendet, wenn der Stapel leer ist, andernfalls „ ReplaceTransition “.

Das folgende Beispiel veranschaulicht die Verwendung von „push“- und „pop“-Übergängen mit „replace()“.

StackView {
    id: stackView

    initialItem: Component {
        id: page

        Page {
            Row {
                spacing: 20
                anchors.centerIn: parent

                Button {
                    text: "<"
                    onClicked: stackView.replace(page, StackView.PopTransition)
                }
                Button {
                    text: ">"
                    onClicked: stackView.replace(page, StackView.PushTransition)
                }
            }
        }
    }
}

Siehe auch push() und Replacing Items.

[since 6.7] Item replaceCurrentItem(items, operation)

Entnimmt „ currentItem “ vom Stapel und fügt „ items “ hinzu. Wenn das optionale Argument „ operation “ angegeben wird, wird der entsprechende Übergang verwendet. Jedem Element kann eine optionale Reihe von Eigenschaften folgen, die auf dieses Element angewendet werden. Gibt das Element zurück, das nun aktuell ist.

Die optionalen Eigenschaftenargumente folgen auf jedes Element und geben eine Zuordnung der anfänglichen Eigenschaftswerte an. Bei dynamisch erstellten Elementen werden diese Werte vor Abschluss der Erstellung angewendet. Dies ist effizienter als das Setzen von Eigenschaftswerten nach der Erstellung, insbesondere wenn große Mengen an Eigenschaftswerten definiert sind, und ermöglicht zudem die Einrichtung von Eigenschaftsbindungen (mithilfe von Qt.binding()) vor der Erstellung des Elements.

Nur Elemente, die von „ StackView “ selbst erstellt wurden (aus einem „ Component “ oder „ url “), werden beim Entfernen aus der Liste zerstört. Weitere Informationen finden Sie unter Item Ownership.

Optional kann ein ` operation ` als letztes Argument angegeben werden. Unterstützte Operationen:

Wenn keine Operation angegeben wird, wird „ ReplaceTransition “ verwendet.

stackView.replaceCurrentItem([item, rectComponent, Qt.resolvedUrl("MyItem.qml")])

// With properties:
stackView.replaceCurrentItem([
    item, { "color": "red" },
    rectComponent, { "color": "green" },
    Qt.resolvedUrl("MyItem.qml"), { "color": "blue" }
])

Um ein einzelnes Element einzufügen, verwenden Sie die entsprechende Überladung:

• replaceCurrentItem(Element, Eigenschaften, Operation)
• replaceCurrentItem(component, properties, operation)
• replaceCurrentItem(URL, Eigenschaften, Operation)

Diese Methode wurde in Qt 6.7 eingeführt.

Siehe auch push() und Replacing Items.

[since 6.7] Item replaceCurrentItem(item, properties, operation)

Entnimmt „ currentItem “ vom Stapel und fügt „ item “ hinzu. Wenn das optionale „ operation “ angegeben ist, wird der entsprechende Übergang verwendet. Wenn die optionalen „ properties “ angegeben sind, werden sie auf das Element angewendet. Gibt das Element zurück, das nun aktuell ist.

Nur Elemente, die StackView selbst erstellt hat (aus einem Component oder url), werden beim Entfernen vom Stapel zerstört. Weitere Informationen finden Sie unter Item Ownership.

Optional kann ein ` operation ` als letztes Argument angegeben werden. Unterstützte Operationen:

Wird keine Operation angegeben, wird „ ReplaceTransition “ verwendet.

Um mehrere Elemente auf den Stapel zu schieben, verwenden Sie „ replaceCurrentItem(items, operation)“.

Diese Methode wurde in Qt 6.7 eingeführt.

Siehe auch „ Replacing Items “.

[since 6.7] Item replaceCurrentItem(component, properties, operation)

Entnimmt „ currentItem “ vom Stapel und fügt „ component “ hinzu. Wenn der optionale Parameter „ operation “ angegeben ist, wird der entsprechende Übergang verwendet. Wenn die optionalen Parameter „ properties “ angegeben sind, werden sie auf das Element angewendet. Gibt das Element zurück, das nun aktuell ist.

Nur Elemente, die von „ StackView “ selbst erstellt wurden (aus einem „ Component “ oder „ url “), werden beim Entfernen vom Stapel zerstört. Weitere Informationen finden Sie unter „ Item Ownership “.

Optional kann ein ` operation ` als letztes Argument angegeben werden. Unterstützte Operationen:

Wenn keine Operation angegeben wird, wird „ ReplaceTransition “ verwendet.

Um mehrere Elemente auf den Stapel zu schieben, verwenden Sie „ replaceCurrentItem(items, operation)“.

Diese Methode wurde in Qt 6.7 eingeführt.

Siehe auch ` Replacing Items`.

[since 6.7] Item replaceCurrentItem(url, properties, operation)

Entnimmt „ currentItem “ vom Stapel und fügt „ url “ hinzu. Wenn das optionale „ operation “ angegeben ist, wird der entsprechende Übergang verwendet. Wenn die optionalen „ properties “ angegeben sind, werden sie auf das Element angewendet. Gibt das Element zurück, das nun aktuell ist.

Nur Elemente, die „ StackView “ selbst erstellt hat (aus einem „ Component “ oder „ url “), werden beim Entfernen vom Stapel zerstört. Weitere Informationen finden Sie unter „ Item Ownership “.

Optional kann ein ` operation ` als letztes Argument angegeben werden. Unterstützte Operationen:

Wenn keine Operation angegeben wird, wird „ ReplaceTransition “ verwendet.

Um mehrere Elemente auf den Stapel zu schieben, verwenden Sie „ replaceCurrentItem(items, operation)“.

Diese Methode wurde in Qt 6.7 eingeführt.

Siehe auch „ Replacing Items “.