Teach QQuickPixmap to handle requests for image regions

For vector image formats that could take a long time to render (such as
SVG and PDF), we need to be able to request smaller regions of the page.
The region needs to be specified in original units (i.e. points in a PDF
or pixels in an SVG).

Change-Id: I9c9eecb22d929f6e7b2636a2a44f50c8eea4c6b2
Reviewed-by: Jan Arve Sæther <jan-arve.saether@qt.io>

3 files changed, 94 insertions, 48 deletions

diff --git a/src/quick/util/qquickpixmapcache.cpp b/src/quick/util/qquickpixmapcache.cpp
index d47719389b..bdd1e2c514 100644
--- a/src/quick/util/qquickpixmapcache.cpp
+++ b/src/quick/util/qquickpixmapcache.cpp
@@ -86,6 +86,8 @@ QT_BEGIN_NAMESPACE
 
 const QLatin1String QQuickPixmap::itemGrabberScheme = QLatin1String("itemgrabber");
 
+Q_LOGGING_CATEGORY(lcImg, "qt.quick.image")
+
 #ifndef QT_NO_DEBUG
 static const bool qsg_leak_check = !qEnvironmentVariableIsEmpty("QML_LEAK_CHECK");
 #endif
@@ -137,6 +139,7 @@ public:
 
     QQuickPixmapData *data;
     QQmlEngine *engineForReader; // always access reader inside readerMutex
+    QRect requestRegion;
     QSize requestSize;
     QUrl url;
 
@@ -240,9 +243,10 @@ public:
 class QQuickPixmapData
 {
 public:
-    QQuickPixmapData(QQuickPixmap *pixmap, const QUrl &u, const QSize &s, const QQuickImageProviderOptions &po, const QString &e)
+    QQuickPixmapData(QQuickPixmap *pixmap, const QUrl &u, const QRect &r, const QSize &rs,
+                     const QQuickImageProviderOptions &po, const QString &e)
     : refCount(1), frameCount(1), frame(0), inCache(false), pixmapStatus(QQuickPixmap::Error),
-      url(u), errorString(e), requestSize(s),
+      url(u), errorString(e), requestRegion(r), requestSize(rs),
       providerOptions(po), appliedTransform(QQuickImageProviderOptions::UsePluginDefaultTransform),
       textureFactory(nullptr), reply(nullptr), prevUnreferenced(nullptr),
       prevUnreferencedPtr(nullptr), nextUnreferenced(nullptr)
@@ -250,9 +254,10 @@ public:
         declarativePixmaps.insert(pixmap);
     }
 
-    QQuickPixmapData(QQuickPixmap *pixmap, const QUrl &u, const QSize &r, const QQuickImageProviderOptions &po, QQuickImageProviderOptions::AutoTransform aTransform, int frame=0, int frameCount=1)
+    QQuickPixmapData(QQuickPixmap *pixmap, const QUrl &u, const QRect &r, const QSize &s, const QQuickImageProviderOptions &po,
+                     QQuickImageProviderOptions::AutoTransform aTransform, int frame=0, int frameCount=1)
     : refCount(1), frameCount(frameCount), frame(frame), inCache(false), pixmapStatus(QQuickPixmap::Loading),
-      url(u), requestSize(r),
+      url(u), requestRegion(r), requestSize(s),
       providerOptions(po), appliedTransform(aTransform),
       textureFactory(nullptr), reply(nullptr), prevUnreferenced(nullptr), prevUnreferencedPtr(nullptr),
       nextUnreferenced(nullptr)
@@ -261,9 +266,10 @@ public:
     }
 
     QQuickPixmapData(QQuickPixmap *pixmap, const QUrl &u, QQuickTextureFactory *texture,
-                     const QSize &s, const QSize &r, const QQuickImageProviderOptions &po, QQuickImageProviderOptions::AutoTransform aTransform, int frame=0, int frameCount=1)
+                     const QSize &s, const QRect &r, const QSize &rs, const QQuickImageProviderOptions &po,
+                     QQuickImageProviderOptions::AutoTransform aTransform, int frame=0, int frameCount=1)
     : refCount(1), frameCount(frameCount), frame(frame), inCache(false), pixmapStatus(QQuickPixmap::Ready),
