Escalabilidad
Al desarrollar aplicaciones para varias plataformas de dispositivos móviles diferentes, te enfrentas a los siguientes retos:
- Las plataformas de dispositivos móviles admiten dispositivos con diferentes configuraciones de pantalla: tamaño, relación de aspecto, orientación y densidad.
- Las distintas plataformas tienen diferentes convenciones de interfaz de usuario y es necesario satisfacer las expectativas de los usuarios en cada una de ellas.
Qt Quick te permite desarrollar aplicaciones que pueden ejecutarse en distintos tipos de dispositivos, como tabletas y teléfonos móviles. En concreto, pueden adaptarse a diferentes configuraciones de pantalla. Sin embargo, siempre es necesario realizar ciertos ajustes y retoques para crear una experiencia de usuario óptima en cada plataforma de destino.
Debes tener en cuenta la escalabilidad cuando:
- Desees implementar tu aplicación en más de una plataforma de dispositivos, como Android e iOS, o en más de una configuración de pantalla de dispositivo.
- Desea estar preparado para nuevos dispositivos que puedan aparecer en el mercado tras su implementación inicial.
Para implementar aplicaciones escalables utilizando Qt Quick:
- Diseña interfaces de usuario utilizando los controles de «Qt Quick », que proporcionan conjuntos de controles de interfaz de usuario.
- Define diseños mediante los diseños deQt Quick , que permiten redimensionar sus elementos.
- Utiliza el enlace de propiedades para implementar casos de uso no cubiertos por los diseños. Por ejemplo, para mostrar versiones alternativas de imágenes en pantallas con baja y alta densidad de píxeles o adaptar automáticamente el contenido de la vista según la orientación actual de la pantalla.
- Selecciona un dispositivo de referencia y calcula una relación de escala para ajustar el tamaño de las imágenes y las fuentes, así como los márgenes, al tamaño real de la pantalla.
- Carga recursos específicos de la plataforma mediante selectores de archivos.
- Carga componentes bajo demanda utilizando un Loader.
Ten en cuenta los siguientes patrones al diseñar tu aplicación:
- El contenido de una vista puede ser bastante similar en todos los tamaños de pantalla, pero con un área de contenido ampliada. Si utilizas el tipo QML « ApplicationWindow » de los controles « Qt Quick », este calculará automáticamente el tamaño de la ventana basándose en los tamaños de sus elementos de contenido. Si utilizas diseños « Qt Quick » para posicionar los elementos de contenido, estos redimensionarán automáticamente los elementos que se les asignen.
- El contenido de una página completa en un dispositivo más pequeño podría constituir un elemento de un diseño en un dispositivo más grande. Por lo tanto, considera la posibilidad de convertirlo en un componente independiente (es decir, definido en un archivo QML aparte) y, en el dispositivo más pequeño, la vista simplemente contendrá una instancia de ese componente. En el dispositivo más grande, puede haber espacio suficiente para utilizar cargadores que muestren elementos adicionales. Por ejemplo, en un visor de correo electrónico, si la pantalla es lo suficientemente grande, podría ser posible mostrar la vista de lista de correos y la vista de lectura de correos una al lado de la otra.
- En el caso de los juegos, lo habitual es crear un tablero de juego que no se redimensione, para no proporcionar una ventaja injusta a los jugadores con pantallas más grandes. Una solución consiste en definir una zona segura que se ajuste a la pantalla con la relación de aspecto más pequeña compatible (normalmente, 3:2) y añadir contenido meramente decorativo en el espacio que quedará oculto en una pantalla de 4:3 o 16:9.
Cambiar el tamaño de las ventanas de la aplicación de forma dinámica
Qt Quick Los controles proporcionan un conjunto de controles de interfaz de usuario para crear interfaces de usuario en Qt Quick. Normalmente, se declara un control ` ApplicationWindow ` como elemento raíz de la aplicación. El control ` ApplicationWindow ` facilita el posicionamiento de otros controles, como ` MenuBar`, ` ToolBar` y `StatusBar`, de forma independiente de la plataforma. El control ` ApplicationWindow ` utiliza las restricciones de tamaño de los elementos de contenido como entrada a la hora de calcular las restricciones de tamaño efectivas de la ventana real.
Además de los controles que definen las partes estándar de las ventanas de las aplicaciones, se proporcionan controles para crear vistas y menús, así como para presentar o recibir entradas de los usuarios. Puedes utilizar los estilos de control deQt Quick para aplicar estilos personalizados a los controles predefinidos.
Qt Quick Los controles, como el « ToolBar », no proporcionan un diseño propio, sino que requieren que se posicione su contenido. Para ello, puede utilizar los diseños de « Qt Quick ».
Diseño dinámico de los controles de pantalla
Qt Quick Los diseños ofrecen formas de distribuir los controles de pantalla en filas, columnas o cuadrículas, utilizando los tipos QML ` RowLayout`, ` ColumnLayout` y ` GridLayout `. Las propiedades de estos tipos QML definen la dirección del diseño y el espaciado entre las celdas.
Puede utilizar los tipos QML de diseñosQt Quick para asociar propiedades adicionales a los elementos añadidos a los diseños. Por ejemplo, puede especificar valores mínimos, máximos y preferidos para la altura, la anchura y el tamaño de los elementos.
Los diseños garantizan que las interfaces de usuario se escalen correctamente cuando se cambia el tamaño de las ventanas y las pantallas, y que siempre utilicen el máximo espacio disponible.
Un caso de uso específico del tipo « GridLayout » es utilizarlo como fila o como columna en función de la orientación de la pantalla.

