qsvgdocument.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qsvgdocument_p.h"
 
#include "qsvghandler_p.h"
#include "qsvgfont_p.h"
 
#include "qpainter.h"
#include "qfile.h"
#include "qbuffer.h"
#include "qbytearray.h"
#include "qstack.h"
#include "qtransform.h"
#include "qdebug.h"
 
#ifndef QT_NO_COMPRESS
#include <zlib.h>
#endif
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
QSvgDocument::QSvgDocument(QtSvg::Options options, QtSvg::AnimatorType type)
    : QSvgStructureNode(0)
    , m_states(this)
    , m_options(options)
{
    m_states.trustedSource = m_options.testFlag(QtSvg::AssumeTrustedSource);
    bool animationEnabled = !m_options.testFlag(QtSvg::DisableAnimations);
    switch (type) {
        case QtSvg::AnimatorType::Automatic:
            if (animationEnabled)
                m_animator.reset(new QSvgAnimator);
            break;
        case QtSvg::AnimatorType::Controlled:
            if (animationEnabled)
                m_animator.reset(new QSvgAnimationController);
    }
}
 
QSvgDocument::~QSvgDocument()
{
    // Only do that when AssumeTrustedSource is set to false. Otherwise, all nodes
    // will be deleted by recursive calls of destructors.
    if (!m_states.trustedSource)
        releaseDescendants();
}
 
static bool hasSvgHeader(const QByteArray &buf)
{
    QTextStream s(buf); // Handle multi-byte encodings
    QString h = s.readAll();
    QStringView th = QStringView(h).trimmed();
    bool matched = false;
    if (th.startsWith("<svg"_L1) || th.startsWith("<!DOCTYPE svg"_L1))
        matched = true;
    else if (th.startsWith("<?xml"_L1) || th.startsWith("<!--"_L1))
        matched = th.contains("<!DOCTYPE svg"_L1) || th.contains("<svg"_L1);
    return matched;
}
 
#ifndef QT_NO_COMPRESS
static QByteArray qt_inflateSvgzDataFrom(QIODevice *device, bool doCheckContent = true);
#   ifdef QT_BUILD_INTERNAL
Q_AUTOTEST_EXPORT QByteArray qt_inflateGZipDataFrom(QIODevice *device)
{
    return qt_inflateSvgzDataFrom(device, false); // autotest wants unchecked result
}
#   endif
 
