qquickitemgrabresult.cpp

Go to the documentation of this file.

// Copyright (C) 2016 Jolla Ltd, author: <gunnar.sletta@jollamobile.com>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include <private/qtquickglobal_p.h>
#include "qquickitemgrabresult.h"
 
#include "qquickrendercontrol.h"
#include "qquickwindow.h"
#include "qquickitem.h"
#if QT_CONFIG(quick_shadereffect)
#include "qquickshadereffectsource_p.h"
#endif
 
#include <QtQml/QQmlEngine>
#include <QtQml/QQmlInfo>
 
#include <private/qquickpixmap_p.h>
#include <private/qquickitem_p.h>
#include <private/qsgcontext_p.h>
#include <private/qsgadaptationlayer_p.h>
 
#include <QtCore/qpointer.h>
 
QT_BEGIN_NAMESPACE
 
const QEvent::Type Event_Grab_Completed = static_cast<QEvent::Type>(QEvent::User + 1);
 
class QQuickItemGrabResultPrivate : public QObjectPrivate
{
public:
    QQuickItemGrabResultPrivate()
        : cacheEntry(nullptr)
        , qmlEngine(nullptr)
        , texture(nullptr)
        , devicePixelRatio(1.0)
    {
    }
 
    ~QQuickItemGrabResultPrivate()
    {
        delete cacheEntry;
    }
 
    void ensureImageInCache() const {
        if (url.isEmpty() && !image.isNull()) {
            url.setScheme(QQuickPixmap::itemGrabberScheme);
            url.setPath(QVariant::fromValue(item.data()).toString());
            static uint counter = 0;
            url.setFragment(QString::number(++counter));
            cacheEntry = new QQuickPixmap(url, image);
        }
    }
 
    static QQuickItemGrabResult *create(QQuickItem *item, const QSize &size);
 
    QImage image;
 
    mutable QUrl url;
    mutable QQuickPixmap *cacheEntry;
 
    QQmlEngine *qmlEngine;
    QJSValue callback;
 
    QPointer<QQuickItem> item;
    QPointer<QQuickWindow> window;
    QSGLayer *texture;
    QSizeF itemSize;
    QSize textureSize;
    qreal devicePixelRatio;
};
 
QQuickItemGrabResult::QQuickItemGrabResult(QObject *parent)
    : QObject(*new QQuickItemGrabResultPrivate, parent)
{
}
 
// ### Qt 7: remove and keep only QUrl overload
bool QQuickItemGrabResult::saveToFile(const QString &fileName) const
{
    Q_D(const QQuickItemGrabResult);
    if (fileName.startsWith(QLatin1String("file:/")))
        return saveToFile(QUrl(fileName));
    return d->image.save(fileName);
}
 
bool QQuickItemGrabResult::saveToFile(const QUrl &filePath) const
{
    Q_D(const QQuickItemGrabResult);
    if (!filePath.isLocalFile()) {
        qWarning() << "saveToFile can only save to a file on the local filesystem";
        return false;
    }
    return d->image.save(filePath.toLocalFile());
}
 
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
#if QT_DEPRECATED_SINCE(5, 15)
bool QQuickItemGrabResult::saveToFile(const QString &fileName)
{
    return std::as_const(*this).saveToFile(fileName);
}
#endif
#endif // < Qt 6
 
QUrl QQuickItemGrabResult::url() const
{
    Q_D(const QQuickItemGrabResult);
    d->ensureImageInCache();
    return d->url;
}
 
QImage QQuickItemGrabResult::image() const
{
    Q_D(const QQuickItemGrabResult);
    return d->image;
}
 
bool QQuickItemGrabResult::event(QEvent *e)
{
    Q_D(QQuickItemGrabResult);
    if (e->type() == Event_Grab_Completed) {
        // JS callback
        if (d->qmlEngine && d->callback.isCallable()) {
            d->callback.call(QJSValueList() << d->qmlEngine->newQObject(this));
            deleteLater();
        } else {
            Q_EMIT ready();
        }
        return true;
    }
    return QObject::event(e);
}
 
void QQuickItemGrabResult::setup()
{
    Q_D(QQuickItemGrabResult);
    if (!d->item) {
        disconnect(d->window.data(), &QQuickWindow::beforeSynchronizing, this, &QQuickItemGrabResult::setup);
        disconnect(d->window.data(), &QQuickWindow::afterRendering, this, &QQuickItemGrabResult::render);
        QCoreApplication::postEvent(this, new QEvent(Event_Grab_Completed));
        return;
    }
 
    QSGRenderContext *rc = QQuickWindowPrivate::get(d->window.data())->context;
    d->devicePixelRatio = d->window->effectiveDevicePixelRatio();
    d->texture = rc->sceneGraphContext()->createLayer(rc);
    d->texture->setDevicePixelRatio(d->devicePixelRatio);
    d->texture->setItem(QQuickItemPrivate::get(d->item)->itemNode());
    d->itemSize = QSizeF(d->item->width(), d->item->height());
}
 