El siguiente fragmento de código utiliza la propiedad ` flow ` para establecer el flujo de la cuadrícula de izquierda a derecha (como una fila) cuando el ancho de la pantalla es mayor que su altura y, en caso contrario, de arriba abajo (como una columna):
ApplicationWindow {
id: root
visible: true
width: 480
height: 620
GridLayout {
anchors.fill: parent
anchors.margins: 20
rowSpacing: 20
columnSpacing: 20
flow: width > height ? GridLayout.LeftToRight : GridLayout.TopToBottom
Rectangle {
Layout.fillWidth: true
Layout.fillHeight: true
color: "#5d5b59"
Label {
anchors.centerIn: parent
text: "Top or left"
color: "white"
}
}
Rectangle {
Layout.fillWidth: true
Layout.fillHeight: true
color: "#1e1b18"
Label {
anchors.centerIn: parent
text: "Bottom or right"
color: "white"
}
}
}
}El cambio constante de tamaño y el recálculo de las pantallas conllevan un coste de rendimiento. Es posible que los dispositivos móviles y embebidos no dispongan de la potencia necesaria para recalcular el tamaño y la posición de los objetos animados en cada fotograma, por ejemplo. Si te encuentras con problemas de rendimiento al utilizar diseños, plantéate utilizar otros métodos, como los enlaces, en su lugar.
A continuación se indican algunas cosas que no debes hacer con los diseños:
- No establezcas enlaces a las propiedades x, y, width o height de los elementos de un diseño, ya que esto entraría en conflicto con el objetivo del diseño y, además, provocaría bucles de enlace.
- No definas funciones JavaScript complejas que se evalúen con regularidad. Esto provocará un rendimiento deficiente, especialmente durante las transiciones animadas.
- No hagas suposiciones sobre el tamaño del contenedor ni sobre el de los elementos secundarios. Intenta crear definiciones de diseño flexibles que puedan adaptarse a los cambios en el espacio disponible.
- No utilices diseños si quieres que el diseño sea «pixel perfect». Los elementos de contenido se redimensionarán y posicionarán automáticamente en función del espacio disponible.
Uso de enlaces
Si los diseños de « Qt Quick » no se ajustan a tus necesidades, puedes recurrir al uso de enlaces de propiedades. Los enlaces permiten que los objetos actualicen automáticamente sus propiedades en respuesta a cambios en los atributos de otros objetos o a la ocurrencia de algún evento externo.
Cuando se asigna un valor a la propiedad de un objeto, este puede ser un valor estático o estar vinculado a una expresión de JavaScript. En el primer caso, el valor de la propiedad no cambiará a menos que se le asigne un nuevo valor. En el segundo caso, se crea un enlace de propiedad y el motor de QML actualiza automáticamente el valor de la propiedad cada vez que cambia el valor de la expresión evaluada.
Este tipo de enlace es el más dinámico. Sin embargo, la evaluación constante de expresiones de JavaScript conlleva un coste de rendimiento.
Puedes utilizar enlaces para gestionar la densidad de píxeles baja y alta en plataformas que no la admiten automáticamente (como sí lo hacen Android, macOS e iOS). El siguiente fragmento de código utiliza la propiedad adjunta « Screen.pixelDensity » para especificar diferentes imágenes que se mostrarán en pantallas con densidad de píxeles baja, alta o normal:
Image {
source: {
if (Screen.pixelDensity < 40)
"image_low_dpi.png"
else if (Screen.pixelDensity > 300)
"image_high_dpi.png"
else
"image.png"
}
}En Android, macOS e iOS, puedes proporcionar recursos alternativos con resoluciones más altas utilizando el identificador correspondiente (por ejemplo, @2x, @3x o @4x) para iconos e imágenes, y colocarlos en el archivo de recursos. Se selecciona automáticamente para su uso la versión que se ajusta a la densidad de píxeles de la pantalla.
Por ejemplo, el siguiente fragmento de código intentará cargar artwork@2x.png en pantallas Retina:
Image {
source: "artwork.png"
}Gestión de la densidad de píxeles
Algunos tipos de QML, como Image, BorderImage y Text, se escalan automáticamente según las propiedades especificadas para ellos. Si no se especifican el ancho y el alto de una imagen (Image), esta utiliza automáticamente el tamaño de la imagen de origen, especificado mediante la propiedad source. De forma predeterminada, al especificar el ancho y la altura, la imagen se escala a ese tamaño. Este comportamiento se puede modificar configurando la propiedad ` fillMode `, lo que permite que la imagen se estire y se repita en mosaico. Sin embargo, el tamaño original de la imagen podría parecer demasiado pequeño en pantallas con un DPI elevado.
Se utiliza un « BorderImage » para crear bordes a partir de imágenes escalando o repitiendo partes de cada imagen. Divide una imagen de origen en 9 regiones que se escalan o repiten según los valores de las propiedades. Sin embargo, las esquinas no se escalan en absoluto, lo que puede hacer que los resultados no sean óptimos en pantallas con alta resolución (DPI).
El tipo QML « Text » intenta determinar cuánto espacio se necesita y establece las propiedades « width » y « height » en consecuencia, a menos que se hayan definido explícitamente. La propiedad « fontPointSize » establece el tamaño en puntos de forma independiente del dispositivo. Sin embargo, especificar fuentes en puntos y otros tamaños en píxeles causa problemas, ya que los puntos son independientes de la densidad de la pantalla. Es probable que un marco alrededor de una cadena que se vea correcto en pantallas con baja resolución (DPI) resulte demasiado pequeño en pantallas con alta resolución (DPI), lo que provocará que el texto quede recortado.
El nivel de compatibilidad con alta resolución (DPI) y las técnicas utilizadas por las plataformas compatibles varían de una plataforma a otra. Las secciones siguientes describen diferentes enfoques para escalar el contenido de la pantalla en pantallas de alta resolución (DPI).
Para obtener más información sobre la compatibilidad con alta resolución (DPI) en Qt y las plataformas compatibles, consulta Alta resolución (DPI).
Escalado de alta resolución
Si un dispositivo de destino admite el escalado de alta resolución, el sistema operativo proporciona a Qt una relación de escalado que se utiliza para escalar la salida gráfica.
La ventaja de este enfoque es que los gráficos vectoriales y las fuentes se escalan automáticamente y las aplicaciones existentes suelen funcionar sin necesidad de modificaciones. Sin embargo, para el contenido rasterizado se necesitan recursos alternativos de alta resolución.
El escalado está implementado para las pilas de « Qt Quick » y « Qt Widgets », además de contar con compatibilidad general en Qt GUI.
Las API gráficas de bajo nivel operan en píxeles del dispositivo. Esto incluye el código que utiliza la API de OpenGL y el que utiliza la API de « QRhi ». Por ejemplo, esto significa que un QWindow con una resolución de pantalla ( size() ) de 1280x720 y un factor de escalado ( QWindow::devicePixelRatio) de 2 tiene un objetivo de renderizado (swapchain) con un tamaño de píxel de dispositivo de 2560x1440.
El sistema operativo escala la geometría de la ventana, los eventos y el escritorio. El complemento de la plataforma Cocoa establece la relación de escala como QWindow::devicePixelRatio() o QScreen::devicePixelRatio(), así como en el almacén de respaldo.
En el caso de ` Qt Widgets`, ` QPainter ` toma ` devicePixelRatio() ` del almacén de respaldo y lo interpreta como una relación de escalado.
Sin embargo, en OpenGL, los píxeles son siempre píxeles del dispositivo. Por ejemplo, la geometría pasada a glViewport() debe escalarse mediante devicePixelRatio().
Los tamaños de fuente especificados (en puntos o píxeles) no cambian y las cadenas conservan su tamaño relativo en comparación con el resto de la interfaz de usuario. Las fuentes se escalan como parte del proceso de dibujo, de modo que una fuente de tamaño 12 se convierte efectivamente en una de tamaño 24 con un escalado de 2x, independientemente de si se especifica en puntos o en píxeles. La unidad px se interpreta como píxeles independientes del dispositivo para garantizar que las fuentes no aparezcan más pequeñas en una pantalla con un DPI alto.
Cálculo de la relación de escalado
Puedes seleccionar un dispositivo de alto DPI como dispositivo de referencia y calcular una relación de escalado para ajustar los tamaños de las imágenes y las fuentes, así como los márgenes, al tamaño real de la pantalla.
El siguiente fragmento de código utiliza valores de referencia para los DPI, la altura y la anchura del dispositivo Android Nexus 5, el tamaño real de la pantalla devuelto por la clase ` QRect ` y el valor de DPI lógico de la pantalla devuelto por el puntero global ` qApp ` para calcular una relación de escala para los tamaños de las imágenes y los márgenes (m_ratio) y otra para los tamaños de las fuentes (m_ratioFont):
qreal refDpi = 216.;
qreal refHeight = 1776.;
qreal refWidth = 1080.;
QRect rect = QGuiApplication::primaryScreen()->geometry();
qreal height = qMax(rect.width(), rect.height());
qreal width = qMin(rect.width(), rect.height());
qreal dpi = QGuiApplication::primaryScreen()->logicalDotsPerInch();
m_ratio = qMin(height/refHeight, width/refWidth);
m_ratioFont = qMin(height*refDpi/(dpi*refHeight), width*refDpi/(dpi*refWidth));Para obtener una relación de escalado razonable, los valores de altura y anchura deben establecerse de acuerdo con la orientación predeterminada del dispositivo de referencia, que en este caso es la orientación vertical.
El siguiente fragmento de código establece la relación de escala de la fuente en 1 si fuera inferior a uno y, por lo tanto, provocara que los tamaños de fuente resultaran demasiado pequeños:
int tempTimeColumnWidth = 600;
int tempTrackHeaderWidth = 270;
if (m_ratioFont < 1.) {
m_ratioFont = 1;Deberías probar con los dispositivos de destino para detectar casos extremos que requieran cálculos adicionales. Algunas pantallas pueden ser demasiado cortas o estrechas para albergar todo el contenido previsto y, por lo tanto, requerir su propio diseño. Por ejemplo, es posible que tengas que ocultar o sustituir parte del contenido en pantallas con relaciones de aspecto atípicas, como 1:1.
La relación de escala se puede aplicar a todos los tamaños de un QQmlPropertyMap para escalar imágenes, fuentes y márgenes:
m_sizes = new QQmlPropertyMap(this);
m_sizes->insert(QLatin1String("trackHeaderHeight"), QVariant(applyRatio(270)));
m_sizes->insert(QLatin1String("trackHeaderWidth"), QVariant(applyRatio(tempTrackHeaderWidth)));
m_sizes->insert(QLatin1String("timeColumnWidth"), QVariant(applyRatio(tempTimeColumnWidth)));
m_sizes->insert(QLatin1String("conferenceHeaderHeight"), QVariant(applyRatio(158)));
m_sizes->insert(QLatin1String("dayWidth"), QVariant(applyRatio(150)));
m_sizes->insert(QLatin1String("favoriteImageHeight"), QVariant(applyRatio(76)));
m_sizes->insert(QLatin1String("favoriteImageWidth"), QVariant(applyRatio(80)));
m_sizes->insert(QLatin1String("titleHeight"), QVariant(applyRatio(60)));
m_sizes->insert(QLatin1String("backHeight"), QVariant(applyRatio(74)));
m_sizes->insert(QLatin1String("backWidth"), QVariant(applyRatio(42)));
m_sizes->insert(QLatin1String("logoHeight"), QVariant(applyRatio(100)));
m_sizes->insert(QLatin1String("logoWidth"), QVariant(applyRatio(286)));
m_fonts = new QQmlPropertyMap(this);
m_fonts->insert(QLatin1String("six_pt"), QVariant(applyFontRatio(9)));
m_fonts->insert(QLatin1String("seven_pt"), QVariant(applyFontRatio(10)));
m_fonts->insert(QLatin1String("eight_pt"), QVariant(applyFontRatio(12)));
m_fonts->insert(QLatin1String("ten_pt"), QVariant(applyFontRatio(14)));
m_fonts->insert(QLatin1String("twelve_pt"), QVariant(applyFontRatio(16)));
m_margins = new QQmlPropertyMap(this);
m_margins->insert(QLatin1String("five"), QVariant(applyRatio(5)));
m_margins->insert(QLatin1String("seven"), QVariant(applyRatio(7)));
m_margins->insert(QLatin1String("ten"), QVariant(applyRatio(10)));
m_margins->insert(QLatin1String("fifteen"), QVariant(applyRatio(15)));
m_margins->insert(QLatin1String("twenty"), QVariant(applyRatio(20)));
m_margins->insert(QLatin1String("thirty"), QVariant(applyRatio(30)));Las funciones del siguiente fragmento de código aplican la relación de escalado a las fuentes, las imágenes y los márgenes:
int Theme::applyFontRatio(const int value)
{
return int(value * m_ratioFont);
}
int Theme::applyRatio(const int value)
{
return qMax(2, int(value * m_ratio));
}Esta técnica ofrece resultados razonables cuando los tamaños de pantalla de los dispositivos de destino no difieren demasiado. Si las diferencias son muy grandes, plantéate crear varios diseños diferentes con distintos valores de referencia.
Carga de archivos en función de la plataforma
Puede utilizar el « QQmlFileSelector » para aplicar un « QFileSelector » a la carga de archivos QML. Esto le permite cargar recursos alternativos en función de la plataforma en la que se ejecute la aplicación. Por ejemplo, puede utilizar el selector de archivos « +android » para cargar diferentes archivos de imagen cuando se ejecute en dispositivos Android.
Puedes utilizar los selectores de archivos junto con objetos singleton para acceder a una única instancia de un objeto en una plataforma concreta.
Los selectores de archivos son estáticos e imponen una estructura de archivos en la que los archivos específicos de cada plataforma se almacenan en subcarpetas que llevan el nombre de la plataforma. Si necesitas una solución más dinámica para cargar partes de tu interfaz de usuario bajo demanda, puedes utilizar un Loader.
Las plataformas de destino pueden automatizar la carga de recursos alternativos para diferentes densidades de pantalla de diversas formas. En Android e iOS, se utiliza el sufijo @2x en los nombres de archivo para indicar versiones de imágenes con alta resolución (DPI). El tipo QML Image y la clase QIcon cargan automáticamente las versiones @2x de las imágenes e iconos si están disponibles. Las clases « QImage » y « QPixmap » establecen automáticamente el « devicePixelRatio » de las versiones @2x de las imágenes en « 2 », pero es necesario añadir código para utilizar realmente las versiones @2x:
if ( QGuiApplication::primaryScreen()->devicePixelRatio() >= 2 ) {
imageVariant = "@2x";
} else {
imageVariant = "";
}Android define tamaños de pantalla generalizados (pequeño, normal, grande, extragrande) y densidades (ldpi, mdpi, hdpi, xhdpi, xxhdpi y xxxhdpi) para los que puedes crear recursos alternativos. Android detecta la configuración actual del dispositivo en tiempo de ejecución y carga los recursos adecuados para tu aplicación. Sin embargo, a partir de Android 3.2 (nivel de API 13), estos grupos de tamaños han quedado obsoletos en favor de una nueva técnica para gestionar los tamaños de pantalla basada en el ancho de pantalla disponible.
Carga de componentes bajo demanda
Un « Loader » puede cargar un archivo QML (mediante la propiedad ` source `) o un objeto «Component» (mediante la propiedad ` sourceComponent `). Resulta útil para retrasar la creación de un componente hasta que sea necesario. Por ejemplo, cuando un componente debe crearse bajo demanda, o cuando no debe crearse innecesariamente por motivos de rendimiento.
También puedes utilizar los «loaders» para reaccionar ante situaciones en las que algunas partes de tu interfaz de usuario no sean necesarias en una plataforma concreta, ya que esta no admite ciertas funcionalidades. En lugar de mostrar una vista que no se necesita en el dispositivo en el que se ejecuta la aplicación, puedes hacer que la vista quede oculta y utilizar los «loaders» para mostrar algo diferente en su lugar.
Cambio de orientación
La propiedad adjunta ` Screen.orientation ` contiene la orientación actual de la pantalla, obtenida del acelerómetro (si está disponible). En un ordenador de sobremesa, este valor no suele cambiar.
Si ` primaryOrientation ` sigue el valor ` orientation`, significa que la pantalla gira automáticamente todo el contenido que se muestra, dependiendo de cómo se sujete el dispositivo. Si la orientación cambia aunque ` primaryOrientation ` no cambie, es posible que el dispositivo no gire su propia pantalla. En ese caso, puede que tengas que utilizar ` Item.rotation ` o ` Item.transform ` para girar el contenido.
Las definiciones de las páginas de nivel superior de la aplicación y las definiciones de componentes reutilizables deben utilizar una única definición de diseño QML para la estructura de diseño. Esta única definición debe incluir el diseño para las distintas orientaciones del dispositivo y relaciones de aspecto. El motivo es que el rendimiento durante un cambio de orientación es fundamental, por lo que conviene asegurarse de que todos los componentes necesarios para ambas orientaciones se carguen cuando cambie la orientación.
Por el contrario, debes realizar pruebas exhaustivas si decides utilizar un « Loader » para cargar código QML adicional necesario en orientaciones distintas, ya que esto afectará al rendimiento del cambio de orientación.
Para habilitar las animaciones de diseño entre las orientaciones, las definiciones de anclaje deben residir dentro del mismo componente contenedor. Por lo tanto, la estructura de una página o un componente debe consistir en un conjunto común de componentes hijos, un conjunto común de definiciones de anclaje y una colección de estados (definidos en un « StateGroup ») que representen las diferentes relaciones de aspecto admitidas por el componente.
Si un componente contenido en una página debe alojarse en numerosas definiciones de factor de forma diferentes, los estados de diseño de la vista deben depender de la relación de aspecto de la página (su contenedor inmediato). Del mismo modo, diferentes instancias de un componente pueden estar situadas dentro de numerosos contenedores diferentes en una interfaz de usuario, por lo que sus estados de diseño deben estar determinados por la relación de aspecto de su padre. La conclusión es que los estados de diseño siempre deben seguir la relación de aspecto del contenedor directo (no la «orientación» de la pantalla del dispositivo actual).
Dentro de cada e State o de diseño, debes definir las relaciones entre los elementos utilizando definiciones de diseño nativas de QML. Consulta más abajo para obtener más información. Durante las transiciones entre los estados (desencadenadas por el cambio de orientación del nivel superior), en el caso de los diseños de anclaje, se pueden utilizar elementos « AnchorAnimation » para controlar las transiciones. En algunos casos, también puede utilizar un « NumberAnimation » (por ejemplo, sobre el ancho de un elemento). Recuerde evitar cálculos complejos en JavaScript durante cada fotograma de la animación. El uso de definiciones de anclaje sencillas y animaciones de anclaje puede ser de ayuda en la mayoría de los casos.
Hay algunos casos adicionales que hay que tener en cuenta:
- ¿Qué ocurre si tienes una única página que tiene un aspecto completamente diferente en orientación horizontal y vertical, es decir, que todos los elementos secundarios son distintos? Para cada página, utiliza dos componentes secundarios, con definiciones de diseño independientes, y haz que uno u otro de los elementos tenga opacidad cero en cada estado. Puedes utilizar una animación de fundido cruzado simplemente aplicando una transición « NumberAnimation » a la opacidad.
- ¿Qué ocurre si tienes una sola página que comparte el 30 % o más del mismo contenido de diseño entre los modos vertical y horizontal? En ese caso, plantéate utilizar un único componente con estados de orientación horizontal y vertical, y un conjunto de elementos secundarios independientes cuya opacidad (o posición) dependa del estado de orientación. Esto te permitirá utilizar animaciones de diseño para los elementos que se comparten entre ambas orientaciones, mientras que los demás elementos se mostrarán o ocultarán con un efecto de fundido, o aparecerán o desaparecerán de la pantalla de forma animada.
- ¿Qué ocurre si tienes dos páginas en un dispositivo portátil que deben aparecer en pantalla al mismo tiempo, por ejemplo, en un dispositivo de mayor tamaño? En este caso, ten en cuenta que tu componente de vista ya no ocupará toda la pantalla. Por lo tanto, es importante recordar que todos los componentes (en particular, los elementos delegados de lista) deben basarse en el ancho del componente que los contiene, y no en el ancho de la pantalla. En este caso, puede ser necesario establecer el ancho en un controlador Component.onCompleted(), para garantizar que el elemento delegado de la lista se haya construido antes de establecer el valor.
- ¿Qué ocurre si las dos orientaciones ocupan demasiada memoria como para tenerlas ambas en memoria a la vez? Utiliza un « Loader » si es necesario, en caso de que no puedas mantener ambas versiones de la vista en memoria a la vez, pero ten en cuenta el rendimiento de la animación de fundido cruzado durante el cambio de diseño. Una solución podría consistir en tener dos elementos de «pantalla de inicio» que sean hijos de la página; de este modo, se realiza un fundido cruzado entre ellos durante la rotación. A continuación, se puede utilizar un ` Loader ` para cargar otro componente hijo que cargue los datos reales del modelo en otro elemento hijo, y realizar un fundido cruzado hacia este cuando se haya completado el ` Loader `.
Véase también «Diseños adaptativos»enQt Quick .
© 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.