qquickcanvasitem.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 <private/qsgadaptationlayer_p.h>
#include "qquickcanvasitem_p.h"
#include <private/qquickitem_p.h>
#include <private/qquickcanvascontext_p.h>
#include <private/qquickcontext2d_p.h>
#include <private/qquickcontext2dtexture_p.h>
#include <private/qsgadaptationlayer_p.h>
#include <qsgtextureprovider.h>
#include <QtQuick/private/qquickpixmapcache_p.h>
#include <QtGui/QGuiApplication>
#include <qsgtextureprovider.h>
 
#include <qqmlinfo.h>
#include <private/qqmlengine_p.h>
#include <QtCore/QBuffer>
#include <QtCore/qdatetime.h>
 
#include <private/qv4value_p.h>
#include <private/qv4functionobject_p.h>
#include <private/qv4scopedvalue_p.h>
#include <private/qv4jscall_p.h>
#include <private/qv4qobjectwrapper_p.h>
#include <private/qjsvalue_p.h>
 
QT_BEGIN_NAMESPACE
 
class QQuickCanvasTextureProvider : public QSGTextureProvider
{
public:
    QSGTexture *tex;
    QSGTexture *texture() const override { return tex; }
    void fireTextureChanged() { emit textureChanged(); }
};
 
QQuickCanvasPixmap::QQuickCanvasPixmap(const QImage& image)
    : m_pixmap(nullptr)
    , m_image(image)
{
 
}
 
QQuickCanvasPixmap::QQuickCanvasPixmap(QQuickPixmap *pixmap)
    : m_pixmap(pixmap)
{
 
}
 
QQuickCanvasPixmap::~QQuickCanvasPixmap()
{
    delete m_pixmap;
}
 
qreal QQuickCanvasPixmap::width() const
{
    if (m_pixmap)
        return m_pixmap->width();
 
    return m_image.width();
}
 
qreal QQuickCanvasPixmap::height() const
{
    if (m_pixmap)
        return m_pixmap->height();
 
    return m_image.height();
}
 
bool QQuickCanvasPixmap::isValid() const
{
    if (m_pixmap)
        return m_pixmap->isReady();
    return !m_image.isNull();
}
 
QImage QQuickCanvasPixmap::image()
{
    if (m_image.isNull() && m_pixmap)
        m_image = m_pixmap->image();
 
    return m_image;
}
 
QHash<QQmlEngine *,QQuickContext2DRenderThread*> QQuickContext2DRenderThread::renderThreads;
QMutex QQuickContext2DRenderThread::renderThreadsMutex;
 
QQuickContext2DRenderThread::QQuickContext2DRenderThread(QQmlEngine *eng)
    : QThread(eng), m_engine(eng), m_eventLoopQuitHack(nullptr)
{
    Q_ASSERT(eng);
    m_eventLoopQuitHack = new QObject;
    m_eventLoopQuitHack->moveToThread(this);
    connect(m_eventLoopQuitHack, SIGNAL(destroyed(QObject*)), SLOT(quit()), Qt::DirectConnection);
    start(QThread::IdlePriority);
}
 
QQuickContext2DRenderThread::~QQuickContext2DRenderThread()
{
    renderThreadsMutex.lock();
    renderThreads.remove(m_engine);
    renderThreadsMutex.unlock();
 
    m_eventLoopQuitHack->deleteLater();
    wait();
}
 
QQuickContext2DRenderThread *QQuickContext2DRenderThread::instance(QQmlEngine *engine)
{
    QQuickContext2DRenderThread *thread = nullptr;
    renderThreadsMutex.lock();
    if (renderThreads.contains(engine))
        thread = renderThreads.value(engine);
    else {
        thread = new QQuickContext2DRenderThread(engine);
        renderThreads.insert(engine, thread);
    }
    renderThreadsMutex.unlock();
    return thread;
}
 