void QQuickItemGrabResult::render()
{
    Q_D(QQuickItemGrabResult);
    if (!d->texture)
        return;
 
    d->texture->setRect(QRectF(0, d->itemSize.height(), d->itemSize.width(), -d->itemSize.height()));
    const QSize minSize = QQuickWindowPrivate::get(d->window.data())->context->sceneGraphContext()->minimumFBOSize();
    const QSize effectiveTextureSize = d->textureSize * d->devicePixelRatio;
    d->texture->setSize(QSize(qMax(minSize.width(), effectiveTextureSize.width()),
                              qMax(minSize.height(), effectiveTextureSize.height())));
    d->texture->scheduleUpdate();
    d->texture->updateTexture();
    d->image = d->texture->toImage();
    d->image.setDevicePixelRatio(d->devicePixelRatio);
 
    delete d->texture;
    d->texture = nullptr;
 
    disconnect(d->window.data(), &QQuickWindow::beforeSynchronizing, this, &QQuickItemGrabResult::setup);
    disconnect(d->window.data(), &QQuickWindow::afterRendering, this, &QQuickItemGrabResult::render);
    QCoreApplication::postEvent(this, new QEvent(Event_Grab_Completed));
}
 
QQuickItemGrabResult *QQuickItemGrabResultPrivate::create(QQuickItem *item, const QSize &targetSize)
{
    QSize size = targetSize;
    if (size.isEmpty())
        size = QSize(item->width(), item->height());
 
    if (size.width() < 1 || size.height() < 1) {
        qmlWarning(item) << "grabToImage: item has invalid dimensions";
        return nullptr;
    }
 
    if (!item->window()) {
        qmlWarning(item) << "grabToImage: item is not attached to a window";
        return nullptr;
    }
 
    QWindow *effectiveWindow = item->window();
    if (QWindow *renderWindow = QQuickRenderControl::renderWindowFor(item->window()))
        effectiveWindow = renderWindow;
 
    if (!effectiveWindow->isVisible()) {
        qmlWarning(item) << "grabToImage: item's window is not visible";
        return nullptr;
    }
 
    QQuickItemGrabResult *result = new QQuickItemGrabResult();
    QQuickItemGrabResultPrivate *d = result->d_func();
    d->item = item;
    d->window = item->window();
    d->textureSize = size;
 
    QQuickItemPrivate::get(item)->refFromEffectItem(false);
 
    // trigger sync & render
    item->window()->update();
 
    return result;
}
 
QSharedPointer<QQuickItemGrabResult> QQuickItem::grabToImage(const QSize &targetSize)
{
    QQuickItemGrabResult *result = QQuickItemGrabResultPrivate::create(this, targetSize);
    if (!result)
        return QSharedPointer<QQuickItemGrabResult>();
 
    connect(window(), &QQuickWindow::beforeSynchronizing, result, &QQuickItemGrabResult::setup, Qt::DirectConnection);
    connect(window(), &QQuickWindow::afterRendering, result, &QQuickItemGrabResult::render, Qt::DirectConnection);
 
    return QSharedPointer<QQuickItemGrabResult>(result);
}
 
bool QQuickItem::grabToImage(const QJSValue &callback, const QSize &targetSize)
{
    QQmlEngine *engine = qmlEngine(this);
    if (!engine) {
        qmlWarning(this) << "grabToImage: item has no QML engine";
        return false;
    }
 
    if (!callback.isCallable()) {
        qmlWarning(this) << "grabToImage: 'callback' is not a function";
        return false;
    }
 
    QSize size = targetSize;
    if (size.isEmpty())
        size = QSize(width(), height());
 
    if (size.width() < 1 || size.height() < 1) {
        qmlWarning(this) << "grabToImage: item has invalid dimensions";
        return false;
    }
 
    if (!window()) {
        qmlWarning(this) << "grabToImage: item is not attached to a window";
        return false;
    }
 
    QQuickItemGrabResult *result = QQuickItemGrabResultPrivate::create(this, size);
    if (!result)
        return false;
 
    connect(window(), &QQuickWindow::beforeSynchronizing, result, &QQuickItemGrabResult::setup, Qt::DirectConnection);
    connect(window(), &QQuickWindow::afterRendering, result, &QQuickItemGrabResult::render, Qt::DirectConnection);
 
    QQuickItemGrabResultPrivate *d = result->d_func();
    d->qmlEngine = engine;
    d->callback = callback;
    return true;
}
 
QT_END_NAMESPACE
 
#include "moc_qquickitemgrabresult.cpp"