qsvgvisitorimpl.cpp

Go to the documentation of this file.

// Copyright (C) 2024 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 "qsvgvisitorimpl_p.h"
#include "qquickgenerator_p.h"
#include "qquicknodeinfo_p.h"
 
#include <private/qsvgvisitor_p.h>
 
#include <QString>
#include <QPainter>
#include <QTextDocument>
#include <QTextLayout>
#include <QMatrix4x4>
#include <QQuickItem>
 
#include <private/qquickshape_p.h>
#include <private/qquicktext_p.h>
#include <private/qquicktranslate_p.h>
#include <private/qquickitem_p.h>
 
#include <private/qquickimagebase_p_p.h>
#include <private/qquickimage_p.h>
#include <private/qsgcurveprocessor_p.h>
 
#include <private/qquadpath_p.h>
 
#include <QtCore/private/qstringiterator_p.h>
 
#include "utils_p.h"
#include <QtCore/qloggingcategory.h>
#include <QtCore/qscopedvaluerollback.h>
#include <QtCore/qxmlstream.h>
 
#include <QtSvg/private/qsvgdocument_p.h>
#include <QtSvg/private/qsvgstyle_p.h>
#include <QtSvg/private/qsvgfilter_p.h>
 
QT_BEGIN_NAMESPACE
 
Q_STATIC_LOGGING_CATEGORY(lcVectorImageAnimations, "qt.quick.vectorimage.animations")
 
using namespace Qt::StringLiterals;
 
class QSvgStyleResolver
{
public:
    explicit QSvgStyleResolver(const QSvgDocument *doc)
        : m_svgState(doc)
    {
        m_dummyImage = QImage(1, 1, QImage::Format_RGB32);
        m_dummyPainter.begin(&m_dummyImage);
        QPen defaultPen(Qt::NoBrush, 1, Qt::SolidLine, Qt::FlatCap, Qt::SvgMiterJoin);
        defaultPen.setMiterLimit(4);
        m_dummyPainter.setPen(defaultPen);
        m_dummyPainter.setBrush(Qt::black);
    }
 
    ~QSvgStyleResolver()
    {
        m_dummyPainter.end();
    }
 
    QPainter& painter() { return m_dummyPainter; }
    QSvgExtraStates& states() { return m_svgState; }
 
    QColor currentFillColor() const
    {
        if (m_dummyPainter.brush().style() == Qt::NoBrush ||
            m_dummyPainter.brush().color() == QColorConstants::Transparent) {
            return QColor(QColorConstants::Transparent);
        }
 
        QColor fillColor;
        fillColor = m_dummyPainter.brush().color();
        fillColor.setAlphaF(m_svgState.fillOpacity);
 
        return fillColor;
    }
 
    qreal currentFillOpacity() const
    {
        return m_svgState.fillOpacity;
    }
 
    const QGradient *currentStrokeGradient() const
    {
        QBrush brush = m_dummyPainter.pen().brush();
        if (brush.style() == Qt::LinearGradientPattern
                || brush.style() == Qt::RadialGradientPattern
                || brush.style() == Qt::ConicalGradientPattern) {
            return brush.gradient();
        }
        return nullptr;
    }
 
    const QGradient *currentFillGradient() const
    {
        if (m_dummyPainter.brush().style() == Qt::LinearGradientPattern || m_dummyPainter.brush().style() == Qt::RadialGradientPattern || m_dummyPainter.brush().style() == Qt::ConicalGradientPattern )
            return m_dummyPainter.brush().gradient();
        return nullptr;
    }
 
    QTransform currentFillTransform() const
    {
        return m_dummyPainter.brush().transform();
    }
 
    QColor currentStrokeColor() const
    {
        if (m_dummyPainter.pen().brush().style() == Qt::NoBrush ||
            m_dummyPainter.pen().brush().color() == QColorConstants::Transparent) {
            return QColor(QColorConstants::Transparent);
        }
 
        QColor strokeColor;
        strokeColor = m_dummyPainter.pen().brush().color();
        strokeColor.setAlphaF(m_svgState.strokeOpacity);
 
        return strokeColor;
    }
 
    static QGradient applyOpacityToGradient(const QGradient &gradient, float opacity)
    {
        QGradient grad = gradient;
        QGradientStops stops;
        for (auto &stop : grad.stops()) {
            stop.second.setAlphaF(stop.second.alphaF() * opacity);
            stops.append(stop);
        }
 
        grad.setStops(stops);
 
        return grad;
    }
 
    float currentStrokeWidth() const
    {
        float penWidth = m_dummyPainter.pen().widthF();
        return penWidth ? penWidth : 1;
    }
 
    QPen currentStroke() const
    {
        return m_dummyPainter.pen();
    }
 
protected:
    QPainter m_dummyPainter;
    QImage m_dummyImage;
    QSvgExtraStates m_svgState;
};
 
namespace {
inline bool isPathContainer(const QSvgDocument *doc, const QSvgStructureNode *node)
{
    bool foundPath = false;
    for (const auto &child : node->renderers()) {
        switch (child->type()) {
            // nodes that shouldn't go inside Shape{}
        case QSvgNode::Switch:
        case QSvgNode::Doc:
        case QSvgNode::Group:
        case QSvgNode::AnimateColor:
        case QSvgNode::AnimateTransform:
        case QSvgNode::Use:
        case QSvgNode::Video:
        case QSvgNode::Image:
        case QSvgNode::Textarea:
        case QSvgNode::Text:
        case QSvgNode::Tspan:
        case QSvgNode::Mask:
        case QSvgNode::Marker:
        case QSvgNode::Pattern:
            //qCDebug(lcQuickVectorGraphics) << "NOT path container because" << node->typeName() ;
            return false;
 
            // nodes that could go inside Shape{}
        case QSvgNode::Defs:
        case QSvgNode::Symbol:
            break;
 
            // nodes that are done as pure ShapePath{}
        case QSvgNode::Rect:
        case QSvgNode::Circle:
        case QSvgNode::Ellipse:
        case QSvgNode::Line:
        case QSvgNode::Path:
        case QSvgNode::Polygon:
        case QSvgNode::Polyline:
        {
            if (child->hasFilter())
                return false;
 
            if (child->hasAnyMarker())
                return false;
 
            if (!child->style().isDefaultProperty(QSvgStyleProperty::Opacity))
                return false;
 
            if (!child->style().isDefaultProperty(QSvgStyleProperty::Transform))
                return false;
 
            const auto animations = doc->animator()->animationsForNode(child.get());
            if (!animations.isEmpty()) {
                //qCDebug(lcQuickVectorGraphics) << "NOT path container because local transform animation";
                return false;
            }
            foundPath = true;
            break;
        }
        default:
            qCDebug(lcQuickVectorImage) << "Unhandled type in switch" << child->type();
            break;
        }
    }
    //qCDebug(lcQuickVectorGraphics) << "Container" << node->nodeId() << node->typeName()  << "is" << foundPath;
    return foundPath;
}
 
static QString capStyleName(Qt::PenCapStyle style)
{
    QString styleName;
 
    switch (style) {
    case Qt::SquareCap:
        styleName = QStringLiteral("squarecap");
        break;
    case Qt::FlatCap:
        styleName = QStringLiteral("flatcap");
        break;
    case Qt::RoundCap:
        styleName = QStringLiteral("roundcap");
        break;
    default:
        break;
    }
 
    return styleName;
}
 
static QString joinStyleName(Qt::PenJoinStyle style)
{
    QString styleName;
 
    switch (style) {
    case Qt::MiterJoin:
        styleName = QStringLiteral("miterjoin");
        break;
    case Qt::BevelJoin:
        styleName = QStringLiteral("beveljoin");
        break;
    case Qt::RoundJoin:
        styleName = QStringLiteral("roundjoin");
        break;
    case Qt::SvgMiterJoin:
        styleName = QStringLiteral("svgmiterjoin");
        break;
    default:
        break;
    }
 
    return styleName;
}
 
static QString dashArrayString(QList<qreal> dashArray)
{
    if (dashArray.isEmpty())
        return QString();
 
    QString dashArrayString;
    QTextStream stream(&dashArrayString);
 
    for (int i = 0; i < dashArray.length() - 1; i++) {
        qreal value = dashArray[i];
        stream << value << ", ";
    }
 
    stream << dashArray.last();
 
    return dashArrayString;
}
};
 
static QString scrub(const QString &raw)
{
    QString res(raw.left(80));
 
    if (!res.isEmpty()) {
        constexpr QLatin1StringView legalSymbols("_-.:"); // Only valid SVG id characters
        qsizetype i = 0;
        do {
            if (res.at(i).isLetterOrNumber() || legalSymbols.contains(res.at(i)))
                i++;
            else
                res.remove(i, 1);
        } while (i < res.size());
    }
 
    return res;
}
 
QSvgVisitorImpl::QSvgVisitorImpl(const QQuickVectorImageSource &source,
                                 QQuickGenerator *generator,
                                 bool assumeTrustedSource)
    : m_source(source)
    , m_generator(generator)
    , m_assumeTrustedSource(assumeTrustedSource)
{
}
 
QSvgVisitorImpl::~QSvgVisitorImpl() = default;
 
bool QSvgVisitorImpl::startDefsBlock(const QSvgNode *node)
{
    StructureNodeInfo info;
    fillCommonNodeInfo(node, info);
 
    info.stage = StructureNodeStage::Start;
 
    // Pattern transforms handled through the fill transform, the transform property is ignored, so
    // we overwrite it with identity.
    if (node->type() == QSvgNode::Pattern) {
        info.transform = QQuickAnimatedProperty(QVariant::fromValue(QTransform{}));
        info.isDefaultTransform = true;
    }
 
    if (!m_generator->generateDefsNode(info))
        return false;
 
    return true;
}
 
void QSvgVisitorImpl::endDefsBlock(const QSvgNode *node)
{
    StructureNodeInfo info;
    fillCommonNodeInfo(node, info);
 
    info.stage = StructureNodeStage::End;
 
    m_generator->generateDefsNode(info);
}
 
static inline bool isStructureNode(const QSvgNode *node)
{
    switch (node->type()) {
    case QSvgNode::Switch:
    case QSvgNode::Doc:
    case QSvgNode::Defs:
    case QSvgNode::Group:
    case QSvgNode::Mask:
    case QSvgNode::Symbol:
    case QSvgNode::Filter:
    case QSvgNode::FeMerge:
    case QSvgNode::FeMergenode:
    case QSvgNode::FeColormatrix:
    case QSvgNode::FeGaussianblur:
    case QSvgNode::FeOffset:
    case QSvgNode::FeComposite:
    case QSvgNode::FeFlood:
    case QSvgNode::FeBlend:
    case QSvgNode::Marker:
    case QSvgNode::Pattern:
        return true;
    default:
        return false;
    }
}
 