class QQuickCanvasItemPrivate : public QQuickItemPrivate
{
public:
    QQuickCanvasItemPrivate();
    ~QQuickCanvasItemPrivate();
    QQuickCanvasContext *context;
    QSizeF canvasSize;
    QSize tileSize;
    QRectF canvasWindow;
    QRectF dirtyRect;
    uint hasCanvasSize :1;
    uint hasTileSize :1;
    uint hasCanvasWindow :1;
    uint available :1;
    QQuickCanvasItem::RenderTarget renderTarget;
    QQuickCanvasItem::RenderStrategy renderStrategy;
    QString contextType;
    QHash<QUrl, QQmlRefPointer<QQuickCanvasPixmap> > pixmaps;
    QUrl baseUrl;
    QMap<int, QV4::PersistentValue> animationCallbacks;
    mutable QQuickCanvasTextureProvider *textureProvider;
    QSGInternalImageNode *node;
    QSGTexture *nodeTexture;
};
 
QQuickCanvasItemPrivate::QQuickCanvasItemPrivate()
    : QQuickItemPrivate()
    , context(nullptr)
    , canvasSize(1, 1)
    , tileSize(1, 1)
    , hasCanvasSize(false)
    , hasTileSize(false)
    , hasCanvasWindow(false)
    , available(false)
    , renderTarget(QQuickCanvasItem::Image)
    , renderStrategy(QQuickCanvasItem::Immediate)
    , textureProvider(nullptr)
    , node(nullptr)
    , nodeTexture(nullptr)
{
    implicitAntialiasing = true;
}
 
QQuickCanvasItemPrivate::~QQuickCanvasItemPrivate()
{
    pixmaps.clear();
}
 
 
QQuickCanvasItem::QQuickCanvasItem(QQuickItem *parent)
    : QQuickItem(*(new QQuickCanvasItemPrivate), parent)
{
    setFlag(ItemHasContents);
}
 
QQuickCanvasItem::~QQuickCanvasItem()
{
    Q_D(QQuickCanvasItem);
    delete d->context;
    if (d->textureProvider)
        QQuickWindowQObjectCleanupJob::schedule(window(), d->textureProvider);
}
 
bool QQuickCanvasItem::isAvailable() const
{
    return d_func()->available;
}
 
QString QQuickCanvasItem::contextType() const
{
    return d_func()->contextType;
}
 
void QQuickCanvasItem::setContextType(const QString &contextType)
{
    Q_D(QQuickCanvasItem);
 
    if (contextType.compare(d->contextType, Qt::CaseInsensitive) == 0)
        return;
 
    if (d->context) {
        qmlWarning(this) << "Canvas already initialized with a different context type";
        return;
    }
 
    d->contextType = contextType;
 
    if (d->available)
        createContext(contextType);
 
    emit contextTypeChanged();
}
 
QJSValue QQuickCanvasItem::context() const
{
    Q_D(const QQuickCanvasItem);
    return d->context ? QJSValuePrivate::fromReturnedValue(d->context->v4value()) : QJSValue();
}
 
QSizeF QQuickCanvasItem::canvasSize() const
{
    Q_D(const QQuickCanvasItem);
    return d->canvasSize;
}
 
void QQuickCanvasItem::setCanvasSize(const QSizeF & size)
{
    Q_D(QQuickCanvasItem);
    if (d->canvasSize != size) {
        d->hasCanvasSize = true;
        d->canvasSize = size;
        emit canvasSizeChanged();
 
        if (d->context)
            polish();
    }
}
 
QSize QQuickCanvasItem::tileSize() const
{
    Q_D(const QQuickCanvasItem);
    return d->tileSize;
}
 
void QQuickCanvasItem::setTileSize(const QSize & size)
{
    Q_D(QQuickCanvasItem);
    if (d->tileSize != size) {
        d->hasTileSize = true;
        d->tileSize = size;
 
        emit tileSizeChanged();
 
        if (d->context)
            polish();
    }
}
 
QRectF QQuickCanvasItem::canvasWindow() const
{
    Q_D(const QQuickCanvasItem);
    return d->canvasWindow;
}
 
void QQuickCanvasItem::setCanvasWindow(const QRectF& rect)
{
    Q_D(QQuickCanvasItem);
    if (d->canvasWindow != rect) {
        d->canvasWindow = rect;
 
        d->hasCanvasWindow = true;
        emit canvasWindowChanged();
 
        if (d->context)
            polish();
    }
}
 