-      url(u), implicitSize(s), requestSize(r),
+      url(u), implicitSize(s), requestRegion(r), requestSize(rs),
       providerOptions(po), appliedTransform(aTransform),
       textureFactory(texture), reply(nullptr), prevUnreferenced(nullptr),
       prevUnreferencedPtr(nullptr), nextUnreferenced(nullptr)
@@ -308,6 +314,7 @@ public:
     QUrl url;
     QString errorString;
     QSize implicitSize;
+    QRect requestRegion;
     QSize requestSize;
     QQuickImageProviderOptions providerOptions;
     QQuickImageProviderOptions::AutoTransform appliedTransform;
@@ -399,7 +406,7 @@ static void maybeRemoveAlpha(QImage *image)
 }
 
 static bool readImage(const QUrl& url, QIODevice *dev, QImage *image, QString *errorString, QSize *impsize, int *frameCount,
-                      const QSize &requestSize, const QQuickImageProviderOptions &providerOptions,
+                      const QRect &requestRegion, const QSize &requestSize, const QQuickImageProviderOptions &providerOptions,
                       QQuickImageProviderOptions::AutoTransform *appliedTransform = nullptr, int frame = 0)
 {
     QImageReader imgio(dev);
@@ -417,6 +424,10 @@ static bool readImage(const QUrl& url, QIODevice *dev, QImage *image, QString *e
     QSize scSize = QQuickImageProviderWithOptions::loadSize(imgio.size(), requestSize, imgio.format(), providerOptions);
     if (scSize.isValid())
         imgio.setScaledSize(scSize);
+    if (!requestRegion.isNull())
+        imgio.setScaledClipRect(requestRegion);
+    qCDebug(lcImg) << url << "frame" << frame << "of" << imgio.imageCount()
+                   << "requestRegion" << requestRegion << "QImageReader size" << imgio.size() << "-> scSize" << scSize;
 
     if (impsize)
         *impsize = imgio.size();
@@ -568,7 +579,8 @@ void QQuickPixmapReader::networkRequestDone(QNetworkReply *reply)
             buff.open(QIODevice::ReadOnly);
             int frameCount;
             int const frame = job->data ? job->data->frame : 0;
-            if (!readImage(reply->url(), &buff, &image, &errorString, &readSize, &frameCount, job->requestSize, job->providerOptions, nullptr, frame))
+            if (!readImage(reply->url(), &buff, &image, &errorString, &readSize, &frameCount,
+                           job->requestRegion, job->requestSize, job->providerOptions, nullptr, frame))
                 error = QQuickPixmapReply::Decoding;
             else if (job->data)
                 job->data->frameCount = frameCount;
@@ -884,7 +896,8 @@ void QQuickPixmapReader::processJob(QQuickPixmapReply *runningJob, const QUrl &u
                 } else {
                     int frameCount;
                     int const frame = runningJob->data ? runningJob->data->frame : 0;
-                    if ( !readImage(url, &f, &image, &errorStr, &readSize, &frameCount, runningJob->requestSize, runningJob->providerOptions, nullptr, frame)) {
+                    if (!readImage(url, &f, &image, &errorStr, &readSize, &frameCount, runningJob->requestRegion, runningJob->requestSize,
+                                   runningJob->providerOptions, nullptr, frame)) {
                         errorCode = QQuickPixmapReply::Loading;
                         if (f.fileName() != localFile)
                             errorStr += QString::fromLatin1(" (%1)").arg(f.fileName());
@@ -997,6 +1010,7 @@ class QQuickPixmapKey
 {
 public:
     const QUrl *url;
+    const QRect *region;
     const QSize *size;
     int frame;
     QQuickImageProviderOptions options;
@@ -1004,12 +1018,17 @@ public:
 
 inline bool operator==(const QQuickPixmapKey &lhs, const QQuickPixmapKey &rhs)
 {
-    return *lhs.size == *rhs.size && *lhs.url == *rhs.url && lhs.options == rhs.options && lhs.frame == rhs.frame;
+    return *lhs.region == *rhs.region && *lhs.size == *rhs.size && *lhs.url == *rhs.url &&
+            lhs.options == rhs.options && lhs.frame == rhs.frame;
 }
 
 inline uint qHash(const QQuickPixmapKey &key)
 {
-    return qHash(*key.url) ^ (key.size->width()*7) ^ (key.size->height()*17) ^ (key.frame*23) ^ (key.options.autoTransform() * 0x5c5c5c5c);
+    return qHash(*key.url) ^ (key.size->width()*7) ^ (key.size->height()*17) ^ (key.frame*23) ^
+            (key.region->x()*29) ^ (key.region->y()*31) ^ (key.options.autoTransform() * 0x5c5c5c5c);
+    // key.region.width() and height() are not included, because the hash function should be simple,
+    // and they are more likely to be held constant for some batches of images
+    // (e.g. tiles, or repeatedly cropping to the same viewport at different positions).
 }
 
 class QQuickPixmapStore : public QObject
@@ -1176,7 +1195,8 @@ void QQuickPixmap::purgeCache()
 }
 
 QQuickPixmapReply::QQuickPixmapReply(QQuickPixmapData *d)
-: data(d), engineForReader(nullptr), requestSize(d->requestSize), url(d->url), loading(false), providerOptions(d->providerOptions), redirectCount(0)
+  : data(d), engineForReader(nullptr), requestRegion(d->requestRegion), requestSize(d->requestSize),
+    url(d->url), loading(false), providerOptions(d->providerOptions), redirectCount(0)
 {
     if (finishedIndex == -1) {
         finishedIndex = QMetaMethod::fromSignal(&QQuickPixmapReply::finished).methodIndex();
@@ -1271,7 +1291,7 @@ void QQuickPixmapData::release()
 void QQuickPixmapData::addToCache()
 {
     if (!inCache) {
-        QQuickPixmapKey key = { &url, &requestSize, frame, providerOptions };
+        QQuickPixmapKey key = { &url, &requestRegion, &requestSize, frame, providerOptions };
         pixmapStore()->m_cache.insert(key, this);
         inCache = true;
         PIXMAP_PROFILE(pixmapCountChanged<QQuickProfiler::PixmapCacheCountChanged>(
@@ -1282,7 +1302,7 @@ void QQuickPixmapData::addToCache()
 void QQuickPixmapData::removeFromCache()
 {
     if (inCache) {
-        QQuickPixmapKey key = { &url, &requestSize, frame, providerOptions };
+        QQuickPixmapKey key = { &url, &requestRegion, &requestSize, frame, providerOptions };
         pixmapStore()->m_cache.remove(key);
         inCache = false;
         PIXMAP_PROFILE(pixmapCountChanged<QQuickProfiler::PixmapCacheCountChanged>(
@@ -1290,7 +1310,9 @@ void QQuickPixmapData::removeFromCache()
     }
 }
 
-static QQuickPixmapData* createPixmapDataSync(QQuickPixmap *declarativePixmap, QQmlEngine *engine, const QUrl &url, const QSize &requestSize, const QQuickImageProviderOptions &providerOptions, int frame, bool *ok)
+static QQuickPixmapData* createPixmapDataSync(QQuickPixmap *declarativePixmap, QQmlEngine *engine, const QUrl &url,
+                                              const QRect &requestRegion, const QSize &requestSize,
+                                              const QQuickImageProviderOptions &providerOptions, int frame, bool *ok)
 {
     if (url.scheme() == QLatin1String("image")) {
         QSize readSize;
@@ -1305,7 +1327,7 @@ static QQuickPixmapData* createPixmapDataSync(QQuickPixmap *declarativePixmap, Q
 
         switch (imageType) {
             case QQuickImageProvider::Invalid:
-                return new QQuickPixmapData(declarativePixmap, url, requestSize, providerOptions,
+                return new QQuickPixmapData(declarativePixmap, url, requestRegion, requestSize, providerOptions,
                     QQuickPixmap::tr("Invalid image provider: %1").arg(url.toString()));
             case QQuickImageProvider::Texture:
             {
@@ -1313,7 +1335,8 @@ static QQuickPixmapData* createPixmapDataSync(QQuickPixmap *declarativePixmap, Q
                                                            : provider->requestTexture(imageId(url), &readSize, requestSize);
                 if (texture) {
                     *ok = true;
-                    return new QQuickPixmapData(declarativePixmap, url, texture, readSize, requestSize, providerOptions, QQuickImageProviderOptions::UsePluginDefaultTransform, frame);
+                    return new QQuickPixmapData(declarativePixmap, url, texture, readSize, requestRegion, requestSize,
+                                                providerOptions, QQuickImageProviderOptions::UsePluginDefaultTransform, frame);
                 }
                 break;
             }
@@ -1324,7 +1347,9 @@ static QQuickPixmapData* createPixmapDataSync(QQuickPixmap *declarativePixmap, Q
                                           : provider->requestImage(imageId(url), &readSize, requestSize);
                 if (!image.isNull()) {
                     *ok = true;
-                    return new QQuickPixmapData(declarativePixmap, url, QQuickTextureFactory::textureFactoryForImage(image), readSize, requestSize, providerOptions, QQuickImageProviderOptions::UsePluginDefaultTransform, frame);
+                    return new QQuickPixmapData(declarativePixmap, url, QQuickTextureFactory::textureFactoryForImage(image),
+                                                readSize, requestRegion, requestSize, providerOptions,
+                                                QQuickImageProviderOptions::UsePluginDefaultTransform, frame);
                 }
                 break;
             }
@@ -1334,7 +1359,9 @@ static QQuickPixmapData* createPixmapDataSync(QQuickPixmap *declarativePixmap, Q
                                             : provider->requestPixmap(imageId(url), &readSize, requestSize);
                 if (!pixmap.isNull()) {
                     *ok = true;
-                    return new QQuickPixmapData(declarativePixmap, url, QQuickTextureFactory::textureFactoryForImage(pixmap.toImage()), readSize, requestSize, providerOptions, QQuickImageProviderOptions::UsePluginDefaultTransform, frame);
+                    return new QQuickPixmapData(declarativePixmap, url, QQuickTextureFactory::textureFactoryForImage(pixmap.toImage()),
+                                                readSize, requestRegion, requestSize, providerOptions,
+                                                QQuickImageProviderOptions::UsePluginDefaultTransform, frame);
                 }
                 break;
             }
@@ -1346,7 +1373,7 @@ static QQuickPixmapData* createPixmapDataSync(QQuickPixmap *declarativePixmap, Q
         }
 
         // provider has bad image type, or provider returned null image
-        return new QQuickPixmapData(declarativePixmap, url, requestSize, providerOptions,
+        return new QQuickPixmapData(declarativePixmap, url, requestRegion, requestSize, providerOptions,
             QQuickPixmap::tr("Failed to get image from provider: %1").arg(url.toString()));
     }
 
@@ -1364,7 +1391,8 @@ static QQuickPixmapData* createPixmapDataSync(QQuickPixmap *declarativePixmap, Q
             QQuickTextureFactory *factory = texReader.read();
             if (factory) {
                 *ok = true;
-                return new QQuickPixmapData(declarativePixmap, url, factory, factory->textureSize(), requestSize, providerOptions, QQuickImageProviderOptions::UsePluginDefaultTransform, frame);
+                return new QQuickPixmapData(declarativePixmap, url, factory, factory->textureSize(), requestRegion, requestSize,
+                                            providerOptions, QQuickImageProviderOptions::UsePluginDefaultTransform, frame);
             } else {
                 errorString = QQuickPixmap::tr("Error decoding: %1").arg(url.toString());
                 if (f.fileName() != localFile)
@@ -1374,9 +1402,10 @@ static QQuickPixmapData* createPixmapDataSync(QQuickPixmap *declarativePixmap, Q
             QImage image;
             QQuickImageProviderOptions::AutoTransform appliedTransform = providerOptions.autoTransform();
             int frameCount;
-            if (readImage(url, &f, &image, &errorString, &readSize, &frameCount, requestSize, providerOptions, &appliedTransform, frame)) {
+            if (readImage(url, &f, &image, &errorString, &readSize, &frameCount, requestRegion, requestSize, providerOptions, &appliedTransform, frame)) {
                 *ok = true;
-                return new QQuickPixmapData(declarativePixmap, url, QQuickTextureFactory::textureFactoryForImage(image), readSize, requestSize, providerOptions, appliedTransform, frame, frameCount);
+                return new QQuickPixmapData(declarativePixmap, url, QQuickTextureFactory::textureFactoryForImage(image), readSize, requestRegion, requestSize,
+                                            providerOptions, appliedTransform, frame, frameCount);
             } else if (f.fileName() != localFile) {
                 errorString += QString::fromLatin1(" (%1)").arg(f.fileName());
             }
@@ -1384,12 +1413,13 @@ static QQuickPixmapData* createPixmapDataSync(QQuickPixmap *declarativePixmap, Q
     } else {
         errorString = QQuickPixmap::tr("Cannot open: %1").arg(url.toString());
     }
-    return new QQuickPixmapData(declarativePixmap, url, requestSize, providerOptions, errorString);
+    return new QQuickPixmapData(declarativePixmap, url, requestRegion, requestSize, providerOptions, errorString);
 }
 
 
 struct QQuickPixmapNull {
     QUrl url;
+    QRect region;
     QSize size;
 };
 Q_GLOBAL_STATIC(QQuickPixmapNull, nullPixmap);
@@ -1405,15 +1435,16 @@ QQuickPixmap::QQuickPixmap(QQmlEngine *engine, const QUrl &url)
     load(engine, url);
 }
 
-QQuickPixmap::QQuickPixmap(QQmlEngine *engine, const QUrl &url, const QSize &size)
+QQuickPixmap::QQuickPixmap(QQmlEngine *engine, const QUrl &url, const QRect &region, const QSize &size)
 : d(nullptr)
 {
-    load(engine, url, size);
+    load(engine, url, region, size);
 }
 
 QQuickPixmap::QQuickPixmap(const QUrl &url, const QImage &image)
 {
-    d = new QQuickPixmapData(this, url, new QQuickDefaultTextureFactory(image), image.size(), QSize(), QQuickImageProviderOptions(), QQuickImageProviderOptions::UsePluginDefaultTransform);
+    d = new QQuickPixmapData(this, url, new QQuickDefaultTextureFactory(image), image.size(), QRect(), QSize(),
+                             QQuickImageProviderOptions(), QQuickImageProviderOptions::UsePluginDefaultTransform);
     d->addToCache();
 }
 
@@ -1486,6 +1517,14 @@ const QSize &QQuickPixmap::requestSize() const
         return nullPixmap()->size;
 }
 
+const QRect &QQuickPixmap::requestRegion() const
+{
+    if (d)
+        return d->requestRegion;
+    else
+        return nullPixmap()->region;
+}
+
 QQuickImageProviderOptions::AutoTransform QQuickPixmap::autoTransform() const
 {
     if (d)
@@ -1561,25 +1600,26 @@ QRect QQuickPixmap::rect() const
 
 void QQuickPixmap::load(QQmlEngine *engine, const QUrl &url)
 {
-    load(engine, url, QSize(), QQuickPixmap::Cache);
+    load(engine, url, QRect(), QSize(), QQuickPixmap::Cache);
 }
 
 void QQuickPixmap::load(QQmlEngine *engine, const QUrl &url, QQuickPixmap::Options options)
 {
-    load(engine, url, QSize(), options);
+    load(engine, url, QRect(), QSize(), options);
 }
 
-void QQuickPixmap::load(QQmlEngine *engine, const QUrl &url, const QSize &size)
+void QQuickPixmap::load(QQmlEngine *engine, const QUrl &url, const QRect &requestRegion, const QSize &requestSize)
 {
-    load(engine, url, size, QQuickPixmap::Cache);
+    load(engine, url, requestRegion, requestSize, QQuickPixmap::Cache);
 }
 
-void QQuickPixmap::load(QQmlEngine *engine, const QUrl &url, const QSize &requestSize, QQuickPixmap::Options options)
+void QQuickPixmap::load(QQmlEngine *engine, const QUrl &url, const QRect &requestRegion, const QSize &requestSize, QQuickPixmap::Options options)
 {
-    load(engine, url, requestSize, options, QQuickImageProviderOptions());
+    load(engine, url, requestRegion, requestSize, options, QQuickImageProviderOptions());
 }
 
-void QQuickPixmap::load(QQmlEngine *engine, const QUrl &url, const QSize &requestSize, QQuickPixmap::Options options, const QQuickImageProviderOptions &providerOptions, int frame, int frameCount)
+void QQuickPixmap::load(QQmlEngine *engine, const QUrl &url, const QRect &requestRegion, const QSize &requestSize,
+                        QQuickPixmap::Options options, const QQuickImageProviderOptions &providerOptions, int frame, int frameCount)
 {
     if (d) {
         d->declarativePixmaps.remove(this);
@@ -1587,7 +1627,7 @@ void QQuickPixmap::load(QQmlEngine *engine, const QUrl &url, const QSize &reques
         d = nullptr;
     }
 
-    QQuickPixmapKey key = { &url, &requestSize, frame, providerOptions };
+    QQuickPixmapKey key = { &url, &requestRegion, &requestSize, frame, providerOptions };
     QQuickPixmapStore *store = pixmapStore();
 
     QHash<QQuickPixmapKey, QQuickPixmapData *>::Iterator iter = store->m_cache.end();
@@ -1596,10 +1636,11 @@ void QQuickPixmap::load(QQmlEngine *engine, const QUrl &url, const QSize &reques
     // cached version. Unless it's an itemgrabber url, since the cache is used to pass
     // the result between QQuickItemGrabResult and QQuickImage.
     if (url.scheme() == itemGrabberScheme) {
-        QSize dummy;
-        if (requestSize != dummy)
+        QRect dummyRegion;
+        QSize dummySize;
+        if (requestSize != dummySize)
             qWarning() << "Ignoring sourceSize request for image url that came from grabToImage. Use the targetSize parameter of the grabToImage() function instead.";
-        const QQuickPixmapKey grabberKey = { &url, &dummy, 0, QQuickImageProviderOptions() };
+        const QQuickPixmapKey grabberKey = { &url, &dummyRegion, &dummySize, 0, QQuickImageProviderOptions() };
         iter = store->m_cache.find(grabberKey);
     } else if (options & QQuickPixmap::Cache)
         iter = store->m_cache.find(key);
@@ -1621,7 +1662,7 @@ void QQuickPixmap::load(QQmlEngine *engine, const QUrl &url, const QSize &reques
         if (!(options & QQuickPixmap::Asynchronous)) {
             bool ok = false;
             PIXMAP_PROFILE(pixmapStateChanged<QQuickProfiler::PixmapLoadingStarted>(url));
-            d = createPixmapDataSync(this, engine, url, requestSize, providerOptions, frame, &ok);
+            d = createPixmapDataSync(this, engine, url, requestRegion, requestSize, providerOptions, frame, &ok);
             if (ok) {
                 PIXMAP_PROFILE(pixmapLoadingFinished(url, QSize(width(), height())));
                 if (options & QQuickPixmap::Cache)
@@ -1638,7 +1679,8 @@ void QQuickPixmap::load(QQmlEngine *engine, const QUrl &url, const QSize &reques
             return;
 
 
-        d = new QQuickPixmapData(this, url, requestSize, providerOptions, QQuickImageProviderOptions::UsePluginDefaultTransform, frame, frameCount);
+        d = new QQuickPixmapData(this, url, requestRegion, requestSize, providerOptions,
+                                 QQuickImageProviderOptions::UsePluginDefaultTransform, frame, frameCount);
         if (options & QQuickPixmap::Cache)
             d->addToCache();
 
@@ -1672,9 +1714,10 @@ void QQuickPixmap::clear(QObject *obj)
     }
 }
 
-bool QQuickPixmap::isCached(const QUrl &url, const QSize &requestSize, const int frame, const QQuickImageProviderOptions &options)
+bool QQuickPixmap::isCached(const QUrl &url, const QRect &requestRegion, const QSize &requestSize,
+                            const int frame, const QQuickImageProviderOptions &options)
 {
-    QQuickPixmapKey key = { &url, &requestSize, frame, options };
+    QQuickPixmapKey key = { &url, &requestRegion, &requestSize, frame, options };
     QQuickPixmapStore *store = pixmapStore();
 
     return store->m_cache.contains(key);
diff --git a/src/quick/util/qquickpixmapcache_p.h b/src/quick/util/qquickpixmapcache_p.h
index ab5d391fa2..01c99cdbb6 100644
--- a/src/quick/util/qquickpixmapcache_p.h
+++ b/src/quick/util/qquickpixmapcache_p.h
@@ -127,7 +127,7 @@ class Q_QUICK_PRIVATE_EXPORT QQuickPixmap
 public:
     QQuickPixmap();
     QQuickPixmap(QQmlEngine *, const QUrl &);
-    QQuickPixmap(QQmlEngine *, const QUrl &, const QSize &);
+    QQuickPixmap(QQmlEngine *, const QUrl &, const QRect &region, const QSize &);
     QQuickPixmap(const QUrl &, const QImage &image);
     ~QQuickPixmap();
 
@@ -148,6 +148,7 @@ public:
     QString error() const;
     const QUrl &url() const;
     const QSize &implicitSize() const;
+    const QRect &requestRegion() const;
     const QSize &requestSize() const;
     QQuickImageProviderOptions::AutoTransform autoTransform() const;
     int frameCount() const;
@@ -163,9 +164,10 @@ public:
 
     void load(QQmlEngine *, const QUrl &);
     void load(QQmlEngine *, const QUrl &, QQuickPixmap::Options options);
-    void load(QQmlEngine *, const QUrl &, const QSize &);
-    void load(QQmlEngine *, const QUrl &, const QSize &, QQuickPixmap::Options options);
-    void load(QQmlEngine *, const QUrl &, const QSize &, QQuickPixmap::Options options, const QQuickImageProviderOptions &providerOptions, int frame = 0, int frameCount = 1);
+    void load(QQmlEngine *, const QUrl &, const QRect &requestRegion, const QSize &requestSize);
+    void load(QQmlEngine *, const QUrl &, const QRect &requestRegion, const QSize &requestSize, QQuickPixmap::Options options);
+    void load(QQmlEngine *, const QUrl &, const QRect &requestRegion, const QSize &requestSize,
+              QQuickPixmap::Options options, const QQuickImageProviderOptions &providerOptions, int frame = 0, int frameCount = 1);
 
     void clear();
     void clear(QObject *);
@@ -176,7 +178,8 @@ public:
     bool connectDownloadProgress(QObject *, int);
 
     static void purgeCache();
-    static bool isCached(const QUrl &url, const QSize &requestSize, const int frame, const QQuickImageProviderOptions &options);
+    static bool isCached(const QUrl &url, const QRect &requestRegion, const QSize &requestSize,
+                         const int frame, const QQuickImageProviderOptions &options);
 
     static const QLatin1String itemGrabberScheme;
 
diff --git a/src/quick/util/qquickstyledtext.cpp b/src/quick/util/qquickstyledtext.cpp
index 08d06c66ab..660852ba83 100644
--- a/src/quick/util/qquickstyledtext.cpp
+++ b/src/quick/util/qquickstyledtext.cpp
@@ -706,7 +706,7 @@ void QQuickStyledTextPrivate::parseImageAttributes(const QChar *&ch, const QStri
             // to avoid a relayout later on.
             QUrl url = baseUrl.resolved(image->url);
             if (url.isLocalFile()) {
-                image->pix = new QQuickPixmap(context->engine(), url, image->size);
+                image->pix = new QQuickPixmap(context->engine(), url, QRect(), image->size);
                 if (image->pix && image->pix->isReady()) {
                     image->size = image->pix->implicitSize();
                 } else {