qsvgiohandler.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
// Qt-Security score:significant reason:default
 
 
#include "qsvgiohandler.h"
 
#ifndef QT_NO_SVGRENDERER
 
#include "qsvgrenderer.h"
#include "private/qsvgdocument_p.h"
#include "qimage.h"
#include "qpixmap.h"
#include "qpainter.h"
#include "qvariant.h"
#include "qbuffer.h"
#include "qdebug.h"
 
QT_BEGIN_NAMESPACE
 
class QSvgIOHandlerPrivate
{
public:
    QSvgIOHandlerPrivate(QSvgIOHandler *qq)
        : q(qq)
    {}
 
    bool load(QIODevice *device);
 
    QSvgIOHandler   *q{nullptr};
    QSvgRenderer     r;
    QXmlStreamReader xmlReader;
    QSize            defaultSize;
    QRect            clipRect;
    QSize            scaledSize;
    QRect            scaledClipRect;
    bool             loadAttempted{false};
    bool             loadStatus{false};
    bool             readDone{false};
    int              currentFrame{0};
    int              frameCount{0};
    int              frameDelay{0};
    QColor           backColor{Qt::transparent};
};
 
 
bool QSvgIOHandlerPrivate::load(QIODevice *device)
{
    if (loadAttempted)
        return loadStatus;
 
    if (q->format().isEmpty())
        q->canRead();
    loadAttempted = true;
 
    // # The SVG renderer doesn't handle trailing, unrelated data, so we must
    // assume that all available data in the device is to be read.
    bool res = false;
    QBuffer *buf = qobject_cast<QBuffer *>(device);
    if (buf) {
        const QByteArray &ba = buf->data();
        res = r.load(QByteArray::fromRawData(ba.constData() + buf->pos(), ba.size() - buf->pos()));
        buf->seek(ba.size());
#ifndef QT_NO_COMPRESS
    } else if (q->format() == "svgz") {
        res = r.load(device->readAll());
#endif
    } else {
        xmlReader.setDevice(device);
        res = r.load(&xmlReader);
    }
 
    if (res) {
        defaultSize = r.defaultSize();
        loadStatus = true;
        if (r.animated()) {
            const int duration = r.animationDuration();
            const int fps = r.framesPerSecond();
            frameCount = qMax(1, static_cast<int>(qint64(duration) * fps / 1000));
            frameDelay = fps > 0 ? 1000 / fps : 0;
        }
    }
 
    return loadStatus;
}
 
 
 
QSvgIOHandler::QSvgIOHandler()
    : d(new QSvgIOHandlerPrivate(this))
{
 
}
 
 
QSvgIOHandler::~QSvgIOHandler()
{
    delete d;
}
 
bool QSvgIOHandler::canRead() const
{
    if (!device())
        return false;
 
    if (d->loadAttempted) {
        if (!d->loadStatus)
            return false;
        if (d->r.animated())
            return d->currentFrame < d->frameCount;
        return !d->readDone;
    }
 
    // Not yet loaded — probe the device to determine format
    bool isCompressed = false;
    if (QSvgDocument::isLikelySvg(device(), &isCompressed)) {
        setFormat(isCompressed ? "svgz" : "svg");
        return true;
    }
    return false;
}
 