static QByteArray qt_inflateSvgzDataFrom(QIODevice *device, bool doCheckContent)
{
    if (!device)
        return QByteArray();
 
    if (!device->isOpen())
        device->open(QIODevice::ReadOnly);
 
    Q_ASSERT(device->isOpen() && device->isReadable());
 
    static const int CHUNK_SIZE = 4096;
    int zlibResult = Z_OK;
 
    QByteArray source;
    QByteArray destination;
 
    // Initialize zlib stream struct
    z_stream zlibStream;
    zlibStream.next_in = Z_NULL;
    zlibStream.avail_in = 0;
    zlibStream.avail_out = 0;
    zlibStream.zalloc = Z_NULL;
    zlibStream.zfree = Z_NULL;
    zlibStream.opaque = Z_NULL;
 
    // Adding 16 to the window size gives us gzip decoding
    if (inflateInit2(&zlibStream, MAX_WBITS + 16) != Z_OK) {
        qCWarning(lcSvgHandler, "Cannot initialize zlib, because: %s",
                (zlibStream.msg != NULL ? zlibStream.msg : "Unknown error"));
        return QByteArray();
    }
 
    bool stillMoreWorkToDo = true;
    while (stillMoreWorkToDo) {
 
        if (!zlibStream.avail_in) {
            source = device->read(CHUNK_SIZE);
 
            if (source.isEmpty())
                break;
 
            zlibStream.avail_in = source.size();
            zlibStream.next_in = reinterpret_cast<Bytef*>(source.data());
        }
 
        do {
            // Prepare the destination buffer
            int oldSize = destination.size();
            if (oldSize > INT_MAX - CHUNK_SIZE) {
                inflateEnd(&zlibStream);
                qCWarning(lcSvgHandler, "Error while inflating gzip file: integer size overflow");
                return QByteArray();
            }
 
            destination.resize(oldSize + CHUNK_SIZE);
            zlibStream.next_out = reinterpret_cast<Bytef*>(
                    destination.data() + oldSize - zlibStream.avail_out);
            zlibStream.avail_out += CHUNK_SIZE;
 
            zlibResult = inflate(&zlibStream, Z_NO_FLUSH);
            switch (zlibResult) {
                case Z_NEED_DICT:
                case Z_DATA_ERROR:
                case Z_STREAM_ERROR:
                case Z_MEM_ERROR: {
                    inflateEnd(&zlibStream);
                    qCWarning(lcSvgHandler, "Error while inflating gzip file: %s",
                            (zlibStream.msg != NULL ? zlibStream.msg : "Unknown error"));
                    return QByteArray();
                }
            }
 
        // If the output buffer still has more room after calling inflate
        // it means we have to provide more data, so exit the loop here
        } while (!zlibStream.avail_out);
 
        if (doCheckContent) {
            // Quick format check, equivalent to QSvgIOHandler::canRead()
            const qsizetype destinationContents = std::min(destination.size(), static_cast<qsizetype>(zlibStream.total_out));
            Q_ASSERT(destinationContents == static_cast<qsizetype>(zlibStream.total_out));
            if (!hasSvgHeader(QByteArray::fromRawData(destination.constData(), destinationContents))) {
                inflateEnd(&zlibStream);
                qCWarning(lcSvgHandler, "Error while inflating gzip file: SVG format check failed");
                return QByteArray();
            }
            doCheckContent = false; // Run only once, on first chunk
        }
 
        if (zlibResult == Z_STREAM_END) {
            // Make sure there are no more members to process before exiting
            if (!(zlibStream.avail_in && inflateReset(&zlibStream) == Z_OK))
                stillMoreWorkToDo = false;
        }
    }
 
    // Chop off trailing space in the buffer
    destination.chop(zlibStream.avail_out);
 
    inflateEnd(&zlibStream);
    return destination;
}
#else
static QByteArray qt_inflateSvgzDataFrom(QIODevice *)
{
    return QByteArray();
}
#endif
 
std::unique_ptr<QSvgDocument> QSvgDocument::load(const QString &fileName, QtSvg::Options options,
                                         QtSvg::AnimatorType type)
{
    std::unique_ptr<QSvgDocument> doc;
    QFile file(fileName);
    if (!file.open(QFile::ReadOnly)) {
        qCWarning(lcSvgHandler, "Cannot open file '%s', because: %s",
                  qPrintable(fileName), qPrintable(file.errorString()));
        return doc;
    }
 
    if (fileName.endsWith(QLatin1String(".svgz"), Qt::CaseInsensitive)
            || fileName.endsWith(QLatin1String(".svg.gz"), Qt::CaseInsensitive)) {
        return load(qt_inflateSvgzDataFrom(&file));
    }
 
    QSvgHandler handler(&file, options, type);
    if (handler.ok()) {
        doc = handler.takeDocument();
        if (doc->m_animator)
            doc->m_animator->setAnimationDuration(handler.animationDuration());
    } else {
        qCWarning(lcSvgHandler, "Cannot read file '%s', because: %s (line %d)",
                 qPrintable(fileName), qPrintable(handler.errorString()), handler.lineNumber());
    }
    return doc;
}
 
