StackView QML Type

Proporciona un modelo de navegación basado en pilas. Más...

• Lista de todos los miembros, incluidos los heredados

Propiedades

• 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

Propiedades anexas

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

Señales adjuntas

• 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étodos

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

Descripción detallada

StackView se puede utilizar con un conjunto de páginas de información interconectadas. Por ejemplo, una aplicación de correo electrónico con vistas separadas para listar los últimos correos, ver un correo específico y listar/ver los adjuntos. La vista de la lista de correos electrónicos se coloca en la pila cuando los usuarios abren un correo electrónico y se retira cuando deciden volver atrás.

El siguiente fragmento muestra un caso de uso sencillo, en el que mainView se coloca y se retira de la pila al hacer clic en el botón correspondiente:

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

Uso de StackView en una aplicación

Utilizar StackView en una aplicación es tan simple como añadirlo como hijo de una ventana. La pila suele estar anclada a los bordes de la ventana, excepto en la parte superior o inferior, donde podría estar anclada a una barra de estado, o algún otro componente de interfaz de usuario similar. La pila puede utilizarse invocando sus métodos de navegación. El primer elemento que se muestra en la StackView es el que se asignó a initialItem, o el elemento superior si initialItem no está configurado.

Navegación básica

StackView soporta tres operaciones primarias de navegación: push(), pop(), y replace(). Estas corresponden a las operaciones clásicas de pila donde "push" añade un elemento a la parte superior de una pila, "pop" elimina el elemento superior de la pila, y "replace" es como un pop seguido de un push, que sustituye el elemento superior por el nuevo elemento. El primer elemento de la pila es el que aparece en la pantalla currently. Lógicamente, "push" navega hacia delante o más profundamente en la interfaz de usuario de la aplicación, "pop" navega hacia atrás, y "replace" reemplaza al currentItem.

Empujar elementos

En la siguiente animación, tres controles Label son empujados a una vista de pila con la función push():

La pila contiene ahora los siguientes elementos: [A, B, C].

Elementos emergentes

Continuando con el ejemplo anterior, el elemento superior de la pila se elimina con una llamada a pop():

La pila contiene ahora los siguientes elementos: [A, B].

Deshacer elementos mediante Pop

A veces, es necesario retroceder más de un paso en la pila. Por ejemplo, para volver a un elemento "principal" o a algún tipo de elemento de sección de la aplicación. En tales casos, es posible especificar un elemento como parámetro para pop(). Esto se denomina una operación de "desenrollado", en la que la pila se desenrolla hasta el elemento especificado. Si el elemento no se encuentra, la pila se desenrolla hasta que se queda con un elemento, que se convierte en currentItem. Para desenrollar explícitamente hasta el fondo de la pila, se recomienda utilizar pop(null), aunque cualquier elemento inexistente servirá.

En la siguiente animación, desenrollamos la pila hasta el primer elemento llamando a pop(null):

La pila contiene ahora un único elemento: [A].

Sustitución de elementos

En la siguiente animación, replace el elemento superior con D:

La pila contiene ahora los siguientes elementos: [A, B, D].

Enlaces profundos

Deep linking significa lanzar una aplicación en un estado determinado. Por ejemplo, una aplicación de un periódico podría ser lanzada para mostrar un artículo en particular, pasando por alto el elemento superior. En términos de StackView, la vinculación profunda significa la capacidad de modificar el estado de la pila, tanto que es posible empujar un conjunto de elementos a la parte superior de la pila, o restablecer completamente la pila a un estado determinado.

La API para la vinculación profunda en StackView es la misma que para la navegación básica. Empujar un array en lugar de un único elemento añade todos los elementos de ese array a la pila. Sin embargo, la animación de transición sólo se aplica al último elemento de la matriz. La semántica normal de push() se aplica para la vinculación profunda, es decir, añade lo que se empuja a la pila.

Esto nos da el siguiente resultado, dada la pila [A, B, C]:

