QQuickImageProvider Class

Descripción Detallada

QQuickImageProvider se utiliza para proporcionar funciones avanzadas de carga de imágenes en aplicaciones QML. Permite que las imágenes en QML sean:

• Cargadas usando QPixmaps en lugar de archivos de imagen reales
• Cargarse de forma asíncrona en un subproceso separado

Para especificar que una imagen debe ser cargada por un proveedor de imágenes, utilice el esquema "image:" para la fuente URL de la imagen, seguido de los identificadores del proveedor de imágenes y de la imagen solicitada. Por ejemplo:

Image { source: "image://myimageprovider/image.png" }

Esto especifica que la imagen debe ser cargada por el proveedor de imágenes llamado "myimageprovider", y la imagen a cargar se llama "image.png". El motor QML invoca al proveedor de imágenes adecuado según los proveedores que se hayan registrado a través de QQmlEngine::addImageProvider().

Tenga en cuenta que los identificadores no distinguen entre mayúsculas y minúsculas, pero el resto de la URL se pasará conservando mayúsculas y minúsculas. Por ejemplo, el siguiente fragmento especificaría que la imagen la carga el proveedor de imágenes llamado "miproveedordeimágenes", pero solicitaría una imagen diferente a la del fragmento anterior ("Imagen.png" en lugar de "imagen.png").

Image { source: "image://MyImageProvider/Image.png" }

Si desea que el resto de la URL no distinga entre mayúsculas y minúsculas, tendrá que hacerlo usted mismo dentro de su proveedor de imágenes.

Un ejemplo

Aquí tiene dos imágenes. Sus valores source indican que deben ser cargadas por un proveedor de imágenes llamado "colors", y las imágenes que deben cargarse son "yellow" y "red", respectivamente:

Column {
    Image { source: "image://colors/yellow" }
    Image { source: "image://colors/red" }
}

Cuando QML carga estas imágenes, busca un proveedor de imágenes que coincida y llama a su método requestImage() o requestPixmap() (dependiendo de su imageType()) para cargar la imagen. El método se llama con el parámetro id establecido en "amarillo" para la primera imagen y en "rojo" para la segunda.

A continuación se muestra una implementación de proveedor de imágenes que puede cargar las imágenes solicitadas por el QML anterior. Esta implementación genera dinámicamente imágenes QPixmap que se rellenan con el color solicitado:

class ColorImageProvider : public QQuickImageProvider
{
public:
    ColorImageProvider()
               : QQuickImageProvider(QQuickImageProvider::Pixmap)
    {
    }

    QPixmap requestPixmap(const QString &id, QSize *size, const QSize &requestedSize) override
    {
       int width = 100;
       int height = 50;

       if (size)
          *size = QSize(width, height);
       QPixmap pixmap(requestedSize.width() > 0 ? requestedSize.width() : width,
                      requestedSize.height() > 0 ? requestedSize.height() : height);
       pixmap.fill(QColor(id).rgba());
       return pixmap;
    }
};

Para que este proveedor sea accesible a QML, se registra en el motor QML con un identificador "colors":

int main(int argc, char *argv[])
{

    QQuickView view;
    QQmlEngine *engine = view.engine();
    engine->addImageProvider(QLatin1String("colors"), new ColorImageProvider);
    view.setSource(QUrl::fromLocalFile(QStringLiteral("imageprovider-example.qml")));
    view.show();
    return app.exec();
}

Ahora las imágenes se pueden cargar correctamente en QML:

Consulte el ejemplo de proveedor de imágenes para ver la implementación completa. Observe que el ejemplo registra el proveedor a través de plugin en lugar de registrarlo en la función main() de la aplicación, como se muestra más arriba.

Es posible proporcionar "@nx" high DPI syntax.

Carga asíncrona de imágenes

Los proveedores de imágenes que soportan la carga de QImage o Texture incluyen automáticamente soporte para la carga asíncrona de imágenes. Para habilitar la carga asíncrona para una fuente de imagen, establezca la propiedad asynchronous a true para el objeto Image o BorderImage relevante. Cuando se activa esta opción, la solicitud de imágenes al proveedor se ejecuta en un subproceso de baja prioridad, lo que permite que la carga de imágenes se ejecute en segundo plano y reduce el impacto en el rendimiento de la interfaz de usuario.

Para forzar la carga asíncrona de imágenes, incluso para fuentes de imágenes que no tengan la propiedad asynchronous establecida en true, puede pasar la bandera QQmlImageProviderBase::ForceAsynchronousImageLoading al constructor del proveedor de imágenes. Esto asegura que todas las peticiones de imágenes para el proveedor se gestionan en un hilo separado.

La carga asíncrona para proveedores de imágenes que proporcionan QPixmap sólo se admite en plataformas que tienen la función ThreadedPixmaps, en plataformas en las que los mapas de píxeles sólo se pueden crear en el subproceso principal (es decir, ThreadedPixmaps no está soportado) si asynchronous se establece en true, el valor se ignora y la imagen se carga de forma síncrona.

La carga asíncrona de imágenes para proveedores de tipo distinto a ImageResponse se ejecuta en un único hilo por motor. Esto significa que un proveedor de imágenes lento bloqueará la carga de cualquier otra solicitud. Para evitarlo, le sugerimos que utilice QQuickAsyncImageProvider e implemente un subproceso en el lado del proveedor a través de QThreadPool o similar. Vea el Ejemplo de Proveedor de Respuesta de Imagen para una implementación completa.

Almacenamiento en caché de imágenes

Las imágenes devueltas por un QQuickImageProvider son automáticamente cacheadas, similar a cualquier imagen cargada por el motor QML. Cuando una imagen con un prefijo "image://" es cargada desde la caché, requestImage() y requestPixmap() no serán llamados para el proveedor de imagen relevante. Si una imagen debe obtenerse siempre del proveedor de imágenes y no debe almacenarse en caché, establezca la propiedad cache en false para el objeto Image o BorderImage correspondiente.