QQuickCanvasItem::RenderTarget QQuickCanvasItem::renderTarget() const
{
    Q_D(const QQuickCanvasItem);
    return d->renderTarget;
}
 
void QQuickCanvasItem::setRenderTarget(QQuickCanvasItem::RenderTarget target)
{
    Q_D(QQuickCanvasItem);
    if (d->renderTarget != target) {
        if (d->context) {
            qmlWarning(this) << "Canvas:renderTarget not changeble once context is active.";
            return;
        }
 
        d->renderTarget = target;
        emit renderTargetChanged();
    }
}
 
QQuickCanvasItem::RenderStrategy QQuickCanvasItem::renderStrategy() const
{
    return d_func()->renderStrategy;
}
 
void QQuickCanvasItem::setRenderStrategy(QQuickCanvasItem::RenderStrategy strategy)
{
    Q_D(QQuickCanvasItem);
    if (d->renderStrategy != strategy) {
        if (d->context) {
            qmlWarning(this) << "Canvas:renderStrategy not changeable once context is active.";
            return;
        }
        d->renderStrategy = strategy;
        emit renderStrategyChanged();
    }
}
 
QQuickCanvasContext* QQuickCanvasItem::rawContext() const
{
    return d_func()->context;
}
 
bool QQuickCanvasItem::isPaintConnected()
{
    IS_SIGNAL_CONNECTED(this, QQuickCanvasItem, paint, (const QRect &));
}
 
void QQuickCanvasItem::sceneGraphInitialized()
{
    Q_D(QQuickCanvasItem);
 
    d->available = true;
    connect(this, SIGNAL(visibleChanged()), SLOT(checkAnimationCallbacks()));
    QMetaObject::invokeMethod(this, "availableChanged", Qt::QueuedConnection);
 
    if (!d->contextType.isNull())
        QMetaObject::invokeMethod(this, "delayedCreate", Qt::QueuedConnection);
    else if (isPaintConnected())
        QMetaObject::invokeMethod(this, "requestPaint", Qt::QueuedConnection);
}
 
void QQuickCanvasItem::geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry)
{
    Q_D(QQuickCanvasItem);
 
    QQuickItem::geometryChange(newGeometry, oldGeometry);
 
    // Due to indirect recursion, newGeometry may be outdated
    // after this call, so we use width and height instead.
    QSizeF newSize = QSizeF(width(), height());
    if (!d->hasCanvasSize && d->canvasSize != newSize) {
        d->canvasSize = newSize;
        emit canvasSizeChanged();
    }
 
    if (!d->hasTileSize && d->tileSize != newSize) {
        d->tileSize = newSize.toSize();
        emit tileSizeChanged();
    }
 
    const QRectF rect = QRectF(QPointF(0, 0), newSize);
 
    if (!d->hasCanvasWindow && d->canvasWindow != rect) {
        d->canvasWindow = rect;
        emit canvasWindowChanged();
    }
 
    if (d->available && newSize != oldGeometry.size()) {
        if (isVisible() || (d->extra.isAllocated() && d->extra->effectRefCount > 0))
            requestPaint();
    }
}
 
void QQuickCanvasItem::releaseResources()
{
    Q_D(QQuickCanvasItem);
 
    if (d->context) {
        delete d->context;
        d->context = nullptr;
    }
    d->node = nullptr; // managed by the scene graph, just reset the pointer
    if (d->textureProvider) {
        QQuickWindowQObjectCleanupJob::schedule(window(), d->textureProvider);
        d->textureProvider = nullptr;
    }
    if (d->nodeTexture) {
        QQuickWindowQObjectCleanupJob::schedule(window(), d->nodeTexture);
        d->nodeTexture = nullptr;
    }
}
 
bool QQuickCanvasItem::event(QEvent *event)
{
    switch (event->type()) {
    case QEvent::PolishRequest:
        polish();
        return true;
    default:
        return QQuickItem::event(event);
    }
}
 
