Flickable QML Type
Ofrece una superficie sobre la que se puede «deslizar el dedo». Más...
| Import Statement: | import QtQuick |
| Inherits: | |
| Inherited By: | GridView, HorizontalHeaderView, ListView, TableView, TreeView, and VerticalHeaderView |
Propiedades
- acceptedButtons : flags
(since 6.9) - atXBeginning : bool
- atXEnd : bool
- atYBeginning : bool
- atYEnd : bool
- bottomMargin : real
- boundsBehavior : enumeration
- boundsMovement : enumeration
- contentHeight : real
- contentItem : Item
- contentWidth : real
- contentX : real
- contentY : real
- dragging : bool
- draggingHorizontally : bool
- draggingVertically : bool
- flickDeceleration : real
- flickableDirection : enumeration
- flicking : bool
- flickingHorizontally : bool
- flickingVertically : bool
- horizontalOvershoot : real
- horizontalVelocity : real
- interactive : bool
- leftMargin : real
- maximumFlickVelocity : real
- moving : bool
- movingHorizontally : bool
- movingVertically : bool
- originX : real
- originY : real
- pixelAligned : bool
- pressDelay : int
- rebound : Transition
- rightMargin : real
- synchronousDrag : bool
- topMargin : real
- verticalOvershoot : real
- verticalVelocity : real
- visibleArea
- visibleArea.heightRatio : real
- visibleArea.widthRatio : real
- visibleArea.xPosition : real
- visibleArea.yPosition : real
Señales
Métodos
- void cancelFlick()
- void flick(qreal xVelocity, qreal yVelocity)
- void flickTo(point position)
(since 6.11) - void flickToChild(QQuickItem *child, PositionMode mode, point offset)
(since 6.11) - void positionViewAtChild(QQuickItem *child, PositionMode mode, point offset)
(since 6.11) - void resizeContent(real width, real height, point center)
- void returnToBounds()
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.
| Tanto contentX como contentY son 0. |
| Tanto « contentX » como « contentY » son 50. |
| contentX es -50 y contentY es 50. |
| Tanto el « contentX » como el « contentY » son -50. |
| 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.
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.
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.heightAunque 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);
}
}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.
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.
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.
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:
| Constante | Descripción |
|---|---|
Flickable.AlignLeft | Desliza el elemento secundario situado a la izquierda de la vista. |
Flickable.AlignHCenter | Desliza el elemento secundario situado en el centro horizontal de la vista. |
Flickable.AlignRight | Deslizar el elemento secundario situado a la derecha de la vista. |
Flickable.AlignTop | Desliza el elemento secundario situado en la parte superior de la vista. |
Flickable.AlignVCenter | Desliza el elemento secundario situado en el centro vertical de la vista. |
Flickable.AlignBottom | Desliza el elemento secundario situado en la parte inferior de la vista. |
Flickable.AlignCenter | Lo mismo que (Flickable.AlignHCenter | Flickable.AlignVCenter) |
Flickable.Visible | Si 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.Contain | Si 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:
| Constante | Descripción |
|---|---|
Flickable.AlignLeft | Coloca el elemento secundario a la izquierda de la vista. |
Flickable.AlignHCenter | Coloca el elemento secundario en el centro horizontal de la vista. |
Flickable.AlignRight | Coloca el elemento secundario a la derecha de la vista. |
Flickable.AlignTop | Coloca el elemento secundario en la parte superior de la vista. |
Flickable.AlignVCenter | Coloca el elemento secundario en el centro vertical de la vista. |
Flickable.AlignBottom | Coloca el elemento secundario en la parte inferior de la vista. |
Flickable.AlignCenter | Lo mismo que (Flickable.AlignHCenter | Flickable.AlignVCenter) |
Flickable.Visible | Si 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.Contain | Si 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.




