StackView QML Type

Propose un modèle de navigation basé sur une pile. En savoir plus...

• 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 associées

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

Signaux associé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'informations interconnectées. Par exemple, une application de messagerie proposant des vues distinctes pour afficher la liste des derniers e-mails, consulter un e-mail spécifique et lister/afficher les pièces jointes. La vue de la liste des e-mails est ajoutée à la pile lorsque l'utilisateur ouvre un e-mail, puis retirée de la pile lorsqu'il choisit de revenir en arrière.

L'extrait de code suivant illustre un cas d'utilisation simple, dans lequel l'mainView est ajoutée à la pile puis retirée de celle-ci lorsque l'utilisateur clique 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 à 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 d'interface utilisateur similaire. La pile peut ensuite être utilisée en appelant ses méthodes de navigation. Le premier élément affiché dans la StackView est celui qui a été attribué à ` initialItem`, ou l’élément situé tout en 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()`. Celles-ci correspondent aux opérations classiques de la pile : « push » ajoute un élément en haut de la pile, « pop » retire l'élément du haut de la pile, et « replace » s'apparente à un « pop » suivi d'un « push », ce qui remplace l'élément du haut par le nouvel élément. L'élément situé tout en haut de la pile correspond à celui qui est visible à l'écran currently. Logiquement, « push » permet de naviguer vers l'avant ou plus en profondeur dans l'interface utilisateur de l'application, « pop » permet de naviguer vers l'arrière, et « replace » remplace l'currentItem.

Ajout d’éléments

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

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

Retrait d’éléments

Dans la continuité de l’exemple ci-dessus, l’élément situé tout en haut de la pile est supprimé à l’aide d’un appel à pop() :

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

Déroulement des éléments via Pop

Il est parfois nécessaire de remonter de plus d’une étape dans la pile. Par exemple, pour revenir à un élément « principal » ou à un é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 la méthode pop(). C’est ce qu’on appelle 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 plus qu’un seul élément, qui devient alors l’ currentItem. Pour revenir explicitement 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 désormais qu’un seul élément : [A].

Remplacer des éléments

replace Dans l’animation suivante, nous remplaçons l’élément du sommet par D:

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

Liens profonds

Le lien profond consiste à lancer une application dans un état particulier. Par exemple, une application de journal pourrait être lancée pour afficher un article spécifique, en contournant l’élément situé tout en haut. Dans le contexte de StackView, le lien profond désigne la capacité à modifier l’état de la pile, au point qu’il est possible d’ajouter un ensemble d’éléments en haut de la pile, ou de réinitialiser complètement la pile à un état donné.

L’API de lien profond dans StackView est identique à celle de la navigation de base. L’ajout d’un tableau à la place d’un élément unique ajoute tous les éléments de ce tableau à la pile. L’animation de transition ne s’applique toutefois qu’au dernier élément du tableau. La sémantique habituelle de la méthode ` push()` s’applique au lien profond : elle ajoute tout ce qui est poussé sur la pile.

Cela donne le résultat suivant, pour une 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] – aucune animation de transition pour l'ajout d'éléments, car la pile était vide.

Recherche d’éléments

Un élément pour lequel l’application ne dispose d’aucune référence peut être trouvé en appelant ` find()`. Cette méthode nécessite une fonction de rappel, qui est invoquée pour chaque élément de la pile (en commençant par le haut) 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 ; dans le cas contraire, ` null ` est renvoyé.

Le code ci-dessous recherche dans la pile un élément nommé « order_id » et remonte 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 à l’aide de ` 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 entrant et sortant. Ces animations définissent la manière dont l’élément entrant doit apparaître et dont l’élément sortant doit disparaître. Les animations peuvent être personnalisées en attribuant différentes valeurs à Transitions pour les propriétés pushEnter, pushExit, popEnter, popExit, replaceEnter et replaceExit de StackView.

L'extrait de code suivant définit une transition par fondu simple 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 ne prend en charge que les éléments qu’elle crée elle-même. Cela signifie qu’aucun élément poussé dans une StackView ne sera jamais détruit par celle-ci ; seuls les éléments que la StackView crée à partir de ` Components ` ou ` URLs ` sont détruits par la StackView. Pour illustrer cela, les messages de l’exemple ci-dessous ne s’afficheront que lorsque la StackView sera détruite, 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))
}

En revanche, les deux éléments créés à partir de l’URL et du composant dans l’exemple suivant seront détruits par la StackView lorsqu’ils en seront retirés :

Component {
    id: itemComponent

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

StackView {
    initialItem: "Item1.qml"

    Component.onCompleted: push(itemComponent)
}

Taille

StackView n’hérite pas d’une taille implicite des éléments qui y sont ajoutés. Cela signifie que l’utiliser comme « contentItem » d’une ` 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 dispose d’une taille dans cette situation :