• push([D, E, F]) => [A, B, C, D, E, F] - animación de transición "push" entre C y F
• replace([D, E, F]) => [A, B, D, E, F] - "reemplazar" la animación de transición entre C y F
• clear() seguido de push([D, E, F]) => [D, E, F] - no hay animación de transición para empujar elementos ya que la pila está vacía.

Búsqueda de elementos

Un elemento para el que la aplicación no tiene una referencia se puede encontrar llamando a find(). El método necesita una función callback, que se invoca para cada elemento de la pila (empezando por arriba) hasta que se encuentra una coincidencia. Si la llamada de retorno devuelve true, find() se detiene y devuelve el elemento coincidente, de lo contrario se devuelve null.

El código siguiente busca en la pila un elemento llamado "order_id" y desenrolla hasta ese elemento.

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

También se puede llegar a un elemento de la pila utilizando get(índice).

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

Transiciones

Para cada operación push o pop, se aplican diferentes animaciones de transición a los elementos que entran y salen. Estas animaciones definen cómo debe animarse el elemento que entra y cómo debe animarse el elemento que sale. Las animaciones pueden personalizarse asignando diferentes Transitions a las propiedades pushEnter, pushExit, popEnter, popExit, replaceEnter, y replaceExit de StackView.

El siguiente fragmento define una transición simple para las operaciones push y 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
        }
    }
}

Propiedad del elemento

StackView sólo se apropia de los elementos que él mismo crea. Esto significa que cualquier ítem empujado a un StackView nunca será destruido por el StackView; sólo los ítems que el StackView crea desde Components o URLs son destruidos por el StackView. Para ilustrar esto, los mensajes del ejemplo de abajo sólo se imprimirán cuando se destruya el StackView, no cuando los ítems se saquen de la pila:

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

Sin embargo, ambos ítems creados desde la URL y el Componente en el siguiente ejemplo serán destruidos por el StackView cuando se salgan de él:

Component {
    id: itemComponent

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

StackView {
    initialItem: "Item1.qml"

    Component.onCompleted: push(itemComponent)
}

Tamaño

StackView no hereda un tamaño implícito de los elementos que son empujados hacia él. Esto significa que su uso como contentItem de un Dialog, por ejemplo, no funcionará como se espera:

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

Hay varias maneras de asegurarse de que StackView tiene un tamaño en esta situación:

• Establecer implicitWidth y implicitHeight en el propio StackView.
• Establecer implicitWidth y implicitHeight en Rectangle.
• Establecer contentWidth y contentHeight en el Dialog.
• Dé un tamaño al Dialog.

Ver también Personalizando StackView, Navegando con StackView, Controles de Navegación, Controles Contenedores, y Gestión del Foco en Qt Quick Controls.

Documentación de Propiedades

busy : bool [read-only]

Esta propiedad mantiene si una transición se está ejecutando.

currentItem : Item [read-only]

Esta propiedad contiene el primer elemento de la pila.

depth : int [read-only]

Esta propiedad contiene el número de elementos que se han introducido en la pila.

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

Esta propiedad indica si la pila está vacía.

Esta propiedad se introdujo en QtQuick.Controls 2.3 (Qt 5.10).

Véase también depth.

initialItem : var

Esta propiedad contiene el elemento inicial que debe mostrarse cuando se crea StackView. El elemento inicial puede ser un Item, Component, o un url. Especificar un elemento inicial es equivalente a:

Component.onCompleted: stackView.push(myInitialItem)

Véase también push().

popEnter : Transition

Esta propiedad contiene la transición que se aplica al elemento que entra en la pila cuando otro elemento sale de ella.

Véase también Personalizar StackView.

popExit : Transition

Esta propiedad contiene la transición que se aplica al elemento que sale de la pila cuando el elemento sale de ella.

Véase también Personalización de StackView.

pushEnter : Transition

Esta propiedad contiene la transición que se aplica al elemento que entra en la pila cuando el elemento es empujado a ella.

Véase también Personalizar StackView.

pushExit : Transition

Esta propiedad contiene la transición que se aplica al elemento que sale de la pila cuando se le coloca otro elemento.

Véase también Personalizar StackView.

replaceEnter : Transition

Esta propiedad contiene la transición que se aplica al elemento que entra en la pila cuando otro elemento es reemplazado por él.

Véase también Personalizar StackView.

replaceExit : Transition

Esta propiedad contiene la transición que se aplica al elemento que sale de la pila cuando es reemplazado por otro elemento.

Véase también Personalización de StackView.

Documentación de la propiedad Attached

StackView.index : int [read-only]

Esta propiedad adjunta contiene el índice de pila del elemento al que está adjunta, o -1 si el elemento no está en una pila.

StackView.status : enumeration [read-only]

Esta propiedad adjunta contiene el estado de la pila del elemento al que está adjunta, o StackView.Inactive si el elemento no está en una pila.

Valores disponibles:

StackView.view : StackView [read-only]

Esta propiedad adjunta contiene la vista de pila del elemento al que está adjunta, o null si el elemento no está en una pila.

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

Esta propiedad adjunta contiene la visibilidad del elemento al que está adjunta. El valor sigue el valor de Item::visible.

Por defecto, StackView muestra los elementos entrantes cuando comienza la transición de entrada, y oculta los elementos salientes cuando finaliza la transición de salida. Establecer esta propiedad explícitamente permite anular el comportamiento por defecto, haciendo posible mantener visibles los elementos que están por debajo del elemento superior.

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

Esta propiedad se introdujo en QtQuick.Controls 2.2 (Qt 5.9).

Documentación de señales adjuntas

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

Esta señal adjunta se emite cuando el elemento al que está adjunta se activa en la pila.

Esta señal se introdujo en QtQuick.Controls 2.1 (Qt 5.8).

Ver también status.

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

Esta señal adjunta se emite cuando el elemento al que está adjunta está en proceso de activarse en la pila.

Esta señal se introdujo en QtQuick.Controls 2.1 (Qt 5.8).

Ver también status.

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

Esta señal adjunta se emite cuando el elemento al que está adjunta se desactiva en la pila.

Esta señal se introdujo en QtQuick.Controls 2.1 (Qt 5.8).

Ver también status.

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

Esta señal adjunta se emite cuando el elemento al que está adjunta está en proceso de ser desactivado en la pila.

Esta señal se introdujo en QtQuick.Controls 2.1 (Qt 5.8).

Ver también status.

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

Esta señal adjunta se emite cuando el ítem al que está adjunta ha sido retirado de la pila. Se puede utilizar, por ejemplo, para destruir de forma segura un elemento que se ha introducido en la pila:

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

Esta señal se introdujo en QtQuick.Controls 2.1 (Qt 5.8).

Ver también status.

Documentación del Método

void clear(transition)

Elimina todos los elementos de la pila.

Sólo los elementos creados por StackView (a partir de Component o url) serán destruidos al ser extraídos. Véase Item Ownership para más información.

Desde QtQuick.Controls 2.3, se puede especificar opcionalmente un transition. Transiciones admitidas:

Item find(callback, behavior)

Busca un elemento específico dentro de la pila. Se llama a la función callback para cada elemento de la pila (con el elemento y el índice como argumentos) hasta que la función de devolución de llamada devuelve true. El valor devuelto es el elemento encontrado. Por ejemplo:

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

Valores admitidos behavior:

Item get(index, behavior)

Devuelve el elemento en la posición index de la pila, o null si el índice está fuera de los límites.

Valores admitidos behavior:

Item pop(item, operation)

Retira uno o más elementos de la pila. Devuelve el último elemento eliminado de la pila.

Si se especifica el argumento item, se saltarán todos los elementos hasta (pero sin incluir) item. Si item es null, se extraen todos los elementos hasta el primero (pero sin incluirlo). Si no se especifica, sólo se mostrará el elemento actual.

Sólo los elementos creados por StackView (a partir de Component o url) serán destruidos al ser vaciados. Véase Item Ownership para más información.

Se puede especificar opcionalmente un operation como último argumento. Operaciones soportadas:

Si no se proporciona ninguna operación, se utilizará PopTransition.

Ejemplos:

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

Véase también clear(), Popping Items, y Unwinding Items via Pop.

[since 6.7] Item popCurrentItem(operation)

Elimina currentItem de la pila. Devuelve el último elemento eliminado de la pila, o null si depth era 1.

Sólo los elementos creados por StackView (a partir de Component o url) serán destruidos al ser extraídos. Véase Item Ownership para más información.

Se puede especificar opcionalmente un operation como último argumento. Operaciones soportadas:

Si no se proporciona ninguna operación, se utilizará PopTransition.

Esta función es equivalente a popToIndex(stackView.currentIndex - 1).

Este método se introdujo en Qt 6.7.

Véase también clear(), Popping Items, y Unwinding Items via Pop.

[since 6.7] Item popToIndex(index, operation)

Despliega todos los elementos hasta (pero sin incluir) index. Devuelve el último elemento eliminado de la pila.

Si index está fuera de los límites, se produce una advertencia y se devuelve null.

Sólo los ítems creados por StackView (a partir de Component o url) serán destruidos. Véase Item Ownership para más información.

Se puede especificar opcionalmente un operation como último argumento. Operaciones soportadas:

Si no se proporciona ninguna operación, se utilizará PopTransition.

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

Este método se introdujo en Qt 6.7.

Véase también clear(), Popping Items, y Unwinding Items via Pop.

[since 6.7] Item popToItem(item, operation)

Despliega todos los elementos hasta (pero sin incluir) item. Devuelve el último elemento eliminado de la pila.

Si item es null, se produce una advertencia y se devuelve null.

Sólo los ítems creados por StackView (a partir de Component o url) serán destruidos. Véase Item Ownership para más información.

Se puede especificar opcionalmente un operation como último argumento. Operaciones soportadas:

Si no se proporciona ninguna operación, se utilizará PopTransition.

stackView.popToItem(someItem, StackView.Immediate)

Este método se introdujo en Qt 6.7.

Véase también clear(), Popping Items, y Unwinding Items via Pop.

Item push(item, properties, operation)

Coloca un item en la pila utilizando un operation opcional y, opcionalmente, aplica un conjunto de properties al elemento. El elemento puede ser un Item, Component, o un url. Devuelve el elemento que se convirtió en actual.

StackView crea una instancia automáticamente si el elemento empujado es un Component, o un url, y la instancia se destruirá cuando se saque de la pila. Consulte Item Ownership para obtener más información.

El argumento opcional properties especifica un mapa de valores de propiedades iniciales para el elemento empujado. Para los elementos creados dinámicamente, estos valores se aplican antes de finalizar la creación. Esto es más eficiente que establecer los valores de las propiedades después de la creación, especialmente cuando se definen grandes conjuntos de valores de propiedades, y también permite que se establezcan los enlaces de las propiedades (utilizando Qt.binding()) antes de que se cree el elemento.

Envío de un único elemento:

stackView.push(rect)

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

Se pueden enviar varios elementos al mismo tiempo, ya sea pasándolos como argumentos adicionales o como una matriz. El último elemento se convierte en el elemento actual. Cada elemento puede ir seguido de un conjunto de propiedades a aplicar.

Pasar una cantidad variable de argumentos:

stackView.push(rect1, rect2, rect3)

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

Pasando una matriz de elementos:

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

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

Se puede especificar opcionalmente un operation como último argumento. Operaciones admitidas:

Si no se proporciona ninguna operación, se utilizará Immediate si la pila está vacía y PushTransition en caso contrario.

Véase también initialItem y Pushing Items.

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

Coloca un item en la pila, aplicando opcionalmente un conjunto de properties, utilizando el operation opcional. Devuelve el elemento que se convirtió en actual (el último elemento).

Se puede especificar opcionalmente un operation como último argumento. Operaciones admitidas:

Si no se proporciona ninguna operación, se utilizará PushTransition.

Para insertar varios elementos en la pila, utilice pushItems().

Este método se introdujo en Qt 6.7.

Véase también initialItem y Pushing Items.

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

Coloca un component en la pila, aplicando opcionalmente un conjunto de properties, utilizando el operation opcional. Devuelve el elemento que se convirtió en actual (el último elemento).

Se puede especificar opcionalmente un operation como último argumento. Operaciones admitidas:

Si no se proporciona ninguna operación, se utilizará PushTransition.

Para colocar varios elementos en la pila, utilice pushItems().

Este método se introdujo en Qt 6.7.

Véase también initialItem y Pushing Items.

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

Coloca un url en la pila, aplicando opcionalmente un conjunto de properties, utilizando el operation opcional. Devuelve el elemento que se convirtió en actual (el último elemento).

Se puede especificar opcionalmente un operation como último argumento. Operaciones admitidas:

Si no se proporciona ninguna operación, se utilizará PushTransition.

Para colocar varios elementos en la pila, utilice pushItems().

Este método se introdujo en Qt 6.7.

Véase también initialItem y Pushing Items.

[since 6.7] Item pushItems(items, operation)

Coloca items en la pila utilizando un operation opcional y, opcionalmente, aplica un conjunto de propiedades a cada elemento. items es una matriz de elementos. Cada elemento puede ser un Item, Component, o url y puede ir seguido de un argumento opcional de propiedades (ver más abajo). Devuelve el elemento que se convirtió en actual (el último elemento).

StackView crea una instancia automáticamente si el elemento empujado es un Component o url, y la instancia se destruirá cuando se saque de la pila. Véase Item Ownership para más información.

Los argumentos opcionales de propiedades vienen después de cada elemento, y especifican un mapa de valores iniciales de propiedades. Para los elementos creados dinámicamente, estos valores se aplican antes de finalizar la creación. Esto es más eficiente que establecer los valores de las propiedades después de la creación, especialmente cuando se definen grandes conjuntos de valores de propiedades, y también permite que se establezcan los enlaces de las propiedades (utilizando Qt.binding()) antes de que se cree el elemento.

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

Se puede especificar opcionalmente un operation como último argumento. Operaciones admitidas:

Si no se proporciona ninguna operación, se utilizará PushTransition.

Para insertar un único elemento, utilice la función correspondiente de pushItem:

• pushItem(elemento, propiedades, operación)
• pushItem(componente, propiedades, operación)
• pushItem(url, propiedades, operación)

Este método se introdujo en Qt 6.7.

Véase también initialItem, pushItem, y Pushing Items.

Item replace(target, item, properties, operation)

Reemplaza uno o más elementos de la pila con el item especificado y el operation opcional , y opcionalmente aplica un conjunto de properties sobre el elemento. El elemento puede ser un Item, Component, o un url. Devuelve el elemento que se ha convertido en actual.

Sólo los elementos creados por StackView (a partir de Component o url) se destruirán cuando aparezcan. Consulte Item Ownership para obtener más información.

Si se especifica el argumento target, todos los elementos hasta el elemento target serán reemplazados. Si target es null, se reemplazarán todos los elementos de la pila. Si no se especifica, sólo se reemplazará el elemento superior.

StackView crea una instancia automáticamente si el elemento de reemplazo es un Component, o un url. El argumento opcional properties especifica un mapa de valores de propiedades iniciales para el elemento de reemplazo. Para los elementos creados dinámicamente, estos valores se aplican antes de finalizar la creación. Esto es más eficiente que establecer los valores de las propiedades después de la creación, particularmente cuando se definen grandes conjuntos de valores de propiedades, y también permite que se establezcan los enlaces de las propiedades (utilizando Qt.binding()) antes de que se cree el elemento.

Reemplazar el elemento superior:

stackView.replace(rect)

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

Se pueden reemplazar varios elementos al mismo tiempo pasándolos como argumentos adicionales o como una matriz. Cada elemento puede ir seguido de un conjunto de propiedades a aplicar.

Pasar una cantidad variable de argumentos:

stackView.replace(rect1, rect2, rect3)

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

Sustitución de una matriz de elementos:

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

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

Opcionalmente, se puede especificar un operation como último argumento. Operaciones admitidas:

Si no se proporciona ninguna operación, se utilizará Immediate si la pila está vacía y ReplaceTransition en caso contrario.

El siguiente ejemplo ilustra el uso de transiciones push y pop con 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)
                }
            }
        }
    }
}

