StackView QML Type

Bietet ein stapelbasiertes Navigationsmodell. Mehr...

Import Statement:	`import QtQuick.Controls`
Inherits:	Control

Liste aller Mitglieder, einschließlich geerbter 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

Beigefügte 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)

Detaillierte Beschreibung

StackView kann mit einer Reihe von miteinander verknüpften Informationsseiten verwendet werden. Zum Beispiel eine E-Mail-Anwendung mit separaten Ansichten zur Auflistung der letzten E-Mails, zur Ansicht einer bestimmten E-Mail und zur Auflistung/Ansicht der Anhänge. Die Ansicht der E-Mail-Liste wird auf den Stapel geschoben, wenn der Benutzer eine E-Mail öffnet, und wieder herausgeklappt, wenn er zurückgehen möchte.

Das folgende Snippet zeigt einen einfachen Anwendungsfall, bei dem die mainView bei einem entsprechenden Schaltflächenklick auf den Stapel geschoben und wieder herausgezogen 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 normalerweise an den Rändern des Fensters verankert, außer oben oder unten, wo er an einer Statusleiste oder einer anderen ähnlichen UI-Komponente verankert werden kann. Der Stapel kann dann durch Aufrufen seiner Navigationsmethoden verwendet werden. Das erste Element, das in der StackView angezeigt wird, ist dasjenige, das initialItem zugewiesen wurde, oder das oberste Element, wenn initialItem nicht gesetzt ist.

StackView unterstützt drei primäre Navigationsoperationen: push(), pop(), und replace(). Diese entsprechen den klassischen Stapeloperationen, bei denen "push" ein Element an die Spitze eines Stapels hinzufügt, "pop" das oberste Element aus dem Stapel entfernt und "replace" wie ein "pop" gefolgt von einem "push" ist, das das oberste Element durch das neue Element ersetzt. Das oberste Element des Stapels ist dasjenige, das unter currently auf dem Bildschirm zu sehen ist. Logischerweise navigiert "push" vorwärts oder tiefer in die Benutzeroberfläche der Anwendung, "pop" navigiert rückwärts, und "replace" ersetzt die currentItem.

Elemente schieben

In der folgenden Animation werden drei Label Steuerelemente mit der Funktion push() auf eine Stapelansicht geschoben:

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

Hinweis: Wenn der Stapel leer ist, gibt es bei einer push()-Operation keine Übergangsanimation, da es nichts gibt, von dem aus der Übergang erfolgen kann (typischerweise beim Start der Anwendung).

Ausblenden von Elementen

In Fortsetzung des obigen Beispiels wird das oberste Element auf dem Stapel mit einem Aufruf von pop() entfernt:

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

Hinweis: Eine pop()-Operation auf einem Stapel mit der Tiefe 1 oder 0 bewirkt nichts. In solchen Fällen kann der Stack mit der Methode clear() geleert werden.

Abwickeln von Elementen über Pop

Manchmal ist es notwendig, mehr als nur einen Schritt im Stack zurückzugehen. Zum Beispiel, um zu einem "Haupt"-Element oder einer Art von Abschnittselement 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 Stack bis zu dem angegebenen Element abgewickelt wird. Wird das Element nicht gefunden, wird der Stapel so lange abgewickelt, bis nur noch ein Element übrig ist, das dann currentItem heißt. Um explizit bis zum unteren Ende des Stapels abzuwickeln, wird empfohlen, pop(null) zu verwenden, obwohl auch ein nicht vorhandenes 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].

Ersetzen von Elementen

In der folgenden Animation wird das oberste Element replace durch D ersetzt:

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

Deep Linking

Deep Linking bedeutet, dass eine Anwendung in einem bestimmten Zustand gestartet wird. Zum Beispiel könnte eine Zeitungsanwendung so gestartet werden, dass sie einen bestimmten Artikel anzeigt und dabei das oberste Element überspringt. In Bezug auf StackView bedeutet Deep Linking die Fähigkeit, den Zustand des Stapels zu verändern, so dass es möglich ist, eine Reihe von Elementen an die Spitze des Stapels zu schieben oder den Stapel vollständig auf einen bestimmten Zustand zurückzusetzen.