void QQuickCanvasItem::invalidateSceneGraph()
{
    Q_D(QQuickCanvasItem);
    if (d->context)
        d->context->deleteLater();
    d->context = nullptr;
    d->node = nullptr; // managed by the scene graph, just reset the pointer
    delete d->textureProvider;
    d->textureProvider = nullptr;
    delete d->nodeTexture;
    d->nodeTexture = nullptr;
 
    // As we can expect(/hope) that the SG will be "good again", we can requestPaint ( which does 'markDirty(canvasWindow);' )
    // Otherwise this Canvas will be "blank" when SG comes back
    requestPaint();
}
 
void QQuickCanvasItem::schedulePolish()
{
    auto polishRequestEvent = new QEvent(QEvent::PolishRequest);
    QCoreApplication::postEvent(this, polishRequestEvent);
}
 
void QQuickCanvasItem::componentComplete()
{
    QQuickItem::componentComplete();
 
    Q_D(QQuickCanvasItem);
    d->baseUrl = qmlEngine(this)->contextForObject(this)->baseUrl();
}
 
void QQuickCanvasItem::itemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &value)
{
    QQuickItem::itemChange(change, value);
    if (change != QQuickItem::ItemSceneChange)
        return;
 
    Q_D(QQuickCanvasItem);
    if (d->available) {
        if (d->dirtyAttributes & QQuickItemPrivate::ContentUpdateMask)
            requestPaint();
        return;
    }
 
    if (value.window== nullptr)
        return;
 
    d->window = value.window;
    QSGRenderContext *context = QQuickWindowPrivate::get(d->window)->context;
 
    // Rendering to FramebufferObject needs a valid OpenGL context.
    if (context != nullptr && (d->renderTarget != FramebufferObject || context->isValid())) {
        // Defer the call. In some (arguably incorrect) cases we get here due
        // to ItemSceneChange with the user-supplied property values not yet
        // set. Work this around by a deferred invoke. (QTBUG-49692)
        QMetaObject::invokeMethod(this, "sceneGraphInitialized", Qt::QueuedConnection);
    } else {
        connect(d->window, SIGNAL(sceneGraphInitialized()), SLOT(sceneGraphInitialized()));
    }
}
 
void QQuickCanvasItem::updatePolish()
{
    QQuickItem::updatePolish();
 
    Q_D(QQuickCanvasItem);
    if (d->context && d->renderStrategy != QQuickCanvasItem::Cooperative)
        d->context->prepare(d->canvasSize.toSize(), d->tileSize, d->canvasWindow.toRect(), d->dirtyRect.toRect(), d->smooth, antialiasing());
 
    if (d->animationCallbacks.size() > 0 && isVisible()) {
        QMap<int, QV4::PersistentValue> animationCallbacks = d->animationCallbacks;
        d->animationCallbacks.clear();
 
        QV4::ExecutionEngine *v4 = qmlEngine(this)->handle();
        QV4::Scope scope(v4);
        QV4::ScopedFunctionObject function(scope);
        QV4::JSCallArguments jsCall(scope, 1);
        *jsCall.thisObject = QV4::QObjectWrapper::wrap(v4, this);
 
        for (auto it = animationCallbacks.cbegin(), end = animationCallbacks.cend(); it != end; ++it) {
            function = it.value().value();
            jsCall.args[0] = QV4::Value::fromUInt32(QDateTime::currentMSecsSinceEpoch());
            function->call(jsCall);
        }
    }
    else {
        if (d->dirtyRect.isValid()) {
            if (d->hasTileSize && d->hasCanvasWindow)
                emit paint(tiledRect(d->canvasWindow.intersected(d->dirtyRect.toAlignedRect()), d->tileSize));
            else
                emit paint(d->dirtyRect.toRect());
            d->dirtyRect = QRectF();
        }
    }
 
    if (d->context) {
        if (d->renderStrategy == QQuickCanvasItem::Cooperative)
            update();
        else
            d->context->flush();
    }
}
 
