qquickimageprovider.cpp

Go to the documentation of this file.

// 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
 
#include "qquickimageprovider.h"
 
#include "qquickimageprovider_p.h"
#include "qquickpixmap_p.h"
#include <QtQuick/private/qsgcontext_p.h>
#include <private/qqmlglobal_p.h>
#include <QtGui/qcolorspace.h>
 
QT_BEGIN_NAMESPACE
 
QQuickTextureFactory::QQuickTextureFactory()
{
}
 
QQuickTextureFactory::~QQuickTextureFactory()
{
}
 
QImage QQuickTextureFactory::image() const
{
    return QImage();
}
 
QQuickTextureFactory *QQuickTextureFactory::textureFactoryForImage(const QImage &image)
{
    if (image.isNull())
        return nullptr;
    QQuickTextureFactory *texture = QSGContext::createTextureFactoryFromImage(image);
    if (texture)
        return texture;
    return new QQuickDefaultTextureFactory(image);
}
 
 
 
QQuickImageResponse::QQuickImageResponse()
    : QObject(*(new QQuickImageResponsePrivate))
{
    qmlobject_connect(this, QQuickImageResponse, SIGNAL(finished()),
                      this, QQuickImageResponse, SLOT(_q_finished()));
}
 
QQuickImageResponse::~QQuickImageResponse()
{
}
 
QString QQuickImageResponse::errorString() const
{
    return QString();
}
 
void QQuickImageResponse::cancel()
{
}
 
QQuickImageProvider::QQuickImageProvider(ImageType type, Flags flags)
    : d(new QQuickImageProviderPrivate)
{
    d->type = type;
    d->flags = flags;
    d->isProviderWithOptions = false;
}
 
QQuickImageProvider::~QQuickImageProvider()
{
    delete d;
}
 
QQuickImageProvider::ImageType QQuickImageProvider::imageType() const
{
    return d->type;
}
 
QQuickImageProvider::Flags QQuickImageProvider::flags() const
{
    return d->flags;
}
 
QImage QQuickImageProvider::requestImage(const QString &id, QSize *size, const QSize& requestedSize)
{
    Q_UNUSED(id);
    Q_UNUSED(size);
    Q_UNUSED(requestedSize);
    if (d->type == Image)
        qWarning("ImageProvider supports Image type but has not implemented requestImage()");
    return QImage();
}
 
QPixmap QQuickImageProvider::requestPixmap(const QString &id, QSize *size, const QSize& requestedSize)
{
    Q_UNUSED(id);
    Q_UNUSED(size);
    Q_UNUSED(requestedSize);
    if (d->type == Pixmap)
        qWarning("ImageProvider supports Pixmap type but has not implemented requestPixmap()");
    return QPixmap();
}
 
 
QQuickTextureFactory *QQuickImageProvider::requestTexture(const QString &id, QSize *size, const QSize &requestedSize)
{
    Q_UNUSED(id);
    Q_UNUSED(size);
    Q_UNUSED(requestedSize);
    if (d->type == Texture)
        qWarning("ImageProvider supports Texture type but has not implemented requestTexture()");
    return nullptr;
}
 
QQuickAsyncImageProvider::QQuickAsyncImageProvider()
 : QQuickImageProvider(ImageResponse, ForceAsynchronousImageLoading)
 , d(nullptr) // just as a placeholder in case we need it for the future
{
    Q_UNUSED(d);
}
 
QQuickAsyncImageProvider::~QQuickAsyncImageProvider()
{
}
 
class QQuickImageProviderOptionsPrivate : public QSharedData
{
public:
    QQuickImageProviderOptionsPrivate()
    {
    }
 
    QColorSpace targetColorSpace;
    QRectF sourceClipRect;
    QQuickImageProviderOptions::AutoTransform autoTransform = QQuickImageProviderOptions::UsePluginDefaultTransform;
    bool preserveAspectRatioCrop = false;
    bool preserveAspectRatioFit = false;
};
 
QQuickImageProviderOptions::QQuickImageProviderOptions()
 : d(new QQuickImageProviderOptionsPrivate())
{
}
 
QQuickImageProviderOptions::~QQuickImageProviderOptions()
{
}
 
QQuickImageProviderOptions::QQuickImageProviderOptions(const QQuickImageProviderOptions &other)
 : d(other.d)
{
}
 
QQuickImageProviderOptions& QQuickImageProviderOptions::operator=(const QQuickImageProviderOptions &other)
{
    d = other.d;
    return *this;
}
 
bool QQuickImageProviderOptions::operator==(const QQuickImageProviderOptions &other) const
{
    return d->autoTransform == other.d->autoTransform &&
           d->preserveAspectRatioCrop == other.d->preserveAspectRatioCrop &&
           d->preserveAspectRatioFit == other.d->preserveAspectRatioFit &&
           d->targetColorSpace == other.d->targetColorSpace;
}
 
QQuickImageProviderOptions::AutoTransform QQuickImageProviderOptions::autoTransform() const
{
    return d->autoTransform;
}
 
void QQuickImageProviderOptions::setAutoTransform(QQuickImageProviderOptions::AutoTransform autoTransform)
{
    d->autoTransform = autoTransform;
}
 
bool QQuickImageProviderOptions::preserveAspectRatioCrop() const
{
    return d->preserveAspectRatioCrop;
}
 
void QQuickImageProviderOptions::setPreserveAspectRatioCrop(bool preserveAspectRatioCrop)
{
    d->preserveAspectRatioCrop = preserveAspectRatioCrop;
}
 
bool QQuickImageProviderOptions::preserveAspectRatioFit() const
{
    return d->preserveAspectRatioFit;
}
 