Die API für Deep Linking in StackView ist dieselbe wie für die grundlegende Navigation. Das Schieben eines Arrays anstelle eines einzelnen Elements fügt dem Stapel alle Elemente in diesem Array hinzu. Die Übergangsanimation wird jedoch nur auf das letzte Element im Array angewendet. Die normale Semantik von push() gilt für Deep Linking, d.h. es wird alles auf den Stack gelegt, was verschoben wurde.

Hinweis: Nur das letzte Element des Arrays wird geladen. Die restlichen Elemente werden nur bei Bedarf geladen, entweder bei nachfolgenden Aufrufen von pop oder bei der Anforderung, ein Element mit get() zu erhalten.

Mit dem Stapel [A, B, C] ergibt sich das folgende 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] - "replace"-Übergangsanimation zwischen C und F
clear() gefolgt von push([D, E, F]) => [D, E, F] - keine Übergangsanimation für das Schieben von Elementen, da der Stapel leer war.

Auffinden von Items

Ein Element, für das die Anwendung keine Referenz hat, kann durch den Aufruf von find() gefunden werden. Die Methode benötigt eine Callback-Funktion, die für jedes Element im Stapel (von oben beginnend) aufgerufen wird, bis eine Übereinstimmung gefunden wird. Wenn der Rückruf true zurückgibt, wird find() beendet und das übereinstimmende Element zurückgegeben, andernfalls wird null zurückgegeben.

Der folgende Code durchsucht den Stapel nach einem Element namens "order_id" und spult zu diesem Element zurück.

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

Sie können auch mit get(index) zu einem Element im Stapel gelangen.

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

Übergänge

Für jede Push- oder Pop-Operation werden unterschiedliche Übergangsanimationen auf die ein- und ausgehenden Elemente angewendet. Diese Animationen legen fest, wie das hereinkommende Element animiert werden soll und wie das herauskommende Element animiert werden soll. Die Animationen können angepasst werden, indem verschiedene Transitions für die Eigenschaften pushEnter, pushExit, popEnter, popExit, replaceEnter und replaceExit von StackView zugewiesen werden.

Hinweis: Die Übergangsanimationen wirken sich gegenseitig auf das Übergangsverhalten aus. Wenn Sie die Animation für eine Eigenschaft anpassen und die andere nicht, kann dies zu unerwarteten Ergebnissen führen.

Das folgende Snippet definiert einen einfachen Fade-Ü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
        }
    }
}

Hinweis: Die Verwendung von Ankern auf den Elementen, die zu einer StackView hinzugefügt werden, wird nicht unterstützt. Normalerweise animieren Push-, Pop- und Replace-Übergänge die Position, was bei der Anwendung von Ankern nicht möglich ist. Beachten Sie, dass dies nur für die Wurzel des Elements gilt. Die Verwendung von Ankern für seine Kinder funktioniert wie erwartet.

Element-Eigentum

StackView übernimmt nur das Eigentum an Elementen, die es selbst erstellt. Das bedeutet, dass jedes Element, das auf einen StackView geschoben wird, niemals vom StackView zerstört wird; nur Elemente, die der StackView von Components oder URLs erstellt, werden vom StackView zerstört. Um dies zu veranschaulichen, werden die Meldungen im folgenden Beispiel nur gedruckt, wenn die StackView zerstört wird, nicht aber, wenn die Elemente vom Stapel genommen 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 aus der URL und der Komponente erstellt werden, werden jedoch von der StackView zerstört, wenn sie vom Stapel genommen 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 Stack geschoben werden. Dies bedeutet, dass die Verwendung als contentItem eines Dialog nicht wie erwartet funktioniert:

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

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

Setzen Sie implicitWidth und implicitHeight auf die StackView selbst.
Setzen Sie implicitWidth und implicitHeight auf Rectangle.
Setzen Sie contentWidth und contentHeight auf den Dialog.
Geben Sie dem Dialog eine Größe.

