En esta página

Flickable QML Type

Ofrece una superficie sobre la que se puede «deslizar el dedo». Más...

Import Statement: import QtQuick
Inherits:

Item

Inherited By:

GridView, HorizontalHeaderView, ListView, TableView, TreeView, and VerticalHeaderView

Propiedades

Señales

Métodos

Descripción detallada

El elemento «Flickable» coloca sus elementos secundarios en una superficie que se puede arrastrar y deslizar con un movimiento rápido, lo que hace que la vista de los elementos secundarios se desplace. Este comportamiento constituye la base de los elementos diseñados para mostrar un gran número de elementos secundarios, como ListView y GridView.

En las interfaces de usuario tradicionales, las vistas se pueden desplazar utilizando controles estándar, como barras de desplazamiento y botones de flecha. En algunas situaciones, también es posible arrastrar la vista directamente manteniendo pulsado un botón del ratón mientras se mueve el cursor. En las interfaces de usuario táctiles, esta acción de arrastre suele complementarse con un movimiento rápido, en el que el desplazamiento continúa después de que el usuario haya dejado de tocar la vista.

Flickable no recorta automáticamente su contenido. Si no se utiliza como elemento a pantalla completa, se recomienda establecer la propiedad ` clip ` en `true`.

Ejemplo de uso

El siguiente ejemplo muestra una pequeña vista de una imagen grande en la que el usuario puede arrastrar o deslizar la imagen para ver diferentes partes de la misma.

import QtQuick

Flickable {
    width: 200; height: 200
    contentWidth: image.width; contentHeight: image.height

    Image { id: image; source: "bigImage.png" }
}

Los elementos declarados como hijos de un Flickable se asocian automáticamente a la propiedad ` contentItem` del Flickable. Esto debe tenerse en cuenta al operar con los hijos del Flickable; normalmente son los hijos de ` contentItem ` los que resultan relevantes. Por ejemplo, los límites de los elementos añadidos al Flickable estarán disponibles mediante contentItem.childrenRect

Ejemplos de contentX y contentY

Las siguientes imágenes muestran un «flickable» al que se le aplica un movimiento de deslizamiento en diversas direcciones y los valores resultantes de « contentX » y « contentY ». El cuadrado azul representa el contenido del «flickable», y el borde negro representa los límites del mismo.

Cuadrado azul de contenido en reposo dentro de unos límites en los que se puede deslizar el dedo

Tanto contentX como contentY son 0.

Cuadrado azul de contenido arrastrado hacia la esquina superior izquierda

Tanto « contentX » como « contentY » son 50.

Cuadrado azul de contenido arrastrado hacia la esquina superior derecha

contentX es -50 y contentY es 50.

Cuadrado azul de contenido arrastrado hacia la esquina inferior derecha

Tanto el « contentX » como el « contentY » son -50.

Cuadrado azul de contenido arrastrado hacia la esquina inferior izquierda

La página « contentX » es 50 y la de « contentY » es -50.

Limitaciones

Nota: Debido a un detalle de implementación, los elementos colocados dentro de un Flickable no pueden anclarse a dicho Flickable. En su lugar, utiliza parent, que hace referencia a contentItem del Flickable. El tamaño del elemento de contenido viene determinado por contentWidth y contentHeight.

Documentación de propiedades

acceptedButtons : flags [since 6.9]

Los botones del ratón que se pueden utilizar para desplazarse por este «Flickable» arrastrando el cursor.

Por defecto, esta propiedad está configurada como « Qt.LeftButton », lo que ofrece el mismo comportamiento que en versiones anteriores de Qt; sin embargo, en la mayoría de las interfaces de usuario, este comportamiento resulta inesperado. Los usuarios esperan poder deslizar el dedo solo en una pantalla táctil y utilizar la rueda del ratón, los gestos del panel táctil o una barra de desplazamiento con el ratón o el panel táctil. Configúralo como « Qt.NoButton » para desactivar el arrastre.

