Печать элемента Qml,расположенного в QQuickWidget

#include "ItemGrabber.h"

#include <QTimer>

#include <private/qquickitem_p.h>
#include <private/qsgrenderer_p.h>

class BindableFbo : public QSGBindable
{
public:
    BindableFbo(QOpenGLFramebufferObject *fbo)
        : m_fbo(fbo)
    {
    }
    virtual void bind() const { m_fbo->bind(); }
private:
    QOpenGLFramebufferObject *m_fbo;
};

ItemGrabber::ItemGrabber(QQuickItem *parent)
    : QQuickItem(parent)
{
    setFlag(ItemHasContents, false);
}

void ItemGrabber::grab(QVariantList items)
{
    m_items.clear();
    for (const auto &i : items) {
        auto obj = qobject_cast<QQuickItem *>(i.value<QObject *>());
        if (obj) {
            m_items.append(obj);
        }
    }

    // Delay the actual rendering to give all elements on the page
    // a chance to be fully rendered.
    QTimer::singleShot(500, this, [this]() {
        if (!isGrabbing && !m_items.isEmpty()) {
            isGrabbing = true;
            setFlag(QQuickItem::ItemHasContents);
            update();
        }
    });
}

QSGNode *ItemGrabber::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *updatePaintNodeData)
{
    Q_UNUSED(updatePaintNodeData);
    if (!(flags() & QQuickItem::ItemHasContents)) {
        isGrabbing = false;
        return oldNode;
    }
    setFlag(QQuickItem::ItemHasContents, false);

    auto toInt = [](qreal value)->int { return static_cast<int>(value); };
    QSize size(toInt(width()), toInt(height()));

    QSGRootNode root;
    QList<QSGNode *> nodes, parentNodes, siblingNodes;
    const int count = m_items.size();
    for (int i = 0; i < count; ++i) {
        QSGNode *node = QQuickItemPrivate::get(m_items[i])->itemNode();
        nodes.append(node);
        QSGNode *parentNode = node->QSGNode::parent();
        parentNodes.append(parentNode);
        QSGNode *previousSiblingNode = node->previousSibling();
        siblingNodes.append(previousSiblingNode);
        if (parentNode) {
            parentNode->removeChildNode(node);
        }
        root.appendChildNode(node);
    }
    QSGRenderer *renderer = QQuickItemPrivate::get(this)->sceneGraphRenderContext()->createRenderer();
    renderer->setRootNode(static_cast<QSGRootNode *>(&root));

    QOpenGLFramebufferObject fbo(size);
    renderer->setDeviceRect(size);
    renderer->setViewportRect(size);
    renderer->setProjectionMatrixToRect(QRectF(QPointF(), size));
    renderer->setClearColor(Qt::transparent);
    renderer->renderScene(BindableFbo(&fbo));
    fbo.release();

    QImage image = fbo.toImage().scaled(size, Qt::KeepAspectRatio, Qt::SmoothTransformation); // Format_ARGB32_Premultiplied

    for (int i = 0; i < count; ++i) {
        root.removeChildNode(nodes[i]);
    }
    renderer->setRootNode(nullptr);
    delete renderer;

    for (int i = 0; i < count; ++i) {
        if (siblingNodes[i]) {
            parentNodes[i]->insertChildNodeAfter(nodes[i], siblingNodes[i]);
        } else {
            parentNodes[i]->prependChildNode(nodes[i]);
        }
    }

    emit grabFinished(image);

    isGrabbing = false;
    return oldNode;
}

grab([item1id,item2id,item3id])

QSize size((int)width(), (int)height());
QOpenGLFramebufferObject fbo(size);

bool MyWidget::event(QEvent *event)
{
    if (event->type() == QEvent::UpdateRequest)
        myGrab();
    return QWidget::event(event);
}

void MyWidget::myGrab()
{
    ...
    QBackingStore *store = backingStore();
    Q_ASSERT(store);

    QPaintDevice *pdev = store->paintDevice();
    const auto image = dynamic_cast<QImage *>(pdev);
    ...
}

#include "grabber.h"