Véase también push() y Replacing Items.

[since 6.7] Item replaceCurrentItem(items, operation)

Saca currentItem de la pila y mete items. Si se especifica la opción operation, se utilizará la transición correspondiente. Cada elemento puede ir seguido de un conjunto opcional de propiedades que se aplicarán a ese elemento. Devuelve el elemento que se ha convertido en actual.

Los argumentos opcionales de propiedades van después de cada elemento y especifican un mapa de valores iniciales de propiedades. Para los elementos creados dinámicamente, estos valores se aplican antes de finalizar la creación. Esto es más eficiente que establecer los valores de las propiedades después de la creación, especialmente cuando se definen grandes conjuntos de valores de propiedades, y también permite que se establezcan los enlaces de las propiedades (utilizando Qt.binding()) antes de que se cree el elemento.

Sólo los elementos creados por StackView (a partir de Component o url) se destruirán cuando se salten. Véase Item Ownership para más información.

Se puede especificar opcionalmente un operation como último argumento. Operaciones soportadas:

Si no se proporciona ninguna operación, se utilizará ReplaceTransition.

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

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

Para insertar un único elemento, utilice la sobrecarga correspondiente:

• replaceCurrentItem(elemento, propiedades, operación)
• replaceCurrentItem(componente, propiedades, operación)
• replaceCurrentItem(url, propiedades, operación)