std::unique_ptr<QSvgDocument> QSvgDocument::load(const QByteArray &contents, QtSvg::Options options,
                                         QtSvg::AnimatorType type)
{
    std::unique_ptr<QSvgDocument> doc;
    QByteArray svg;
    // Check for gzip magic number and inflate if appropriate
    if (contents.startsWith("\x1f\x8b")) {
        QBuffer buffer;
        buffer.setData(contents);
        svg = qt_inflateSvgzDataFrom(&buffer);
    } else {
        svg = contents;
    }
    if (svg.isNull())
        return doc;
 
    QBuffer buffer;
    buffer.setData(svg);
    buffer.open(QIODevice::ReadOnly);
    QSvgHandler handler(&buffer, options, type);
 
    if (handler.ok()) {
        doc = handler.takeDocument();
        if (doc->m_animator)
            doc->m_animator->setAnimationDuration(handler.animationDuration());
    }
    return doc;
}
 
std::unique_ptr<QSvgDocument> QSvgDocument::load(QXmlStreamReader *contents, QtSvg::Options options,
                                         QtSvg::AnimatorType type)
{
    QSvgHandler handler(contents, options, type);
 
    std::unique_ptr<QSvgDocument> doc;
    if (handler.ok()) {
        doc = handler.takeDocument();
        if (doc->m_animator)
            doc->m_animator->setAnimationDuration(handler.animationDuration());
    }
    return doc;
}
 
void QSvgDocument::draw(QPainter *p, const QRectF &bounds)
{
    if (displayMode() == QSvgNode::NoneMode)
        return;
 
    p->save();
    //sets default style on the painter
    //### not the most optimal way
    mapSourceToTarget(p, bounds);
    initPainter(p);
    applyStyle(p, m_states);
    for (const auto &node : renderers()) {
        if ((node->isVisible()) && (node->displayMode() != QSvgNode::NoneMode))
            node->draw(p, m_states);
    }
    revertStyle(p, m_states);
    p->restore();
}
 
 
void QSvgDocument::draw(QPainter *p, const QString &id,
                            const QRectF &bounds)
{
    QSvgNode *node = namedNode(id);
 
    if (!node) {
        qCDebug(lcSvgHandler, "Couldn't find node %s. Skipping rendering.", qPrintable(id));
        return;
    }
 
    if (node->displayMode() == QSvgNode::NoneMode)
        return;
 
    p->save();
 
    const QRectF elementBounds = node->bounds(this);
 
    mapSourceToTarget(p, bounds, elementBounds);
    QTransform originalTransform = p->worldTransform();
 
    //XXX set default style on the painter
    QPen pen(Qt::NoBrush, 1, Qt::SolidLine, Qt::FlatCap, Qt::SvgMiterJoin);
    pen.setMiterLimit(4);
    p->setPen(pen);
    p->setBrush(Qt::black);
    p->setRenderHint(QPainter::Antialiasing);
    p->setRenderHint(QPainter::SmoothPixmapTransform);
 
    QStack<QSvgNode*> parentApplyStack;
    QSvgNode *parent = node->parent();
    while (parent) {
        parentApplyStack.push(parent);
        parent = parent->parent();
    }
 
    for (int i = parentApplyStack.size() - 1; i >= 0; --i)
        parentApplyStack[i]->applyStyle(p, m_states);
 
    // Reset the world transform so that our parents don't affect
    // the position
    QTransform currentTransform = p->worldTransform();
    p->setWorldTransform(originalTransform);
 
    node->draw(p, m_states);
 
    p->setWorldTransform(currentTransform);
 
    for (int i = 0; i < parentApplyStack.size(); ++i)
        parentApplyStack[i]->revertStyle(p, m_states);
 
    //p->fillRect(bounds.adjusted(-5, -5, 5, 5), QColor(0, 0, 255, 100));
 
    p->restore();
}
 
QSvgNode::Type QSvgDocument::type() const
{
    return Doc;
}
 
void QSvgDocument::setWidth(int len, bool percent)
{
    m_size.setWidth(len);
    m_widthPercent = percent;
}
 
void QSvgDocument::setHeight(int len, bool percent)
{
    m_size.setHeight(len);
    m_heightPercent = percent;
}
 
void QSvgDocument::setPreserveAspectRatio(bool on)
{
    m_preserveAspectRatio = on;
}
 