#include <QDebug>
#include <QElapsedTimer>
#include <QSGRootNode>
#include <QOpenGLFramebufferObject>

#include <private/qquickitem_p.h>
#include <private/qsgrenderer_p.h>

class BindableFbo final : public QSGBindable
{
public:
    explicit BindableFbo(QOpenGLFramebufferObject *fbo)
        : m_fbo(fbo)
    { }

    void bind() const final { m_fbo->bind(); }

private:
    QOpenGLFramebufferObject *m_fbo = nullptr;
};

Grabber::Grabber(QQuickItem *parent)
    : QQuickItem(parent)
{
    setFlag(QQuickItem::ItemHasContents);

    connect(this, &Grabber::windowChanged,
            this, &Grabber::scheduleWindowChange);
}

void Grabber::setSourceItem(QQuickItem *sourceItem)
{
    if (sourceItem == m_sourceItem)
        return;
    m_sourceItem = sourceItem;
    emit sourceItemChanged(m_sourceItem);
    update();
}

QQuickItem *Grabber::sourceItem() const
{
    return m_sourceItem;
}

QSGNode *Grabber::updatePaintNode(QSGNode *oldNode,
                                  UpdatePaintNodeData *updatePaintNodeData)
{
    Q_UNUSED(updatePaintNodeData);

    if (!m_sourceItem)
        return oldNode;

    m_running = true;

    const auto itemNode = QQuickItemPrivate::get(m_sourceItem)->itemNode();
    const auto parentNode = itemNode->parent();
    const auto siblingNode = itemNode->previousSibling();

    if (parentNode)
        parentNode->removeChildNode(itemNode);

    const QScopedPointer<QSGRenderer> renderer(
                QQuickItemPrivate::get(this)->
                sceneGraphRenderContext()->createRenderer());

    QSGRootNode rootNode;
    rootNode.appendChildNode(itemNode);
    renderer->setRootNode(&rootNode);

    const QSize size(m_sourceItem->width(), m_sourceItem->height());
    renderer->setDeviceRect(size);
    renderer->setViewportRect(size);
    renderer->setProjectionMatrixToRect(QRectF(QPointF(), size));
    renderer->setClearColor(Qt::transparent);

    QOpenGLFramebufferObject fbo(size);
    renderer->renderScene(BindableFbo(&fbo));
    fbo.release();

    rootNode.removeChildNode(itemNode);

    if (parentNode) {
        if (siblingNode) {
            parentNode->insertChildNodeAfter(itemNode, siblingNode);
        } else {
            parentNode->prependChildNode(itemNode);
        }
    }

    QElapsedTimer et;
    et.start();
    const QImage image = fbo.toImage(); // TOO LONG!
    static int count = 0;
    qDebug() << "Elapsed:" << et.elapsed() << count;

    ++count;

    //image.save(tr("test%1.png").arg(count++));

    return oldNode;
}

void Grabber::scheduleWindowChange(QQuickWindow *window)
{
    disconnect(m_updateConnection);
    if (window) {
        m_updateConnection = connect(window, &QQuickWindow::afterRendering,
                                     this, &Grabber::scheduleUpdate);
    }
}

void Grabber::scheduleUpdate()
{
    if (!m_running)
        update();
    else
        m_running = false;
}

import QtQuick 2.9
import QtQuick.Window 2.2

import com.semsotec.horex 1.0

Window {
    visible: true
    width: 800
    height: 600
    title: qsTr("Hello World")

    Item {
        id: root
        anchors.fill: parent

        Rectangle {
            width: 200
            height: 200
            color: "red"

            Behavior on x {
                NumberAnimation { from: 0; to: 800; duration: 2000; loops: Animation.Infinite }
            }
            Component.onCompleted: x = 100

            Text {
                id: name
                text: qsTr("text")
            }
        }

        Rectangle {
            y: root.height / 1.5
            width: 20
            height: 20
            color: "green"

            Behavior on x {
                NumberAnimation { from: 800; to: 0; duration: 500; loops: Animation.Infinite }
            }
            Component.onCompleted: x = 100
        }
    }

    Grabber {
        sourceItem: root
    }
}