Este método se introdujo en Qt 6.7.

Véase también push() y Replacing Items.

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

Saca currentItem de la pila y mete item. Si se especifica el opcional operation, se utilizará la transición correspondiente. Si se especifica properties opcional, se aplicará al elemento. Devuelve el elemento que se ha convertido en actual.

Sólo los elementos creados por StackView (a partir de Component o url) se destruirán al saltar. Consulte Item Ownership para obtener más información.

Se puede especificar opcionalmente un operation como último argumento. Operaciones soportadas:

Si no se proporciona ninguna operación, se utilizará ReplaceTransition.

Para insertar varios elementos en la pila, utilice replaceCurrentItem(elementos, operación).

Este método se introdujo en Qt 6.7.

Véase también Replacing Items.

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

Saca currentItem de la pila y mete component. Si se especifica el opcional operation, se utilizará la transición correspondiente. Si se especifica properties opcional, se aplicará al elemento. Devuelve el elemento que se ha convertido en actual.

Sólo los elementos creados por StackView (a partir de Component o url) se destruirán al saltar. Consulte Item Ownership para obtener más información.

Se puede especificar opcionalmente un operation como último argumento. Operaciones soportadas:

Si no se proporciona ninguna operación, se utilizará ReplaceTransition.

Para insertar varios elementos en la pila, utilice replaceCurrentItem(elementos, operación).

Este método se introdujo en Qt 6.7.

Véase también Replacing Items.

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

Saca currentItem de la pila y mete url. Si se especifica el opcional operation, se utilizará la transición correspondiente. Si se especifica properties opcional, se aplicará al elemento. Devuelve el elemento que se ha convertido en actual.

Sólo los elementos creados por StackView (a partir de Component o url) se destruirán al saltar. Consulte Item Ownership para obtener más información.

Se puede especificar opcionalmente un operation como último argumento. Operaciones soportadas:

Si no se proporciona ninguna operación, se utilizará ReplaceTransition.

Para insertar varios elementos en la pila, utilice replaceCurrentItem(elementos, operación).

Este método se introdujo en Qt 6.7.

Véase también Replacing Items.