QSGNode *QQuickCanvasItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
{
    Q_D(QQuickCanvasItem);
 
    if (!d->context || d->canvasWindow.size().isEmpty()) {
        if (d->textureProvider) {
            d->textureProvider->tex = nullptr;
            d->textureProvider->fireTextureChanged();
        }
        delete oldNode;
        return nullptr;
    }
 
    QSGInternalImageNode *node = static_cast<QSGInternalImageNode *>(oldNode);
    if (!node) {
        QSGRenderContext *rc = QQuickWindowPrivate::get(window())->context;
        node = rc->sceneGraphContext()->createInternalImageNode(rc);
        d->node = node;
    }
 
 
    if (d->smooth)
        node->setFiltering(QSGTexture::Linear);
    else
        node->setFiltering(QSGTexture::Nearest);
 
    if (d->renderStrategy == QQuickCanvasItem::Cooperative) {
        d->context->prepare(d->canvasSize.toSize(), d->tileSize, d->canvasWindow.toRect(), d->dirtyRect.toRect(), d->smooth, antialiasing());
        d->context->flush();
    }
 
    QQuickContext2D *ctx = qobject_cast<QQuickContext2D *>(d->context);
    QQuickContext2DTexture *factory = ctx->texture();
    QSGTexture *texture = factory->textureForNextFrame(d->nodeTexture, window());
    if (!texture) {
        delete node;
        d->node = nullptr;
        d->nodeTexture = nullptr;
        if (d->textureProvider) {
            d->textureProvider->tex = nullptr;
            d->textureProvider->fireTextureChanged();
        }
        return nullptr;
    }
 
    d->nodeTexture = texture;
    node->setTexture(texture);
    node->setTargetRect(QRectF(QPoint(0, 0), d->canvasWindow.size()));
    node->setInnerTargetRect(QRectF(QPoint(0, 0), d->canvasWindow.size()));
    node->update();
 
    if (d->textureProvider) {
        d->textureProvider->tex = d->nodeTexture;
        d->textureProvider->fireTextureChanged();
    }
    return node;
}
 
bool QQuickCanvasItem::isTextureProvider() const
{
    return true;
}
 
QSGTextureProvider *QQuickCanvasItem::textureProvider() const
{
    // When Item::layer::enabled == true, QQuickItem will be a texture
    // provider. In this case we should prefer to return the layer rather
    // than the canvas itself.
    if (QQuickItem::isTextureProvider())
        return QQuickItem::textureProvider();
 
    Q_D(const QQuickCanvasItem);
 
    QQuickWindow *w = window();
    if (!w || !w->isSceneGraphInitialized()
            || QThread::currentThread() != QQuickWindowPrivate::get(w)->context->thread()) {
        qWarning("QQuickCanvasItem::textureProvider: can only be queried on the rendering thread of an exposed window");
        return nullptr;
    }
 
    if (!d->textureProvider)
        d->textureProvider = new QQuickCanvasTextureProvider;
    d->textureProvider->tex = d->nodeTexture;
    return d->textureProvider;
}
 
void QQuickCanvasItem::getContext(QQmlV4Function *args)
{
    Q_D(QQuickCanvasItem);
 
    QV4::Scope scope(args->v4engine());
    QV4::ScopedString str(scope, (*args)[0]);
    if (!str) {
        qmlWarning(this) << "getContext should be called with a string naming the required context type";
        args->setReturnValue(QV4::Encode::null());
        return;
    }
 
    if (!d->available) {
        qmlWarning(this) << "Unable to use getContext() at this time, please wait for available: true";
        args->setReturnValue(QV4::Encode::null());
        return;
    }
 
    QString contextId = str->toQString();
 
    if (d->context != nullptr) {
        if (d->context->contextNames().contains(contextId, Qt::CaseInsensitive)) {
            args->setReturnValue(d->context->v4value());
            return;
        }
 
        qmlWarning(this) << "Canvas already initialized with a different context type";
        args->setReturnValue(QV4::Encode::null());
        return;
    }
 
    if (createContext(contextId))
        args->setReturnValue(d->context->v4value());
    else
        args->setReturnValue(QV4::Encode::null());
}
 