static void recurseSvgNodes(const QSvgNode *root, const std::function<void(const QSvgNode *)> &fnc)
{
    fnc(root);
 
    if (isStructureNode(root)) {
        const QSvgStructureNode *sn = static_cast<const QSvgStructureNode *>(root);
        for (const auto &child : sn->renderers())
            recurseSvgNodes(child.get(), fnc);
    }
}
 
void QSvgVisitorImpl::pregenerateReferencedNodes(const QSvgNode *doc)
{
    Q_ASSERT(m_doc != nullptr);
    Q_ASSERT(m_generator != nullptr);
 
    // Find any node which is referenced from elsewhere and generate a Component definition
    // for it
    QSet<QString> referencedIds;
    auto findReferencedIds = [&referencedIds](const QSvgNode *node) {
        if (node->hasFilter())
            referencedIds.insert(node->filterId());
        if (node->hasMask())
            referencedIds.insert(node->maskId());
        if (node->hasMarkerStart())
            referencedIds.insert(node->markerStartId());
        if (node->hasMarkerMid())
            referencedIds.insert(node->markerMidId());
        if (node->hasMarkerEnd())
            referencedIds.insert(node->markerEndId());
        if (node->type() == QSvgNode::Pattern)
            referencedIds.insert(node->nodeId());
    };
    recurseSvgNodes(doc, findReferencedIds);
 
    m_pregeneratingReferencedNodes = true;
    for (const QString &referencedId : referencedIds) {
        const QSvgNode *referencedNode = m_doc->namedNode(referencedId);
        if (referencedNode == nullptr)
            continue;
 
        if (!startDefsBlock(referencedNode))
            return;
 
        traverse(referencedNode);
 
        endDefsBlock(referencedNode);
    }
 
    m_pregeneratingReferencedNodes = false;
}
 
bool QSvgVisitorImpl::doTraversal()
{
    if (!m_generator) {
        qCDebug(lcQuickVectorImage) << "No valid QQuickGenerator is set. Genration will stop";
        return false;
    }
 
    QtSvg::Options options;
    if (m_assumeTrustedSource)
        options.setFlag(QtSvg::AssumeTrustedSource);
 
    const auto doc = m_source.isFile()
        ? QSvgDocument::load(m_source.fileName(), options)
        : QSvgDocument::load(m_source.data(), options);
 
    QScopedValueRollback docResetter(m_doc, doc.get());
    if (!doc) {
        qCDebug(lcQuickVectorImage) << "Not a valid Svg source:" << m_source;
        return false;
    }
 
    m_styleResolver = std::make_unique<QSvgStyleResolver>(doc.get());
    QSvgVisitor::traverse(doc.get());
 
    return true;
}
 
void QSvgVisitorImpl::visitNode(const QSvgNode *node)
{
    handleBaseNodeSetup(node);
 
    NodeInfo info;
    fillCommonNodeInfo(node, info);
    fillAnimationInfo(node, info);
 
    m_generator->generateNode(info);
 
    handleBaseNodeEnd(node);
}
 
void QSvgVisitorImpl::visitImageNode(const QSvgImage *node)
{
    // TODO: this requires proper asset management.
    handleBaseNodeSetup(node);
 
    ImageNodeInfo info;
    fillCommonNodeInfo(node, info);
    fillAnimationInfo(node, info);
    info.image = node->image();
    info.rect = node->rect();
    info.externalFileReference = node->filename();
 
    m_generator->generateImageNode(info);
 
    handleBaseNodeEnd(node);
}
 
void QSvgVisitorImpl::visitRectNode(const QSvgRect *node)
{
    QRectF rect = node->rect();
    QPointF rads = node->radius();
    // This is using Qt::RelativeSize semantics: percentage of half rect size
    qreal x1 = rect.left();
    qreal x2 = rect.right();
    qreal y1 = rect.top();
    qreal y2 = rect.bottom();
 
    qreal rx =  rads.x() * rect.width() / 200;
    qreal ry = rads.y() * rect.height() / 200;
    QPainterPath p;
 
    p.moveTo(x1 + rx, y1);
    p.lineTo(x2 - rx, y1);
    // qCDebug(lcQuickVectorGraphics) << "Line1" << x2 - rx << y1;
    p.arcTo(x2 - rx * 2, y1, rx * 2, ry * 2, 90, -90); // ARC to x2, y1 + ry
    // qCDebug(lcQuickVectorGraphics) << "p1" << p;
 
    p.lineTo(x2, y2 - ry);
    p.arcTo(x2 - rx * 2, y2 - ry * 2, rx * 2, ry * 2, 0, -90); // ARC to x2 - rx, y2
 
    p.lineTo(x1 + rx, y2);
    p.arcTo(x1, y2 - ry * 2, rx * 2, ry * 2, 270, -90); // ARC to x1, y2 - ry
 
    p.lineTo(x1, y1 + ry);
    p.arcTo(x1, y1, rx * 2, ry * 2, 180, -90); // ARC to x1 + rx, y1
 
    handlePathNode(node, p);
}
 
void QSvgVisitorImpl::visitEllipseNode(const QSvgEllipse *node)
{
    QRectF rect = node->rect();
 
    QPainterPath p;
    p.addEllipse(rect);
 
    handlePathNode(node, p);
}
 
void QSvgVisitorImpl::visitPathNode(const QSvgPath *node)
{
    handlePathNode(node, node->path());
}
 
void QSvgVisitorImpl::visitLineNode(const QSvgLine *node)
{
    QPainterPath p;
    p.moveTo(node->line().p1());
    p.lineTo(node->line().p2());
    handlePathNode(node, p);
}
 
void QSvgVisitorImpl::visitPolygonNode(const QSvgPolygon *node)
{
    QPainterPath p = QQuickVectorImageGenerator::Utils::polygonToPath(node->polygon(), true);
    handlePathNode(node, p);
}
 
void QSvgVisitorImpl::visitPolylineNode(const QSvgPolyline *node)
{
    QPainterPath p = QQuickVectorImageGenerator::Utils::polygonToPath(node->polygon(), false);
    handlePathNode(node, p);
}
 
QString QSvgVisitorImpl::gradientCssDescription(const QGradient *gradient)
{
    QString cssDescription;
    if (gradient->type() == QGradient::LinearGradient) {
        const QLinearGradient *linearGradient = static_cast<const QLinearGradient *>(gradient);
 
        cssDescription += " -qt-foreground: qlineargradient("_L1;
        cssDescription += "x1:"_L1 + QString::number(linearGradient->start().x()) + u',';
        cssDescription += "y1:"_L1 + QString::number(linearGradient->start().y()) + u',';
        cssDescription += "x2:"_L1 + QString::number(linearGradient->finalStop().x()) + u',';
        cssDescription += "y2:"_L1 + QString::number(linearGradient->finalStop().y()) + u',';
    } else if (gradient->type() == QGradient::RadialGradient) {
        const QRadialGradient *radialGradient = static_cast<const QRadialGradient *>(gradient);
 
        cssDescription += " -qt-foreground: qradialgradient("_L1;
        cssDescription += "cx:"_L1 + QString::number(radialGradient->center().x()) + u',';
        cssDescription += "cy:"_L1 + QString::number(radialGradient->center().y()) + u',';
        cssDescription += "fx:"_L1 + QString::number(radialGradient->focalPoint().x()) + u',';
        cssDescription += "fy:"_L1 + QString::number(radialGradient->focalPoint().y()) + u',';
        cssDescription += "radius:"_L1 + QString::number(radialGradient->radius()) + u',';
    } else {
        const QConicalGradient *conicalGradient = static_cast<const QConicalGradient *>(gradient);
 
        cssDescription += " -qt-foreground: qconicalgradient("_L1;
        cssDescription += "cx:"_L1 + QString::number(conicalGradient->center().x()) + u',';
        cssDescription += "cy:"_L1 + QString::number(conicalGradient->center().y()) + u',';
        cssDescription += "angle:"_L1 + QString::number(conicalGradient->angle()) + u',';
    }
 
    const QStringList coordinateModes = { "logical"_L1, "stretchtodevice"_L1, "objectbounding"_L1, "object"_L1 };
    cssDescription += "coordinatemode:"_L1;
    cssDescription += coordinateModes.at(int(gradient->coordinateMode()));
    cssDescription += u',';
 
    const QStringList spreads = { "pad"_L1, "reflect"_L1, "repeat"_L1 };
    cssDescription += "spread:"_L1;
    cssDescription += spreads.at(int(gradient->spread()));
 
    for (const QGradientStop &stop : gradient->stops()) {
        cssDescription += ",stop:"_L1;
        cssDescription += QString::number(stop.first);
        cssDescription += u' ';
        cssDescription += stop.second.name(QColor::HexArgb);
    }
 
    cssDescription += ");"_L1;
 
    return cssDescription;
}
 
QString QSvgVisitorImpl::colorCssDescription(QColor color)
{
    QString cssDescription;
    cssDescription += QStringLiteral("rgba(");
    cssDescription += QString::number(color.red()) + QStringLiteral(",");
    cssDescription += QString::number(color.green()) + QStringLiteral(",");
    cssDescription += QString::number(color.blue()) + QStringLiteral(",");
    cssDescription += QString::number(color.alphaF()) + QStringLiteral(")");
 
    return cssDescription;
}
 
namespace {
 
    // Simple class for representing the SVG font as a font engine
    // We use the Proxy font engine type, which is currently unused and does not map to
    // any specific font engine
    // (The QSvgFont object must outlive the engine.)
    class QSvgFontEngine : public QFontEngine
    {
    public:
        QSvgFontEngine(const QString &family, const QSvgFont *font, qreal size);
 
        QFontEngine *cloneWithSize(qreal size) const override;
 
        glyph_t glyphIndex(uint ucs4) const override;
        int stringToCMap(const QChar *str,
                         int len,
                         QGlyphLayout *glyphs,
                         int *nglyphs,
                         ShaperFlags flags) const override;
 
        void addGlyphsToPath(glyph_t *glyphs,
                             QFixedPoint *positions,
                             int nGlyphs,
                             QPainterPath *path,
                             QTextItem::RenderFlags flags) override;
 
        glyph_metrics_t boundingBox(glyph_t glyph) override;
 
        void recalcAdvances(QGlyphLayout *, ShaperFlags) const override;
        QFixed ascent() const override;
        QFixed capHeight() const override;
        QFixed descent() const override;
        QFixed leading() const override;
        qreal maxCharWidth() const override;
        qreal minLeftBearing() const override;
        qreal minRightBearing() const override;
 
