En esta página

StackView QML Type

Ofrece un modelo de navegación basado en una pila. Más...

Import Statement: import QtQuick.Controls
Inherits:

Control

Propiedades

Propiedades adjuntas

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

Descripción detallada

Esquema de la vista en pila que muestra la navegación por la página

StackView se puede utilizar con un conjunto de páginas de información interrelacionadas. Por ejemplo, una aplicación de correo electrónico con vistas independientes para mostrar los correos más recientes, ver un correo específico y mostrar o ver los archivos adjuntos. La vista de la lista de correos se añade a la pila cuando el usuario abre un correo y se retira de ella cuando decide volver atrás.

El siguiente fragmento de código muestra un caso de uso sencillo, en el que la vista « mainView » se añade a la pila y se retira de ella al pulsar 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 sencillo como añadirlo como elemento secundario a una ventana. La pila suele anclarse a los bordes de la ventana, excepto en la parte superior o inferior, donde puede anclarse a una barra de estado o a algún otro componente de interfaz de usuario similar. A continuación, se puede utilizar la pila 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 situado más arriba si no se ha establecido ` initialItem `.

Navegación básica

StackView admite tres operaciones de navegación principales: ` push()`, ` pop()` y ` replace()`. Estas corresponden a las operaciones clásicas de pila, en las que «push» añade un elemento a la parte superior de la pila, «pop» elimina el elemento superior de la pila y «replace» es como un «pop» seguido de un «push», lo que sustituye el elemento superior por el nuevo. El elemento situado en la parte superior de la pila corresponde al que es currently visible en pantalla. Lógicamente, «push» navega hacia adelante o hacia lo más profundo de la interfaz de usuario de la aplicación, «pop» navega hacia atrás y «replace» sustituye el currentItem.

Inserción de elementos

En la siguiente animación, se añaden tres controles Label a una vista de pila mediante la función push():

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

Nota: Cuando la pila está vacía, una operación push() no tendrá animación de transición porque no hay nada desde lo que realizar la transición (normalmente al iniciar la aplicación).

Extracción de elementos

Siguiendo con el ejemplo anterior, el elemento situado en la parte superior de la pila se elimina mediante una llamada a ` pop()`:

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

Nota: Una operación ` pop()` en una pila con profundidad 1 o 0 no realiza ninguna acción. En tales casos, la pila se puede vaciar utilizando el método ` clear()`.

