StackView QML Type

Fournit un modèle de navigation basé sur les piles. Plus d'informations...

• Liste de tous les membres, y compris les membres hérités

Propriétés

• 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

Propriétés rattachées

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

Signaux attachés

• 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))

Méthodes

• 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)

Description détaillée

StackView peut être utilisé avec un ensemble de pages d'information reliées entre elles. Par exemple, une application de messagerie électronique avec des vues distinctes pour lister les derniers courriels, visualiser un courriel spécifique et lister/visualiser les pièces jointes. L'affichage de la liste des courriels est poussé dans la pile lorsque les utilisateurs ouvrent un courriel, et en ressort lorsqu'ils choisissent de revenir en arrière.

L'extrait suivant illustre un cas d'utilisation simple, dans lequel le site mainView est poussé dans la pile et en ressort lors d'un clic sur le bouton correspondant :

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

Utilisation de StackView dans une application

L'utilisation de StackView dans une application est aussi simple que de l'ajouter en tant qu'enfant d'une fenêtre. La pile est généralement ancrée aux bords de la fenêtre, sauf en haut ou en bas, où elle peut être ancrée à une barre d'état ou à un autre composant similaire de l'interface utilisateur. La pile peut ensuite être utilisée en invoquant ses méthodes de navigation. Le premier élément à s'afficher dans le StackView est celui qui a été attribué à initialItem, ou l'élément le plus haut si initialItem n'est pas défini.

Navigation de base

StackView prend en charge trois opérations de navigation principales : push(), pop() et replace(). Ces opérations correspondent aux opérations de pile classiques : "push" ajoute un élément au sommet de la pile, "pop" retire l'élément supérieur de la pile et "replace" est comme un pop suivi d'un push, qui remplace l'élément supérieur par le nouvel élément. L'élément le plus haut de la pile correspond à celui qui est visible à l'écran ( currently ). Logiquement, "push" permet de naviguer vers l'avant ou plus profondément dans l'interface utilisateur de l'application, "pop" permet de naviguer vers l'arrière et "replace" remplace l'élément currentItem.

Pousser des éléments

Dans l'animation suivante, trois contrôles Label sont poussés sur une vue en pile à l'aide de la fonction push() :

La pile contient maintenant les éléments suivants : [A, B, C].

Extraction d'éléments

Dans la continuité de l'exemple précédent, l'élément le plus haut de la pile est supprimé par un appel à pop() :

La pile contient maintenant les éléments suivants : [A, B].

Déroulement des éléments via Pop

Il est parfois nécessaire de revenir en arrière de plus d'un pas dans la pile. Par exemple, pour revenir à un élément "principal" ou à une sorte d'élément de section dans l'application. Dans ce cas, il est possible de spécifier un élément en tant que paramètre de pop(). Il s'agit d'une opération de "déroulement", au cours de laquelle la pile se déroule jusqu'à l'élément spécifié. Si l'élément n'est pas trouvé, la pile se déroule jusqu'à ce qu'il ne reste qu'un seul élément, qui devient currentItem. Pour dérouler explicitement jusqu'au bas de la pile, il est recommandé d'utiliser pop(null), bien que n'importe quel élément inexistant fasse l'affaire.

Dans l'animation suivante, nous déroulons la pile jusqu'au premier élément en appelant pop(null):

La pile ne contient plus qu'un seul élément : [A].

Remplacement des éléments

Dans l'animation suivante, nous replace l'élément le plus haut en appelant D:

La pile contient maintenant les éléments suivants : [A, B, D].

Lien profond

Laliaison profonde consiste à lancer une application dans un état particulier. Par exemple, une application de journal peut être lancée pour afficher un article particulier, sans passer par l'élément le plus haut. En ce qui concerne StackView, l'établissement de liens profonds signifie la possibilité de modifier l'état de la pile, à tel point qu'il est possible de pousser un ensemble d'éléments au sommet de la pile ou de réinitialiser complètement la pile à un état donné.

L'API pour la liaison profonde dans StackView est la même que pour la navigation de base. Pousser un tableau au lieu d'un seul élément ajoute tous les éléments de ce tableau à la pile. L'animation de transition n'est toutefois appliquée qu'au dernier élément du tableau. La sémantique normale de push() s'applique à la liaison profonde, c'est-à-dire qu'elle ajoute tout ce qui est poussé sur la pile.