        QFixed emSquareSize() const override;
 
    private:
        const QSvgFont *m_font;
        QString m_family;
    };
 
    QSvgFontEngine::QSvgFontEngine(const QString &family, const QSvgFont *font, qreal size)
        : QFontEngine(Proxy)
        , m_font(font)
        , m_family(family)
    {
        fontDef.pixelSize = size;
        fontDef.families = QStringList(family);
    }
 
    QFixed QSvgFontEngine::emSquareSize() const
    {
        return QFixed::fromReal(m_font->m_unitsPerEm);
    }
 
    glyph_t QSvgFontEngine::glyphIndex(uint ucs4) const
    {
        const ushort c(ucs4);
        if (ucs4 < USHRT_MAX && m_font->findFirstGlyphFor(QStringView(&c, 1)))
            return glyph_t(ucs4);
 
        return 0;
    }
 
    int QSvgFontEngine::stringToCMap(const QChar *str,
                                     int len,
                                     QGlyphLayout *glyphs,
                                     int *nglyphs,
                                     ShaperFlags flags) const
    {
        Q_ASSERT(glyphs->numGlyphs >= *nglyphs);
        if (*nglyphs < len) {
            *nglyphs = len;
            return -1;
        }
 
        int ucs4Length = 0;
        QStringIterator it(str, str + len);
        while (it.hasNext()) {
            char32_t ucs4 = it.next();
            glyph_t index = glyphIndex(ucs4);
            glyphs->glyphs[ucs4Length++] = index;
        }
 
        *nglyphs = ucs4Length;
        glyphs->numGlyphs = ucs4Length;
 
        if (!(flags & GlyphIndicesOnly))
            recalcAdvances(glyphs, flags);
 
        return *nglyphs;
    }
 
    void QSvgFontEngine::addGlyphsToPath(glyph_t *glyphs,
                                         QFixedPoint *positions,
                                         int nGlyphs,
                                         QPainterPath *path,
                                         QTextItem::RenderFlags flags)
    {
        Q_UNUSED(flags);
        const qreal scale = fontDef.pixelSize / m_font->m_unitsPerEm;
        for (int i = 0; i < nGlyphs; ++i) {
            glyph_t index = glyphs[i];
            if (index > 0) {
                QPointF position = positions[i].toPointF();
                const ushort c(index);
                const QSvgGlyph *foundGlyph = m_font->findFirstGlyphFor(QStringView(&c, 1));
 
                if (!foundGlyph)
                    continue;
 
                QPainterPath glyphPath = foundGlyph->m_path;
 
                QTransform xform;
                xform.translate(position.x(), position.y());
                xform.scale(scale, -scale);
                glyphPath = xform.map(glyphPath);
                path->addPath(glyphPath);
            }
        }
    }
 
    glyph_metrics_t QSvgFontEngine::boundingBox(glyph_t glyph)
    {
        glyph_metrics_t ret;
        ret.x = 0; // left bearing
        ret.y = -ascent();
        const qreal scale = fontDef.pixelSize / m_font->m_unitsPerEm;
        const ushort c(glyph);
        const QSvgGlyph *svgGlyph = m_font->findFirstGlyphFor(QStringView(&c, 1));
        ret.width = QFixed::fromReal(svgGlyph ? svgGlyph->m_horizAdvX * scale : 0.);
        ret.height = ascent() + descent();
        return ret;
    }
 
    QFontEngine *QSvgFontEngine::cloneWithSize(qreal size) const
    {
        QSvgFontEngine *otherEngine = new QSvgFontEngine(m_family, m_font, size);
        return otherEngine;
    }
 
    void QSvgFontEngine::recalcAdvances(QGlyphLayout *glyphLayout, ShaperFlags) const
    {
        const qreal scale = fontDef.pixelSize / m_font->m_unitsPerEm;
        for (int i = 0; i < glyphLayout->numGlyphs; i++) {
            const ushort c(glyphLayout->glyphs[i]);
            const QSvgGlyph *svgGl = m_font->findFirstGlyphFor(QStringView(&c, 1));
            glyphLayout->advances[i] = QFixed::fromReal(svgGl ? svgGl->m_horizAdvX * scale : 0.);
        }
    }
 
    QFixed QSvgFontEngine::ascent() const
    {
        return QFixed::fromReal(fontDef.pixelSize);
    }
 
    QFixed QSvgFontEngine::capHeight() const
    {
        return ascent();
    }
    QFixed QSvgFontEngine::descent() const
    {
        return QFixed{};
    }
 
    QFixed QSvgFontEngine::leading() const
    {
        return QFixed{};
    }
 
    qreal QSvgFontEngine::maxCharWidth() const
    {
        const qreal scale = fontDef.pixelSize / m_font->m_unitsPerEm;
        return m_font->m_horizAdvX * scale;
    }
 
    qreal QSvgFontEngine::minLeftBearing() const
    {
        return 0.0;
    }
 
    qreal QSvgFontEngine::minRightBearing() const
    {
        return 0.0;
    }
}
 
static QVariant calculateInterpolatedValue(const QSvgAbstractAnimatedProperty *property, int index, int)
{
    if (index == 0)
        const_cast<QSvgAbstractAnimatedProperty *>(property)->interpolate(1, 0.0);
    else
        const_cast<QSvgAbstractAnimatedProperty *>(property)->interpolate(index, 1.0);
 
    return property->interpolatedValue();
}
 