Se puede configurar con una combinación «OR» de botones del ratón, y se ignorarán los eventos procedentes de otros botones.

Esta propiedad se introdujo en Qt 6.9.

atXBeginning : bool [read-only]

atXEnd : bool [read-only]

atYBeginning : bool [read-only]

atYEnd : bool [read-only]

Estas propiedades se cumplen si la vista deslizable se encuentra al principio o al final, respectivamente.

bottomMargin : real

leftMargin : real

rightMargin : real

topMargin : real

Estas propiedades definen los márgenes alrededor del contenido. Este espacio se reserva además de los márgenes de « contentWidth » y « contentHeight ».

boundsBehavior : enumeration

Esta propiedad determina si la superficie puede arrastrarse más allá de los límites del Flickable o si puede sobrepasar dichos límites al deslizarla.

Cuando el ` boundsMovement ` es ` Flickable.FollowBoundsBehavior`, un valor distinto de ` Flickable.StopAtBounds ` dará la sensación de que los bordes de la vista son suaves, en lugar de un límite físico rígido.

boundsBehavior puede adoptar uno de los siguientes valores:

  • Flickable.StopAtBounds: el contenido no se puede arrastrar más allá de los límites del Flickable, y los movimientos no se saldrán de dichos límites.
  • Flickable.DragOverBounds: el contenido se puede arrastrar más allá de los límites del Flickable, pero los movimientos no sobrepasarán dichos límites.
  • Flickable.OvershootBounds: el contenido puede sobrepasar el límite al deslizarlo, pero no se puede arrastrar más allá del límite del Flickable. (desde QtQuick 2.5)
  • Flickable.DragAndOvershootBounds (predeterminado): el contenido se puede arrastrar más allá de los límites del Flickable y puede sobrepasar dichos límites al deslizarlo.

Véase también horizontalOvershoot, verticalOvershoot y boundsMovement.

boundsMovement : enumeration

Esta propiedad determina si el elemento «flickable» dará la sensación de que los bordes de la vista son suaves, en lugar de un límite físico marcado.

El valor de « boundsMovement » puede ser uno de los siguientes:

  • Flickable.StopAtBounds: permite implementar efectos de borde personalizados en los que el contenido no sigue los arrastres o deslizamientos más allá de los límites del elemento «flickable». Los valores de horizontalOvershoot y verticalOvershoot pueden utilizarse para implementar efectos de borde personalizados.
  • Flickable.FollowBoundsBehavior (predeterminado): el valor de boundsBehavior determina si el contenido sigue los movimientos de arrastre o los deslizamientos más allá de los límites del elemento deslizable.

El siguiente ejemplo mantiene el contenido dentro de los límites y, en su lugar, aplica un efecto de volteo cuando se desliza más allá de los límites horizontales:

Flickable {
    id: flickable
    boundsMovement: Flickable.StopAtBounds
    boundsBehavior: Flickable.DragAndOvershootBounds
    transform: Rotation {
        axis { x: 0; y: 1; z: 0 }
        origin.x: flickable.width / 2
        origin.y: flickable.height / 2
        angle: Math.min(30, Math.max(-30, flickable.horizontalOvershoot))
    }
}

El siguiente ejemplo mantiene el contenido dentro de los límites y, en su lugar, aplica un efecto de opacidad cuando se arrastra más allá de los límites verticales:

Flickable {
    boundsMovement: Flickable.StopAtBounds
    boundsBehavior: Flickable.DragOverBounds
    opacity: Math.max(0.5, 1.0 - Math.abs(verticalOvershoot) / height)
}

Véase también boundsBehavior, verticalOvershoot y horizontalOvershoot.

contentHeight : real

contentWidth : real

Las dimensiones del contenido (la superficie controlada por Flickable). Normalmente, este valor debe establecerse en el tamaño total de los elementos colocados en el Flickable.