Cela nous donne le résultat suivant, étant donné la pile [A, B, C] :

• push([D, E, F]) => [A, B, C, D, E, F] - animation de transition "push" entre C et F
• replace([D, E, F]) => [A, B, D, E, F] - animation de transition "replace" entre C et F
• clear() suivi de push([D, E, F]) => [D, E, F] - pas d'animation de transition pour pousser les éléments car la pile est vide.

Recherche d'éléments

Un élément pour lequel l'application n'a pas de référence peut être trouvé en appelant find(). La méthode nécessite une fonction de rappel, qui est invoquée pour chaque élément de la pile (en commençant par le sommet) jusqu'à ce qu'une correspondance soit trouvée. Si la fonction de rappel renvoie true, find() s'arrête et renvoie l'élément correspondant, sinon null est renvoyé.

Le code ci-dessous recherche dans la pile un élément nommé "order_id" et se déroule jusqu'à cet élément.

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

Vous pouvez également accéder à un élément de la pile en utilisant get(index).

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

Transitions

Pour chaque opération "push" ou "pop", différentes animations de transition sont appliquées aux éléments entrants et sortants. Ces animations définissent la façon dont l'élément entrant doit être animé et l'élément sortant doit être animé. Les animations peuvent être personnalisées en attribuant différents Transitions aux propriétés pushEnter, pushExit, popEnter, popExit, replaceEnter et replaceExit de StackView.

L'extrait suivant définit une simple transition en fondu pour les opérations "push" et "pop" :

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

Propriété des éléments

StackView n'est propriétaire que des éléments qu'il crée lui-même. Cela signifie que tout élément poussé sur un StackView ne sera jamais détruit par le StackView ; seuls les éléments que le StackView crée à partir de Components ou URLs sont détruits par le StackView. Pour illustrer cela, les messages de l'exemple ci-dessous ne seront imprimés que lorsque le StackView sera détruit, et non lorsque les éléments seront retirés de la pile :

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))
}

Cependant, les deux éléments créés à partir de l'URL et du composant dans l'exemple suivant seront détruits par le StackView lorsqu'ils en seront extraits :

