58     QSvgIOHandlerPrivate()

    59     QSvgIOHandlerPrivate(QSvgIOHandler *qq)

    59         : r(new QSvgRenderer()), loaded(false)

    60         : q(qq), loaded(false), readDone(false), backColor(Qt::transparent)

    67     static bool findSvgTag(QIODevice *device);

    64 

    68 

    65     QSvgIOHandler   *q;

    69     QSvgRenderer *r;

    66     QSvgRenderer     r;

    70     QSize         defaultSize;

    67     QXmlStreamReader xmlReader;

    71     QSize         currentSize;

    68     QSize            defaultSize;

    72     bool          loaded;

    69     QRect            clipRect;

    70     QSize            scaledSize;

    71     QRect            scaledClipRect;

    72     bool             loaded;

    73     bool             readDone;

    74     QColor           backColor;

    79 

    82     if (q->format().isEmpty())

    80     if (r->load(device->readAll())) {

    83         q->canRead();

    81         defaultSize = QSize(r->viewBox().width(), r->viewBox().height());

    84 

    82         if (currentSize.isEmpty())

    85     // # The SVG renderer doesn't handle trailing, unrelated data, so we must

    83             currentSize = defaultSize;

    86     // assume that all available data in the device is to be read.

    84     }

    87     bool res = false;

    85     loaded = r->isValid();

    88     QBuffer *buf = qobject_cast<QBuffer *>(device);

    89     if (buf) {

    90         const QByteArray &ba = buf->data();

    91         res = r.load(QByteArray::fromRawData(ba.constData() + buf->pos(), ba.size() - buf->pos()));

    92         buf->seek(ba.size());

    93     } else if (q->format() == "svgz") {

    94         res = r.load(device->readAll());

    95     } else {

    96         xmlReader.setDevice(device);

    97         res = r.load(&xmlReader);

    98     }

    99 

   100     if (res) {

   101         defaultSize = QSize(r.viewBox().width(), r.viewBox().height());

   102         loaded = true;

   103     }

    90 bool QSvgIOHandlerPrivate::findSvgTag(QIODevice *device)

   108 

    91 {

   109 QSvgIOHandler::QSvgIOHandler()

    92     qint64 pos = device->pos();

   110     : d(new QSvgIOHandlerPrivate(this))

    93     device->seek(0);

   111 {

    94     char buffer[256];

   112 

    95     const char svg_tag[] = "<svg";

   113 }

    96 

   114 

    97     while (1) {

   115 

    98         int size = device->read(buffer, 256);

   116 QSvgIOHandler::~QSvgIOHandler()

    99         for (int i=0; i<size - 5; ++i) {

   117 {

   100             if (!memcmp(buffer + i, svg_tag, 4)) {

   118     delete d;

   101                 if (buffer[i+4] == ' ' || buffer[i+4] == '\t'

   119 }

   102                     || buffer[i+4] == '\n' || buffer[i+4] == '\r')

   120 

   103                 {

   121 

   104                     device->seek(pos);

   122 bool QSvgIOHandler::canRead() const

   105                     return true;

   123 {

   106                 }

   124     if (!device())

   125         return false;

   126     if (d->loaded && !d->readDone)

   127         return true;        // Will happen if we have been asked for the size

   128 

   129     QByteArray buf = device()->peek(8);

   130     if (buf.startsWith("\x1f\x8b")) {

   131         setFormat("svgz");

   132         return true;

   133     } else if (buf.contains("<?xml") || buf.contains("<svg")) {

   134         setFormat("svg");

   135         return true;

   136     }

   137     return false;

   138 }

   139 

   140 

   141 QByteArray QSvgIOHandler::name() const

   142 {

   143     return "svg";

   144 }

   145 

   146 

   147 bool QSvgIOHandler::read(QImage *image)

   148 {

   149     if (!d->readDone && d->load(device())) {

   150         bool xform = (d->clipRect.isValid() || d->scaledSize.isValid() || d->scaledClipRect.isValid());

   151         QSize finalSize = d->defaultSize;

   152         QRectF bounds;

   153         if (xform && !d->defaultSize.isEmpty()) {

   154             bounds = QRectF(QPointF(0,0), QSizeF(d->defaultSize));

   155             QPoint tr1, tr2;

   156             QSizeF sc(1, 1);

   157             if (d->clipRect.isValid()) {

   158                 tr1 = -d->clipRect.topLeft();

   159                 finalSize = d->clipRect.size();

   109         if (device->atEnd())

   176         *image = QImage(finalSize, QImage::Format_ARGB32_Premultiplied);

   110             break;

   177         if (!finalSize.isEmpty()) {

   111         device->seek(device->pos()-4);

   178             image->fill(d->backColor.rgba());

   112     }

   113     device->seek(pos);

   114     return false;

   115 }

   116 

   117 QSvgIOHandler::QSvgIOHandler()

   118     : d(new QSvgIOHandlerPrivate())

   119 {

   120 

   121 }

   122 

   123 

   124 QSvgIOHandler::~QSvgIOHandler()

   125 {

   126     delete d;

   127 }

   128 

   129 

   130 bool QSvgIOHandler::canRead() const

   131 {

   132     return QSvgIOHandlerPrivate::findSvgTag(device());

   133 }

   134 

   135 

   136 QByteArray QSvgIOHandler::name() const

   137 {

   138     return "svg";

   139 }

   140 

   141 

   142 bool QSvgIOHandler::read(QImage *image)

   143 {

   144     if (d->load(device())) {

   145         *image = QImage(d->currentSize, QImage::Format_ARGB32_Premultiplied);

   146         if (!d->currentSize.isEmpty()) {

   147             image->fill(0x00000000);

   149             d->r->render(&p);

   180             d->r.render(&p, bounds);

   170         return d->currentSize;

   205         return d->scaledSize;

   206         break;

   207     case ScaledClipRect:

   208         return d->scaledClipRect;

   209         break;

   210     case BackgroundColor:

   211         return d->backColor;

   182     case Size:

   223     case ClipRect:

   183         d->defaultSize = value.toSize();

   224         d->clipRect = value.toRect();

   184         d->currentSize = value.toSize();

   187         d->currentSize = value.toSize();

   227         d->scaledSize = value.toSize();

   228         break;

   229     case ScaledClipRect:

   230         d->scaledClipRect = value.toRect();

   231         break;

   232     case BackgroundColor:

   233         d->backColor = value.value<QColor>();

   211     return QSvgIOHandlerPrivate::findSvgTag(device);

   261     QByteArray buf = device->peek(8);

   262     return buf.startsWith("\x1f\x8b") || buf.contains("<?xml") || buf.contains("<svg");