void QSvgDocument::setViewBox(const QRectF &rect)
{
    m_viewBox = rect;
    m_implicitViewBox = rect.isNull();
}
 
QtSvg::Options QSvgDocument::options() const
{
    return m_options;
}
 
void QSvgDocument::addSvgFont(const QString &name, QSvgFontPtr font)
{
    if (name.isEmpty())
        return;
 
    if (!m_fonts.insert({ name, std::move(font) }).second)
        qCWarning(lcSvgHandler) << "Font Family already added: " << name;
}
 
QSvgFont *QSvgDocument::svgFont(const QString &family) const
{
    auto it = m_fonts.find(family);
    return it != m_fonts.end() ? it->second.get() : nullptr;
}
 
void QSvgDocument::addNamedNode(const QString &id, QSvgNode *node)
{
    m_namedNodes.insert(id, node);
}
 
QSvgNode *QSvgDocument::namedNode(const QString &id) const
{
    return m_namedNodes.value(id);
}
 
void QSvgDocument::addPaintServer(QSvgPaintServerSharedPtr paintServer, const QString &id)
{
    if (id.isEmpty())
        return;
 
    if (!m_paintServers.insert({ id, paintServer }).second)
        qCWarning(lcSvgHandler) << "Duplicate unique style id:" << id;
}
 
QSvgPaintServerSharedPtr QSvgDocument::paintServer(QStringView id) const
{
    auto it = m_paintServers.find(id.toString());
    return it != m_paintServers.end() ? it->second : nullptr;
}
 
void QSvgDocument::restartAnimation()
{
    if (m_animator)
        m_animator->restartAnimation();
}
 
bool QSvgDocument::animated() const
{
    return m_animated;
}
 
void QSvgDocument::setAnimated(bool a)
{
    m_animated = a;
}
 
void QSvgDocument::draw(QPainter *p)
{
    draw(p, QRectF());
}
 
void QSvgDocument::drawCommand(QPainter *, QSvgExtraStates &)
{
    qCDebug(lcSvgHandler) << "SVG Tiny does not support nested <svg> elements: ignored.";
    return;
}
 
static bool isValidMatrix(const QTransform &transform)
{
    qreal determinant = transform.determinant();
    return qIsFinite(determinant);
}
 
void QSvgDocument::mapSourceToTarget(QPainter *p, const QRectF &targetRect, const QRectF &sourceRect)
{
    QTransform oldTransform = p->worldTransform();
 
    QRectF target = targetRect;
    if (target.isEmpty()) {
        QPaintDevice *dev = p->device();
        QRectF deviceRect(0, 0, dev->width(), dev->height());
        if (deviceRect.isEmpty()) {
            if (sourceRect.isEmpty())
                target = QRectF(QPointF(0, 0), size());
            else
                target = QRectF(QPointF(0, 0), sourceRect.size());
        } else {
            target = deviceRect;
        }
    }
 
    QRectF source = sourceRect;
    if (source.isEmpty())
        source = viewBox();
 
    if (source != target && !qFuzzyIsNull(source.width()) && !qFuzzyIsNull(source.height())) {
        if (m_implicitViewBox || !preserveAspectRatio()) {
            // Code path used when no view box is set, or IgnoreAspectRatio requested
            QTransform transform;
            transform.scale(target.width() / source.width(),
                            target.height() / source.height());
            QRectF c2 = transform.mapRect(source);
            p->translate(target.x() - c2.x(),
                         target.y() - c2.y());
            p->scale(target.width() / source.width(),
                     target.height() / source.height());
        } else {
            // Code path used when KeepAspectRatio is requested. This attempts to emulate the default values
            // of the <preserveAspectRatio tag that's implicitly defined when <viewbox> is used.
 
            // Scale the view box into the view port (target) by preserve the aspect ratio.
            QSizeF viewBoxSize = source.size();
            viewBoxSize.scale(target.width(), target.height(), Qt::KeepAspectRatio);
 
            // Center the view box in the view port
            p->translate(target.x() + (target.width() - viewBoxSize.width()) / 2,
                         target.y() + (target.height() - viewBoxSize.height()) / 2);
 
            p->scale(viewBoxSize.width() / source.width(),
                     viewBoxSize.height() / source.height());
 
            // Apply the view box translation if specified.
            p->translate(-source.x(), -source.y());
        }
    }
 
    if (!isValidMatrix(p->worldTransform()))
        p->setWorldTransform(oldTransform);
}
 