void QQuickCanvasItem::requestAnimationFrame(QQmlV4Function *args)
{
    QV4::Scope scope(args->v4engine());
    QV4::ScopedFunctionObject f(scope, (*args)[0]);
    if (!f) {
        qmlWarning(this) << "requestAnimationFrame should be called with an animation callback function";
        args->setReturnValue(QV4::Encode::null());
        return;
    }
 
    Q_D(QQuickCanvasItem);
 
    static int id = 0;
 
    d->animationCallbacks.insert(++id, QV4::PersistentValue(scope.engine, f->asReturnedValue()));
 
    // QTBUG-55778: Calling polish directly here can lead to a polish loop
    if (isVisible())
        schedulePolish();
 
    args->setReturnValue(QV4::Encode(id));
}
 
void QQuickCanvasItem::cancelRequestAnimationFrame(QQmlV4Function *args)
{
    QV4::Scope scope(args->v4engine());
    QV4::ScopedValue v(scope, (*args)[0]);
    if (!v->isInteger()) {
        qmlWarning(this) << "cancelRequestAnimationFrame should be called with an animation callback id";
        args->setReturnValue(QV4::Encode::null());
        return;
    }
 
    d_func()->animationCallbacks.remove(v->integerValue());
}
 
 
void QQuickCanvasItem::requestPaint()
{
    markDirty(d_func()->canvasWindow);
}
 
void QQuickCanvasItem::markDirty(const QRectF& rect)
{
    Q_D(QQuickCanvasItem);
    if (!d->available)
        return;
 
    d->dirtyRect |= rect;
 
    polish();
}
 
void QQuickCanvasItem::checkAnimationCallbacks()
{
    if (d_func()->animationCallbacks.size() > 0 && isVisible())
        polish();
}
 
bool QQuickCanvasItem::save(const QString &filename, const QSizeF &imageSize) const
{
    Q_D(const QQuickCanvasItem);
    QUrl url = d->baseUrl.resolved(QUrl::fromLocalFile(filename));
    return toImage(QRectF(QPointF(0, 0), imageSize)).save(url.toLocalFile());
}
 
QQmlRefPointer<QQuickCanvasPixmap> QQuickCanvasItem::loadedPixmap(const QUrl& url, QSizeF sourceSize)
{
    Q_D(QQuickCanvasItem);
    QUrl fullPathUrl = d->baseUrl.resolved(url);
    if (!d->pixmaps.contains(fullPathUrl)) {
        loadImage(url, sourceSize);
    }
    return d->pixmaps.value(fullPathUrl);
}
 
void QQuickCanvasItem::loadImage(const QUrl& url, QSizeF sourceSize)
{
    Q_D(QQuickCanvasItem);
    QUrl fullPathUrl = d->baseUrl.resolved(url);
    if (!d->pixmaps.contains(fullPathUrl)) {
        QQuickPixmap* pix = new QQuickPixmap();
        QQmlRefPointer<QQuickCanvasPixmap> canvasPix;
        canvasPix.adopt(new QQuickCanvasPixmap(pix));
        d->pixmaps.insert(fullPathUrl, canvasPix);
 
        pix->load(qmlEngine(this)
                , fullPathUrl
                , QRect()
                , sourceSize.toSize()
                , QQuickPixmap::Cache | QQuickPixmap::Asynchronous);
        if (pix->isLoading())
            pix->connectFinished(this, SIGNAL(imageLoaded()));
    }
}
void QQuickCanvasItem::unloadImage(const QUrl& url)
{
    Q_D(QQuickCanvasItem);
    d->pixmaps.remove(d->baseUrl.resolved(url));
}
 
bool QQuickCanvasItem::isImageError(const QUrl& url) const
{
    Q_D(const QQuickCanvasItem);
    QUrl fullPathUrl = d->baseUrl.resolved(url);
    return d->pixmaps.contains(fullPathUrl)
        && d->pixmaps.value(fullPathUrl)->pixmap()->isError();
}
 
bool QQuickCanvasItem::isImageLoading(const QUrl& url) const
{
    Q_D(const QQuickCanvasItem);
    QUrl fullPathUrl = d->baseUrl.resolved(url);
    return d->pixmaps.contains(fullPathUrl)
        && d->pixmaps.value(fullPathUrl)->pixmap()->isLoading();
}
bool QQuickCanvasItem::isImageLoaded(const QUrl& url) const
{
    Q_D(const QQuickCanvasItem);
    QUrl fullPathUrl = d->baseUrl.resolved(url);
    return d->pixmaps.contains(fullPathUrl)
        && d->pixmaps.value(fullPathUrl)->pixmap()->isReady();
}
 