void QQuickImageProviderOptions::setPreserveAspectRatioFit(bool preserveAspectRatioFit)
{
    d->preserveAspectRatioFit = preserveAspectRatioFit;
}
 
QColorSpace QQuickImageProviderOptions::targetColorSpace() const
{
    return d->targetColorSpace;
}
 
void QQuickImageProviderOptions::setTargetColorSpace(const QColorSpace &colorSpace)
{
    d->targetColorSpace = colorSpace;
}
 
QRectF QQuickImageProviderOptions::sourceClipRect() const
{
    return d->sourceClipRect;
}
 
void QQuickImageProviderOptions::setSourceClipRect(const QRectF &rect)
{
    d->sourceClipRect = rect;
}
 
QQuickImageProviderWithOptions::QQuickImageProviderWithOptions(ImageType type, Flags flags)
 : QQuickAsyncImageProvider()
{
    QQuickImageProvider::d->type = type;
    QQuickImageProvider::d->flags = flags;
    QQuickImageProvider::d->isProviderWithOptions = true;
}
 
QImage QQuickImageProviderWithOptions::requestImage(const QString &id, QSize *size, const QSize& requestedSize)
{
    return requestImage(id, size, requestedSize, QQuickImageProviderOptions());
}
 
QPixmap QQuickImageProviderWithOptions::requestPixmap(const QString &id, QSize *size, const QSize& requestedSize)
{
    return requestPixmap(id, size, requestedSize, QQuickImageProviderOptions());
}
 
QQuickTextureFactory *QQuickImageProviderWithOptions::requestTexture(const QString &id, QSize *size, const QSize &requestedSize)
{
    return requestTexture(id, size, requestedSize, QQuickImageProviderOptions());
}
 
QImage QQuickImageProviderWithOptions::requestImage(const QString &id, QSize *size, const QSize& requestedSize, const QQuickImageProviderOptions &options)
{
    Q_UNUSED(options);
    return QQuickAsyncImageProvider::requestImage(id, size, requestedSize);
}
 
QPixmap QQuickImageProviderWithOptions::requestPixmap(const QString &id, QSize *size, const QSize& requestedSize, const QQuickImageProviderOptions &options)
{
    Q_UNUSED(options);
    return QQuickAsyncImageProvider::requestPixmap(id, size, requestedSize);
}
 
QQuickTextureFactory *QQuickImageProviderWithOptions::requestTexture(const QString &id, QSize *size, const QSize &requestedSize, const QQuickImageProviderOptions &options)
{
    Q_UNUSED(options);
    return QQuickAsyncImageProvider::requestTexture(id, size, requestedSize);
}
 
QQuickImageResponse *QQuickImageProviderWithOptions::requestImageResponse(const QString &id, const QSize &requestedSize)
{
    Q_UNUSED(id);
    Q_UNUSED(requestedSize);
    if (imageType() == ImageResponse)
        qWarning("ImageProvider is of ImageResponse type but has not implemented requestImageResponse()");
    return nullptr;
}
 
QQuickImageResponse *QQuickImageProviderWithOptions::requestImageResponse(const QString &id, const QSize &requestedSize, const QQuickImageProviderOptions &options)
{
    Q_UNUSED(options);
    return requestImageResponse(id, requestedSize);
}
 
QSize QQuickImageProviderWithOptions::loadSize(const QSize &originalSize, const QSize &requestedSize, const QByteArray &format, const QQuickImageProviderOptions &options,
                                               qreal devicePixelRatio)
{
    QSize res;
    const bool formatIsScalable = (format == "svg" || format == "svgz" || format == "pdf");
    const bool noRequestedSize = requestedSize.width() <= 0 && requestedSize.height() <= 0;
    if ((noRequestedSize && !formatIsScalable) || originalSize.isEmpty())
        return res;
 
    // If no sourceSize was set and we're loading an SVG, ensure that we provide
    // a default size that accounts for DPR so that the image isn't blurry.
    if (noRequestedSize && formatIsScalable)
        return originalSize * devicePixelRatio;
 
    const bool preserveAspectCropOrFit = options.preserveAspectRatioCrop() || options.preserveAspectRatioFit();
 
    if (!preserveAspectCropOrFit && formatIsScalable && !requestedSize.isEmpty())
        return requestedSize;
 
    qreal ratio = 0.0;
    if (requestedSize.width() && (preserveAspectCropOrFit || formatIsScalable ||
                                  requestedSize.width() < originalSize.width())) {
        ratio = qreal(requestedSize.width()) / originalSize.width();
    }
    if (requestedSize.height() && (preserveAspectCropOrFit || formatIsScalable ||
                                   requestedSize.height() < originalSize.height())) {
        qreal hr = qreal(requestedSize.height()) / originalSize.height();
        if (ratio == 0.0)
            ratio = hr;
        else if (!preserveAspectCropOrFit && (hr < ratio))
            ratio = hr;
        else if (preserveAspectCropOrFit && (hr > ratio))
            ratio = hr;
    }
    if (ratio > 0.0) {
        res.setHeight(qRound(originalSize.height() * ratio));
        res.setWidth(qRound(originalSize.width() * ratio));
    }
    return res;
}
 
QQuickImageProviderWithOptions *QQuickImageProviderWithOptions::checkedCast(QQuickImageProvider *provider)
{
    if (provider && provider->d && provider->d->isProviderWithOptions)
        return static_cast<QQuickImageProviderWithOptions *>(provider);
 
    return nullptr;
}
 
QT_END_NAMESPACE
 
#include "moc_qquickimageprovider.cpp"