Desenrollar 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 operación de «desenrollado», en la que la pila se desenrolla hasta el elemento especificado. Si no se encuentra el elemento, la pila se desenrolla hasta que solo quede un elemento, que se convierte en el ` 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, sustituimos replace el elemento superior por D:

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

Enlaces profundos

Los enlaces profundos consisten en iniciar una aplicación en un estado concreto. Por ejemplo, una aplicación de periódico podría iniciarse mostrando un artículo concreto, sin pasar por el elemento situado en la parte superior. En lo que respecta a StackView, el enlace profundo se refiere a la capacidad de modificar el estado de la pila, hasta tal punto que es posible insertar un conjunto de elementos en la parte superior de la pila o restablecerla por completo a un estado determinado.

La API para los enlaces profundos en StackView es la misma que para la navegación básica. Al insertar un array en lugar de un único elemento, se añaden a la pila todos los elementos de dicho array. Sin embargo, la animación de transición solo se aplica al último elemento del array. La semántica habitual de push() se aplica al enlace profundo, es decir, añade todo lo que se inserta en la pila.

Nota: Solo se carga el último elemento del array. El resto de los elementos se cargan únicamente cuando es necesario, ya sea en llamadas posteriores a pop o al solicitar un elemento mediante get().

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] — Animación de transición «replace» entre C y F
  • clear() seguido de push([D, E, F]) => [D, E, F] — sin animación de transición al insertar elementos, ya que la pila estaba vacía.

Búsqueda de elementos

Un elemento para el que la aplicación no tiene ninguna referencia se puede encontrar llamando a ` find()`. El método necesita una función de devolución de llamada, que se invoca para cada elemento de la pila (empezando por el primero) hasta que se encuentra una coincidencia. Si la función de devolución de llamada 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 se desplaza hasta dicho elemento.

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

También puedes acceder a un elemento de la pila utilizando get(índice).

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

Transiciones

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

Nota: Las animaciones de transición influyen en el comportamiento de transición de las demás. Personalizar la animación de una y dejar la otra sin modificar puede dar lugar a resultados inesperados.

El siguiente fragmento de código define una transición de desvanecimiento sencilla 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
        }
    }
}

Nota: No se admiteel uso de anclajes en los elementos añadidos a un StackView. Normalmente, las transiciones «push», «pop» y «replace» animan la posición, lo cual no es posible cuando se aplican anclajes. Ten en cuenta que esto solo se aplica a la raíz del elemento. El uso de anclajes para sus elementos secundarios funciona como se espera.

Propiedad de los elementos

StackView solo asume la propiedad de los elementos que crea ella misma. Esto significa que ningún elemento añadido a un `StackView` será destruido nunca por este; solo los elementos que el `StackView` crea a partir de ` Components ` o ` URLs ` son destruidos por él. Para ilustrarlo, los mensajes del ejemplo siguiente solo se mostrarán cuando se destruya el `StackView`, no cuando los elementos se extraigan 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, los dos elementos creados a partir de la URL y del componente en el siguiente ejemplo serán destruidos por la StackView cuando se extraigan de ella:

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 se añaden a ella. Esto significa que utilizarla como « contentItem » de un « Dialog », por ejemplo, no funcionará como se espera:

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

Hay varias formas de garantizar que StackView tenga un tamaño en esta situación:

Véase también Personalización de StackView, Navegación con StackView, Controles de navegación, Controles de contenedor y Gestión del foco en los controles de Qt Quick .

Documentación de propiedades

busy : bool [read-only]

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

currentItem : Item [read-only]

Esta propiedad contiene el elemento que se encuentra actualmente en la parte superior de la pila.

depth : int [read-only]

Esta propiedad contiene el número de elementos que hay actualmente 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 al crear el « StackView ». El elemento inicial puede ser un « Item », un « Component » o un « url ». Especificar un elemento inicial equivale 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 se retira otro elemento de ella.

Véase también Personalización deStackView.

popExit : Transition

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

Véase también Personalización deStackView.

pushEnter : Transition

Esta propiedad contiene la transición que se aplica al elemento que entra en la pila cuando se añade a ella.

Véase también Personalización deStackView.

pushExit : Transition

Esta propiedad contiene la transición que se aplica al elemento que sale de la pila cuando se añade otro elemento a la misma.

Véase también Personalización deStackView.

replaceEnter : Transition

Esta propiedad contiene la transición que se aplica al elemento que entra en la pila cuando sustituye a otro elemento.

Véase también Personalización deStackView.

replaceExit : Transition

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

Véase también Personalización deStackView.

Documentación de la propiedad adjunta

StackView.index : int [read-only attached]

Esta propiedad adjunta contiene el índice de la pila del elemento al que está asociada, o un objeto de tipo « -1 » si el elemento no se encuentra en una pila.

StackView.status : enumeration [read-only attached]

Esta propiedad adjunta contiene el estado de la pila del elemento al que está asociada, o el valor « StackView.Inactive » si el elemento no forma parte de ninguna pila.

Valores disponibles:

ConstanteDescripción
StackView.InactiveEl elemento está inactivo (o no forma parte de una pila).
StackView.DeactivatingEl elemento se está desactivando (se retira de la pila).
StackView.ActivatingEl elemento se está activando (se convierte en el elemento actual).
StackView.ActiveEl elemento está activo, es decir, es el elemento actual.

StackView.view : StackView [read-only attached]

Esta propiedad adjunta contiene la vista de pila del elemento al que está asociada, o un objeto de tipo « null » si el elemento no forma parte de una pila.

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

Esta propiedad asociada hereda la visibilidad del elemento al que está vinculada. Su 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. Al configurar esta propiedad de forma explícita, se anula el comportamiento predeterminado, lo que permite mantener visibles los elementos que se encuentran por debajo del elemento situado en la parte superior.

Nota: Las transiciones predeterminadas de la mayoría de los estilos deslizan los elementos salientes fuera de la vista y también pueden animar su opacidad. Para mantener visible toda la pila de elementos, se recomienda personalizar la propiedad ` transitions ` de modo que se puedan ver los elementos situados debajo.

Vista de la pila que muestra el comportamiento de la visibilidad

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 la señal asociada

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

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

Nota: El controlador correspondiente es onActivated.

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

Véase también status.

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

Esta señal adjunta se emite cuando el elemento al que está asociada está en proceso de activación en la pila.

Nota: El controlador correspondiente es onActivating.

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

Véase también status.

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

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

Nota: El controlador correspondiente es onDeactivated.

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

Véase también status.

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

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

Nota: El controlador correspondiente es onDeactivating.

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

Véase también status.

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

Esta señal adjunta se emite cuando el elemento al que está asociada se ha eliminado de la pila. Se puede utilizar para destruir de forma segura un elemento que se había añadido a la pila; por ejemplo:

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

Nota: El controlador correspondiente es onRemoved.

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

Véase también status.

Documentación del método

void clear(transition)

Elimina todos los elementos de la pila.

Solo se eliminarán los elementos que haya creado el propio « StackView » (a partir de un « Component » o un « url ») al extraerlos de la pila. Consulte Item Ownership para obtener más información.

Desde la versión QtQuick.Controls 2.3, se puede especificar opcionalmente un transition. Transiciones admitidas:

ConstanteDescripción
StackView.ImmediateBorra la pila inmediatamente sin ninguna transición (por defecto).
StackView.PushTransitionBorra la pila con una transición «push».
StackView.ReplaceTransitionVacía la pila con una transición de sustitución.
StackView.PopTransitionBorra la pila con una transición «pop».

Item find(callback, behavior)

Busca un elemento concreto dentro de la pila. La función ` callback ` se invoca para cada elemento de la pila (con el elemento y el índice como argumentos) hasta que la función de llamada de retorno devuelva ` true`. El valor devuelto es el elemento encontrado. Por ejemplo:

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

Valores admitidos para ` behavior `:

ConstanteDescripción
StackView.DontLoadSe omiten los elementos no cargados (no se invoca la función de llamada de retorno para ellos).
StackView.ForceLoadSe fuerza la carga de los elementos descargados.

Item get(index, behavior)

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

Valores de « behavior » admitidos:

ConstanteDescripción
StackView.DontLoadEl elemento no se carga de forma forzada (y se devuelve null si aún no se ha cargado).
StackView.ForceLoadSe fuerza la carga del elemento.

Item pop(item, operation)

Extrae uno o más elementos de la pila. Devuelve el último elemento extraído de la pila.

Si se especifica el argumento « item », se extraerán todos los elementos hasta (sin incluir) « item ». Si « item » es « null », se extraerá todos los elementos hasta (sin incluir) el primer elemento. Si no se especifica, solo se extrae el elemento actual.

Nota: Una operación pop() en una pila con profundidad 1 o 0 no realiza ninguna acción. En tales casos, la pila se puede vaciar utilizando el método clear().

Solo se destruirán al extraerlos los elementos que la propia pila ` StackView ` haya creado (a partir de un ` Component ` o un ` url`). Consulta Item Ownership para obtener más información.

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

ConstanteDescripción
StackView.ImmediateUna operación inmediata sin transiciones.
StackView.PushTransitionUna operación con transiciones de inserción (desde QtQuick.Controls 2.1).
StackView.ReplaceTransitionUna operación con transiciones de sustitución (a partir de QtQuick.Controls 2.1).
StackView.PopTransitionUna operación con transiciones «pop» (desde la versión 2.1 de QtQuick.Controls ).

Si no se especifica ninguna operación, se utilizará « PopTransition ».

Ejemplos:

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

Nota: Si estás compilando QML, utiliza en su lugar las funciones de tipado fuerte ` popToItem`, ` popToIndex ` o ` popCurrentItem `.

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

[since 6.7] Item popCurrentItem(operation)

Extray currentItem de la pila. Devuelve el último elemento extraído de la pila, o null si depth era 1.

Solo se destruirán al extraerse los elementos que el propio ` StackView ` haya creado (a partir de un ` Component ` o un ` url`). Consulta Item Ownership para obtener más información.

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

ConstanteDescripción
StackView.ImmediateUna operación inmediata sin transiciones.
StackView.PushTransitionUna operación con transiciones de inserción.
StackView.ReplaceTransitionUna operación con transiciones de sustitución.
StackView.PopTransitionUna operación con transiciones «pop».

Si no se especifica 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)

Extruye todos los elementos hasta (sin incluirlo) index. Devuelve el último elemento extraído de la pila.

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

Solo se destruirán al sacarlos los elementos que el propio ` StackView ` haya creado (a partir de un ` Component ` o un ` url`). Consulta Item Ownership para obtener más información.

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

ConstanteDescripción
StackView.ImmediateUna operación inmediata sin transiciones.
StackView.PushTransitionUna operación con transiciones de inserción.
StackView.ReplaceTransitionUna operación con transiciones de sustitución.
StackView.PopTransitionUna operación con transiciones «pop».

Si no se especifica 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)

Extruye todos los elementos hasta (sin incluir) item. Devuelve el último elemento extraído de la pila.

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

Solo los elementos que el propio ` StackView ` haya creado (a partir de un ` Component ` o un ` url`) se destruirán al extraerse. Consulte Item Ownership para obtener más información.

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

ConstanteDescripción
StackView.ImmediateUna operación inmediata sin transiciones.
StackView.PushTransitionUna operación con transiciones de inserción.
StackView.ReplaceTransitionUna operación con transiciones de sustitución.
StackView.PopTransitionUna operación con transiciones «pop».

Si no se especifica 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)

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

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

El argumento opcional ` properties ` especifica un mapa de valores iniciales de las propiedades del elemento insertado. En el caso de los elementos creados dinámicamente, estos valores se aplican antes de que finalice la creación. Esto resulta más eficiente que establecer los valores de las propiedades tras la creación, especialmente cuando se definen grandes conjuntos de valores de propiedades, y además permite configurar los enlaces de propiedades (utilizando Qt.binding()) antes de que se cree el elemento.

Inserción de un único elemento:

stackView.push(rect)

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

Se pueden añadir 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 que se deben aplicar.

Pasar un número variable de argumentos:

stackView.push(rect1, rect2, rect3)

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

Insertar una matriz de elementos:

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

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

Opcionalmente, se puede especificar una « operation » como último argumento. Operaciones admitidas:

ConstanteDescripción
StackView.ImmediateUna operación inmediata sin transiciones.
StackView.PushTransitionUna operación con transiciones de inserción (desde la versión QtQuick.Controls 2.1).
StackView.ReplaceTransitionUna operación con transiciones de sustitución (a partir de la versión 2.1 de QtQuick.Controls ).
StackView.PopTransitionUna operación con transiciones «pop» (desde QtQuick.Controls 2.1).

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

Nota: Los elementos que ya existen en la pila no se añaden.

Nota: Si estás compilando QML, utiliza en su lugar las funciones de tipado fuerte pushItem o pushItems.

Véase también initialItem y Pushing Items.

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

Inserta un objeto ` item ` en la pila, aplicando opcionalmente un conjunto de operaciones ` properties`, utilizando el objeto opcional ` operation`. Devuelve el elemento que se ha convertido en el actual (el último elemento).

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

ConstanteDescripción
StackView.ImmediateUna operación inmediata sin transiciones.
StackView.PushTransitionUna operación con transiciones de inserción.
StackView.ReplaceTransitionUna operación con transiciones de sustitución.
StackView.PopTransitionUna operación con transiciones de «pop».

Si no se especifica ninguna operación, se utilizará « PushTransition ».

Para insertar varios elementos en la pila, utiliza ` 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)

