QQuickImageProvider Class

Description détaillée

QQuickImageProvider est utilisé pour fournir des fonctionnalités avancées de chargement d'images dans les applications QML. Il permet aux images en QML d'être :

• chargées à l'aide de QPixmaps plutôt qu'à l'aide de fichiers d'images réels
• chargées de manière asynchrone dans un thread séparé.

Pour spécifier qu'une image doit être chargée par un fournisseur d'images, utilisez le schéma "image :" pour la source URL de l'image, suivi des identifiants du fournisseur d'images et de l'image demandée. Voici un exemple :

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

Ceci spécifie que l'image doit être chargée par le fournisseur d'images nommé "myimageprovider", et que l'image à charger est nommée "image.png". Le moteur QML invoque le fournisseur d'images approprié en fonction des fournisseurs qui ont été enregistrés via QQmlEngine::addImageProvider().

Notez que les identifiants sont insensibles à la casse, mais que le reste de l'URL sera transmis en préservant la casse. Par exemple, l'extrait ci-dessous spécifierait toujours que l'image est chargée par le fournisseur d'images nommé "myimageprovider", mais il demanderait une image différente de celle de l'extrait ci-dessus ("Image.png" au lieu de "image.png").

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

Si vous souhaitez que le reste de l'URL ne tienne pas compte de la casse, vous devrez vous en charger vous-même dans votre fournisseur d'images.

Un exemple

Voici deux images. Leurs valeurs source indiquent qu'elles doivent être chargées par un fournisseur d'images nommé "colors", et que les images à charger sont respectivement "yellow" et "red" :

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

Lorsque ces images sont chargées par QML, celui-ci recherche un fournisseur d'images correspondant et appelle sa méthode requestImage() ou requestPixmap() (en fonction de sa méthode imageType()) pour charger l'image. La méthode est appelée avec le paramètre id réglé sur "yellow" pour la première image, et sur "red" pour la seconde.

Voici une implémentation d'un fournisseur d'images qui peut charger les images demandées par le QML ci-dessus. Cette implémentation génère dynamiquement des images QPixmap qui sont remplies avec la couleur demandée :

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;
    }
};

Pour rendre ce fournisseur accessible à QML, il est enregistré auprès du moteur QML avec un identifiant "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();
}

Les images peuvent maintenant être chargées avec succès dans QML :

Voir l'exemple de fournisseur d'images pour la mise en œuvre complète. Notez que l'exemple enregistre le fournisseur via un plugin au lieu de l'enregistrer dans la fonction main() de l'application, comme indiqué ci-dessus.

Il est possible de fournir "@nx" high DPI syntax.

Chargement asynchrone d'images

Les fournisseurs d'images qui prennent en charge le chargement de QImage ou de Texture incluent automatiquement la prise en charge du chargement asynchrone des images. Pour activer le chargement asynchrone d'une source d'images, définissez la propriété asynchronous sur true pour l'objet Image ou BorderImage concerné. Lorsque cette option est activée, la demande d'image au fournisseur est exécutée dans un thread de faible priorité, ce qui permet d'exécuter le chargement de l'image en arrière-plan et de réduire l'impact sur les performances de l'interface utilisateur.

Pour forcer le chargement asynchrone des images, même pour les sources d'images dont la propriété asynchronous n'est pas définie sur true, vous pouvez passer le drapeau QQmlImageProviderBase::ForceAsynchronousImageLoading au constructeur du fournisseur d'images. Cela garantit que toutes les demandes d'images pour le fournisseur sont traitées dans un thread séparé.

Le chargement asynchrone pour les fournisseurs d'images qui fournissent QPixmap n'est pris en charge que sur les plateformes qui disposent de la fonctionnalité ThreadedPixmaps. Sur les plateformes où les pixmaps ne peuvent être créées que dans le thread principal (c'est-à-dire que ThreadedPixmaps n'est pas pris en charge), si asynchronous est défini sur true, la valeur est ignorée et l'image est chargée de manière synchrone.

Le chargement asynchrone d'images pour les fournisseurs de type autre que ImageResponse est exécuté sur la base d'un seul thread par moteur. Cela signifie qu'un fournisseur d'images lent bloquera le chargement de toute autre demande. Pour éviter cela, nous suggérons d'utiliser QQuickAsyncImageProvider et d'implémenter le threading du côté du fournisseur via un QThreadPool ou similaire. Voir l'exemple de fournisseur de réponse d'image pour une implémentation complète.

Mise en cache des images

Les images renvoyées par un QQuickImageProvider sont automatiquement mises en cache, comme toute image chargée par le moteur QML. Lorsqu'une image avec un préfixe "image://" est chargée à partir du cache, requestImage() et requestPixmap() ne seront pas appelés pour le fournisseur d'images concerné. Si une image doit toujours être récupérée auprès du fournisseur d'images et ne doit pas être mise en cache, définissez la propriété cache à false pour l'objet Image ou BorderImage concerné.