El siguiente fragmento de código muestra cómo se utilizan estas propiedades para mostrar una imagen que es más grande que el propio elemento de Flickable:

import QtQuick

Flickable {
    width: 200; height: 200
    contentWidth: image.width; contentHeight: image.height

    Image { id: image; source: "bigImage.png" }
}

En algunos casos, las dimensiones del contenido se pueden establecer automáticamente en función de las propiedades « childrenRect.width » y « childrenRect.height » de « contentItem ». Por ejemplo, el fragmento de código anterior se podría reescribir así:

contentWidth: contentItem.childrenRect.width; contentHeight: contentItem.childrenRect.height

Aunque esto supone que el origen de `childrenRect` es (0, 0).

contentItem : Item [read-only]

El elemento interno que contiene los elementos que se van a desplazar en el Flickable.

Los elementos declarados como hijos de un Flickable se vinculan automáticamente al contentItem del Flickable.

Los elementos creados dinámicamente deben vincularse explícitamente al «contentItem»:

Flickable {
    id: myFlickable
    function addItem(file) {
        var component = Qt.createComponent(file)
        component.createObject(myFlickable.contentItem);
    }
}

contentX : real

contentY : real

Estas propiedades contienen la coordenada de superficie que se encuentra actualmente en la esquina superior izquierda del Flickable. Por ejemplo, si deslizas una imagen 100 píxeles hacia arriba, el valor de « contentY » aumentará en 100.

Nota: Si deslizas de nuevo hacia el origen (la esquina superior izquierda), tras la animación de rebote, contentX se estabilizará en el mismo valor que originX, y contentY en originY. Estos suelen ser (0,0); sin embargo, ListView y GridView pueden tener un origen arbitrario debido a variaciones en el tamaño del delegado o a la inserción o eliminación de elementos fuera de la región visible. Por lo tanto, si quieres implementar algo parecido a una barra de desplazamiento vertical, una forma de hacerlo es utilizar y: (contentY - originY) * (height / contentHeight) para la posición; otra forma es utilizar los valores normalizados de visibleArea.

Véase también Examples of contentX and contentY, originX y originY.

dragging : bool [read-only]

draggingHorizontally : bool [read-only]

draggingVertically : bool [read-only]

Estas propiedades indican si la vista se está desplazando actualmente en horizontal, en vertical o en ambas direcciones, debido a que el usuario la está arrastrando.

flickDeceleration : real

Esta propiedad determina la velocidad a la que se desacelera un movimiento rápido: cuanto mayor sea el valor, más rápido se ralentizará cuando el usuario deje de realizar el movimiento rápido con el dedo. Por ejemplo, 0,0001 es casi «sin fricción», mientras que 10 000 se percibe como bastante «pegajoso».

El valor por defecto depende de la plataforma. No se permiten valores iguales o inferiores a cero.

flickableDirection : enumeration

Esta propiedad determina en qué direcciones se puede deslizar la vista.

  • Flickable.AutoFlickDirection (por defecto): permite deslizar verticalmente si la altura del contenido (contentHeight) no es igual a la altura del Flickable. Permite deslizar horizontalmente si la anchura del contenido (contentWidth) no es igual a la anchura del Flickable.
  • Flickable.AutoFlickIfNeeded: permite el desplazamiento vertical si la altura del contenido (contentHeight) es mayor que la altura del Flickable. Permite el desplazamiento horizontal si la anchura del contenido (contentWidth) es mayor que la anchura del Flickable. (desde QtQuick 2.7)
  • Flickable.HorizontalFlick: permite el desplazamiento horizontal.
  • Flickable.VerticalFlick: permite deslizar el dedo verticalmente.
  • Flickable.HorizontalAndVerticalFlick: permite deslizar en ambas direcciones.

flicking : bool [read-only]

flickingHorizontally : bool [read-only]