Inserta un objeto ` component ` en la pila, aplicando opcionalmente un conjunto de operaciones ` properties`, utilizando el objeto opcional ` operation`. Devuelve el elemento que se ha convertido en el actual (el último elemento).

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

ConstanteDescripción
StackView.ImmediateUna operación inmediata sin transiciones.
StackView.PushTransitionUna operación con transiciones de inserción.
StackView.ReplaceTransitionUna operación con transiciones de sustitución.
StackView.PopTransitionUna operación con transiciones «pop».

Si no se especifica ninguna operación, se utilizará « PushTransition ».

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

Esta función sobrecarga a `pushItem()`.

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)

Inserta un objeto ` url ` en la pila, aplicando opcionalmente un conjunto de operaciones ` properties`, utilizando el objeto opcional ` operation`. Devuelve el elemento que se ha convertido en el actual (el último elemento).

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

ConstanteDescripción
StackView.ImmediateUna operación inmediata sin transiciones.
StackView.PushTransitionUna operación con transiciones de inserción.
StackView.ReplaceTransitionUna operación con transiciones de sustitución.
StackView.PopTransitionUna operación con transiciones «pop».

Si no se especifica ninguna operación, se utilizará « PushTransition ».

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

Esta función sobrecarga a `pushItem()`.

Este método se introdujo en Qt 6.7.