Component {
    id: itemComponent

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

StackView {
    initialItem: "Item1.qml"

    Component.onCompleted: push(itemComponent)
}

Taille

Le StackView n'hérite pas d'une taille implicite des éléments qui sont poussés sur lui. Cela signifie que son utilisation en tant que contentItem d'un Dialog, par exemple, ne fonctionnera pas comme prévu :

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

Il existe plusieurs façons de s'assurer que StackView a une taille dans cette situation :

• Définissez implicitWidth et implicitHeight sur le StackView lui-même.
• Définissez implicitWidth et implicitHeight sur le site Rectangle.
• Définissez contentWidth et contentHeight sur le dialogue.
• Donnez une taille à la boîte de dialogue.

Voir aussi Personnaliser StackView, Naviguer avec StackView, Contrôles de navigation, Contrôles de conteneur, et Gestion du focus dans les contrôles Qt Quick .

Documentation sur les propriétés

busy : bool [read-only]

Cette propriété indique si une transition est en cours.

currentItem : Item [read-only]

Cette propriété contient l'élément le plus élevé de la pile.

depth : int [read-only]

Cette propriété contient le nombre d'éléments actuellement poussés sur la pile.

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

Cette propriété indique si la pile est vide.

Cette propriété a été introduite dans QtQuick.Controls 2.3 (Qt 5.10).

Voir aussi depth.

initialItem : var

Cette propriété contient l'élément initial qui doit être affiché lorsque le site StackView est créé. L'élément initial peut être Item, Component ou url. La spécification d'un élément initial est équivalente à :

Component.onCompleted: stackView.push(myInitialItem)

Voir aussi push().

popEnter : Transition

Cette propriété définit la transition appliquée à l'élément qui entre dans la pile lorsqu'un autre élément en est extrait.

Voir aussi Personnaliser StackView.

popExit : Transition

Cette propriété contient la transition appliquée à l'élément qui sort de la pile lorsque l'élément en est extrait.

Voir aussi Personnaliser StackView.

pushEnter : Transition

Cette propriété contient la transition appliquée à l'élément qui entre dans la pile lorsqu'il y est poussé.

Voir aussi Personnaliser StackView.

pushExit : Transition

Cette propriété contient la transition appliquée à l'élément qui sort de la pile lorsqu'un autre élément y est poussé.

Voir aussi Personnaliser StackView.

replaceEnter : Transition

Cette propriété définit la transition appliquée à l'élément qui entre dans la pile lorsqu'il est remplacé par un autre élément.

Voir aussi Personnaliser StackView.

replaceExit : Transition

Cette propriété contient la transition appliquée à l'élément qui quitte la pile lorsqu'il est remplacé par un autre élément.

Voir aussi Personnalisation de StackView.

Documentation sur la propriété Attached

StackView.index : int [read-only]

Cette propriété attachée contient l'indice de pile de l'élément auquel elle est attachée, ou -1 si l'élément n'est pas dans une pile.

StackView.status : enumeration [read-only]

Cette propriété attachée contient l'état de la pile de l'élément auquel elle est attachée, ou StackView.Inactive si l'élément n'est pas dans une pile.

Valeurs disponibles :

StackView.view : StackView [read-only]

Cette propriété attachée contient la vue de pile de l'élément auquel elle est attachée, ou null si l'élément n'est pas dans une pile.

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

Cette propriété attachée contient la visibilité de l'élément auquel elle est attachée. Sa valeur suit celle de Item::visible.

Par défaut, StackView affiche les éléments entrants lorsque la transition d'entrée commence et masque les éléments sortants lorsque la transition de sortie se termine. La définition explicite de cette propriété permet d'outrepasser le comportement par défaut, ce qui permet de garder visibles les éléments situés en dessous de l'élément le plus haut.

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

Cette propriété a été introduite dans QtQuick.Controls 2.2 (Qt 5.9).

Documentation sur les signaux attachés

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

Ce signal attaché est émis lorsque l'élément auquel il est attaché est activé dans la pile.

Ce signal a été introduit dans QtQuick.Controls 2.1 (Qt 5.8).

Voir aussi status.

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

Ce signal attaché est émis lorsque l'élément auquel il est attaché est en cours d'activation dans la pile.

Ce signal a été introduit dans QtQuick.Controls 2.1 (Qt 5.8).

Voir aussi status.

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

Ce signal attaché est émis lorsque l'élément auquel il est attaché est désactivé dans la pile.

Ce signal a été introduit dans QtQuick.Controls 2.1 (Qt 5.8).

Voir aussi status.

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

Ce signal attaché est émis lorsque l'élément auquel il est attaché est en cours de désactivation dans la pile.

Ce signal a été introduit dans QtQuick.Controls 2.1 (Qt 5.8).

Voir aussi status.

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

Ce signal attaché est émis lorsque l'élément auquel il est attaché a été retiré de la pile. Il peut être utilisé pour détruire en toute sécurité un élément qui a été poussé sur la pile, par exemple :

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

Ce signal a été introduit dans QtQuick.Controls 2.1 (Qt 5.8).

Voir aussi status.

Documentation de la méthode

void clear(transition)

Supprime tous les éléments de la pile.

Seuls les éléments que StackView a créés lui-même (à partir d'un Component ou d'un url) seront détruits lorsqu'ils seront sortis de la pile. Voir Item Ownership pour plus d'informations.

Depuis QtQuick.Controls 2.3, un transition peut être spécifié en option. Transitions prises en charge :

Item find(callback, behavior)

Recherche d'un élément spécifique dans la pile. La fonction callback est appelée pour chaque élément de la pile (avec l'élément et l'index comme arguments) jusqu'à ce que la fonction de rappel renvoie true. La valeur de retour est l'élément trouvé. Par exemple, la valeur de retour est l'élément trouvé :

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

Valeurs behavior prises en charge :

Item get(index, behavior)

Renvoie l'élément situé à la position index dans la pile, ou null si l'index est hors limites.

Valeurs behavior prises en charge :

Item pop(item, operation)

Retire un ou plusieurs éléments de la pile. Renvoie le dernier élément retiré de la pile.

Si l'argument item est spécifié, tous les éléments jusqu'à item (non compris) seront extraits. Si item est null, tous les éléments jusqu'au premier élément (non compris) sont extraits. Si elle n'est pas spécifiée, seul l'élément courant est extrait.

Seuls les éléments que StackView a créés lui-même (à partir d'un Component ou d'un url) seront détruits lorsqu'ils seront extraits. Voir Item Ownership pour plus d'informations.

Un operation peut être spécifié en option comme dernier argument. Opérations supportées :

Si aucune opération n'est fournie, PopTransition sera utilisé.

Exemples :

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

Voir aussi clear(), Popping Items, et Unwinding Items via Pop.

[since 6.7] Item popCurrentItem(operation)

Retire currentItem de la pile. Renvoie le dernier élément retiré de la pile, ou null si depth était 1.

Seuls les éléments que StackView a créés lui-même (à partir d'un Component ou d'un url) sont détruits lorsqu'ils sont retirés de la pile. Voir Item Ownership pour plus d'informations.

Un operation peut être spécifié en option comme dernier argument. Opérations prises en charge :

Si aucune opération n'est fournie, PopTransition sera utilisé.

Cette fonction est équivalente à popToIndex(stackView.currentIndex - 1).

Cette méthode a été introduite dans Qt 6.7.

Voir aussi clear(), Popping Items, et Unwinding Items via Pop.

[since 6.7] Item popToIndex(index, operation)

Dépose tous les éléments jusqu'à (mais pas y compris) index. Renvoie le dernier élément retiré de la pile.

Si index est hors limites, un avertissement est produit et null est renvoyé.

Seuls les éléments que StackView a créés lui-même (à partir de Component ou url) seront détruits lorsqu'ils seront extraits. Voir Item Ownership pour plus d'informations.

Un operation peut être spécifié en option comme dernier argument. Opérations prises en charge :

Si aucune opération n'est fournie, PopTransition sera utilisé.

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

Cette méthode a été introduite dans Qt 6.7.

Voir aussi clear(), Popping Items, et Unwinding Items via Pop.

[since 6.7] Item popToItem(item, operation)

Retire tous les éléments de la pile jusqu'à (mais pas y compris) item. Retourne le dernier élément retiré de la pile.

Si item est null, un avertissement est produit et null est renvoyé.

Seuls les éléments que StackView a créés lui-même (à partir de Component ou url) seront détruits lorsqu'ils seront extraits. Voir Item Ownership pour plus d'informations.

Un operation peut être spécifié en option comme dernier argument. Opérations prises en charge :

Si aucune opération n'est fournie, PopTransition sera utilisé.

stackView.popToItem(someItem, StackView.Immediate)

Cette méthode a été introduite dans Qt 6.7.

Voir aussi clear(), Popping Items, et Unwinding Items via Pop.

Item push(item, properties, operation)

Pousse un item sur la pile à l'aide d'un operation optionnel, et applique éventuellement un ensemble de properties sur l'élément. L'élément peut être un Item, Component, ou un url. Retourne l'élément qui est devenu courant.

StackView crée une instance automatiquement si l'élément poussé est un Component, ou un url, et l'instance sera détruite lorsqu'elle sera retirée de la pile. Voir Item Ownership pour plus d'informations.

L'argument optionnel properties spécifie une carte de valeurs de propriétés initiales pour l'élément poussé. Pour les éléments créés dynamiquement, ces valeurs sont appliquées avant que la création ne soit finalisée. C'est plus efficace que de définir les valeurs des propriétés après la création, en particulier lorsque de grands ensembles de valeurs de propriétés sont définis, et cela permet également de définir les liaisons de propriétés (à l'aide de Qt.binding()) avant que l'élément ne soit créé.