QRectF QSvgDocument::boundsOnElement(const QString &id) const
{
    const QSvgNode *node = namedNode(id);
    if (!node)
        node = this;
    return node->bounds(this);
}
 
bool QSvgDocument::elementExists(const QString &id) const
{
    return bool(namedNode(id));
}
 
QTransform QSvgDocument::transformForElement(const QString &id) const
{
    QSvgNode *node = namedNode(id);
 
    if (!node) {
        qCDebug(lcSvgHandler, "Couldn't find node %s. Skipping rendering.", qPrintable(id));
        return QTransform();
    }
 
    QTransform t;
 
    node = node->parent();
    while (node) {
        if (auto prop = node->m_style.property(QSvgStyleProperty::Transform))
            t *= static_cast<QSvgTransformStyle*>(prop)->qtransform();
        node = node->parent();
    }
 
    return t;
}
 
int QSvgDocument::currentFrame() const
{
    const double runningPercentage = qMin(currentElapsed() / double(animationDuration()), 1.);
    const int totalFrames = m_fps * animationDuration() / 1000;
    return int(runningPercentage * totalFrames);
}
 
void QSvgDocument::setCurrentFrame(int frame)
{
    if (!m_animator)
        return;
 
    const int totalFrames = m_fps * animationDuration() / 1000;
    if (totalFrames == 0)
        return;
 
    const int timeForFrame = frame * animationDuration() / totalFrames; //in ms
    const int timeToAdd = timeForFrame - currentElapsed();
    m_animator->setAnimatorTime(timeToAdd);
}
 
void QSvgDocument::setFramesPerSecond(int num)
{
    m_fps = num;
}
 
QSharedPointer<QSvgAbstractAnimator> QSvgDocument::animator() const
{
    return m_animator;
}
 
bool QSvgDocument::isLikelySvg(QIODevice *device, bool *isCompressed)
{
    constexpr int bufSize = 4096;
    char buf[bufSize];
    char inflateBuf[bufSize];
    bool useInflateBuf = false;
    int readLen = device->peek(buf, bufSize);
    if (readLen < 8)
        return false;
#ifndef QT_NO_COMPRESS
    if (quint8(buf[0]) == 0x1f && quint8(buf[1]) == 0x8b) {
        // Indicates gzip compressed content, i.e. svgz
        z_stream zlibStream;
        zlibStream.avail_in = readLen;
        zlibStream.next_out = reinterpret_cast<Bytef *>(inflateBuf);
        zlibStream.avail_out = bufSize;
        zlibStream.next_in = reinterpret_cast<Bytef *>(buf);
        zlibStream.zalloc = Z_NULL;
        zlibStream.zfree = Z_NULL;
        zlibStream.opaque = Z_NULL;
        if (inflateInit2(&zlibStream, MAX_WBITS + 16) != Z_OK)
            return false;
        int zlibResult = inflate(&zlibStream, Z_NO_FLUSH);
        inflateEnd(&zlibStream);
        if ((zlibResult != Z_OK && zlibResult != Z_STREAM_END) || zlibStream.total_out < 8)
            return false;
        readLen = zlibStream.total_out;
        if (isCompressed)
            *isCompressed = true;
        useInflateBuf = true;
    }
#endif
    return hasSvgHeader(QByteArray::fromRawData(useInflateBuf ? inflateBuf : buf, readLen));
}
 
QT_END_NAMESPACE