Véase también initialItem y Pushing Items.

[since 6.7] Item pushItems(items, operation)

Inserta 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 de propiedades opcional (véase más abajo). Devuelve el elemento que se ha convertido en el actual (el último elemento).

StackView Crea una instancia automáticamente si el elemento insertado es un ` Component ` o un ` url`, y la instancia se destruirá cuando se extraiga de la pila. Consulta Item Ownership para obtener más información.

Los argumentos opcionales de propiedades aparecen después de cada elemento y especifican un mapa de valores iniciales de las propiedades. En el caso de los elementos creados dinámicamente, estos valores se aplican antes de que finalice la creación. Esto resulta más eficiente que establecer los valores de las propiedades tras la creación, especialmente cuando se definen grandes conjuntos de valores de propiedades, y además permite configurar los enlaces de 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
])

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

ConstanteDescripción
StackView.ImmediateUna operación inmediata sin transiciones.
StackView.PushTransitionUna operación con transiciones de inserción.
StackView.ReplaceTransitionUna operación con transiciones de sustitución.
StackView.PopTransitionUna operación con transiciones «pop».

Si no se especifica ninguna operación, se utilizará « PushTransition ».

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

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

Nota: Los elementos que ya existen en la pila no se añaden.

Este método se introdujo en Qt 6.7.

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