Pousser un seul élément :

stackView.push(rect)

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

Plusieurs éléments peuvent être poussés en même temps, soit en les passant en tant qu'arguments supplémentaires, soit sous la forme d'un tableau. Le dernier élément devient l'élément courant. Chaque élément peut être suivi d'un ensemble de propriétés à appliquer.

Passage d'un nombre variable d'arguments :

stackView.push(rect1, rect2, rect3)

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

Pousser un tableau d'éléments :

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

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

Une adresse operation peut être spécifiée en option comme dernier argument. Opérations prises en charge :

Si aucune opération n'est fournie, Immediate sera utilisé si la pile est vide, et PushTransition dans le cas contraire.

Voir également initialItem et Pushing Items.

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

Pousse un item sur la pile, en appliquant éventuellement un ensemble de properties, en utilisant le operation optionnel. Renvoie l'élément qui est devenu courant (le dernier élément).

Un operation peut être optionnellement spécifié comme dernier argument. Opérations supportées :

Si aucune opération n'est fournie, PushTransition sera utilisé.

Pour pousser plusieurs éléments sur la pile, utilisez pushItems().

Cette méthode a été introduite dans Qt 6.7.

Voir aussi initialItem et Pushing Items.

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

Pousse un component sur la pile, en appliquant éventuellement un ensemble de properties, en utilisant l'option operation. Renvoie l'élément qui est devenu courant (le dernier élément).