Siehe auch Anpassen von StackView, Navigieren mit StackView, Navigations-Steuerelemente, Container-Steuerelemente und Fokus-Management in Qt Quick Controls.

Eigenschaft Dokumentation

busy : bool [read-only]

Diese Eigenschaft zeigt an, ob 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 aktuell auf den Stapel geschobenen Elemente.

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

Diese Eigenschaft zeigt an, ob der Stack 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 anfängliche Element, das angezeigt werden soll, wenn StackView erstellt wird. Das Anfangselement kann ein Item, Component oder url sein. Die Angabe eines Anfangselements ist äquivalent zu:

Component.onCompleted: stackView.push(myInitialItem)

Siehe auch push().

popEnter : Transition

Diese Eigenschaft enthält den Übergang, der auf das Element angewandt wird, das in den Stapel kommt, wenn ein anderes Element aus dem Stapel herausgenommen wird.

Siehe auch StackView anpassen.

popExit : Transition

Diese Eigenschaft enthält den Übergang, der auf das Element angewandt wird, das den Stapel verlässt, wenn das Element aus dem Stapel herausgezogen wird.

Siehe auch StackView anpassen.

pushEnter : Transition

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

Siehe auch StackView anpassen.

pushExit : Transition

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

Siehe auch StackView anpassen.

replaceEnter : Transition

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

Siehe auch StackView anpassen.

replaceExit : Transition

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

Siehe auch StackView anpassen.

Dokumentation der angehängten Eigenschaft

StackView.index : int [read-only]

Diese angehängte Eigenschaft enthält den Stapelindex des Elements, an das sie angehängt ist, oder -1, wenn sich das Element nicht in einem Stapel befindet.

StackView.status : enumeration [read-only]

Diese angehängte Eigenschaft enthält den Stapelstatus des Elements, an das sie angehängt ist, oder StackView.Inactive, wenn sich das Element nicht in einem Stapel befindet.

Verfügbare Werte:

Konstante	Beschreibung
`StackView.Inactive`	Das Element ist inaktiv (oder befindet sich nicht in einem Stapel).
`StackView.Deactivating`	Der Gegenstand wird gerade deaktiviert (abgehoben).
`StackView.Activating`	Der Artikel wird aktiviert (er wird der aktuelle Artikel).
`StackView.Active`	Das Element ist aktiv, d. h. es ist das aktuelle Element.

StackView.view : StackView [read-only]

Diese angehängte Eigenschaft enthält die Stapelansicht des Elements, an das sie angehängt ist, oder null, wenn sich das Element nicht in einem Stapel befindet.

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

Diese angehängte Eigenschaft enthält die Sichtbarkeit des Elements, an das sie angehängt ist. Der Wert folgt dem Wert von Item::visible.

Standardmäßig zeigt StackView eingehende Elemente an, wenn der Eingangsübergang beginnt, und blendet ausgehende Elemente aus, wenn der Ausgangsübergang endet. Durch explizites Setzen dieser Eigenschaft kann das Standardverhalten außer Kraft gesetzt werden, so dass auch Elemente unterhalb des obersten Elements sichtbar bleiben.

Hinweis: Die Standardübergänge der meisten Stile schieben ausgehende Elemente aus der Ansicht heraus und können auch ihre Deckkraft animieren. Um einen vollständigen Stapel von Elementen sichtbar zu halten, sollten Sie die transitions so anpassen, dass die darunter liegenden Elemente sichtbar sind.

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 zum angehängten Signal

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

Dieses angehängte Signal wird ausgegeben, wenn das Element, an das es angehängt ist, im Stapel aktiviert wird.

Hinweis: Der entsprechende Handler ist onActivated.

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

Siehe auch status.

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

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

Hinweis: Der entsprechende Handler ist onActivating.

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

Siehe auch status.

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

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

Hinweis: Der entsprechende Handler ist onDeactivated.

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

Siehe auch status.

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

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

Hinweis: Der entsprechende Handler ist onDeactivating.

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

Siehe auch status.

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