Item replace(target, item, properties, operation)

Sustituye uno o más elementos de la pila por el item especificado y el operation opcional, y, opcionalmente, aplica un conjunto de properties al elemento. El elemento puede ser un Item, un Component o un url. Devuelve el elemento que pasa a ser el actual.

Solo los elementos que StackView haya creado él mismo (a partir de un Component o un url) se destruirán al extraerse. Consulte Item Ownership para obtener más información.

Si se especifica el argumento ` target `, se sustituirán todos los elementos hasta el elemento ` target `. Si ` target ` es ` null`, se sustituirán todos los elementos de la pila. Si no se especifica, solo se sustituirá el elemento superior.

StackView Crea una instancia automáticamente si el elemento de sustitución es un ` Component` o un ` url`. El argumento opcional ` properties ` especifica un mapa de valores iniciales de las propiedades para el elemento de sustitución. En el caso de los elementos creados dinámicamente, estos valores se aplican antes de que finalice la creación. Esto resulta más eficiente que establecer los valores de las propiedades tras la creación, especialmente cuando se definen grandes conjuntos de valores de propiedades, y además permite configurar los enlaces de propiedades (utilizando Qt.binding()) antes de que se cree el elemento.

Sustituir el elemento superior:

stackView.replace(rect)

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

Se pueden sustituir varios elementos al mismo tiempo, ya sea pasándolos como argumentos adicionales o como una matriz. Cada elemento puede ir seguido de un conjunto de propiedades que se van a aplicar.

Pasar un número 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:

ConstanteDescripción
StackView.ImmediateUna operación inmediata sin transiciones.
StackView.PushTransitionUna operación con transiciones de inserción (a partir de QtQuick.Controls 2.1).
StackView.ReplaceTransitionUna operación con transiciones de sustitución (a partir de QtQuick.Controls 2.1).
StackView.PopTransitionUna operación con transiciones «pop» (desde QtQuick.Controls 2.1).

Si no se especifica 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)
                }
            }
        }
    }
}

Nota: Si estás compilando QML, utiliza en su lugar las funciones replaceCurrentItem de tipado fuerte.

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

[since 6.7] Item replaceCurrentItem(items, operation)