flickingVertically : bool [read-only]

Estas propiedades indican si la vista se está desplazando en ese momento en horizontal, en vertical o en ambas direcciones, como consecuencia de que el usuario haya deslizado la vista con un movimiento rápido.

horizontalOvershoot : real [read-only]

Esta propiedad indica el sobrepaso horizontal, es decir, la distancia horizontal en la que el contenido se ha arrastrado o deslizado más allá de los límites del elemento deslizable. El valor es negativo cuando el contenido se arrastra o se desliza más allá del principio, y positivo cuando se desliza más allá del final; 0.0 en los demás casos.

El hecho de que se notifiquen los valores para el arrastre y/o el deslizamiento viene determinado por boundsBehavior. La distancia de sobrepaso se notifica incluso cuando boundsMovement es Flickable.StopAtBounds.

Véase también verticalOvershoot, boundsBehavior y boundsMovement.

horizontalVelocity : real [read-only]

verticalVelocity : real [read-only]

La velocidad instantánea de movimiento a lo largo de los ejes x e y, en píxeles/seg.

La velocidad indicada se suaviza para evitar resultados erráticos.

Ten en cuenta que, en el caso de vistas con un contenido de gran tamaño (más de 10 veces el tamaño de la vista), la velocidad del deslizamiento puede superar la velocidad del toque si se realizan varios deslizamientos rápidos y consecutivos. Esto permite al usuario desplazarse más rápidamente por contenidos de gran tamaño.

interactive : bool

Esta propiedad indica si el usuario puede interactuar con el elemento «Flickable». Un usuario no puede arrastrar ni deslizar con un movimiento rápido un elemento «Flickable» que no sea interactivo.

Por defecto, esta propiedad tiene el valor «true».

Esta propiedad resulta útil para desactivar temporalmente el deslizamiento. Esto permite una interacción especial con los elementos secundarios del Flickable; por ejemplo, es posible que quieras congelar un mapa «flickable» mientras te desplazas por un cuadro de diálogo emergente que sea un elemento secundario del Flickable.

maximumFlickVelocity : real

Esta propiedad establece la velocidad máxima a la que el usuario puede desplazar la vista con un movimiento rápido, expresada en píxeles por segundo.

El valor por defecto depende de la plataforma.

moving : bool [read-only]

movingHorizontally : bool [read-only]

movingVertically : bool [read-only]

Estas propiedades indican si la vista se está desplazando en ese momento en horizontal, en vertical o en ambas direcciones, ya sea porque el usuario la está arrastrando o porque está deslizando el dedo sobre ella.

originX : real [read-only]

originY : real [read-only]

Estas propiedades definen el origen del contenido. Este valor siempre hace referencia a la posición superior izquierda del contenido, independientemente de la dirección del diseño.

Normalmente es (0,0), aunque ListView y GridView pueden tener un origen arbitrario debido a variaciones en el tamaño de los delegados o a la inserción o eliminación de elementos fuera de la región visible.

Véase también contentX y contentY.

pixelAligned : bool

Esta propiedad establece la alineación de contentX y contentY en píxeles (true) o subpíxeles (false).

Activa «pixelAligned» para optimizar el contenido estático o el contenido en movimiento con bordes de alto contraste, como líneas de un píxel de ancho, texto o gráficos vectoriales. Desactiva «pixelAligned» cuando se optimice la calidad de la animación.

El valor predeterminado es « false ».

pressDelay : int

Esta propiedad establece el tiempo de retraso (en milisegundos) en el envío de un evento de pulsación a los elementos hijos del Flickable. Esto puede resultar útil cuando reaccionar a una pulsación antes de que se produzca una acción de deslizamiento tiene efectos indeseados.

Si se arrastra o se desliza el Flickable antes de que expire el tiempo de retardo, el evento de pulsación no se transmitirá. Si se suelta el botón dentro del tiempo de espera, se transmitirán tanto la pulsación como la liberación.

