Revision control
++ // Copyright (C) 2016 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++ // Qt-Security score:significant reason:default
++
++ #include "qquickimagebase_p.h"
++ #include "qquickimagebase_p_p.h"
++
++ #include <QtGui/qguiapplication.h>
++ #include <QtGui/qscreen.h>
++ #include <QtGui/qicon.h>
++
++ #include <QtQml/qqmlinfo.h>
++ #include <QtQml/qqmlfile.h>
++ #include <QtQml/qqmlabstracturlinterceptor.h>
++
++
++ QT_BEGIN_NAMESPACE
++
++ using namespace Qt::Literals::StringLiterals;
++
++ // This function gives derived classes the chance set the devicePixelRatio
++ // if they're not happy with our implementation of it.
++ bool QQuickImageBasePrivate::updateDevicePixelRatio(qreal targetDevicePixelRatio, bool scalable)
++ {
++ // QQuickImageProvider and SVG and PDF can generate a high resolution image when
++ // sourceSize is set. If sourceSize is not set then the provider default size will
++ // be used, as usual.
++ if (scalable)
++ devicePixelRatio = targetDevicePixelRatio;
++ return scalable;
++ }
++
++ // Returns the device pixel ratio to load the image for, and remembers it.
++ qreal QQuickImageBasePrivate::devicePixelRatioForLoading()
++ {
++ loadedForDevicePixelRatio = effectiveDevicePixelRatio();
++ return loadedForDevicePixelRatio;
++ }
++
++ // Whether the image needs to be reloaded for the device pixel ratio of its window.
++ bool QQuickImageBasePrivate::needsReloadForDevicePixelRatio() const
++ {
++ Q_Q(const QQuickImageBase);
++ return window && loadedForDevicePixelRatio > 0 && qmlEngine(q) && q->isComponentComplete()
++ && window->effectiveDevicePixelRatio() != loadedForDevicePixelRatio;
++ }
++
++ void QQuickImageBasePrivate::setStatus(QQuickImageBase::Status value)
++ {
++ Q_Q(QQuickImageBase);
++
++ if (status == value)
++ return;
++
++ status = value;
++ emit q->statusChanged(status);
++ }
++
++ void QQuickImageBasePrivate::setProgress(qreal value)
++ {
++ Q_Q(QQuickImageBase);
++
++ if (qFuzzyCompare(progress, value))
++ return;
++
++ progress = value;
++ emit q->progressChanged(progress);
++ }
++
++ QQuickImageBase::QQuickImageBase(QQuickItem *parent)
++ : QQuickImplicitSizeItem(*(new QQuickImageBasePrivate), parent)
++ {
++ setFlag(ItemHasContents);
++ }
++
++ QQuickImageBase::QQuickImageBase(QQuickImageBasePrivate &dd, QQuickItem *parent)
++ : QQuickImplicitSizeItem(dd, parent)
++ {
++ setFlag(ItemHasContents);
++ }
++
++ QQuickImageBase::~QQuickImageBase()
++ {
++ }
++
++ QQuickImageBase::Status QQuickImageBase::status() const
++ {
++ Q_D(const QQuickImageBase);
++ return d->status;
++ }
++
++ qreal QQuickImageBase::progress() const
++ {
++ Q_D(const QQuickImageBase);
++ return d->progress;
++ }
++
++ bool QQuickImageBase::asynchronous() const
++ {
++ Q_D(const QQuickImageBase);
++ return d->async;
++ }
++
++ void QQuickImageBase::setAsynchronous(bool async)
++ {
++ Q_D(QQuickImageBase);
++ if (d->async != async) {
++ d->async = async;
++ emit asynchronousChanged();
++ }
++ }
++
++ QUrl QQuickImageBase::source() const
++ {
++ Q_D(const QQuickImageBase);
++ return d->url;
++ }
++
++ void QQuickImageBase::setSource(const QUrl &url)
++ {
++ Q_D(QQuickImageBase);
++
++ if (url == d->url)
++ return;
++
++ d->url = url;
++ emit sourceChanged(d->url);
++
++ if (isComponentComplete())
++ load();
++ }
++
++ void QQuickImageBase::setSourceSize(const QSize& size)
++ {
++ Q_D(QQuickImageBase);
++ if (d->sourcesize == size)
++ return;
++
++ d->sourcesize = size;
++ emit sourceSizeChanged();
++ if (isComponentComplete())
++ load();
++ }
++
++ QSize QQuickImageBase::sourceSize() const
++ {
++ Q_D(const QQuickImageBase);
++
++ int width = d->sourcesize.width();
++ int height = d->sourcesize.height();
++ return QSize(width != -1 ? width : d->currentPix->width(), height != -1 ? height : d->currentPix->height());
++ }
++
++ void QQuickImageBase::resetSourceSize()
++ {
++ setSourceSize(QSize());
++ }
++
++ QRectF QQuickImageBase::sourceClipRect() const
++ {
++ Q_D(const QQuickImageBase);
++ return d->sourceClipRect;
++ }
++
++ void QQuickImageBase::setSourceClipRect(const QRectF &r)
++ {
++ Q_D(QQuickImageBase);
++ if (d->sourceClipRect == r)
++ return;
++
++ d->sourceClipRect = r;
++ d->providerOptions.setSourceClipRect(r);
++ emit sourceClipRectChanged();
++ if (isComponentComplete())
++ load();
++ }
++
++ void QQuickImageBase::resetSourceClipRect()
++ {
++ setSourceClipRect(QRect());
++ }
++
++ bool QQuickImageBase::cache() const
++ {
++ Q_D(const QQuickImageBase);
++ return d->cache;
++ }
++
++ void QQuickImageBase::setCache(bool cache)
++ {
++ Q_D(QQuickImageBase);
++ if (d->cache == cache)
++ return;
++
++ d->cache = cache;
++ emit cacheChanged();
++ if (isComponentComplete())
++ load();
++ }
++
++ QImage QQuickImageBase::image() const
++ {
++ Q_D(const QQuickImageBase);
++ return d->currentPix->image();
++ }
++
++ void QQuickImageBase::setMirror(bool mirror)
++ {
++ Q_D(QQuickImageBase);
++ if (mirror == d->mirrorHorizontally)
++ return;
++
++ d->mirrorHorizontally = mirror;
++
++ if (isComponentComplete())
++ update();
++
++ emit mirrorChanged();
++ }
++
++ bool QQuickImageBase::mirror() const
++ {
++ Q_D(const QQuickImageBase);
++ return d->mirrorHorizontally;
++ }
++
++ void QQuickImageBase::setMirrorVertically(bool mirror)
++ {
++ Q_D(QQuickImageBase);
++ if (mirror == d->mirrorVertically)
++ return;
++
++ d->mirrorVertically = mirror;
++
++ if (isComponentComplete())
++ update();
++
++ emit mirrorVerticallyChanged();
++ }
++
++ bool QQuickImageBase::mirrorVertically() const
++ {
++ Q_D(const QQuickImageBase);
++ return d->mirrorVertically;
++ }
++
++ void QQuickImageBase::setCurrentFrame(int frame)
++ {
++ Q_D(QQuickImageBase);
++ if (frame == d->currentFrame || frame < 0 || (isComponentComplete() && frame >= d->currentPix->frameCount()))
++ return;
++
++ d->currentFrame = frame;
++
++ if (isComponentComplete()) {
++ if (frame > 0)
++ d->cache = false;
++ load();
++ update();
++ }
++
++ emit currentFrameChanged();
++ }
++
++ int QQuickImageBase::currentFrame() const
++ {
++ Q_D(const QQuickImageBase);
++ return d->currentFrame;
++ }
++
++ int QQuickImageBase::frameCount() const
++ {
++ Q_D(const QQuickImageBase);
++ return d->frameCount;
++ }
++
++ void QQuickImageBase::loadEmptyUrl()
++ {
++ Q_D(QQuickImageBase);
++ d->loadedForDevicePixelRatio = 0;
++ d->currentPix->clear(this);
++ d->pendingPix->clear(this);
++ d->setProgress(0);
++ d->status = Null; // do not emit statusChanged until after setImplicitSize
++ setImplicitSize(0, 0); // also called in QQuickImageBase::pixmapChange, but not QQuickImage/QQuickBorderImage overrides
++ pixmapChange(); // This calls update() in QQuickBorderImage and QQuickImage, not in QQuickImageBase...
++
++ emit statusChanged(d->status);
++ if (sourceSize() != d->oldSourceSize) {
++ d->oldSourceSize = sourceSize();
++ emit sourceSizeChanged();
++ }
++ if (autoTransform() != d->oldAutoTransform) {
++ d->oldAutoTransform = autoTransform();
++ emitAutoTransformBaseChanged();
++ }
++ update(); // .. but double updating should be harmless
++ }
++
++ void QQuickImageBase::loadPixmap(const QUrl &url, LoadPixmapOptions loadOptions)
++ {
++ Q_D(QQuickImageBase);
++ QQuickPixmap::Options options;
++ if (d->async)
++ options |= QQuickPixmap::Asynchronous;
++ if (d->cache)
++ options |= QQuickPixmap::Cache;
++ d->pendingPix->clear(this);
++ QUrl loadUrl = url;
++ const QQmlContext *context = qmlContext(this);
++ if (context)
++ loadUrl = context->resolvedUrl(url);
++
++ if (loadOptions & HandleDPR) {
++ const qreal targetDevicePixelRatio = d->devicePixelRatioForLoading();
++ d->devicePixelRatio = 1.0;
++ bool updatedDevicePixelRatio = false;
++ const QUrl resolvedUrl = context ? context->resolvedUrl(d->url) : d->url;
++ const bool scalable = QQuickPixmap::isScalableImageFormat(resolvedUrl);
++ if (d->sourcesize.isValid() || (scalable && d->url.scheme() != "image"_L1))
++ updatedDevicePixelRatio = d->updateDevicePixelRatio(targetDevicePixelRatio, scalable);
++
++ if (!updatedDevicePixelRatio) {
++ // (possible) local file: loadUrl and d->devicePixelRatio will be modified if
++ // an "@2x" file is found.
++ resolve2xLocalFile(resolvedUrl, targetDevicePixelRatio, &loadUrl, &d->devicePixelRatio);
++ }
++ }
++
++ d->status = Null; // reset status, no emit
++
++ auto engine = qmlEngine(this);
++ if (engine) {
++ d->pendingPix->load(engine,
++ loadUrl,
++ d->sourceClipRect.toRect(),
++ (loadOptions & HandleDPR) ? d->sourcesize * d->devicePixelRatio : QSize(),
++ options,
++ (loadOptions & UseProviderOptions) ? d->providerOptions : QQuickImageProviderOptions(),
++ d->currentFrame, d->frameCount,
++ d->devicePixelRatio);
++ }
++ if (d->pendingPix->isLoading()) {
++ d->setProgress(0);
++ d->setStatus(Loading);
++
++ static int thisRequestProgress = -1;
++ static int thisRequestFinished = -1;
++ if (thisRequestProgress == -1) {
++ thisRequestProgress =
++ QQuickImageBase::staticMetaObject.indexOfSlot("requestProgress(qint64,qint64)");
++ thisRequestFinished =
++ QQuickImageBase::staticMetaObject.indexOfSlot("requestFinished()");
++ }
++
++ d->pendingPix->connectFinished(this, thisRequestFinished);
++ d->pendingPix->connectDownloadProgress(this, thisRequestProgress);
++ if (!d->retainWhileLoading)
++ update(); //pixmap may have invalidated texture, updatePaintNode needs to be called before the next repaint
++ } else {
++ requestFinished();
++ }
++ }
++
++ void QQuickImageBase::load()
++ {
++ Q_D(QQuickImageBase);
++
++ if (d->url.isEmpty()) {
++ loadEmptyUrl();
++ update();
++ } else {
++ loadPixmap(d->url, LoadPixmapOptions(HandleDPR | UseProviderOptions));
++ }
++ }
++
++ void QQuickImageBase::requestFinished()
++ {
++ Q_D(QQuickImageBase);
++ if (d->pendingPix != d->currentPix
++ && d->pendingPix->status() != QQuickPixmap::Null
++ && d->pendingPix->status() != QQuickPixmap::Loading) {
++ std::swap(d->pendingPix, d->currentPix);
++ d->pendingPix->clear(this); // Clear the old image
++ }
++
++ if (d->currentPix->isError()) {
++ qmlWarning(this) << d->currentPix->error();
++ d->status = Error;
++ d->setProgress(0);
++ } else {
++ // itemgrabber: images carry their own devicePixelRatio (set by whatever grabbed
++ // them), which isn't known ahead of load the way "@2x" and scalable-image-format
++ // ratios are, so pick it up here once the pixmap has actually loaded.
++ if (d->url.scheme() == QQuickPixmap::itemGrabberScheme)
++ d->devicePixelRatio = d->currentPix->devicePixelRatio();
++ d->status = Ready; // do not emit statusChanged until after setImplicitSize
++ d->setProgress(1);
++ }
++
++ pixmapChange();
++ emit statusChanged(d->status);
++
++ if (sourceSize() != d->oldSourceSize) {
++ d->oldSourceSize = sourceSize();
++ emit sourceSizeChanged();
++ }
++ if (autoTransform() != d->oldAutoTransform) {
++ d->oldAutoTransform = autoTransform();
++ emitAutoTransformBaseChanged();
++ }
++ if (d->frameCount != d->currentPix->frameCount()) {
++ d->frameCount = d->currentPix->frameCount();
++ emit frameCountChanged();
++ }
++ if (d->colorSpace != d->currentPix->colorSpace()) {
++ d->colorSpace = d->currentPix->colorSpace();
++ emit colorSpaceChanged();
++ }
++
++ update();
++ }
++
++ void QQuickImageBase::requestProgress(qint64 received, qint64 total)
++ {
++ Q_D(QQuickImageBase);
++ if (d->status == Loading && total > 0)
++ d->setProgress(qreal(received) / total);
++ }
++
++ void QQuickImageBase::itemChange(ItemChange change, const ItemChangeData &value)
++ {
++ Q_D(QQuickImageBase);
++ // If the screen DPI changed, reload image.
++ if (change == ItemDevicePixelRatioHasChanged && value.realValue != d->devicePixelRatio) {
++ const auto oldDpr = d->devicePixelRatio;
++ // ### how can we get here with !qmlEngine(this)? that implies
++ // itemChange() on an item pending deletion, which seems strange.
++ // Note: We call load here without checking for a valid URL or
++ // any other properties, as we can't know whether the subclass'
++ // implementation of load() is based on URLs or not.
++ if (qmlEngine(this) && isComponentComplete()) {
++ load();
++ // not changed when loading (sourceSize might not be set)
++ if (d->devicePixelRatio == oldDpr) {
++ const QQmlContext *context = qmlContext(this);
++ const QUrl resolvedUrl = context ? context->resolvedUrl(d->url) : d->url;
++ d->updateDevicePixelRatio(value.realValue,
++ QQuickPixmap::isScalableImageFormat(resolvedUrl));
++ }
++ }
++ } else if (change == ItemSceneChange && d->needsReloadForDevicePixelRatio()) {
++ // If the image was loaded before the item had a window, it was loaded
++ // for qApp->devicePixelRatio(). ItemDevicePixelRatioHasChanged is not
++ // sent when the item enters a window, so reload the image if it was
++ // loaded for a different DPR. Do it when polishing, to not emit
++ // signals in the middle of reparenting.
++ polish();
++ }
++ QQuickItem::itemChange(change, value);
++ }
++
++ void QQuickImageBase::updatePolish()
++ {
++ Q_D(QQuickImageBase);
++ if (d->needsReloadForDevicePixelRatio())
++ load();
++ QQuickItem::updatePolish();
++ }
++
++ void QQuickImageBase::componentComplete()
++ {
++ Q_D(QQuickImageBase);
++ QQuickItem::componentComplete();
++ if (d->url.isValid())
++ load();
++ }
++
++ void QQuickImageBase::pixmapChange()
++ {
++ Q_D(QQuickImageBase);
++ setImplicitSize(d->currentPix->width() / d->devicePixelRatio, d->currentPix->height() / d->devicePixelRatio);
++ }
++
++ void QQuickImageBase::resolve2xLocalFile(const QUrl &url, qreal targetDevicePixelRatio, QUrl *sourceUrl, qreal *sourceDevicePixelRatio)
++ {
++ Q_ASSERT(sourceUrl);
++ Q_ASSERT(sourceDevicePixelRatio);
++
++ // Bail out if "@2x" image loading is disabled, don't change the source url or devicePixelRatio.
++ static const bool disable2xImageLoading = !qEnvironmentVariableIsEmpty("QT_HIGHDPI_DISABLE_2X_IMAGE_LOADING");
++ if (disable2xImageLoading)
++ return;
++
++ const QString localFile = QQmlFile::urlToLocalFileOrQrc(url);
++
++ // Non-local file path: @2x loading is not supported.
++ if (localFile.isEmpty())
++ return;
++
++ // Special case: the url in the QML source refers directly to an "@2x" file.
++ int atLocation = localFile.lastIndexOf(QLatin1Char('@'));
++ if (atLocation > 0 && atLocation + 3 < localFile.size()) {
++ if (localFile[atLocation + 1].isDigit()
++ && localFile[atLocation + 2] == QLatin1Char('x')
++ && localFile[atLocation + 3] == QLatin1Char('.')) {
++ *sourceDevicePixelRatio = localFile[atLocation + 1].digitValue();
++ return;
++ }
++ }
++
++ // Look for an @2x version
++ QString localFileX = qt_findAtNxFile(localFile, targetDevicePixelRatio, sourceDevicePixelRatio);
++ if (localFileX != localFile)
++ *sourceUrl = QUrl::fromLocalFile(localFileX);
++ }
++
++ bool QQuickImageBase::autoTransform() const
++ {
++ Q_D(const QQuickImageBase);
++ if (d->providerOptions.autoTransform() == QQuickImageProviderOptions::UsePluginDefaultTransform)
++ return d->currentPix->autoTransform() == QQuickImageProviderOptions::ApplyTransform;
++ return d->providerOptions.autoTransform() == QQuickImageProviderOptions::ApplyTransform;
++ }
++
++ void QQuickImageBase::setAutoTransform(bool transform)
++ {
++ Q_D(QQuickImageBase);
++ if (d->providerOptions.autoTransform() != QQuickImageProviderOptions::UsePluginDefaultTransform &&
++ transform == (d->providerOptions.autoTransform() == QQuickImageProviderOptions::ApplyTransform))
++ return;
++ d->providerOptions.setAutoTransform(transform ? QQuickImageProviderOptions::ApplyTransform : QQuickImageProviderOptions::DoNotApplyTransform);
++ emitAutoTransformBaseChanged();
++ }
++
++ QColorSpace QQuickImageBase::colorSpace() const
++ {
++ Q_D(const QQuickImageBase);
++ return d->colorSpace;
++ }
++
++ void QQuickImageBase::setColorSpace(const QColorSpace &colorSpace)
++ {
++ Q_D(QQuickImageBase);
++ if (d->colorSpace == colorSpace)
++ return;
++ d->colorSpace = colorSpace;
++ d->providerOptions.setTargetColorSpace(colorSpace);
++ emit colorSpaceChanged();
++ }
++
++ bool QQuickImageBase::retainWhileLoading() const
++ {
++ Q_D(const QQuickImageBase);
++ return d->retainWhileLoading;
++ }
++
++ void QQuickImageBase::setRetainWhileLoading(bool retainWhileLoading)
++ {
++ Q_D(QQuickImageBase);
++ if (d->retainWhileLoading == retainWhileLoading)
++ return;
++
++ d->retainWhileLoading = retainWhileLoading;
++ if (d->retainWhileLoading) {
++ if (d->currentPix == &d->pix1)
++ d->pendingPix = &d->pix2;
++ else
++ d->pendingPix = &d->pix1;
++ } else {
++ d->pendingPix->clear();
++ d->pendingPix = d->currentPix;
++ }
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_qquickimagebase_p.cpp"