void QSvgVisitorImpl::visitTextNode(const QSvgText *node)
{
    handleBaseNodeSetup(node);
    const bool isTextArea = node->type() == QSvgNode::Textarea;
 
    QString text;
    bool needsRichText = false;
    bool preserveWhiteSpace = node->whitespaceMode() == QSvgText::Preserve;
    const QGradient *mainGradient = m_styleResolver->currentFillGradient();
 
 
    auto *fontStyle = static_cast<QSvgFontStyle *>(node->styleProperty(QSvgStyleProperty::Font));
    QSvgFont *svgFont = nullptr;
    QString svgFontFamily;
    if (fontStyle) {
        Q_ASSERT(m_doc);
        svgFontFamily = fontStyle->qfont().family();
        svgFont = m_doc->svgFont(svgFontFamily);
    }
 
    QFontEngine *fontEngine = nullptr;
    if (svgFont != nullptr) {
        fontEngine = new QSvgFontEngine(svgFontFamily, svgFont, m_styleResolver->painter().font().pointSize());
        fontEngine->ref.ref();
    }
 
 
#if QT_CONFIG(texthtmlparser)
    bool needsPathNode = mainGradient != nullptr
                           || svgFont != nullptr
                           || m_styleResolver->currentStrokeGradient() != nullptr;
#endif
    for (const auto *tspan : node->tspans()) {
        if (!tspan) {
            text += QStringLiteral("<br>");
            continue;
        }
 
        // Note: We cannot get the font directly from the style, since this does
        // not apply the weight, since this is relative and depends on current state.
        handleBaseNodeSetup(tspan);
        QFont font = m_styleResolver->painter().font();
 
        QString styleTagContent;
 
        if ((font.resolveMask() & QFont::FamilyResolved)
            || (font.resolveMask() & QFont::FamiliesResolved)) {
            styleTagContent += QStringLiteral("font-family: %1;").arg(font.family());
        }
 
        if (font.resolveMask() & QFont::WeightResolved
            && font.weight() != QFont::Normal
            && font.weight() != QFont::Bold) {
            styleTagContent += QStringLiteral("font-weight: %1;").arg(int(font.weight()));
        }
 
        if (font.resolveMask() & QFont::SizeResolved) {
            // Pixel size stored as point size in SVG parser
            styleTagContent += QStringLiteral("font-size: %1px;").arg(int(font.pointSizeF()));
        }
 
        if (font.resolveMask() & QFont::CapitalizationResolved
            && font.capitalization() == QFont::SmallCaps) {
            styleTagContent += QStringLiteral("font-variant: small-caps;");
        }
 
        if (m_styleResolver->currentFillGradient() != nullptr
            && m_styleResolver->currentFillGradient() != mainGradient) {
            const QGradient grad = m_styleResolver->applyOpacityToGradient(*m_styleResolver->currentFillGradient(), m_styleResolver->currentFillOpacity());
            styleTagContent += gradientCssDescription(&grad) + u';';
#if QT_CONFIG(texthtmlparser)
            needsPathNode = true;
#endif
        }
 
        const QColor currentStrokeColor = m_styleResolver->currentStrokeColor();
        if (currentStrokeColor.alpha() > 0) {
            QString strokeColor = colorCssDescription(currentStrokeColor);
            styleTagContent += QStringLiteral("-qt-stroke-color:%1;").arg(strokeColor);
            styleTagContent += QStringLiteral("-qt-stroke-width:%1px;").arg(m_styleResolver->currentStrokeWidth());
            styleTagContent += QStringLiteral("-qt-stroke-dasharray:%1;").arg(dashArrayString(m_styleResolver->currentStroke().dashPattern()));
            styleTagContent += QStringLiteral("-qt-stroke-dashoffset:%1;").arg(m_styleResolver->currentStroke().dashOffset());
            styleTagContent += QStringLiteral("-qt-stroke-lineCap:%1;").arg(capStyleName(m_styleResolver->currentStroke().capStyle()));
            styleTagContent += QStringLiteral("-qt-stroke-lineJoin:%1;").arg(joinStyleName(m_styleResolver->currentStroke().joinStyle()));
            if (m_styleResolver->currentStroke().joinStyle() == Qt::MiterJoin || m_styleResolver->currentStroke().joinStyle() == Qt::SvgMiterJoin)
                styleTagContent += QStringLiteral("-qt-stroke-miterlimit:%1;").arg(m_styleResolver->currentStroke().miterLimit());
#if QT_CONFIG(texthtmlparser)
            needsPathNode = true;
#endif
        }
 
        if (tspan->whitespaceMode() == QSvgText::Preserve && !preserveWhiteSpace)
            styleTagContent += QStringLiteral("white-space: pre-wrap;");
 
        QString content = tspan->text().toHtmlEscaped();
        content.replace(QLatin1Char('\t'), QLatin1Char(' '));
        content.replace(QLatin1Char('\n'), QLatin1Char(' '));
 
        bool fontTag = false;
        if (!tspan->style().isDefaultProperty(QSvgStyleProperty::Fill)) {
            auto fill = static_cast<QSvgFillStyle *>(tspan->style().property(QSvgStyleProperty::Fill));
            auto &b = fill->qbrush();
            qCDebug(lcQuickVectorImage) << "tspan FILL:" << b;
            if (b.style() != Qt::NoBrush)
            {
                if (qFuzzyCompare(b.color().alphaF() + 1.0, 2.0))
                {
                    QString spanColor = b.color().name();
                    fontTag = !spanColor.isEmpty();
                    if (fontTag)
                        text += QStringLiteral("<font color=\"%1\">").arg(spanColor);
                } else {
                    QString spanColor = colorCssDescription(b.color());
                    styleTagContent += QStringLiteral("color:%1").arg(spanColor);
                }
            }
        }
 
        needsRichText = needsRichText || !styleTagContent.isEmpty();
        if (!styleTagContent.isEmpty())
            text += QStringLiteral("<span style=\"%1\">").arg(styleTagContent.toHtmlEscaped());
 
        if (font.resolveMask() & QFont::WeightResolved && font.bold())
            text += QStringLiteral("<b>");
 
        if (font.resolveMask() & QFont::StyleResolved && font.italic())
            text += QStringLiteral("<i>");
 
        if (font.resolveMask() & QFont::CapitalizationResolved) {
            switch (font.capitalization()) {
            case QFont::AllLowercase:
                content = content.toLower();
                break;
            case QFont::AllUppercase:
                content = content.toUpper();
                break;
            case QFont::Capitalize:
                // ### We need to iterate over the string and do the title case conversion,
                // since this is not part of QString.
                qCWarning(lcQuickVectorImage) << "Title case not implemented for tspan";
                break;
            default:
                break;
            }
        }
        text += content;
        if (fontTag)
            text += QStringLiteral("</font>");
 
        if (font.resolveMask() & QFont::StyleResolved && font.italic())
            text += QStringLiteral("</i>");
 
        if (font.resolveMask() & QFont::WeightResolved && font.bold())
            text += QStringLiteral("</b>");
 
        if (!styleTagContent.isEmpty())
            text += QStringLiteral("</span>");
 
        handleBaseNodeEnd(tspan);
    }
 
    if (preserveWhiteSpace && (needsRichText || m_styleResolver->currentFillGradient() != nullptr))
        text = QStringLiteral("<span style=\"white-space: pre-wrap\">") + text + QStringLiteral("</span>");
 
    QFont font = m_styleResolver->painter().font();
    if (font.pixelSize() <= 0 && font.pointSize() > 0)
        font.setPixelSize(font.pointSize()); // Pixel size stored as point size by SVG parser
 
    font.setHintingPreference(QFont::PreferNoHinting);
 
#if QT_CONFIG(texthtmlparser)
    if (needsPathNode) {
        QTextDocument document;
        document.setHtml(text);
        if (isTextArea && node->size().width() > 0)
            document.setTextWidth(node->size().width());
        document.setDefaultFont(font);
        document.pageCount(); // Force layout
 
        QTextBlock block = document.firstBlock();
        while (block.isValid()) {
            QTextLayout *lout = block.layout();
 
            if (lout != nullptr) {
                QRectF boundingRect = lout->boundingRect();
 
                // If this block has requested the current SVG font, we override it
                // (note that this limits the text to one svg font, but this is also the case
                // in the QPainter at the moment, and needs a more centralized solution in Qt Svg
                // first)
                QFont blockFont = block.charFormat().font();
                if (svgFont != nullptr
                    && blockFont.family() == svgFontFamily) {
                    QRawFont rawFont;
                    QRawFontPrivate *rawFontD = QRawFontPrivate::get(rawFont);
                    rawFontD->setFontEngine(fontEngine->cloneWithSize(blockFont.pixelSize()));
 
                    lout->setRawFont(rawFont);
                }
 
                auto addPathForFormat = [&](QPainterPath p, QTextCharFormat fmt, int pathIndex) {
                    PathNodeInfo info;
                    fillCommonNodeInfo(node, info, QStringLiteral("_path%1").arg(pathIndex));
                    fillPathAnimationInfo(node, info);
                    auto fillStyle = static_cast<QSvgFillStyle *>(node->style().property(QSvgStyleProperty::Fill));
                    if (fillStyle)
                        info.fillRule = fillStyle->fillRule();
 
                    if (fmt.hasProperty(QTextCharFormat::ForegroundBrush)) {
                        info.fillColor.setDefaultValue(fmt.foreground().color());
                        if (fmt.foreground().gradient() != nullptr && fmt.foreground().gradient()->type() != QGradient::NoGradient)
                            info.grad = *fmt.foreground().gradient();
                    } else {
                        info.fillColor.setDefaultValue(m_styleResolver->currentFillColor());
                    }
 
                    info.path.setDefaultValue(QVariant::fromValue(p));
 
                    const QGradient *strokeGradient = m_styleResolver->currentStrokeGradient();
                    QPen pen;
                    if (fmt.hasProperty(QTextCharFormat::TextOutline)) {
                        pen = fmt.textOutline();
                        if (strokeGradient == nullptr) {
                            info.strokeStyle = StrokeStyle::fromPen(pen);
                            info.strokeStyle.color.setDefaultValue(pen.color());
                        }
                    } else {
                        pen = m_styleResolver->currentStroke();
                        if (strokeGradient == nullptr) {
                            info.strokeStyle = StrokeStyle::fromPen(pen);
                            info.strokeStyle.color.setDefaultValue(m_styleResolver->currentStrokeColor());
                        }
                    }
 
                    if (info.grad.type() == QGradient::NoGradient && m_styleResolver->currentFillGradient() != nullptr)
                        info.grad = m_styleResolver->applyOpacityToGradient(*m_styleResolver->currentFillGradient(), m_styleResolver->currentFillOpacity());
 
                    info.fillTransform = m_styleResolver->currentFillTransform();
 
                    m_generator->generatePath(info, boundingRect);
 
                    if (strokeGradient != nullptr) {
                        PathNodeInfo strokeInfo;
                        fillCommonNodeInfo(node, strokeInfo, QStringLiteral("_stroke%1").arg(pathIndex));
                        fillPathAnimationInfo(node, strokeInfo);
 
                        strokeInfo.grad = *strokeGradient;
 
                        QPainterPathStroker stroker(pen);
                        strokeInfo.path.setDefaultValue(QVariant::fromValue(stroker.createStroke(p)));
                        m_generator->generatePath(strokeInfo, boundingRect);
                    }
                };
 
                qreal baselineOffset = -QFontMetricsF(font).ascent();
                if (lout->lineCount() > 0 && lout->lineAt(0).isValid())
                    baselineOffset = -lout->lineAt(0).ascent();
 
                const QPointF baselineTranslation(0.0, baselineOffset);
                auto glyphsToPath = [&](QList<QGlyphRun> glyphRuns, qreal width) {
                    QList<QPainterPath> paths;
                    for (const QGlyphRun &glyphRun : glyphRuns) {
                        QRawFont font = glyphRun.rawFont();
                        QList<quint32> glyphIndexes = glyphRun.glyphIndexes();
                        QList<QPointF> positions = glyphRun.positions();
 
                        for (qsizetype j = 0; j < glyphIndexes.size(); ++j) {
                            quint32 glyphIndex = glyphIndexes.at(j);
                            const QPointF &pos = positions.at(j);
 
                            QPainterPath p = font.pathForGlyph(glyphIndex);
                            p.translate(pos + node->position() + baselineTranslation);
                            if (m_styleResolver->states().textAnchor == Qt::AlignHCenter)
                                p.translate(QPointF(-0.5 * width, 0));
                            else if (m_styleResolver->states().textAnchor == Qt::AlignRight)
                                p.translate(QPointF(-width, 0));
                            paths.append(p);
                        }
                    }
 
                    return paths;
                };
 
                QList<QTextLayout::FormatRange> formats = block.textFormats();
                for (int i = 0; i < formats.size(); ++i) {
                    QTextLayout::FormatRange range = formats.at(i);
 
                    QList<QGlyphRun> glyphRuns = lout->glyphRuns(range.start, range.length);
                    QList<QPainterPath> paths = glyphsToPath(glyphRuns, lout->minimumWidth());
                    for (int j = 0; j < paths.size(); ++j) {
                        const QPainterPath &path = paths.at(j);
                        addPathForFormat(path, range.format, j);
                    }
                }
            }
 
            block = block.next();
        }
    } else
#endif
    {
        TextNodeInfo info;
        fillCommonNodeInfo(node, info);
        fillAnimationInfo(node, info);
 
        {
            QList<AnimationPair> animations = collectAnimations(node, QStringLiteral("fill"));
            if (!animations.isEmpty())
                applyAnimationsToProperty(animations, &info.fillColor, calculateInterpolatedValue);
        }
 
        {
            QList<AnimationPair> animations = collectAnimations(node, QStringLiteral("fill-opacity"));
            if (!animations.isEmpty())
                applyAnimationsToProperty(animations, &info.fillOpacity, calculateInterpolatedValue);
        }
 
        {
            QList<AnimationPair> animations = collectAnimations(node, QStringLiteral("stroke"));
            if (!animations.isEmpty())
                applyAnimationsToProperty(animations, &info.strokeColor, calculateInterpolatedValue);
        }
 
        {
            QList<AnimationPair> animations = collectAnimations(node, QStringLiteral("stroke-opacity"));
            if (!animations.isEmpty())
                applyAnimationsToProperty(animations, &info.strokeOpacity, calculateInterpolatedValue);
        }
 
        info.position = node->position();
        info.size = node->size();
        info.font = font;
        info.text = text;
        info.isTextArea = isTextArea;
        info.needsRichText = needsRichText;
        info.fillColor.setDefaultValue(m_styleResolver->currentFillColor());
        info.alignment = m_styleResolver->states().textAnchor;
        info.strokeColor.setDefaultValue(m_styleResolver->currentStrokeColor());
 
        m_generator->generateTextNode(info);
    }
 
    handleBaseNodeEnd(node);
 
    if (fontEngine != nullptr) {
        fontEngine->ref.deref();
        Q_ASSERT(fontEngine->ref.loadRelaxed() == 0);
        delete fontEngine;
    }
}
 
void QSvgVisitorImpl::visitUseNode(const QSvgUse *node)
{
    QSvgNode *link = node->link();
    if (!link)
        return;
    handleBaseNodeSetup(node);
    UseNodeInfo info;
    fillCommonNodeInfo(node, info);
    fillAnimationInfo(node, info);
    info.stage = StructureNodeStage::Start;
    info.startPos = node->start();
    m_generator->generateUseNode(info);
    QString oldLinkSuffix = m_linkSuffix;
    m_linkSuffix += QStringLiteral("_use") + info.id;
    m_useLevel++;
    QSvgVisitor::traverse(link);
    m_useLevel--;
    m_linkSuffix = oldLinkSuffix;
    info.stage = StructureNodeStage::End;
    m_generator->generateUseNode(info);
    handleBaseNodeEnd(node);
}
 