Extrae « currentItem » de la pila y añade « items ». Si se especifica el parámetro opcional « operation », se utilizará la transición correspondiente. Cada elemento puede ir seguido de un conjunto opcional de propiedades que se aplicarán a dicho elemento. Devuelve el elemento que se ha convertido en el actual.

Los argumentos de propiedades opcionales aparecen después de cada elemento y especifican un mapa de valores iniciales de las propiedades. En el caso de los elementos creados dinámicamente, estos valores se aplican antes de que finalice la creación. Esto resulta más eficiente que establecer los valores de las propiedades tras la creación, especialmente cuando se definen grandes conjuntos de valores de propiedades, y además permite configurar los enlaces de propiedades (utilizando ` Qt.binding()`) antes de que se cree el elemento.

Solo los elementos que el propio ` StackView ` haya creado (a partir de un ` Component ` o un ` url`) se destruirán al ser extraídos. Consulte Item Ownership para obtener más información.

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

ConstanteDescripción
StackView.ImmediateUna operación inmediata sin transiciones.
StackView.PushTransitionUna operación con transiciones de inserción.
StackView.ReplaceTransitionUna operación con transiciones de sustitución.
StackView.PopTransitionUna operación con transiciones «pop».

Si no se especifica 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, utiliza la sobrecarga correspondiente:

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)

Extrae currentItem de la pila y añade item. Si se especifica el parámetro opcional operation, se utilizará la transición correspondiente. Si se especifican los parámetros opcionales properties, se aplicarán al elemento. Devuelve el elemento que se ha convertido en el actual.

Solo se destruirán al extraerse de la pila los elementos que StackView haya creado él mismo (a partir de un Component o un url). Consulte Item Ownership para obtener más información.

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

ConstanteDescripción
StackView.ImmediateUna operación inmediata sin transiciones.
StackView.PushTransitionUna operación con transiciones de inserción.
StackView.ReplaceTransitionUna operación con transiciones de sustitución.
StackView.PopTransitionUna operación con transiciones de extracción.

Si no se especifica ninguna operación, se utilizará « ReplaceTransition ».

Para insertar varios elementos en la pila, utiliza ` replaceCurrentItem(items, operation)`.

Esta función sobrescribe a `replaceCurrentItem()`.

Este método se introdujo en Qt 6.7.

Véase también Replacing Items.

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

Extrae currentItem de la pila y añade component. Si se especifica el parámetro opcional operation, se utilizará la transición correspondiente. Si se especifican los parámetros opcionales properties, se aplicarán al elemento. Devuelve el elemento que se ha convertido en el actual.

Solo se destruirán al ser extraídos de la pila aquellos elementos que StackView haya creado él mismo (a partir de un Component o un url). Véase Item Ownership para obtener más información.

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

ConstanteDescripción
StackView.ImmediateUna operación inmediata sin transiciones.
StackView.PushTransitionUna operación con transiciones «push».
StackView.ReplaceTransitionUna operación con transiciones de sustitución.
StackView.PopTransitionUna operación con transiciones «pop».

Si no se especifica ninguna operación, se utilizará « ReplaceTransition ».

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

Esta función sobrecarga la función `replaceCurrentItem()`.

Este método se introdujo en Qt 6.7.

Véase también Replacing Items.

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

Extrae currentItem de la pila y añade url. Si se especifica el parámetro opcional operation, se utilizará la transición correspondiente. Si se especifican los parámetros opcionales properties, se aplicarán al elemento. Devuelve el elemento que se ha convertido en el actual.

Solo se destruirán al ser extraídos de la pila aquellos elementos que el propio ` StackView ` haya creado (a partir de un ` Component ` o un ` url`). Consulte ` Item Ownership ` para obtener más información.

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

ConstanteDescripción
StackView.ImmediateUna operación inmediata sin transiciones.
StackView.PushTransitionUna operación con transiciones de inserción.
StackView.ReplaceTransitionUna operación con transiciones de sustitución.
StackView.PopTransitionUna operación con transiciones «pop».

Si no se especifica ninguna operación, se utilizará « ReplaceTransition ».

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

Esta función sobrescribe a `replaceCurrentItem()`.

Este método se introdujo en Qt 6.7.

Véase también Replacing Items.

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