Un operation peut être optionnellement spécifié comme dernier argument. Opérations supportées :

Si aucune opération n'est fournie, PushTransition sera utilisé.

Pour pousser plusieurs éléments sur la pile, utilisez pushItems().

Cette méthode a été introduite dans Qt 6.7.

Voir également initialItem et Pushing Items.

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

Pousse un url sur la pile, en appliquant éventuellement un ensemble de properties, en utilisant l'option operation. Renvoie l'élément qui est devenu courant (le dernier élément).

Un operation peut être optionnellement spécifié comme dernier argument. Opérations supportées :

Si aucune opération n'est fournie, PushTransition sera utilisé.

Pour pousser plusieurs éléments sur la pile, utilisez pushItems().

Cette méthode a été introduite dans Qt 6.7.

Voir également initialItem et Pushing Items.

[since 6.7] Item pushItems(items, operation)

Pousse items sur la pile en utilisant un argument facultatif operation, et applique éventuellement un ensemble de propriétés à chaque élément. items est un tableau d'éléments. Chaque élément peut être Item, Component, ou url et peut être suivi d'un argument facultatif de propriétés (voir ci-dessous). Renvoie l'élément qui est devenu courant (le dernier élément).

StackView crée automatiquement une instance si l'élément poussé est un Component ou un url, et l'instance sera détruite lorsqu'elle sera retirée de la pile. Voir Item Ownership pour plus d'informations.

Les arguments facultatifs de propriétés viennent après chaque élément et spécifient une carte de valeurs initiales de propriétés. Pour les éléments créés dynamiquement, ces valeurs sont appliquées avant que la création ne soit finalisée. C'est plus efficace que de définir les valeurs des propriétés après la création, en particulier lorsque de grands ensembles de valeurs de propriétés sont définis, et cela permet également de définir les liaisons de propriétés (à l'aide de Qt.binding()) avant la création de l'élément.

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
])

Un operation peut être spécifié en option comme dernier argument. Opérations prises en charge :

Si aucune opération n'est fournie, PushTransition sera utilisé.

Pour pousser un seul élément, utilisez la fonction pushItem correspondante :

• pushItem(élément, propriétés, opération)
• pushItem(composant, propriétés, opération)
• pushItem(url, propriétés, opération)

Cette méthode a été introduite dans Qt 6.7.

Voir aussi initialItem, pushItem, et Pushing Items.

Item replace(target, item, properties, operation)

Remplace un ou plusieurs éléments de la pile par l'élément spécifié item et l'élément facultatif operation, et applique éventuellement un ensemble de properties à l'élément. L'élément peut être un Item, un Component ou un url. Renvoie l'élément qui est devenu courant.

Seuls les éléments que StackView a créés lui-même (à partir d'un Component ou d'un url) seront détruits lorsqu'ils seront éjectés. Voir Item Ownership pour plus d'informations.

Si l'argument target est spécifié, tous les éléments jusqu'à l'élément target seront remplacés. Si target est null, tous les éléments de la pile seront remplacés. Si l'argument n'est pas spécifié, seul l'élément supérieur sera remplacé.

StackView crée automatiquement une instance si l'élément remplaçant est un Component ou un url. L'argument facultatif properties spécifie une carte des valeurs initiales des propriétés de l'élément remplaçant. Pour les éléments créés dynamiquement, ces valeurs sont appliquées avant que la création ne soit finalisée. Cette méthode est plus efficace que la définition des valeurs de propriété après la création, en particulier lorsque de grands ensembles de valeurs de propriété sont définis, et permet également de définir les liaisons de propriété (à l'aide de Qt.binding()) avant la création de l'élément.

Remplacer l'élément supérieur :

stackView.replace(rect)

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

Plusieurs éléments peuvent être remplacés en même temps, soit en les passant en tant qu'arguments supplémentaires, soit en tant que tableau. Chaque élément peut être suivi d'un ensemble de propriétés à appliquer.