Ten en cuenta que, en el caso de Flickables anidados con la propiedad `pressDelay` establecida, el `pressDelay` de los Flickables externos queda anulado por el del Flickable más interno. Si el arrastre supera el umbral de arrastre de la plataforma, el evento de pulsación se transmitirá independientemente de esta propiedad.

Véase también QStyleHints.

rebound : Transition

Aquí se define la transición que se aplicará a la vista de contenido cuando esta vuelva a situarse dentro de los límites del elemento deslizable. La transición se activa cuando la vista se desliza o se arrastra más allá del borde del área de contenido, o cuando se llama a ` returnToBounds()`.

import QtQuick 2.0

Flickable {
    width: 150; height: 150
    contentWidth: 300; contentHeight: 300

    rebound: Transition {
        NumberAnimation {
            properties: "x,y"
            duration: 1000
            easing.type: Easing.OutBounce
        }
    }

    Rectangle {
        width: 300; height: 300
        gradient: Gradient {
            GradientStop { position: 0.0; color: "lightsteelblue" }
            GradientStop { position: 1.0; color: "blue" }
        }
    }
}

Cuando la vista anterior se desliza más allá de sus límites, volverá a ellos utilizando la transición especificada:

Si no se establece esta propiedad, se aplica una animación predeterminada.

synchronousDrag : bool

Si esta propiedad se establece en «true», cuando el ratón o el punto de contacto se desplace lo suficiente como para comenzar a arrastrar el contenido, este dará un salto, de modo que el píxel del contenido que se encontraba debajo del cursor o del punto de contacto al pulsar permanezca debajo de ese punto.

El valor por defecto es « false », lo que proporciona una experiencia más fluida (sin salto) a costa de que se «pierda» parte de la distancia de arrastre al principio.

verticalOvershoot : real [read-only]

Esta propiedad contiene el sobrepaso vertical, es decir, la distancia vertical en la que el contenido se ha arrastrado o desplazado rápidamente más allá de los límites del elemento «flickable». El valor es negativo cuando el contenido se arrastra o se desplaza rápidamente más allá del principio, y positivo cuando lo hace más allá del final; en los demás casos, 0.0.

El hecho de que se notifiquen los valores para el arrastre y/o el deslizamiento rápido viene determinado por boundsBehavior. La distancia de sobrepaso se notifica incluso cuando boundsMovement es Flickable.StopAtBounds.

Véase también « horizontalOvershoot », « boundsBehavior » y « boundsMovement ».

visibleArea group

visibleArea.heightRatio : real [read-only]

visibleArea.widthRatio : real [read-only]

visibleArea.xPosition : real [read-only]

visibleArea.yPosition : real [read-only]

Estas propiedades describen la posición y el tamaño del área que se está visualizando actualmente. El tamaño se define como el porcentaje de la vista completa que está visible en ese momento, escalado en un rango de 0,0 a 1,0. La posición de la página suele estar comprendida entre 0,0 (principio) y 1,0 menos la relación de tamaño (final); es decir, yPosition está comprendida entre 0,0 y 1,0 -heightRatio. Sin embargo, es posible que el contenido se arrastre fuera del rango normal, lo que da lugar a que las posiciones de la página también se encuentren fuera de dicho rango.

Estas propiedades se utilizan normalmente para dibujar una barra de desplazamiento. Por ejemplo:

Rectangle {
    width: 200; height: 200

    Flickable {
        id: flickable
        ...
    }

    Rectangle {
        id: scrollbar
        anchors.right: flickable.right
        y: flickable.visibleArea.yPosition * flickable.height
        width: 10
        height: flickable.visibleArea.heightRatio * flickable.height
        color: "black"
    }
}

Documentación de Signal

dragEnded()

Esta señal se emite cuando el usuario deja de arrastrar la vista.