bool QSvgIOHandler::read(QImage *image)
{
    if (!d->load(device()))
        return false;
 
    // For non-animated SVGs, preserve original single-read behavior
    if (!d->r.animated()) {
        if (d->readDone)
            return false;
    } else {
        // For animated SVGs, set the current frame on the renderer
        if (d->currentFrame >= d->frameCount)
            return false;
        d->r.setCurrentFrame(d->currentFrame);
    }
 
    bool xform = (d->clipRect.isValid() || d->scaledSize.isValid() || d->scaledClipRect.isValid());
    QSize finalSize = d->defaultSize;
    QRectF bounds;
    if (xform && !d->defaultSize.isEmpty()) {
        bounds = QRectF(QPointF(0,0), QSizeF(d->defaultSize));
        QPoint tr1, tr2;
        QSizeF sc(1, 1);
        if (d->clipRect.isValid()) {
            tr1 = -d->clipRect.topLeft();
            finalSize = d->clipRect.size();
        }
        if (d->scaledSize.isValid()) {
            sc = QSizeF(qreal(d->scaledSize.width()) / finalSize.width(),
                        qreal(d->scaledSize.height()) / finalSize.height());
            finalSize = d->scaledSize;
        }
        if (d->scaledClipRect.isValid()) {
            tr2 = -d->scaledClipRect.topLeft();
            finalSize = d->scaledClipRect.size();
        }
        QTransform t;
        t.translate(tr2.x(), tr2.y());
        t.scale(sc.width(), sc.height());
        t.translate(tr1.x(), tr1.y());
        bounds = t.mapRect(bounds);
    }
    if (finalSize.isEmpty()) {
        *image = QImage();
    } else {
        if (qMax(finalSize.width(), finalSize.height()) > 0xffff)
            return false; // Assume corrupted file
        if (!QImageIOHandler::allocateImage(finalSize, QImage::Format_ARGB32_Premultiplied, image))
            return false;
        image->fill(d->backColor.rgba());
        QPainter p(image);
        d->r.render(&p, bounds);
        p.end();
    }
 
    d->readDone = true;
    if (d->r.animated())
        ++d->currentFrame;
    return true;
}
 
 
QVariant QSvgIOHandler::option(ImageOption option) const
{
    switch(option) {
    case ImageFormat:
        return QImage::Format_ARGB32_Premultiplied;
        break;
    case Size:
        d->load(device());
        return d->defaultSize;
        break;
    case ClipRect:
        return d->clipRect;
        break;
    case ScaledSize:
        return d->scaledSize;
        break;
    case ScaledClipRect:
        return d->scaledClipRect;
        break;
    case BackgroundColor:
        return d->backColor;
        break;
    case Animation:
        d->load(device());
        return d->r.animated();
        break;
    default:
        break;
    }
    return QVariant();
}
 
 
void QSvgIOHandler::setOption(ImageOption option, const QVariant & value)
{
    switch(option) {
    case ClipRect:
        d->clipRect = value.toRect();
        break;
    case ScaledSize:
        d->scaledSize = value.toSize();
        break;
    case ScaledClipRect:
        d->scaledClipRect = value.toRect();
        break;
    case BackgroundColor:
        d->backColor = value.value<QColor>();
        break;
    default:
        break;
    }
}
 
 
bool QSvgIOHandler::supportsOption(ImageOption option) const
{
    switch(option)
    {
    case ImageFormat:
    case Size:
    case ClipRect:
    case ScaledSize:
    case ScaledClipRect:
    case BackgroundColor:
    case Animation:
        return true;
    default:
        break;
    }
    return false;
}
 
 
bool QSvgIOHandler::jumpToNextImage()
{
    return jumpToImage(d->currentFrame + 1);
}
 
bool QSvgIOHandler::jumpToImage(int imageNumber)
{
    if (!d->load(device()) || !d->r.animated())
        return false;
    if (imageNumber < 0 || imageNumber >= d->frameCount)
        return false;
    d->currentFrame = imageNumber;
    return true;
}
 
int QSvgIOHandler::loopCount() const
{
    return 0;
}
 
int QSvgIOHandler::imageCount() const
{
    if (!d->load(device()))
        return 0;
    if (d->r.animated())
        return d->frameCount;
    return 1;
}
 
int QSvgIOHandler::nextImageDelay() const
{
    if (d->load(device()) && d->r.animated())
        return d->frameDelay;
    return 0;
}
 
int QSvgIOHandler::currentImageNumber() const
{
    if (d->load(device()) && d->r.animated())
        return d->currentFrame - 1;  // currentFrame is the *next* frame to read
    return 0;
}
 
bool QSvgIOHandler::canRead(QIODevice *device)
{
    return QSvgDocument::isLikelySvg(device);
}
 
QT_END_NAMESPACE
 
#endif // QT_NO_SVGRENDERER