Dieses angehängte Signal wird ausgegeben, wenn der Gegenstand, an den es angehängt ist, vom Stapel entfernt wurde. Es kann z.B. verwendet werden, um ein Element, das auf den Stapel geschoben wurde, sicher zu zerstören:

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

Hinweis: Der entsprechende Handler ist onRemoved.

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

Siehe auch status.

Dokumentation der Methode

void clear(transition)

Entfernt alle Elemente vom Stapel.

Nur Elemente, die StackView selbst erstellt hat (von einem Component oder url), werden beim Popping zerstört. Siehe Item Ownership für weitere Informationen.

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

Konstante	Beschreibung
`StackView.Immediate`	Löscht den Stapel sofort und ohne Übergang (Standard).
`StackView.PushTransition`	Leert den Stapel mit einem Push-Übergang.
`StackView.ReplaceTransition`	Löscht den Stapel mit einem Replace-Übergang.
`StackView.PopTransition`	Den Stapel mit einem Pop-Übergang leeren.

Item find(callback, behavior)

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

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

Unterstützte behavior Werte:

Konstante	Beschreibung
`StackView.DontLoad`	Ungeladene Elemente werden übersprungen (die Callback-Funktion wird für sie nicht aufgerufen).
`StackView.ForceLoad`	Ungeladene Elemente werden zum Laden gezwungen.

Item get(index, behavior)

Gibt das Element an der Position index im Stack zurück, oder null, wenn der Index außerhalb der Grenzen liegt.

Unterstützte behavior Werte:

Konstante	Beschreibung
`StackView.DontLoad`	Das Element wird nicht zum Laden gezwungen (und `null` wird zurückgegeben, wenn es noch nicht geladen ist).
`StackView.ForceLoad`	Das Element wird zum Laden gezwungen.

Item pop(item, operation)

Entfernt ein oder mehrere Elemente vom Stapel. Gibt das letzte vom Stapel entfernte Element zurück.

Wenn das Argument item angegeben ist, werden alle Elemente bis (aber nicht einschließlich) item entfernt. Wenn item null ist, werden alle Elemente bis zum ersten Element (aber nicht einschließlich) entfernt. Wird nichts angegeben, wird nur das aktuelle Element herausgenommen.

Hinweis: Eine pop()-Operation auf einem Stapel mit der Tiefe 1 oder 0 bewirkt nichts. In solchen Fällen kann der Stapel mit der Methode clear() geleert werden.

Nur Elemente, die StackView selbst erstellt hat (aus Component oder url), werden beim Popping zerstört. Siehe Item Ownership für weitere Informationen.

Ein operation kann optional als letztes Argument angegeben werden. Unterstützte Operationen:

Konstante	Beschreibung
`StackView.Immediate`	Eine sofortige Operation ohne Übergänge.
`StackView.PushTransition`	Eine Operation mit Push-Übergängen (seit QtQuick.Controls 2.1).
`StackView.ReplaceTransition`	Eine Operation mit replace-Übergängen (seit QtQuick.Controls 2.1).
`StackView.PopTransition`	Eine Operation mit Pop-Übergängen (seit QtQuick.Controls 2.1).

Wenn keine Operation angegeben wird, wird PopTransition verwendet.

Beispiele:

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

Hinweis: Wenn Sie QML kompilieren, verwenden Sie stattdessen die stark typisierten Funktionen popToItem, popToIndex oder popCurrentItem.

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

[since 6.7] Item popCurrentItem(operation)

Entfernt currentItem vom Stapel. Gibt das letzte vom Stapel entfernte Element zurück, oder null, wenn depth 1 war.

Nur Elemente, die StackView selbst erstellt hat (aus Component oder url), werden zerstört, wenn sie entfernt werden. Siehe Item Ownership für weitere Informationen.

Ein operation kann optional als letztes Argument angegeben werden. Unterstützte Operationen:

Konstante	Beschreibung
`StackView.Immediate`	Eine sofortige Operation ohne Übergänge.
`StackView.PushTransition`	Eine Operation mit Push-Übergängen.
`StackView.ReplaceTransition`	Eine Operation mit Replace-Übergängen.
`StackView.PopTransition`	Eine Operation mit Pop-Übergängen.

Wenn keine Operation angegeben wird, wird PopTransition verwendet.

Diese Funktion ist äquivalent zu 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)

Entfernt alle Elemente bis (aber nicht einschließlich) index. Gibt das letzte vom Stapel entfernte Element zurück.

Wenn index außerhalb der Grenzen liegt, wird eine Warnung ausgegeben und null zurückgegeben.

Nur Elemente, die StackView selbst erstellt hat (aus Component oder url), werden beim Popping zerstört. Siehe Item Ownership für weitere Informationen.

Ein operation kann optional als letztes Argument angegeben werden. Unterstützte Operationen:

Konstante	Beschreibung
`StackView.Immediate`	Eine sofortige Operation ohne Übergänge.
`StackView.PushTransition`	Eine Operation mit Push-Übergängen.
`StackView.ReplaceTransition`	Eine Operation mit Replace-Übergängen.
`StackView.PopTransition`	Eine Operation mit Pop-Übergängen.

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)

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

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

Nur Elemente, die StackView selbst erstellt hat (aus Component oder url), werden beim Popping zerstört. Siehe Item Ownership für weitere Informationen.

Ein operation kann optional als letztes Argument angegeben werden. Unterstützte Operationen:

Konstante	Beschreibung
`StackView.Immediate`	Eine sofortige Operation ohne Übergänge.
`StackView.PushTransition`	Eine Operation mit Push-Übergängen.
`StackView.ReplaceTransition`	Eine Operation mit Replace-Übergängen.
`StackView.PopTransition`	Eine Operation mit Pop-Übergängen.

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 mit einem optionalen operation auf den Stack und wendet optional einen Satz von properties auf das Element an. Das Element kann Item, Component oder url sein. Gibt das Element zurück, das aktuell wurde.

StackView erzeugt automatisch eine Instanz, wenn das geschobene Element ein Component oder ein url ist, und die Instanz wird zerstört, wenn sie vom Stapel genommen wird. Siehe Item Ownership für weitere Informationen.

Das optionale Argument properties gibt eine Zuordnung von anfänglichen Eigenschaftswerten für das geschobene Element an. Für dynamisch erstellte Elemente werden diese Werte angewendet, bevor die Erstellung abgeschlossen ist. Dies ist effizienter als das Festlegen von Eigenschaftswerten nach der Erstellung, insbesondere wenn große Mengen von Eigenschaftswerten definiert sind, und ermöglicht auch die Einrichtung von Eigenschaftsbindungen (unter Verwendung von Qt.binding()), bevor das Element erstellt wird.

Verschieben eines einzelnen Elements:

stackView.push(rect)

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

Mehrere Elemente können gleichzeitig verschoben werden, indem sie entweder als zusätzliche Argumente oder als Array übergeben werden. Das letzte Element wird das aktuelle Element. Jedem Element kann ein Satz 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"})

Übergabe eines Arrays von Elementen:

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

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

Ein operation kann optional als letztes Argument angegeben werden. Unterstützte Operationen:

Konstante	Beschreibung
`StackView.Immediate`	Eine sofortige Operation ohne Übergänge.
`StackView.PushTransition`	Eine Operation mit Push-Übergängen (seit QtQuick.Controls 2.1).
`StackView.ReplaceTransition`	Eine Operation mit replace-Übergängen (seit QtQuick.Controls 2.1).
`StackView.PopTransition`	Eine Operation mit Pop-Übergängen (seit QtQuick.Controls 2.1).

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

Hinweis: Elemente, die bereits auf dem Stack vorhanden sind, werden nicht verschoben.

Hinweis: Wenn Sie QML kompilieren, verwenden Sie stattdessen die stark typisierten Funktionen pushItem oder pushItems.

Siehe auch initialItem und Pushing Items.

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