Si la velocidad del arrastre es suficiente en el momento en que se suelta el botón táctil o del ratón, se iniciará un movimiento rápido.

Nota: El controlador correspondiente es ` onDragEnded`.

dragStarted()

Esta señal se emite cuando la vista comienza a arrastrarse debido a la interacción del usuario.

Nota: El controlador correspondiente es onDragStarted.

flickEnded()

Esta señal se emite cuando la vista deja de moverse tras un movimiento rápido o una serie de movimientos rápidos.

Nota: El controlador correspondiente es onFlickEnded.

flickStarted()

Esta señal se emite cuando se realiza un movimiento rápido sobre la vista. Un movimiento rápido comienza en el momento en que se suelta el ratón o se retira el dedo de la pantalla, mientras aún se encuentra en movimiento.

Nota: El controlador correspondiente es onFlickStarted.

movementEnded()

Esta señal se emite cuando la vista deja de moverse debido a la interacción del usuario o a la llamada a la función ` flick()`. Si había un «flick» activo, esta señal se emitirá una vez que el «flick» se detenga. Si no había ningún «flick» activo, esta señal se emitirá cuando el usuario deje de arrastrar, es decir, al soltar el ratón o al retirar el dedo de la pantalla táctil.

Nota: El controlador correspondiente es onMovementEnded.

movementStarted()

Esta señal se emite cuando la vista comienza a moverse debido a la interacción del usuario o a la llamada a la función flick().

Nota: El controlador correspondiente es onMovementStarted.

Documentación del método

void cancelFlick()

Cancela la animación de deslizamiento actual.

void flick(qreal xVelocity, qreal yVelocity)

Desplaza el contenido con una velocidad de xVelocity en horizontal y yVelocity en vertical, en píxeles por segundo.

Al llamar a este método, se actualizarán las propiedades y señales de movimiento y desplazamiento correspondientes, igual que en un desplazamiento real en una pantalla táctil.

[since 6.11] void flickTo(point position)

Desplaza el elemento desplazable hasta position.

Si al deslizar el elemento deslizable se mostrara un espacio en blanco al principio o al final del mismo, el deslizamiento se detendrá en el límite.

Este método se introdujo en Qt 6.11.

[since 6.11] void flickToChild(QQuickItem *child, PositionMode mode, point offset)

Mueve el elemento desplazable de tal forma que un elemento de ` child ` (si es un elemento secundario) quede en la posición especificada por ` mode`. ` mode ` puede ser una combinación mediante el operador «OR» de los siguientes elementos:

ConstanteDescripción
Flickable.AlignLeftDesliza el elemento secundario situado a la izquierda de la vista.
Flickable.AlignHCenterDesliza el elemento secundario situado en el centro horizontal de la vista.
Flickable.AlignRightDeslizar el elemento secundario situado a la derecha de la vista.
Flickable.AlignTopDesliza el elemento secundario situado en la parte superior de la vista.
Flickable.AlignVCenterDesliza el elemento secundario situado en el centro vertical de la vista.
Flickable.AlignBottomDesliza el elemento secundario situado en la parte inferior de la vista.
Flickable.AlignCenterLo mismo que (Flickable.AlignHCenter | Flickable.AlignVCenter)
Flickable.VisibleSi alguna parte del elemento secundario está visible, no se realiza ninguna acción. De lo contrario, se desplaza el elemento de contenido para que todo el elemento secundario quede visible.
Flickable.ContainSi el elemento secundario está visible en su totalidad, no se realiza ninguna acción. De lo contrario, se desplaza el elemento de contenido para que el elemento secundario quede visible en su totalidad. Si el elemento secundario es más grande que la vista, se dará preferencia a la parte superior izquierda del mismo.

Si no se especifica ninguna alineación vertical, se ignorará el deslizamiento vertical. Lo mismo ocurre con la alineación horizontal.

Opcionalmente, puedes especificar ` offset ` para desplazar un número adicional de píxeles más allá de la alineación de destino.