• Définir les propriétés ` implicitWidth ` et ` implicitHeight ` sur le StackView lui-même.
• Définissez les propriétés ` implicitWidth ` et ` implicitHeight ` sur l’ Rectangle.
• Définissez les propriétés « contentWidth » et « contentHeight » de la boîte de dialogue.
• Définissez la taille de la boîte de dialogue.

Voir également Personnalisation de StackView, Navigation avec StackView, Contrôles de navigation, Contrôles de conteneur et Gestion du focus dans Qt Quick Controls.

Documentation sur les propriétés

busy : bool [read-only]

Cette propriété indique si une transition est en cours d'exécution.

currentItem : Item [read-only]

Cette propriété contient l'élément actuellement situé au sommet de la pile.

depth : int [read-only]

Cette propriété contient le nombre d'éléments actuellement placés dans 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 également depth.

initialItem : var

Cette propriété contient l'élément initial qui doit s'afficher lors de la création de l'StackView. L'élément initial peut être un Item, un Component ou un url. La spécification d'un élément initial revient à :

Component.onCompleted: stackView.push(myInitialItem)

Voir également push().

popEnter : Transition

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

Voir également Personnalisation deStackView.

popExit : Transition

Cette propriété contient la transition appliquée à l'élément qui quitte la pile lorsqu'il en est retiré.

Voir également Personnalisation deStackView.

pushEnter : Transition

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

Voir également Personnalisation deStackView.

pushExit : Transition

Cette propriété définit la transition appliquée à l'élément qui quitte la pile lorsqu'un autre élément y est ajouté.

Voir également Personnalisation deStackView.

replaceEnter : Transition

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

Voir également Personnalisation deStackView.

replaceExit : Transition

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

Voir également Personnalisation deStackView.

Documentation sur les propriétés associées

StackView.index : int [read-only attached]

Cette propriété associée contient l'index de la pile de l'élément auquel elle est associée, ou la valeur « -1 » si l'élément ne se trouve pas dans une pile.

StackView.status : enumeration [read-only attached]

Cette propriété associée contient l'état de la pile de l'élément auquel elle est associée, ou la valeur « StackView.Inactive » si l'élément ne fait pas partie d'une pile.

Valeurs disponibles :

StackView.view : StackView [read-only attached]

Cette propriété associée contient la vue « stack » de l'élément auquel elle est associée, ou la valeur « null » si l'élément ne fait pas partie d'une pile.

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

Cette propriété associée reprend la visibilité de l'élément auquel elle est associée. Sa valeur suit celle de la propriété « 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 de remplacer 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 relative aux signaux associés

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

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

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

Voir également status.

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

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

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

Voir également status.

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

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

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

Voir également status.

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

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

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

Voir également status.

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

Ce signal est émis lorsque l'élément auquel il est associé a été retiré de la pile. Il peut être utilisé pour détruire en toute sécurité un élément qui avait été ajouté à 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 également status.

Documentation des méthodes

void clear(transition)

Supprime tous les éléments de la pile.

Seuls les éléments créés par StackView lui-même (à partir d’un Component ou d’un url) seront détruits lors de leur retrait. Voir Item Ownership pour plus d’informations.

Depuis la version QtQuick.Controls 2.3, il est possible de spécifier en option une transition. 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 renvoyée correspond à l'élément trouvé. Par exemple :

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

Valeurs prises en charge pour ` behavior ` :

Item get(index, behavior)

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

Valeurs d'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’à (sans inclure) « item » sont retirés. Si « item » vaut « null », tous les éléments jusqu’à (sans inclure) le premier élément sont retirés. S’il n’est pas spécifié, seul l’élément actuel est retiré.