Schiebt ein item auf den Stapel und wendet optional eine Reihe von properties an, wobei das optionale operation verwendet wird. Gibt das Element zurück, das aktuell wurde (das letzte Element).

Ein operation kann optional als letztes Argument angegeben werden. Unterstützte Operationen:

Konstante	Beschreibung
`StackView.Immediate`	Eine sofortige Operation ohne Übergänge.
`StackView.PushTransition`	Eine Operation mit Push-Übergängen.
`StackView.ReplaceTransition`	Eine Operation mit Replace-Übergängen.
`StackView.PopTransition`	Eine Operation mit Pop-Übergängen.

Wenn keine Operation angegeben wird, 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)

Diese Funktion überlastet pushItem().

Schiebt ein component auf den Stapel und wendet dabei optional einen Satz von properties an, unter Verwendung des optionalen operation. Gibt das Element zurück, das aktuell wurde (das letzte Element).

Ein operation kann optional als letztes Argument angegeben werden. Unterstützte Operationen:

Konstante	Beschreibung
`StackView.Immediate`	Eine sofortige Operation ohne Übergänge.
`StackView.PushTransition`	Eine Operation mit Push-Übergängen.
`StackView.ReplaceTransition`	Eine Operation mit Replace-Übergängen.
`StackView.PopTransition`	Eine Operation mit Pop-Übergängen.

Wenn keine Operation angegeben wird, 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)

Diese Funktion überlastet pushItem().

Schiebt ein url auf den Stapel und wendet dabei optional einen Satz von properties an, unter Verwendung des optionalen operation. Gibt das Element zurück, das aktuell wurde (das letzte Element).

Ein operation kann optional als letztes Argument angegeben werden. Unterstützte Operationen:

Konstante	Beschreibung
`StackView.Immediate`	Eine sofortige Operation ohne Übergänge.
`StackView.PushTransition`	Eine Operation mit Push-Übergängen.
`StackView.ReplaceTransition`	Eine Operation mit Replace-Übergängen.
`StackView.PopTransition`	Eine Operation mit Pop-Übergängen.

Wenn keine Operation angegeben wird, 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)

Schiebt items unter Verwendung eines optionalen operation auf den Stapel und wendet optional einen Satz von Eigenschaften auf jedes Element an. items ist ein Array von Elementen. Jedes Element kann ein Item, Component oder url sein und kann von einem optionalen Eigenschaftsargument gefolgt werden (siehe unten). Gibt das Element zurück, das aktuell wurde (das letzte Element).

StackView erzeugt automatisch eine Instanz, wenn das geschobene Element ein Component oder url ist, und die Instanz wird zerstört, wenn sie vom Stapel gepoppt wird. Siehe Item Ownership für weitere Informationen.

Die optionalen Eigenschaftsargumente kommen nach jedem Element und geben eine Karte der anfänglichen Eigenschaftswerte an. Bei dynamisch erstellten Elementen werden diese Werte angewendet, bevor die Erstellung abgeschlossen ist. Dies ist effizienter als das Festlegen von Eigenschaftswerten nach der Erstellung, insbesondere wenn große Mengen von Eigenschaftswerten definiert werden, und ermöglicht auch das Einrichten von Eigenschaftsbindungen (mit 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
])

Ein operation kann optional als letztes Argument angegeben werden. Unterstützte Operationen:

Konstante	Beschreibung
`StackView.Immediate`	Eine sofortige Operation ohne Übergänge.
`StackView.PushTransition`	Eine Operation mit Push-Übergängen.
`StackView.ReplaceTransition`	Eine Operation mit Replace-Übergängen.
`StackView.PopTransition`	Eine Operation mit Pop-Übergängen.

Wenn keine Operation angegeben wird, wird PushTransition verwendet.

Um ein einzelnes Element zu verschieben, verwenden Sie die entsprechende Funktion pushItem:

pushItem(Element, Eigenschaften, Vorgang)
pushItem(Komponente, Eigenschaften, Operation)
pushItem(url, properties, operation)