bool QSvgVisitorImpl::visitSwitchNodeStart(const QSvgSwitch *node)
{
    QSvgNode *link = node->childToRender();
    if (!link)
        return false;
 
    QString oldLinkSuffix = m_linkSuffix;
    m_linkSuffix += QStringLiteral("_switch") + QString::number(quintptr(node), 16);
    QSvgVisitor::traverse(link);
    m_linkSuffix = oldLinkSuffix;
 
    return false;
}
 
void QSvgVisitorImpl::visitSwitchNodeEnd(const QSvgSwitch *node)
{
    Q_UNUSED(node);
}
 
bool QSvgVisitorImpl::visitDefsNodeStart(const QSvgDefs *node)
{
    Q_UNUSED(node);
    return m_pregeneratingReferencedNodes;
}
 
void QSvgVisitorImpl::visitDefsNodeEnd(const QSvgDefs *node)
{
    Q_UNUSED(node);
}
 
bool QSvgVisitorImpl::visitPatternNodeStart(const QSvgPattern *node)
{
    if (m_pregeneratingReferencedNodes) {
        handleBaseNodeSetup(node);
 
        PatternNodeInfo info;
        fillCommonNodeInfo(node, info);
        fillAnimationInfo(node, info);
 
        info.stage = StructureNodeStage::Start;
 
        QSvgRectF r = node->rect();
        info.isPatternRectRelativeCoordinates = r.unitX() == QtSvg::UnitTypes::objectBoundingBox;
        info.patternRect = r;
 
        if (node->contentUnits() == QtSvg::UnitTypes::objectBoundingBox)
            qCWarning(lcQuickVectorImage) << "Only user space content units supported for patterns";
 
        return m_generator->generatePatternNode(info);
    } else {
        return false;
    }
}
 
void QSvgVisitorImpl::visitPatternNodeEnd(const QSvgPattern *node)
{
    Q_ASSERT(m_pregeneratingReferencedNodes);
 
    handleBaseNodeSetup(node);
 
    PatternNodeInfo info;
    fillCommonNodeInfo(node, info);
    fillAnimationInfo(node, info);
 
    QSvgRectF r = node->rect();
    info.isPatternRectRelativeCoordinates = r.unitX() == QtSvg::UnitTypes::objectBoundingBox;
    info.patternRect = r;
 
    info.stage = StructureNodeStage::End;
 
    m_generator->generatePatternNode(info);
}
 
bool QSvgVisitorImpl::visitSymbolNodeStart(const QSvgSymbol *node)
{
    if (m_useLevel == 0)
        return false;
 
    handleBaseNodeSetup(node);
 
    StructureNodeInfo info;
    fillCommonNodeInfo(node, info);
    fillAnimationInfo(node, info);
 
    QTransform oldTransform = info.transform.defaultValue().value<QTransform>();
    info.clipBox = oldTransform.mapRect(node->clipRect());
 
    QTransform xform = node->aspectRatioTransform();
    if (!xform.isIdentity()) {
        info.isDefaultTransform = false;
        xform = xform * oldTransform;
        info.transform.setDefaultValue(QVariant::fromValue(xform));
    }
    info.stage = StructureNodeStage::Start;
 
    return m_generator->generateStructureNode(info);
}
 
void QSvgVisitorImpl::visitSymbolNodeEnd(const QSvgSymbol *node)
{
    handleBaseNodeSetup(node);
 
    StructureNodeInfo info;
    fillCommonNodeInfo(node, info);
    fillAnimationInfo(node, info);
 
    info.clipBox = node->clipRect();
    info.stage = StructureNodeStage::End;
 
    m_generator->generateStructureNode(info);
}
 
bool QSvgVisitorImpl::visitMaskNodeStart(const QSvgMask *node)
{
    if (!m_pregeneratingReferencedNodes)
        return false;
 
    handleBaseNodeSetup(node);
 
    MaskNodeInfo info;
 
    QSvgRectF r = node->rect();
    info.isMaskRectRelativeCoordinates = r.unitX() == QtSvg::UnitTypes::objectBoundingBox;
    info.maskRect = r;
 
    info.isMaskContentRelativeCoordinates =
            node->contentUnits() == QtSvg::UnitTypes::objectBoundingBox;
 
    fillCommonNodeInfo(node, info);
 
    return m_generator->generateMaskNode(info);
}
 
void QSvgVisitorImpl::visitMaskNodeEnd(const QSvgMask *node)
{
    MaskNodeInfo info;
    info.stage = StructureNodeStage::End;
 
    QSvgRectF r = node->rect();
    info.isMaskRectRelativeCoordinates = r.unitX() == QtSvg::UnitTypes::objectBoundingBox;
    info.maskRect = r;
    info.isMaskContentRelativeCoordinates =
            node->contentUnits() == QtSvg::UnitTypes::objectBoundingBox;
    fillCommonNodeInfo(node, info);
 
    m_generator->generateMaskNode(info);
 
    handleBaseNodeEnd(node);
}
 
bool QSvgVisitorImpl::visitFilterNodeStart(const QSvgFilterContainer *node)
{
    Q_UNUSED(node)
 
    if (!m_pregeneratingReferencedNodes)
        return false;
 
    if (!m_filterPrimitives.isEmpty()) {
        qCWarning(lcQuickVectorImage) << "Filter defined inside a filter";
        return false;
    }
 
    return true;
}
 
void QSvgVisitorImpl::visitFilterNodeEnd(const QSvgFilterContainer *node)
{
    if (m_filterPrimitives.isEmpty())
        return;
 
    handleBaseNodeSetup(node);
 
    FilterNodeInfo info;
    fillCommonNodeInfo(node, info);
 
    info.filterRect = node->rect();
    if (node->filterUnits() == QtSvg::UnitTypes::objectBoundingBox)
        info.csFilterRect = FilterNodeInfo::CoordinateSystem::Relative;
 
    bool generatedAlpha = false;
    for (const QSvgFeFilterPrimitive *filterPrimitive : std::as_const(m_filterPrimitives)) {
        if (filterPrimitive->requiresSourceAlpha() && !generatedAlpha) {
            FilterNodeInfo::FilterStep alphaStep;
            alphaStep.filterType = FilterNodeInfo::Type::ColorMatrix;
            alphaStep.csFilterParameter = FilterNodeInfo::CoordinateSystem::MatchFilterRect;
 
            // Isolate alpha
            qreal values[] = { 0.0, 0.0, 0.0, 0.0, 0.0,
                              0.0, 0.0, 0.0, 0.0, 0.0,
                              0.0, 0.0, 0.0, 0.0, 0.0,
                              0.0, 0.0, 0.0, 1.0, 0.0,
                              0.0, 0.0, 0.0, 0.0, 0.0 };
            QGenericMatrix<5, 5, qreal> matrix(values);
            alphaStep.filterParameter = QVariant::fromValue(matrix);
            alphaStep.outputName = info.id + QStringLiteral("_source_alpha");
            generatedAlpha = true;
 
            info.steps.append(alphaStep);
        }
 
        fillFilterPrimitiveInfo(node, filterPrimitive, info);
    }
 
    m_generator->generateFilterNode(info);
    m_filterPrimitives.clear();
}
 