StackView Seuls les éléments créés par la pile elle-même (à partir d’un ` Component ` ou d’un ` url`) seront détruits lorsqu’ils sont retiré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, PopTransition sera utilisé.

Exemples :

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

Voir également 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 créés par StackView elle-même (à partir d’un Component ou d’un url) seront détruits lors de leur suppression. 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, la fonction « PopTransition » sera utilisée.

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

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

Voir également ` clear()`, ` Popping Items` et ` Unwinding Items via Pop`.

[since 6.7] Item popToIndex(index, operation)

Retire tous les éléments jusqu'à (sans inclure) index. Renvoie le dernier élément retiré de la pile.

Si index est hors limites, un avertissement est généré et null est renvoyé.

Seuls les éléments créés par « StackView » lui-même (à partir d’un « Component » ou d’un « url ») seront détruits lors de leur extraction. 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, la méthode ` PopTransition ` sera utilisée.

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

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

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

[since 6.7] Item popToItem(item, operation)

Déplace tous les éléments vers le bas jusqu'à (sans inclure) item. Renvoie le dernier élément retiré de la pile.

Si item est null, un avertissement est généré et null est renvoyé.

Seuls les éléments créés par StackView lui-même (à partir d’un Component ou d’un url) seront détruits lors de leur extraction. 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, la méthode « PopTransition » sera utilisée.

stackView.popToItem(someItem, StackView.Immediate)

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

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

Item push(item, properties, operation)

Ajoute un objet ` item ` à la pile à l'aide d'un ` operation` facultatif, et applique éventuellement un ensemble de ` properties ` à cet élément. L'élément peut être un ` Item`, un ` Component` ou un ` url`. Renvoie l'élément qui est devenu l'élément courant.

StackView Crée automatiquement une instance si l’élément poussé est un Component ou un url; cette instance sera détruite lorsqu’elle sera retirée de la pile. Voir Item Ownership pour plus d’informations.

L’argument facultatif properties spécifie une carte des valeurs initiales des propriétés de l’élément ajouté à la pile. 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 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 permet également de configurer les liaisons de propriétés (à l’aide de ` Qt.binding()`) avant la création de l’élément.

Ajout d’un seul élément :

stackView.push(rect)

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

Il est possible d’ajouter plusieurs éléments simultanément, soit en les passant en tant qu’arguments supplémentaires, soit sous forme de tableau. Le dernier élément devient l’élément actif. Chaque élément peut être suivi d’un ensemble de propriétés à appliquer.

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

Ajout d’un tableau d’éléments :

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

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

Un « operation » peut être spécifié de manière facultative en tant que 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)

Ajoute un élément « item » à la pile, en appliquant éventuellement un ensemble d'properties, à l'aide du paramètre facultatif « operation ». Renvoie l'élément devenu actif (le dernier élément).

Un ` operation ` peut être spécifié de manière facultative en tant que dernier argument. Opérations prises en charge :

Si aucune opération n'est fournie, la fonction « PushTransition » sera utilisée.

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

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

Voir également « initialItem » et « Pushing Items ».

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

Ajoute un élément « component » à la pile, en appliquant éventuellement un ensemble d’ properties, à l’aide de la fonction optionnelle operation. Renvoie l’élément devenu « current » (le dernier élément).

Un operation peut être spécifié de manière facultative en tant que dernier argument. Opérations prises en charge :

Si aucune opération n'est fournie, la fonction « PushTransition » sera utilisée.

Pour ajouter plusieurs éléments à 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)

Ajoute un élément de type ` url ` à la pile, en appliquant éventuellement un ensemble d’ properties, à l’aide de l’argument facultatif ` operation`. Renvoie l’élément qui est devenu l’élément courant (le dernier élément).

Un ` operation ` peut être spécifié de manière facultative en tant que dernier argument. Opérations prises en charge :

Si aucune opération n'est fournie, la fonction ` PushTransition ` sera utilisée.

Pour ajouter plusieurs éléments à 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)

Ajoute items à la pile à l'aide d'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 un Item, Component ou url et peut être suivi d'un argument de propriétés facultatif (voir ci-dessous). Renvoie l'élément devenu actif (le dernier élément).

StackView Crée automatiquement une instance si l’élément ajouté est un Component ou un url; cette instance sera détruite lorsqu’elle sera retirée de la pile. Voir Item Ownership pour plus d’informations.