Hinweis: Elemente, die bereits im Stack vorhanden sind, werden nicht verschoben.

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 Stack mit dem angegebenen item und optional operation und wendet optional einen Satz von properties auf das Element an. Das Element kann Item, Component oder url sein. Gibt das Element zurück, das aktuell wurde.

Nur Elemente, die StackView selbst erstellt hat (aus einem Component oder url), werden zerstört, wenn sie gepoppt werden. Siehe Item Ownership für weitere Informationen.

Wenn das Argument target angegeben ist, werden alle Elemente bis zum Element target ersetzt. Wenn target gleich null ist, werden alle Elemente im Stapel ersetzt. Wenn nicht angegeben, wird nur das oberste Element ersetzt.

StackView erstellt automatisch eine Instanz, wenn das ersetzende Element ein Component oder ein url ist. Das optionale Argument properties gibt eine Zuordnung der anfänglichen Eigenschaftswerte für das ersetzende Element an. Für dynamisch erstellte Elemente werden diese Werte angewendet, bevor die Erstellung abgeschlossen ist. Dies ist effizienter als das Festlegen von Eigenschaftswerten nach der Erstellung, insbesondere wenn große Mengen von Eigenschaftswerten definiert sind, und ermöglicht außerdem die Einrichtung von Eigenschaftsbindungen (mit Qt.binding()), bevor das Element erstellt wird.

Ersetzen Sie das oberste Element:

stackView.replace(rect)

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

Mehrere Elemente können gleichzeitig ersetzt werden, indem sie als zusätzliche Argumente oder als Array übergeben werden. Jedem Element kann ein Satz von Eigenschaften folgen, die angewendet werden sollen.

Ü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"}])

Ein operation kann optional als letztes Argument angegeben werden. Unterstützte Operationen:

Konstante	Beschreibung
`StackView.Immediate`	Eine sofortige Operation ohne Übergänge.
`StackView.PushTransition`	Eine Operation mit Push-Übergängen (seit QtQuick.Controls 2.1).
`StackView.ReplaceTransition`	Eine Operation mit replace-Übergängen (seit QtQuick.Controls 2.1).
`StackView.PopTransition`	Eine Operation mit Pop-Übergängen (seit QtQuick.Controls 2.1).

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

Das folgende Beispiel illustriert 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)
                }
            }
        }
    }
}

Hinweis: Wenn Sie QML kompilieren, verwenden Sie stattdessen die stark typisierten replaceCurrentItem Funktionen.

Siehe auch push() und Replacing Items.

[since 6.7] Item replaceCurrentItem(items, operation)

Entfernt currentItem vom Stapel und schiebt items. Wenn das optionale operation angegeben ist, wird der entsprechende Übergang verwendet. Auf jedes Element kann ein optionaler Satz von Eigenschaften folgen, die auf dieses Element angewendet werden. Gibt das Element zurück, das aktuell wurde.

Die optionalen Eigenschaftsargumente stehen nach jedem Element und geben eine Zuordnung der anfänglichen Eigenschaftswerte an. Bei dynamisch erstellten Elementen werden diese Werte angewendet, bevor die Erstellung abgeschlossen ist. Dies ist effizienter als das Festlegen von Eigenschaftswerten nach der Erstellung, insbesondere wenn große Mengen von Eigenschaftswerten definiert werden, und ermöglicht außerdem das Einrichten von Eigenschaftsbindungen (mit Qt.binding()), bevor das Element erstellt wird.

Nur Elemente, die StackView selbst erstellt hat (aus einem Component oder url), werden beim Popping zerstört. Siehe Item Ownership für weitere Informationen.

Ein operation kann optional als letztes Argument angegeben werden. Unterstützte Operationen:

Konstante	Beschreibung
`StackView.Immediate`	Eine sofortige Operation ohne Übergänge.
`StackView.PushTransition`	Eine Operation mit Push-Übergängen.
`StackView.ReplaceTransition`	Eine Operation mit Replace-Übergängen.
`StackView.PopTransition`	Eine Operation mit Pop-Übergängen.

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 zu verschieben, verwenden Sie die entsprechende Überladung:

replaceCurrentItem(Element, Eigenschaften, Operation)
replaceCurrentItem(component, properties, operation)
replaceCurrentItem(url, properties, operation)

Diese Methode wurde in Qt 6.7 eingeführt.

Siehe auch push() und Replacing Items.

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

Diese Funktion überlastet replaceCurrentItem().

Entfernt currentItem vom Stapel und schiebt item. Wenn die Option 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 aktuell wurde.

Nur Elemente, die StackView selbst erstellt hat (aus einem Component oder url), werden beim Popping zerstört. Siehe Item Ownership für weitere Informationen.

Ein operation kann optional als letztes Argument angegeben werden. Unterstützte Operationen:

Konstante	Beschreibung
`StackView.Immediate`	Eine sofortige Operation ohne Übergänge.
`StackView.PushTransition`	Eine Operation mit Push-Übergängen.
`StackView.ReplaceTransition`	Eine Operation mit Replace-Übergängen.
`StackView.PopTransition`	Eine Operation mit Pop-Übergängen.

Wenn keine Operation angegeben wird, wird ReplaceTransition verwendet.

Um mehrere Elemente auf den Stapel zu schieben, verwenden Sie replaceCurrentItem(Elemente, Operation).

Diese Methode wurde in Qt 6.7 eingeführt.

Siehe auch Replacing Items.

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

Diese Funktion überlastet replaceCurrentItem().

Entfernt currentItem vom Stapel und schiebt component. Wenn die Option 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 aktuell wurde.

Nur Elemente, die StackView selbst erstellt hat (aus einem Component oder url), werden beim Popping zerstört. Siehe Item Ownership für weitere Informationen.

Ein operation kann optional als letztes Argument angegeben werden. Unterstützte Operationen:

Konstante	Beschreibung
`StackView.Immediate`	Eine sofortige Operation ohne Übergänge.
`StackView.PushTransition`	Eine Operation mit Push-Übergängen.
`StackView.ReplaceTransition`	Eine Operation mit Replace-Übergängen.
`StackView.PopTransition`	Eine Operation mit Pop-Übergängen.

Wenn keine Operation angegeben wird, wird ReplaceTransition verwendet.

Um mehrere Elemente auf den Stapel zu schieben, verwenden Sie replaceCurrentItem(Elemente, Operation).

Diese Methode wurde in Qt 6.7 eingeführt.

Siehe auch Replacing Items.

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

Diese Funktion überlastet replaceCurrentItem().

Entfernt currentItem vom Stapel und schiebt url ein. Wenn die Option 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 aktuell wurde.

Nur Elemente, die StackView selbst erstellt hat (aus einem Component oder url), werden beim Popping zerstört. Siehe Item Ownership für weitere Informationen.

Ein operation kann optional als letztes Argument angegeben werden. Unterstützte Operationen:

Konstante	Beschreibung
`StackView.Immediate`	Eine sofortige Operation ohne Übergänge.
`StackView.PushTransition`	Eine Operation mit Push-Übergängen.
`StackView.ReplaceTransition`	Eine Operation mit Replace-Übergängen.
`StackView.PopTransition`	Eine Operation mit Pop-Übergängen.

Wenn keine Operation angegeben wird, wird ReplaceTransition verwendet.

Um mehrere Elemente auf den Stapel zu schieben, verwenden Sie replaceCurrentItem(Elemente, Operation).

Diese Methode wurde in Qt 6.7 eingeführt.

Siehe auch Replacing Items.

© 2025 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.

StackView QML Type

Eigenschaften

Beigefügte Eigenschaften

Angehängte Signale

Methoden

Detaillierte Beschreibung

Verwendung von StackView in einer Anwendung

Grundlegende Navigation

Elemente schieben

Ausblenden von Elementen

Abwickeln von Elementen über Pop

Ersetzen von Elementen

Deep Linking

Auffinden von Items

Übergänge

Element-Eigentum

Größe

Eigenschaft Dokumentation

Dokumentation der angehängten Eigenschaft

Dokumentation zum angehängten Signal

Dokumentation der Methode