void QSvgVisitorImpl::fillFilterPrimitiveInfo(const QSvgFilterContainer *node,
                                              const QSvgFeFilterPrimitive *filterPrimitive,
                                              FilterNodeInfo &info)
{
    FilterNodeInfo::FilterStep step;
    step.filterPrimitiveRect = filterPrimitive->rect();
 
    step.outputName = info.id + QStringLiteral("_")
        + (filterPrimitive->result().isEmpty()
        ? QStringLiteral("output_") + QString::number(info.steps.size())
        : filterPrimitive->result());
 
    auto findInput = [&info, &filterPrimitive](const QString &input, QString *outName) {
        const QString alphaSource = info.id + QStringLiteral("_source_alpha");
        if (input == QStringLiteral("SourceGraphic")) {
            return FilterNodeInfo::FilterInput::SourceColor;
        } else if (input == QStringLiteral("SourceAlpha")) {
            *outName = alphaSource;
            return FilterNodeInfo::FilterInput::SourceAlpha;
        } else if (info.steps.isEmpty()) {
            return FilterNodeInfo::FilterInput::SourceColor;
        }
 
        if (!input.isEmpty()) {
            *outName = info.id + QStringLiteral("_") + input;
        } else {
            bool insideMergeNode = filterPrimitive->type() == QSvgNode::FeMergenode;
            for (int i = info.steps.size() - 1; i >= 0; --i) {
                const auto &prevStep = info.steps.at(i);
                if (insideMergeNode && prevStep.filterType == FilterNodeInfo::Type::Merge) {
                    insideMergeNode = false;
                    continue;
                }
 
                if (!prevStep.outputName.isEmpty() && prevStep.outputName != alphaSource) {
                    *outName = prevStep.outputName;
                    break;
                }
            }
        }
 
        return FilterNodeInfo::FilterInput::Name;
    };
 
    step.input1 = findInput(filterPrimitive->input(), &step.namedInput1);
 
    if (node->primitiveUnits() == QtSvg::UnitTypes::objectBoundingBox)
        step.csFilterParameter = FilterNodeInfo::CoordinateSystem::Relative;
 
    // We special-case the default filter primitive rect as is done in Qt Svg.
    // The default is to match the filter's rect and this is represented by making
    // the types of the filter primitive's rect QtSvg::UnitTypes::unknown. Since
    // this is not generally handled in Qt Svg, we also just special case it here.
    if (node->primitiveUnits() == QtSvg::UnitTypes::userSpaceOnUse
        && filterPrimitive->rect().unitW() == QtSvg::UnitTypes::unknown) {
        step.csFilterParameter = FilterNodeInfo::CoordinateSystem::MatchFilterRect;
    }
 
    switch (filterPrimitive->type()) {
    case QSvgNode::FeMerge:
        step.filterType = FilterNodeInfo::Type::Merge;
        break;
    case QSvgNode::FeMergenode:
        step.filterType = FilterNodeInfo::Type::MergeNode;
        break;
    case QSvgNode::FeBlend:
    {
        const QSvgFeBlend *blend = static_cast<const QSvgFeBlend *>(filterPrimitive);
        switch (blend->mode()) {
        case QSvgFeBlend::Mode::Normal:
            step.filterType = FilterNodeInfo::Type::BlendNormal;
            break;
        case QSvgFeBlend::Mode::Multiply:
            step.filterType = FilterNodeInfo::Type::BlendMultiply;
            break;
        case QSvgFeBlend::Mode::Screen:
            step.filterType = FilterNodeInfo::Type::BlendScreen;
            break;
        case QSvgFeBlend::Mode::Darken:
            step.filterType = FilterNodeInfo::Type::BlendDarken;
            break;
        case QSvgFeBlend::Mode::Lighten:
            step.filterType = FilterNodeInfo::Type::BlendLighten;
            break;
        }
 
        step.input2 = findInput(blend->input2(), &step.namedInput2);
        break;
    }
    case QSvgNode::FeComposite:
    {
        const QSvgFeComposite *composite =  static_cast<const QSvgFeComposite *>(filterPrimitive);
        switch (composite->compositionOperator()) {
        case QSvgFeComposite::Operator::Over:
            step.filterType = FilterNodeInfo::Type::CompositeOver;
            break;
        case QSvgFeComposite::Operator::In:
            step.filterType = FilterNodeInfo::Type::CompositeIn;
            break;
        case QSvgFeComposite::Operator::Out:
            step.filterType = FilterNodeInfo::Type::CompositeOut;
            break;
        case QSvgFeComposite::Operator::Atop:
            step.filterType = FilterNodeInfo::Type::CompositeAtop;
            break;
        case QSvgFeComposite::Operator::Xor:
            step.filterType = FilterNodeInfo::Type::CompositeXor;
            break;
        case QSvgFeComposite::Operator::Lighter:
            step.filterType = FilterNodeInfo::Type::CompositeLighter;
            break;
        case QSvgFeComposite::Operator::Arithmetic:
            step.filterType = FilterNodeInfo::Type::CompositeArithmetic;
            break;
        };
 
        step.input2 = findInput(composite->input2(), &step.namedInput2);
        step.filterParameter = composite->k();
        break;
    }
    case QSvgNode::FeOffset:
    {
        const QSvgFeOffset *offset = static_cast<const QSvgFeOffset *>(filterPrimitive);
        step.filterType = FilterNodeInfo::Type::Offset;
        step.filterParameter = QVariant::fromValue(QVector2D(offset->dx(), offset->dy()));
        break;
 
    }
    case QSvgNode::FeColormatrix:
    {
        const QSvgFeColorMatrix *colorMatrix =
            static_cast<const QSvgFeColorMatrix *>(filterPrimitive);
        step.filterType = FilterNodeInfo::Type::ColorMatrix;
        step.filterParameter = QVariant::fromValue(colorMatrix->matrix());
        break;
    }
 
    case QSvgNode::FeGaussianblur:
    {
        const QSvgFeGaussianBlur *gaussianBlur =
            static_cast<const QSvgFeGaussianBlur *>(filterPrimitive);
 
        if (gaussianBlur->edgeMode() == QSvgFeGaussianBlur::EdgeMode::Wrap)
            info.wrapMode = QSGTexture::Repeat;
        step.filterType = FilterNodeInfo::Type::GaussianBlur;
        if (!qFuzzyCompare(gaussianBlur->stdDeviationX(), gaussianBlur->stdDeviationY()))
            qCWarning(lcQuickVectorImage) << "Separate X and Y deviations not supported for gaussian blur";
        step.filterParameter = std::max(gaussianBlur->stdDeviationX(),
                                        gaussianBlur->stdDeviationY());
        break;
    }
 
    case QSvgNode::FeFlood:
    {
        const QSvgFeFlood *flood =
            static_cast<const QSvgFeFlood *>(filterPrimitive);
 
        step.filterType = FilterNodeInfo::Type::Flood;
        step.filterParameter = flood->color();
        break;
    }
    default:
        // Create a dummy filter node to make sure bindings still work for unsupported filters
        step.filterType = FilterNodeInfo::Type::None;
        break;
    }
 
    info.steps.append(step);
}
 
bool QSvgVisitorImpl::visitFeFilterPrimitiveNodeStart(const QSvgFeFilterPrimitive *node)
{
    m_filterPrimitives.append(node);
    return true;
}
 
void QSvgVisitorImpl::visitFeFilterPrimitiveNodeEnd(const QSvgFeFilterPrimitive *node)
{
    Q_UNUSED(node);
}
 
bool QSvgVisitorImpl::visitStructureNodeStart(const QSvgStructureNode *node)
{
    Q_ASSERT(m_doc);
    constexpr bool forceSeparatePaths = false;
    handleBaseNodeSetup(node);
 
    StructureNodeInfo info;
 
    fillCommonNodeInfo(node, info);
    fillAnimationInfo(node, info);
    info.forceSeparatePaths = forceSeparatePaths;
    info.isPathContainer = isPathContainer(m_doc, node);
    if (!info.isDefaultOpacity || info.opacity.isAnimated())
        info.opacityGroupBounds = node->bounds(m_doc);
    info.stage = StructureNodeStage::Start;
 
    return m_generator->generateStructureNode(info);
}
 
void QSvgVisitorImpl::visitStructureNodeEnd(const QSvgStructureNode *node)
{
    Q_ASSERT(m_doc);
    handleBaseNodeEnd(node);
    //    qCDebug(lcQuickVectorGraphics) << "REVERT" << node->nodeId() << node->type() << (m_styleResolver->painter().pen().style() != Qt::NoPen) << m_styleResolver->painter().pen().color().name()
    //             << (m_styleResolver->painter().pen().brush().style() != Qt::NoBrush) << m_styleResolver->painter().pen().brush().color().name();
 
    StructureNodeInfo info;
    fillCommonNodeInfo(node, info);
    info.isPathContainer = isPathContainer(m_doc, node);
    info.stage = StructureNodeStage::End;
 
    m_generator->generateStructureNode(info);
}
 
QString QSvgVisitorImpl::nextNodeId() const
{
    return QStringLiteral("_qt_node%1").arg(m_nodeIdCounter++);
}
 
bool QSvgVisitorImpl::visitDocumentNodeStart(const QSvgDocument *node)
{
    handleBaseNodeSetup(node);
 
    StructureNodeInfo info;
    fillCommonNodeInfo(node, info);
    fillAnimationInfo(node, info);
 
    const QSvgDocument *doc = static_cast<const QSvgDocument *>(node);
    info.size = doc->size();
    info.viewBox = doc->viewBox();
    info.isPathContainer = isPathContainer(doc, node);
    info.forceSeparatePaths = false;
    info.stage = StructureNodeStage::Start;
 
    if (m_generator->generateRootNode(info)) {
        pregenerateReferencedNodes(node);
        return true;
    } else {
        return false;
    }
}
 
void QSvgVisitorImpl::visitDocumentNodeEnd(const QSvgDocument *node)
{
    handleBaseNodeEnd(node);
    qCDebug(lcQuickVectorImage) << "REVERT" << node->nodeId() << node->type() << (m_styleResolver->painter().pen().style() != Qt::NoPen)
                                   << m_styleResolver->painter().pen().color().name() << (m_styleResolver->painter().pen().brush().style() != Qt::NoBrush)
                                   << m_styleResolver->painter().pen().brush().color().name();
 
    StructureNodeInfo info;
    fillCommonNodeInfo(node, info);
    info.stage = StructureNodeStage::End;
 
    m_generator->generateRootNode(info);
}
 
QString QSvgVisitorImpl::findOrCreateId(const QString &id)
{
    QString ret = m_idForNodeId.value(id);
    if (ret.isEmpty()) {
        ret = nextNodeId();
        m_idForNodeId.insert(id, ret);
    }
    return ret;
}
 
QString QSvgVisitorImpl::findOrCreateId(const QSvgNode *node, const QString &nodeId)
{
    QString key = nodeId;
    const QSvgNode *n = m_nodesForKeys.value(key);
    if (key.isEmpty() || (n != nullptr && n != node))
        key = QString::number(quintptr(node), 16);
 
    m_nodesForKeys.insert(key, node);
    return findOrCreateId(key);
}
 
void QSvgVisitorImpl::fillCommonNodeInfo(const QSvgNode *node, NodeInfo &info, const QString &idSuffix)
{
    const QString nodeId = scrub(node->nodeId());
    info.id = findOrCreateId(node, nodeId);
 
    // Internal disambiguation when multiple items come from the same node
    info.id += idSuffix;
 
    if (!m_linkSuffix.isEmpty())
        info.id += m_linkSuffix;
 
    info.nodeId = nodeId;
    info.typeName = node->typeName();
    info.isDefaultTransform = node->style().isDefaultProperty(QSvgStyleProperty::Transform);
 
    auto transform = static_cast<QSvgTransformStyle *>(node->style().property(QSvgStyleProperty::Transform));
    QTransform xf = !info.isDefaultTransform ? transform->qtransform() : QTransform();
    info.transform.setDefaultValue(QVariant::fromValue(xf));
 
    auto opacity = static_cast<QSvgOpacityStyle *>(node->style().property(QSvgStyleProperty::Opacity));
    info.isDefaultOpacity = node->style().isDefaultProperty(QSvgStyleProperty::Opacity);
    info.opacity.setDefaultValue(!info.isDefaultOpacity ? opacity->opacity() : 1.0);
    info.isVisible = node->isVisible();
    info.isDisplayed = node->displayMode() != QSvgNode::DisplayMode::NoneMode;
 
    if (node->hasFilter()
        || node->hasMask()
        || node->type() == QSvgNode::Type::Mask
        || node->type() == QSvgNode::Type::Pattern) {
        QImage dummy(1, 1, QImage::Format_RGB32);
        QPainter p(&dummy);
        p.setPen(QPen(Qt::NoPen));
        QRectF b;
        if (m_doc) {
            QSvgExtraStates states(m_doc);
            b = node->internalBounds(&p, states);
        }
        info.bounds = b;
    }
 
    if (node->hasMask())
        info.maskId = findOrCreateId(node->maskId());
 
    if (node->hasFilter())
        info.filterId = findOrCreateId(node->filterId());
}
 
QList<QSvgVisitorImpl::AnimationPair> QSvgVisitorImpl::collectAnimations(const QSvgNode *node,
                                                                         const QString &propertyName)
{
    Q_ASSERT(m_doc);
    QList<AnimationPair> ret;
    const QList<QSvgAbstractAnimation *> animations = m_doc->animator()->animationsForNode(node);
    for (const QSvgAbstractAnimation *animation : animations) {
        const QList<QSvgAbstractAnimatedProperty *> properties = animation->properties();
        for (const QSvgAbstractAnimatedProperty *property : properties) {
            if (property->propertyName() == propertyName)
                ret.append(std::make_pair(animation, property));
        }
    }
 
    return ret;
}
 