Si al desplazar el elemento desplazable en el elemento secundario se mostrara un espacio vacío al principio o al final del elemento desplazable, este dejará de desplazarse en el límite.

import QtQuick
import QtQuick.Controls
import QtQuick.Window

Flickable {
    id: flickable

    width: 200
    height: 200
    contentWidth: width
    contentHeight: column.height

    // Will flick to the beginning of the activeFocusItem every time it changes
    property Item activeFocusItem: Window.activeFocusItem
    onActiveFocusItemChanged: flickable.flickToChild(activeFocusItem, Flickable.AlignTop)

    Column {
        id: column

        spacing: 10

        Repeater {
            model: 10
            TextArea {}
        }
    }
}

Este método se introdujo en Qt 6.11.

[since 6.11] void positionViewAtChild(QQuickItem *child, PositionMode mode, point offset)

Posiciones contentX y contentY, de modo que child (si se trata de un elemento secundario) se encuentre en la posición especificada por mode. mode puede ser una combinación mediante operadores «o» de los siguientes elementos:

ConstanteDescripción
Flickable.AlignLeftColoca el elemento secundario a la izquierda de la vista.
Flickable.AlignHCenterColoca el elemento secundario en el centro horizontal de la vista.
Flickable.AlignRightColoca el elemento secundario a la derecha de la vista.
Flickable.AlignTopColoca el elemento secundario en la parte superior de la vista.
Flickable.AlignVCenterColoca el elemento secundario en el centro vertical de la vista.
Flickable.AlignBottomColoca el elemento secundario en la parte inferior de la vista.
Flickable.AlignCenterLo mismo que (Flickable.AlignHCenter | Flickable.AlignVCenter)
Flickable.VisibleSi alguna parte del elemento secundario está visible, no se realiza ninguna acción. De lo contrario, se desplaza el elemento de contenido para que todo el elemento secundario quede visible.
Flickable.ContainSi el elemento secundario está visible en su totalidad, no se realiza ninguna acción. En caso contrario, se desplaza el elemento de contenido para que el elemento secundario quede visible por completo. Si el elemento secundario es más grande que la vista, se dará preferencia a la parte superior izquierda del mismo.

Si no se especifica ninguna alineación vertical, se ignorará el posicionamiento vertical. Lo mismo ocurre con la alineación horizontal.

Opcionalmente, puedes especificar ` offset ` para desplazar ` contentX ` y `contentY ` un número adicional de píxeles más allá de la alineación de destino.

Si al colocar el elemento «flickable» en el elemento secundario se mostrara un espacio vacío al principio o al final del «flickable», este se colocará en el límite.

import QtQuick
import QtQuick.Controls
import QtQuick.Window

Flickable {
    id: flickable

    width: 200
    height: 200
    contentWidth: width
    contentHeight: column.height

    // Will center activeFocusItem in the Flickable every time it changes
    property Item activeFocusItem: Window.activeFocusItem
    onActiveFocusItemChanged: flickable.positionViewAtChild(activeFocusItem, Flickable.AlignCenter)

    Column {
        id: column

        spacing: 10

        Repeater {
            model: 10
            TextArea {}
        }
    }
}

Este método se introdujo en Qt 6.11.

void resizeContent(real width, real height, point center)

Cambia el tamaño del contenido a width x height, aproximadamente center.

Esto no escala el contenido del Flickable, sino que únicamente cambia el tamaño de contentWidth y contentHeight.

Al cambiar el tamaño del contenido, este podría quedar fuera de los límites del Flickable. Al llamar a returnToBounds() se volverá a situar el contenido dentro de los límites permitidos.

void returnToBounds()

Garantiza que el contenido se ajuste a los límites legales.

Esta función puede utilizarse para garantizar que el contenido se ajuste a los límites legales tras haberlo colocado manualmente.

© 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.