QImage QQuickCanvasItem::toImage(const QRectF& rect) const
{
    Q_D(const QQuickCanvasItem);
 
    if (!d->context)
        return QImage();
 
    const QRectF &rectSource = rect.isEmpty() ? canvasWindow() : rect;
    const qreal dpr = window() && rect.isEmpty() ? window()->effectiveDevicePixelRatio() : qreal(1);
    const QRectF rectScaled(rectSource.topLeft() * dpr, rectSource.size() * dpr);
 
    QImage image = d->context->toImage(rectScaled);
    image.setDevicePixelRatio(dpr);
    return image;
}
 
static const char* mimeToType(const QString &mime)
{
    const QLatin1String imagePrefix("image/");
    if (!mime.startsWith(imagePrefix))
        return nullptr;
    const QStringView mimeExt = QStringView{mime}.mid(imagePrefix.size());
    if (mimeExt == QLatin1String("png"))
        return "png";
    else if (mimeExt == QLatin1String("bmp"))
        return "bmp";
    else if (mimeExt == QLatin1String("jpeg"))
        return "jpeg";
    else if (mimeExt == QLatin1String("x-portable-pixmap"))
        return "ppm";
    else if (mimeExt == QLatin1String("tiff"))
        return "tiff";
    else if (mimeExt == QLatin1String("xpm"))
        return "xpm";
    return nullptr;
}
 
QString QQuickCanvasItem::toDataURL(const QString& mimeType) const
{
    QImage image = toImage();
 
    if (!image.isNull()) {
        QByteArray ba;
        QBuffer buffer(&ba);
        buffer.open(QIODevice::WriteOnly);
        const QString mime = mimeType.toLower();
        const char* type = mimeToType(mime);
        if (!type)
            return QStringLiteral("data:,");
 
        image.save(&buffer, type);
        buffer.close();
        return QLatin1String("data:") + mime + QLatin1String(";base64,") + QLatin1String(ba.toBase64().constData());
    }
    return QStringLiteral("data:,");
}
 
void QQuickCanvasItem::delayedCreate()
{
    Q_D(QQuickCanvasItem);
 
    if (!d->context && !d->contextType.isNull())
        createContext(d->contextType);
 
    requestPaint();
}
 
bool QQuickCanvasItem::createContext(const QString &contextType)
{
    Q_D(QQuickCanvasItem);
 
    if (!window())
        return false;
 
    if (contextType == QLatin1String("2d")) {
        if (d->contextType.compare(QLatin1String("2d"), Qt::CaseInsensitive) != 0)  {
            d->contextType = QLatin1String("2d");
            emit contextTypeChanged(); // XXX: can't be in setContextType()
        }
        initializeContext(new QQuickContext2D(this));
        return true;
    }
 
    return false;
}
 
void QQuickCanvasItem::initializeContext(QQuickCanvasContext *context, const QVariantMap &args)
{
    Q_D(QQuickCanvasItem);
 
    d->context = context;
    d->context->init(this, args);
    d->context->setV4Engine(qmlEngine(this)->handle());
    connect(d->context, SIGNAL(textureChanged()), SLOT(update()));
    connect(d->context, SIGNAL(textureChanged()), SIGNAL(painted()));
    emit contextChanged();
}
 
QRect QQuickCanvasItem::tiledRect(const QRectF &window, const QSize &tileSize)
{
    if (window.isEmpty())
        return QRect();
 
    const int tw = tileSize.width();
    const int th = tileSize.height();
    const int h1 = window.left() / tw;
    const int v1 = window.top() / th;
 
    const int htiles = ((window.right() - h1 * tw) + tw - 1)/tw;
    const int vtiles = ((window.bottom() - v1 * th) + th - 1)/th;
 
    return QRect(h1 * tw, v1 * th, htiles * tw, vtiles * th);
}
 
QT_END_NAMESPACE
 
#include "moc_qquickcanvasitem_p.cpp"