void QSvgVisitorImpl::applyAnimationsToProperty(const QList<AnimationPair> &animations,
                                                QQuickAnimatedProperty *outProperty,
                                                std::function<QVariant(const QSvgAbstractAnimatedProperty *, int index, int animationIndex)> calculateValue)
{
    qCDebug(lcVectorImageAnimations) << "Applying animations to property with default value"
                                     << outProperty->defaultValue();
    for (auto it = animations.constBegin(); it != animations.constEnd(); ++it) {
        qCDebug(lcVectorImageAnimations) << "    -> Add animation";
        const QSvgAbstractAnimation *animation = it->first;
        const QSvgAbstractAnimatedProperty *property = it->second;
 
        const int start = animation->start();
        const int repeatCount = animation->iterationCount();
        const int duration = animation->duration();
 
        bool freeze = false;
        bool replace = true;
        if (animation->animationType() == QSvgAbstractAnimation::SMIL) {
            const QSvgAnimateNode *animateNode = static_cast<const QSvgAnimateNode *>(animation);
            freeze = animateNode->fill() == QSvgAnimateNode::Freeze;
            replace = animateNode->additiveType() == QSvgAnimateNode::Replace;
        }
 
        qCDebug(lcVectorImageAnimations) << "        -> Start:" << start
                                         << ", repeatCount:" << repeatCount
                                         << ", freeze:" << freeze
                                         << ", replace:" << replace;
 
        QList<qreal> propertyKeyFrames = property->keyFrames();
        QList<QQuickAnimatedProperty::PropertyAnimation> outAnimations;
 
        // For transform animations, we register the type of the transform in the animation
        // (this assumes that each animation is only for a single part of the transform)
        if (property->type() == QSvgAbstractAnimatedProperty::Transform) {
            const auto *transformProperty = static_cast<const QSvgAnimatedPropertyTransform *>(property);
            const auto &components = transformProperty->components();
            Q_ASSERT(q20::cmp_greater_equal(components.size(),transformProperty->transformCount()));
            for (uint i = 0; i < transformProperty->transformCount(); ++i) {
                QQuickAnimatedProperty::PropertyAnimation outAnimation;
                outAnimation.repeatCount = repeatCount;
                outAnimation.startOffset = start;
                if (freeze)
                    outAnimation.flags |= QQuickAnimatedProperty::PropertyAnimation::FreezeAtEnd;
                if (replace)
                    outAnimation.flags |= QQuickAnimatedProperty::PropertyAnimation::ReplacePreviousAnimations;
                switch (components.at(i).type) {
                case QSvgAnimatedPropertyTransform::TransformComponent::Translate:
                    outAnimation.subtype = QTransform::TxTranslate;
                    break;
                case QSvgAnimatedPropertyTransform::TransformComponent::Scale:
                    outAnimation.subtype = QTransform::TxScale;
                    break;
                case QSvgAnimatedPropertyTransform::TransformComponent::Rotate:
                    outAnimation.subtype = QTransform::TxRotate;
                    break;
                case QSvgAnimatedPropertyTransform::TransformComponent::Skew:
                    outAnimation.subtype = QTransform::TxShear;
                    break;
                default:
                    qCWarning(lcQuickVectorImage()) << "Unhandled transform type:" << components.at(i).type;
                    break;
                }
 
                qDebug(lcVectorImageAnimations) << "        -> Property type:"
                                                << property->type()
                                                << " name:"
                                                << property->propertyName()
                                                << " animation subtype:"
                                                << outAnimation.subtype;
 
                outAnimations.append(outAnimation);
            }
        } else {
            QQuickAnimatedProperty::PropertyAnimation outAnimation;
            outAnimation.repeatCount = repeatCount;
            outAnimation.startOffset = start;
            if (freeze)
                outAnimation.flags |= QQuickAnimatedProperty::PropertyAnimation::FreezeAtEnd;
 
            qDebug(lcVectorImageAnimations) << "        -> Property type:"
                                            << property->type()
                                            << " name:"
                                            << property->propertyName();
 
            outAnimations.append(outAnimation);
        }
 
        outProperty->beginAnimationGroup();
        const auto animationEasing = easingForAnimation(animation->easing(), animation->animationType());
        for (int i = 0; i < outAnimations.size(); ++i) {
            QQuickAnimatedProperty::PropertyAnimation outAnimation = outAnimations.at(i);
 
            for (int j = 0; j < propertyKeyFrames.size(); ++j) {
                const int time = qRound(propertyKeyFrames.at(j) * duration);
 
                const QVariant value = calculateValue(property, j, i);
                outAnimation.frames[time] = value;
 
                const QSvgEasingInterface *easingInterface = j > 0 ? property->easingAt(j - 1) : nullptr;
                outAnimation.easingPerFrame[time] = easingInterface != nullptr
                    ? easingForAnimation(easingInterface, animation->animationType())
                    : animationEasing;
 
                qCDebug(lcVectorImageAnimations) << "        -> Frame " << time << " is " << value;
            }
 
            outProperty->addAnimation(outAnimation);
        }
    }
}
 
QBezier QSvgVisitorImpl::easingForAnimation(const QSvgEasingInterface *easingInterface,
                                            QSvgAbstractAnimation::AnimationType type)
{
    constexpr QPointF startControlPoint(0, 0);
    constexpr QPointF endControlPoint(1, 1);
    constexpr QPointF easeC1(0.25, 0.1);
    constexpr QPointF easeC2(0.25, 1);
 
    QBezier easing = QBezier::fromPoints(startControlPoint, startControlPoint, endControlPoint, endControlPoint);
 
#if QT_CONFIG(cssparser)
    if (type == QSvgAbstractAnimation::CSS) {
        const QSvgCssEasing *cssEasing = static_cast<const QSvgCssEasing *>(easingInterface);
        switch (cssEasing->easingFunction()) {
        case QSvgCssValues::EasingFunction::Ease:
        case QSvgCssValues::EasingFunction::EaseIn:
        case QSvgCssValues::EasingFunction::EaseOut:
        case QSvgCssValues::EasingFunction::EaseInOut:
        case QSvgCssValues::EasingFunction::CubicBezier:
        case QSvgCssValues::EasingFunction::Linear:
        {
            const QSvgCssCubicBezierEasing *cssCubicEasing = static_cast<const QSvgCssCubicBezierEasing *>(cssEasing);
            QPointF c1 = cssCubicEasing->c1();
            QPointF c2 = cssCubicEasing->c2();
            easing = QBezier::fromPoints(startControlPoint, c1, c2, endControlPoint);
            break;
        }
        case QSvgCssValues::EasingFunction::Steps:
        {
            qCDebug(lcVectorImageAnimations) << "Step easing is not supported reverting to default.";
            easing = QBezier::fromPoints(startControlPoint, easeC1, easeC2, endControlPoint);
            break;
        }
        }
    }
#endif
 
    return easing;
}
 
void QSvgVisitorImpl::fillColorAnimationInfo(const QSvgNode *node, PathNodeInfo &info)
{
    // Collect all animations affecting fill
    {
        QList<AnimationPair> animations = collectAnimations(node, QStringLiteral("fill"));
        if (!animations.isEmpty())
            applyAnimationsToProperty(animations, &info.fillColor, calculateInterpolatedValue);
    }
 
    {
        QList<AnimationPair> animations = collectAnimations(node, QStringLiteral("fill-opacity"));
        if (!animations.isEmpty())
            applyAnimationsToProperty(animations, &info.fillOpacity, calculateInterpolatedValue);
    }
 
    {
        QList<AnimationPair> animations = collectAnimations(node, QStringLiteral("stroke"));
        if (!animations.isEmpty())
            applyAnimationsToProperty(animations, &info.strokeStyle.color, calculateInterpolatedValue);
    }
 
    {
        QList<AnimationPair> animations = collectAnimations(node, QStringLiteral("stroke-opacity"));
        if (!animations.isEmpty())
            applyAnimationsToProperty(animations, &info.strokeStyle.opacity, calculateInterpolatedValue);
    }
}
 
void QSvgVisitorImpl::fillTransformAnimationInfo(const QSvgNode *node, NodeInfo &info)
{
    qCDebug(lcVectorImageAnimations) << "Applying transform animations to property with default value"
                                     << info.transform.defaultValue();
 
    auto calculateValue = [](const QSvgAbstractAnimatedProperty *property, int index, int animationIndex) {
        if (property->type() != QSvgAbstractAnimatedProperty::Transform)
            return QVariant{};
 
        const auto *transformProperty = static_cast<const QSvgAnimatedPropertyTransform *>(property);
        const auto &components = transformProperty->components();
 
        const int componentIndex = index * transformProperty->transformCount() + animationIndex;
 
        QVariantList parameters;
 
        const QSvgAnimatedPropertyTransform::TransformComponent &component = components.at(componentIndex);
        switch (component.type) {
        case QSvgAnimatedPropertyTransform::TransformComponent::Translate:
            parameters.append(QVariant::fromValue(QPointF(component.values.value(0),
                                                          component.values.value(1))));
            break;
        case QSvgAnimatedPropertyTransform::TransformComponent::Rotate:
            parameters.append(QVariant::fromValue(QPointF(component.values.value(1),
                                                          component.values.value(2))));
            parameters.append(QVariant::fromValue(component.values.value(0)));
            break;
        case QSvgAnimatedPropertyTransform::TransformComponent::Scale:
            parameters.append(QVariant::fromValue(QPointF(component.values.value(0),
                                                          component.values.value(1))));
            break;
        case QSvgAnimatedPropertyTransform::TransformComponent::Skew:
            parameters.append(QVariant::fromValue(QPointF(component.values.value(0),
                                                          component.values.value(1))));
            break;
        default:
            qCWarning(lcVectorImageAnimations) << "Unhandled transform type:" << component.type;
        };
 
        return QVariant::fromValue(parameters);
    };
 
 
    {
        QList<AnimationPair> animations = collectAnimations(node, QStringLiteral("transform"));
        if (!animations.isEmpty())
            applyAnimationsToProperty(animations, &info.transform, calculateValue);
    }
}
 