Passage d'un nombre variable d'arguments :

stackView.replace(rect1, rect2, rect3)

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

Remplacement d'un tableau d'éléments :

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

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

Un operation peut être spécifié en option comme dernier argument. Opérations prises en charge :

Si aucune opération n'est fournie, Immediate sera utilisé si la pile est vide, et ReplaceTransition dans le cas contraire.

L'exemple suivant illustre l'utilisation des transitions push et pop avec 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)
                }
            }
        }
    }
}

Voir également push() et Replacing Items.

[since 6.7] Item replaceCurrentItem(items, operation)

Retire currentItem de la pile et pousse items. Si l'option operation est spécifiée, la transition correspondante sera utilisée. Chaque élément peut être suivi d'un ensemble facultatif de propriétés qui lui seront appliquées. Retourne l'élément qui est devenu courant.

Les arguments facultatifs de propriétés viennent après chaque élément et spécifient une carte de valeurs initiales de propriétés. Pour les éléments créés dynamiquement, ces valeurs sont appliquées avant que la création ne soit finalisée. C'est plus efficace que de définir les valeurs des propriétés après la création, en particulier lorsque de grands ensembles de valeurs de propriétés sont définis, et cela permet également de définir les liaisons de propriétés (à l'aide de Qt.binding()) avant que l'élément ne soit créé.

Seuls les éléments que StackView a créés lui-même (à partir d'un Component ou d'un url) seront détruits lorsqu'ils seront éjectés. Voir Item Ownership pour plus d'informations.

Un operation peut être spécifié en option comme dernier argument. Opérations prises en charge :

Si aucune opération n'est fournie, ReplaceTransition sera utilisé.

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

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

Pour pousser un seul élément, utilisez la surcharge correspondante :

• replaceCurrentItem(élément, propriétés, opération)
• replaceCurrentItem(composant, propriétés, opération)
• replaceCurrentItem(url, propriétés, opération)

Cette méthode a été introduite dans Qt 6.7.

Voir aussi push() et Replacing Items.

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

Retire currentItem de la pile et pousse item. Si l'option operation est spécifiée, la transition correspondante sera utilisée. Si l'option properties est spécifiée, elle sera appliquée à l'élément. Renvoie l'élément qui est devenu courant.

Seuls les éléments que StackView a créés lui-même (à partir d'un Component ou d'un url) seront détruits lorsqu'ils seront éjectés. Voir Item Ownership pour plus d'informations.

Un operation peut être spécifié en option comme dernier argument. Opérations prises en charge :

Si aucune opération n'est fournie, ReplaceTransition sera utilisé.

Pour pousser plusieurs éléments sur la pile, utilisez replaceCurrentItem(éléments, opération).

Cette méthode a été introduite dans Qt 6.7.

Voir aussi Replacing Items.

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

Retire currentItem de la pile et pousse component. Si l'option operation est spécifiée, la transition correspondante sera utilisée. Si l'option properties est spécifiée, elle sera appliquée à l'élément. Renvoie l'élément qui est devenu courant.

Seuls les éléments que StackView a créés lui-même (à partir d'un Component ou d'un url) seront détruits lorsqu'ils seront éjectés. Voir Item Ownership pour plus d'informations.

Un operation peut être spécifié en option comme dernier argument. Opérations prises en charge :

Si aucune opération n'est fournie, ReplaceTransition sera utilisé.

Pour pousser plusieurs éléments sur la pile, utilisez replaceCurrentItem(éléments, opération).

Cette méthode a été introduite dans Qt 6.7.

Voir aussi Replacing Items.

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

Retire currentItem de la pile et pousse url. Si l'option operation est spécifiée, la transition correspondante sera utilisée. Si l'option properties est spécifiée, elle sera appliquée à l'élément. Renvoie l'élément qui est devenu courant.

Seuls les éléments que StackView a créés lui-même (à partir d'un Component ou d'un url) seront détruits lorsqu'ils seront éjectés. Voir Item Ownership pour plus d'informations.

Un operation peut être spécifié en option comme dernier argument. Opérations prises en charge :

Si aucune opération n'est fournie, ReplaceTransition sera utilisé.

Pour pousser plusieurs éléments sur la pile, utilisez replaceCurrentItem(éléments, opération).

Cette méthode a été introduite dans Qt 6.7.

Voir aussi Replacing Items.