Les arguments facultatifs « properties » suivent chaque élément et spécifient une carte des valeurs initiales des propriétés. 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 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 permet également de configurer des 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
])

Une fonction ` operation ` peut être spécifiée de manière facultative en tant que dernier argument. Opérations prises en charge :

Si aucune opération n’est fournie, la fonction « PushTransition » sera utilisée.

Pour ajouter un élément unique, 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 également initialItem, pushItem et Pushing Items.

Item replace(target, item, properties, operation)

Remplace un ou plusieurs éléments de la pile par l'item spécifié et l'operation facultatif, 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 devenu actif.

Seuls les éléments créés par StackView lui-même (à partir d’un Component ou d’un url) seront détruits lorsqu’ils sont retiré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. S'il n'est pas spécifié, seul l'élément du haut sera remplacé.

StackView crée automatiquement une instance si l’élément de remplacement est un ` Component` ou un ` url`. L’argument facultatif ` properties ` spécifie une carte des valeurs initiales des propriétés pour l’élément de remplacement. 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 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 permet également de configurer des liaisons de propriétés (à l’aide de ` Qt.binding()`) avant la création de l’élément.

Remplacer l’élément du haut :

stackView.replace(rect)

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

Plusieurs éléments peuvent être remplacés simultanément, soit en les transmettant en tant qu’arguments supplémentaires, soit sous forme de tableau. Chaque élément peut être suivi d’un ensemble de propriétés à appliquer.

Transmission 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é de manière facultative en tant que 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 la fonction `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 y ajoute items. Si l'argument facultatif operation est spécifié, la transition correspondante sera utilisée. Chaque élément peut être suivi d'un ensemble facultatif de propriétés qui seront appliquées à cet élément. Renvoie l'élément qui est devenu l'élément actif.

Les arguments de propriétés facultatifs viennent après chaque élément et spécifient une carte des valeurs initiales des propriétés. 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 de définir les 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 configurer des liaisons de propriétés (à l’aide de ` Qt.binding()`) avant la création de l’élément.

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

Un operation peut être spécifié de manière facultative en tant que dernier argument. Opérations prises en charge :

Si aucune opération n'est fournie, l'opération « ReplaceTransition » sera utilisée.

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 également push() et Replacing Items.

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

Retire currentItem de la pile et y ajoute item. Si l'argument facultatif operation est spécifié, la transition correspondante sera utilisée. Si les arguments facultatifs properties sont spécifiés, ils seront appliqués à l'élément. Renvoie l'élément qui est devenu l'élément actif.

Seuls les éléments que ` StackView ` a lui-même créés (à partir d’un ` Component ` ou d’un ` url`) seront détruits lors de leur retrait. 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, l'opération « ReplaceTransition » sera utilisée.

Pour pousser plusieurs éléments sur la pile, utilisez ` replaceCurrentItem(items, operation)`.

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

Voir également Replacing Items.

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

Retire currentItem de la pile et y ajoute component. Si l'argument facultatif operation est spécifié, la transition correspondante sera utilisée. Si les arguments facultatifs properties sont spécifiés, ils seront appliqués à l'élément. Renvoie l'élément devenu actif.

Seuls les éléments créés par StackView lui-même (à partir d’un Component ou d’un url) seront détruits lors de leur retrait. 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, l'opération « ReplaceTransition » sera utilisée.

Pour pousser plusieurs éléments sur la pile, utilisez ` replaceCurrentItem(items, operation)`.

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

Voir également Replacing Items.

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

Retire currentItem de la pile et y ajoute url. Si l'argument facultatif operation est spécifié, la transition correspondante sera utilisée. Si les arguments facultatifs properties sont spécifiés, ils seront appliqués à l'élément. Renvoie l'élément qui est devenu l'élément actif.

Seuls les éléments créés par StackView lui-même (à partir d’un Component ou d’un url) seront détruits lors de leur retrait. Voir Item Ownership pour plus d’informations.

Un operation peut être spécifié de manière facultative comme dernier argument. Opérations prises en charge :

Si aucune opération n'est fournie, l'opération « ReplaceTransition » sera utilisée.

Pour pousser plusieurs éléments sur la pile, utilisez replaceCurrentItem(items, operation).

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

Voir également Replacing Items.