void QSvgVisitorImpl::fillMotionPathAnimationInfo(const QSvgNode *node, NodeInfo &info)
{
    QList<AnimationPair> animations = collectAnimations(node, QStringLiteral("offset-distance"));
    auto offset = static_cast<QSvgOffsetStyle *>(node->style().property(QSvgStyleProperty::Offset));
 
    if (animations.isEmpty())
        return;
 
    if (!offset) {
        qCWarning(lcQuickVectorImage) << "Motion path animation: No offset path";
        return;
    }
 
    if (animations.size() > 1) {
        qCWarning(lcQuickVectorImage)
            << "Not supported: More than one offset path animation on same node";
    }
 
    const AnimationPair &animationPair = animations.first();
 
    const QSvgAbstractAnimation *animation = animationPair.first;
    const QSvgAbstractAnimatedProperty *property = animationPair.second;
 
    const int start = animation->start();
    const int repeatCount = animation->iterationCount();
    const int duration = animation->duration();
 
    qCDebug(lcVectorImageAnimations) << "Motion path animation:"
                                     << "start == " << start
                                     << ", repeatCount == " << repeatCount
                                     << "; duration == " << duration;
 
 
    QQuickAnimatedProperty::PropertyAnimation outAnimation;
    outAnimation.repeatCount = repeatCount;
    outAnimation.startOffset = start;
 
    QPainterPath originalPath = offset->path();
 
    qreal baseRotation;
    bool adaptAngle;
    switch (offset->rotateType()) {
    case QtSvg::OffsetRotateType::Auto:
        adaptAngle = true;
        baseRotation = 0.0;
        break;
    case QtSvg::OffsetRotateType::Angle:
        adaptAngle = false;
        baseRotation = offset->rotateAngle();
        break;
    case QtSvg::OffsetRotateType::AutoAngle:
        adaptAngle = true;
        baseRotation = offset->rotateAngle();
        break;
    case QtSvg::OffsetRotateType::Reverse:
        adaptAngle = true;
        baseRotation = 180.0;
        break;
    case QtSvg::OffsetRotateType::ReverseAngle:
        adaptAngle = true;
        baseRotation = offset->rotateAngle() + 180.0f;
        break;
    default:
        Q_UNREACHABLE();
    }
 
    // Default value holds additional parameters
    QVariantList params({ QVariant::fromValue(originalPath), adaptAngle, baseRotation });
    info.motionPath.setDefaultValue(params);
 
    const QList<qreal> propertyKeyFrames = property->keyFrames();
    outAnimation.frames[0] = qreal(0);
    const auto animationEasing = easingForAnimation(animation->easing(), animation->animationType());
    for (int j = 0; j < propertyKeyFrames.size(); ++j) {
        const int time = qRound(propertyKeyFrames.at(j) * duration);
        if (time >= 0) {
            qreal t = calculateInterpolatedValue(property, j, 0).toReal();
            outAnimation.frames[time] = t;
 
            const QSvgEasingInterface *easingInterface = j > 0 ? property->easingAt(j - 1) : nullptr;
            outAnimation.easingPerFrame[time] = easingInterface != nullptr
                ? easingForAnimation(easingInterface, animation->animationType())
                : animationEasing;
 
            qCDebug(lcVectorImageAnimations) << "        -> Frame " << time << " is " << t;
        }
    }
 
    info.motionPath.addAnimation(outAnimation);
}
 
void QSvgVisitorImpl::fillPathAnimationInfo(const QSvgNode *node, PathNodeInfo &info)
{
    fillColorAnimationInfo(node, info);
    fillAnimationInfo(node, info);
}
 
void QSvgVisitorImpl::fillAnimationInfo(const QSvgNode *node, NodeInfo &info)
{
    {
        QList<AnimationPair> animations = collectAnimations(node, QStringLiteral("opacity"));
        if (!animations.isEmpty())
            applyAnimationsToProperty(animations, &info.opacity, calculateInterpolatedValue);
    }
 
    fillTransformAnimationInfo(node, info);
    fillMotionPathAnimationInfo(node, info);
}
 
void QSvgVisitorImpl::handleBaseNodeSetup(const QSvgNode *node)
{
    qCDebug(lcQuickVectorImage) << "Before SETUP" << node << "fill" << m_styleResolver->currentFillColor()
                                   << "stroke" << m_styleResolver->currentStrokeColor() << m_styleResolver->currentStrokeWidth()
                                   << node->nodeId() << " type: " << node->typeName()  << " " << node->type();
 
    node->applyStyle(&m_styleResolver->painter(), m_styleResolver->states());
 
    qCDebug(lcQuickVectorImage) << "After SETUP" << node << "fill" << m_styleResolver->currentFillColor()
                                   << "stroke" << m_styleResolver->currentStrokeColor()
                                   << m_styleResolver->currentStrokeWidth() << node->nodeId();
}
 
void QSvgVisitorImpl::handleBaseNode(const QSvgNode *node)
{
    NodeInfo info;
    fillCommonNodeInfo(node, info);
 
    m_generator->generateNodeBase(info);
}
 
void QSvgVisitorImpl::handleBaseNodeEnd(const QSvgNode *node)
{
    node->revertStyle(&m_styleResolver->painter(), m_styleResolver->states());
 
    qCDebug(lcQuickVectorImage) << "After END" << node << "fill" << m_styleResolver->currentFillColor()
                                   << "stroke" << m_styleResolver->currentStrokeColor() << m_styleResolver->currentStrokeWidth()
                                   << node->nodeId();
}
 
void QSvgVisitorImpl::handlePathNode(const QSvgNode *node, const QPainterPath &path)
{
    handleBaseNodeSetup(node);
 
    PathNodeInfo info;
    fillCommonNodeInfo(node, info);
 
    if (node->hasMarkerStart())
        info.markerStartId = findOrCreateId(node->markerStartId());
 
    if (node->hasMarkerMid())
        info.markerMidId = findOrCreateId(node->markerMidId());
 
    if (node->hasMarkerEnd())
        info.markerEndId = findOrCreateId(node->markerEndId());
 
    const QGradient *strokeGradient = m_styleResolver->currentStrokeGradient();
    auto strokeStyle = static_cast<QSvgStrokeStyle *>(node->style().property(QSvgStyleProperty::Stroke));
    bool hasStrokePattern = strokeStyle
                            && strokeStyle->paintServer()
                            && strokeStyle->paintServer()->type() == QSvgPaintServer::Type::Pattern;
 
    info.path.setDefaultValue(QVariant::fromValue(path));
    info.fillColor.setDefaultValue(m_styleResolver->currentFillColor());
    if (strokeGradient != nullptr)
        info.strokeGrad = *strokeGradient;
 
    if (!hasStrokePattern) {
        info.strokeStyle = StrokeStyle::fromPen(m_styleResolver->currentStroke());
        info.strokeStyle.color.setDefaultValue(m_styleResolver->currentStrokeColor());
    }
    if (m_styleResolver->currentFillGradient() != nullptr)
        info.grad = m_styleResolver->applyOpacityToGradient(*m_styleResolver->currentFillGradient(), m_styleResolver->currentFillOpacity());
    info.fillTransform = m_styleResolver->currentFillTransform();
 
    auto fillStyle = static_cast<QSvgFillStyle *>(node->style().property(QSvgStyleProperty::Fill));
    if (fillStyle) {
        info.fillRule = fillStyle->fillRule();
 
        if (fillStyle->paintServer()
            && fillStyle->paintServer()->type() == QSvgPaintServer::Type::Pattern) {
            QSvgPatternPaint *paintServer = static_cast<QSvgPatternPaint *>(fillStyle->paintServer());
            info.patternId = findOrCreateId(paintServer->patternNode()->nodeId());
 
            // The fill transform in the style resolver is a calculated transform which contains
            // the inverse of the QPainter's world transform at the given time to negate any other
            // transform set. We avoid this by generating the pattern definition in isolation and
            // ignore its transform, so we just use the raw pattern transform from the input here.
            info.fillTransform = paintServer->patternNode()->transform();
        }
    }
 
    fillPathAnimationInfo(node, info);
 
    m_generator->generatePath(info);
 
    if (hasStrokePattern) {
        PathNodeInfo strokeInfo;
        fillCommonNodeInfo(node, strokeInfo, QStringLiteral("_stroke"));
 
        QSvgPatternPaint *paintServer = static_cast<QSvgPatternPaint *>(strokeStyle->paintServer());
        strokeInfo.patternId = findOrCreateId(paintServer->patternNode()->nodeId());
        strokeInfo.fillTransform = paintServer->patternNode()->transform();
 
        QPainterPathStroker stroker(m_styleResolver->currentStroke());
        strokeInfo.path.setDefaultValue(QVariant::fromValue(stroker.createStroke(path)));
        m_generator->generatePath(strokeInfo);
    }
 
    handleBaseNodeEnd(node);
}
 
void QSvgVisitorImpl::fillMarkerInfo(const QSvgMarker *node, MarkerNodeInfo &info)
{
    QTransform oldTransform = info.transform.defaultValue().value<QTransform>();
 
    info.markerSize = node->rect().size();
    info.anchorPoint = node->refP();
    info.clipBox = oldTransform.mapRect(node->clipRect());
    info.viewBox = node->viewBox();
    switch (node->orientation()) {
    case QSvgMarker::Orientation::Auto:
        info.orientation = MarkerNodeInfo::Orientation::Auto;
        break;
    case QSvgMarker::Orientation::AutoStartReverse:
        info.orientation = MarkerNodeInfo::Orientation::AutoStartReverse;
        break;
    case QSvgMarker::Orientation::Value:
        info.orientation = MarkerNodeInfo::Orientation::Value;
        break;
    }
 
    switch (node->markerUnits()) {
    case QSvgMarker::MarkerUnits::UserSpaceOnUse:
        info.markerUnits = MarkerNodeInfo::MarkerUnits::UserSpace;
        break;
    case QSvgMarker::MarkerUnits::StrokeWidth:
        info.markerUnits = MarkerNodeInfo::MarkerUnits::StrokeWidth;
        break;
    }
 
    info.angle = node->orientationAngle();
 
    QTransform xform = node->aspectRatioTransform();
    if (!xform.isIdentity()) {
        info.isDefaultTransform = false;
        xform = xform * oldTransform;
        info.transform.setDefaultValue(QVariant::fromValue(xform));
    }
 
    info.preserveAspectRatio = MarkerNodeInfo::PreserveAspectRatio(node->preserveAspectRatios().toInt());
}
 
bool QSvgVisitorImpl::visitMarkerNodeStart(const QSvgMarker *node)
{
    if (!m_pregeneratingReferencedNodes)
        return false;
 
    handleBaseNodeSetup(node);
 
    MarkerNodeInfo info;
 
    fillCommonNodeInfo(node, info);
    fillAnimationInfo(node, info);
    fillMarkerInfo(node, info);
    info.stage = StructureNodeStage::Start;
 
    return m_generator->generateMarkerNode(info);
}
 
void QSvgVisitorImpl::visitMarkerNodeEnd(const QSvgMarker *node)
{
    handleBaseNodeEnd(node);
 
    MarkerNodeInfo info;
    fillCommonNodeInfo(node, info);
    fillMarkerInfo(node, info);
    info.stage = StructureNodeStage::End;
 
    m_generator->generateMarkerNode(info);
}
 
QT_END_NAMESPACE