Initial import from the monolithic Qt.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://qt.gitorious.org/qt/pages/GitIntroductionWithQt

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12

35 files changed, 12360 insertions, 0 deletions

diff --git a/src/plugins/iconengines/iconengines.pro b/src/plugins/iconengines/iconengines.pro
new file mode 100644
index 0000000..bef8995
--- /dev/null
+++ b/src/plugins/iconengines/iconengines.pro
@@ -0,0 +1,3 @@
+TEMPLATE = subdirs
+
+contains(QT_CONFIG, svg): SUBDIRS += svgiconengine
diff --git a/src/plugins/iconengines/svgiconengine/main.cpp b/src/plugins/iconengines/svgiconengine/main.cpp
new file mode 100644
index 0000000..f7ca0c2
--- /dev/null
+++ b/src/plugins/iconengines/svgiconengine/main.cpp
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qiconengineplugin.h>
+#include <qstringlist.h>
+
+#if !defined(QT_NO_IMAGEFORMATPLUGIN) && !defined(QT_NO_SVG)
+
+#include "qsvgiconengine.h"
+
+#include <qiodevice.h>
+#include <qbytearray.h>
+#include <qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+class QSvgIconPlugin : public QIconEnginePluginV2
+{
+public:
+    QStringList keys() const;
+    QIconEngineV2 *create(const QString &filename = QString());
+};
+
+QStringList QSvgIconPlugin::keys() const
+{
+    QStringList keys(QLatin1String("svg"));
+#ifndef QT_NO_COMPRESS
+    keys << QLatin1String("svgz") << QLatin1String("svg.gz");
+#endif
+    return keys;
+}
+
+QIconEngineV2 *QSvgIconPlugin::create(const QString &file)
+{
+    QSvgIconEngine *engine = new QSvgIconEngine;
+    if (!file.isNull())
+        engine->addFile(file, QSize(), QIcon::Normal, QIcon::Off);
+    return engine;
+}
+
+Q_EXPORT_STATIC_PLUGIN(QSvgIconPlugin)
+Q_EXPORT_PLUGIN2(qsvgicon, QSvgIconPlugin)
+
+QT_END_NAMESPACE
+
+#endif // !QT_NO_IMAGEFORMATPLUGIN
diff --git a/src/plugins/iconengines/svgiconengine/qsvgiconengine.cpp b/src/plugins/iconengines/svgiconengine/qsvgiconengine.cpp
new file mode 100644
index 0000000..9d9abb6
--- /dev/null
+++ b/src/plugins/iconengines/svgiconengine/qsvgiconengine.cpp
@@ -0,0 +1,357 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "qsvgiconengine.h"
+
+#ifndef QT_NO_SVGRENDERER
+
+#include "qpainter.h"
+#include "qpixmap.h"
+#include "qsvgrenderer.h"
+#include "qpixmapcache.h"
+#include "qstyle.h"
+#include "qapplication.h"
+#include "qstyleoption.h"
+#include "qfileinfo.h"
+#include <QAtomicInt>
+#include "qdebug.h"
+
+QT_BEGIN_NAMESPACE
+
+class QSvgIconEnginePrivate : public QSharedData
+{
+public:
+    QSvgIconEnginePrivate()
+        : svgBuffers(0), addedPixmaps(0)
+        { stepSerialNum(); }
+
+    ~QSvgIconEnginePrivate()
+        { delete addedPixmaps; delete svgBuffers; }
+
+    static int hashKey(QIcon::Mode mode, QIcon::State state)
+        { return (((mode)<<4)|state); }
+
+    QString pmcKey(const QSize &size, QIcon::Mode mode, QIcon::State state)
+        { return QLatin1String("$qt_svgicon_")
+                 + QString::number(serialNum, 16).append(QLatin1Char('_'))
+                 + QString::number((((((size.width()<<11)|size.height())<<11)|mode)<<4)|state, 16); }
+
+    void stepSerialNum()
+        { serialNum = lastSerialNum.fetchAndAddRelaxed(1); }
+
+    void loadDataForModeAndState(QSvgRenderer *renderer, QIcon::Mode mode, QIcon::State state);
+
+    QHash<int, QString> svgFiles;
+    QHash<int, QByteArray> *svgBuffers;
+    QHash<int, QPixmap> *addedPixmaps;
+    int serialNum;
+    static QAtomicInt lastSerialNum;
+};
+
+QAtomicInt QSvgIconEnginePrivate::lastSerialNum;
+
+static inline int pmKey(const QSize &size, QIcon::Mode mode, QIcon::State state)
+{
+    return ((((((size.width()<<11)|size.height())<<11)|mode)<<4)|state);
+}
+
+QSvgIconEngine::QSvgIconEngine()
+    : d(new QSvgIconEnginePrivate)
+{
+}
+
+QSvgIconEngine::QSvgIconEngine(const QSvgIconEngine &other)
+    : QIconEngineV2(other), d(new QSvgIconEnginePrivate)
+{
+    d->svgFiles = other.d->svgFiles;
+    if (other.d->svgBuffers)
+        d->svgBuffers = new QHash<int, QByteArray>(*other.d->svgBuffers);
+    if (other.d->addedPixmaps)
+        d->addedPixmaps = new QHash<int, QPixmap>(*other.d->addedPixmaps);
+}
+
+
+QSvgIconEngine::~QSvgIconEngine()
+{
+}
+
+
+QSize QSvgIconEngine::actualSize(const QSize &size, QIcon::Mode mode,
+                                 QIcon::State state)
+{
+    if (d->addedPixmaps) {
+        QPixmap pm = d->addedPixmaps->value(d->hashKey(mode, state));
+        if (!pm.isNull() && pm.size() == size)
+            return size;
+    }
+
+    QPixmap pm = pixmap(size, mode, state);
+    if (pm.isNull())
+        return QSize();
+    return pm.size();
+}
+
+void QSvgIconEnginePrivate::loadDataForModeAndState(QSvgRenderer *renderer, QIcon::Mode mode, QIcon::State state)
+{
+    QByteArray buf;
+    if (svgBuffers) {
+        buf = svgBuffers->value(hashKey(mode, state));
+        if (buf.isEmpty())
+            buf = svgBuffers->value(hashKey(QIcon::Normal, QIcon::Off));
+    }
+    if (!buf.isEmpty()) {
+#ifndef QT_NO_COMPRESS
+        buf = qUncompress(buf);
+#endif
+        renderer->load(buf);
+    } else {
+        QString svgFile = svgFiles.value(hashKey(mode, state));
+        if (svgFile.isEmpty())
+            svgFile = svgFiles.value(hashKey(QIcon::Normal, QIcon::Off));
+        if (!svgFile.isEmpty())
+            renderer->load(svgFile);
+    }
+}
+
+QPixmap QSvgIconEngine::pixmap(const QSize &size, QIcon::Mode mode,
+                               QIcon::State state)
+{
+    QPixmap pm;
+
+    QString pmckey(d->pmcKey(size, mode, state));
+    if (QPixmapCache::find(pmckey, pm))
+        return pm;
+
+    if (d->addedPixmaps) {
+        pm = d->addedPixmaps->value(d->hashKey(mode, state));
+        if (!pm.isNull() && pm.size() == size)
+            return pm;
+    }
+
+    QSvgRenderer renderer;
+    d->loadDataForModeAndState(&renderer, mode, state);
+    if (!renderer.isValid())
+        return pm;
+
+    QSize actualSize = renderer.defaultSize();
+    if (!actualSize.isNull())
+        actualSize.scale(size, Qt::KeepAspectRatio);
+
+    QImage img(actualSize, QImage::Format_ARGB32_Premultiplied);
+    img.fill(0x00000000);
+    QPainter p(&img);
+    renderer.render(&p);
+    p.end();
+    pm = QPixmap::fromImage(img);
+    QStyleOption opt(0);
+    opt.palette = QApplication::palette();
+    QPixmap generated = QApplication::style()->generatedIconPixmap(mode, pm, &opt);
+    if (!generated.isNull())
+        pm = generated;
+
+    if (!pm.isNull())
+        QPixmapCache::insert(pmckey, pm);
+
+    return pm;
+}
+
+
+void QSvgIconEngine::addPixmap(const QPixmap &pixmap, QIcon::Mode mode,
+                               QIcon::State state)
+{
+    if (!d->addedPixmaps)
+        d->addedPixmaps = new QHash<int, QPixmap>;
+    d->stepSerialNum();
+    d->addedPixmaps->insert(d->hashKey(mode, state), pixmap);
+}
+
+
+void QSvgIconEngine::addFile(const QString &fileName, const QSize &,
+                             QIcon::Mode mode, QIcon::State state)
+{
+    if (!fileName.isEmpty()) {
+        QString abs = fileName;
+        if (fileName.at(0) != QLatin1Char(':'))
+            abs = QFileInfo(fileName).absoluteFilePath();
+        if (abs.endsWith(QLatin1String(".svg"), Qt::CaseInsensitive)
+#ifndef QT_NO_COMPRESS
+                || abs.endsWith(QLatin1String(".svgz"), Qt::CaseInsensitive)
+                || abs.endsWith(QLatin1String(".svg.gz"), Qt::CaseInsensitive))
+#endif
+        {
+            QSvgRenderer renderer(abs);
+            if (renderer.isValid()) {
+                d->stepSerialNum();
+                d->svgFiles.insert(d->hashKey(mode, state), abs);
+            }
+        } else {
+            QPixmap pm(abs);
+            if (!pm.isNull())
+                addPixmap(pm, mode, state);
+        }
+    }
+}
+
+void QSvgIconEngine::paint(QPainter *painter, const QRect &rect,
+                           QIcon::Mode mode, QIcon::State state)
+{
+    painter->drawPixmap(rect, pixmap(rect.size(), mode, state));
+}
+
+QString QSvgIconEngine::key() const
+{
+    return QLatin1String("svg");
+}
+
+QIconEngineV2 *QSvgIconEngine::clone() const
+{
+    return new QSvgIconEngine(*this);
+}
+
+
+bool QSvgIconEngine::read(QDataStream &in)
+{
+    d = new QSvgIconEnginePrivate;
+    d->svgBuffers = new QHash<int, QByteArray>;
+
+    if (in.version() >= QDataStream::Qt_4_4) {
+        int isCompressed;
+        QHash<int, QString> fileNames;  // For memoryoptimization later
+        in >> fileNames >> isCompressed >> *d->svgBuffers;
+#ifndef QT_NO_COMPRESS
+        if (!isCompressed) {
+            foreach(int key, d->svgBuffers->keys())
+                d->svgBuffers->insert(key, qCompress(d->svgBuffers->value(key)));
+        }
+#else
+        if (isCompressed) {
+            qWarning("QSvgIconEngine: Can not decompress SVG data");
+            d->svgBuffers->clear();
+        }
+#endif
+        int hasAddedPixmaps;
+        in >> hasAddedPixmaps;
+        if (hasAddedPixmaps) {
+            d->addedPixmaps = new QHash<int, QPixmap>;
+            in >> *d->addedPixmaps;
+        }
+    }
+    else {
+        QPixmap pixmap;
+        QByteArray data;
+        uint mode;
+        uint state;
+        int num_entries;
+
+        in >> data;
+        if (!data.isEmpty()) {
+#ifndef QT_NO_COMPRESS
+            data = qUncompress(data);
+#endif
+            if (!data.isEmpty())
+                d->svgBuffers->insert(d->hashKey(QIcon::Normal, QIcon::Off), data);
+        }
+        in >> num_entries;
+        for (int i=0; i<num_entries; ++i) {
+            if (in.atEnd())
+                return false;
+            in >> pixmap;
+            in >> mode;
+            in >> state;
+            // The pm list written by 4.3 is buggy and/or useless, so ignore.
+            //addPixmap(pixmap, QIcon::Mode(mode), QIcon::State(state));
+        }
+    }
+
+    return true;
+}
+
+
+bool QSvgIconEngine::write(QDataStream &out) const
+{
+    if (out.version() >= QDataStream::Qt_4_4) {
+        int isCompressed = 0;
+#ifndef QT_NO_COMPRESS
+        isCompressed = 1;
+#endif
+        QHash<int, QByteArray> svgBuffers;
+        if (d->svgBuffers)
+            svgBuffers = *d->svgBuffers;
+        foreach(int key, d->svgFiles.keys()) {
+            QByteArray buf;
+            QFile f(d->svgFiles.value(key));
+            if (f.open(QIODevice::ReadOnly))
+                buf = f.readAll();
+#ifndef QT_NO_COMPRESS
+            buf = qCompress(buf);
+#endif
+            svgBuffers.insert(key, buf);
+        }
+        out << d->svgFiles << isCompressed << svgBuffers;
+        if (d->addedPixmaps)
+            out << (int)1 << *d->addedPixmaps;
+        else
+            out << (int)0;
+    }
+    else {
+        QByteArray buf;
+        if (d->svgBuffers)
+            buf = d->svgBuffers->value(d->hashKey(QIcon::Normal, QIcon::Off));
+        if (buf.isEmpty()) {
+            QString svgFile = d->svgFiles.value(d->hashKey(QIcon::Normal, QIcon::Off));
+            if (!svgFile.isEmpty()) {
+                QFile f(svgFile);
+                if (f.open(QIODevice::ReadOnly))
+                    buf = f.readAll();
+            }
+        }
+#ifndef QT_NO_COMPRESS
+        buf = qCompress(buf);
+#endif
+        out << buf;
+        // 4.3 has buggy handling of added pixmaps, so don't write any
+        out << (int)0;
+    }
+    return true;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SVGRENDERER
diff --git a/src/plugins/iconengines/svgiconengine/qsvgiconengine.h b/src/plugins/iconengines/svgiconengine/qsvgiconengine.h
new file mode 100644
index 0000000..245adf6
--- /dev/null
+++ b/src/plugins/iconengines/svgiconengine/qsvgiconengine.h
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSVGICONENGINE_H
+#define QSVGICONENGINE_H
+
+#include <QtGui/qiconengine.h>
+#include <QtCore/qshareddata.h>
+
+#ifndef QT_NO_SVG
+
+QT_BEGIN_NAMESPACE
+
+class QSvgIconEnginePrivate;
+
+class QSvgIconEngine : public QIconEngineV2
+{
+public:
+    QSvgIconEngine();
+    QSvgIconEngine(const QSvgIconEngine &other);
+    ~QSvgIconEngine();
+    void paint(QPainter *painter, const QRect &rect,
+               QIcon::Mode mode, QIcon::State state);
+    QSize actualSize(const QSize &size, QIcon::Mode mode,
+                     QIcon::State state);
+    QPixmap pixmap(const QSize &size, QIcon::Mode mode,
+                   QIcon::State state);
+
+    void addPixmap(const QPixmap &pixmap, QIcon::Mode mode,
+                   QIcon::State state);
+    void addFile(const QString &fileName, const QSize &size,
+                 QIcon::Mode mode, QIcon::State state);
+
+    QString key() const;
+    QIconEngineV2 *clone() const;
+    bool read(QDataStream &in);
+    bool write(QDataStream &out) const;
+
+private:
+    QSharedDataPointer<QSvgIconEnginePrivate> d;
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SVG
+#endif
diff --git a/src/plugins/iconengines/svgiconengine/svgiconengine.pro b/src/plugins/iconengines/svgiconengine/svgiconengine.pro
new file mode 100644
index 0000000..5c5a31e
--- /dev/null
+++ b/src/plugins/iconengines/svgiconengine/svgiconengine.pro
@@ -0,0 +1,13 @@
+TARGET  = qsvgicon
+include(../../qpluginbase.pri)
+
+HEADERS += qsvgiconengine.h
+SOURCES += main.cpp \
+           qsvgiconengine.cpp
+QT += xml svg
+
+QTDIR_build:DESTDIR  = $$QT_BUILD_TREE/plugins/iconengines
+target.path += $$[QT_INSTALL_PLUGINS]/iconengines
+INSTALLS += target
+
+symbian:TARGET.UID3=0x2001B2E3
diff --git a/src/plugins/imageformats/imageformats.pro b/src/plugins/imageformats/imageformats.pro
new file mode 100644
index 0000000..edffb73
--- /dev/null
+++ b/src/plugins/imageformats/imageformats.pro
@@ -0,0 +1,2 @@
+TEMPLATE = subdirs
+SUBDIRS += svg 
diff --git a/src/plugins/imageformats/svg/main.cpp b/src/plugins/imageformats/svg/main.cpp
new file mode 100644
index 0000000..e143d3e
--- /dev/null
+++ b/src/plugins/imageformats/svg/main.cpp
@@ -0,0 +1,94 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qimageiohandler.h>
+#include <qstringlist.h>
+
+#if !defined(QT_NO_IMAGEFORMATPLUGIN) && !defined(QT_NO_SVGRENDERER)
+
+#include "qsvgiohandler.h"
+
+#include <qiodevice.h>
+#include <qbytearray.h>
+#include <qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+class QSvgPlugin : public QImageIOPlugin
+{
+public:
+    QStringList keys() const;
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+};
+
+QStringList QSvgPlugin::keys() const
+{
+    return QStringList() << QLatin1String("svg") << QLatin1String("svgz");
+}
+
+QImageIOPlugin::Capabilities QSvgPlugin::capabilities(QIODevice *device, const QByteArray &format) const
+{
+    if (format == "svg" || format == "svgz")
+        return Capabilities(CanRead);
+    if (!format.isEmpty())
+        return 0;
+
+    Capabilities cap;
+    if (device->isReadable() && QSvgIOHandler::canRead(device))
+        cap |= CanRead;
+    return cap;
+}
+
+QImageIOHandler *QSvgPlugin::create(QIODevice *device, const QByteArray &format) const
+{
+    QSvgIOHandler *hand = new QSvgIOHandler();
+    hand->setDevice(device);
+    hand->setFormat(format);
+    return hand;
+}
+
+Q_EXPORT_STATIC_PLUGIN(QSvgPlugin)
+Q_EXPORT_PLUGIN2(qsvg, QSvgPlugin)
+
+QT_END_NAMESPACE
+
+#endif // !QT_NO_IMAGEFORMATPLUGIN
diff --git a/src/plugins/imageformats/svg/qsvgiohandler.cpp b/src/plugins/imageformats/svg/qsvgiohandler.cpp
new file mode 100644
index 0000000..3c8f2e9
--- /dev/null
+++ b/src/plugins/imageformats/svg/qsvgiohandler.cpp
@@ -0,0 +1,267 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qsvgiohandler.h"
+
+#ifndef QT_NO_SVGRENDERER
+
+#include "qsvgrenderer.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), loaded(false), readDone(false), backColor(Qt::transparent)
+    {}
+
+    bool load(QIODevice *device);
+
+    QSvgIOHandler   *q;
+    QSvgRenderer     r;
+    QXmlStreamReader xmlReader;
+    QSize            defaultSize;
+    QRect            clipRect;
+    QSize            scaledSize;
+    QRect            scaledClipRect;
+    bool             loaded;
+    bool             readDone;
+    QColor           backColor;
+};
+
+
+bool QSvgIOHandlerPrivate::load(QIODevice *device)
+{
+    if (loaded)
+        return true;
+    if (q->format().isEmpty())
+        q->canRead();
+
+    // # 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());
+    } else if (q->format() == "svgz") {
+        res = r.load(device->readAll());
+    } else {
+        xmlReader.setDevice(device);
+        res = r.load(&xmlReader);
+    }
+
+    if (res) {
+        defaultSize = QSize(r.viewBox().width(), r.viewBox().height());
+        loaded = true;
+    }
+
+    return loaded;
+}
+
+
+QSvgIOHandler::QSvgIOHandler()
+    : d(new QSvgIOHandlerPrivate(this))
+{
+
+}
+
+
+QSvgIOHandler::~QSvgIOHandler()
+{
+    delete d;
+}
+
+
+bool QSvgIOHandler::canRead() const
+{
+    if (!device())
+        return false;
+    if (d->loaded && !d->readDone)
+        return true;        // Will happen if we have been asked for the size
+
+    QByteArray buf = device()->peek(8);
+    if (buf.startsWith("\x1f\x8b")) {
+        setFormat("svgz");
+        return true;
+    } else if (buf.contains("<?xml") || buf.contains("<svg")) {
+        setFormat("svg");
+        return true;
+    }
+    return false;
+}
+
+
+QByteArray QSvgIOHandler::name() const
+{
+    return "svg";
+}
+
+
+bool QSvgIOHandler::read(QImage *image)
+{
+    if (!d->readDone && d->load(device())) {
+        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);
+        }
+        *image = QImage(finalSize, QImage::Format_ARGB32_Premultiplied);
+        if (!finalSize.isEmpty()) {
+            image->fill(d->backColor.rgba());
+            QPainter p(image);
+            d->r.render(&p, bounds);
+            p.end();
+        }
+        d->readDone = true;
+        return true;
+    }
+
+    return false;
+}
+
+
+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;
+    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:
+        return true;
+    default:
+        break;
+    }
+    return false;
+}
+
+
+bool QSvgIOHandler::canRead(QIODevice *device)
+{
+    QByteArray buf = device->peek(8);
+    return buf.startsWith("\x1f\x8b") || buf.contains("<?xml") || buf.contains("<svg");
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SVGRENDERER
diff --git a/src/plugins/imageformats/svg/qsvgiohandler.h b/src/plugins/imageformats/svg/qsvgiohandler.h
new file mode 100644
index 0000000..7ef0009
--- /dev/null
+++ b/src/plugins/imageformats/svg/qsvgiohandler.h
@@ -0,0 +1,77 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSVGIOHANDLER_H
+#define QSVGIOHANDLER_H
+
+#include <QtGui/qimageiohandler.h>
+
+#ifndef QT_NO_SVGRENDERER
+
+QT_BEGIN_NAMESPACE
+
+class QImage;
+class QByteArray;
+class QIODevice;
+class QVariant;
+class QSvgIOHandlerPrivate;
+
+class QSvgIOHandler : public QImageIOHandler
+{
+public:
+    QSvgIOHandler();
+    ~QSvgIOHandler();
+    virtual bool canRead() const;
+    virtual QByteArray name() const;
+    virtual bool read(QImage *image);
+    static bool canRead(QIODevice *device);
+    virtual QVariant option(ImageOption option) const;
+    virtual void setOption(ImageOption option, const QVariant & value);
+    virtual bool supportsOption(ImageOption option) const;
+
+private:
+    QSvgIOHandlerPrivate *d;
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SVGRENDERER
+#endif // QSVGIOHANDLER_H
diff --git a/src/plugins/imageformats/svg/svg.pro b/src/plugins/imageformats/svg/svg.pro
new file mode 100644
index 0000000..bcf4c21
--- /dev/null
+++ b/src/plugins/imageformats/svg/svg.pro
@@ -0,0 +1,13 @@
+TARGET  = qsvg
+include(../../qpluginbase.pri)
+
+HEADERS += qsvgiohandler.h
+SOURCES += main.cpp \
+           qsvgiohandler.cpp
+QT += xml svg
+
+QTDIR_build:DESTDIR = $$QT_BUILD_TREE/plugins/imageformats
+target.path += $$[QT_INSTALL_PLUGINS]/imageformats
+INSTALLS += target
+
+symbian:TARGET.UID3=0x2001E618
diff --git a/src/plugins/plugins.pro b/src/plugins/plugins.pro
new file mode 100644
index 0000000..1d714d4
--- /dev/null
+++ b/src/plugins/plugins.pro
@@ -0,0 +1,2 @@
+TEMPLATE = subdirs
+SUBDIRS +=  iconengines imageformats
diff --git a/src/src.pro b/src/src.pro
new file mode 100644
index 0000000..903663f
--- /dev/null
+++ b/src/src.pro
@@ -0,0 +1,3 @@
+TEMPLATE = subdirs
+CONFIG += ordered
+SUBDIRS += svg  plugins
diff --git a/src/svg/qgraphicssvgitem.cpp b/src/svg/qgraphicssvgitem.cpp
new file mode 100644
index 0000000..9c3742e
--- /dev/null
+++ b/src/svg/qgraphicssvgitem.cpp
@@ -0,0 +1,391 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtSvg module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "qgraphicssvgitem.h"
+
+#ifndef QT_NO_GRAPHICSSVGITEM
+
+#include "qpainter.h"
+#include "qstyleoption.h"
+#include "qsvgrenderer.h"
+#include "qdebug.h"
+
+#include "private/qobject_p.h"
+#include "private/qgraphicsitem_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QGraphicsSvgItemPrivate : public QGraphicsItemPrivate
+{
+public:
+    Q_DECLARE_PUBLIC(QGraphicsSvgItem)
+
+    QGraphicsSvgItemPrivate()
+        : renderer(0), shared(false)
+    {
+    }
+
+    void init(QGraphicsItem *parent)
+    {
+        Q_Q(QGraphicsSvgItem);
+        q->setParentItem(parent);
+        renderer = new QSvgRenderer(q);
+        QObject::connect(renderer, SIGNAL(repaintNeeded()),
+                         q, SLOT(_q_repaintItem()));
+        q->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
+        q->setMaximumCacheSize(QSize(1024, 768));
+    }
+
+    void _q_repaintItem()
+    {
+        q_func()->update();
+    }
+
+    inline void updateDefaultSize()
+    {
+        QRectF bounds;
+        if (elemId.isEmpty()) {
+            bounds = QRectF(QPointF(0, 0), renderer->defaultSize());
+        } else {
+            bounds = renderer->boundsOnElement(elemId);
+        }
+        if (boundingRect.size() != bounds.size()) {
+            q_func()->prepareGeometryChange();
+            boundingRect.setSize(bounds.size());
+        }
+    }
+
+    QSvgRenderer *renderer;
+    QRectF boundingRect;
+    bool shared;
+    QString elemId;
+};
+
+/*!
+    \class QGraphicsSvgItem
+    \ingroup graphicsview-api
+    \brief The QGraphicsSvgItem class is a QGraphicsItem that can be used to render
+           the contents of SVG files.
+
+    \since 4.2
+
+    QGraphicsSvgItem provides a way of rendering SVG files onto QGraphicsView.
+    QGraphicsSvgItem can be created by passing the SVG file to be rendered to
+    its constructor or by explicit setting a shared QSvgRenderer on it.
+
+    Note that setting QSvgRenderer on a QGraphicsSvgItem doesn't make the item take
+    ownership of the renderer, therefore if using setSharedRenderer() method one has
+    to make sure that the lifetime of the QSvgRenderer object will be at least as long
+    as that of the QGraphicsSvgItem.
+
+    QGraphicsSvgItem provides a way of rendering only parts of the SVG files via
+    the setElementId. If setElementId() method is called, only the SVG element
+    (and its children) with the passed id will be renderer. This provides a convenient
+    way of selectively rendering large SVG files that contain a number of discrete
+    elements. For example the following code renders only jokers from a SVG file
+    containing a whole card deck:
+
+    \snippet doc/src/snippets/code/src_svg_qgraphicssvgitem.cpp 0
+
+    Size of the item can be set via the \l{QRectF::setSize()}
+    {setSize()} method of the \l{QGraphicsSvgItem::boundingRect()}
+    {bounding rectangle} or via direct manipulation of the items
+    transformation matrix.
+
+    By default the SVG rendering is cached using QGraphicsItem::DeviceCoordinateCache
+    mode to speedup the display of items. Caching can be disabled by passing
+    QGraphicsItem::NoCache to the QGraphicsItem::setCacheMode() method.
+
+    \sa QSvgWidget, {QtSvg Module}, QGraphicsItem, QGraphicsView
+*/
+
+/*!
+    Constructs a new SVG item with the given \a parent.
+*/
+QGraphicsSvgItem::QGraphicsSvgItem(QGraphicsItem *parent)
+    : QGraphicsObject(*new QGraphicsSvgItemPrivate(), 0, 0)
+{
+    Q_D(QGraphicsSvgItem);
+    d->init(parent);
+}
+
+/*!
+    Constructs a new item with the given \a parent and loads the contents of the
+    SVG file with the specified \a fileName.
+*/
+QGraphicsSvgItem::QGraphicsSvgItem(const QString &fileName, QGraphicsItem *parent)
+    : QGraphicsObject(*new QGraphicsSvgItemPrivate(), 0, 0)
+{
+    Q_D(QGraphicsSvgItem);
+    d->init(parent);
+    d->renderer->load(fileName);
+    d->updateDefaultSize();
+}
+
+/*!
+    Returns the currently use QSvgRenderer.
+*/
+QSvgRenderer *QGraphicsSvgItem::renderer() const
+{
+    return d_func()->renderer;
+}
+
+
+/*!
+    Returns the bounding rectangle of this item.
+*/
+QRectF QGraphicsSvgItem::boundingRect() const
+{
+    Q_D(const QGraphicsSvgItem);
+    return d->boundingRect;
+}
+
+/*!
+    \internal
+
+    Highlights \a item as selected.
+
+    NOTE: This function is a duplicate of qt_graphicsItem_highlightSelected() in qgraphicsitem.cpp!
+*/
+static void qt_graphicsItem_highlightSelected(
+    QGraphicsItem *item, QPainter *painter, const QStyleOptionGraphicsItem *option)
+{
+    const QRectF murect = painter->transform().mapRect(QRectF(0, 0, 1, 1));
+    if (qFuzzyIsNull(qMax(murect.width(), murect.height())))
+        return;
+
+    const QRectF mbrect = painter->transform().mapRect(item->boundingRect());
+    if (qMin(mbrect.width(), mbrect.height()) < qreal(1.0))
+        return;
+
+    qreal itemPenWidth;
+    switch (item->type()) {
+        case QGraphicsEllipseItem::Type:
+            itemPenWidth = static_cast<QGraphicsEllipseItem *>(item)->pen().widthF();
+            break;
+        case QGraphicsPathItem::Type:
+            itemPenWidth = static_cast<QGraphicsPathItem *>(item)->pen().widthF();
+            break;
+        case QGraphicsPolygonItem::Type:
+            itemPenWidth = static_cast<QGraphicsPolygonItem *>(item)->pen().widthF();
+            break;
+        case QGraphicsRectItem::Type:
+            itemPenWidth = static_cast<QGraphicsRectItem *>(item)->pen().widthF();
+            break;
+        case QGraphicsSimpleTextItem::Type:
+            itemPenWidth = static_cast<QGraphicsSimpleTextItem *>(item)->pen().widthF();
+            break;
+        case QGraphicsLineItem::Type:
+            itemPenWidth = static_cast<QGraphicsLineItem *>(item)->pen().widthF();
+            break;
+        default:
+            itemPenWidth = 1.0;
+    }
+    const qreal pad = itemPenWidth / 2;
+
+    const qreal penWidth = 0; // cosmetic pen
+
+    const QColor fgcolor = option->palette.windowText().color();
+    const QColor bgcolor( // ensure good contrast against fgcolor
+        fgcolor.red()   > 127 ? 0 : 255,
+        fgcolor.green() > 127 ? 0 : 255,
+        fgcolor.blue()  > 127 ? 0 : 255);
+
+    painter->setPen(QPen(bgcolor, penWidth, Qt::SolidLine));
+    painter->setBrush(Qt::NoBrush);
+    painter->drawRect(item->boundingRect().adjusted(pad, pad, -pad, -pad));
+
+    painter->setPen(QPen(option->palette.windowText(), 0, Qt::DashLine));
+    painter->setBrush(Qt::NoBrush);
+    painter->drawRect(item->boundingRect().adjusted(pad, pad, -pad, -pad));
+}
+
+/*!
+    \reimp
+*/
+void QGraphicsSvgItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option,
+                             QWidget *widget)
+{
+//    Q_UNUSED(option);
+    Q_UNUSED(widget);
+
+    Q_D(QGraphicsSvgItem);
+    if (!d->renderer->isValid())
+        return;
+
+    if (d->elemId.isEmpty())
+        d->renderer->render(painter, d->boundingRect);
+    else
+        d->renderer->render(painter, d->elemId, d->boundingRect);
+
+    if (option->state & QStyle::State_Selected)
+        qt_graphicsItem_highlightSelected(this, painter, option);
+}
+
+/*!
+    \reimp
+*/
+int QGraphicsSvgItem::type() const
+{
+    return Type;
+}
+
+/*!
+  \property QGraphicsSvgItem::maximumCacheSize
+  \since 4.6
+
+  This property holds the maximum size of the device coordinate cache
+  for this item.
+ */
+
+/*!
+    Sets the maximum device coordinate cache size of the item to \a size.
+    If the item is cached using QGraphicsItem::DeviceCoordinateCache mode,
+    caching is bypassed if the extension of the item in device coordinates
+    is larger than \a size.
+
+    The cache corresponds to the QPixmap which is used to cache the
+    results of the rendering.
+    Use QPixmapCache::setCacheLimit() to set limitations on the whole cache
+    and use setMaximumCacheSize() when setting cache size for individual
+    items.
+
+    \sa QGraphicsItem::cacheMode()
+*/
+void QGraphicsSvgItem::setMaximumCacheSize(const QSize &size)
+{
+    QGraphicsItem::d_ptr->setExtra(QGraphicsItemPrivate::ExtraMaxDeviceCoordCacheSize, size);
+    update();
+}
+
+/*!
+    Returns the current maximum size of the device coordinate cache for this item.
+    If the item is cached using QGraphicsItem::DeviceCoordinateCache mode,
+    caching is bypassed if the extension of the item in device coordinates
+    is larger than the maximum size.
+
+    The default maximum cache size is 1024x768.
+    QPixmapCache::cacheLimit() gives the
+    cumulative bounds of the whole cache, whereas maximumCacheSize() refers
+    to a maximum cache size for this particular item.
+
+    \sa QGraphicsItem::cacheMode()
+*/
+QSize QGraphicsSvgItem::maximumCacheSize() const
+{
+    return QGraphicsItem::d_ptr->extra(QGraphicsItemPrivate::ExtraMaxDeviceCoordCacheSize).toSize();
+}
+
+/*!
+  \property QGraphicsSvgItem::elementId
+  \since 4.6
+  
+  This property holds the element's XML ID.
+ */
+
+/*!
+    Sets the XML ID of the element to \a id.
+*/
+void QGraphicsSvgItem::setElementId(const QString &id)
+{
+    Q_D(QGraphicsSvgItem);
+    d->elemId = id;
+    d->updateDefaultSize();
+    update();
+}
+
+/*!
+    Returns the XML ID the element that is currently
+    being rendered. Returns an empty string if the whole
+    file is being rendered.
+*/
+QString QGraphicsSvgItem::elementId() const
+{
+    Q_D(const QGraphicsSvgItem);
+    return d->elemId;
+}
+
+/*!
+    Sets \a renderer to be a shared QSvgRenderer on the item. By
+    using this method one can share the same QSvgRenderer on a number
+    of items. This means that the SVG file will be parsed only once.
+    QSvgRenderer passed to this method has to exist for as long as
+    this item is used.
+*/
+void QGraphicsSvgItem::setSharedRenderer(QSvgRenderer *renderer)
+{
+    Q_D(QGraphicsSvgItem);
+    if (!d->shared)
+        delete d->renderer;
+
+    d->renderer = renderer;
+    d->shared = true;
+
+    d->updateDefaultSize();
+
+    update();
+}
+
+/*!
+    \obsolete
+
+    Use QGraphicsItem::setCacheMode() instead. Passing true to this function is equivalent
+    to QGraphicsItem::setCacheMode(QGraphicsItem::DeviceCoordinateCache).
+*/
+void QGraphicsSvgItem::setCachingEnabled(bool caching)
+{
+    setCacheMode(caching ? QGraphicsItem::DeviceCoordinateCache : QGraphicsItem::NoCache);
+}
+
+/*!
+    \obsolete
+
+    Use QGraphicsItem::cacheMode() instead.
+*/
+bool QGraphicsSvgItem::isCachingEnabled() const
+{
+    return cacheMode() != QGraphicsItem::NoCache;
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qgraphicssvgitem.cpp"
+
+#endif // QT_NO_GRAPHICSSVGITEM
diff --git a/src/svg/qgraphicssvgitem.h b/src/svg/qgraphicssvgitem.h
new file mode 100644
index 0000000..6577db4
--- /dev/null
+++ b/src/svg/qgraphicssvgitem.h
@@ -0,0 +1,101 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtSvg module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#ifndef QGRAPHICSSVGITEM_H
+#define QGRAPHICSSVGITEM_H
+
+#include <QtGui/qgraphicsitem.h>
+
+#ifndef QT_NO_GRAPHICSSVGITEM
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Svg)
+
+class QSvgRenderer;
+class QGraphicsSvgItemPrivate;
+
+class Q_SVG_EXPORT QGraphicsSvgItem : public QGraphicsObject
+{
+    Q_OBJECT
+    Q_INTERFACES(QGraphicsItem)
+    Q_PROPERTY(QString elementId READ elementId WRITE setElementId)
+    Q_PROPERTY(QSize maximumCacheSize READ maximumCacheSize WRITE setMaximumCacheSize)
+
+public:
+    QGraphicsSvgItem(QGraphicsItem *parentItem=0);
+    QGraphicsSvgItem(const QString &fileName, QGraphicsItem *parentItem=0);
+
+    void setSharedRenderer(QSvgRenderer *renderer);
+    QSvgRenderer *renderer() const;
+
+    void setElementId(const QString &id);
+    QString elementId() const;
+
+    void setCachingEnabled(bool);
+    bool isCachingEnabled() const;
+
+    void setMaximumCacheSize(const QSize &size);
+    QSize maximumCacheSize() const;
+
+    virtual QRectF boundingRect() const;
+
+    virtual void paint(QPainter *painter,
+                       const QStyleOptionGraphicsItem *option,
+                       QWidget *widget=0);
+
+    enum { Type = 13 };
+    virtual int type() const;
+
+private:
+    Q_DISABLE_COPY(QGraphicsSvgItem)
+    Q_DECLARE_PRIVATE_D(QGraphicsItem::d_ptr.data(), QGraphicsSvgItem)
+
+    Q_PRIVATE_SLOT(d_func(), void _q_repaintItem())
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QT_NO_GRAPHICSSVGITEM
+#endif // QGRAPHICSSVGITEM_H
diff --git a/src/svg/qsvgfont.cpp b/src/svg/qsvgfont.cpp
new file mode 100644
index 0000000..66950ff
--- /dev/null
+++ b/src/svg/qsvgfont.cpp
@@ -0,0 +1,142 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtSvg module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qsvgfont_p.h"
+
+#ifndef QT_NO_SVG
+
+#include "qpainter.h"
+#include "qpen.h"
+#include "qdebug.h"
+#include "qpicture.h"
+
+QT_BEGIN_NAMESPACE
+
+QSvgGlyph::QSvgGlyph(QChar unicode, const QPainterPath &path, qreal horizAdvX)
+    : m_unicode(unicode), m_path(path), m_horizAdvX(horizAdvX)
+{
+
+}
+
+
+QSvgFont::QSvgFont(qreal horizAdvX)
+    : m_horizAdvX(horizAdvX)
+{
+}
+
+
+QString QSvgFont::familyName() const
+{
+    return m_familyName;
+}
+
+
+void QSvgFont::addGlyph(QChar unicode, const QPainterPath &path, qreal horizAdvX )
+{
+    m_glyphs.insert(unicode, QSvgGlyph(unicode, path,
+                                       (horizAdvX==-1)?m_horizAdvX:horizAdvX));
+}
+
+
+void QSvgFont::draw(QPainter *p, const QPointF &point, const QString &str, qreal pixelSize, Qt::Alignment alignment) const
+{
+    p->save();
+    p->translate(point);
+    p->scale(pixelSize / m_unitsPerEm, -pixelSize / m_unitsPerEm);
+
+    // Calculate the text width to be used for alignment
+    int textWidth = 0;
+    QString::const_iterator itr = str.constBegin();
+    for ( ; itr != str.constEnd(); ++itr) {
+        QChar unicode = *itr;
+        if (!m_glyphs.contains(*itr)) {
+            unicode = 0;
+            if (!m_glyphs.contains(unicode))
+                continue;
+        }
+        textWidth += static_cast<int>(m_glyphs[unicode].m_horizAdvX);
+    }
+
+    QPoint alignmentOffset(0, 0);
+    if (alignment == Qt::AlignHCenter) {
+        alignmentOffset.setX(-textWidth / 2);
+    } else if (alignment == Qt::AlignRight) {
+        alignmentOffset.setX(-textWidth);
+    }
+
+    p->translate(alignmentOffset);
+
+    // since in SVG the embedded font ain't really a path
+    // the outline has got to stay untransformed...
+    qreal penWidth = p->pen().widthF();
+    penWidth /= (pixelSize/m_unitsPerEm);
+    QPen pen = p->pen();
+    pen.setWidthF(penWidth);
+    p->setPen(pen);
+
+    itr = str.constBegin();
+    for ( ; itr != str.constEnd(); ++itr) {
+        QChar unicode = *itr;
+        if (!m_glyphs.contains(*itr)) {
+            unicode = 0;
+            if (!m_glyphs.contains(unicode))
+                continue;
+        }
+        p->drawPath(m_glyphs[unicode].m_path);
+        p->translate(m_glyphs[unicode].m_horizAdvX, 0);
+    }
+
+    p->restore();
+}
+
+void QSvgFont::setFamilyName(const QString &name)
+{
+    m_familyName = name;
+}
+
+void QSvgFont::setUnitsPerEm(qreal upem)
+{
+    m_unitsPerEm = upem;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SVG
diff --git a/src/svg/qsvgfont_p.h b/src/svg/qsvgfont_p.h
new file mode 100644
index 0000000..df82ee5
--- /dev/null
+++ b/src/svg/qsvgfont_p.h
@@ -0,0 +1,103 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtSvg module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSVGFONT_P_H
+#define QSVGFONT_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qpainterpath.h"
+
+#ifndef QT_NO_SVG
+
+#include "qhash.h"
+#include "qstring.h"
+#include "qsvgstyle_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QSvgGlyph
+{
+public:
+    QSvgGlyph(QChar unicode, const QPainterPath &path, qreal horizAdvX);
+    QSvgGlyph() : m_unicode(0), m_horizAdvX(0) {}
+
+    QChar m_unicode;
+    QPainterPath m_path;
+    qreal m_horizAdvX;
+};
+
+
+class QSvgFont : public QSvgRefCounted
+{
+public:
+    QSvgFont(qreal horizAdvX);
+
+    void setFamilyName(const QString &name);
+    QString familyName() const;
+
+    void setUnitsPerEm(qreal upem);
+
+    void addGlyph(QChar unicode, const QPainterPath &path, qreal horizAdvX = -1);
+
+    void draw(QPainter *p, const QPointF &point, const QString &str, qreal pixelSize, Qt::Alignment alignment) const;
+public:
+    QString m_familyName;
+    qreal m_unitsPerEm;
+    qreal m_ascent;
+    qreal m_descent;
+    qreal m_horizAdvX;
+    QHash<QChar, QSvgGlyph> m_glyphs;
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SVG
+#endif // QSVGFONT_P_H
diff --git a/src/svg/qsvggenerator.cpp b/src/svg/qsvggenerator.cpp
new file mode 100644
index 0000000..d0d73ae
--- /dev/null
+++ b/src/svg/qsvggenerator.cpp
@@ -0,0 +1,1072 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtSvg module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qsvggenerator.h"
+
+#ifndef QT_NO_SVGGENERATOR
+
+#include "qpainterpath.h"
+
+#include "private/qpaintengine_p.h"
+#include "private/qtextengine_p.h"
+#include "private/qdrawhelper_p.h"
+
+#include "qfile.h"
+#include "qtextcodec.h"
+#include "qtextstream.h"
+#include "qbuffer.h"
+#include "qmath.h"
+
+#include "qdebug.h"
+
+QT_BEGIN_NAMESPACE
+
+static void translate_color(const QColor &color, QString *color_string,
+                            QString *opacity_string)
+{
+    Q_ASSERT(color_string);
+    Q_ASSERT(opacity_string);
+
+    *color_string =
+        QString::fromLatin1("#%1%2%3")
+        .arg(color.red(), 2, 16, QLatin1Char('0'))
+        .arg(color.green(), 2, 16, QLatin1Char('0'))
+        .arg(color.blue(), 2, 16, QLatin1Char('0'));
+    *opacity_string = QString::number(color.alphaF());
+}
+
+static void translate_dashPattern(QVector<qreal> pattern, const qreal& width, QString *pattern_string)
+{
+    Q_ASSERT(pattern_string);
+
+    // Note that SVG operates in absolute lengths, whereas Qt uses a length/width ratio.
+    foreach (qreal entry, pattern)
+        *pattern_string += QString::fromLatin1("%1,").arg(entry * width);
+
+    pattern_string->chop(1);
+}
+
+class QSvgPaintEnginePrivate : public QPaintEnginePrivate
+{
+public:
+    QSvgPaintEnginePrivate()
+    {
+        size = QSize();
+        viewBox = QRectF();
+        outputDevice = 0;
+        resolution = 72;
+
+        attributes.document_title = QLatin1String("Qt Svg Document");
+        attributes.document_description = QLatin1String("Generated with Qt");
+        attributes.font_family = QLatin1String("serif");
+        attributes.font_size = QLatin1String("10pt");
+        attributes.font_style = QLatin1String("normal");
+        attributes.font_weight = QLatin1String("normal");
+
+        afterFirstUpdate = false;
+        numGradients = 0;
+    }
+
+    QSize size;
+    QRectF viewBox;
+    QIODevice *outputDevice;
+    QTextStream *stream;
+    int resolution;
+
+    QString header;
+    QString defs;
+    QString body;
+    bool    afterFirstUpdate;
+
+    QBrush brush;
+    QPen pen;
+    QMatrix matrix;
+    QFont font;
+
+    QString generateGradientName() {
+        ++numGradients;
+        currentGradientName = QString::fromLatin1("gradient%1").arg(numGradients);
+        return currentGradientName;
+    }
+
+    QString currentGradientName;
+    int numGradients;
+
+    struct _attributes {
+        QString document_title;
+        QString document_description;
+        QString font_weight;
+        QString font_size;
+        QString font_family;
+        QString font_style;
+        QString stroke, strokeOpacity;
+        QString dashPattern, dashOffset;
+        QString fill, fillOpacity;
+    } attributes;
+};
+
+static inline QPaintEngine::PaintEngineFeatures svgEngineFeatures()
+{
+    return QPaintEngine::PaintEngineFeatures(
+        QPaintEngine::AllFeatures
+        & ~QPaintEngine::PatternBrush
+        & ~QPaintEngine::PerspectiveTransform
+        & ~QPaintEngine::ConicalGradientFill
+        & ~QPaintEngine::PorterDuff);
+}
+
+class QSvgPaintEngine : public QPaintEngine
+{
+    Q_DECLARE_PRIVATE(QSvgPaintEngine)
+public:
+
+    QSvgPaintEngine()
+        : QPaintEngine(*new QSvgPaintEnginePrivate,
+                       svgEngineFeatures())
+    {
+    }
+
+    bool begin(QPaintDevice *device);
+    bool end();
+
+    void updateState(const QPaintEngineState &state);
+    void popGroup();
+
+    void drawPath(const QPainterPath &path);
+    void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr);
+    void drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode);
+    void drawTextItem(const QPointF &pt, const QTextItem &item);
+    void drawImage(const QRectF &r, const QImage &pm, const QRectF &sr,
+                   Qt::ImageConversionFlag = Qt::AutoColor);
+
+    QPaintEngine::Type type() const { return QPaintEngine::SVG; }
+
+    QSize size() const { return d_func()->size; }
+    void setSize(const QSize &size) {
+        Q_ASSERT(!isActive());
+        d_func()->size = size;
+    }
+
+    QRectF viewBox() const { return d_func()->viewBox; }
+    void setViewBox(const QRectF &viewBox) {
+        Q_ASSERT(!isActive());
+        d_func()->viewBox = viewBox;
+    }
+
+    QString documentTitle() const { return d_func()->attributes.document_title; }
+    void setDocumentTitle(const QString &title) {
+        d_func()->attributes.document_title = title;
+    }
+
+    QString documentDescription() const { return d_func()->attributes.document_description; }
+    void setDocumentDescription(const QString &description) {
+        d_func()->attributes.document_description = description;
+    }
+
+    QIODevice *outputDevice() const { return d_func()->outputDevice; }
+    void setOutputDevice(QIODevice *device) {
+        Q_ASSERT(!isActive());
+        d_func()->outputDevice = device;
+    }
+
+    int resolution() { return d_func()->resolution; }
+    void setResolution(int resolution) {
+        Q_ASSERT(!isActive());
+        d_func()->resolution = resolution;
+    }
+    void saveLinearGradientBrush(const QGradient *g)
+    {
+        QTextStream str(&d_func()->defs, QIODevice::Append);
+        const QLinearGradient *grad = static_cast<const QLinearGradient*>(g);
+        str << QLatin1String("<linearGradient ");
+        saveGradientUnits(str, g);
+        if (grad) {
+            str << QLatin1String("x1=\"") <<grad->start().x()<< QLatin1String("\" ")
+                << QLatin1String("y1=\"") <<grad->start().y()<< QLatin1String("\" ")
+                << QLatin1String("x2=\"") <<grad->finalStop().x() << QLatin1String("\" ")
+                << QLatin1String("y2=\"") <<grad->finalStop().y() << QLatin1String("\" ");
+        }
+
+        str << QLatin1String("id=\"") << d_func()->generateGradientName() << QLatin1String("\">\n");
+        saveGradientStops(str, g);
+        str << QLatin1String("</linearGradient>") <<endl;
+    }
+    void saveRadialGradientBrush(const QGradient *g)
+    {
+        QTextStream str(&d_func()->defs, QIODevice::Append);
+        const QRadialGradient *grad = static_cast<const QRadialGradient*>(g);
+        str << QLatin1String("<radialGradient ");
+        saveGradientUnits(str, g);
+        if (grad) {
+            str << QLatin1String("cx=\"") <<grad->center().x()<< QLatin1String("\" ")
+                << QLatin1String("cy=\"") <<grad->center().y()<< QLatin1String("\" ")
+                << QLatin1String("r=\"") <<grad->radius() << QLatin1String("\" ")
+                << QLatin1String("fx=\"") <<grad->focalPoint().x() << QLatin1String("\" ")
+                << QLatin1String("fy=\"") <<grad->focalPoint().y() << QLatin1String("\" ");
+        }
+        str << QLatin1String("xml:id=\"") <<d_func()->generateGradientName()<< QLatin1String("\">\n");
+        saveGradientStops(str, g);
+        str << QLatin1String("</radialGradient>") << endl;
+    }
+    void saveConicalGradientBrush(const QGradient *)
+    {
+        qWarning("svg's don't support conical gradients!");
+    }
+
+    void saveGradientStops(QTextStream &str, const QGradient *g) {
+        QGradientStops stops = g->stops();
+
+        if (g->interpolationMode() == QGradient::ColorInterpolation) {
+            bool constantAlpha = true;
+            int alpha = stops.at(0).second.alpha();
+            for (int i = 1; i < stops.size(); ++i)
+                constantAlpha &= (stops.at(i).second.alpha() == alpha);
+
+            if (!constantAlpha) {
+                const qreal spacing = qreal(0.02);
+                QGradientStops newStops;
+                QRgb fromColor = PREMUL(stops.at(0).second.rgba());
+                QRgb toColor;
+                for (int i = 0; i + 1 < stops.size(); ++i) {
+                    int parts = qCeil((stops.at(i + 1).first - stops.at(i).first) / spacing);
+                    newStops.append(stops.at(i));
+                    toColor = PREMUL(stops.at(i + 1).second.rgba());
+
+                    if (parts > 1) {
+                        qreal step = (stops.at(i + 1).first - stops.at(i).first) / parts;
+                        for (int j = 1; j < parts; ++j) {
+                            QRgb color = INV_PREMUL(INTERPOLATE_PIXEL_256(fromColor, 256 - 256 * j / parts, toColor, 256 * j / parts));
+                            newStops.append(QGradientStop(stops.at(i).first + j * step, QColor::fromRgba(color)));
+                        }
+                    }
+                    fromColor = toColor;
+                }
+                newStops.append(stops.back());
+                stops = newStops;
+            }
+        }
+
+        foreach(QGradientStop stop, stops) {
+            QString color =
+                QString::fromLatin1("#%1%2%3")
+                .arg(stop.second.red(), 2, 16, QLatin1Char('0'))
+                .arg(stop.second.green(), 2, 16, QLatin1Char('0'))
+                .arg(stop.second.blue(), 2, 16, QLatin1Char('0'));
+            str << QLatin1String("    <stop offset=\"")<< stop.first << QLatin1String("\" ")
+                << QLatin1String("stop-color=\"") << color << QLatin1String("\" ")
+                << QLatin1String("stop-opacity=\"") << stop.second.alphaF() <<QLatin1String("\" />\n");
+        }
+    }
+
+    void saveGradientUnits(QTextStream &str, const QGradient *gradient)
+    {
+        str << QLatin1String("gradientUnits=\"");
+        if (gradient && gradient->coordinateMode() == QGradient::ObjectBoundingMode)
+            str << QLatin1String("objectBoundingBox");
+        else
+            str << QLatin1String("userSpaceOnUse");
+        str << QLatin1String("\" ");
+    }
+
+    void generateQtDefaults()
+    {
+        *d_func()->stream << QLatin1String("fill=\"none\" ");
+        *d_func()->stream << QLatin1String("stroke=\"black\" ");
+        *d_func()->stream << QLatin1String("stroke-width=\"1\" ");
+        *d_func()->stream << QLatin1String("fill-rule=\"evenodd\" ");
+        *d_func()->stream << QLatin1String("stroke-linecap=\"square\" ");
+        *d_func()->stream << QLatin1String("stroke-linejoin=\"bevel\" ");
+        *d_func()->stream << QLatin1String(">\n");
+    }
+    inline QTextStream &stream()
+    {
+        return *d_func()->stream;
+    }
+
+
+    void qpenToSvg(const QPen &spen)
+    {
+        QString width;
+
+        d_func()->pen = spen;
+
+        switch (spen.style()) {
+        case Qt::NoPen:
+            stream() << QLatin1String("stroke=\"none\" ");
+
+            d_func()->attributes.stroke = QLatin1String("none");
+            d_func()->attributes.strokeOpacity = QString();
+            return;
+            break;
+        case Qt::SolidLine: {
+            QString color, colorOpacity;
+
+            translate_color(spen.color(), &color,
+                            &colorOpacity);
+            d_func()->attributes.stroke = color;
+            d_func()->attributes.strokeOpacity = colorOpacity;
+
+            stream() << QLatin1String("stroke=\"")<<color<< QLatin1String("\" ");
+            stream() << QLatin1String("stroke-opacity=\"")<<colorOpacity<< QLatin1String("\" ");
+        }
+            break;
+        case Qt::DashLine:
+        case Qt::DotLine:
+        case Qt::DashDotLine:
+        case Qt::DashDotDotLine:
+        case Qt::CustomDashLine: {
+            QString color, colorOpacity, dashPattern, dashOffset;
+
+            qreal penWidth = spen.width() == 0 ? qreal(1) : spen.widthF();
+
+            translate_color(spen.color(), &color, &colorOpacity);
+            translate_dashPattern(spen.dashPattern(), penWidth, &dashPattern);
+
+            // SVG uses absolute offset
+            dashOffset = QString::number(spen.dashOffset() * penWidth);
+
+            d_func()->attributes.stroke = color;
+            d_func()->attributes.strokeOpacity = colorOpacity;
+            d_func()->attributes.dashPattern = dashPattern;
+            d_func()->attributes.dashOffset = dashOffset;
+
+            stream() << QLatin1String("stroke=\"")<<color<< QLatin1String("\" ");
+            stream() << QLatin1String("stroke-opacity=\"")<<colorOpacity<< QLatin1String("\" ");
+            stream() << QLatin1String("stroke-dasharray=\"")<<dashPattern<< QLatin1String("\" ");
+            stream() << QLatin1String("stroke-dashoffset=\"")<<dashOffset<< QLatin1String("\" ");
+            break;
+        }
+        default:
+            qWarning("Unsupported pen style");
+            break;
+        }
+
+        if (spen.widthF() == 0)
+            stream() <<"stroke-width=\"1\" ";
+        else
+            stream() <<"stroke-width=\"" << spen.widthF() << "\" ";
+
+        switch (spen.capStyle()) {
+        case Qt::FlatCap:
+            stream() << "stroke-linecap=\"butt\" ";
+            break;
+        case Qt::SquareCap:
+            stream() << "stroke-linecap=\"square\" ";
+            break;
+        case Qt::RoundCap:
+            stream() << "stroke-linecap=\"round\" ";
+            break;
+        default:
+            qWarning("Unhandled cap style");
+        }
+        switch (spen.joinStyle()) {
+        case Qt::MiterJoin:
+            stream() << "stroke-linejoin=\"miter\" "
+                        "stroke-miterlimit=\""<<spen.miterLimit()<<"\" ";
+            break;
+        case Qt::BevelJoin:
+            stream() << "stroke-linejoin=\"bevel\" ";
+            break;
+        case Qt::RoundJoin:
+            stream() << "stroke-linejoin=\"round\" ";
+            break;
+        case Qt::SvgMiterJoin:
+            stream() << "stroke-linejoin=\"miter\" "
+                        "stroke-miterlimit=\""<<spen.miterLimit()<<"\" ";
+            break;
+        default:
+            qWarning("Unhandled join style");
+        }
+    }
+    void qbrushToSvg(const QBrush &sbrush)
+    {
+        d_func()->brush = sbrush;
+        switch (sbrush.style()) {
+        case Qt::SolidPattern: {
+            QString color, colorOpacity;
+            translate_color(sbrush.color(), &color, &colorOpacity);
+            stream() << "fill=\"" << color << "\" "
+                        "fill-opacity=\""
+                     << colorOpacity << "\" ";
+            d_func()->attributes.fill = color;
+            d_func()->attributes.fillOpacity = colorOpacity;
+        }
+            break;
+        case Qt::LinearGradientPattern:
+            saveLinearGradientBrush(sbrush.gradient());
+            d_func()->attributes.fill = QString::fromLatin1("url(#%1)").arg(d_func()->currentGradientName);
+            d_func()->attributes.fillOpacity = QString();
+            stream() << QLatin1String("fill=\"url(#") << d_func()->currentGradientName << QLatin1String(")\" ");
+            break;
+        case Qt::RadialGradientPattern:
+            saveRadialGradientBrush(sbrush.gradient());
+            d_func()->attributes.fill = QString::fromLatin1("url(#%1)").arg(d_func()->currentGradientName);
+            d_func()->attributes.fillOpacity = QString();
+            stream() << QLatin1String("fill=\"url(#") << d_func()->currentGradientName << QLatin1String(")\" ");
+            break;
+        case Qt::ConicalGradientPattern:
+            saveConicalGradientBrush(sbrush.gradient());
+            d_func()->attributes.fill = QString::fromLatin1("url(#%1)").arg(d_func()->currentGradientName);
+            d_func()->attributes.fillOpacity = QString();
+            stream() << QLatin1String("fill=\"url(#") << d_func()->currentGradientName << QLatin1String(")\" ");
+            break;
+        case Qt::NoBrush:
+            stream() << QLatin1String("fill=\"none\" ");
+            d_func()->attributes.fill = QLatin1String("none");
+            d_func()->attributes.fillOpacity = QString();
+            return;
+            break;
+        default:
+           break;
+        }
+    }
+    void qfontToSvg(const QFont &sfont)
+    {
+        Q_D(QSvgPaintEngine);
+
+        d->font = sfont;
+
+        if (d->font.pixelSize() == -1)
+            d->attributes.font_size = QString::number(d->font.pointSizeF() * d->resolution / 72);
+        else
+            d->attributes.font_size = QString::number(d->font.pixelSize());
+
+        int svgWeight = d->font.weight();
+        switch (svgWeight) {
+        case QFont::Light:
+            svgWeight = 100;
+            break;
+        case QFont::Normal:
+            svgWeight = 400;
+            break;
+        case QFont::Bold:
+            svgWeight = 700;
+            break;
+        default:
+            svgWeight *= 10;
+        }
+
+        d->attributes.font_weight = QString::number(svgWeight);
+        d->attributes.font_family = d->font.family();
+        d->attributes.font_style = d->font.italic() ? QLatin1String("italic") : QLatin1String("normal");
+
+        *d->stream << "font-family=\"" << d->attributes.font_family << "\" "
+                      "font-size=\"" << d->attributes.font_size << "\" "
+                      "font-weight=\"" << d->attributes.font_weight << "\" "
+                      "font-style=\"" << d->attributes.font_style << "\" "
+                   << endl;
+    }
+};
+
+class QSvgGeneratorPrivate
+{
+public:
+    QSvgPaintEngine *engine;
+
+    uint owns_iodevice : 1;
+    QString fileName;
+};
+
+/*!
+    \class QSvgGenerator
+    \ingroup painting
+    \since 4.3
+    \brief The QSvgGenerator class provides a paint device that is used to create SVG drawings.
+    \reentrant
+
+    This paint device represents a Scalable Vector Graphics (SVG) drawing. Like QPrinter, it is
+    designed as a write-only device that generates output in a specific format.
+
+    To write an SVG file, you first need to configure the output by setting the \l fileName
+    or \l outputDevice properties. It is usually necessary to specify the size of the drawing
+    by setting the \l size property, and in some cases where the drawing will be included in
+    another, the \l viewBox property also needs to be set.
+
+    \snippet examples/painting/svggenerator/window.cpp configure SVG generator
+
+    Other meta-data can be specified by setting the \a title, \a description and \a resolution
+    properties.
+
+    As with other QPaintDevice subclasses, a QPainter object is used to paint onto an instance
+    of this class:
+
+    \snippet examples/painting/svggenerator/window.cpp begin painting
+    \dots
+    \snippet examples/painting/svggenerator/window.cpp end painting
+
+    Painting is performed in the same way as for any other paint device. However,
+    it is necessary to use the QPainter::begin() and \l{QPainter::}{end()} to
+    explicitly begin and end painting on the device.
+
+    The \l{SVG Generator Example} shows how the same painting commands can be used
+    for painting a widget and writing an SVG file.
+
+    \sa QSvgRenderer, QSvgWidget, {About SVG}
+*/
+
+/*!
+    Constructs a new generator.
+*/
+QSvgGenerator::QSvgGenerator()
+    : d_ptr(new QSvgGeneratorPrivate)
+{
+    Q_D(QSvgGenerator);
+
+    d->engine = new QSvgPaintEngine;
+    d->owns_iodevice = false;
+}
+
+/*!
+    Destroys the generator.
+*/
+QSvgGenerator::~QSvgGenerator()
+{
+    Q_D(QSvgGenerator);
+    if (d->owns_iodevice)
+        delete d->engine->outputDevice();
+    delete d->engine;
+}
+
+/*!
+    \property QSvgGenerator::title
+    \brief the title of the generated SVG drawing
+    \since 4.5
+    \sa description
+*/
+QString QSvgGenerator::title() const
+{
+    Q_D(const QSvgGenerator);
+
+    return d->engine->documentTitle();
+}
+
+void QSvgGenerator::setTitle(const QString &title)
+{
+    Q_D(QSvgGenerator);
+
+    d->engine->setDocumentTitle(title);
+}
+
+/*!
+    \property QSvgGenerator::description
+    \brief the description of the generated SVG drawing
+    \since 4.5
+    \sa title
+*/
+QString QSvgGenerator::description() const
+{
+    Q_D(const QSvgGenerator);
+
+    return d->engine->documentDescription();
+}
+
+void QSvgGenerator::setDescription(const QString &description)
+{
+    Q_D(QSvgGenerator);
+
+    d->engine->setDocumentDescription(description);
+}
+
+/*!
+    \property QSvgGenerator::size
+    \brief the size of the generated SVG drawing
+    \since 4.5
+
+    By default this property is set to \c{QSize(-1, -1)}, which
+    indicates that the generator should not output the width and
+    height attributes of the \c<svg> element.
+
+    \note It is not possible to change this property while a
+    QPainter is active on the generator.
+
+    \sa viewBox, resolution
+*/
+QSize QSvgGenerator::size() const
+{
+    Q_D(const QSvgGenerator);
+    return d->engine->size();
+}
+
+void QSvgGenerator::setSize(const QSize &size)
+{
+    Q_D(QSvgGenerator);
+    if (d->engine->isActive()) {
+        qWarning("QSvgGenerator::setSize(), cannot set size while SVG is being generated");
+        return;
+    }
+    d->engine->setSize(size);
+}
+
+/*!
+    \property QSvgGenerator::viewBox
+    \brief the viewBox of the generated SVG drawing
+    \since 4.5
+
+    By default this property is set to \c{QRect(0, 0, -1, -1)}, which
+    indicates that the generator should not output the viewBox attribute
+    of the \c<svg> element.
+
+    \note It is not possible to change this property while a
+    QPainter is active on the generator.
+
+    \sa viewBox(), size, resolution
+*/
+QRectF QSvgGenerator::viewBoxF() const
+{
+    Q_D(const QSvgGenerator);
+    return d->engine->viewBox();
+}
+
+/*!
+    \since 4.5
+
+    Returns viewBoxF().toRect().
+
+    \sa viewBoxF()
+*/
+QRect QSvgGenerator::viewBox() const
+{
+    Q_D(const QSvgGenerator);
+    return d->engine->viewBox().toRect();
+}
+
+void QSvgGenerator::setViewBox(const QRectF &viewBox)
+{
+    Q_D(QSvgGenerator);
+    if (d->engine->isActive()) {
+        qWarning("QSvgGenerator::setViewBox(), cannot set viewBox while SVG is being generated");
+        return;
+    }
+    d->engine->setViewBox(viewBox);
+}
+
+void QSvgGenerator::setViewBox(const QRect &viewBox)
+{
+    setViewBox(QRectF(viewBox));
+}
+
+/*!
+    \property QSvgGenerator::fileName
+    \brief the target filename for the generated SVG drawing
+    \since 4.5
+
+    \sa outputDevice
+*/
+QString QSvgGenerator::fileName() const
+{
+    Q_D(const QSvgGenerator);
+    return d->fileName;
+}
+
+void QSvgGenerator::setFileName(const QString &fileName)
+{
+    Q_D(QSvgGenerator);
+    if (d->engine->isActive()) {
+        qWarning("QSvgGenerator::setFileName(), cannot set file name while SVG is being generated");
+        return;
+    }
+
+    if (d->owns_iodevice)
+        delete d->engine->outputDevice();
+
+    d->owns_iodevice = true;
+
+    d->fileName = fileName;
+    QFile *file = new QFile(fileName);
+    d->engine->setOutputDevice(file);
+}
+
+/*!
+    \property QSvgGenerator::outputDevice
+    \brief the output device for the generated SVG drawing
+    \since 4.5
+
+    If both output device and file name are specified, the output device
+    will have precedence.
+
+    \sa fileName
+*/
+QIODevice *QSvgGenerator::outputDevice() const
+{
+    Q_D(const QSvgGenerator);
+    return d->engine->outputDevice();
+}
+
+void QSvgGenerator::setOutputDevice(QIODevice *outputDevice)
+{
+    Q_D(QSvgGenerator);
+    if (d->engine->isActive()) {
+        qWarning("QSvgGenerator::setOutputDevice(), cannot set output device while SVG is being generated");
+        return;
+    }
+    d->owns_iodevice = false;
+    d->engine->setOutputDevice(outputDevice);
+    d->fileName = QString();
+}
+
+/*!
+    \property QSvgGenerator::resolution
+    \brief the resolution of the generated output
+    \since 4.5
+
+    The resolution is specified in dots per inch, and is used to
+    calculate the physical size of an SVG drawing.
+
+    \sa size, viewBox
+*/
+int QSvgGenerator::resolution() const
+{
+    Q_D(const QSvgGenerator);
+    return d->engine->resolution();
+}
+
+void QSvgGenerator::setResolution(int dpi)
+{
+    Q_D(QSvgGenerator);
+    d->engine->setResolution(dpi);
+}
+
+/*!
+    Returns the paint engine used to render graphics to be converted to SVG
+    format information.
+*/
+QPaintEngine *QSvgGenerator::paintEngine() const
+{
+    Q_D(const QSvgGenerator);
+    return d->engine;
+}
+
+/*!
+    \reimp
+*/
+int QSvgGenerator::metric(QPaintDevice::PaintDeviceMetric metric) const
+{
+    Q_D(const QSvgGenerator);
+    switch (metric) {
+    case QPaintDevice::PdmDepth:
+        return 32;
+    case QPaintDevice::PdmWidth:
+        return d->engine->size().width();
+    case QPaintDevice::PdmHeight:
+        return d->engine->size().height();
+    case QPaintDevice::PdmDpiX:
+        return d->engine->resolution();
+    case QPaintDevice::PdmDpiY:
+        return d->engine->resolution();
+    case QPaintDevice::PdmHeightMM:
+        return qRound(d->engine->size().height() * 25.4 / d->engine->resolution());
+    case QPaintDevice::PdmWidthMM:
+        return qRound(d->engine->size().width() * 25.4 / d->engine->resolution());
+    case QPaintDevice::PdmNumColors:
+        return 0xffffffff;
+    case QPaintDevice::PdmPhysicalDpiX:
+        return d->engine->resolution();
+    case QPaintDevice::PdmPhysicalDpiY:
+        return d->engine->resolution();
+    default:
+        qWarning("QSvgGenerator::metric(), unhandled metric %d\n", metric);
+        break;
+    }
+    return 0;
+}
+
+/*****************************************************************************
+ * class QSvgPaintEngine
+ */
+
+bool QSvgPaintEngine::begin(QPaintDevice *)
+{
+    Q_D(QSvgPaintEngine);
+    if (!d->outputDevice) {
+        qWarning("QSvgPaintEngine::begin(), no output device");
+        return false;
+    }
+
+    if (!d->outputDevice->isOpen()) {
+        if (!d->outputDevice->open(QIODevice::WriteOnly | QIODevice::Text)) {
+            qWarning("QSvgPaintEngine::begin(), could not open output device: '%s'",
+                     qPrintable(d->outputDevice->errorString()));
+            return false;
+        }
+    } else if (!d->outputDevice->isWritable()) {
+        qWarning("QSvgPaintEngine::begin(), could not write to read-only output device: '%s'",
+                 qPrintable(d->outputDevice->errorString()));
+        return false;
+    }
+
+    d->stream = new QTextStream(&d->header);
+
+    // stream out the header...
+    *d->stream << "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>" << endl << "<svg";
+
+    if (d->size.isValid()) {
+        qreal wmm = d->size.width() * 25.4 / d->resolution;
+        qreal hmm = d->size.height() * 25.4 / d->resolution;
+        *d->stream << " width=\"" << wmm << "mm\" height=\"" << hmm << "mm\"" << endl;
+    }
+
+    if (d->viewBox.isValid()) {
+        *d->stream << " viewBox=\"" << d->viewBox.left() << ' ' << d->viewBox.top();
+        *d->stream << ' ' << d->viewBox.width() << ' ' << d->viewBox.height() << '\"' << endl;
+    }
+
+    *d->stream << " xmlns=\"http://www.w3.org/2000/svg\""
+                  " xmlns:xlink=\"http://www.w3.org/1999/xlink\" "
+                  " version=\"1.2\" baseProfile=\"tiny\">" << endl;
+
+    if (!d->attributes.document_title.isEmpty()) {
+        *d->stream << "<title>" << d->attributes.document_title << "</title>" << endl;
+    }
+
+    if (!d->attributes.document_description.isEmpty()) {
+        *d->stream << "<desc>" << d->attributes.document_description << "</desc>" << endl;
+    }
+
+    d->stream->setString(&d->defs);
+    *d->stream << "<defs>\n";
+
+    d->stream->setString(&d->body);
+    // Start the initial graphics state...
+    *d->stream << "<g ";
+    generateQtDefaults();
+    *d->stream << endl;
+
+    return true;
+}
+
+bool QSvgPaintEngine::end()
+{
+    Q_D(QSvgPaintEngine);
+
+    d->stream->setString(&d->defs);
+    *d->stream << "</defs>\n";
+
+    d->stream->setDevice(d->outputDevice);
+#ifndef QT_NO_TEXTCODEC
+    d->stream->setCodec(QTextCodec::codecForName("UTF-8"));
+#endif
+
+    *d->stream << d->header;
+    *d->stream << d->defs;
+    *d->stream << d->body;
+    if (d->afterFirstUpdate)
+        *d->stream << "</g>" << endl; // close the updateState
+
+    *d->stream << "</g>" << endl // close the Qt defaults
+               << "</svg>" << endl;
+
+    delete d->stream;
+
+    return true;
+}
+
+void QSvgPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pm,
+                                 const QRectF &sr)
+{
+    drawImage(r, pm.toImage(), sr);
+}
+
+void QSvgPaintEngine::drawImage(const QRectF &r, const QImage &image,
+                                const QRectF &sr,
+                                Qt::ImageConversionFlag flags)
+{
+    //Q_D(QSvgPaintEngine);
+
+    Q_UNUSED(sr);
+    Q_UNUSED(flags);
+    stream() << "<image ";
+    stream() << "x=\""<<r.x()<<"\" "
+                "y=\""<<r.y()<<"\" "
+                "width=\""<<r.width()<<"\" "
+                "height=\""<<r.height()<<"\" "
+                "preserveAspectRatio=\"none\" ";
+
+    QByteArray data;
+    QBuffer buffer(&data);
+    buffer.open(QBuffer::ReadWrite);
+    image.save(&buffer, "PNG");
+    buffer.close();
+    stream() << "xlink:href=\"data:image/png;base64,"
+             << data.toBase64()
+             <<"\" />\n";
+}
+
+void QSvgPaintEngine::updateState(const QPaintEngineState &state)
+{
+    Q_D(QSvgPaintEngine);
+    QPaintEngine::DirtyFlags flags = state.state();
+
+    // always stream full gstate, which is not required, but...
+    flags |= QPaintEngine::AllDirty;
+
+    // close old state and start a new one...
+    if (d->afterFirstUpdate)
+        *d->stream << "</g>\n\n";
+
+    *d->stream << "<g ";
+
+    if (flags & QPaintEngine::DirtyBrush) {
+        qbrushToSvg(state.brush());
+    }
+
+    if (flags & QPaintEngine::DirtyPen) {
+        qpenToSvg(state.pen());
+    }
+
+    if (flags & QPaintEngine::DirtyTransform) {
+        d->matrix = state.matrix();
+        *d->stream << "transform=\"matrix(" << d->matrix.m11() << ','
+                   << d->matrix.m12() << ','
+                   << d->matrix.m21() << ',' << d->matrix.m22() << ','
+                   << d->matrix.dx() << ',' << d->matrix.dy()
+                   << ")\""
+                   << endl;
+    }
+
+    if (flags & QPaintEngine::DirtyFont) {
+        qfontToSvg(state.font());
+    }
+
+    if (flags & QPaintEngine::DirtyOpacity) {
+        if (!qFuzzyIsNull(state.opacity() - 1))
+            stream() << "opacity=\""<<state.opacity()<<"\" ";
+    }
+
+    *d->stream << '>' << endl;
+
+    d->afterFirstUpdate = true;
+}
+
+void QSvgPaintEngine::drawPath(const QPainterPath &p)
+{
+    Q_D(QSvgPaintEngine);
+
+    *d->stream << "<path vector-effect=\""
+               << (state->pen().isCosmetic() ? "non-scaling-stroke" : "none")
+               << "\" fill-rule=\""
+               << (p.fillRule() == Qt::OddEvenFill ? "evenodd" : "nonzero")
+               << "\" d=\"";
+
+    for (int i=0; i<p.elementCount(); ++i) {
+        const QPainterPath::Element &e = p.elementAt(i);
+        switch (e.type) {
+        case QPainterPath::MoveToElement:
+            *d->stream << 'M' << e.x << ',' << e.y;
+            break;
+        case QPainterPath::LineToElement:
+            *d->stream << 'L' << e.x << ',' << e.y;
+            break;
+        case QPainterPath::CurveToElement:
+            *d->stream << 'C' << e.x << ',' << e.y;
+            ++i;
+            while (i < p.elementCount()) {
+                const QPainterPath::Element &e = p.elementAt(i);
+                if (e.type != QPainterPath::CurveToDataElement) {
+                    --i;
+                    break;
+                } else
+                    *d->stream << ' ';
+                *d->stream << e.x << ',' << e.y;
+                ++i;
+            }
+            break;
+        default:
+            break;
+        }
+        if (i != p.elementCount() - 1) {
+            *d->stream << ' ';
+        }
+    }
+
+    *d->stream << "\"/>" << endl;
+}
+
+void QSvgPaintEngine::drawPolygon(const QPointF *points, int pointCount,
+                                  PolygonDrawMode mode)
+{
+    Q_ASSERT(pointCount >= 2);
+
+    //Q_D(QSvgPaintEngine);
+
+    QPainterPath path(points[0]);
+    for (int i=1; i<pointCount; ++i)
+        path.lineTo(points[i]);
+
+    if (mode == PolylineMode) {
+        stream() << "<polyline fill=\"none\" vector-effect=\""
+                 << (state->pen().isCosmetic() ? "non-scaling-stroke" : "none")
+                 << "\" points=\"";
+        for (int i = 0; i < pointCount; ++i) {
+            const QPointF &pt = points[i];
+            stream() << pt.x() << ',' << pt.y() << ' ';
+        }
+        stream() << "\" />" <<endl;
+    } else {
+        path.closeSubpath();
+        drawPath(path);
+    }
+}
+
+void QSvgPaintEngine::drawTextItem(const QPointF &pt, const QTextItem &textItem)
+{
+    Q_D(QSvgPaintEngine);
+    if (d->pen.style() == Qt::NoPen)
+        return;
+
+    const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
+    QString s = QString::fromRawData(ti.chars, ti.num_chars);
+
+    *d->stream << "<text "
+                  "fill=\"" << d->attributes.stroke << "\" "
+                  "fill-opacity=\"" << d->attributes.strokeOpacity << "\" "
+                  "stroke=\"none\" "
+                  "xml:space=\"preserve\" "
+                  "x=\"" << pt.x() << "\" y=\"" << pt.y() << "\" ";
+    qfontToSvg(textItem.font());
+    *d->stream << " >"
+               << Qt::escape(s)
+               << "</text>"
+               << endl;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SVGGENERATOR
diff --git a/src/svg/qsvggenerator.h b/src/svg/qsvggenerator.h
new file mode 100644
index 0000000..62fc6f8
--- /dev/null
+++ b/src/svg/qsvggenerator.h
@@ -0,0 +1,112 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtSvg module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSVGGENERATOR_H
+#define QSVGGENERATOR_H
+
+#include <QtGui/qpaintdevice.h>
+
+#ifndef QT_NO_SVGGENERATOR
+
+#include <QtCore/qnamespace.h>
+#include <QtCore/qiodevice.h>
+#include <QtCore/qobjectdefs.h>
+#include <QtCore/qscopedpointer.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Svg)
+
+class QSvgGeneratorPrivate;
+
+class Q_SVG_EXPORT QSvgGenerator : public QPaintDevice
+{
+    Q_DECLARE_PRIVATE(QSvgGenerator)
+
+    Q_PROPERTY(QSize size READ size WRITE setSize)
+    Q_PROPERTY(QRectF viewBox READ viewBoxF WRITE setViewBox)
+    Q_PROPERTY(QString title READ title WRITE setTitle)
+    Q_PROPERTY(QString description READ description WRITE setDescription)
+    Q_PROPERTY(QString fileName READ fileName WRITE setFileName)
+    Q_PROPERTY(QIODevice* outputDevice READ outputDevice WRITE setOutputDevice)
+    Q_PROPERTY(int resolution READ resolution WRITE setResolution)
+public:
+    QSvgGenerator();
+    ~QSvgGenerator();
+
+    QString title() const;
+    void setTitle(const QString &title);
+
+    QString description() const;
+    void setDescription(const QString &description);
+
+    QSize size() const;
+    void setSize(const QSize &size);
+
+    QRect viewBox() const;
+    QRectF viewBoxF() const;
+    void setViewBox(const QRect &viewBox);
+    void setViewBox(const QRectF &viewBox);
+
+    QString fileName() const;
+    void setFileName(const QString &fileName);
+
+    QIODevice *outputDevice() const;
+    void setOutputDevice(QIODevice *outputDevice);
+
+    void setResolution(int dpi);
+    int resolution() const;
+protected:
+    QPaintEngine *paintEngine() const;
+    int metric(QPaintDevice::PaintDeviceMetric metric) const;
+
+private:
+    QScopedPointer<QSvgGeneratorPrivate> d_ptr;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QT_NO_SVGGENERATOR
+#endif // QSVGGENERATOR_H
diff --git a/src/svg/qsvggraphics.cpp b/src/svg/qsvggraphics.cpp
new file mode 100644
index 0000000..0cfa2ed
--- /dev/null
+++ b/src/svg/qsvggraphics.cpp
@@ -0,0 +1,615 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtSvg module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qsvggraphics_p.h"
+
+#ifndef QT_NO_SVG
+
+#include "qsvgfont_p.h"
+
+#include "qpainter.h"
+#include "qtextdocument.h"
+#include "qabstracttextdocumentlayout.h"
+#include "qtextcursor.h"
+#include "qdebug.h"
+
+#include <math.h>
+#include <limits.h>
+
+QT_BEGIN_NAMESPACE
+
+#define QT_SVG_DRAW_SHAPE(command)                          \
+    qreal oldOpacity = p->opacity();                        \
+    QBrush oldBrush = p->brush();                           \
+    QPen oldPen = p->pen();                                 \
+    p->setPen(Qt::NoPen);                                   \
+    p->setOpacity(oldOpacity * states.fillOpacity);         \
+    command;                                                \
+    p->setPen(oldPen);                                      \
+    if (oldPen.widthF() != 0) {                             \
+        p->setOpacity(oldOpacity * states.strokeOpacity);   \
+        p->setBrush(Qt::NoBrush);                           \
+        command;                                            \
+        p->setBrush(oldBrush);                              \
+    }                                                       \
+    p->setOpacity(oldOpacity);
+
+
+void QSvgAnimation::draw(QPainter *, QSvgExtraStates &)
+{
+    qWarning("<animation> no implemented");
+}
+
+static inline QRectF boundsOnStroke(QPainter *p, const QPainterPath &path, qreal width)
+{
+    QPainterPathStroker stroker;
+    stroker.setWidth(width);
+    QPainterPath stroke = stroker.createStroke(path);
+    return p->transform().map(stroke).boundingRect();
+}
+
+QSvgEllipse::QSvgEllipse(QSvgNode *parent, const QRectF &rect)
+    : QSvgNode(parent), m_bounds(rect)
+{
+}
+
+
+QRectF QSvgEllipse::bounds(QPainter *p, QSvgExtraStates &) const
+{
+    QPainterPath path;
+    path.addEllipse(m_bounds);
+    qreal sw = strokeWidth(p);
+    return qFuzzyIsNull(sw) ? p->transform().map(path).boundingRect() : boundsOnStroke(p, path, sw);
+}
+
+void QSvgEllipse::draw(QPainter *p, QSvgExtraStates &states)
+{
+    applyStyle(p, states);
+    QT_SVG_DRAW_SHAPE(p->drawEllipse(m_bounds));
+    revertStyle(p, states);
+}
+
+QSvgArc::QSvgArc(QSvgNode *parent, const QPainterPath &path)
+    : QSvgNode(parent), m_path(path)
+{
+}
+
+void QSvgArc::draw(QPainter *p, QSvgExtraStates &states)
+{
+    applyStyle(p, states);
+    if (p->pen().widthF() != 0) {
+        qreal oldOpacity = p->opacity();
+        p->setOpacity(oldOpacity * states.strokeOpacity);
+        p->drawPath(m_path);
+        p->setOpacity(oldOpacity);
+    }
+    revertStyle(p, states);
+}
+
+QSvgImage::QSvgImage(QSvgNode *parent, const QImage &image,
+                     const QRect &bounds)
+    : QSvgNode(parent), m_image(image),
+      m_bounds(bounds)
+{
+    if (m_bounds.width() == 0)
+        m_bounds.setWidth(m_image.width());
+    if (m_bounds.height() == 0)
+        m_bounds.setHeight(m_image.height());
+}
+
+void QSvgImage::draw(QPainter *p, QSvgExtraStates &states)
+{
+    applyStyle(p, states);
+    p->drawImage(m_bounds, m_image);
+    revertStyle(p, states);
+}
+
+
+QSvgLine::QSvgLine(QSvgNode *parent, const QLineF &line)
+    : QSvgNode(parent), m_line(line)
+{
+}
+
+
+void QSvgLine::draw(QPainter *p, QSvgExtraStates &states)
+{
+    applyStyle(p, states);
+    if (p->pen().widthF() != 0) {
+        qreal oldOpacity = p->opacity();
+        p->setOpacity(oldOpacity * states.strokeOpacity);
+        p->drawLine(m_line);
+        p->setOpacity(oldOpacity);
+    }
+    revertStyle(p, states);
+}
+
+QSvgPath::QSvgPath(QSvgNode *parent, const QPainterPath &qpath)
+    : QSvgNode(parent), m_path(qpath)
+{
+}
+
+void QSvgPath::draw(QPainter *p, QSvgExtraStates &states)
+{
+    applyStyle(p, states);
+    m_path.setFillRule(states.fillRule);
+    QT_SVG_DRAW_SHAPE(p->drawPath(m_path));
+    revertStyle(p, states);
+}
+
+QRectF QSvgPath::bounds(QPainter *p, QSvgExtraStates &) const
+{
+    qreal sw = strokeWidth(p);
+    return qFuzzyIsNull(sw) ? p->transform().map(m_path).boundingRect()
+        : boundsOnStroke(p, m_path, sw);
+}
+
+QSvgPolygon::QSvgPolygon(QSvgNode *parent, const QPolygonF &poly)
+    : QSvgNode(parent), m_poly(poly)
+{
+}
+
+QRectF QSvgPolygon::bounds(QPainter *p, QSvgExtraStates &) const
+{
+    qreal sw = strokeWidth(p);
+    if (qFuzzyIsNull(sw)) {
+        return p->transform().map(m_poly).boundingRect();
+    } else {
+        QPainterPath path;
+        path.addPolygon(m_poly);
+        return boundsOnStroke(p, path, sw);
+    }
+}
+
+void QSvgPolygon::draw(QPainter *p, QSvgExtraStates &states)
+{
+    applyStyle(p, states);
+    QT_SVG_DRAW_SHAPE(p->drawPolygon(m_poly, states.fillRule));
+    revertStyle(p, states);
+}
+
+
+QSvgPolyline::QSvgPolyline(QSvgNode *parent, const QPolygonF &poly)
+    : QSvgNode(parent), m_poly(poly)
+{
+
+}
+
+void QSvgPolyline::draw(QPainter *p, QSvgExtraStates &states)
+{
+    applyStyle(p, states);
+    qreal oldOpacity = p->opacity();
+    if (p->brush().style() != Qt::NoBrush) {
+        QPen save = p->pen();
+        p->setPen(QPen(Qt::NoPen));
+        p->setOpacity(oldOpacity * states.fillOpacity);
+        p->drawPolygon(m_poly, states.fillRule);
+        p->setPen(save);
+    }
+    if (p->pen().widthF() != 0) {
+        p->setOpacity(oldOpacity * states.strokeOpacity);
+        p->drawPolyline(m_poly);
+    }
+    p->setOpacity(oldOpacity);
+    revertStyle(p, states);
+}
+
+QSvgRect::QSvgRect(QSvgNode *node, const QRectF &rect, int rx, int ry)
+    : QSvgNode(node),
+      m_rect(rect), m_rx(rx), m_ry(ry)
+{
+}
+
+QRectF QSvgRect::bounds(QPainter *p, QSvgExtraStates &) const
+{
+    qreal sw = strokeWidth(p);
+    if (qFuzzyIsNull(sw)) {
+        return p->transform().mapRect(m_rect);
+    } else {
+        QPainterPath path;
+        path.addRect(m_rect);
+        return boundsOnStroke(p, path, sw);
+    }
+}
+
+void QSvgRect::draw(QPainter *p, QSvgExtraStates &states)
+{
+    applyStyle(p, states);
+    if (m_rx || m_ry) {
+        QT_SVG_DRAW_SHAPE(p->drawRoundedRect(m_rect, m_rx, m_ry, Qt::RelativeSize));
+    } else {
+        QT_SVG_DRAW_SHAPE(p->drawRect(m_rect));
+    }
+    revertStyle(p, states);
+}
+
+QSvgTspan * const QSvgText::LINEBREAK = 0;
+
+QSvgText::QSvgText(QSvgNode *parent, const QPointF &coord)
+    : QSvgNode(parent)
+    , m_coord(coord)
+    , m_type(TEXT)
+    , m_size(0, 0)
+    , m_mode(Default)
+{
+}
+
+QSvgText::~QSvgText()
+{
+    for (int i = 0; i < m_tspans.size(); ++i) {
+        if (m_tspans[i] != LINEBREAK)
+            delete m_tspans[i];
+    }
+}
+
+void QSvgText::setTextArea(const QSizeF &size)
+{
+    m_size = size;
+    m_type = TEXTAREA;
+}
+
+//QRectF QSvgText::bounds(QPainter *p, QSvgExtraStates &) const {}
+
+void QSvgText::draw(QPainter *p, QSvgExtraStates &states)
+{
+    applyStyle(p, states);
+    qreal oldOpacity = p->opacity();
+    p->setOpacity(oldOpacity * states.fillOpacity);
+
+    // Force the font to have a size of 100 pixels to avoid truncation problems
+    // when the font is very small.
+    qreal scale = 100.0 / p->font().pointSizeF();
+    Qt::Alignment alignment = states.textAnchor;
+
+    QTransform oldTransform = p->worldTransform();
+    p->scale(1 / scale, 1 / scale);
+
+    qreal y = 0;
+    bool initial = true;
+    qreal px = m_coord.x() * scale;
+    qreal py = m_coord.y() * scale;
+    QSizeF scaledSize = m_size * scale;
+
+    if (m_type == TEXTAREA) {
+        if (alignment == Qt::AlignHCenter)
+            px += scaledSize.width() / 2;
+        else if (alignment == Qt::AlignRight)
+            px += scaledSize.width();
+    }
+
+    QRectF bounds;
+    if (m_size.height() != 0)
+        bounds = QRectF(0, py, 1, scaledSize.height()); // x and width are not used.
+
+    bool appendSpace = false;
+    QVector<QString> paragraphs;
+    QStack<QTextCharFormat> formats;
+    QVector<QList<QTextLayout::FormatRange> > formatRanges;
+    paragraphs.push_back(QString());
+    formatRanges.push_back(QList<QTextLayout::FormatRange>());
+
+    for (int i = 0; i < m_tspans.size(); ++i) {
+        if (m_tspans[i] == LINEBREAK) {
+            if (m_type == TEXTAREA) {
+                if (paragraphs.back().isEmpty()) {
+                    QFont font = p->font();
+                    font.setPixelSize(font.pointSizeF() * scale);
+
+                    QTextLayout::FormatRange range;
+                    range.start = 0;
+                    range.length = 1;
+                    range.format.setFont(font);
+                    formatRanges.back().append(range);
+
+                    paragraphs.back().append(QLatin1Char(' '));;
+                }
+                appendSpace = false;
+                paragraphs.push_back(QString());
+                formatRanges.push_back(QList<QTextLayout::FormatRange>());
+            }
+        } else {
+            WhitespaceMode mode = m_tspans[i]->whitespaceMode();
+            m_tspans[i]->applyStyle(p, states);
+
+            QFont font = p->font();
+            font.setPixelSize(font.pointSizeF() * scale);
+
+            QString newText(m_tspans[i]->text());
+            newText.replace(QLatin1Char('\t'), QLatin1Char(' '));
+            newText.replace(QLatin1Char('\n'), QLatin1Char(' '));
+
+            bool prependSpace = !appendSpace && !m_tspans[i]->isTspan() && (mode == Default) && !paragraphs.back().isEmpty() && newText.startsWith(QLatin1Char(' '));
+            if (appendSpace || prependSpace)
+                paragraphs.back().append(QLatin1Char(' '));
+
+            bool appendSpaceNext = (!m_tspans[i]->isTspan() && (mode == Default) && newText.endsWith(QLatin1Char(' ')));
+
+            if (mode == Default) {
+                newText = newText.simplified();
+                if (newText.isEmpty())
+                    appendSpaceNext = false;
+            }
+
+            QTextLayout::FormatRange range;
+            range.start = paragraphs.back().length();
+            range.length = newText.length();
+            range.format.setFont(font);
+            range.format.setTextOutline(p->pen());
+            range.format.setForeground(p->brush());
+
+            if (appendSpace) {
+                Q_ASSERT(!formatRanges.back().isEmpty());
+                ++formatRanges.back().back().length;
+            } else if (prependSpace) {
+                --range.start;
+                ++range.length;
+            }
+            formatRanges.back().append(range);
+
+            appendSpace = appendSpaceNext;
+            paragraphs.back() += newText;
+
+            m_tspans[i]->revertStyle(p, states);
+        }
+    }
+
+    if (states.svgFont) {
+        // SVG fonts not fully supported...
+        QString text = paragraphs.front();
+        for (int i = 1; i < paragraphs.size(); ++i) {
+            text.append(QLatin1Char('\n'));
+            text.append(paragraphs[i]);
+        }
+        states.svgFont->draw(p, m_coord * scale, text, p->font().pointSizeF() * scale, states.textAnchor);
+    } else {
+        for (int i = 0; i < paragraphs.size(); ++i) {
+            QTextLayout tl(paragraphs[i]);
+            QTextOption op = tl.textOption();
+            op.setWrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere);
+            tl.setTextOption(op);
+            tl.setAdditionalFormats(formatRanges[i]);
+            tl.beginLayout();
+
+            forever {
+                QTextLine line = tl.createLine();
+                if (!line.isValid())
+                    break;
+                if (m_size.width() != 0)
+                    line.setLineWidth(scaledSize.width());
+            }
+            tl.endLayout();
+
+            bool endOfBoundsReached = false;
+            for (int i = 0; i < tl.lineCount(); ++i) {
+                QTextLine line = tl.lineAt(i);
+
+                qreal x = 0;
+                if (alignment == Qt::AlignHCenter)
+                    x -= 0.5 * line.naturalTextWidth();
+                else if (alignment == Qt::AlignRight)
+                    x -= line.naturalTextWidth();
+
+                if (initial && m_type == TEXT)
+                    y -= line.ascent();
+                initial = false;
+
+                line.setPosition(QPointF(x, y));
+
+                // Check if the current line fits into the bounding rectangle.
+                if ((m_size.width() != 0 && line.naturalTextWidth() > scaledSize.width())
+                    || (m_size.height() != 0 && y + line.height() > scaledSize.height())) {
+                    // I need to set the bounds height to 'y-epsilon' to avoid drawing the current
+                    // line. Since the font is scaled to 100 units, 1 should be a safe epsilon.
+                    bounds.setHeight(y - 1);
+                    endOfBoundsReached = true;
+                    break;
+                }
+
+                y += 1.1 * line.height();
+            }
+            tl.draw(p, QPointF(px, py), QVector<QTextLayout::FormatRange>(), bounds);
+
+            if (endOfBoundsReached)
+                break;
+        }
+    }
+
+    p->setWorldTransform(oldTransform, false);
+    p->setOpacity(oldOpacity);
+    revertStyle(p, states);
+}
+
+void QSvgText::addText(const QString &text)
+{
+    m_tspans.append(new QSvgTspan(this, false));
+    m_tspans.back()->setWhitespaceMode(m_mode);
+    m_tspans.back()->addText(text);
+}
+
+QSvgUse::QSvgUse(const QPointF &start, QSvgNode *parent, QSvgNode *node)
+    : QSvgNode(parent), m_link(node), m_start(start)
+{
+
+}
+
+void QSvgUse::draw(QPainter *p, QSvgExtraStates &states)
+{
+    applyStyle(p, states);
+
+    if (!m_start.isNull()) {
+        p->translate(m_start);
+    }
+    m_link->draw(p, states);
+    if (!m_start.isNull()) {
+        p->translate(-m_start);
+    }
+
+    revertStyle(p, states);
+}
+
+void QSvgVideo::draw(QPainter *p, QSvgExtraStates &states)
+{
+    applyStyle(p, states);
+
+    revertStyle(p, states);
+}
+
+QSvgNode::Type QSvgAnimation::type() const
+{
+    return ANIMATION;
+}
+
+QSvgNode::Type QSvgArc::type() const
+{
+    return ARC;
+}
+
+QSvgNode::Type QSvgCircle::type() const
+{
+    return CIRCLE;
+}
+
+QSvgNode::Type QSvgEllipse::type() const
+{
+    return ELLIPSE;
+}
+
+QSvgNode::Type QSvgImage::type() const
+{
+    return IMAGE;
+}
+
+QSvgNode::Type QSvgLine::type() const
+{
+    return LINE;
+}
+
+QSvgNode::Type QSvgPath::type() const
+{
+    return PATH;
+}
+
+QSvgNode::Type QSvgPolygon::type() const
+{
+    return POLYGON;
+}
+
+QSvgNode::Type QSvgPolyline::type() const
+{
+    return POLYLINE;
+}
+
+QSvgNode::Type QSvgRect::type() const
+{
+    return RECT;
+}
+
+QSvgNode::Type QSvgText::type() const
+{
+    return m_type;
+}
+
+QSvgNode::Type QSvgUse::type() const
+{
+    return USE;
+}
+
+QSvgNode::Type QSvgVideo::type() const
+{
+    return VIDEO;
+}
+
+QRectF QSvgUse::bounds(QPainter *p, QSvgExtraStates &states) const
+{
+    QRectF bounds;
+    if (m_link) {
+        p->translate(m_start);
+        bounds = m_link->transformedBounds(p, states);
+        p->translate(-m_start);
+    }
+    return bounds;
+}
+
+QRectF QSvgPolyline::bounds(QPainter *p, QSvgExtraStates &) const
+{
+    qreal sw = strokeWidth(p);
+    if (qFuzzyIsNull(sw)) {
+        return p->transform().map(m_poly).boundingRect();
+    } else {
+        QPainterPath path;
+        path.addPolygon(m_poly);
+        return boundsOnStroke(p, path, sw);
+    }
+}
+
+QRectF QSvgArc::bounds(QPainter *p, QSvgExtraStates &) const
+{
+    qreal sw = strokeWidth(p);
+    return qFuzzyIsNull(sw) ? p->transform().map(m_path).boundingRect()
+        : boundsOnStroke(p, m_path, sw);
+}
+
+QRectF QSvgImage::bounds(QPainter *p, QSvgExtraStates &) const
+{
+    return p->transform().mapRect(m_bounds);
+}
+
+QRectF QSvgLine::bounds(QPainter *p, QSvgExtraStates &) const
+{
+    qreal sw = strokeWidth(p);
+    if (qFuzzyIsNull(sw)) {
+        QPointF p1 = p->transform().map(m_line.p1());
+        QPointF p2 = p->transform().map(m_line.p2());
+        qreal minX = qMin(p1.x(), p2.x());
+        qreal minY = qMin(p1.y(), p2.y());
+        qreal maxX = qMax(p1.x(), p2.x());
+        qreal maxY = qMax(p1.y(), p2.y());
+        return QRectF(minX, minY, maxX - minX, maxY - minY);
+    } else {
+        QPainterPath path;
+        path.moveTo(m_line.p1());
+        path.lineTo(m_line.p2());
+        return boundsOnStroke(p, path, sw);
+    }
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SVG
diff --git a/src/svg/qsvggraphics_p.h b/src/svg/qsvggraphics_p.h
new file mode 100644
index 0000000..58c4fdf
--- /dev/null
+++ b/src/svg/qsvggraphics_p.h
@@ -0,0 +1,262 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtSvg module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSVGGRAPHICS_P_H
+#define QSVGGRAPHICS_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qsvgnode_p.h"
+
+#ifndef QT_NO_SVG
+
+#include "QtGui/qpainterpath.h"
+#include "QtGui/qimage.h"
+#include "QtGui/qtextlayout.h"
+#include "QtGui/qtextoption.h"
+#include "QtCore/qstack.h"
+
+QT_BEGIN_NAMESPACE
+
+class QTextCharFormat;
+
+class QSvgAnimation : public QSvgNode
+{
+public:
+    virtual void draw(QPainter *p, QSvgExtraStates &states);
+    virtual Type type() const;
+};
+
+class QSvgArc : public QSvgNode
+{
+public:
+    QSvgArc(QSvgNode *parent, const QPainterPath &path);
+    virtual void draw(QPainter *p, QSvgExtraStates &states);
+    virtual Type type() const;
+    virtual QRectF bounds(QPainter *p, QSvgExtraStates &states) const;
+private:
+    QPainterPath m_path;
+};
+
+class QSvgEllipse : public QSvgNode
+{
+public:
+    QSvgEllipse(QSvgNode *parent, const QRectF &rect);
+    virtual void draw(QPainter *p, QSvgExtraStates &states);
+    virtual Type type() const;
+    virtual QRectF bounds(QPainter *p, QSvgExtraStates &states) const;
+private:
+    QRectF m_bounds;
+};
+
+class QSvgCircle : public QSvgEllipse
+{
+public:
+    QSvgCircle(QSvgNode *parent, const QRectF &rect) : QSvgEllipse(parent, rect) { }
+    virtual Type type() const;
+};
+
+class QSvgImage : public QSvgNode
+{
+public:
+    QSvgImage(QSvgNode *parent, const QImage &image,
+              const QRect &bounds);
+    virtual void draw(QPainter *p, QSvgExtraStates &states);
+    virtual Type type() const;
+    virtual QRectF bounds(QPainter *p, QSvgExtraStates &states) const;
+private:
+    QImage m_image;
+    QRect  m_bounds;
+};
+
+class QSvgLine : public QSvgNode
+{
+public:
+    QSvgLine(QSvgNode *parent, const QLineF &line);
+    virtual void draw(QPainter *p, QSvgExtraStates &states);
+    virtual Type type() const;
+    virtual QRectF bounds(QPainter *p, QSvgExtraStates &states) const;
+private:
+    QLineF m_line;
+};
+
+class QSvgPath : public QSvgNode
+{
+public:
+    QSvgPath(QSvgNode *parent, const QPainterPath &qpath);
+    virtual void draw(QPainter *p, QSvgExtraStates &states);
+    virtual Type type() const;
+    virtual QRectF bounds(QPainter *p, QSvgExtraStates &states) const;
+
+    QPainterPath *qpath() {
+        return &m_path;
+    }
+private:
+    QPainterPath m_path;
+};
+
+class QSvgPolygon : public QSvgNode
+{
+public:
+    QSvgPolygon(QSvgNode *parent, const QPolygonF &poly);
+    virtual void draw(QPainter *p, QSvgExtraStates &states);
+    virtual Type type() const;
+    virtual QRectF bounds(QPainter *p, QSvgExtraStates &states) const;
+private:
+    QPolygonF m_poly;
+};
+
+class QSvgPolyline : public QSvgNode
+{
+public:
+    QSvgPolyline(QSvgNode *parent, const QPolygonF &poly);
+    virtual void draw(QPainter *p, QSvgExtraStates &states);
+    virtual Type type() const;
+    virtual QRectF bounds(QPainter *p, QSvgExtraStates &states) const;
+private:
+    QPolygonF m_poly;
+};
+
+class QSvgRect : public QSvgNode
+{
+public:
+    QSvgRect(QSvgNode *paren, const QRectF &rect, int rx=0, int ry=0);
+    virtual Type type() const;
+    virtual void draw(QPainter *p, QSvgExtraStates &states);
+    virtual QRectF bounds(QPainter *p, QSvgExtraStates &states) const;
+private:
+    QRectF m_rect;
+    int m_rx, m_ry;
+};
+
+class  QSvgTspan;
+
+class  QSvgText : public QSvgNode
+{
+public:
+    enum WhitespaceMode
+    {
+        Default,
+        Preserve
+    };
+
+    QSvgText(QSvgNode *parent, const QPointF &coord);
+    ~QSvgText();
+    void setTextArea(const QSizeF &size);
+
+    virtual void draw(QPainter *p, QSvgExtraStates &states);
+    virtual Type type() const;
+
+    void addTspan(QSvgTspan *tspan) {m_tspans.append(tspan);}
+    void addText(const QString &text);
+    void addLineBreak() {m_tspans.append(LINEBREAK);}
+    void setWhitespaceMode(WhitespaceMode mode) {m_mode = mode;}
+
+    //virtual QRectF bounds(QPainter *p, QSvgExtraStates &states) const;
+private:
+    static QSvgTspan * const LINEBREAK;
+
+    QPointF m_coord;
+
+    // 'm_tspans' is also used to store characters outside tspans and line breaks.
+    // If a 'm_tspan' item is null, it indicates a line break.
+    QVector<QSvgTspan *> m_tspans;
+
+    Type m_type;
+    QSizeF m_size;
+    WhitespaceMode m_mode;
+};
+
+class  QSvgTspan : public QSvgNode
+{
+public:
+    // tspans are also used to store normal text, so the 'isProperTspan' is used to separate text from tspan.
+    QSvgTspan(QSvgNode *parent, bool isProperTspan = true)
+        : QSvgNode(parent), m_mode(QSvgText::Default), m_isTspan(isProperTspan)
+    {
+    }
+    ~QSvgTspan() { };
+    virtual Type type() const {return TSPAN;}
+    virtual void draw(QPainter *, QSvgExtraStates &) {Q_ASSERT(!"Tspans should be drawn through QSvgText::draw().");}
+    void addText(const QString &text) {m_text += text;}
+    const QString &text() const {return m_text;}
+    bool isTspan() const {return m_isTspan;}
+    void setWhitespaceMode(QSvgText::WhitespaceMode mode) {m_mode = mode;}
+    QSvgText::WhitespaceMode whitespaceMode() const {return m_mode;}
+private:
+    QString m_text;
+    QSvgText::WhitespaceMode m_mode;
+    bool m_isTspan;
+};
+
+class QSvgUse : public QSvgNode
+{
+public:
+    QSvgUse(const QPointF &start, QSvgNode *parent, QSvgNode *link);
+    virtual void draw(QPainter *p, QSvgExtraStates &states);
+    virtual Type type() const;
+    virtual QRectF bounds(QPainter *p, QSvgExtraStates &states) const;
+
+private:
+    QSvgNode *m_link;
+    QPointF   m_start;
+};
+
+class QSvgVideo : public QSvgNode
+{
+public:
+    virtual void draw(QPainter *p, QSvgExtraStates &states);
+    virtual Type type() const;
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SVG
+#endif // QSVGGRAPHICS_P_H
diff --git a/src/svg/qsvghandler.cpp b/src/svg/qsvghandler.cpp
new file mode 100644
index 0000000..3fbc08c
--- /dev/null
+++ b/src/svg/qsvghandler.cpp
@@ -0,0 +1,3923 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtSvg module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qplatformdefs.h"
+
+#include "qsvghandler_p.h"
+
+#ifndef QT_NO_SVG
+
+#include "qsvgtinydocument_p.h"
+#include "qsvgstructure_p.h"
+#include "qsvggraphics_p.h"
+#include "qsvgnode_p.h"
+#include "qsvgfont_p.h"
+
+#include "qapplication.h"
+#include "qwidget.h"
+#include "qpen.h"
+#include "qpainterpath.h"
+#include "qbrush.h"
+#include "qcolor.h"
+#include "qtextformat.h"
+#include "qvector.h"
+#include "qfileinfo.h"
+#include "qfile.h"
+#include "qdebug.h"
+#include "qmath.h"
+#include "qnumeric.h"
+#include "qvarlengtharray.h"
+#include "private/qmath_p.h"
+
+#include "float.h"
+
+QT_BEGIN_NAMESPACE
+
+static const char *qt_inherit_text = "inherit";
+#define QT_INHERIT QLatin1String(qt_inherit_text)
+
+Q_CORE_EXPORT double qstrtod(const char *s00, char const **se, bool *ok);
+
+// ======== duplicated from qcolor_p
+
+static inline int qsvg_h2i(char hex)
+{
+    if (hex >= '0' && hex <= '9')
+        return hex - '0';
+    if (hex >= 'a' && hex <= 'f')
+        return hex - 'a' + 10;
+    if (hex >= 'A' && hex <= 'F')
+        return hex - 'A' + 10;
+    return -1;
+}
+
+static inline int qsvg_hex2int(const char *s)
+{
+    return (qsvg_h2i(s[0]) << 4) | qsvg_h2i(s[1]);
+}
+
+static inline int qsvg_hex2int(char s)
+{
+    int h = qsvg_h2i(s);
+    return (h << 4) | h;
+}
+
+bool qsvg_get_hex_rgb(const char *name, QRgb *rgb)
+{
+    if(name[0] != '#')
+        return false;
+    name++;
+    int len = qstrlen(name);
+    int r, g, b;
+    if (len == 12) {
+        r = qsvg_hex2int(name);
+        g = qsvg_hex2int(name + 4);
+        b = qsvg_hex2int(name + 8);
+    } else if (len == 9) {
+        r = qsvg_hex2int(name);
+        g = qsvg_hex2int(name + 3);
+        b = qsvg_hex2int(name + 6);
+    } else if (len == 6) {
+        r = qsvg_hex2int(name);
+        g = qsvg_hex2int(name + 2);
+        b = qsvg_hex2int(name + 4);
+    } else if (len == 3) {
+        r = qsvg_hex2int(name[0]);
+        g = qsvg_hex2int(name[1]);
+        b = qsvg_hex2int(name[2]);
+    } else {
+        r = g = b = -1;
+    }
+    if ((uint)r > 255 || (uint)g > 255 || (uint)b > 255) {
+        *rgb = 0;
+        return false;
+    }
+    *rgb = qRgb(r, g ,b);
+    return true;
+}
+
+bool qsvg_get_hex_rgb(const QChar *str, int len, QRgb *rgb)
+{
+    if (len > 13)
+        return false;
+    char tmp[16];
+    for(int i = 0; i < len; ++i)
+        tmp[i] = str[i].toLatin1();
+    tmp[len] = 0;
+    return qsvg_get_hex_rgb(tmp, rgb);
+}
+
+// ======== end of qcolor_p duplicate
+
+static bool parsePathDataFast(const QStringRef &data, QPainterPath &path);
+
+static inline QString someId(const QXmlStreamAttributes &attributes)
+{
+    QString id = attributes.value(QLatin1String("id")).toString();
+    if (id.isEmpty())
+        id = attributes.value(QLatin1String("xml:id")).toString();
+    return id;
+}
+
+struct QSvgAttributes
+{
+    QSvgAttributes(const QXmlStreamAttributes &xmlAttributes, QSvgHandler *handler);
+
+    QString id;
+
+    QStringRef color;
+    QStringRef colorOpacity;
+    QStringRef fill;
+    QStringRef fillRule;
+    QStringRef fillOpacity;
+    QStringRef stroke;
+    QStringRef strokeDashArray;
+    QStringRef strokeDashOffset;
+    QStringRef strokeLineCap;
+    QStringRef strokeLineJoin;
+    QStringRef strokeMiterLimit;
+    QStringRef strokeOpacity;
+    QStringRef strokeWidth;
+    QStringRef vectorEffect;
+    QStringRef fontFamily;
+    QStringRef fontSize;
+    QStringRef fontStyle;
+    QStringRef fontWeight;
+    QStringRef fontVariant;
+    QStringRef textAnchor;
+    QStringRef transform;
+    QStringRef visibility;
+    QStringRef opacity;
+    QStringRef compOp;
+    QStringRef display;
+    QStringRef offset;
+    QStringRef stopColor;
+    QStringRef stopOpacity;
+
+    QVector<QSvgCssAttribute> m_cssAttributes;
+};
+
+QSvgAttributes::QSvgAttributes(const QXmlStreamAttributes &xmlAttributes, QSvgHandler *handler)
+{
+    QStringRef style = xmlAttributes.value(QLatin1String("style"));
+    if (!style.isEmpty()) {
+        handler->parseCSStoXMLAttrs(style.toString(), &m_cssAttributes);
+        for (int j = 0; j < m_cssAttributes.count(); ++j) {
+            const QSvgCssAttribute &attribute = m_cssAttributes.at(j);
+            QStringRef name = attribute.name;
+            QStringRef value = attribute.value;
+            if (name.isEmpty())
+                continue;
+
+            switch (name.at(0).unicode()) {
+
+            case 'c':
+                if (name == QLatin1String("color"))
+                    color = value;
+                else if (name == QLatin1String("color-opacity"))
+                    colorOpacity = value;
+                else if (name == QLatin1String("comp-op"))
+                    compOp = value;
+                break;
+
+            case 'd':
+                if (name == QLatin1String("display"))
+                    display = value;
+                break;
+
+            case 'f':
+                if (name == QLatin1String("fill"))
+                    fill = value;
+                else if (name == QLatin1String("fill-rule"))
+                    fillRule = value;
+                else if (name == QLatin1String("fill-opacity"))
+                    fillOpacity = value;
+                else if (name == QLatin1String("font-family"))
+                    fontFamily = value;
+                else if (name == QLatin1String("font-size"))
+                    fontSize = value;
+                else if (name == QLatin1String("font-style"))
+                    fontStyle = value;
+                else if (name == QLatin1String("font-weight"))
+                    fontWeight = value;
+                else if (name == QLatin1String("font-variant"))
+                    fontVariant = value;
+                break;
+
+            case 'o':
+                if (name == QLatin1String("opacity"))
+                    opacity = value;
+                else if (name == QLatin1String("offset"))
+                    offset = value;
+                break;
+
+            case 's':
+                if (name.length() > 5 && QStringRef(name.string(), name.position() + 1, 5) == QLatin1String("troke")) {
+                    QStringRef strokeRef(name.string(), name.position() + 6, name.length() - 6);
+                    if (strokeRef.isEmpty())
+                        stroke = value;
+                    else if (strokeRef == QLatin1String("-dasharray"))
+                        strokeDashArray = value;
+                    else if (strokeRef == QLatin1String("-dashoffset"))
+                        strokeDashOffset = value;
+                    else if (strokeRef == QLatin1String("-linecap"))
+                        strokeLineCap = value;
+                    else if (strokeRef == QLatin1String("-linejoin"))
+                        strokeLineJoin = value;
+                    else if (strokeRef == QLatin1String("-miterlimit"))
+                        strokeMiterLimit = value;
+                    else if (strokeRef == QLatin1String("-opacity"))
+                        strokeOpacity = value;
+                    else if (strokeRef == QLatin1String("-width"))
+                        strokeWidth = value;
+                }
+                else if (name == QLatin1String("stop-color"))
+                    stopColor = value;
+                else if (name == QLatin1String("stop-opacity"))
+                    stopOpacity = value;
+                break;
+
+            case 't':
+                if (name == QLatin1String("text-anchor"))
+                    textAnchor = value;
+                else if (name == QLatin1String("transform"))
+                    transform = value;
+                break;
+
+            case 'v':
+                if (name == QLatin1String("vector-effect"))
+                    vectorEffect = value;
+                else if (name == QLatin1String("visibility"))
+                    visibility = value;
+                break;
+
+            default:
+                break;
+           }
+        }
+    }
+
+    for (int i = 0; i < xmlAttributes.count(); ++i) {
+        const QXmlStreamAttribute &attribute = xmlAttributes.at(i);
+        QStringRef name = attribute.qualifiedName();
+        if (name.isEmpty())
+            continue;
+        QStringRef value = attribute.value();
+
+        switch (name.at(0).unicode()) {
+
+        case 'c':
+            if (name == QLatin1String("color"))
+                color = value;
+            else if (name == QLatin1String("color-opacity"))
+                colorOpacity = value;
+            else if (name == QLatin1String("comp-op"))
+                compOp = value;
+            break;
+
+        case 'd':
+            if (name == QLatin1String("display"))
+                display = value;
+            break;
+
+        case 'f':
+            if (name == QLatin1String("fill"))
+                fill = value;
+            else if (name == QLatin1String("fill-rule"))
+                fillRule = value;
+            else if (name == QLatin1String("fill-opacity"))
+                fillOpacity = value;
+            else if (name == QLatin1String("font-family"))
+                fontFamily = value;
+            else if (name == QLatin1String("font-size"))
+                fontSize = value;
+            else if (name == QLatin1String("font-style"))
+                fontStyle = value;
+            else if (name == QLatin1String("font-weight"))
+                fontWeight = value;
+            else if (name == QLatin1String("font-variant"))
+                fontVariant = value;
+            break;
+
+        case 'i':
+            if (name == QLatin1String("id"))
+                id = value.toString();
+            break;
+
+        case 'o':
+            if (name == QLatin1String("opacity"))
+                opacity = value;
+            if (name == QLatin1String("offset"))
+                offset = value;
+            break;
+
+        case 's':
+            if (name.length() > 5 && QStringRef(name.string(), name.position() + 1, 5) == QLatin1String("troke")) {
+                QStringRef strokeRef(name.string(), name.position() + 6, name.length() - 6);
+                if (strokeRef.isEmpty())
+                    stroke = value;
+                else if (strokeRef == QLatin1String("-dasharray"))
+                    strokeDashArray = value;
+                else if (strokeRef == QLatin1String("-dashoffset"))
+                    strokeDashOffset = value;
+                else if (strokeRef == QLatin1String("-linecap"))
+                    strokeLineCap = value;
+                else if (strokeRef == QLatin1String("-linejoin"))
+                    strokeLineJoin = value;
+                else if (strokeRef == QLatin1String("-miterlimit"))
+                    strokeMiterLimit = value;
+                else if (strokeRef == QLatin1String("-opacity"))
+                    strokeOpacity = value;
+                else if (strokeRef == QLatin1String("-width"))
+                    strokeWidth = value;
+            }
+            else if (name == QLatin1String("stop-color"))
+                stopColor = value;
+            else if (name == QLatin1String("stop-opacity"))
+                stopOpacity = value;
+            break;
+
+        case 't':
+            if (name == QLatin1String("text-anchor"))
+                textAnchor = value;
+            else if (name == QLatin1String("transform"))
+                transform = value;
+            break;
+
+        case 'v':
+            if (name == QLatin1String("vector-effect"))
+                vectorEffect = value;
+            else if (name == QLatin1String("visibility"))
+                visibility = value;
+            break;
+
+        case 'x':
+            if (name == QLatin1String("xml:id") && id.isEmpty())
+                id = value.toString();
+            break;
+
+        default:
+            break;
+        }
+    }
+
+}
+
+static const char * QSvgStyleSelector_nodeString[] = {
+    "svg",
+    "g",
+    "defs",
+    "switch",
+    "animation",
+    "arc",
+    "circle",
+    "ellipse",
+    "image",
+    "line",
+    "path",
+    "polygon",
+    "polyline",
+    "rect",
+    "text",
+    "textarea",
+    "use",
+    "video"
+};
+
+class QSvgStyleSelector : public QCss::StyleSelector
+{
+public:
+    QSvgStyleSelector()
+    {
+        nameCaseSensitivity = Qt::CaseInsensitive;
+    }
+    virtual ~QSvgStyleSelector()
+    {
+    }
+
+    inline QString nodeToName(QSvgNode *node) const
+    {
+        return QLatin1String(QSvgStyleSelector_nodeString[node->type()]);
+    }
+
+    inline QSvgNode *svgNode(NodePtr node) const
+    {
+        return (QSvgNode*)node.ptr;
+    }
+    inline QSvgStructureNode *nodeToStructure(QSvgNode *n) const
+    {
+        if (n &&
+            (n->type() == QSvgNode::DOC ||
+             n->type() == QSvgNode::G ||
+             n->type() == QSvgNode::DEFS ||
+             n->type() == QSvgNode::SWITCH)) {
+            return (QSvgStructureNode*)n;
+        }
+        return 0;
+    }
+
+    inline QSvgStructureNode *svgStructure(NodePtr node) const
+    {
+        QSvgNode *n = svgNode(node);
+        QSvgStructureNode *st = nodeToStructure(n);
+        return st;
+    }
+
+    virtual bool nodeNameEquals(NodePtr node, const QString& nodeName) const
+    {
+        QSvgNode *n = svgNode(node);
+        if (!n)
+            return false;
+        QString name = nodeToName(n);
+        return QString::compare(name, nodeName, Qt::CaseInsensitive) == 0;
+    }
+    virtual QString attribute(NodePtr node, const QString &name) const
+    {
+        QSvgNode *n = svgNode(node);
+        if ((!n->nodeId().isEmpty() && (name == QLatin1String("id") ||
+                                        name == QLatin1String("xml:id"))))
+            return n->nodeId();
+        if (!n->xmlClass().isEmpty() && name == QLatin1String("class"))
+            return n->xmlClass();
+        return QString();
+    }
+    virtual bool hasAttributes(NodePtr node) const
+    {
+        QSvgNode *n = svgNode(node);
+        return (n &&
+                (!n->nodeId().isEmpty() || !n->xmlClass().isEmpty()));
+    }
+
+    virtual QStringList nodeIds(NodePtr node) const
+    {
+        QSvgNode *n = svgNode(node);
+        QString nid;
+        if (n)
+            nid = n->nodeId();
+        QStringList lst; lst.append(nid);
+        return lst;
+    }
+
+    virtual QStringList nodeNames(NodePtr node) const
+    {
+        QSvgNode *n = svgNode(node);
+        if (n)
+           return QStringList(nodeToName(n));
+        return QStringList();
+    }
+
+    virtual bool isNullNode(NodePtr node) const
+    {
+        return !node.ptr;
+    }
+
+    virtual NodePtr parentNode(NodePtr node) const
+    {
+        QSvgNode *n = svgNode(node);
+        NodePtr newNode;
+        newNode.ptr = 0;
+        newNode.id = 0;
+        if (n) {
+            QSvgNode *svgParent = n->parent();
+            if (svgParent) {
+                newNode.ptr = svgParent;
+            }
+        }
+        return newNode;
+    }
+    virtual NodePtr previousSiblingNode(NodePtr node) const
+    {
+        NodePtr newNode;
+        newNode.ptr = 0;
+        newNode.id = 0;
+
+        QSvgNode *n = svgNode(node);
+        if (!n)
+            return newNode;
+        QSvgStructureNode *svgParent = nodeToStructure(n->parent());
+
+        if (svgParent) {
+            newNode.ptr = svgParent->previousSiblingNode(n);
+        }
+        return newNode;
+    }
+    virtual NodePtr duplicateNode(NodePtr node) const
+    {
+        NodePtr n;
+        n.ptr = node.ptr;
+        n.id  = node.id;
+        return n;
+    }
+    virtual void freeNode(NodePtr node) const
+    {
+        Q_UNUSED(node);
+    }
+};
+
+// '0' is 0x30 and '9' is 0x39
+static inline bool isDigit(ushort ch)
+{
+    static quint16 magic = 0x3ff;
+    return ((ch >> 4) == 3) && (magic >> (ch & 15));
+}
+
+static qreal toDouble(const QChar *&str)
+{
+    const int maxLen = 255;//technically doubles can go til 308+ but whatever
+    char temp[maxLen+1];
+    int pos = 0;
+
+    if (*str == QLatin1Char('-')) {
+        temp[pos++] = '-';
+        ++str;
+    } else if (*str == QLatin1Char('+')) {
+        ++str;
+    }
+    while (isDigit(str->unicode()) && pos < maxLen) {
+        temp[pos++] = str->toLatin1();
+        ++str;
+    }
+    if (*str == QLatin1Char('.') && pos < maxLen) {
+        temp[pos++] = '.';
+        ++str;
+    }
+    while (isDigit(str->unicode()) && pos < maxLen) {
+        temp[pos++] = str->toLatin1();
+        ++str;
+    }
+    bool exponent = false;
+    if ((*str == QLatin1Char('e') || *str == QLatin1Char('E')) && pos < maxLen) {
+        exponent = true;
+        temp[pos++] = 'e';
+        ++str;
+        if ((*str == QLatin1Char('-') || *str == QLatin1Char('+')) && pos < maxLen) {
+            temp[pos++] = str->toLatin1();
+            ++str;
+        }
+        while (isDigit(str->unicode()) && pos < maxLen) {
+            temp[pos++] = str->toLatin1();
+            ++str;
+        }
+    }
+
+    temp[pos] = '\0';
+
+    qreal val;
+    if (!exponent && pos < 10) {
+        int ival = 0;
+        const char *t = temp;
+        bool neg = false;
+        if(*t == '-') {
+            neg = true;
+            ++t;
+        }
+        while(*t && *t != '.') {
+            ival *= 10;
+            ival += (*t) - '0';
+            ++t;
+        }
+        if(*t == '.') {
+            ++t;
+            int div = 1;
+            while(*t) {
+                ival *= 10;
+                ival += (*t) - '0';
+                div *= 10;
+                ++t;
+            }
+            val = ((qreal)ival)/((qreal)div);
+        } else {
+            val = ival;
+        }
+        if (neg)
+            val = -val;
+    } else {
+#if defined(Q_WS_QWS) && !defined(Q_OS_VXWORKS)
+        if(sizeof(qreal) == sizeof(float))
+            val = strtof(temp, 0);
+        else
+#endif
+        {
+            bool ok = false;
+            val = qstrtod(temp, 0, &ok);
+        }
+    }
+    return val;
+
+}
+static qreal toDouble(const QString &str, bool *ok = NULL)
+{
+    const QChar *c = str.constData();
+    qreal res = toDouble(c);
+    if (ok) {
+        *ok = ((*c) == QLatin1Char('\0'));
+    }
+    return res;
+}
+
+static qreal toDouble(const QStringRef &str, bool *ok = NULL)
+{
+    const QChar *c = str.constData();
+    qreal res = toDouble(c);
+    if (ok) {
+        *ok = (c == (str.constData() + str.length()));
+    }
+    return res;
+}
+
+static QVector<qreal> parseNumbersList(const QChar *&str)
+{
+    QVector<qreal> points;
+    if (!str)
+        return points;
+    points.reserve(32);
+
+    while (str->isSpace())
+        ++str;
+    while (isDigit(str->unicode()) ||
+           *str == QLatin1Char('-') || *str == QLatin1Char('+') ||
+           *str == QLatin1Char('.')) {
+
+        points.append(toDouble(str));
+
+        while (str->isSpace())
+            ++str;
+        if (*str == QLatin1Char(','))
+            ++str;
+
+        //eat the rest of space
+        while (str->isSpace())
+            ++str;
+    }
+
+    return points;
+}
+
+static inline void parseNumbersArray(const QChar *&str, QVarLengthArray<qreal, 8> &points)
+{
+    while (str->isSpace())
+        ++str;
+    while (isDigit(str->unicode()) ||
+           *str == QLatin1Char('-') || *str == QLatin1Char('+') ||
+           *str == QLatin1Char('.')) {
+
+        points.append(toDouble(str));
+
+        while (str->isSpace())
+            ++str;
+        if (*str == QLatin1Char(','))
+            ++str;
+
+        //eat the rest of space
+        while (str->isSpace())
+            ++str;
+    }
+}
+
+static QVector<qreal> parsePercentageList(const QChar *&str)
+{
+    QVector<qreal> points;
+    if (!str)
+        return points;
+
+    while (str->isSpace())
+        ++str;
+    while ((*str >= QLatin1Char('0') && *str <= QLatin1Char('9')) ||
+           *str == QLatin1Char('-') || *str == QLatin1Char('+') ||
+           *str == QLatin1Char('.')) {
+
+        points.append(toDouble(str));
+
+        while (str->isSpace())
+            ++str;
+        if (*str == QLatin1Char('%'))
+            ++str;
+        while (str->isSpace())
+            ++str;
+        if (*str == QLatin1Char(','))
+            ++str;
+
+        //eat the rest of space
+        while (str->isSpace())
+            ++str;
+    }
+
+    return points;
+}
+
+static QString idFromUrl(const QString &url)
+{
+    QString::const_iterator itr = url.constBegin();
+    while ((*itr).isSpace())
+        ++itr;
+    if ((*itr) == QLatin1Char('('))
+        ++itr;
+    while ((*itr).isSpace())
+        ++itr;
+    if ((*itr) == QLatin1Char('#'))
+        ++itr;
+    QString id;
+    while ((*itr) != QLatin1Char(')')) {
+        id += *itr;
+        ++itr;
+    }
+    return id;
+}
+
+static inline QStringRef trimRef(const QStringRef &str)
+{
+    if (str.isEmpty())
+        return QStringRef();
+    const QChar *s = str.string()->constData() + str.position();
+    int end = str.length() - 1;
+    if (!s[0].isSpace() && !s[end].isSpace())
+        return str;
+
+    int start = 0;
+    while (start<=end && s[start].isSpace())  // skip white space from start
+        start++;
+    if (start <= end) {                          // only white space
+        while (s[end].isSpace())           // skip white space from end
+            end--;
+    }
+    int l = end - start + 1;
+    if (l <= 0)
+        return QStringRef();
+    return QStringRef(str.string(), str.position() + start, l);
+}
+
+/**
+ * returns true when successfuly set the color. false signifies
+ * that the color should be inherited
+ */
+static bool resolveColor(const QStringRef &colorStr, QColor &color, QSvgHandler *handler)
+{
+    QStringRef colorStrTr = trimRef(colorStr);
+    if (colorStrTr.isEmpty())
+        return false;
+
+    switch(colorStrTr.at(0).unicode()) {
+
+        case '#':
+            {
+                // #rrggbb is very very common, so let's tackle it here
+                // rather than falling back to QColor
+                QRgb rgb;
+                bool ok = qsvg_get_hex_rgb(colorStrTr.unicode(), colorStrTr.length(), &rgb);
+                if (ok)
+                    color.setRgb(rgb);
+                return ok;
+            }
+            break;
+
+        case 'r':
+            {
+                // starts with "rgb(", ends with ")" and consists of at least 7 characters "rgb(,,)"
+                if (colorStrTr.length() >= 7 && colorStrTr.at(colorStrTr.length() - 1) == QLatin1Char(')')
+                    && QStringRef(colorStrTr.string(), colorStrTr.position(), 4) == QLatin1String("rgb(")) {
+                    const QChar *s = colorStrTr.constData() + 4;
+                    QVector<qreal> compo = parseNumbersList(s);
+                    //1 means that it failed after reaching non-parsable
+                    //character which is going to be "%"
+                    if (compo.size() == 1) {
+                        s = colorStrTr.constData() + 4;
+                        compo = parsePercentageList(s);
+                        for (int i = 0; i < compo.size(); ++i)
+                            compo[i] *= (qreal)2.55;
+                    }
+
+                    if (compo.size() == 3) {
+                        color = QColor(int(compo[0]),
+                                       int(compo[1]),
+                                       int(compo[2]));
+                        return true;
+                    }
+                    return false;
+                }
+            }
+            break;
+
+        case 'c':
+            if (colorStrTr == QLatin1String("currentColor")) {
+                color = handler->currentColor();
+                return true;
+            }
+            break;
+        case 'i':
+            if (colorStrTr == QT_INHERIT)
+                return false;
+            break;
+        default:
+            break;
+    }
+
+    color = QColor(colorStrTr.toString());
+    return color.isValid();
+}
+
+static bool constructColor(const QStringRef &colorStr, const QStringRef &opacity,
+                           QColor &color, QSvgHandler *handler)
+{
+    if (!resolveColor(colorStr, color, handler))
+        return false;
+    if (!opacity.isEmpty()) {
+        bool ok = true;
+        qreal op = qMin(qreal(1.0), qMax(qreal(0.0), toDouble(opacity, &ok)));
+        if (!ok)
+            op = 1.0;
+        color.setAlphaF(op);
+    }
+    return true;
+}
+
+static qreal parseLength(const QString &str, QSvgHandler::LengthType &type,
+                         QSvgHandler *handler, bool *ok = NULL)
+{
+    QString numStr = str.trimmed();
+
+    if (numStr.endsWith(QLatin1Char('%'))) {
+        numStr.chop(1);
+        type = QSvgHandler::LT_PERCENT;
+    } else if (numStr.endsWith(QLatin1String("px"))) {
+        numStr.chop(2);
+        type = QSvgHandler::LT_PX;
+    } else if (numStr.endsWith(QLatin1String("pc"))) {
+        numStr.chop(2);
+        type = QSvgHandler::LT_PC;
+    } else if (numStr.endsWith(QLatin1String("pt"))) {
+        numStr.chop(2);
+        type = QSvgHandler::LT_PT;
+    } else if (numStr.endsWith(QLatin1String("mm"))) {
+        numStr.chop(2);
+        type = QSvgHandler::LT_MM;
+    } else if (numStr.endsWith(QLatin1String("cm"))) {
+        numStr.chop(2);
+        type = QSvgHandler::LT_CM;
+    } else if (numStr.endsWith(QLatin1String("in"))) {
+        numStr.chop(2);
+        type = QSvgHandler::LT_IN;
+    } else {
+        type = handler->defaultCoordinateSystem();
+        //type = QSvgHandler::LT_OTHER;
+    }
+    qreal len = toDouble(numStr, ok);
+    //qDebug()<<"len is "<<len<<", from '"<<numStr << "'";
+    return len;
+}
+
+static inline qreal convertToNumber(const QString &str, QSvgHandler *handler, bool *ok = NULL)
+{
+    QSvgHandler::LengthType type;
+    qreal num = parseLength(str, type, handler, ok);
+    if (type == QSvgHandler::LT_PERCENT) {
+        num = num/100.0;
+    }
+    return num;
+}
+
+static bool createSvgGlyph(QSvgFont *font, const QXmlStreamAttributes &attributes)
+{
+    QStringRef uncStr = attributes.value(QLatin1String("unicode"));
+    QStringRef havStr = attributes.value(QLatin1String("horiz-adv-x"));
+    QStringRef pathStr = attributes.value(QLatin1String("d"));
+
+    QChar unicode = (uncStr.isEmpty()) ? 0 : uncStr.at(0);
+    qreal havx = (havStr.isEmpty()) ? -1 : toDouble(havStr);
+    QPainterPath path;
+    path.setFillRule(Qt::WindingFill);
+    parsePathDataFast(pathStr, path);
+
+    font->addGlyph(unicode, path, havx);
+
+    return true;
+}
+
+// this should really be called convertToDefaultCoordinateSystem
+// and convert when type != QSvgHandler::defaultCoordinateSystem
+static qreal convertToPixels(qreal len, bool , QSvgHandler::LengthType type)
+{
+
+    switch (type) {
+    case QSvgHandler::LT_PERCENT:
+        break;
+    case QSvgHandler::LT_PX:
+        break;
+    case QSvgHandler::LT_PC:
+        break;
+    case QSvgHandler::LT_PT:
+        return len * 1.25;
+        break;
+    case QSvgHandler::LT_MM:
+        return len * 3.543307;
+        break;
+    case QSvgHandler::LT_CM:
+        return len * 35.43307;
+        break;
+    case QSvgHandler::LT_IN:
+        return len * 90;
+        break;
+    case QSvgHandler::LT_OTHER:
+        break;
+    default:
+        break;
+    }
+    return len;
+}
+
+static void parseColor(QSvgNode *,
+                       const QSvgAttributes &attributes,
+                       QSvgHandler *handler)
+{
+    QColor color;
+    if (constructColor(attributes.color, attributes.colorOpacity, color, handler)) {
+        handler->popColor();
+        handler->pushColor(color);
+    }
+}
+
+static QSvgStyleProperty *styleFromUrl(QSvgNode *node, const QString &url)
+{
+    return node ? node->styleProperty(idFromUrl(url)) : 0;
+}
+
+static void parseBrush(QSvgNode *node,
+                       const QSvgAttributes &attributes,
+                       QSvgHandler *handler)
+{
+    if (!attributes.fill.isEmpty() || !attributes.fillRule.isEmpty() || !attributes.fillOpacity.isEmpty()) {
+        QSvgFillStyle *prop = new QSvgFillStyle;
+
+        //fill-rule attribute handling
+        if (!attributes.fillRule.isEmpty() && attributes.fillRule != QT_INHERIT) {
+            if (attributes.fillRule == QLatin1String("evenodd"))
+                prop->setFillRule(Qt::OddEvenFill);
+            else if (attributes.fillRule == QLatin1String("nonzero"))
+                prop->setFillRule(Qt::WindingFill);
+        }
+
+        //fill-opacity atttribute handling
+        if (!attributes.fillOpacity.isEmpty() && attributes.fillOpacity != QT_INHERIT) {
+            prop->setFillOpacity(qMin(qreal(1.0), qMax(qreal(0.0), toDouble(attributes.fillOpacity))));
+        }
+
+        //fill attribute handling
+        if ((!attributes.fill.isEmpty()) && (attributes.fill != QT_INHERIT) ) {
+            if (attributes.fill.length() > 3 &&
+                QStringRef(attributes.fill.string(), attributes.fill.position(), 3) == QLatin1String("url")) {
+                QStringRef urlRef(attributes.fill.string(), attributes.fill.position() + 3, attributes.fill.length() - 3);
+                QString value = urlRef.toString();
+                QSvgStyleProperty *style = styleFromUrl(node, value);
+                if (style) {
+                    if (style->type() == QSvgStyleProperty::SOLID_COLOR || style->type() == QSvgStyleProperty::GRADIENT)
+                        prop->setFillStyle(reinterpret_cast<QSvgFillStyleProperty *>(style));
+                } else {
+                    QString id = idFromUrl(value);
+                    prop->setGradientId(id);
+                    prop->setGradientResolved(false);
+                }
+            } else if (attributes.fill != QLatin1String("none")) {
+                QColor color;
+                if (resolveColor(attributes.fill, color, handler))
+                    prop->setBrush(QBrush(color));
+            } else {
+                prop->setBrush(QBrush(Qt::NoBrush));
+            }
+        }
+        node->appendStyleProperty(prop, attributes.id);
+    }
+}
+
+
+
+static QMatrix parseTransformationMatrix(const QStringRef &value)
+{
+    if (value.isEmpty())
+        return QMatrix();
+
+    QMatrix matrix;
+    const QChar *str = value.constData();
+    const QChar *end = str + value.length();
+
+    while (str < end) {
+        if (str->isSpace() || *str == QLatin1Char(',')) {
+            ++str;
+            continue;
+        }
+        enum State {
+            Matrix,
+            Translate,
+            Rotate,
+            Scale,
+            SkewX,
+            SkewY
+        };
+        State state = Matrix;
+        if (*str == QLatin1Char('m')) {  //matrix
+            const char *ident = "atrix";
+            for (int i = 0; i < 5; ++i)
+                if (*(++str) != QLatin1Char(ident[i]))
+                    goto error;
+            ++str;
+            state = Matrix;
+        } else if (*str == QLatin1Char('t')) { //translate
+            const char *ident = "ranslate";
+            for (int i = 0; i < 8; ++i)
+                if (*(++str) != QLatin1Char(ident[i]))
+                    goto error;
+            ++str;
+            state = Translate;
+        } else if (*str == QLatin1Char('r')) { //rotate
+            const char *ident = "otate";
+            for (int i = 0; i < 5; ++i)
+                if (*(++str) != QLatin1Char(ident[i]))
+                    goto error;
+            ++str;
+            state = Rotate;
+        } else if (*str == QLatin1Char('s')) { //scale, skewX, skewY
+            ++str;
+            if (*str == QLatin1Char('c')) {
+                const char *ident = "ale";
+                for (int i = 0; i < 3; ++i)
+                    if (*(++str) != QLatin1Char(ident[i]))
+                        goto error;
+                ++str;
+                state = Scale;
+            } else if (*str == QLatin1Char('k')) {
+                if (*(++str) != QLatin1Char('e'))
+                    goto error;
+                if (*(++str) != QLatin1Char('w'))
+                    goto error;
+                ++str;
+                if (*str == QLatin1Char('X'))
+                    state = SkewX;
+                else if (*str == QLatin1Char('Y'))
+                    state = SkewY;
+                else
+                    goto error;
+                ++str;
+            } else {
+                goto error;
+            }
+        } else {
+            goto error;
+        }
+
+
+        while (str < end && str->isSpace())
+            ++str;
+        if (*str != QLatin1Char('('))
+            goto error;
+        ++str;
+        QVarLengthArray<qreal, 8> points;
+        parseNumbersArray(str, points);
+        if (*str != QLatin1Char(')'))
+            goto error;
+        ++str;
+
+        if(state == Matrix) {
+            if(points.count() != 6)
+                goto error;
+            matrix = matrix * QMatrix(points[0], points[1],
+                                      points[2], points[3],
+                                      points[4], points[5]);
+        } else if (state == Translate) {
+            if (points.count() == 1)
+                matrix.translate(points[0], 0);
+            else if (points.count() == 2)
+                matrix.translate(points[0], points[1]);
+            else
+                goto error;
+        } else if (state == Rotate) {
+            if(points.count() == 1) {
+                matrix.rotate(points[0]);
+            } else if (points.count() == 3) {
+                matrix.translate(points[1], points[2]);
+                matrix.rotate(points[0]);
+                matrix.translate(-points[1], -points[2]);
+            } else {
+                goto error;
+            }
+        } else if (state == Scale) {
+            if (points.count() < 1 || points.count() > 2)
+                goto error;
+            qreal sx = points[0];
+            qreal sy = sx;
+            if(points.count() == 2)
+                sy = points[1];
+            matrix.scale(sx, sy);
+        } else if (state == SkewX) {
+            if (points.count() != 1)
+                goto error;
+            const qreal deg2rad = qreal(0.017453292519943295769);
+            matrix.shear(qTan(points[0]*deg2rad), 0);
+        } else if (state == SkewY) {
+            if (points.count() != 1)
+                goto error;
+            const qreal deg2rad = qreal(0.017453292519943295769);
+            matrix.shear(0, qTan(points[0]*deg2rad));
+        }
+    }
+  error:
+    return matrix;
+}
+
+static void parsePen(QSvgNode *node,
+                     const QSvgAttributes &attributes,
+                     QSvgHandler *handler)
+{
+    //qDebug()<<"Node "<<node->type()<<", attrs are "<<value<<width;
+
+    if (!attributes.stroke.isEmpty() || !attributes.strokeDashArray.isEmpty() || !attributes.strokeDashOffset.isEmpty() || !attributes.strokeLineCap.isEmpty()
+        || !attributes.strokeLineJoin.isEmpty() || !attributes.strokeMiterLimit.isEmpty() || !attributes.strokeOpacity.isEmpty() || !attributes.strokeWidth.isEmpty()
+        || !attributes.vectorEffect.isEmpty()) {
+
+        QSvgStrokeStyle *prop = new QSvgStrokeStyle;
+
+        //stroke attribute handling
+        if ((!attributes.stroke.isEmpty()) && (attributes.stroke != QT_INHERIT) ) {
+            if (attributes.stroke.length() > 3 &&
+                 QStringRef(attributes.stroke.string(), attributes.stroke.position(), 3) == QLatin1String("url")) {
+                 QStringRef urlRef(attributes.stroke.string(), attributes.stroke.position() + 3, attributes.stroke.length() - 3);
+                 QString value = urlRef.toString();
+                    QSvgStyleProperty *style = styleFromUrl(node, value);
+                    if (style) {
+                        if (style->type() == QSvgStyleProperty::SOLID_COLOR || style->type() == QSvgStyleProperty::GRADIENT)
+                            prop->setStyle(reinterpret_cast<QSvgFillStyleProperty *>(style));
+                    } else {
+                        QString id = idFromUrl(value);
+                        prop->setGradientId(id);
+                        prop->setGradientResolved(false);
+                    }
+            } else if (attributes.stroke != QLatin1String("none")) {
+                QColor color;
+                if (resolveColor(attributes.stroke, color, handler))
+                    prop->setStroke(QBrush(color));
+            } else {
+                prop->setStroke(QBrush(Qt::NoBrush));
+            }
+        }
+
+        //stroke-width handling
+        if (!attributes.strokeWidth.isEmpty() && attributes.strokeWidth != QT_INHERIT) {
+            QSvgHandler::LengthType lt;
+            prop->setWidth(parseLength(attributes.strokeWidth.toString(), lt, handler));
+        }
+
+        //stroke-dasharray
+        if (!attributes.strokeDashArray.isEmpty() && attributes.strokeDashArray != QT_INHERIT) {
+            if (attributes.strokeDashArray == QLatin1String("none")) {
+                prop->setDashArrayNone();
+            } else {
+                QString dashArray  = attributes.strokeDashArray.toString();
+                const QChar *s = dashArray.constData();
+                QVector<qreal> dashes = parseNumbersList(s);
+                // if the dash count is odd the dashes should be duplicated
+                if ((dashes.size() & 1) != 0)
+                    dashes << QVector<qreal>(dashes);
+                prop->setDashArray(dashes);
+            }
+        }
+
+        //stroke-linejoin attribute handling
+        if (!attributes.strokeLineJoin.isEmpty()) {
+            if (attributes.strokeLineJoin == QLatin1String("miter"))
+                prop->setLineJoin(Qt::SvgMiterJoin);
+            else if (attributes.strokeLineJoin == QLatin1String("round"))
+                prop->setLineJoin(Qt::RoundJoin);
+            else if (attributes.strokeLineJoin == QLatin1String("bevel"))
+                prop->setLineJoin(Qt::BevelJoin);
+        }
+
+        //stroke-linecap attribute handling
+        if (!attributes.strokeLineCap.isEmpty()) {
+            if (attributes.strokeLineCap == QLatin1String("butt"))
+                prop->setLineCap(Qt::FlatCap);
+            else if (attributes.strokeLineCap == QLatin1String("round"))
+                prop->setLineCap(Qt::RoundCap);
+            else if (attributes.strokeLineCap == QLatin1String("square"))
+                prop->setLineCap(Qt::SquareCap);
+        }
+
+        //stroke-dashoffset attribute handling
+        if (!attributes.strokeDashOffset.isEmpty() && attributes.strokeDashOffset != QT_INHERIT)
+            prop->setDashOffset(toDouble(attributes.strokeDashOffset));
+
+        //vector-effect attribute handling
+        if (!attributes.vectorEffect.isEmpty()) {
+            if (attributes.vectorEffect == QLatin1String("non-scaling-stroke"))
+                prop->setVectorEffect(true);
+            else if (attributes.vectorEffect == QLatin1String("none"))
+                prop->setVectorEffect(false);
+        }
+
+        //stroke-miterlimit
+        if (!attributes.strokeMiterLimit.isEmpty() && attributes.strokeMiterLimit != QT_INHERIT)
+            prop->setMiterLimit(toDouble(attributes.strokeMiterLimit));
+
+        //stroke-opacity atttribute handling
+        if (!attributes.strokeOpacity.isEmpty() && attributes.strokeOpacity != QT_INHERIT)
+            prop->setOpacity(qMin(qreal(1.0), qMax(qreal(0.0), toDouble(attributes.strokeOpacity))));
+
+        node->appendStyleProperty(prop, attributes.id);
+    }
+}
+
+static void parseFont(QSvgNode *node,
+                      const QSvgAttributes &attributes,
+                      QSvgHandler *handler)
+{
+    if (attributes.fontFamily.isEmpty() && attributes.fontSize.isEmpty() && attributes.fontStyle.isEmpty() &&
+        attributes.fontWeight.isEmpty() && attributes.fontVariant.isEmpty() && attributes.textAnchor.isEmpty())
+        return;
+
+    QSvgTinyDocument *doc = node->document();
+    QSvgFontStyle *fontStyle = 0;
+    if (!attributes.fontFamily.isEmpty()) {
+        QSvgFont *svgFont = doc->svgFont(attributes.fontFamily.toString());
+        if (svgFont)
+            fontStyle = new QSvgFontStyle(svgFont, doc);
+    }
+    if (!fontStyle)
+        fontStyle = new QSvgFontStyle;
+
+    if (!attributes.fontFamily.isEmpty() && attributes.fontFamily != QT_INHERIT)
+        fontStyle->setFamily(attributes.fontFamily.toString().trimmed());
+
+    if (!attributes.fontSize.isEmpty() && attributes.fontSize != QT_INHERIT) {
+        // TODO: Support relative sizes 'larger' and 'smaller'.
+        QSvgHandler::LengthType dummy; // should always be pixel size
+        qreal size = 0;
+        static const qreal sizeTable[] = { qreal(6.9), qreal(8.3), qreal(10.0), qreal(12.0), qreal(14.4), qreal(17.3), qreal(20.7) };
+        enum AbsFontSize { XXSmall, XSmall, Small, Medium, Large, XLarge, XXLarge };
+        switch (attributes.fontSize.at(0).unicode()) {
+        case 'x':
+            if (attributes.fontSize == QLatin1String("xx-small"))
+                size = sizeTable[XXSmall];
+            else if (attributes.fontSize == QLatin1String("x-small"))
+                size = sizeTable[XSmall];
+            else if (attributes.fontSize == QLatin1String("x-large"))
+                size = sizeTable[XLarge];
+            else if (attributes.fontSize == QLatin1String("xx-large"))
+                size = sizeTable[XXLarge];
+            break;
+        case 's':
+            if (attributes.fontSize == QLatin1String("small"))
+                size = sizeTable[Small];
+            break;
+        case 'm':
+            if (attributes.fontSize == QLatin1String("medium"))
+                size = sizeTable[Medium];
+            break;
+        case 'l':
+            if (attributes.fontSize == QLatin1String("large"))
+                size = sizeTable[Large];
+            break;
+        default:
+            size = parseLength(attributes.fontSize.toString(), dummy, handler);
+            break;
+        }
+        fontStyle->setSize(size);
+    }
+
+    if (!attributes.fontStyle.isEmpty() && attributes.fontStyle != QT_INHERIT) {
+        if (attributes.fontStyle == QLatin1String("normal")) {
+            fontStyle->setStyle(QFont::StyleNormal);
+        } else if (attributes.fontStyle == QLatin1String("italic")) {
+            fontStyle->setStyle(QFont::StyleItalic);
+        } else if (attributes.fontStyle == QLatin1String("oblique")) {
+            fontStyle->setStyle(QFont::StyleOblique);
+        }
+    }
+
+    if (!attributes.fontWeight.isEmpty() && attributes.fontWeight != QT_INHERIT) {
+        bool ok = false;
+        int weightNum = attributes.fontWeight.toString().toInt(&ok);
+        if (ok) {
+            fontStyle->setWeight(weightNum);
+        } else {
+            if (attributes.fontWeight == QLatin1String("normal")) {
+                fontStyle->setWeight(400);
+            } else if (attributes.fontWeight == QLatin1String("bold")) {
+                fontStyle->setWeight(700);
+            } else if (attributes.fontWeight == QLatin1String("bolder")) {
+                fontStyle->setWeight(QSvgFontStyle::BOLDER);
+            } else if (attributes.fontWeight == QLatin1String("lighter")) {
+                fontStyle->setWeight(QSvgFontStyle::LIGHTER);
+            }
+        }
+    }
+
+    if (!attributes.fontVariant.isEmpty() && attributes.fontVariant != QT_INHERIT) {
+        if (attributes.fontVariant == QLatin1String("normal"))
+            fontStyle->setVariant(QFont::MixedCase);
+        else if (attributes.fontVariant == QLatin1String("small-caps"))
+            fontStyle->setVariant(QFont::SmallCaps);
+    }
+
+    if (!attributes.textAnchor.isEmpty() && attributes.textAnchor != QT_INHERIT) {
+        if (attributes.textAnchor == QLatin1String("start"))
+            fontStyle->setTextAnchor(Qt::AlignLeft);
+        if (attributes.textAnchor == QLatin1String("middle"))
+           fontStyle->setTextAnchor(Qt::AlignHCenter);
+        else if (attributes.textAnchor == QLatin1String("end"))
+           fontStyle->setTextAnchor(Qt::AlignRight);
+    }
+
+    node->appendStyleProperty(fontStyle, attributes.id);
+}
+
+static void parseTransform(QSvgNode *node,
+                           const QSvgAttributes &attributes,
+                           QSvgHandler *)
+{
+    if (attributes.transform.isEmpty())
+        return;
+    QMatrix matrix = parseTransformationMatrix(trimRef(attributes.transform));
+
+    if (!matrix.isIdentity()) {
+        node->appendStyleProperty(new QSvgTransformStyle(QTransform(matrix)), attributes.id);
+    }
+
+}
+
+static void parseVisibility(QSvgNode *node,
+                            const QSvgAttributes &attributes,
+                            QSvgHandler *)
+{
+    QSvgNode *parent = node->parent();
+
+    if (parent && (attributes.visibility.isEmpty() || attributes.visibility == QT_INHERIT))
+        node->setVisible(parent->isVisible());
+    else if (attributes.visibility == QLatin1String("hidden") || attributes.visibility == QLatin1String("collapse")) {
+        node->setVisible(false);
+    } else
+        node->setVisible(true);
+}
+
+static void pathArcSegment(QPainterPath &path,
+                           qreal xc, qreal yc,
+                           qreal th0, qreal th1,
+                           qreal rx, qreal ry, qreal xAxisRotation)
+{
+    qreal sinTh, cosTh;
+    qreal a00, a01, a10, a11;
+    qreal x1, y1, x2, y2, x3, y3;
+    qreal t;
+    qreal thHalf;
+
+    sinTh = qSin(xAxisRotation * (Q_PI / 180.0));
+    cosTh = qCos(xAxisRotation * (Q_PI / 180.0));
+
+    a00 =  cosTh * rx;
+    a01 = -sinTh * ry;
+    a10 =  sinTh * rx;
+    a11 =  cosTh * ry;
+
+    thHalf = 0.5 * (th1 - th0);
+    t = (8.0 / 3.0) * qSin(thHalf * 0.5) * qSin(thHalf * 0.5) / qSin(thHalf);
+    x1 = xc + qCos(th0) - t * qSin(th0);
+    y1 = yc + qSin(th0) + t * qCos(th0);
+    x3 = xc + qCos(th1);
+    y3 = yc + qSin(th1);
+    x2 = x3 + t * qSin(th1);
+    y2 = y3 - t * qCos(th1);
+
+    path.cubicTo(a00 * x1 + a01 * y1, a10 * x1 + a11 * y1,
+                 a00 * x2 + a01 * y2, a10 * x2 + a11 * y2,
+                 a00 * x3 + a01 * y3, a10 * x3 + a11 * y3);
+}
+
+// the arc handling code underneath is from XSVG (BSD license)
+/*
+ * Copyright  2002 USC/Information Sciences Institute
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Information Sciences Institute not be used in advertising or
+ * publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Information Sciences Institute
+ * makes no representations about the suitability of this software for
+ * any purpose.  It is provided "as is" without express or implied
+ * warranty.
+ *
+ * INFORMATION SCIENCES INSTITUTE DISCLAIMS ALL WARRANTIES WITH REGARD
+ * TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL INFORMATION SCIENCES
+ * INSTITUTE BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA
+ * OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ *
+ */
+static void pathArc(QPainterPath &path,
+                    qreal               rx,
+                    qreal               ry,
+                    qreal               x_axis_rotation,
+                    int         large_arc_flag,
+                    int         sweep_flag,
+                    qreal               x,
+                    qreal               y,
+                    qreal curx, qreal cury)
+{
+    qreal sin_th, cos_th;
+    qreal a00, a01, a10, a11;
+    qreal x0, y0, x1, y1, xc, yc;
+    qreal d, sfactor, sfactor_sq;
+    qreal th0, th1, th_arc;
+    int i, n_segs;
+    qreal dx, dy, dx1, dy1, Pr1, Pr2, Px, Py, check;
+
+    rx = qAbs(rx);
+    ry = qAbs(ry);
+
+    sin_th = qSin(x_axis_rotation * (Q_PI / 180.0));
+    cos_th = qCos(x_axis_rotation * (Q_PI / 180.0));
+
+    dx = (curx - x) / 2.0;
+    dy = (cury - y) / 2.0;
+    dx1 =  cos_th * dx + sin_th * dy;
+    dy1 = -sin_th * dx + cos_th * dy;
+    Pr1 = rx * rx;
+    Pr2 = ry * ry;
+    Px = dx1 * dx1;
+    Py = dy1 * dy1;
+    /* Spec : check if radii are large enough */
+    check = Px / Pr1 + Py / Pr2;
+    if (check > 1) {
+        rx = rx * qSqrt(check);
+        ry = ry * qSqrt(check);
+    }
+
+    a00 =  cos_th / rx;
+    a01 =  sin_th / rx;
+    a10 = -sin_th / ry;
+    a11 =  cos_th / ry;
+    x0 = a00 * curx + a01 * cury;
+    y0 = a10 * curx + a11 * cury;
+    x1 = a00 * x + a01 * y;
+    y1 = a10 * x + a11 * y;
+    /* (x0, y0) is current point in transformed coordinate space.
+       (x1, y1) is new point in transformed coordinate space.
+
+       The arc fits a unit-radius circle in this space.
+    */
+    d = (x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0);
+    sfactor_sq = 1.0 / d - 0.25;
+    if (sfactor_sq < 0) sfactor_sq = 0;
+    sfactor = qSqrt(sfactor_sq);
+    if (sweep_flag == large_arc_flag) sfactor = -sfactor;
+    xc = 0.5 * (x0 + x1) - sfactor * (y1 - y0);
+    yc = 0.5 * (y0 + y1) + sfactor * (x1 - x0);
+    /* (xc, yc) is center of the circle. */
+
+    th0 = qAtan2(y0 - yc, x0 - xc);
+    th1 = qAtan2(y1 - yc, x1 - xc);
+
+    th_arc = th1 - th0;
+    if (th_arc < 0 && sweep_flag)
+        th_arc += 2 * Q_PI;
+    else if (th_arc > 0 && !sweep_flag)
+        th_arc -= 2 * Q_PI;
+
+    n_segs = qCeil(qAbs(th_arc / (Q_PI * 0.5 + 0.001)));
+
+    for (i = 0; i < n_segs; i++) {
+        pathArcSegment(path, xc, yc,
+                       th0 + i * th_arc / n_segs,
+                       th0 + (i + 1) * th_arc / n_segs,
+                       rx, ry, x_axis_rotation);
+    }
+}
+
+static bool parsePathDataFast(const QStringRef &dataStr, QPainterPath &path)
+{
+    qreal x0 = 0, y0 = 0;              // starting point
+    qreal x = 0, y = 0;                // current point
+    char lastMode = 0;
+    QPointF ctrlPt;
+    const QChar *str = dataStr.constData();
+    const QChar *end = str + dataStr.size();
+
+    while (str != end) {
+        while (str->isSpace())
+            ++str;
+        QChar pathElem = *str;
+        ++str;
+        QChar endc = *end;
+        *const_cast<QChar *>(end) = 0; // parseNumbersArray requires 0-termination that QStringRef cannot guarantee
+        QVarLengthArray<qreal, 8> arg;
+        parseNumbersArray(str, arg);
+        *const_cast<QChar *>(end) = endc;
+        if (pathElem == QLatin1Char('z') || pathElem == QLatin1Char('Z'))
+            arg.append(0);//dummy
+        const qreal *num = arg.constData();
+        int count = arg.count();
+        while (count > 0) {
+            qreal offsetX = x;        // correction offsets
+            qreal offsetY = y;        // for relative commands
+            switch (pathElem.unicode()) {
+            case 'm': {
+                if (count < 2) {
+                    num++;
+                    count--;
+                    break;
+                }
+                x = x0 = num[0] + offsetX;
+                y = y0 = num[1] + offsetY;
+                num += 2;
+                count -= 2;
+                path.moveTo(x0, y0);
+
+                 // As per 1.2  spec 8.3.2 The "moveto" commands
+                 // If a 'moveto' is followed by multiple pairs of coordinates without explicit commands,
+                 // the subsequent pairs shall be treated as implicit 'lineto' commands.
+                 pathElem = QLatin1Char('l');
+            }
+                break;
+            case 'M': {
+                if (count < 2) {
+                    num++;
+                    count--;
+                    break;
+                }
+                x = x0 = num[0];
+                y = y0 = num[1];
+                num += 2;
+                count -= 2;
+                path.moveTo(x0, y0);
+
+                // As per 1.2  spec 8.3.2 The "moveto" commands
+                // If a 'moveto' is followed by multiple pairs of coordinates without explicit commands,
+                // the subsequent pairs shall be treated as implicit 'lineto' commands.
+                pathElem = QLatin1Char('L');
+            }
+                break;
+            case 'z':
+            case 'Z': {
+                x = x0;
+                y = y0;
+                count--; // skip dummy
+                num++;
+                path.closeSubpath();
+            }
+                break;
+            case 'l': {
+                if (count < 2) {
+                    num++;
+                    count--;
+                    break;
+                }
+                x = num[0] + offsetX;
+                y = num[1] + offsetY;
+                num += 2;
+                count -= 2;
+                path.lineTo(x, y);
+
+            }
+                break;
+            case 'L': {
+                if (count < 2) {
+                    num++;
+                    count--;
+                    break;
+                }
+                x = num[0];
+                y = num[1];
+                num += 2;
+                count -= 2;
+                path.lineTo(x, y);
+            }
+                break;
+            case 'h': {
+                x = num[0] + offsetX;
+                num++;
+                count--;
+                path.lineTo(x, y);
+            }
+                break;
+            case 'H': {
+                x = num[0];
+                num++;
+                count--;
+                path.lineTo(x, y);
+            }
+                break;
+            case 'v': {
+                y = num[0] + offsetY;
+                num++;
+                count--;
+                path.lineTo(x, y);
+            }
+                break;
+            case 'V': {
+                y = num[0];
+                num++;
+                count--;
+                path.lineTo(x, y);
+            }
+                break;
+            case 'c': {
+                if (count < 6) {
+                    num += count;
+                    count = 0;
+                    break;
+                }
+                QPointF c1(num[0] + offsetX, num[1] + offsetY);
+                QPointF c2(num[2] + offsetX, num[3] + offsetY);
+                QPointF e(num[4] + offsetX, num[5] + offsetY);
+                num += 6;
+                count -= 6;
+                path.cubicTo(c1, c2, e);
+                ctrlPt = c2;
+                x = e.x();
+                y = e.y();
+                break;
+            }
+            case 'C': {
+                if (count < 6) {
+                    num += count;
+                    count = 0;
+                    break;
+                }
+                QPointF c1(num[0], num[1]);
+                QPointF c2(num[2], num[3]);
+                QPointF e(num[4], num[5]);
+                num += 6;
+                count -= 6;
+                path.cubicTo(c1, c2, e);
+                ctrlPt = c2;
+                x = e.x();
+                y = e.y();
+                break;
+            }
+            case 's': {
+                if (count < 4) {
+                    num += count;
+                    count = 0;
+                    break;
+                }
+                QPointF c1;
+                if (lastMode == 'c' || lastMode == 'C' ||
+                    lastMode == 's' || lastMode == 'S')
+                    c1 = QPointF(2*x-ctrlPt.x(), 2*y-ctrlPt.y());
+                else
+                    c1 = QPointF(x, y);
+                QPointF c2(num[0] + offsetX, num[1] + offsetY);
+                QPointF e(num[2] + offsetX, num[3] + offsetY);
+                num += 4;
+                count -= 4;
+                path.cubicTo(c1, c2, e);
+                ctrlPt = c2;
+                x = e.x();
+                y = e.y();
+                break;
+            }
+            case 'S': {
+                if (count < 4) {
+                    num += count;
+                    count = 0;
+                    break;
+                }
+                QPointF c1;
+                if (lastMode == 'c' || lastMode == 'C' ||
+                    lastMode == 's' || lastMode == 'S')
+                    c1 = QPointF(2*x-ctrlPt.x(), 2*y-ctrlPt.y());
+                else
+                    c1 = QPointF(x, y);
+                QPointF c2(num[0], num[1]);
+                QPointF e(num[2], num[3]);
+                num += 4;
+                count -= 4;
+                path.cubicTo(c1, c2, e);
+                ctrlPt = c2;
+                x = e.x();
+                y = e.y();
+                break;
+            }
+            case 'q': {
+                if (count < 4) {
+                    num += count;
+                    count = 0;
+                    break;
+                }
+                QPointF c(num[0] + offsetX, num[1] + offsetY);
+                QPointF e(num[2] + offsetX, num[3] + offsetY);
+                num += 4;
+                count -= 4;
+                path.quadTo(c, e);
+                ctrlPt = c;
+                x = e.x();
+                y = e.y();
+                break;
+            }
+            case 'Q': {
+                if (count < 4) {
+                    num += count;
+                    count = 0;
+                    break;
+                }
+                QPointF c(num[0], num[1]);
+                QPointF e(num[2], num[3]);
+                num += 4;
+                count -= 4;
+                path.quadTo(c, e);
+                ctrlPt = c;
+                x = e.x();
+                y = e.y();
+                break;
+            }
+            case 't': {
+                if (count < 2) {
+                    num += count;
+                    count = 0;
+                    break;
+                }
+                QPointF e(num[0] + offsetX, num[1] + offsetY);
+                num += 2;
+                count -= 2;
+                QPointF c;
+                if (lastMode == 'q' || lastMode == 'Q' ||
+                    lastMode == 't' || lastMode == 'T')
+                    c = QPointF(2*x-ctrlPt.x(), 2*y-ctrlPt.y());
+                else
+                    c = QPointF(x, y);
+                path.quadTo(c, e);
+                ctrlPt = c;
+                x = e.x();
+                y = e.y();
+                break;
+            }
+            case 'T': {
+                if (count < 2) {
+                    num += count;
+                    count = 0;
+                    break;
+                }
+                QPointF e(num[0], num[1]);
+                num += 2;
+                count -= 2;
+                QPointF c;
+                if (lastMode == 'q' || lastMode == 'Q' ||
+                    lastMode == 't' || lastMode == 'T')
+                    c = QPointF(2*x-ctrlPt.x(), 2*y-ctrlPt.y());
+                else
+                    c = QPointF(x, y);
+                path.quadTo(c, e);
+                ctrlPt = c;
+                x = e.x();
+                y = e.y();
+                break;
+            }
+            case 'a': {
+                if (count < 7) {
+                    num += count;
+                    count = 0;
+                    break;
+                }
+                qreal rx = (*num++);
+                qreal ry = (*num++);
+                qreal xAxisRotation = (*num++);
+                qreal largeArcFlag  = (*num++);
+                qreal sweepFlag = (*num++);
+                qreal ex = (*num++) + offsetX;
+                qreal ey = (*num++) + offsetY;
+                count -= 7;
+                qreal curx = x;
+                qreal cury = y;
+                pathArc(path, rx, ry, xAxisRotation, int(largeArcFlag),
+                        int(sweepFlag), ex, ey, curx, cury);
+
+                x = ex;
+                y = ey;
+            }
+                break;
+            case 'A': {
+                if (count < 7) {
+                    num += count;
+                    count = 0;
+                    break;
+                }
+                qreal rx = (*num++);
+                qreal ry = (*num++);
+                qreal xAxisRotation = (*num++);
+                qreal largeArcFlag  = (*num++);
+                qreal sweepFlag = (*num++);
+                qreal ex = (*num++);
+                qreal ey = (*num++);
+                count -= 7;
+                qreal curx = x;
+                qreal cury = y;
+                pathArc(path, rx, ry, xAxisRotation, int(largeArcFlag),
+                        int(sweepFlag), ex, ey, curx, cury);
+
+                x = ex;
+                y = ey;
+            }
+                break;
+            default:
+                return false;
+            }
+            lastMode = pathElem.toLatin1();
+        }
+    }
+    return true;
+}
+
+static bool parseStyle(QSvgNode *node,
+                       const QXmlStreamAttributes &attributes,
+                       QSvgHandler *);
+
+static bool parseStyle(QSvgNode *node,
+                       const QSvgAttributes &attributes,
+                       QSvgHandler *);
+
+static void parseCSStoXMLAttrs(const QVector<QCss::Declaration> &declarations,
+                               QXmlStreamAttributes &attributes)
+{
+    for (int i = 0; i < declarations.count(); ++i) {
+        const QCss::Declaration &decl = declarations.at(i);
+        if (decl.d->property.isEmpty())
+            continue;
+        QCss::Value val = decl.d->values.first();
+        QString valueStr;
+        if (decl.d->values.count() != 1) {
+            for (int i=0; i<decl.d->values.count(); ++i) {
+                const QString &value = decl.d->values[i].toString();
+                if (value.isEmpty())
+                    valueStr += QLatin1Char(',');
+                else
+                    valueStr += value;
+            }
+        } else {
+            valueStr = val.toString();
+        }
+        if (val.type == QCss::Value::Uri) {
+            valueStr.prepend(QLatin1String("url("));
+            valueStr.append(QLatin1Char(')'));
+        } else if (val.type == QCss::Value::Function) {
+            QStringList lst = val.variant.toStringList();
+            valueStr.append(lst.at(0));
+            valueStr.append(QLatin1Char('('));
+            for (int i = 1; i < lst.count(); ++i) {
+                valueStr.append(lst.at(i));
+                if ((i +1) < lst.count())
+                    valueStr.append(QLatin1Char(','));
+            }
+            valueStr.append(QLatin1Char(')'));
+        } else if (val.type == QCss::Value::KnownIdentifier) {
+            switch (val.variant.toInt()) {
+            case QCss::Value_None:
+                valueStr = QLatin1String("none");
+                break;
+            default:
+                break;
+            }
+        }
+
+        attributes.append(QString(), decl.d->property, valueStr);
+    }
+}
+
+void QSvgHandler::parseCSStoXMLAttrs(QString css, QVector<QSvgCssAttribute> *attributes)
+{
+    // preprocess (for unicode escapes), tokenize and remove comments
+    m_cssParser.init(css);
+    QString key;
+
+    attributes->reserve(10);
+
+    while (m_cssParser.hasNext()) {
+        m_cssParser.skipSpace();
+
+        if (!m_cssParser.hasNext())
+            break;
+        m_cssParser.next();
+
+        QStringRef name;
+        if (m_cssParser.hasEscapeSequences) {
+            key = m_cssParser.lexem();
+            name = QStringRef(&key, 0, key.length());
+        } else {
+            const QCss::Symbol &sym = m_cssParser.symbol();
+            name = QStringRef(&sym.text, sym.start, sym.len);
+        }
+
+        m_cssParser.skipSpace();
+        if (!m_cssParser.test(QCss::COLON))
+            break;
+
+        m_cssParser.skipSpace();
+        if (!m_cssParser.hasNext())
+            break;
+
+        QSvgCssAttribute attribute;
+        attribute.name = QXmlStreamStringRef(name);
+
+        const int firstSymbol = m_cssParser.index;
+        int symbolCount = 0;
+        do {
+            m_cssParser.next();
+            ++symbolCount;
+        } while (m_cssParser.hasNext() && !m_cssParser.test(QCss::SEMICOLON));
+
+        bool canExtractValueByRef = !m_cssParser.hasEscapeSequences;
+        if (canExtractValueByRef) {
+            int len = m_cssParser.symbols.at(firstSymbol).len;
+            for (int i = firstSymbol + 1; i < firstSymbol + symbolCount; ++i) {
+                len += m_cssParser.symbols.at(i).len;
+
+                if (m_cssParser.symbols.at(i - 1).start + m_cssParser.symbols.at(i - 1).len
+                        != m_cssParser.symbols.at(i).start) {
+                    canExtractValueByRef = false;
+                    break;
+                }
+            }
+            if (canExtractValueByRef) {
+                const QCss::Symbol &sym = m_cssParser.symbols.at(firstSymbol);
+                attribute.value = QXmlStreamStringRef(QStringRef(&sym.text, sym.start, len));
+            }
+        }
+        if (!canExtractValueByRef) {
+            QString value;
+            for (int i = firstSymbol; i < m_cssParser.index - 1; ++i)
+                value += m_cssParser.symbols.at(i).lexem();
+            attribute.value = QXmlStreamStringRef(QStringRef(&value, 0, value.length()));
+        }
+
+        attributes->append(attribute);
+
+        m_cssParser.skipSpace();
+    }
+}
+
+static void cssStyleLookup(QSvgNode *node,
+                           QSvgHandler *handler,
+                           QSvgStyleSelector *selector)
+{
+    QCss::StyleSelector::NodePtr cssNode;
+    cssNode.ptr = node;
+    QVector<QCss::Declaration> decls = selector->declarationsForNode(cssNode);
+
+    QXmlStreamAttributes attributes;
+    parseCSStoXMLAttrs(decls, attributes);
+    parseStyle(node, attributes, handler);
+}
+
+static inline QStringList stringToList(const QString &str)
+{
+    QStringList lst = str.split(QLatin1Char(','), QString::SkipEmptyParts);
+    return lst;
+}
+
+static bool parseCoreNode(QSvgNode *node,
+                          const QXmlStreamAttributes &attributes)
+{
+    QStringList features;
+    QStringList extensions;
+    QStringList languages;
+    QStringList formats;
+    QStringList fonts;
+    QString xmlClassStr;
+
+    for (int i = 0; i < attributes.count(); ++i) {
+        const QXmlStreamAttribute &attribute = attributes.at(i);
+        QStringRef name = attribute.qualifiedName();
+        if (name.isEmpty())
+            continue;
+        QStringRef value = attribute.value();
+        switch (name.at(0).unicode()) {
+        case 'c':
+            if (name == QLatin1String("class"))
+                xmlClassStr = value.toString();
+            break;
+        case 'r':
+            if (name == QLatin1String("requiredFeatures"))
+                features = stringToList(value.toString());
+            else if (name == QLatin1String("requiredExtensions"))
+                extensions = stringToList(value.toString());
+            else if (name == QLatin1String("requiredFormats"))
+                formats = stringToList(value.toString());
+            else if (name == QLatin1String("requiredFonts"))
+                fonts = stringToList(value.toString());
+            break;
+        case 's':
+            if (name == QLatin1String("systemLanguage"))
+                languages = stringToList(value.toString());
+            break;
+        default:
+            break;
+        }
+    }
+
+    node->setRequiredFeatures(features);
+    node->setRequiredExtensions(extensions);
+    node->setRequiredLanguages(languages);
+    node->setRequiredFormats(formats);
+    node->setRequiredFonts(fonts);
+    node->setNodeId(someId(attributes));
+    node->setXmlClass(xmlClassStr);
+
+    return true;
+}
+
+static void parseOpacity(QSvgNode *node,
+                         const QSvgAttributes &attributes,
+                         QSvgHandler *)
+{
+    if (attributes.opacity.isEmpty())
+        return;
+
+    const QString value = attributes.opacity.toString().trimmed();
+
+    bool ok = false;
+    qreal op = value.toDouble(&ok);
+
+    if (ok) {
+        QSvgOpacityStyle *opacity = new QSvgOpacityStyle(qBound(qreal(0.0), op, qreal(1.0)));
+        node->appendStyleProperty(opacity, attributes.id);
+    }
+}
+
+static QPainter::CompositionMode svgToQtCompositionMode(const QString &op)
+{
+#define NOOP qDebug()<<"Operation: "<<op<<" is not implemented"
+    if (op == QLatin1String("clear")) {
+        return QPainter::CompositionMode_Clear;
+    } else if (op == QLatin1String("src")) {
+        return QPainter::CompositionMode_Source;
+    } else if (op == QLatin1String("dst")) {
+        return QPainter::CompositionMode_Destination;
+    } else if (op == QLatin1String("src-over")) {
+        return QPainter::CompositionMode_SourceOver;
+    } else if (op == QLatin1String("dst-over")) {
+        return QPainter::CompositionMode_DestinationOver;
+    } else if (op == QLatin1String("src-in")) {
+        return QPainter::CompositionMode_SourceIn;
+    } else if (op == QLatin1String("dst-in")) {
+        return QPainter::CompositionMode_DestinationIn;
+    } else if (op == QLatin1String("src-out")) {
+        return QPainter::CompositionMode_SourceOut;
+    } else if (op == QLatin1String("dst-out")) {
+        return QPainter::CompositionMode_DestinationOut;
+    } else if (op == QLatin1String("src-atop")) {
+        return QPainter::CompositionMode_SourceAtop;
+    } else if (op == QLatin1String("dst-atop")) {
+        return QPainter::CompositionMode_DestinationAtop;
+    } else if (op == QLatin1String("xor")) {
+        return QPainter::CompositionMode_Xor;
+    } else if (op == QLatin1String("plus")) {
+        return QPainter::CompositionMode_Plus;
+    } else if (op == QLatin1String("multiply")) {
+        return QPainter::CompositionMode_Multiply;
+    } else if (op == QLatin1String("screen")) {
+        return QPainter::CompositionMode_Screen;
+    } else if (op == QLatin1String("overlay")) {
+        return QPainter::CompositionMode_Overlay;
+    } else if (op == QLatin1String("darken")) {
+        return QPainter::CompositionMode_Darken;
+    } else if (op == QLatin1String("lighten")) {
+        return QPainter::CompositionMode_Lighten;
+    } else if (op == QLatin1String("color-dodge")) {
+        return QPainter::CompositionMode_ColorDodge;
+    } else if (op == QLatin1String("color-burn")) {
+        return QPainter::CompositionMode_ColorBurn;
+    } else if (op == QLatin1String("hard-light")) {
+        return QPainter::CompositionMode_HardLight;
+    } else if (op == QLatin1String("soft-light")) {
+        return QPainter::CompositionMode_SoftLight;
+    } else if (op == QLatin1String("difference")) {
+        return QPainter::CompositionMode_Difference;
+    } else if (op == QLatin1String("exclusion")) {
+        return QPainter::CompositionMode_Exclusion;
+    } else {
+        NOOP;
+    }
+
+    return QPainter::CompositionMode_SourceOver;
+}
+
+static void parseCompOp(QSvgNode *node,
+                        const QSvgAttributes &attributes,
+                        QSvgHandler *)
+{
+    if (attributes.compOp.isEmpty())
+        return;
+    QString value = attributes.compOp.toString().trimmed();
+
+    if (!value.isEmpty()) {
+        QSvgCompOpStyle *compop = new QSvgCompOpStyle(svgToQtCompositionMode(value));
+        node->appendStyleProperty(compop, attributes.id);
+    }
+}
+
+static inline QSvgNode::DisplayMode displayStringToEnum(const QString &str)
+{
+    if (str == QLatin1String("inline")) {
+        return QSvgNode::InlineMode;
+    } else if (str == QLatin1String("block")) {
+        return QSvgNode::BlockMode;
+    } else if (str == QLatin1String("list-item")) {
+        return QSvgNode::ListItemMode;
+    } else if (str == QLatin1String("run-in")) {
+        return QSvgNode::RunInMode;
+    } else if (str == QLatin1String("compact")) {
+        return QSvgNode::CompactMode;
+    } else if (str == QLatin1String("marker")) {
+        return QSvgNode::MarkerMode;
+    } else if (str == QLatin1String("table")) {
+        return QSvgNode::TableMode;
+    } else if (str == QLatin1String("inline-table")) {
+        return QSvgNode::InlineTableMode;
+    } else if (str == QLatin1String("table-row")) {
+        return QSvgNode::TableRowGroupMode;
+    } else if (str == QLatin1String("table-header-group")) {
+        return QSvgNode::TableHeaderGroupMode;
+    } else if (str == QLatin1String("table-footer-group")) {
+        return QSvgNode::TableFooterGroupMode;
+    } else if (str == QLatin1String("table-row")) {
+        return QSvgNode::TableRowMode;
+    } else if (str == QLatin1String("table-column-group")) {
+        return QSvgNode::TableColumnGroupMode;
+    } else if (str == QLatin1String("table-column")) {
+        return QSvgNode::TableColumnMode;
+    } else if (str == QLatin1String("table-cell")) {
+        return QSvgNode::TableCellMode;
+    } else if (str == QLatin1String("table-caption")) {
+        return QSvgNode::TableCaptionMode;
+    } else if (str == QLatin1String("none")) {
+        return QSvgNode::NoneMode;
+    } else if (str == QT_INHERIT) {
+        return QSvgNode::InheritMode;
+    }
+    return QSvgNode::BlockMode;
+}
+
+static void parseOthers(QSvgNode *node,
+                        const QSvgAttributes &attributes,
+                        QSvgHandler *)
+{
+    if (attributes.display.isEmpty())
+        return;
+    QString displayStr = attributes.display.toString().trimmed();
+
+    if (!displayStr.isEmpty()) {
+        node->setDisplayMode(displayStringToEnum(displayStr));
+    }
+}
+
+static bool parseStyle(QSvgNode *node,
+                       const QSvgAttributes &attributes,
+                       QSvgHandler *handler)
+{
+    parseColor(node, attributes, handler);
+    parseBrush(node, attributes, handler);
+    parsePen(node, attributes, handler);
+    parseFont(node, attributes, handler);
+    parseTransform(node, attributes, handler);
+    parseVisibility(node, attributes, handler);
+    parseOpacity(node, attributes, handler);
+    parseCompOp(node, attributes, handler);
+    parseOthers(node, attributes, handler);
+#if 0
+    value = attributes.value("audio-level");
+
+    value = attributes.value("color-rendering");
+
+    value = attributes.value("display-align");
+
+    value = attributes.value("image-rendering");
+
+    value = attributes.value("line-increment");
+
+    value = attributes.value("pointer-events");
+
+    value = attributes.value("shape-rendering");
+
+    value = attributes.value("solid-color");
+
+    value = attributes.value("solid-opacity");
+
+    value = attributes.value("text-rendering");
+
+    value = attributes.value("vector-effect");
+
+    value = attributes.value("viewport-fill");
+
+    value = attributes.value("viewport-fill-opacity");
+#endif
+    return true;
+}
+
+static bool parseStyle(QSvgNode *node,
+                       const QXmlStreamAttributes &attrs,
+                       QSvgHandler *handler)
+{
+    return parseStyle(node, QSvgAttributes(attrs, handler), handler);
+}
+
+static bool parseAnchorNode(QSvgNode *parent,
+                            const QXmlStreamAttributes &attributes,
+                            QSvgHandler *)
+{
+    Q_UNUSED(parent); Q_UNUSED(attributes);
+    return true;
+}
+
+static bool parseAnimateNode(QSvgNode *parent,
+                             const QXmlStreamAttributes &attributes,
+                             QSvgHandler *)
+{
+    Q_UNUSED(parent); Q_UNUSED(attributes);
+    return true;
+}
+
+static bool parseAnimateColorNode(QSvgNode *parent,
+                                  const QXmlStreamAttributes &attributes,
+                                  QSvgHandler *handler)
+{
+    QString typeStr    = attributes.value(QLatin1String("type")).toString();
+    QStringRef fromStr    = attributes.value(QLatin1String("from"));
+    QStringRef toStr      = attributes.value(QLatin1String("to"));
+    QString valuesStr  = attributes.value(QLatin1String("values")).toString();
+    QString beginStr   = attributes.value(QLatin1String("begin")).toString();
+    QString durStr     = attributes.value(QLatin1String("dur")).toString();
+    QString targetStr  = attributes.value(QLatin1String("attributeName")).toString();
+    QString repeatStr  = attributes.value(QLatin1String("repeatCount")).toString();
+    QString fillStr    = attributes.value(QLatin1String("fill")).toString();
+
+    QList<QColor> colors;
+    if (valuesStr.isEmpty()) {
+        QColor startColor, endColor;
+        resolveColor(fromStr, startColor, handler);
+        resolveColor(toStr, endColor, handler);
+        colors.append(startColor);
+        colors.append(endColor);
+    } else {
+        QStringList str = valuesStr.split(QLatin1Char(';'));
+        QStringList::const_iterator itr;
+        for (itr = str.constBegin(); itr != str.constEnd(); ++itr) {
+            QColor color;
+            QString str = *itr;
+            resolveColor(QStringRef(&str), color, handler);
+            colors.append(color);
+        }
+    }
+
+    int ms = 1000;
+    beginStr = beginStr.trimmed();
+    if (beginStr.endsWith(QLatin1String("ms"))) {
+        beginStr.chop(2);
+        ms = 1;
+    } else if (beginStr.endsWith(QLatin1String("s"))) {
+        beginStr.chop(1);
+    }
+    durStr = durStr.trimmed();
+    if (durStr.endsWith(QLatin1String("ms"))) {
+        durStr.chop(2);
+        ms = 1;
+    } else if (durStr.endsWith(QLatin1String("s"))) {
+        durStr.chop(1);
+    }
+    int begin = static_cast<int>(toDouble(beginStr) * ms);
+    int end   = static_cast<int>((toDouble(durStr) + begin) * ms);
+
+    QSvgAnimateColor *anim = new QSvgAnimateColor(begin, end, 0);
+    anim->setArgs((targetStr == QLatin1String("fill")), colors);
+    anim->setFreeze(fillStr == QLatin1String("freeze"));
+    anim->setRepeatCount(
+        (repeatStr == QLatin1String("indefinite")) ? -1 :
+            (repeatStr == QLatin1String("")) ? 1 : toDouble(repeatStr));
+
+    parent->appendStyleProperty(anim, someId(attributes));
+    parent->document()->setAnimated(true);
+    handler->setAnimPeriod(begin, end);
+    return true;
+}
+
+static bool parseAimateMotionNode(QSvgNode *parent,
+                                  const QXmlStreamAttributes &attributes,
+                                  QSvgHandler *)
+{
+    Q_UNUSED(parent); Q_UNUSED(attributes);
+    return true;
+}
+
+static void parseNumberTriplet(QVector<qreal> &values, const QChar *&s)
+{
+    QVector<qreal> list = parseNumbersList(s);
+    values << list;
+    for (int i = 3 - list.size(); i > 0; --i)
+        values.append(0.0);
+}
+
+static bool parseAnimateTransformNode(QSvgNode *parent,
+                                      const QXmlStreamAttributes &attributes,
+                                      QSvgHandler *handler)
+{
+    QString typeStr    = attributes.value(QLatin1String("type")).toString();
+    QString values     = attributes.value(QLatin1String("values")).toString();
+    QString beginStr   = attributes.value(QLatin1String("begin")).toString();
+    QString durStr     = attributes.value(QLatin1String("dur")).toString();
+    QString targetStr  = attributes.value(QLatin1String("attributeName")).toString();
+    QString repeatStr  = attributes.value(QLatin1String("repeatCount")).toString();
+    QString fillStr    = attributes.value(QLatin1String("fill")).toString();
+    QString fromStr    = attributes.value(QLatin1String("from")).toString();
+    QString toStr      = attributes.value(QLatin1String("to")).toString();
+    QString byStr      = attributes.value(QLatin1String("by")).toString();
+    QString addtv      = attributes.value(QLatin1String("additive")).toString();
+
+    QSvgAnimateTransform::Additive additive = QSvgAnimateTransform::Replace;
+    if (addtv == QLatin1String("sum"))
+        additive = QSvgAnimateTransform::Sum;
+
+    QVector<qreal> vals;
+    if (values.isEmpty()) {
+        const QChar *s;
+        if (fromStr.isEmpty()) {
+            if (!byStr.isEmpty()) {
+                // By-animation.
+                additive = QSvgAnimateTransform::Sum;
+                vals.append(0.0);
+                vals.append(0.0);
+                vals.append(0.0);
+                parseNumberTriplet(vals, s = byStr.constData());
+            } else {
+                // To-animation not defined.
+                return false;
+            }
+        } else {
+            if (!toStr.isEmpty()) {
+                // From-to-animation.
+                parseNumberTriplet(vals, s = fromStr.constData());
+                parseNumberTriplet(vals, s = toStr.constData());
+            } else if (!byStr.isEmpty()) {
+                // From-by-animation.
+                parseNumberTriplet(vals, s = fromStr.constData());
+                parseNumberTriplet(vals, s = byStr.constData());
+                for (int i = vals.size() - 3; i < vals.size(); ++i)
+                    vals[i] += vals[i - 3];
+            } else {
+                return false;
+            }
+        }
+    } else {
+        const QChar *s = values.constData();
+        while (s && *s != QLatin1Char(0)) {
+            parseNumberTriplet(vals, s);
+            if (*s == QLatin1Char(0))
+                break;
+            ++s;
+        }
+    }
+
+    int ms = 1000;
+    beginStr = beginStr.trimmed();
+    if (beginStr.endsWith(QLatin1String("ms"))) {
+        beginStr.chop(2);
+        ms = 1;
+    } else if (beginStr.endsWith(QLatin1String("s"))) {
+        beginStr.chop(1);
+    }
+    int begin = static_cast<int>(toDouble(beginStr) * ms);
+    durStr = durStr.trimmed();
+    if (durStr.endsWith(QLatin1String("ms"))) {
+        durStr.chop(2);
+        ms = 1;
+    } else if (durStr.endsWith(QLatin1String("s"))) {
+        durStr.chop(1);
+        ms = 1000;
+    }
+    int end = static_cast<int>(toDouble(durStr)*ms) + begin;
+
+    QSvgAnimateTransform::TransformType type = QSvgAnimateTransform::Empty;
+    if (typeStr == QLatin1String("translate")) {
+        type = QSvgAnimateTransform::Translate;
+    } else if (typeStr == QLatin1String("scale")) {
+        type = QSvgAnimateTransform::Scale;
+    } else if (typeStr == QLatin1String("rotate")) {
+        type = QSvgAnimateTransform::Rotate;
+    } else if (typeStr == QLatin1String("skewX")) {
+        type = QSvgAnimateTransform::SkewX;
+    } else if (typeStr == QLatin1String("skewY")) {
+        type = QSvgAnimateTransform::SkewY;
+    } else {
+        return false;
+    }
+
+    QSvgAnimateTransform *anim = new QSvgAnimateTransform(begin, end, 0);
+    anim->setArgs(type, additive, vals);
+    anim->setFreeze(fillStr == QLatin1String("freeze"));
+    anim->setRepeatCount(
+            (repeatStr == QLatin1String("indefinite"))? -1 :
+            (repeatStr == QLatin1String(""))? 1 : toDouble(repeatStr));
+
+    parent->appendStyleProperty(anim, someId(attributes));
+    parent->document()->setAnimated(true);
+    handler->setAnimPeriod(begin, end);
+    return true;
+}
+
+static QSvgNode * createAnimationNode(QSvgNode *parent,
+                                      const QXmlStreamAttributes &attributes,
+                                      QSvgHandler *)
+{
+    Q_UNUSED(parent); Q_UNUSED(attributes);
+    return 0;
+}
+
+static bool parseAudioNode(QSvgNode *parent,
+                           const QXmlStreamAttributes &attributes,
+                           QSvgHandler *)
+{
+    Q_UNUSED(parent); Q_UNUSED(attributes);
+    return true;
+}
+
+static QSvgNode *createCircleNode(QSvgNode *parent,
+                                  const QXmlStreamAttributes &attributes,
+                                  QSvgHandler *)
+{
+    QString cx      = attributes.value(QLatin1String("cx")).toString();
+    QString cy      = attributes.value(QLatin1String("cy")).toString();
+    QString r       = attributes.value(QLatin1String("r")).toString();
+    qreal ncx = toDouble(cx);
+    qreal ncy = toDouble(cy);
+    qreal nr  = toDouble(r);
+
+    QRectF rect(ncx-nr, ncy-nr, nr*2, nr*2);
+    QSvgNode *circle = new QSvgCircle(parent, rect);
+    return circle;
+}
+
+static QSvgNode *createDefsNode(QSvgNode *parent,
+                                const QXmlStreamAttributes &attributes,
+                                QSvgHandler *)
+{
+    Q_UNUSED(attributes);
+    QSvgDefs *defs = new QSvgDefs(parent);
+    return defs;
+}
+
+static bool parseDescNode(QSvgNode *parent,
+                          const QXmlStreamAttributes &attributes,
+                          QSvgHandler *)
+{
+    Q_UNUSED(parent); Q_UNUSED(attributes);
+    return true;
+}
+
+static bool parseDiscardNode(QSvgNode *parent,
+                             const QXmlStreamAttributes &attributes,
+                             QSvgHandler *)
+{
+    Q_UNUSED(parent); Q_UNUSED(attributes);
+    return true;
+}
+
+static QSvgNode *createEllipseNode(QSvgNode *parent,
+                                   const QXmlStreamAttributes &attributes,
+                                   QSvgHandler *)
+{
+    QString cx      = attributes.value(QLatin1String("cx")).toString();
+    QString cy      = attributes.value(QLatin1String("cy")).toString();
+    QString rx      = attributes.value(QLatin1String("rx")).toString();
+    QString ry      = attributes.value(QLatin1String("ry")).toString();
+    qreal ncx = toDouble(cx);
+    qreal ncy = toDouble(cy);
+    qreal nrx = toDouble(rx);
+    qreal nry = toDouble(ry);
+
+    QRectF rect(ncx-nrx, ncy-nry, nrx*2, nry*2);
+    QSvgNode *ellipse = new QSvgEllipse(parent, rect);
+    return ellipse;
+}
+
+static QSvgStyleProperty *createFontNode(QSvgNode *parent,
+                                         const QXmlStreamAttributes &attributes,
+                                         QSvgHandler *)
+{
+    QString hax      = attributes.value(QLatin1String("horiz-adv-x")).toString();
+    QString myId     = someId(attributes);
+
+    qreal horizAdvX = toDouble(hax);
+
+    while (parent && parent->type() != QSvgNode::DOC) {
+        parent = parent->parent();
+    }
+
+    if (parent) {
+        QSvgTinyDocument *doc = static_cast<QSvgTinyDocument*>(parent);
+        QSvgFont *font = new QSvgFont(horizAdvX);
+        font->setFamilyName(myId);
+        if (!font->familyName().isEmpty()) {
+            if (!doc->svgFont(font->familyName()))
+                doc->addSvgFont(font);
+        }
+        return new QSvgFontStyle(font, doc);
+    }
+    return 0;
+}
+
+static bool parseFontFaceNode(QSvgStyleProperty *parent,
+                              const QXmlStreamAttributes &attributes,
+                              QSvgHandler *)
+{
+    if (parent->type() != QSvgStyleProperty::FONT) {
+        return false;
+    }
+
+    QSvgFontStyle *style = static_cast<QSvgFontStyle*>(parent);
+    QSvgFont *font = style->svgFont();
+    QString name   = attributes.value(QLatin1String("font-family")).toString();
+    QString unitsPerEmStr   = attributes.value(QLatin1String("units-per-em")).toString();
+
+    qreal unitsPerEm = toDouble(unitsPerEmStr);
+    if (!unitsPerEm)
+        unitsPerEm = 1000;
+
+    if (!name.isEmpty())
+        font->setFamilyName(name);
+    font->setUnitsPerEm(unitsPerEm);
+
+    if (!font->familyName().isEmpty())
+        if (!style->doc()->svgFont(font->familyName()))
+            style->doc()->addSvgFont(font);
+
+    return true;
+}
+
+static bool parseFontFaceNameNode(QSvgStyleProperty *parent,
+                                  const QXmlStreamAttributes &attributes,
+                                  QSvgHandler *)
+{
+    if (parent->type() != QSvgStyleProperty::FONT) {
+        return false;
+    }
+
+    QSvgFontStyle *style = static_cast<QSvgFontStyle*>(parent);
+    QSvgFont *font = style->svgFont();
+    QString name   = attributes.value(QLatin1String("name")).toString();
+
+    if (!name.isEmpty())
+        font->setFamilyName(name);
+
+    if (!font->familyName().isEmpty())
+        if (!style->doc()->svgFont(font->familyName()))
+            style->doc()->addSvgFont(font);
+
+    return true;
+}
+
+static bool parseFontFaceSrcNode(QSvgStyleProperty *parent,
+                                 const QXmlStreamAttributes &attributes,
+                                 QSvgHandler *)
+{
+    Q_UNUSED(parent); Q_UNUSED(attributes);
+    return true;
+}
+
+static bool parseFontFaceUriNode(QSvgStyleProperty *parent,
+                                 const QXmlStreamAttributes &attributes,
+                                 QSvgHandler *)
+{
+    Q_UNUSED(parent); Q_UNUSED(attributes);
+    return true;
+}
+
+static bool parseForeignObjectNode(QSvgNode *parent,
+                                   const QXmlStreamAttributes &attributes,
+                                   QSvgHandler *)
+{
+    Q_UNUSED(parent); Q_UNUSED(attributes);
+    return true;
+}
+
+static QSvgNode *createGNode(QSvgNode *parent,
+                             const QXmlStreamAttributes &attributes,
+                             QSvgHandler *)
+{
+    Q_UNUSED(attributes);
+    QSvgG *node = new QSvgG(parent);
+    return node;
+}
+
+static bool parseGlyphNode(QSvgStyleProperty *parent,
+                           const QXmlStreamAttributes &attributes,
+                           QSvgHandler *)
+{
+    if (parent->type() != QSvgStyleProperty::FONT) {
+        return false;
+    }
+
+    QSvgFontStyle *style = static_cast<QSvgFontStyle*>(parent);
+    QSvgFont *font = style->svgFont();
+    createSvgGlyph(font, attributes);
+    return true;
+}
+
+static bool parseHandlerNode(QSvgNode *parent,
+                             const QXmlStreamAttributes &attributes,
+                             QSvgHandler *)
+{
+    Q_UNUSED(parent); Q_UNUSED(attributes);
+    return true;
+}
+
+static bool parseHkernNode(QSvgNode *parent,
+                           const QXmlStreamAttributes &attributes,
+                           QSvgHandler *)
+{
+    Q_UNUSED(parent); Q_UNUSED(attributes);
+    return true;
+}
+
+static QSvgNode *createImageNode(QSvgNode *parent,
+                                 const QXmlStreamAttributes &attributes,
+                                 QSvgHandler *handler)
+{
+    QString x = attributes.value(QLatin1String("x")).toString();
+    QString y = attributes.value(QLatin1String("y")).toString();
+    QString width  = attributes.value(QLatin1String("width")).toString();
+    QString height = attributes.value(QLatin1String("height")).toString();
+    QString filename = attributes.value(QLatin1String("xlink:href")).toString();
+    qreal nx = toDouble(x);
+    qreal ny = toDouble(y);
+    QSvgHandler::LengthType type;
+    qreal nwidth = parseLength(width, type, handler);
+    nwidth = convertToPixels(nwidth, true, type);
+
+    qreal nheight = parseLength(height, type, handler);
+    nheight = convertToPixels(nheight, false, type);
+
+
+    filename = filename.trimmed();
+    QImage image;
+    if (filename.startsWith(QLatin1String("data"))) {
+        int idx = filename.lastIndexOf(QLatin1String("base64,"));
+        if (idx != -1) {
+            idx += 7;
+            QString dataStr = filename.mid(idx);
+            QByteArray data = QByteArray::fromBase64(dataStr.toAscii());
+            image = QImage::fromData(data);
+        } else {
+            qDebug()<<"QSvgHandler::createImageNode: Unrecognized inline image format!";
+        }
+    } else
+        image = QImage(filename);
+
+    if (image.isNull()) {
+        qDebug()<<"couldn't create image from "<<filename;
+        return 0;
+    }
+
+    if (image.format() == QImage::Format_ARGB32)
+        image = image.convertToFormat(QImage::Format_ARGB32_Premultiplied);
+
+    QSvgNode *img = new QSvgImage(parent,
+                                  image,
+                                  QRect(int(nx),
+                                        int(ny),
+                                        int(nwidth),
+                                        int(nheight)));
+    return img;
+}
+
+static QSvgNode *createLineNode(QSvgNode *parent,
+                                const QXmlStreamAttributes &attributes,
+                                QSvgHandler *)
+{
+    QString x1 = attributes.value(QLatin1String("x1")).toString();
+    QString y1 = attributes.value(QLatin1String("y1")).toString();
+    QString x2 = attributes.value(QLatin1String("x2")).toString();
+    QString y2 = attributes.value(QLatin1String("y2")).toString();
+    qreal nx1 = toDouble(x1);
+    qreal ny1 = toDouble(y1);
+    qreal nx2 = toDouble(x2);
+    qreal ny2 = toDouble(y2);
+
+    QLineF lineBounds(nx1, ny1, nx2, ny2);
+    QSvgNode *line = new QSvgLine(parent, lineBounds);
+    return line;
+}
+
+
+static void parseBaseGradient(QSvgNode *node,
+                              const QXmlStreamAttributes &attributes,
+                              QSvgGradientStyle *gradProp,
+                              QSvgHandler *handler)
+{
+    QString link   = attributes.value(QLatin1String("xlink:href")).toString();
+    QStringRef trans  = attributes.value(QLatin1String("gradientTransform"));
+    QString spread = attributes.value(QLatin1String("spreadMethod")).toString();
+    QString units = attributes.value(QLatin1String("gradientUnits")).toString();
+    QStringRef colorStr = attributes.value(QLatin1String("color"));
+    QStringRef colorOpacityStr = attributes.value(QLatin1String("color-opacity"));
+
+    QColor color;
+    if (constructColor(colorStr, colorOpacityStr, color, handler)) {
+        handler->popColor();
+        handler->pushColor(color);
+    }
+
+    QMatrix matrix;
+    QGradient *grad = gradProp->qgradient();
+    if (!link.isEmpty()) {
+        QSvgStyleProperty *prop = node->styleProperty(link);
+        //qDebug()<<"inherited "<<prop<<" ("<<link<<")";
+        if (prop && prop->type() == QSvgStyleProperty::GRADIENT) {
+            QSvgGradientStyle *inherited =
+                static_cast<QSvgGradientStyle*>(prop);
+            if (!inherited->stopLink().isEmpty()) {
+                gradProp->setStopLink(inherited->stopLink(), handler->document());
+            } else {
+                grad->setStops(inherited->qgradient()->stops());
+                gradProp->setGradientStopsSet(inherited->gradientStopsSet());
+            }
+
+            matrix = inherited->qmatrix();
+        } else {
+            gradProp->setStopLink(link, handler->document());
+        }
+    }
+
+    if (!trans.isEmpty()) {
+        matrix = parseTransformationMatrix(trans);
+        gradProp->setMatrix(matrix);
+    } else if (!matrix.isIdentity()) {
+        gradProp->setMatrix(matrix);
+    }
+
+    if (!spread.isEmpty()) {
+        if (spread == QLatin1String("pad")) {
+            grad->setSpread(QGradient::PadSpread);
+        } else if (spread == QLatin1String("reflect")) {
+            grad->setSpread(QGradient::ReflectSpread);
+        } else if (spread == QLatin1String("repeat")) {
+            grad->setSpread(QGradient::RepeatSpread);
+        }
+    }
+
+    if (units.isEmpty() || units == QLatin1String("objectBoundingBox")) {
+         grad->setCoordinateMode(QGradient::ObjectBoundingMode);
+    }
+}
+
+static QSvgStyleProperty *createLinearGradientNode(QSvgNode *node,
+                                                   const QXmlStreamAttributes &attributes,
+                                                   QSvgHandler *handler)
+{
+    QString x1 = attributes.value(QLatin1String("x1")).toString();
+    QString y1 = attributes.value(QLatin1String("y1")).toString();
+    QString x2 = attributes.value(QLatin1String("x2")).toString();
+    QString y2 = attributes.value(QLatin1String("y2")).toString();
+
+    qreal nx1 = 0.0;
+    qreal ny1 = 0.0;
+    qreal nx2 = 1.0;
+    qreal ny2 = 0.0;
+
+    if (!x1.isEmpty())
+        nx1 =  convertToNumber(x1, handler);
+    if (!y1.isEmpty())
+        ny1 =  convertToNumber(y1, handler);
+    if (!x2.isEmpty())
+        nx2 =  convertToNumber(x2, handler);
+    if (!y2.isEmpty())
+        ny2 =  convertToNumber(y2, handler);
+
+    QSvgNode *itr = node;
+    while (itr && itr->type() != QSvgNode::DOC) {
+        itr = itr->parent();
+    }
+
+    QLinearGradient *grad = new QLinearGradient(nx1, ny1, nx2, ny2);
+    grad->setInterpolationMode(QGradient::ComponentInterpolation);
+    QSvgGradientStyle *prop = new QSvgGradientStyle(grad);
+    parseBaseGradient(node, attributes, prop, handler);
+
+    return prop;
+}
+
+static bool parseMetadataNode(QSvgNode *parent,
+                              const QXmlStreamAttributes &attributes,
+                              QSvgHandler *)
+{
+    Q_UNUSED(parent); Q_UNUSED(attributes);
+    return true;
+}
+
+static bool parseMissingGlyphNode(QSvgStyleProperty *parent,
+                                  const QXmlStreamAttributes &attributes,
+                                  QSvgHandler *)
+{
+    if (parent->type() != QSvgStyleProperty::FONT) {
+        return false;
+    }
+
+    QSvgFontStyle *style = static_cast<QSvgFontStyle*>(parent);
+    QSvgFont *font = style->svgFont();
+    createSvgGlyph(font, attributes);
+    return true;
+}
+
+static bool parseMpathNode(QSvgNode *parent,
+                           const QXmlStreamAttributes &attributes,
+                           QSvgHandler *)
+{
+    Q_UNUSED(parent); Q_UNUSED(attributes);
+    return true;
+}
+
+static QSvgNode *createPathNode(QSvgNode *parent,
+                                const QXmlStreamAttributes &attributes,
+                                QSvgHandler *)
+{
+    QStringRef data      = attributes.value(QLatin1String("d"));
+
+    QPainterPath qpath;
+    qpath.setFillRule(Qt::WindingFill);
+    //XXX do error handling
+    parsePathDataFast(data, qpath);
+
+    QSvgNode *path = new QSvgPath(parent, qpath);
+    return path;
+}
+
+static QSvgNode *createPolygonNode(QSvgNode *parent,
+                                   const QXmlStreamAttributes &attributes,
+                                   QSvgHandler *)
+{
+    QString pointsStr  = attributes.value(QLatin1String("points")).toString();
+
+    //same QPolygon parsing is in createPolylineNode
+    const QChar *s = pointsStr.constData();
+    QVector<qreal> points = parseNumbersList(s);
+    QPolygonF poly(points.count()/2);
+    for (int i = 0; i < poly.size(); ++i)
+        poly[i] = QPointF(points.at(2 * i), points.at(2 * i + 1));
+    QSvgNode *polygon = new QSvgPolygon(parent, poly);
+    return polygon;
+}
+
+static QSvgNode *createPolylineNode(QSvgNode *parent,
+                                    const QXmlStreamAttributes &attributes,
+                                    QSvgHandler *)
+{
+    QString pointsStr  = attributes.value(QLatin1String("points")).toString();
+
+    //same QPolygon parsing is in createPolygonNode
+    const QChar *s = pointsStr.constData();
+    QVector<qreal> points = parseNumbersList(s);
+    QPolygonF poly(points.count()/2);
+    for (int i = 0; i < poly.size(); ++i)
+        poly[i] = QPointF(points.at(2 * i), points.at(2 * i + 1));
+
+    QSvgNode *line = new QSvgPolyline(parent, poly);
+    return line;
+}
+
+static bool parsePrefetchNode(QSvgNode *parent,
+                              const QXmlStreamAttributes &attributes,
+                              QSvgHandler *)
+{
+    Q_UNUSED(parent); Q_UNUSED(attributes);
+    return true;
+}
+
+static QSvgStyleProperty *createRadialGradientNode(QSvgNode *node,
+                                                   const QXmlStreamAttributes &attributes,
+                                                   QSvgHandler *handler)
+{
+    QString cx = attributes.value(QLatin1String("cx")).toString();
+    QString cy = attributes.value(QLatin1String("cy")).toString();
+    QString r  = attributes.value(QLatin1String("r")).toString();
+    QString fx = attributes.value(QLatin1String("fx")).toString();
+    QString fy = attributes.value(QLatin1String("fy")).toString();
+
+    qreal ncx = 0.5;
+    qreal ncy = 0.5;
+    qreal nr  = 0.5;
+    if (!cx.isEmpty())
+        ncx = toDouble(cx);
+    if (!cy.isEmpty())
+        ncy = toDouble(cy);
+    if (!r.isEmpty())
+        nr = toDouble(r);
+
+    qreal nfx = ncx;
+    if (!fx.isEmpty())
+        nfx = toDouble(fx);
+    qreal nfy = ncy;
+    if (!fy.isEmpty())
+        nfy = toDouble(fy);
+
+    QRadialGradient *grad = new QRadialGradient(ncx, ncy, nr, nfx, nfy);
+    grad->setInterpolationMode(QGradient::ComponentInterpolation);
+
+    QSvgGradientStyle *prop = new QSvgGradientStyle(grad);
+    parseBaseGradient(node, attributes, prop, handler);
+
+    return prop;
+}
+
+static QSvgNode *createRectNode(QSvgNode *parent,
+                                const QXmlStreamAttributes &attributes,
+                                QSvgHandler *handler)
+{
+    QString x      = attributes.value(QLatin1String("x")).toString();
+    QString y      = attributes.value(QLatin1String("y")).toString();
+    QString width  = attributes.value(QLatin1String("width")).toString();
+    QString height = attributes.value(QLatin1String("height")).toString();
+    QString rx      = attributes.value(QLatin1String("rx")).toString();
+    QString ry      = attributes.value(QLatin1String("ry")).toString();
+
+    QSvgHandler::LengthType type;
+    qreal nwidth = parseLength(width, type, handler);
+    nwidth = convertToPixels(nwidth, true, type);
+
+    qreal nheight = parseLength(height, type, handler);
+    nheight = convertToPixels(nheight, true, type);
+    qreal nrx = toDouble(rx);
+    qreal nry = toDouble(ry);
+
+    QRectF bounds(toDouble(x), toDouble(y),
+                  nwidth, nheight);
+
+    //9.2 The 'rect'  element clearly specifies it
+    // but the case might in fact be handled because
+    // we draw rounded rectangles differently
+    if (nrx > bounds.width()/2)
+        nrx = bounds.width()/2;
+    if (nry > bounds.height()/2)
+        nry = bounds.height()/2;
+
+    if (!rx.isEmpty() && ry.isEmpty())
+        nry = nrx;
+    else if (!ry.isEmpty() && rx.isEmpty())
+        nrx = nry;
+
+    //we draw rounded rect from 0...99
+    //svg from 0...bounds.width()/2 so we're adjusting the
+    //coordinates
+    nrx *= (100/(bounds.width()/2));
+    nry *= (100/(bounds.height()/2));
+
+    QSvgNode *rect = new QSvgRect(parent, bounds,
+                                  int(nrx),
+                                  int(nry));
+    return rect;
+}
+
+static bool parseScriptNode(QSvgNode *parent,
+                            const QXmlStreamAttributes &attributes,
+                            QSvgHandler *)
+{
+    Q_UNUSED(parent); Q_UNUSED(attributes);
+    return true;
+}
+
+static bool parseSetNode(QSvgNode *parent,
+                         const QXmlStreamAttributes &attributes,
+                         QSvgHandler *)
+{
+    Q_UNUSED(parent); Q_UNUSED(attributes);
+    return true;
+}
+
+static QSvgStyleProperty *createSolidColorNode(QSvgNode *parent,
+                                               const QXmlStreamAttributes &attributes,
+                                               QSvgHandler *handler)
+{
+    Q_UNUSED(parent); Q_UNUSED(attributes);
+    QStringRef solidColorStr = attributes.value(QLatin1String("solid-color"));
+    QStringRef solidOpacityStr = attributes.value(QLatin1String("solid-opacity"));
+
+    if (solidOpacityStr.isEmpty())
+        solidOpacityStr = attributes.value(QLatin1String("opacity"));
+
+    QColor color;
+    if (!constructColor(solidColorStr, solidOpacityStr, color, handler))
+        return 0;
+    QSvgSolidColorStyle *style = new QSvgSolidColorStyle(color);
+    return style;
+}
+
+static bool parseStopNode(QSvgStyleProperty *parent,
+                          const QXmlStreamAttributes &attributes,
+                          QSvgHandler *handler)
+{
+    if (parent->type() != QSvgStyleProperty::GRADIENT)
+        return false;
+    QString nodeIdStr     = someId(attributes);
+    QString xmlClassStr   = attributes.value(QLatin1String("class")).toString();
+
+    //### nasty hack because stop gradients are not in the rendering tree
+    //    we force a dummy node with the same id and class into a rendering
+    //    tree to figure out whether the selector has a style for it
+    //    QSvgStyleSelector should be coded in a way that could avoid it
+    QSvgAnimation anim;
+    anim.setNodeId(nodeIdStr);
+    anim.setXmlClass(xmlClassStr);
+
+    QCss::StyleSelector::NodePtr cssNode;
+    cssNode.ptr = &anim;
+    QVector<QCss::Declaration> decls = handler->selector()->declarationsForNode(cssNode);
+
+    QXmlStreamAttributes xmlAttr = attributes;
+    for (int i = 0; i < decls.count(); ++i) {
+        const QCss::Declaration &decl = decls.at(i);
+
+        if (decl.d->property.isEmpty())
+            continue;
+        if (decl.d->values.count() != 1)
+            continue;
+        QCss::Value val = decl.d->values.first();
+        QString valueStr = val.toString();
+        if (val.type == QCss::Value::Uri) {
+            valueStr.prepend(QLatin1String("url("));
+            valueStr.append(QLatin1Char(')'));
+        }
+        xmlAttr.append(QString(), decl.d->property, valueStr);
+    }
+    QSvgAttributes attrs(xmlAttr, handler);
+
+    QSvgGradientStyle *style =
+        static_cast<QSvgGradientStyle*>(parent);
+    QString offsetStr   = attrs.offset.toString();
+    QStringRef colorStr    = attrs.stopColor;
+    QColor color;
+
+    bool ok = true;
+    qreal offset = convertToNumber(offsetStr, handler, &ok);
+    if (!ok)
+        offset = 0.0;
+    QString black = QString::fromLatin1("#000000");
+    if (colorStr.isEmpty()) {
+        colorStr = QStringRef(&black);
+    }
+
+    constructColor(colorStr, attrs.stopOpacity, color, handler);
+
+    QGradient *grad = style->qgradient();
+
+    offset = qMin(qreal(1), qMax(qreal(0), offset)); // Clamp to range [0, 1]
+    QGradientStops stops;
+    if (style->gradientStopsSet()) {
+        stops = grad->stops();
+        // If the stop offset equals the one previously added, add an epsilon to make it greater.
+        if (offset <= stops.back().first)
+            offset = stops.back().first + FLT_EPSILON;
+    }
+
+    // If offset is greater than one, it must be clamped to one.
+    if (offset > 1.0) {
+        if ((stops.size() == 1) || (stops.at(stops.size() - 2).first < 1.0 - FLT_EPSILON)) {
+            stops.back().first = 1.0 - FLT_EPSILON;
+            grad->setStops(stops);
+        }
+        offset = 1.0;
+    }
+
+    grad->setColorAt(offset, color);
+    style->setGradientStopsSet(true);
+    return true;
+}
+
+static bool parseStyleNode(QSvgNode *parent,
+                           const QXmlStreamAttributes &attributes,
+                           QSvgHandler *handler)
+{
+    Q_UNUSED(parent);
+    QString type = attributes.value(QLatin1String("type")).toString();
+    type = type.toLower();
+
+    if (type == QLatin1String("text/css")) {
+        handler->setInStyle(true);
+    }
+
+    return true;
+}
+
+static QSvgNode *createSvgNode(QSvgNode *parent,
+                               const QXmlStreamAttributes &attributes,
+                               QSvgHandler *handler)
+{
+    Q_UNUSED(parent); Q_UNUSED(attributes);
+
+    QString baseProfile = attributes.value(QLatin1String("baseProfile")).toString();
+#if 0
+    if (baseProfile.isEmpty() && baseProfile != QLatin1String("tiny")) {
+        qWarning("Profile is %s while we only support tiny!",
+                 qPrintable(baseProfile));
+    }
+#endif
+
+    QSvgTinyDocument *node = new QSvgTinyDocument();
+    QString widthStr  = attributes.value(QLatin1String("width")).toString();
+    QString heightStr = attributes.value(QLatin1String("height")).toString();
+    QString viewBoxStr = attributes.value(QLatin1String("viewBox")).toString();
+
+    QSvgHandler::LengthType type = QSvgHandler::LT_PX; // FIXME: is the default correct?
+    qreal width = 0;
+    if (!widthStr.isEmpty()) {
+        width = parseLength(widthStr, type, handler);
+        if (type != QSvgHandler::LT_PT)
+            width = convertToPixels(width, true, type);
+        node->setWidth(int(width), type == QSvgHandler::LT_PERCENT);
+    }
+    qreal height = 0;
+    if (!heightStr.isEmpty()) {
+        height = parseLength(heightStr, type, handler);
+        if (type != QSvgHandler::LT_PT)
+            height = convertToPixels(height, false, type);
+        node->setHeight(int(height), type == QSvgHandler::LT_PERCENT);
+    }
+
+    QStringList viewBoxValues;
+    if (!viewBoxStr.isEmpty()) {
+        viewBoxStr = viewBoxStr.replace(QLatin1Char(' '), QLatin1Char(','));
+        viewBoxStr = viewBoxStr.replace(QLatin1Char('\r'), QLatin1Char(','));
+        viewBoxStr = viewBoxStr.replace(QLatin1Char('\n'), QLatin1Char(','));
+        viewBoxStr = viewBoxStr.replace(QLatin1Char('\t'), QLatin1Char(','));
+        viewBoxValues = viewBoxStr.split(QLatin1Char(','), QString::SkipEmptyParts);
+    }
+    if (viewBoxValues.count() == 4) {
+        QString xStr      = viewBoxValues.at(0).trimmed();
+        QString yStr      = viewBoxValues.at(1).trimmed();
+        QString widthStr  = viewBoxValues.at(2).trimmed();
+        QString heightStr = viewBoxValues.at(3).trimmed();
+
+        QSvgHandler::LengthType lt;
+        qreal x = parseLength(xStr, lt, handler);
+        qreal y = parseLength(yStr, lt, handler);
+        qreal w = parseLength(widthStr, lt, handler);
+        qreal h = parseLength(heightStr, lt, handler);
+
+        node->setViewBox(QRectF(x, y, w, h));
+
+    } else if (width && height) {
+        if (type == QSvgHandler::LT_PT) {
+            width = convertToPixels(width, false, type);
+            height = convertToPixels(height, false, type);
+        }
+        node->setViewBox(QRectF(0, 0, width, height));
+    }
+    handler->setDefaultCoordinateSystem(QSvgHandler::LT_PX);
+
+    return node;
+}
+
+static QSvgNode *createSwitchNode(QSvgNode *parent,
+                                  const QXmlStreamAttributes &attributes,
+                                  QSvgHandler *)
+{
+    Q_UNUSED(attributes);
+    QSvgSwitch *node = new QSvgSwitch(parent);
+    return node;
+}
+
+static bool parseTbreakNode(QSvgNode *parent,
+                            const QXmlStreamAttributes &,
+                            QSvgHandler *)
+{
+    if (parent->type() != QSvgNode::TEXTAREA)
+        return false;
+    static_cast<QSvgText*>(parent)->addLineBreak();
+    return true;
+}
+
+static QSvgNode *createTextNode(QSvgNode *parent,
+                                const QXmlStreamAttributes &attributes,
+                                QSvgHandler *handler)
+{
+    QString x = attributes.value(QLatin1String("x")).toString();
+    QString y = attributes.value(QLatin1String("y")).toString();
+    //### editable and rotate not handled
+    QSvgHandler::LengthType type;
+    qreal nx = parseLength(x, type, handler);
+    qreal ny = parseLength(y, type, handler);
+
+    QSvgNode *text = new QSvgText(parent, QPointF(nx, ny));
+    return text;
+}
+
+static QSvgNode *createTextAreaNode(QSvgNode *parent,
+                                    const QXmlStreamAttributes &attributes,
+                                    QSvgHandler *handler)
+{
+    QSvgText *node = static_cast<QSvgText *>(createTextNode(parent, attributes, handler));
+    if (node) {
+        QSvgHandler::LengthType type;
+        qreal width = parseLength(attributes.value(QLatin1String("width")).toString(), type, handler);
+        qreal height = parseLength(attributes.value(QLatin1String("height")).toString(), type, handler);
+        node->setTextArea(QSizeF(width, height));
+    }
+    return node;
+}
+
+static QSvgNode *createTspanNode(QSvgNode *parent,
+                                    const QXmlStreamAttributes &,
+                                    QSvgHandler *)
+{
+    return new QSvgTspan(parent);
+}
+
+static bool parseTitleNode(QSvgNode *parent,
+                           const QXmlStreamAttributes &attributes,
+                           QSvgHandler *)
+{
+    Q_UNUSED(parent); Q_UNUSED(attributes);
+    return true;
+}
+
+static QSvgNode *createUseNode(QSvgNode *parent,
+                               const QXmlStreamAttributes &attributes,
+                               QSvgHandler *handler)
+{
+    QString linkId = attributes.value(QLatin1String("xlink:href")).toString().remove(0, 1);
+    QString xStr = attributes.value(QLatin1String("x")).toString();
+    QString yStr = attributes.value(QLatin1String("y")).toString();
+    QSvgStructureNode *group = 0;
+
+    if (linkId.isEmpty())
+        linkId = attributes.value(QLatin1String("href")).toString().remove(0, 1);
+    switch (parent->type()) {
+    case QSvgNode::DOC:
+    case QSvgNode::DEFS:
+    case QSvgNode::G:
+    case QSvgNode::SWITCH:
+        group = static_cast<QSvgStructureNode*>(parent);
+        break;
+    default:
+        break;
+    }
+
+    if (group) {
+        QSvgNode *link = group->scopeNode(linkId);
+        if (link) {
+            QPointF pt;
+            if (!xStr.isNull() || !yStr.isNull()) {
+                QSvgHandler::LengthType type;
+                qreal nx = parseLength(xStr, type, handler);
+                nx = convertToPixels(nx, true, type);
+
+                qreal ny = parseLength(yStr, type, handler);
+                ny = convertToPixels(ny, true, type);
+                pt = QPointF(nx, ny);
+            }
+
+            //delay link resolving till the first draw call on
+            //use nodes, link 2might have not been created yet
+            QSvgUse *node = new QSvgUse(pt, parent, link);
+            return node;
+        }
+    }
+
+    qWarning("link %s hasn't been detected!", qPrintable(linkId));
+    return 0;
+}
+
+static QSvgNode *createVideoNode(QSvgNode *parent,
+                                 const QXmlStreamAttributes &attributes,
+                                 QSvgHandler *)
+{
+    Q_UNUSED(parent); Q_UNUSED(attributes);
+    return 0;
+}
+
+typedef QSvgNode *(*FactoryMethod)(QSvgNode *, const QXmlStreamAttributes &, QSvgHandler *);
+
+static FactoryMethod findGroupFactory(const QString &name)
+{
+    if (name.isEmpty())
+        return 0;
+
+    QStringRef ref(&name, 1, name.length() - 1);
+    switch (name.at(0).unicode()) {
+    case 'd':
+        if (ref == QLatin1String("efs")) return createDefsNode;
+        break;
+    case 'g':
+        if (ref.isEmpty()) return createGNode;
+        break;
+    case 's':
+        if (ref == QLatin1String("vg")) return createSvgNode;
+        if (ref == QLatin1String("witch")) return createSwitchNode;
+        break;
+    default:
+        break;
+    }
+    return 0;
+}
+
+static FactoryMethod findGraphicsFactory(const QString &name)
+{
+    if (name.isEmpty())
+        return 0;
+
+    QStringRef ref(&name, 1, name.length() - 1);
+    switch (name.at(0).unicode()) {
+    case 'a':
+        if (ref == QLatin1String("nimation")) return createAnimationNode;
+        break;
+    case 'c':
+        if (ref == QLatin1String("ircle")) return createCircleNode;
+        break;
+    case 'e':
+        if (ref == QLatin1String("llipse")) return createEllipseNode;
+        break;
+    case 'i':
+        if (ref == QLatin1String("mage")) return createImageNode;
+        break;
+    case 'l':
+        if (ref == QLatin1String("ine")) return createLineNode;
+        break;
+    case 'p':
+        if (ref == QLatin1String("ath")) return createPathNode;
+        if (ref == QLatin1String("olygon")) return createPolygonNode;
+        if (ref == QLatin1String("olyline")) return createPolylineNode;
+        break;
+    case 'r':
+        if (ref == QLatin1String("ect")) return createRectNode;
+        break;
+    case 't':
+        if (ref == QLatin1String("ext")) return createTextNode;
+        if (ref == QLatin1String("extArea")) return createTextAreaNode;
+        if (ref == QLatin1String("span")) return createTspanNode;
+        break;
+    case 'u':
+        if (ref == QLatin1String("se")) return createUseNode;
+        break;
+    case 'v':
+        if (ref == QLatin1String("ideo")) return createVideoNode;
+        break;
+    default:
+        break;
+    }
+    return 0;
+}
+
+typedef bool (*ParseMethod)(QSvgNode *, const QXmlStreamAttributes &, QSvgHandler *);
+
+static ParseMethod findUtilFactory(const QString &name)
+{
+    if (name.isEmpty())
+        return 0;
+
+    QStringRef ref(&name, 1, name.length() - 1);
+    switch (name.at(0).unicode()) {
+    case 'a':
+        if (ref.isEmpty()) return parseAnchorNode;
+        if (ref == QLatin1String("nimate")) return parseAnimateNode;
+        if (ref == QLatin1String("nimateColor")) return parseAnimateColorNode;
+        if (ref == QLatin1String("nimateMotion")) return parseAimateMotionNode;
+        if (ref == QLatin1String("nimateTransform")) return parseAnimateTransformNode;
+        if (ref == QLatin1String("udio")) return parseAudioNode;
+        break;
+    case 'd':
+        if (ref == QLatin1String("esc")) return parseDescNode;
+        if (ref == QLatin1String("iscard")) return parseDiscardNode;
+        break;
+    case 'f':
+        if (ref == QLatin1String("oreignObject")) return parseForeignObjectNode;
+        break;
+    case 'h':
+        if (ref == QLatin1String("andler")) return parseHandlerNode;
+        if (ref == QLatin1String("kern")) return parseHkernNode;
+        break;
+    case 'm':
+        if (ref == QLatin1String("etadata")) return parseMetadataNode;
+        if (ref == QLatin1String("path")) return parseMpathNode;
+        break;
+    case 'p':
+        if (ref == QLatin1String("refetch")) return parsePrefetchNode;
+        break;
+    case 's':
+        if (ref == QLatin1String("cript")) return parseScriptNode;
+        if (ref == QLatin1String("et")) return parseSetNode;
+        if (ref == QLatin1String("tyle")) return parseStyleNode;
+        break;
+    case 't':
+        if (ref == QLatin1String("break")) return parseTbreakNode;
+        if (ref == QLatin1String("itle")) return parseTitleNode;
+        break;
+    default:
+        break;
+    }
+    return 0;
+}
+
+typedef QSvgStyleProperty *(*StyleFactoryMethod)(QSvgNode *,
+                                                 const QXmlStreamAttributes &,
+                                                 QSvgHandler *);
+
+static StyleFactoryMethod findStyleFactoryMethod(const QString &name)
+{
+    if (name.isEmpty())
+        return 0;
+
+    QStringRef ref(&name, 1, name.length() - 1);
+    switch (name.at(0).unicode()) {
+    case 'f':
+        if (ref == QLatin1String("ont")) return createFontNode;
+        break;
+    case 'l':
+        if (ref == QLatin1String("inearGradient")) return createLinearGradientNode;
+        break;
+    case 'r':
+        if (ref == QLatin1String("adialGradient")) return createRadialGradientNode;
+        break;
+    case 's':
+        if (ref == QLatin1String("olidColor")) return createSolidColorNode;
+        break;
+    default:
+        break;
+    }
+    return 0;
+}
+
+typedef bool (*StyleParseMethod)(QSvgStyleProperty *,
+                                 const QXmlStreamAttributes &,
+                                 QSvgHandler *);
+
+static StyleParseMethod findStyleUtilFactoryMethod(const QString &name)
+{
+    if (name.isEmpty())
+        return 0;
+
+    QStringRef ref(&name, 1, name.length() - 1);
+    switch (name.at(0).unicode()) {
+    case 'f':
+        if (ref == QLatin1String("ont-face")) return parseFontFaceNode;
+        if (ref == QLatin1String("ont-face-name")) return parseFontFaceNameNode;
+        if (ref == QLatin1String("ont-face-src")) return parseFontFaceSrcNode;
+        if (ref == QLatin1String("ont-face-uri")) return parseFontFaceUriNode;
+        break;
+    case 'g':
+        if (ref == QLatin1String("lyph")) return parseGlyphNode;
+        break;
+    case 'm':
+        if (ref == QLatin1String("issing-glyph")) return parseMissingGlyphNode;
+        break;
+    case 's':
+        if (ref == QLatin1String("top")) return parseStopNode;
+        break;
+    default:
+        break;
+    }
+    return 0;
+}
+
+QSvgHandler::QSvgHandler(QIODevice *device) : xml(new QXmlStreamReader(device))
+                                             , m_ownsReader(true)
+{
+    init();
+}
+
+QSvgHandler::QSvgHandler(const QByteArray &data) : xml(new QXmlStreamReader(data))
+                                                 , m_ownsReader(true)
+{
+    init();
+}
+
+QSvgHandler::QSvgHandler(QXmlStreamReader *const reader) : xml(reader)
+                                                         , m_ownsReader(false)
+{
+    init();
+}
+
+void QSvgHandler::init()
+{
+    m_doc = 0;
+    m_style = 0;
+    m_animEnd = 0;
+    m_defaultCoords = LT_PX;
+    m_defaultPen = QPen(Qt::black, 1, Qt::SolidLine, Qt::FlatCap, Qt::SvgMiterJoin);
+    m_defaultPen.setMiterLimit(4);
+    parse();
+}
+
+void QSvgHandler::parse()
+{
+    xml->setNamespaceProcessing(false);
+    m_selector = new QSvgStyleSelector;
+    m_inStyle = false;
+    bool done = false;
+    while (!xml->atEnd() && !done) {
+        switch (xml->readNext()) {
+        case QXmlStreamReader::StartElement:
+            // he we could/should verify the namespaces, and simply
+            // call m_skipNodes(Unknown) if we don't know the
+            // namespace.  We do support http://www.w3.org/2000/svg
+            // but also http://www.w3.org/2000/svg-20000303-stylable
+            // And if the document uses an external dtd, the reported
+            // namespaceUri is empty. The only possible strategy at
+            // this point is to do what everyone else seems to do and
+            // ignore the reported namespaceUri completely.
+            if (!startElement(xml->name().toString(), xml->attributes())) {
+                delete m_doc;
+                m_doc = 0;
+                return;
+            }
+            break;
+        case QXmlStreamReader::EndElement:
+            endElement(xml->name());
+            // if we are using somebody else's qxmlstreamreader
+            // we should not read until the end of the stream
+            done = !m_ownsReader && (xml->name() == QLatin1String("svg"));
+            break;
+        case QXmlStreamReader::Characters:
+            characters(xml->text());
+            break;
+        case QXmlStreamReader::ProcessingInstruction:
+            processingInstruction(xml->processingInstructionTarget().toString(), xml->processingInstructionData().toString());
+            break;
+        default:
+            break;
+        }
+    }
+    resolveGradients(m_doc);
+}
+
+bool QSvgHandler::startElement(const QString &localName,
+                               const QXmlStreamAttributes &attributes)
+{
+    QSvgNode *node = 0;
+
+    pushColorCopy();
+
+    /* The xml:space attribute may appear on any element. We do
+     * a lookup by the qualified name here, but this is namespace aware, since
+     * the XML namespace can only be bound to prefix "xml." */
+    const QStringRef xmlSpace(attributes.value(QLatin1String("xml:space")));
+    if (xmlSpace.isNull()) {
+        // This element has no xml:space attribute.
+        m_whitespaceMode.push(m_whitespaceMode.isEmpty() ? QSvgText::Default : m_whitespaceMode.top());
+    } else if (xmlSpace == QLatin1String("preserve")) {
+        m_whitespaceMode.push(QSvgText::Preserve);
+    } else if (xmlSpace == QLatin1String("default")) {
+        m_whitespaceMode.push(QSvgText::Default);
+    } else {
+        qWarning() << QString::fromLatin1("\"%1\" is an invalid value for attribute xml:space. "
+                                          "Valid values are \"preserve\" and \"default\".").arg(xmlSpace.toString());
+        m_whitespaceMode.push(QSvgText::Default);
+    }
+
+    if (!m_doc && localName != QLatin1String("svg"))
+        return false;
+
+    if (FactoryMethod method = findGroupFactory(localName)) {
+        //group
+        node = method(m_doc ? m_nodes.top() : 0, attributes, this);
+        Q_ASSERT(node);
+        if (!m_doc) {
+            Q_ASSERT(node->type() == QSvgNode::DOC);
+            m_doc = static_cast<QSvgTinyDocument*>(node);
+        } else {
+            switch (m_nodes.top()->type()) {
+            case QSvgNode::DOC:
+            case QSvgNode::G:
+            case QSvgNode::DEFS:
+            case QSvgNode::SWITCH:
+            {
+                QSvgStructureNode *group =
+                    static_cast<QSvgStructureNode*>(m_nodes.top());
+                group->addChild(node, someId(attributes));
+            }
+                break;
+            default:
+                break;
+            }
+        }
+        parseCoreNode(node, attributes);
+        cssStyleLookup(node, this, m_selector);
+        parseStyle(node, attributes, this);
+    } else if (FactoryMethod method = findGraphicsFactory(localName)) {
+        //rendering element
+        Q_ASSERT(!m_nodes.isEmpty());
+        node = method(m_nodes.top(), attributes, this);
+        if (node) {
+            switch (m_nodes.top()->type()) {
+            case QSvgNode::DOC:
+            case QSvgNode::G:
+            case QSvgNode::DEFS:
+            case QSvgNode::SWITCH:
+            {
+                QSvgStructureNode *group =
+                    static_cast<QSvgStructureNode*>(m_nodes.top());
+                group->addChild(node, someId(attributes));
+            }
+                break;
+            case QSvgNode::TEXT:
+            case QSvgNode::TEXTAREA:
+                if (node->type() == QSvgNode::TSPAN) {
+                    static_cast<QSvgText *>(m_nodes.top())->addTspan(static_cast<QSvgTspan *>(node));
+                } else {
+                    qWarning("\'text\' or \'textArea\' element contains invalid element type.");
+                    delete node;
+                    node = 0;
+                }
+                break;
+            default:
+                qWarning("Could not add child element to parent element because the types are incorrect.");
+                delete node;
+                node = 0;
+                break;
+            }
+
+            if (node) {
+                parseCoreNode(node, attributes);
+                cssStyleLookup(node, this, m_selector);
+                parseStyle(node, attributes, this);
+                if (node->type() == QSvgNode::TEXT || node->type() == QSvgNode::TEXTAREA) {
+                    static_cast<QSvgText *>(node)->setWhitespaceMode(m_whitespaceMode.top());
+                } else if (node->type() == QSvgNode::TSPAN) {
+                    static_cast<QSvgTspan *>(node)->setWhitespaceMode(m_whitespaceMode.top());
+                }
+            }
+        }
+    } else if (ParseMethod method = findUtilFactory(localName)) {
+        Q_ASSERT(!m_nodes.isEmpty());
+        if (!method(m_nodes.top(), attributes, this)) {
+            qWarning("Problem parsing %s", qPrintable(localName));
+        }
+    } else if (StyleFactoryMethod method = findStyleFactoryMethod(localName)) {
+        QSvgStyleProperty *prop = method(m_nodes.top(), attributes, this);
+        if (prop) {
+            m_style = prop;
+            m_nodes.top()->appendStyleProperty(prop, someId(attributes));
+        } else {
+            qWarning("Could not parse node: %s", qPrintable(localName));
+        }
+    } else if (StyleParseMethod method = findStyleUtilFactoryMethod(localName)) {
+        if (m_style) {
+            if (!method(m_style, attributes, this)) {
+                qWarning("Problem parsing %s", qPrintable(localName));
+            }
+        }
+    } else {
+        //qWarning()<<"Skipping unknown element!"<<namespaceURI<<"::"<<localName;
+        m_skipNodes.push(Unknown);
+        return true;
+    }
+
+    if (node) {
+        m_nodes.push(node);
+        m_skipNodes.push(Graphics);
+    } else {
+        //qDebug()<<"Skipping "<<localName;
+        m_skipNodes.push(Style);
+    }
+    return true;
+}
+
+bool QSvgHandler::endElement(const QStringRef &localName)
+{
+    CurrentNode node = m_skipNodes.top();
+    m_skipNodes.pop();
+    m_whitespaceMode.pop();
+
+    popColor();
+
+    if (node == Unknown) {
+        return true;
+    }
+
+    if (m_inStyle && localName == QLatin1String("style"))
+        m_inStyle = false;
+
+    if (node == Graphics)
+        m_nodes.pop();
+    else if (m_style && !m_skipNodes.isEmpty() && m_skipNodes.top() != Style)
+        m_style = 0;
+
+    return true;
+}
+
+void QSvgHandler::resolveGradients(QSvgNode *node)
+{
+    if (!node || (node->type() != QSvgNode::DOC && node->type() != QSvgNode::G
+        && node->type() != QSvgNode::DEFS && node->type() != QSvgNode::SWITCH)) {
+        return;
+    }
+    QSvgStructureNode *structureNode = static_cast<QSvgStructureNode *>(node);
+
+    QList<QSvgNode *> ren = structureNode->renderers();
+    for (QList<QSvgNode *>::iterator it = ren.begin(); it != ren.end(); ++it) {
+        QSvgFillStyle *fill = static_cast<QSvgFillStyle *>((*it)->styleProperty(QSvgStyleProperty::FILL));
+        if (fill && !fill->isGradientResolved()) {
+            QString id = fill->gradientId();
+            QSvgFillStyleProperty *style = structureNode->styleProperty(id);
+            if (style) {
+                fill->setFillStyle(style);
+            } else {
+                qWarning("Could not resolve property : %s", qPrintable(id));
+                fill->setBrush(Qt::NoBrush);
+            }
+        }
+
+        QSvgStrokeStyle *stroke = static_cast<QSvgStrokeStyle *>((*it)->styleProperty(QSvgStyleProperty::STROKE));
+        if (stroke && !stroke->isGradientResolved()) {
+            QString id = stroke->gradientId();
+            QSvgFillStyleProperty *style = structureNode->styleProperty(id);
+            if (style) {
+                stroke->setStyle(style);
+            } else {
+                qWarning("Could not resolve property : %s", qPrintable(id));
+                stroke->setStroke(Qt::NoBrush);
+            }
+        }
+
+        resolveGradients(*it);
+    }
+}
+
+bool QSvgHandler::characters(const QStringRef &str)
+{
+    if (m_inStyle) {
+        QString css = str.toString();
+        QCss::StyleSheet sheet;
+        QCss::Parser(css).parse(&sheet);
+        m_selector->styleSheets.append(sheet);
+        return true;
+    } else if (m_skipNodes.isEmpty() || m_skipNodes.top() == Unknown || m_nodes.isEmpty())
+        return true;
+
+    if (m_nodes.top()->type() == QSvgNode::TEXT || m_nodes.top()->type() == QSvgNode::TEXTAREA) {
+        static_cast<QSvgText*>(m_nodes.top())->addText(str.toString());
+    } else if (m_nodes.top()->type() == QSvgNode::TSPAN) {
+        static_cast<QSvgTspan*>(m_nodes.top())->addText(str.toString());
+    }
+
+    return true;
+}
+
+QSvgTinyDocument * QSvgHandler::document() const
+{
+    return m_doc;
+}
+
+QSvgHandler::LengthType QSvgHandler::defaultCoordinateSystem() const
+{
+    return m_defaultCoords;
+}
+
+void QSvgHandler::setDefaultCoordinateSystem(LengthType type)
+{
+    m_defaultCoords = type;
+}
+
+void QSvgHandler::pushColor(const QColor &color)
+{
+    m_colorStack.push(color);
+    m_colorTagCount.push(1);
+}
+
+void QSvgHandler::pushColorCopy()
+{
+    if (m_colorTagCount.count())
+        ++m_colorTagCount.top();
+    else
+        pushColor(Qt::black);
+}
+
+void QSvgHandler::popColor()
+{
+    if (m_colorTagCount.count()) {
+        if (!--m_colorTagCount.top()) {
+            m_colorStack.pop();
+            m_colorTagCount.pop();
+        }
+    }
+}
+
+QColor QSvgHandler::currentColor() const
+{
+    if (!m_colorStack.isEmpty())
+        return m_colorStack.top();
+    else
+        return QColor(0, 0, 0);
+}
+
+void QSvgHandler::setInStyle(bool b)
+{
+    m_inStyle = b;
+}
+
+bool QSvgHandler::inStyle() const
+{
+    return m_inStyle;
+}
+
+QSvgStyleSelector * QSvgHandler::selector() const
+{
+    return m_selector;
+}
+
+bool QSvgHandler::processingInstruction(const QString &target, const QString &data)
+{
+    if (target == QLatin1String("xml-stylesheet")) {
+        QRegExp rx(QLatin1String("type=\\\"(.+)\\\""));
+        rx.setMinimal(true);
+        bool isCss = false;
+        int pos = 0;
+        while ((pos = rx.indexIn(data, pos)) != -1) {
+            QString type =  rx.cap(1);
+            if (type.toLower() == QLatin1String("text/css")) {
+                isCss = true;
+            }
+            pos += rx.matchedLength();
+        }
+
+        if (isCss) {
+            QRegExp rx(QLatin1String("href=\\\"(.+)\\\""));
+            rx.setMinimal(true);
+            pos = 0;
+            pos = rx.indexIn(data, pos);
+            QString addr = rx.cap(1);
+            QFileInfo fi(addr);
+            //qDebug()<<"External CSS file "<<fi.absoluteFilePath()<<fi.exists();
+            if (fi.exists()) {
+                QFile file(fi.absoluteFilePath());
+                if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+                    return true;
+                }
+                QByteArray cssData = file.readAll();
+                QString css = QString::fromUtf8(cssData);
+
+                QCss::StyleSheet sheet;
+                QCss::Parser(css).parse(&sheet);
+                m_selector->styleSheets.append(sheet);
+            }
+
+        }
+    }
+
+    return true;
+}
+
+void QSvgHandler::setAnimPeriod(int start, int end)
+{
+    Q_UNUSED(start);
+    m_animEnd   = qMax(end, m_animEnd);
+}
+
+int QSvgHandler::animationDuration() const
+{
+    return m_animEnd;
+}
+
+QSvgHandler::~QSvgHandler()
+{
+    delete m_selector;
+    m_selector = 0;
+
+    if(m_ownsReader)
+        delete xml;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SVG
diff --git a/src/svg/qsvghandler_p.h b/src/svg/qsvghandler_p.h
new file mode 100644
index 0000000..1d1712e
--- /dev/null
+++ b/src/svg/qsvghandler_p.h
@@ -0,0 +1,188 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtSvg module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSVGHANDLER_P_H
+#define QSVGHANDLER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtXml/qxmlstream.h"
+
+#ifndef QT_NO_SVG
+
+#include "QtCore/qhash.h"
+#include "QtCore/qstack.h"
+#include "qsvgstyle_p.h"
+#include "private/qcssparser_p.h"
+#include "private/qsvggraphics_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QSvgNode;
+class QSvgTinyDocument;
+class QSvgHandler;
+class QColor;
+class QSvgStyleSelector;
+class QXmlStreamReader;
+
+struct QSvgCssAttribute
+{
+    QXmlStreamStringRef name;
+    QXmlStreamStringRef value;
+};
+
+class QSvgHandler
+{
+public:
+    enum LengthType {
+        LT_PERCENT,
+        LT_PX,
+        LT_PC,
+        LT_PT,
+        LT_MM,
+        LT_CM,
+        LT_IN,
+        LT_OTHER
+    };
+
+public:
+    QSvgHandler(QIODevice *device);
+    QSvgHandler(const QByteArray &data);
+    QSvgHandler(QXmlStreamReader *const data);
+    ~QSvgHandler();
+
+    QSvgTinyDocument *document() const;
+
+    inline bool ok() const {
+        return document() != 0 && !xml->hasError();
+    }
+
+    inline QString errorString() const { return xml->errorString(); }
+    inline int lineNumber() const { return xml->lineNumber(); }
+
+    void setDefaultCoordinateSystem(LengthType type);
+    LengthType defaultCoordinateSystem() const;
+
+    void pushColor(const QColor &color);
+    void pushColorCopy();
+    void popColor();
+    QColor currentColor() const;
+
+    void setInStyle(bool b);
+    bool inStyle() const;
+
+    QSvgStyleSelector *selector() const;
+
+    void setAnimPeriod(int start, int end);
+    int animationDuration() const;
+
+    void parseCSStoXMLAttrs(QString css, QVector<QSvgCssAttribute> *attributes);
+
+    inline QPen defaultPen() const
+    { return m_defaultPen; }
+
+public:
+    bool startElement(const QString &localName, const QXmlStreamAttributes &attributes);
+    bool endElement(const QStringRef &localName);
+    bool characters(const QStringRef &str);
+    bool processingInstruction(const QString &target, const QString &data);
+
+private:
+    void init();
+
+    QSvgTinyDocument *m_doc;
+    QStack<QSvgNode*> m_nodes;
+
+    QList<QSvgNode*>  m_resolveNodes;
+
+    enum CurrentNode
+    {
+        Unknown,
+        Graphics,
+        Style
+    };
+    QStack<CurrentNode> m_skipNodes;
+
+    /*!
+        Follows the depths of elements. The top is current xml:space
+        value that applies for a given element.
+     */
+    QStack<QSvgText::WhitespaceMode> m_whitespaceMode;
+
+    QSvgRefCounter<QSvgStyleProperty> m_style;
+
+    LengthType m_defaultCoords;
+
+    QStack<QColor> m_colorStack;
+    QStack<int>    m_colorTagCount;
+
+    bool m_inStyle;
+
+    QSvgStyleSelector *m_selector;
+
+    int m_animEnd;
+
+    QXmlStreamReader *const xml;
+    QCss::Parser m_cssParser;
+    void parse();
+    void resolveGradients(QSvgNode *node);
+
+    QPen m_defaultPen;
+    /**
+     * Whether we own the variable xml, and hence whether
+     * we need to delete it.
+     */
+    const bool m_ownsReader;
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SVG
+#endif // QSVGHANDLER_P_H
diff --git a/src/svg/qsvgnode.cpp b/src/svg/qsvgnode.cpp
new file mode 100644
index 0000000..5751f80
--- /dev/null
+++ b/src/svg/qsvgnode.cpp
@@ -0,0 +1,345 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtSvg module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qsvgnode_p.h"
+#include "qsvgtinydocument_p.h"
+
+#ifndef QT_NO_SVG
+
+#include "qdebug.h"
+#include "qstack.h"
+
+QT_BEGIN_NAMESPACE
+
+QSvgNode::QSvgNode(QSvgNode *parent)
+    : m_parent(parent),
+      m_visible(true),
+      m_displayMode(BlockMode)
+{
+}
+
+QSvgNode::~QSvgNode()
+{
+
+}
+
+void QSvgNode::appendStyleProperty(QSvgStyleProperty *prop, const QString &id)
+{
+    //qDebug()<<"appending "<<prop->type()<< " ("<< id <<") "<<"to "<<this<<this->type();
+    QSvgTinyDocument *doc;
+    switch (prop->type()) {
+    case QSvgStyleProperty::QUALITY:
+        m_style.quality = static_cast<QSvgQualityStyle*>(prop);
+        break;
+    case QSvgStyleProperty::FILL:
+        m_style.fill = static_cast<QSvgFillStyle*>(prop);
+        break;
+    case QSvgStyleProperty::VIEWPORT_FILL:
+        m_style.viewportFill = static_cast<QSvgViewportFillStyle*>(prop);
+        break;
+    case QSvgStyleProperty::FONT:
+        m_style.font = static_cast<QSvgFontStyle*>(prop);
+        break;
+    case QSvgStyleProperty::STROKE:
+        m_style.stroke = static_cast<QSvgStrokeStyle*>(prop);
+        break;
+    case QSvgStyleProperty::SOLID_COLOR:
+        m_style.solidColor = static_cast<QSvgSolidColorStyle*>(prop);
+        doc = document();
+        if (doc && !id.isEmpty())
+            doc->addNamedStyle(id, m_style.solidColor);
+        break;
+    case QSvgStyleProperty::GRADIENT:
+        m_style.gradient = static_cast<QSvgGradientStyle*>(prop);
+        doc = document();
+        if (doc && !id.isEmpty())
+            doc->addNamedStyle(id, m_style.gradient);
+        break;
+    case QSvgStyleProperty::TRANSFORM:
+        m_style.transform = static_cast<QSvgTransformStyle*>(prop);
+        break;
+    case QSvgStyleProperty::ANIMATE_COLOR:
+        m_style.animateColor = static_cast<QSvgAnimateColor*>(prop);
+        break;
+    case QSvgStyleProperty::ANIMATE_TRANSFORM:
+        m_style.animateTransforms.append(
+            static_cast<QSvgAnimateTransform*>(prop));
+        break;
+    case QSvgStyleProperty::OPACITY:
+        m_style.opacity = static_cast<QSvgOpacityStyle*>(prop);
+        break;
+    case QSvgStyleProperty::COMP_OP:
+        m_style.compop = static_cast<QSvgCompOpStyle*>(prop);
+        break;
+    default:
+        qDebug("QSvgNode: Trying to append unknown property!");
+        break;
+    }
+}
+
+void QSvgNode::applyStyle(QPainter *p, QSvgExtraStates &states) const
+{
+    m_style.apply(p, this, states);
+}
+
+void QSvgNode::revertStyle(QPainter *p, QSvgExtraStates &states) const
+{
+    m_style.revert(p, states);
+}
+
+QSvgStyleProperty * QSvgNode::styleProperty(QSvgStyleProperty::Type type) const
+{
+    const QSvgNode *node = this;
+    while (node) {
+        switch (type) {
+        case QSvgStyleProperty::QUALITY:
+            if (node->m_style.quality)
+                return node->m_style.quality;
+            break;
+        case QSvgStyleProperty::FILL:
+            if (node->m_style.fill)
+                return node->m_style.fill;
+            break;
+        case QSvgStyleProperty::VIEWPORT_FILL:
+            if (m_style.viewportFill)
+                return node->m_style.viewportFill;
+            break;
+        case QSvgStyleProperty::FONT:
+            if (node->m_style.font)
+                return node->m_style.font;
+            break;
+        case QSvgStyleProperty::STROKE:
+            if (node->m_style.stroke)
+                return node->m_style.stroke;
+            break;
+        case QSvgStyleProperty::SOLID_COLOR:
+            if (node->m_style.solidColor)
+                return node->m_style.solidColor;
+            break;
+        case QSvgStyleProperty::GRADIENT:
+            if (node->m_style.gradient)
+                return node->m_style.gradient;
+            break;
+        case QSvgStyleProperty::TRANSFORM:
+            if (node->m_style.transform)
+                return node->m_style.transform;
+            break;
+        case QSvgStyleProperty::ANIMATE_COLOR:
+            if (node->m_style.animateColor)
+                return node->m_style.animateColor;
+            break;
+        case QSvgStyleProperty::ANIMATE_TRANSFORM:
+            if (!node->m_style.animateTransforms.isEmpty())
+                return node->m_style.animateTransforms.first();
+            break;
+        case QSvgStyleProperty::OPACITY:
+            if (node->m_style.opacity)
+                return node->m_style.opacity;
+            break;
+        case QSvgStyleProperty::COMP_OP:
+            if (node->m_style.compop)
+                return node->m_style.compop;
+            break;
+        default:
+            break;
+        }
+        node = node->parent();
+    }
+
+    return 0;
+}
+
+QSvgFillStyleProperty * QSvgNode::styleProperty(const QString &id) const
+{
+    QString rid = id;
+    if (rid.startsWith(QLatin1Char('#')))
+        rid.remove(0, 1);
+    QSvgTinyDocument *doc = document();
+    return doc ? doc->namedStyle(rid) : 0;
+}
+
+QRectF QSvgNode::bounds(QPainter *, QSvgExtraStates &) const
+{
+    return QRectF(0, 0, 0, 0);
+}
+
+QRectF QSvgNode::transformedBounds() const
+{
+    if (!m_cachedBounds.isEmpty())
+        return m_cachedBounds;
+
+    QImage dummy(1, 1, QImage::Format_RGB32);
+    QPainter p(&dummy);
+    QSvgExtraStates states;
+
+    QPen pen(Qt::NoBrush, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
+    pen.setMiterLimit(4);
+    p.setPen(pen);
+
+    QStack<QSvgNode*> parentApplyStack;
+    QSvgNode *parent = m_parent;
+    while (parent) {
+        parentApplyStack.push(parent);
+        parent = parent->parent();
+    }
+
+    for (int i = parentApplyStack.size() - 1; i >= 0; --i)
+        parentApplyStack[i]->applyStyle(&p, states);
+    
+    p.setWorldTransform(QTransform());
+
+    m_cachedBounds = transformedBounds(&p, states);
+    return m_cachedBounds;
+}
+
+QSvgTinyDocument * QSvgNode::document() const
+{
+    QSvgTinyDocument *doc = 0;
+    QSvgNode *node = const_cast<QSvgNode*>(this);
+    while (node && node->type() != QSvgNode::DOC) {
+        node = node->parent();
+    }
+    doc = static_cast<QSvgTinyDocument*>(node);
+
+    return doc;
+}
+
+void QSvgNode::setRequiredFeatures(const QStringList &lst)
+{
+    m_requiredFeatures = lst;
+}
+
+const QStringList & QSvgNode::requiredFeatures() const
+{
+    return m_requiredFeatures;
+}
+
+void QSvgNode::setRequiredExtensions(const QStringList &lst)
+{
+    m_requiredExtensions = lst;
+}
+
+const QStringList & QSvgNode::requiredExtensions() const
+{
+    return m_requiredExtensions;
+}
+
+void QSvgNode::setRequiredLanguages(const QStringList &lst)
+{
+    m_requiredLanguages = lst;
+}
+
+const QStringList & QSvgNode::requiredLanguages() const
+{
+    return m_requiredLanguages;
+}
+
+void QSvgNode::setRequiredFormats(const QStringList &lst)
+{
+    m_requiredFormats = lst;
+}
+
+const QStringList & QSvgNode::requiredFormats() const
+{
+    return m_requiredFormats;
+}
+
+void QSvgNode::setRequiredFonts(const QStringList &lst)
+{
+    m_requiredFonts = lst;
+}
+
+const QStringList & QSvgNode::requiredFonts() const
+{
+    return m_requiredFonts;
+}
+
+void QSvgNode::setVisible(bool visible)
+{
+    //propagate visibility change of true to the parent
+    //not propagating false is just a small performance
+    //degradation since we'll iterate over children without
+    //drawing any of them
+    if (m_parent && visible && !m_parent->isVisible())
+        m_parent->setVisible(true);
+
+    m_visible = visible;
+}
+
+QRectF QSvgNode::transformedBounds(QPainter *p, QSvgExtraStates &states) const
+{
+    applyStyle(p, states);
+    QRectF rect = bounds(p, states);
+    revertStyle(p, states);
+    return rect;
+}
+
+void QSvgNode::setNodeId(const QString &i)
+{
+    m_id = i;
+}
+
+void QSvgNode::setXmlClass(const QString &str)
+{
+    m_class = str;
+}
+
+void QSvgNode::setDisplayMode(DisplayMode mode)
+{
+    m_displayMode = mode;
+}
+
+QSvgNode::DisplayMode QSvgNode::displayMode() const
+{
+    return m_displayMode;
+}
+
+qreal QSvgNode::strokeWidth(QPainter *p)
+{
+    QPen pen = p->pen();
+    if (pen.style() == Qt::NoPen || pen.brush().style() == Qt::NoBrush || pen.isCosmetic())
+        return 0;
+    return pen.widthF();
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SVG
diff --git a/src/svg/qsvgnode_p.h b/src/svg/qsvgnode_p.h
new file mode 100644
index 0000000..9d06988
--- /dev/null
+++ b/src/svg/qsvgnode_p.h
@@ -0,0 +1,206 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtSvg module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSVGNODE_P_H
+#define QSVGNODE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qsvgstyle_p.h"
+
+#ifndef QT_NO_SVG
+
+#include "QtCore/qstring.h"
+#include "QtCore/qhash.h"
+
+QT_BEGIN_NAMESPACE
+
+class QPainter;
+class QSvgTinyDocument;
+
+class QSvgNode
+{
+public:
+    enum Type
+    {
+        DOC,
+        G,
+        DEFS,
+        SWITCH,
+        ANIMATION,
+        ARC,
+        CIRCLE,
+        ELLIPSE,
+        IMAGE,
+        LINE,
+        PATH,
+        POLYGON,
+        POLYLINE,
+        RECT,
+        TEXT,
+        TEXTAREA,
+        TSPAN,
+        USE,
+        VIDEO
+    };
+    enum DisplayMode {
+        InlineMode,
+        BlockMode,
+        ListItemMode,
+        RunInMode,
+        CompactMode,
+        MarkerMode,
+        TableMode,
+        InlineTableMode,
+        TableRowGroupMode,
+        TableHeaderGroupMode,
+        TableFooterGroupMode,
+        TableRowMode,
+        TableColumnGroupMode,
+        TableColumnMode,
+        TableCellMode,
+        TableCaptionMode,
+        NoneMode,
+        InheritMode
+    };
+public:
+    QSvgNode(QSvgNode *parent=0);
+    virtual ~QSvgNode();
+    virtual void draw(QPainter *p, QSvgExtraStates &states) =0;
+
+    QSvgNode *parent() const;
+
+    void appendStyleProperty(QSvgStyleProperty *prop, const QString &id);
+    void applyStyle(QPainter *p, QSvgExtraStates &states) const;
+    void revertStyle(QPainter *p, QSvgExtraStates &states) const;
+    QSvgStyleProperty *styleProperty(QSvgStyleProperty::Type type) const;
+    QSvgFillStyleProperty *styleProperty(const QString &id) const;
+
+    QSvgTinyDocument *document() const;
+
+    virtual Type type() const =0;
+    virtual QRectF bounds(QPainter *p, QSvgExtraStates &states) const;
+    virtual QRectF transformedBounds(QPainter *p, QSvgExtraStates &states) const;
+    QRectF transformedBounds() const;
+
+    void setRequiredFeatures(const QStringList &lst);
+    const QStringList & requiredFeatures() const;
+
+    void setRequiredExtensions(const QStringList &lst);
+    const QStringList & requiredExtensions() const;
+
+    void setRequiredLanguages(const QStringList &lst);
+    const QStringList & requiredLanguages() const;
+
+    void setRequiredFormats(const QStringList &lst);
+    const QStringList & requiredFormats() const;
+
+    void setRequiredFonts(const QStringList &lst);
+    const QStringList & requiredFonts() const;
+
+    void setVisible(bool visible);
+    bool isVisible() const;
+
+    void setDisplayMode(DisplayMode display);
+    DisplayMode displayMode() const;
+
+    QString nodeId() const;
+    void setNodeId(const QString &i);
+
+    QString xmlClass() const;
+    void setXmlClass(const QString &str);
+protected:
+    mutable QSvgStyle m_style;
+
+    static qreal strokeWidth(QPainter *p);
+private:
+    QSvgNode   *m_parent;
+
+    QStringList m_requiredFeatures;
+    QStringList m_requiredExtensions;
+    QStringList m_requiredLanguages;
+    QStringList m_requiredFormats;
+    QStringList m_requiredFonts;
+
+    bool        m_visible;
+
+    QString m_id;
+    QString m_class;
+
+    DisplayMode m_displayMode;
+    mutable QRectF m_cachedBounds;
+
+    friend class QSvgTinyDocument;
+};
+
+inline QSvgNode *QSvgNode::parent() const
+{
+    return m_parent;
+}
+
+inline bool QSvgNode::isVisible() const
+{
+    return m_visible;
+}
+
+inline QString QSvgNode::nodeId() const
+{
+    return m_id;
+}
+
+inline QString QSvgNode::xmlClass() const
+{
+    return m_class;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SVG
+#endif // QSVGNODE_P_H
diff --git a/src/svg/qsvgrenderer.cpp b/src/svg/qsvgrenderer.cpp
new file mode 100644
index 0000000..9cc6b0c
--- /dev/null
+++ b/src/svg/qsvgrenderer.cpp
@@ -0,0 +1,501 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtSvg module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qsvgrenderer.h"
+
+#ifndef QT_NO_SVGRENDERER
+
+#include "qsvgtinydocument_p.h"
+
+#include "qbytearray.h"
+#include "qtimer.h"
+#include "qdebug.h"
+#include "private/qobject_p.h"
+
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QSvgRenderer
+    \ingroup painting
+
+    \brief The QSvgRenderer class is used to draw the contents of SVG files onto paint devices.
+    \since 4.1
+    \reentrant
+
+    Using QSvgRenderer, Scalable Vector Graphics (SVG) can be rendered onto any QPaintDevice
+    subclass, including QWidget, QImage, and QGLWidget.
+
+    QSvgRenderer provides an API that supports basic features of SVG rendering, such as loading
+    and rendering of static drawings, and more interactive features like animation. Since the
+    rendering is performed using QPainter, SVG drawings can be rendered on any subclass of
+    QPaintDevice.
+
+    SVG drawings are either loaded when an QSvgRenderer is constructed, or loaded later
+    using the load() functions. Data is either supplied directly as serialized XML, or
+    indirectly using a file name. If a valid file has been loaded, either when the renderer
+    is constructed or at some later time, isValid() returns true; otherwise it returns false.
+    QSvgRenderer provides the render() slot to render the current document, or the current
+    frame of an animated document, using a given painter.
+
+    The defaultSize() function provides information about the amount of space that is required
+    to render the currently loaded SVG file. This is useful for paint devices, such as QWidget,
+    that often need to supply a size hint to their parent layout.
+    The default size of a drawing may differ from its visible area, found using the \l viewBox
+    property.
+
+    Animated SVG drawings are supported, and can be controlled with a simple collection of
+    functions and properties:
+
+    \list
+    \o The animated() function indicates whether a drawing contains animation information.
+    \omit
+    \o The animationDuration() function provides the duration in milliseconds of the
+       animation, without taking any looping into account.
+    \o The \l currentFrame property contains the current frame of the animation.
+    \endomit
+    \o The \l framesPerSecond property contains the rate at which the animation plays.
+    \endlist
+
+    Finally, the QSvgRenderer class provides the repaintNeeded() signal which is emitted
+    whenever the rendering of the document needs to be updated.
+
+    \sa QSvgWidget, {QtSvg Module}, {SVG Viewer Example}, QPicture
+*/
+
+class QSvgRendererPrivate : public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(QSvgRenderer)
+public:
+    explicit QSvgRendererPrivate()
+        : QObjectPrivate(),
+          render(0), timer(0),
+          fps(30)
+    {}
+    ~QSvgRendererPrivate()
+    {
+        delete render;
+    }
+
+    static void callRepaintNeeded(QSvgRenderer *const q);
+
+    QSvgTinyDocument *render;
+    QTimer *timer;
+    int fps;
+};
+
+/*!
+    Constructs a new renderer with the given \a parent.
+*/
+QSvgRenderer::QSvgRenderer(QObject *parent)
+    : QObject(*(new QSvgRendererPrivate), parent)
+{
+}
+
+/*!
+    Constructs a new renderer with the given \a parent and loads the contents of the
+    SVG file with the specified \a filename.
+*/
+QSvgRenderer::QSvgRenderer(const QString &filename, QObject *parent)
+    : QObject(*new QSvgRendererPrivate, parent)
+{
+    load(filename);
+}
+
+/*!
+    Constructs a new renderer with the given \a parent and loads the SVG data
+    from the byte array specified by \a contents.
+*/
+QSvgRenderer::QSvgRenderer(const QByteArray &contents, QObject *parent)
+    : QObject(*new QSvgRendererPrivate, parent)
+{
+    load(contents);
+}
+
+/*!
+    \since 4.5
+
+    Constructs a new renderer with the given \a parent and loads the SVG data
+    using the stream reader specified by \a contents.
+*/
+QSvgRenderer::QSvgRenderer(QXmlStreamReader *contents, QObject *parent)
+    : QObject(*new QSvgRendererPrivate, parent)
+{
+    load(contents);
+}
+
+/*!
+    Destroys the renderer.
+*/
+QSvgRenderer::~QSvgRenderer()
+{
+
+}
+
+/*!
+    Returns true if there is a valid current document; otherwise returns false.
+*/
+bool QSvgRenderer::isValid() const
+{
+    Q_D(const QSvgRenderer);
+    return d->render;
+}
+
+/*!
+    Returns the default size of the document contents.
+*/
+QSize QSvgRenderer::defaultSize() const
+{
+    Q_D(const QSvgRenderer);
+    if (d->render)
+        return d->render->size();
+    else
+        return QSize();
+}
+
+/*!
+    Returns viewBoxF().toRect().
+
+    \sa viewBoxF()
+*/
+QRect QSvgRenderer::viewBox() const
+{
+    Q_D(const QSvgRenderer);
+    if (d->render)
+        return d->render->viewBox().toRect();
+    else
+        return QRect();
+}
+
+/*!
+    \property QSvgRenderer::viewBox
+    \brief the rectangle specifying the visible area of the document in logical coordinates
+    \since 4.2
+*/
+void QSvgRenderer::setViewBox(const QRect &viewbox)
+{
+    Q_D(QSvgRenderer);
+    if (d->render)
+        d->render->setViewBox(viewbox);
+}
+
+/*!
+    Returns true if the current document contains animated elements; otherwise
+    returns false.
+
+    \sa framesPerSecond()
+*/
+bool QSvgRenderer::animated() const
+{
+    Q_D(const QSvgRenderer);
+    if (d->render)
+        return d->render->animated();
+    else
+        return false;
+}
+
+/*!
+    \property QSvgRenderer::framesPerSecond
+    \brief the number of frames per second to be shown
+
+    The number of frames per second is 0 if the current document is not animated.
+
+    \sa animated()
+*/
+int QSvgRenderer::framesPerSecond() const
+{
+    Q_D(const QSvgRenderer);
+    return d->fps;
+}
+
+void QSvgRenderer::setFramesPerSecond(int num)
+{
+    Q_D(QSvgRenderer);
+    if (num < 0) {
+        qWarning("QSvgRenderer::setFramesPerSecond: Cannot set negative value %d", num);
+        return;
+    }
+    d->fps = num;
+}
+
+/*!
+  \property QSvgRenderer::currentFrame
+  \brief the current frame of the document's animation, or 0 if the document is not animated
+  \internal
+
+  \sa animationDuration(), framesPerSecond, animated()
+*/
+
+/*!
+  \internal
+*/
+int QSvgRenderer::currentFrame() const
+{
+    Q_D(const QSvgRenderer);
+    return d->render->currentFrame();
+}
+
+/*!
+  \internal
+*/
+void QSvgRenderer::setCurrentFrame(int frame)
+{
+    Q_D(QSvgRenderer);
+    d->render->setCurrentFrame(frame);
+}
+
+/*!
+    \internal
+
+    Returns the number of frames in the animation, or 0 if the current document is not
+    animated.
+
+    \sa animated(), framesPerSecond
+*/
+int QSvgRenderer::animationDuration() const
+{
+    Q_D(const QSvgRenderer);
+    return d->render->animationDuration();
+}
+
+/*!
+ \internal
+ \since 4.5
+
+ We can't have template functions, that's loadDocument(), as friends, for this
+ code, so we let this function be a friend of QSvgRenderer instead.
+ */
+void QSvgRendererPrivate::callRepaintNeeded(QSvgRenderer *const q)
+{
+    q->repaintNeeded();
+}
+
+template<typename TInputType>
+static bool loadDocument(QSvgRenderer *const q,
+                         QSvgRendererPrivate *const d,
+                         const TInputType &in)
+{
+    delete d->render;
+    d->render = QSvgTinyDocument::load(in);
+    if (d->render && d->render->animated() && d->fps > 0) {
+        if (!d->timer)
+            d->timer = new QTimer(q);
+        else
+            d->timer->stop();
+        q->connect(d->timer, SIGNAL(timeout()),
+                   q, SIGNAL(repaintNeeded()));
+        d->timer->start(1000/d->fps);
+    } else if (d->timer) {
+        d->timer->stop();
+    }
+
+    //force first update
+    QSvgRendererPrivate::callRepaintNeeded(q);
+
+    return d->render;
+}
+
+/*!
+    Loads the SVG file specified by \a filename, returning true if the content
+    was successfully parsed; otherwise returns false.
+*/
+bool QSvgRenderer::load(const QString &filename)
+{
+    Q_D(QSvgRenderer);
+    return loadDocument(this, d, filename);
+}
+
+/*!
+    Loads the specified SVG format \a contents, returning true if the content
+    was successfully parsed; otherwise returns false.
+*/
+bool QSvgRenderer::load(const QByteArray &contents)
+{
+    Q_D(QSvgRenderer);
+    return loadDocument(this, d, contents);
+}
+
+/*!
+  Loads the specified SVG in \a contents, returning true if the content
+  was successfully parsed; otherwise returns false.
+
+  The reader will be used from where it currently is positioned. If \a contents
+  is \c null, behavior is undefined.
+
+  \since 4.5
+*/
+bool QSvgRenderer::load(QXmlStreamReader *contents)
+{
+    Q_D(QSvgRenderer);
+    return loadDocument(this, d, contents);
+}
+
+/*!
+    Renders the current document, or the current frame of an animated
+    document, using the given \a painter.
+*/
+void QSvgRenderer::render(QPainter *painter)
+{
+    Q_D(QSvgRenderer);
+    if (d->render) {
+        d->render->draw(painter);
+    }
+}
+
+/*!
+    \fn void QSvgRenderer::repaintNeeded()
+
+    This signal is emitted whenever the rendering of the document
+    needs to be updated, usually for the purposes of animation.
+*/
+
+/*!
+    Renders the given element with \a elementId using the given \a painter
+    on the specified \a bounds. If the bounding rectangle is not specified
+    the SVG element is mapped to the whole paint device.
+*/
+void QSvgRenderer::render(QPainter *painter, const QString &elementId,
+                          const QRectF &bounds)
+{
+    Q_D(QSvgRenderer);
+    if (d->render) {
+        d->render->draw(painter, elementId, bounds);
+    }
+}
+
+/*!
+    Renders the current document, or the current frame of an animated
+    document, using the given \a painter on the specified \a bounds within
+    the painter.  If the bounding rectangle is not specified
+    the SVG file is mapped to the whole paint device.
+*/
+void QSvgRenderer::render(QPainter *painter, const QRectF &bounds)
+{
+    Q_D(QSvgRenderer);
+    if (d->render) {
+        d->render->draw(painter, bounds);
+    }
+}
+
+QRectF QSvgRenderer::viewBoxF() const
+{
+    Q_D(const QSvgRenderer);
+    if (d->render)
+        return d->render->viewBox();
+    else
+        return QRect();
+}
+
+void QSvgRenderer::setViewBox(const QRectF &viewbox)
+{
+    Q_D(QSvgRenderer);
+    if (d->render)
+        d->render->setViewBox(viewbox);
+}
+
+/*!
+    \since 4.2
+
+    Returns bounding rectangle of the item with the given \a id.
+    The transformation matrix of parent elements is not affecting
+    the bounds of the element.
+
+    \sa matrixForElement()
+*/
+QRectF QSvgRenderer::boundsOnElement(const QString &id) const
+{
+    Q_D(const QSvgRenderer);
+    QRectF bounds;
+    if (d->render)
+        bounds = d->render->boundsOnElement(id);
+    return bounds;
+}
+
+
+/*!
+    \since 4.2
+
+    Returns true if the element with the given \a id exists
+    in the currently parsed SVG file and is a renderable
+    element.
+
+    Note: this method returns true only for elements that
+    can be rendered. Which implies that elements that are considered
+    part of the fill/stroke style properties, e.g. radialGradients
+    even tough marked with "id" attributes will not be found by this
+    method.
+*/
+bool QSvgRenderer::elementExists(const QString &id) const
+{
+    Q_D(const QSvgRenderer);
+    bool exists = false;
+    if (d->render)
+        exists = d->render->elementExists(id);
+    return exists;
+}
+
+/*!
+    \since 4.2
+
+    Returns the transformation matrix for the element
+    with the given \a id. The matrix is a product of
+    the transformation of the element's parents. The transformation of
+    the element itself is not included.
+
+    To find the bounding rectangle of the element in logical coordinates,
+    you can apply the matrix on the rectangle returned from boundsOnElement().
+
+    \sa boundsOnElement()
+*/
+QMatrix QSvgRenderer::matrixForElement(const QString &id) const
+{
+    Q_D(const QSvgRenderer);
+    QMatrix mat;
+    if (d->render)
+        mat = d->render->matrixForElement(id);
+    return mat;
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qsvgrenderer.cpp"
+
+#endif // QT_NO_SVGRENDERER
diff --git a/src/svg/qsvgrenderer.h b/src/svg/qsvgrenderer.h
new file mode 100644
index 0000000..b1a20d2
--- /dev/null
+++ b/src/svg/qsvgrenderer.h
@@ -0,0 +1,120 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtSvg module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSVGRENDERER_H
+#define QSVGRENDERER_H
+
+#include <QtGui/qmatrix.h>
+
+#ifndef QT_NO_SVGRENDERER
+
+#include <QtCore/qobject.h>
+#include <QtCore/qsize.h>
+#include <QtCore/qrect.h>
+#include <QtCore/qxmlstream.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Svg)
+
+class QSvgRendererPrivate;
+class QPainter;
+class QByteArray;
+
+class Q_SVG_EXPORT QSvgRenderer : public QObject
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QRectF viewBox READ viewBoxF WRITE setViewBox)
+    Q_PROPERTY(int framesPerSecond READ framesPerSecond WRITE setFramesPerSecond)
+    Q_PROPERTY(int currentFrame READ currentFrame WRITE setCurrentFrame)
+public:
+    QSvgRenderer(QObject *parent=0);
+    QSvgRenderer(const QString &filename, QObject *parent=0);
+    QSvgRenderer(const QByteArray &contents, QObject *parent=0);
+    QSvgRenderer(QXmlStreamReader *contents, QObject *parent=0);
+    ~QSvgRenderer();
+
+    bool isValid() const;
+
+    QSize defaultSize() const;
+
+    QRect viewBox() const;
+    QRectF viewBoxF() const;
+    void setViewBox(const QRect &viewbox);
+    void setViewBox(const QRectF &viewbox);
+
+    bool animated() const;
+    int framesPerSecond() const;
+    void setFramesPerSecond(int num);
+    int currentFrame() const;
+    void setCurrentFrame(int);
+    int animationDuration() const;//in seconds
+
+    QRectF boundsOnElement(const QString &id) const;
+    bool elementExists(const QString &id) const;
+    QMatrix matrixForElement(const QString &id) const;
+
+public Q_SLOTS:
+    bool load(const QString &filename);
+    bool load(const QByteArray &contents);
+    bool load(QXmlStreamReader *contents);
+    void render(QPainter *p);
+    void render(QPainter *p, const QRectF &bounds);
+
+    void render(QPainter *p, const QString &elementId,
+                const QRectF &bounds=QRectF());
+
+Q_SIGNALS:
+    void repaintNeeded();
+
+private:
+    Q_DECLARE_PRIVATE(QSvgRenderer)
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QT_NO_SVGRENDERER
+#endif // QSVGRENDERER_H
diff --git a/src/svg/qsvgstructure.cpp b/src/svg/qsvgstructure.cpp
new file mode 100644
index 0000000..71fc8d2
--- /dev/null
+++ b/src/svg/qsvgstructure.cpp
@@ -0,0 +1,383 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtSvg module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qsvgstructure_p.h"
+
+#ifndef QT_NO_SVG
+
+#include "qsvgnode_p.h"
+#include "qsvgstyle_p.h"
+#include "qsvgtinydocument_p.h"
+
+#include "qpainter.h"
+#include "qlocale.h"
+#include "qdebug.h"
+
+QT_BEGIN_NAMESPACE
+
+QSvgG::QSvgG(QSvgNode *parent)
+    : QSvgStructureNode(parent)
+{
+
+}
+
+QSvgStructureNode::~QSvgStructureNode()
+{
+    qDeleteAll(m_renderers);
+}
+
+void QSvgG::draw(QPainter *p, QSvgExtraStates &states)
+{
+    QList<QSvgNode*>::iterator itr = m_renderers.begin();
+    applyStyle(p, states);
+
+    while (itr != m_renderers.end()) {
+        QSvgNode *node = *itr;
+        if ((node->isVisible()) && (node->displayMode() != QSvgNode::NoneMode))
+            node->draw(p, states);
+        ++itr;
+    }
+    revertStyle(p, states);
+}
+
+QSvgNode::Type QSvgG::type() const
+{
+    return G;
+}
+
+QSvgStructureNode::QSvgStructureNode(QSvgNode *parent)
+    :QSvgNode(parent)
+{
+
+}
+
+QSvgNode * QSvgStructureNode::scopeNode(const QString &id) const
+{
+    QSvgTinyDocument *doc = document();
+    return doc ? doc->namedNode(id) : 0;
+}
+
+void QSvgStructureNode::addChild(QSvgNode *child, const QString &id)
+{
+    m_renderers.append(child);
+
+    if (id.isEmpty())
+        return; //we can't add it to scope without id
+
+    QSvgTinyDocument *doc = document();
+    if (doc)
+        doc->addNamedNode(id, child);
+}
+
+QSvgDefs::QSvgDefs(QSvgNode *parent)
+    : QSvgStructureNode(parent)
+{
+}
+
+void QSvgDefs::draw(QPainter *, QSvgExtraStates &)
+{
+    //noop
+}
+
+QSvgNode::Type QSvgDefs::type() const
+{
+    return DEFS;
+}
+
+/*
+  Below is a lookup function based on the gperf output using the following set:
+
+  http://www.w3.org/Graphics/SVG/feature/1.2/#SVG
+  http://www.w3.org/Graphics/SVG/feature/1.2/#SVG-static
+  http://www.w3.org/Graphics/SVG/feature/1.2/#CoreAttribute
+  http://www.w3.org/Graphics/SVG/feature/1.2/#Structure
+  http://www.w3.org/Graphics/SVG/feature/1.2/#ConditionalProcessing
+  http://www.w3.org/Graphics/SVG/feature/1.2/#ConditionalProcessingAttribute
+  http://www.w3.org/Graphics/SVG/feature/1.2/#Image
+  http://www.w3.org/Graphics/SVG/feature/1.2/#Prefetch
+  http://www.w3.org/Graphics/SVG/feature/1.2/#Shape
+  http://www.w3.org/Graphics/SVG/feature/1.2/#Text
+  http://www.w3.org/Graphics/SVG/feature/1.2/#PaintAttribute
+  http://www.w3.org/Graphics/SVG/feature/1.2/#OpacityAttribute
+  http://www.w3.org/Graphics/SVG/feature/1.2/#GraphicsAttribute
+  http://www.w3.org/Graphics/SVG/feature/1.2/#Gradient
+  http://www.w3.org/Graphics/SVG/feature/1.2/#SolidColor
+  http://www.w3.org/Graphics/SVG/feature/1.2/#XlinkAttribute
+  http://www.w3.org/Graphics/SVG/feature/1.2/#ExternalResourcesRequiredAttribute
+  http://www.w3.org/Graphics/SVG/feature/1.2/#Font
+  http://www.w3.org/Graphics/SVG/feature/1.2/#Hyperlinking
+  http://www.w3.org/Graphics/SVG/feature/1.2/#Extensibility
+*/
+
+// ----- begin of generated code -----
+
+/* C code produced by gperf version 3.0.2 */
+/* Command-line: gperf -c -L c svg  */
+/* Computed positions: -k'45-46' */
+
+#if !((' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \
+      && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \
+      && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \
+      && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \
+      && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \
+      && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \
+      && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \
+      && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \
+      && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \
+      && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \
+      && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \
+      && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \
+      && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \
+      && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \
+      && ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \
+      && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \
+      && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \
+      && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \
+      && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \
+      && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \
+      && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \
+      && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \
+      && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126))
+/* The character set is not based on ISO-646.  */
+#error "gperf generated tables don't work with this execution character set. Please report a bug to <bug-gnu-gperf@gnu.org>."
+#endif
+
+enum {
+    TOTAL_KEYWORDS = 20,
+    MIN_WORD_LENGTH = 47,
+    MAX_WORD_LENGTH = 78,
+    MIN_HASH_VALUE = 48,
+    MAX_HASH_VALUE = 88
+};
+/* maximum key range = 41, duplicates = 0 */
+
+inline static bool isSupportedSvgFeature(const QString &str)
+{
+    static const unsigned char asso_values[] = {
+        89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
+        89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
+        89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
+        89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
+        89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
+        89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
+        89, 89, 89, 89, 89, 89, 89,  0, 89,  5,
+        15,  5,  0, 10, 89, 89, 89, 89, 89,  0,
+        15, 89, 89,  0,  0, 89,  5, 89,  0, 89,
+        89, 89, 89, 89, 89, 89, 89,  0, 89, 89,
+        89,  0, 89, 89,  0, 89, 89, 89,  0,  5,
+        89,  0,  0, 89,  5, 89,  0, 89, 89, 89,
+        5,  0, 89, 89, 89, 89, 89, 89, 89, 89,
+        89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
+        89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
+        89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
+        89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
+        89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
+        89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
+        89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
+        89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
+        89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
+        89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
+        89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
+        89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
+        89, 89, 89, 89, 89, 89
+    };
+
+    static const char * wordlist[] = {
+        "", "", "", "", "", "", "", "", "",
+        "", "", "", "", "", "", "", "", "",
+        "", "", "", "", "", "", "", "", "",
+        "", "", "", "", "", "", "", "", "",
+        "", "", "", "", "", "", "", "", "",
+        "", "", "",
+        "http://www.w3.org/Graphics/SVG/feature/1.2/#Text",
+        "http://www.w3.org/Graphics/SVG/feature/1.2/#Shape",
+        "", "",
+        "http://www.w3.org/Graphics/SVG/feature/1.2/#SVG",
+        "http://www.w3.org/Graphics/SVG/feature/1.2/#Structure",
+        "http://www.w3.org/Graphics/SVG/feature/1.2/#SolidColor",
+        "",
+        "http://www.w3.org/Graphics/SVG/feature/1.2/#Hyperlinking",
+        "http://www.w3.org/Graphics/SVG/feature/1.2/#CoreAttribute",
+        "http://www.w3.org/Graphics/SVG/feature/1.2/#XlinkAttribute",
+        "http://www.w3.org/Graphics/SVG/feature/1.2/#SVG-static",
+        "http://www.w3.org/Graphics/SVG/feature/1.2/#OpacityAttribute",
+        "",
+        "http://www.w3.org/Graphics/SVG/feature/1.2/#Gradient",
+        "http://www.w3.org/Graphics/SVG/feature/1.2/#Font",
+        "http://www.w3.org/Graphics/SVG/feature/1.2/#Image",
+        "http://www.w3.org/Graphics/SVG/feature/1.2/#ConditionalProcessing",
+        "",
+        "http://www.w3.org/Graphics/SVG/feature/1.2/#Extensibility",
+        "", "", "",
+        "http://www.w3.org/Graphics/SVG/feature/1.2/#GraphicsAttribute",
+        "http://www.w3.org/Graphics/SVG/feature/1.2/#Prefetch",
+        "http://www.w3.org/Graphics/SVG/feature/1.2/#PaintAttribute",
+        "http://www.w3.org/Graphics/SVG/feature/1.2/#ConditionalProcessingAttribute",
+        "", "", "", "", "", "", "", "", "",
+        "", "", "", "",
+        "http://www.w3.org/Graphics/SVG/feature/1.2/#ExternalResourcesRequiredAttribute"
+    };
+
+    if (str.length() <= MAX_WORD_LENGTH && str.length() >= MIN_WORD_LENGTH) {
+        const int key = str.length()
+                        + asso_values[str.at(45).unicode()]
+                        + asso_values[str.at(44).unicode()];
+        if (key <= MAX_HASH_VALUE && key >= 0)
+            return str == QLatin1String(wordlist[key]);
+    }
+    return false;
+}
+
+// ----- end of generated code -----
+
+static inline bool isSupportedSvgExtension(const QString &)
+{
+    return false;
+}
+
+
+QSvgSwitch::QSvgSwitch(QSvgNode *parent)
+    : QSvgStructureNode(parent)
+{
+    init();
+}
+
+void QSvgSwitch::draw(QPainter *p, QSvgExtraStates &states)
+{
+    QList<QSvgNode*>::iterator itr = m_renderers.begin();
+    applyStyle(p, states);
+
+    while (itr != m_renderers.end()) {
+        QSvgNode *node = *itr;
+        if (node->isVisible() && (node->displayMode() != QSvgNode::NoneMode)) {
+            const QStringList &features  = node->requiredFeatures();
+            const QStringList &extensions = node->requiredExtensions();
+            const QStringList &languages = node->requiredLanguages();
+            const QStringList &formats = node->requiredFormats();
+            const QStringList &fonts = node->requiredFonts();
+
+            bool okToRender = true;
+            if (!features.isEmpty()) {
+                QStringList::const_iterator sitr = features.constBegin();
+                for (; sitr != features.constEnd(); ++sitr) {
+                    if (!isSupportedSvgFeature(*sitr)) {
+                        okToRender = false;
+                        break;
+                    }
+                }
+            }
+
+            if (okToRender && !extensions.isEmpty()) {
+                QStringList::const_iterator sitr = extensions.constBegin();
+                for (; sitr != extensions.constEnd(); ++sitr) {
+                    if (!isSupportedSvgExtension(*sitr)) {
+                        okToRender = false;
+                        break;
+                    }
+                }
+            }
+
+            if (okToRender && !languages.isEmpty()) {
+                QStringList::const_iterator sitr = languages.constBegin();
+                okToRender = false;
+                for (; sitr != languages.constEnd(); ++sitr) {
+                    if ((*sitr).startsWith(m_systemLanguagePrefix)) {
+                        okToRender = true;
+                        break;
+                    }
+                }
+            }
+
+            if (okToRender && !formats.isEmpty()) {
+                okToRender = false;
+            }
+
+            if (okToRender && !fonts.isEmpty()) {
+                okToRender = false;
+            }
+
+            if (okToRender) {
+                node->draw(p, states);
+                break;
+            }
+        }
+        ++itr;
+    }
+    revertStyle(p, states);
+}
+
+QSvgNode::Type QSvgSwitch::type() const
+{
+    return SWITCH;
+}
+
+void QSvgSwitch::init()
+{
+    QLocale locale;
+    m_systemLanguage = locale.name().replace(QLatin1Char('_'), QLatin1Char('-'));
+    int idx = m_systemLanguage.indexOf(QLatin1Char('-'));
+    m_systemLanguagePrefix = m_systemLanguage.mid(0, idx);
+}
+
+QRectF QSvgStructureNode::bounds(QPainter *p, QSvgExtraStates &states) const
+{
+    QRectF bounds;
+    foreach(QSvgNode *node, m_renderers)
+        bounds |= node->transformedBounds(p, states);
+    return bounds;
+}
+
+QSvgNode * QSvgStructureNode::previousSiblingNode(QSvgNode *n) const
+{
+    QSvgNode *prev = 0;
+    QList<QSvgNode*>::const_iterator itr = m_renderers.constBegin();
+    while (itr != m_renderers.constEnd()) {
+        QSvgNode *node = *itr;
+        if (node == n)
+            return prev;
+        prev = node;
+    }
+    return prev;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SVG
diff --git a/src/svg/qsvgstructure_p.h b/src/svg/qsvgstructure_p.h
new file mode 100644
index 0000000..f511c02
--- /dev/null
+++ b/src/svg/qsvgstructure_p.h
@@ -0,0 +1,118 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtSvg module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSVGSTRUCTURE_P_H
+#define QSVGSTRUCTURE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qsvgnode_p.h"
+
+#ifndef QT_NO_SVG
+
+#include "QtCore/qlist.h"
+#include "QtCore/qhash.h"
+
+QT_BEGIN_NAMESPACE
+
+class QSvgTinyDocument;
+class QSvgNode;
+class QPainter;
+class QSvgDefs;
+
+class QSvgStructureNode : public QSvgNode
+{
+public:
+    QSvgStructureNode(QSvgNode *parent);
+    ~QSvgStructureNode();
+    QSvgNode *scopeNode(const QString &id) const;
+    void addChild(QSvgNode *child, const QString &id);
+    virtual QRectF bounds(QPainter *p, QSvgExtraStates &states) const;
+    QSvgNode *previousSiblingNode(QSvgNode *n) const;
+    QList<QSvgNode*> renderers() const { return m_renderers; }
+protected:
+    QList<QSvgNode*>          m_renderers;
+    QHash<QString, QSvgNode*> m_scope;
+    QList<QSvgStructureNode*> m_linkedScopes;
+};
+
+class QSvgG : public QSvgStructureNode
+{
+public:
+    QSvgG(QSvgNode *parent);
+    virtual void draw(QPainter *p, QSvgExtraStates &states);
+    Type type() const;
+};
+
+class QSvgDefs : public QSvgStructureNode
+{
+public:
+    QSvgDefs(QSvgNode *parent);
+    virtual void draw(QPainter *p, QSvgExtraStates &states);
+    Type type() const;
+};
+
+class QSvgSwitch : public QSvgStructureNode
+{
+public:
+    QSvgSwitch(QSvgNode *parent);
+    virtual void draw(QPainter *p, QSvgExtraStates &states);
+    Type type() const;
+private:
+    void init();
+private:
+    QString m_systemLanguage;
+    QString m_systemLanguagePrefix;
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SVG
+#endif // QSVGSTRUCTURE_P_H
diff --git a/src/svg/qsvgstyle.cpp b/src/svg/qsvgstyle.cpp
new file mode 100644
index 0000000..06adec5
--- /dev/null
+++ b/src/svg/qsvgstyle.cpp
@@ -0,0 +1,958 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtSvg module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qsvgstyle_p.h"
+
+#ifndef QT_NO_SVG
+
+#include "qsvgfont_p.h"
+#include "qsvggraphics_p.h"
+#include "qsvgnode_p.h"
+#include "qsvgtinydocument_p.h"
+
+#include "qpainter.h"
+#include "qpair.h"
+#include "qcolor.h"
+#include "qdebug.h"
+#include "qmath.h"
+#include "qnumeric.h"
+
+QT_BEGIN_NAMESPACE
+
+QSvgExtraStates::QSvgExtraStates()
+    : fillOpacity(1.0)
+    , strokeOpacity(1.0)
+    , svgFont(0)
+    , textAnchor(Qt::AlignLeft)
+    , fontWeight(400)
+    , fillRule(Qt::WindingFill)
+    , strokeDashOffset(0)
+    , vectorEffect(false)
+{
+}
+
+QSvgStyleProperty::~QSvgStyleProperty()
+{
+}
+
+void QSvgFillStyleProperty::apply(QPainter *, const QSvgNode *, QSvgExtraStates &)
+{
+    Q_ASSERT(!"This should not be called!");
+}
+
+void QSvgFillStyleProperty::revert(QPainter *, QSvgExtraStates &)
+{
+    Q_ASSERT(!"This should not be called!");
+}
+
+
+QSvgQualityStyle::QSvgQualityStyle(int color)
+    : m_colorRendering(color)
+{
+
+}
+void QSvgQualityStyle::apply(QPainter *, const QSvgNode *, QSvgExtraStates &)
+{
+
+}
+void QSvgQualityStyle::revert(QPainter *, QSvgExtraStates &)
+{
+
+}
+
+QSvgFillStyle::QSvgFillStyle()
+    : m_style(0)
+    , m_fillRule(Qt::WindingFill)
+    , m_oldFillRule(Qt::WindingFill)
+    , m_fillOpacity(1.0)
+    , m_oldFillOpacity(0)
+    , m_gradientResolved(1)
+    , m_fillRuleSet(0)
+    , m_fillOpacitySet(0)
+    , m_fillSet(0)
+{
+}
+
+void QSvgFillStyle::setFillRule(Qt::FillRule f)
+{
+    m_fillRuleSet = 1;
+    m_fillRule = f;
+}
+
+void QSvgFillStyle::setFillOpacity(qreal opacity)
+{
+    m_fillOpacitySet = 1;
+    m_fillOpacity = opacity;
+}
+
+void QSvgFillStyle::setFillStyle(QSvgFillStyleProperty* style)
+{
+    m_style = style;
+    m_fillSet = 1;
+}
+
+void QSvgFillStyle::setBrush(QBrush brush)
+{
+    m_fill = brush;
+    m_style = 0;
+    m_fillSet = 1;
+}
+
+void QSvgFillStyle::apply(QPainter *p, const QSvgNode *, QSvgExtraStates &states)
+{
+    m_oldFill = p->brush();
+    m_oldFillRule = states.fillRule;
+    m_oldFillOpacity = states.fillOpacity;
+
+    if (m_fillRuleSet)
+        states.fillRule = m_fillRule;
+    if (m_fillSet) {
+        if (m_style)
+            p->setBrush(m_style->brush(p, states));
+        else
+            p->setBrush(m_fill);
+    }
+    if (m_fillOpacitySet)
+        states.fillOpacity = m_fillOpacity;
+}
+
+void QSvgFillStyle::revert(QPainter *p, QSvgExtraStates &states)
+{
+    if (m_fillOpacitySet)
+        states.fillOpacity = m_oldFillOpacity;
+    if (m_fillSet)
+        p->setBrush(m_oldFill);
+    if (m_fillRuleSet)
+        states.fillRule = m_oldFillRule;
+}
+
+QSvgViewportFillStyle::QSvgViewportFillStyle(const QBrush &brush)
+    : m_viewportFill(brush)
+{
+}
+
+void QSvgViewportFillStyle::apply(QPainter *p, const QSvgNode *, QSvgExtraStates &)
+{
+    m_oldFill = p->brush();
+    p->setBrush(m_viewportFill);
+}
+
+void QSvgViewportFillStyle::revert(QPainter *p, QSvgExtraStates &)
+{
+    p->setBrush(m_oldFill);
+}
+
+QSvgFontStyle::QSvgFontStyle(QSvgFont *font, QSvgTinyDocument *doc)
+    : m_svgFont(font)
+    , m_doc(doc)
+    , m_familySet(0)
+    , m_sizeSet(0)
+    , m_styleSet(0)
+    , m_variantSet(0)
+    , m_weightSet(0)
+    , m_textAnchorSet(0)
+{
+}
+
+QSvgFontStyle::QSvgFontStyle()
+    : m_svgFont(0)
+    , m_doc(0)
+    , m_familySet(0)
+    , m_sizeSet(0)
+    , m_styleSet(0)
+    , m_variantSet(0)
+    , m_weightSet(0)
+    , m_textAnchorSet(0)
+{
+}
+
+int QSvgFontStyle::SVGToQtWeight(int weight) {
+    switch (weight) {
+    case 100:
+    case 200:
+        return QFont::Light;
+    case 300:
+    case 400:
+        return QFont::Normal;
+    case 500:
+    case 600:
+        return QFont::DemiBold;
+    case 700:
+    case 800:
+        return QFont::Bold;
+    case 900:
+        return QFont::Black;
+    }
+    return QFont::Normal;
+}
+
+void QSvgFontStyle::apply(QPainter *p, const QSvgNode *, QSvgExtraStates &states)
+{
+    m_oldQFont = p->font();
+    m_oldSvgFont = states.svgFont;
+    m_oldTextAnchor = states.textAnchor;
+    m_oldWeight = states.fontWeight;
+
+    if (m_textAnchorSet)
+        states.textAnchor = m_textAnchor;
+
+    QFont font = m_oldQFont;
+    if (m_familySet) {
+        states.svgFont = m_svgFont;
+        font.setFamily(m_qfont.family());
+    }
+
+    if (m_sizeSet)
+        font.setPointSizeF(m_qfont.pointSizeF());
+
+    if (m_styleSet)
+        font.setStyle(m_qfont.style());
+
+    if (m_variantSet)
+        font.setCapitalization(m_qfont.capitalization());
+
+    if (m_weightSet) {
+        if (m_weight == BOLDER) {
+            states.fontWeight = qMin(states.fontWeight + 100, 900);
+        } else if (m_weight == LIGHTER) {
+            states.fontWeight = qMax(states.fontWeight - 100, 100);
+        } else {
+            states.fontWeight = m_weight;
+        }
+        font.setWeight(SVGToQtWeight(states.fontWeight));
+    }
+
+    p->setFont(font);
+}
+
+void QSvgFontStyle::revert(QPainter *p, QSvgExtraStates &states)
+{
+    p->setFont(m_oldQFont);
+    states.svgFont = m_oldSvgFont;
+    states.textAnchor = m_oldTextAnchor;
+    states.fontWeight = m_oldWeight;
+}
+
+QSvgStrokeStyle::QSvgStrokeStyle()
+    : m_strokeOpacity(1.0)
+    , m_oldStrokeOpacity(0.0)
+    , m_strokeDashOffset(0)
+    , m_oldStrokeDashOffset(0)
+    , m_style(0)
+    , m_gradientResolved(1)
+    , m_vectorEffect(0)
+    , m_oldVectorEffect(0)
+    , m_strokeSet(0)
+    , m_strokeDashArraySet(0)
+    , m_strokeDashOffsetSet(0)
+    , m_strokeLineCapSet(0)
+    , m_strokeLineJoinSet(0)
+    , m_strokeMiterLimitSet(0)
+    , m_strokeOpacitySet(0)
+    , m_strokeWidthSet(0)
+    , m_vectorEffectSet(0)
+{
+}
+
+void QSvgStrokeStyle::apply(QPainter *p, const QSvgNode *, QSvgExtraStates &states)
+{
+    m_oldStroke = p->pen();
+    m_oldStrokeOpacity = states.strokeOpacity;
+    m_oldStrokeDashOffset = states.strokeDashOffset;
+    m_oldVectorEffect = states.vectorEffect;
+
+    QPen pen = p->pen();
+
+    qreal oldWidth = pen.widthF();
+    qreal width = m_stroke.widthF();
+    if (oldWidth == 0)
+        oldWidth = 1;
+    if (width == 0)
+        width = 1;
+    qreal scale = oldWidth / width;
+
+    if (m_strokeOpacitySet)
+        states.strokeOpacity = m_strokeOpacity;
+
+    if (m_vectorEffectSet)
+        states.vectorEffect = m_vectorEffect;
+
+    if (m_strokeSet) {
+        if (m_style)
+            pen.setBrush(m_style->brush(p, states));
+        else
+            pen.setBrush(m_stroke.brush());
+    }
+
+    if (m_strokeWidthSet)
+        pen.setWidthF(m_stroke.widthF());
+
+    bool setDashOffsetNeeded = false;
+
+    if (m_strokeDashOffsetSet) {
+        states.strokeDashOffset = m_strokeDashOffset;
+        setDashOffsetNeeded = true;
+    }
+
+    if (m_strokeDashArraySet) {
+        if (m_stroke.style() == Qt::SolidLine) {
+            pen.setStyle(Qt::SolidLine);
+        } else if (m_strokeWidthSet || oldWidth == 1) {
+            // If both width and dash array was set, the dash array is already scaled correctly.
+            pen.setDashPattern(m_stroke.dashPattern());
+            setDashOffsetNeeded = true;
+        } else {
+            // If dash array was set, but not the width, the dash array has to be scaled with respect to the old width.
+            QVector<qreal> dashes = m_stroke.dashPattern();
+            for (int i = 0; i < dashes.size(); ++i)
+                dashes[i] /= oldWidth;
+            pen.setDashPattern(dashes);
+            setDashOffsetNeeded = true;
+        }
+    } else if (m_strokeWidthSet && pen.style() != Qt::SolidLine && scale != 1) {
+        // If the width was set, but not the dash array, the old dash array must be scaled with respect to the new width.
+        QVector<qreal> dashes = pen.dashPattern();
+        for (int i = 0; i < dashes.size(); ++i)
+            dashes[i] *= scale;
+        pen.setDashPattern(dashes);
+        setDashOffsetNeeded = true;
+    }
+
+    if (m_strokeLineCapSet)
+        pen.setCapStyle(m_stroke.capStyle());
+    if (m_strokeLineJoinSet)
+        pen.setJoinStyle(m_stroke.joinStyle());
+    if (m_strokeMiterLimitSet)
+        pen.setMiterLimit(m_stroke.miterLimit());
+
+    // You can have dash offset on solid strokes in SVG files, but not in Qt.
+    // QPen::setDashOffset() will set the pen style to Qt::CustomDashLine,
+    // so don't call the method if the pen is solid.
+    if (setDashOffsetNeeded && pen.style() != Qt::SolidLine) {
+        qreal currentWidth = pen.widthF();
+        if (currentWidth == 0)
+            currentWidth = 1;
+        pen.setDashOffset(states.strokeDashOffset / currentWidth);
+    }
+
+    pen.setCosmetic(states.vectorEffect);
+
+    p->setPen(pen);
+}
+
+void QSvgStrokeStyle::revert(QPainter *p, QSvgExtraStates &states)
+{
+    p->setPen(m_oldStroke);
+    states.strokeOpacity = m_oldStrokeOpacity;
+    states.strokeDashOffset = m_oldStrokeDashOffset;
+    states.vectorEffect = m_oldVectorEffect;
+}
+
+void QSvgStrokeStyle::setDashArray(const QVector<qreal> &dashes)
+{
+    if (m_strokeWidthSet) {
+        QVector<qreal> d = dashes;
+        qreal w = m_stroke.widthF();
+        if (w != 0 && w != 1) {
+            for (int i = 0; i < d.size(); ++i)
+                d[i] /= w;
+        }
+        m_stroke.setDashPattern(d);
+    } else {
+        m_stroke.setDashPattern(dashes);
+    }
+    m_strokeDashArraySet = 1;
+}
+
+QSvgSolidColorStyle::QSvgSolidColorStyle(const QColor &color)
+    : m_solidColor(color)
+{
+}
+
+QSvgGradientStyle::QSvgGradientStyle(QGradient *grad)
+    : m_gradient(grad), m_gradientStopsSet(false)
+{
+}
+
+QBrush QSvgGradientStyle::brush(QPainter *, QSvgExtraStates &)
+{
+    if (!m_link.isEmpty()) {
+        resolveStops();
+    }
+
+    // If the gradient is marked as empty, insert transparent black
+    if (!m_gradientStopsSet) {
+        m_gradient->setStops(QGradientStops() << QGradientStop(0.0, QColor(0, 0, 0, 0)));
+        m_gradientStopsSet = true;
+    }
+
+    QBrush b(*m_gradient);
+
+    if (!m_matrix.isIdentity())
+        b.setMatrix(m_matrix);
+
+    return b;
+}
+
+
+void QSvgGradientStyle::setMatrix(const QMatrix &mat)
+{
+    m_matrix = mat;
+}
+
+QSvgTransformStyle::QSvgTransformStyle(const QTransform &trans)
+    : m_transform(trans)
+{
+}
+
+void QSvgTransformStyle::apply(QPainter *p, const QSvgNode *, QSvgExtraStates &)
+{
+    m_oldWorldTransform = p->worldTransform();
+    p->setWorldTransform(m_transform, true);
+}
+
+void QSvgTransformStyle::revert(QPainter *p, QSvgExtraStates &)
+{
+    p->setWorldTransform(m_oldWorldTransform, false /* don't combine */);
+}
+
+QSvgStyleProperty::Type QSvgQualityStyle::type() const
+{
+    return QUALITY;
+}
+
+QSvgStyleProperty::Type QSvgFillStyle::type() const
+{
+    return FILL;
+}
+
+QSvgStyleProperty::Type QSvgViewportFillStyle::type() const
+{
+    return VIEWPORT_FILL;
+}
+
+QSvgStyleProperty::Type QSvgFontStyle::type() const
+{
+    return FONT;
+}
+
+QSvgStyleProperty::Type QSvgStrokeStyle::type() const
+{
+    return STROKE;
+}
+
+QSvgStyleProperty::Type QSvgSolidColorStyle::type() const
+{
+    return SOLID_COLOR;
+}
+
+QSvgStyleProperty::Type QSvgGradientStyle::type() const
+{
+    return GRADIENT;
+}
+
+QSvgStyleProperty::Type QSvgTransformStyle::type() const
+{
+    return TRANSFORM;
+}
+
+
+QSvgCompOpStyle::QSvgCompOpStyle(QPainter::CompositionMode mode)
+    : m_mode(mode)
+{
+
+}
+
+void QSvgCompOpStyle::apply(QPainter *p, const QSvgNode *, QSvgExtraStates &)
+{
+    m_oldMode = p->compositionMode();
+    p->setCompositionMode(m_mode);
+}
+
+void QSvgCompOpStyle::revert(QPainter *p, QSvgExtraStates &)
+{
+    p->setCompositionMode(m_oldMode);
+}
+
+QSvgStyleProperty::Type QSvgCompOpStyle::type() const
+{
+    return COMP_OP;
+}
+
+QSvgStyle::~QSvgStyle()
+{
+}
+
+void QSvgStyle::apply(QPainter *p, const QSvgNode *node, QSvgExtraStates &states)
+{
+    if (quality) {
+        quality->apply(p, node, states);
+    }
+
+    if (fill) {
+        fill->apply(p, node, states);
+    }
+
+    if (viewportFill) {
+        viewportFill->apply(p, node, states);
+    }
+
+    if (font) {
+        font->apply(p, node, states);
+    }
+
+    if (stroke) {
+        stroke->apply(p, node, states);
+    }
+
+    if (transform) {
+        transform->apply(p, node, states);
+    }
+
+    if (animateColor) {
+        animateColor->apply(p, node, states);
+    }
+
+    //animated transforms have to be applied
+    //_after_ the original object transformations
+    if (!animateTransforms.isEmpty()) {
+        qreal totalTimeElapsed = node->document()->currentElapsed();
+        // Find the last animateTransform with additive="replace", since this will override all
+        // previous animateTransforms.
+        QList<QSvgRefCounter<QSvgAnimateTransform> >::const_iterator itr = animateTransforms.constEnd();
+        do {
+            --itr;
+            if ((*itr)->animActive(totalTimeElapsed)
+                && (*itr)->additiveType() == QSvgAnimateTransform::Replace) {
+                // An animateTransform with additive="replace" will replace the transform attribute.
+                if (transform)
+                    transform->revert(p, states);
+                break;
+            }
+        } while (itr != animateTransforms.constBegin());
+
+        // Apply the animateTransforms after and including the last one with additive="replace".
+        for (; itr != animateTransforms.constEnd(); ++itr) {
+            if ((*itr)->animActive(totalTimeElapsed))
+                (*itr)->apply(p, node, states);
+        }
+    }
+
+    if (opacity) {
+        opacity->apply(p, node, states);
+    }
+
+    if (compop) {
+        compop->apply(p, node, states);
+    }
+}
+
+void QSvgStyle::revert(QPainter *p, QSvgExtraStates &states)
+{
+    if (quality) {
+        quality->revert(p, states);
+    }
+
+    if (fill) {
+        fill->revert(p, states);
+    }
+
+    if (viewportFill) {
+        viewportFill->revert(p, states);
+    }
+
+    if (font) {
+        font->revert(p, states);
+    }
+
+    if (stroke) {
+        stroke->revert(p, states);
+    }
+
+    //animated transforms need to be reverted _before_
+    //the native transforms
+    if (!animateTransforms.isEmpty()) {
+        QList<QSvgRefCounter<QSvgAnimateTransform> >::const_iterator itr = animateTransforms.constBegin();
+        for (; itr != animateTransforms.constEnd(); ++itr) {
+            if ((*itr)->transformApplied()) {
+                (*itr)->revert(p, states);
+                break;
+            }
+        }
+        for (; itr != animateTransforms.constEnd(); ++itr)
+            (*itr)->clearTransformApplied();
+    }
+
+    if (transform) {
+        transform->revert(p, states);
+    }
+
+    if (animateColor) {
+        animateColor->revert(p, states);
+    }
+
+    if (opacity) {
+        opacity->revert(p, states);
+    }
+
+    if (compop) {
+        compop->revert(p, states);
+    }
+}
+
+QSvgAnimateTransform::QSvgAnimateTransform(int startMs, int endMs, int byMs )
+    : QSvgStyleProperty(),
+      m_from(startMs), m_to(endMs), m_by(byMs),
+      m_type(Empty), m_additive(Replace), m_count(0), m_finished(false), m_transformApplied(false)
+{
+    m_totalRunningTime = m_to - m_from;
+}
+
+void QSvgAnimateTransform::setArgs(TransformType type, Additive additive, const QVector<qreal> &args)
+{
+    m_type = type;
+    m_args = args;
+    m_additive = additive;
+    Q_ASSERT(!(args.count()%3));
+    m_count = args.count() / 3;
+}
+
+void QSvgAnimateTransform::apply(QPainter *p, const QSvgNode *node, QSvgExtraStates &)
+{
+    m_oldWorldTransform = p->worldTransform();
+    resolveMatrix(node);
+    p->setWorldTransform(m_transform, true);
+    m_transformApplied = true;
+}
+
+void QSvgAnimateTransform::revert(QPainter *p, QSvgExtraStates &)
+{
+    p->setWorldTransform(m_oldWorldTransform, false /* don't combine */);
+    m_transformApplied = false;
+}
+
+void QSvgAnimateTransform::resolveMatrix(const QSvgNode *node)
+{
+    static const qreal deg2rad = qreal(0.017453292519943295769);
+    qreal totalTimeElapsed = node->document()->currentElapsed();
+    if (totalTimeElapsed < m_from || m_finished)
+        return;
+
+    qreal animationFrame = 0;
+    if (m_totalRunningTime != 0) {
+        animationFrame = (totalTimeElapsed - m_from) / m_totalRunningTime;
+
+        if (m_repeatCount >= 0 && m_repeatCount < animationFrame) {
+            m_finished = true;
+            animationFrame = m_repeatCount;
+        }
+    }
+
+    qreal percentOfAnimation = animationFrame;
+    if (percentOfAnimation > 1) {
+        percentOfAnimation -= ((int)percentOfAnimation);
+    }
+
+    qreal currentPosition = percentOfAnimation * (m_count - 1);
+    int startElem = qFloor(currentPosition);
+    int endElem   = qCeil(currentPosition);
+
+    switch(m_type)
+    {
+    case Translate: {
+        startElem *= 3;
+        endElem   *= 3;
+        qreal from1, from2;
+        qreal to1, to2;
+        from1 = m_args[startElem++];
+        from2 = m_args[startElem++];
+        to1   = m_args[endElem++];
+        to2   = m_args[endElem++];
+
+        qreal transXDiff = (to1-from1) * percentOfAnimation;
+        qreal transX = from1 + transXDiff;
+        qreal transYDiff = (to2-from2) * percentOfAnimation;
+        qreal transY = from2 + transYDiff;
+        m_transform = QTransform();
+        m_transform.translate(transX, transY);
+        break;
+    }
+    case Scale: {
+        startElem *= 3;
+        endElem   *= 3;
+        qreal from1, from2;
+        qreal to1, to2;
+        from1 = m_args[startElem++];
+        from2 = m_args[startElem++];
+        to1   = m_args[endElem++];
+        to2   = m_args[endElem++];
+
+        qreal transXDiff = (to1-from1) * percentOfAnimation;
+        qreal transX = from1 + transXDiff;
+        qreal transYDiff = (to2-from2) * percentOfAnimation;
+        qreal transY = from2 + transYDiff;
+        if (transY == 0)
+            transY = transX;
+        m_transform = QTransform();
+        m_transform.scale(transX, transY);
+        break;
+    }
+    case Rotate: {
+        startElem *= 3;
+        endElem   *= 3;
+        qreal from1, from2, from3;
+        qreal to1, to2, to3;
+        from1 = m_args[startElem++];
+        from2 = m_args[startElem++];
+        from3 = m_args[startElem++];
+        to1   = m_args[endElem++];
+        to2   = m_args[endElem++];
+        to3   = m_args[endElem++];
+
+        qreal rotationDiff = (to1 - from1) * percentOfAnimation;
+        //qreal rotation = from1 + rotationDiff;
+
+        qreal transXDiff = (to2-from2) * percentOfAnimation;
+        qreal transX = from2 + transXDiff;
+        qreal transYDiff = (to3-from3) * percentOfAnimation;
+        qreal transY = from3 + transYDiff;
+        m_transform = QTransform();
+        m_transform.translate(transX, transY);
+        m_transform.rotate(rotationDiff);
+        m_transform.translate(-transX, -transY);
+        break;
+    }
+    case SkewX: {
+        startElem *= 3;
+        endElem   *= 3;
+        qreal from1;
+        qreal to1;
+        from1 = m_args[startElem++];
+        to1   = m_args[endElem++];
+
+        qreal transXDiff = (to1-from1) * percentOfAnimation;
+        qreal transX = from1 + transXDiff;
+        m_transform = QTransform();
+        m_transform.shear(qTan(transX * deg2rad), 0);
+        break;
+    }
+    case SkewY: {
+        startElem *= 3;
+        endElem   *= 3;
+        qreal from1;
+        qreal to1;
+        from1 = m_args[startElem++];
+        to1   = m_args[endElem++];
+
+
+        qreal transYDiff = (to1 - from1) * percentOfAnimation;
+        qreal transY = from1 + transYDiff;
+        m_transform = QTransform();
+        m_transform.shear(0, qTan(transY * deg2rad));
+        break;
+    }
+    default:
+        break;
+    }
+}
+
+QSvgStyleProperty::Type QSvgAnimateTransform::type() const
+{
+    return ANIMATE_TRANSFORM;
+}
+
+void QSvgAnimateTransform::setFreeze(bool freeze)
+{
+    m_freeze = freeze;
+}
+
+void QSvgAnimateTransform::setRepeatCount(qreal repeatCount)
+{
+    m_repeatCount = repeatCount;
+}
+
+QSvgAnimateColor::QSvgAnimateColor(int startMs, int endMs, int byMs)
+    : QSvgStyleProperty(),
+      m_from(startMs), m_to(endMs), m_by(byMs),
+      m_finished(false)
+{
+    m_totalRunningTime = m_to - m_from;
+}
+
+void QSvgAnimateColor::setArgs(bool fill,
+                               const QList<QColor> &colors)
+{
+    m_fill = fill;
+    m_colors = colors;
+}
+
+void QSvgAnimateColor::setFreeze(bool freeze)
+{
+    m_freeze = freeze;
+}
+
+void QSvgAnimateColor::setRepeatCount(qreal repeatCount)
+{
+    m_repeatCount = repeatCount;
+}
+
+void QSvgAnimateColor::apply(QPainter *p, const QSvgNode *node, QSvgExtraStates &)
+{
+    qreal totalTimeElapsed = node->document()->currentElapsed();
+    if (totalTimeElapsed < m_from || m_finished)
+        return;
+
+    qreal animationFrame = 0;
+    if (m_totalRunningTime != 0)
+        animationFrame = (totalTimeElapsed - m_from) / m_totalRunningTime;
+
+    if (m_repeatCount >= 0 && m_repeatCount < animationFrame) {
+        m_finished = true;
+        animationFrame = m_repeatCount;
+    }
+
+    qreal percentOfAnimation = animationFrame;
+    if (percentOfAnimation > 1) {
+        percentOfAnimation -= ((int)percentOfAnimation);
+    }
+
+    qreal currentPosition = percentOfAnimation * (m_colors.count() - 1);
+
+    int startElem = qFloor(currentPosition);
+    int endElem   = qCeil(currentPosition);
+    QColor start = m_colors[startElem];
+    QColor end = m_colors[endElem];
+
+    qreal percentOfColorMorph = currentPosition;
+    if (percentOfColorMorph > 1) {
+        percentOfColorMorph -= ((int)percentOfColorMorph);
+    }
+
+    // Interpolate between the two fixed colors start and end
+    qreal aDiff = (end.alpha() - start.alpha()) * percentOfColorMorph;
+    qreal rDiff = (end.red()   - start.red()) * percentOfColorMorph;
+    qreal gDiff = (end.green() - start.green()) * percentOfColorMorph;
+    qreal bDiff = (end.blue()  - start.blue()) * percentOfColorMorph;
+
+    int alpha  = int(start.alpha() + aDiff);
+    int red    = int(start.red() + rDiff);
+    int green  = int(start.green() + gDiff);
+    int blue   = int(start.blue() + bDiff);
+
+    QColor color(red, green, blue, alpha);
+
+    if (m_fill) {
+        QBrush b = p->brush();
+        m_oldBrush = b;
+        b.setColor(color);
+        p->setBrush(b);
+    } else {
+        QPen pen = p->pen();
+        m_oldPen = pen;
+        pen.setColor(color);
+        p->setPen(pen);
+    }
+}
+
+void QSvgAnimateColor::revert(QPainter *p, QSvgExtraStates &)
+{
+    if (m_fill) {
+        p->setBrush(m_oldBrush);
+    } else {
+        p->setPen(m_oldPen);
+    }
+}
+
+QSvgStyleProperty::Type QSvgAnimateColor::type() const
+{
+    return ANIMATE_COLOR;
+}
+
+QSvgOpacityStyle::QSvgOpacityStyle(qreal opacity)
+    : m_opacity(opacity), m_oldOpacity(0)
+{
+
+}
+
+void QSvgOpacityStyle::apply(QPainter *p, const QSvgNode *, QSvgExtraStates &)
+{
+    m_oldOpacity = p->opacity();
+    p->setOpacity(m_opacity * m_oldOpacity);
+}
+
+void QSvgOpacityStyle::revert(QPainter *p, QSvgExtraStates &)
+{
+    p->setOpacity(m_oldOpacity);
+}
+
+QSvgStyleProperty::Type QSvgOpacityStyle::type() const
+{
+    return OPACITY;
+}
+
+void QSvgGradientStyle::setStopLink(const QString &link, QSvgTinyDocument *doc)
+{
+    m_link = link;
+    m_doc  = doc;
+}
+
+void QSvgGradientStyle::resolveStops()
+{
+    if (!m_link.isEmpty() && m_doc) {
+        QSvgStyleProperty *prop = m_doc->styleProperty(m_link);
+        if (prop) {
+            if (prop->type() == QSvgStyleProperty::GRADIENT) {
+                QSvgGradientStyle *st =
+                    static_cast<QSvgGradientStyle*>(prop);
+                st->resolveStops();
+                m_gradient->setStops(st->qgradient()->stops());
+                m_gradientStopsSet = st->gradientStopsSet();
+            }
+        } else {
+            qWarning("Could not resolve property : %s", qPrintable(m_link));
+        }
+        m_link = QString();
+    }
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SVG
diff --git a/src/svg/qsvgstyle_p.h b/src/svg/qsvgstyle_p.h
new file mode 100644
index 0000000..e53ab48
--- /dev/null
+++ b/src/svg/qsvgstyle_p.h
@@ -0,0 +1,826 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtSvg module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSVGSTYLE_P_H
+#define QSVGSTYLE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtGui/qpainter.h"
+
+#ifndef QT_NO_SVG
+
+#include "QtGui/qpen.h"
+#include "QtGui/qbrush.h"
+#include "QtGui/qmatrix.h"
+#include "QtGui/qcolor.h"
+#include "QtGui/qfont.h"
+#include <qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+class QPainter;
+class QSvgNode;
+class QSvgFont;
+class QSvgTinyDocument;
+
+template <class T> class QSvgRefCounter
+{
+public:
+    QSvgRefCounter() { t = 0; }
+    QSvgRefCounter(T *_t)
+    {
+        t = _t;
+        if (t)
+            t->ref();
+    }
+    QSvgRefCounter(const QSvgRefCounter &other)
+    {
+        t = other.t;
+        if (t)
+            t->ref();
+    }
+    QSvgRefCounter &operator =(T *_t)
+    {
+        if(_t)
+            _t->ref();
+        if (t)
+            t->deref();
+        t = _t;
+        return *this;
+    }
+    QSvgRefCounter &operator =(const QSvgRefCounter &other)
+    {
+        if(other.t)
+            other.t->ref();
+        if (t)
+            t->deref();
+        t = other.t;
+        return *this;
+    }
+    ~QSvgRefCounter()
+    {
+        if (t)
+            t->deref();
+    }
+
+    inline T *operator->() const { return t; }
+    inline operator T*() const { return t; }
+
+private:
+    T *t;
+};
+
+class QSvgRefCounted
+{
+public:
+    QSvgRefCounted() { _ref = 0; }
+    virtual ~QSvgRefCounted() {}
+    void ref() {
+        ++_ref;
+//        qDebug() << this << ": adding ref, now " << _ref;
+    }
+    void deref() {
+//        qDebug() << this << ": removing ref, now " << _ref;
+        if(!--_ref) {
+//            qDebug("     deleting");
+            delete this;
+        }
+    }
+private:
+    int _ref;
+};
+
+struct QSvgExtraStates
+{
+    QSvgExtraStates();
+
+    qreal fillOpacity;
+    qreal strokeOpacity;
+    QSvgFont *svgFont;
+    Qt::Alignment textAnchor;
+    int fontWeight;
+    Qt::FillRule fillRule;
+    qreal strokeDashOffset;
+    bool vectorEffect; // true if pen is cosmetic
+};
+
+class QSvgStyleProperty : public QSvgRefCounted
+{
+public:
+    enum Type
+    {
+        QUALITY,
+        FILL,
+        VIEWPORT_FILL,
+        FONT,
+        STROKE,
+        SOLID_COLOR,
+        GRADIENT,
+        TRANSFORM,
+        ANIMATE_TRANSFORM,
+        ANIMATE_COLOR,
+        OPACITY,
+        COMP_OP
+    };
+public:
+    virtual ~QSvgStyleProperty();
+    virtual void apply(QPainter *p, const QSvgNode *node, QSvgExtraStates &states) = 0;
+    virtual void revert(QPainter *p, QSvgExtraStates &states) =0;
+    virtual Type type() const=0;
+};
+
+class QSvgFillStyleProperty : public QSvgStyleProperty
+{
+public:
+    virtual QBrush brush(QPainter *p, QSvgExtraStates &states) = 0;
+    virtual void apply(QPainter *p, const QSvgNode *node, QSvgExtraStates &states);
+    virtual void revert(QPainter *p, QSvgExtraStates &states);
+};
+
+class QSvgQualityStyle : public QSvgStyleProperty
+{
+public:
+    QSvgQualityStyle(int color);
+    virtual void apply(QPainter *p, const QSvgNode *node, QSvgExtraStates &states);
+    virtual void revert(QPainter *p, QSvgExtraStates &states);
+    virtual Type type() const;
+private:
+    // color-render ing v 	v 	'auto' | 'optimizeSpeed' |
+    //                                  'optimizeQuality' | 'inherit'
+    int m_colorRendering;
+
+    // shape-rendering v 	v 	'auto' | 'optimizeSpeed' | 'crispEdges' |
+    //                                  'geometricPrecision' | 'inherit'
+    //QSvgShapeRendering m_shapeRendering;
+
+
+    // text-rendering    v 	v 	'auto' | 'optimizeSpeed' | 'optimizeLegibility'
+    //                                | 'geometricPrecision' | 'inherit'
+    //QSvgTextRendering m_textRendering;
+
+
+    // vector-effect         v 	x 	'default' | 'non-scaling-stroke' | 'inherit'
+    //QSvgVectorEffect m_vectorEffect;
+
+    // image-rendering v 	v 	'auto' | 'optimizeSpeed' | 'optimizeQuality' |
+    //                                      'inherit'
+    //QSvgImageRendering m_imageRendering;
+};
+
+
+
+class QSvgOpacityStyle : public QSvgStyleProperty
+{
+public:
+    QSvgOpacityStyle(qreal opacity);
+    virtual void apply(QPainter *p, const QSvgNode *node, QSvgExtraStates &states);
+    virtual void revert(QPainter *p, QSvgExtraStates &states);
+    virtual Type type() const;
+private:
+    qreal m_opacity;
+    qreal m_oldOpacity;
+};
+
+class QSvgFillStyle : public QSvgStyleProperty
+{
+public:
+    QSvgFillStyle();
+    virtual void apply(QPainter *p, const QSvgNode *node, QSvgExtraStates &states);
+    virtual void revert(QPainter *p, QSvgExtraStates &states);
+    virtual Type type() const;
+
+    void setFillRule(Qt::FillRule f);
+    void setFillOpacity(qreal opacity);
+    void setFillStyle(QSvgFillStyleProperty* style);
+    void setBrush(QBrush brush);
+
+    const QBrush & qbrush() const
+    {
+        return m_fill;
+    }
+
+    qreal fillOpacity() const
+    {
+        return m_fillOpacity;
+    }
+
+    Qt::FillRule fillRule() const
+    {
+        return m_fillRule;
+    }
+
+    QSvgFillStyleProperty* style() const
+    {
+        return m_style;
+    }
+
+    void setGradientId(const QString &Id)
+    {
+        m_gradientId = Id;
+    }
+
+    QString gradientId() const
+    {
+        return m_gradientId;
+    }
+
+    void setGradientResolved(bool resolved)
+    {
+        m_gradientResolved = resolved;
+    }
+
+    bool isGradientResolved() const
+    {
+        return m_gradientResolved;
+    }
+
+private:
+    // fill            v 	v 	'inherit' | <Paint.datatype>
+    // fill-opacity    v 	v 	'inherit' | <OpacityValue.datatype>
+    QBrush m_fill;
+    QBrush m_oldFill;
+    QSvgFillStyleProperty *m_style;
+
+    Qt::FillRule m_fillRule;
+    Qt::FillRule m_oldFillRule;
+    qreal m_fillOpacity;
+    qreal m_oldFillOpacity;
+
+    QString m_gradientId;
+    uint m_gradientResolved : 1;
+
+    uint m_fillRuleSet : 1;
+    uint m_fillOpacitySet : 1;
+    uint m_fillSet : 1;
+};
+
+class QSvgViewportFillStyle : public QSvgStyleProperty
+{
+public:
+    QSvgViewportFillStyle(const QBrush &brush);
+    virtual void apply(QPainter *p, const QSvgNode *node, QSvgExtraStates &states);
+    virtual void revert(QPainter *p, QSvgExtraStates &states);
+    virtual Type type() const;
+
+    const QBrush & qbrush() const
+    {
+        return m_viewportFill;
+    }
+private:
+    // viewport-fill         v 	x 	'inherit' | <Paint.datatype>
+    // viewport-fill-opacity 	v 	x 	'inherit' | <OpacityValue.datatype>
+    QBrush m_viewportFill;
+
+    QBrush m_oldFill;
+};
+
+class QSvgFontStyle : public QSvgStyleProperty
+{
+public:
+    static const int LIGHTER = -1;
+    static const int BOLDER = 1;
+
+    QSvgFontStyle(QSvgFont *font, QSvgTinyDocument *doc);
+    QSvgFontStyle();
+    virtual void apply(QPainter *p, const QSvgNode *node, QSvgExtraStates &states);
+    virtual void revert(QPainter *p, QSvgExtraStates &states);
+    virtual Type type() const;
+
+    void setSize(qreal size)
+    {
+        // Store the _pixel_ size in the font. Since QFont::setPixelSize() only takes an int, call
+        // QFont::SetPointSize() instead. Set proper font size just before rendering.
+        m_qfont.setPointSizeF(size);
+        m_sizeSet = 1;
+    }
+
+    void setTextAnchor(Qt::Alignment anchor)
+    {
+        m_textAnchor = anchor;
+        m_textAnchorSet = 1;
+    }
+
+    void setFamily(const QString &family)
+    {
+        m_qfont.setFamily(family);
+        m_familySet = 1;
+    }
+
+    void setStyle(QFont::Style fontStyle) {
+        m_qfont.setStyle(fontStyle);
+        m_styleSet = 1;
+    }
+
+    void setVariant(QFont::Capitalization fontVariant)
+    {
+        m_qfont.setCapitalization(fontVariant);
+        m_variantSet = 1;
+    }
+
+    static int SVGToQtWeight(int weight);
+
+    void setWeight(int weight)
+    {
+        m_weight = weight;
+        m_weightSet = 1;
+    }
+
+    QSvgFont * svgFont() const
+    {
+        return m_svgFont;
+    }
+
+    const QFont &qfont() const
+    {
+        return m_qfont;
+    }
+
+    QSvgTinyDocument *doc() const {return m_doc;}
+
+private:
+    QSvgFont *m_svgFont;
+    QSvgTinyDocument *m_doc;
+    QFont m_qfont;
+
+    int m_weight;
+    Qt::Alignment m_textAnchor;
+
+    QSvgFont *m_oldSvgFont;
+    QFont m_oldQFont;
+    Qt::Alignment m_oldTextAnchor;
+    int m_oldWeight;
+
+    uint m_familySet : 1;
+    uint m_sizeSet : 1;
+    uint m_styleSet : 1;
+    uint m_variantSet : 1;
+    uint m_weightSet : 1;
+    uint m_textAnchorSet : 1;
+};
+
+class QSvgStrokeStyle : public QSvgStyleProperty
+{
+public:
+    QSvgStrokeStyle();
+    virtual void apply(QPainter *p, const QSvgNode *node, QSvgExtraStates &states);
+    virtual void revert(QPainter *p, QSvgExtraStates &states);
+    virtual Type type() const;
+
+    void setStroke(QBrush brush)
+    {
+        m_stroke.setBrush(brush);
+        m_style = 0;
+        m_strokeSet = 1;
+    }
+
+    void setStyle(QSvgFillStyleProperty *style)
+    {
+        m_style = style;
+        m_strokeSet = 1;
+    }
+
+    void setDashArray(const QVector<qreal> &dashes);
+
+    void setDashArrayNone()
+    {
+        m_stroke.setStyle(Qt::SolidLine);
+        m_strokeDashArraySet = 1;
+    }
+
+    void setDashOffset(qreal offset)
+    {
+        m_strokeDashOffset = offset;
+        m_strokeDashOffsetSet = 1;
+    }
+
+    void setLineCap(Qt::PenCapStyle cap)
+    {
+        m_stroke.setCapStyle(cap);
+        m_strokeLineCapSet = 1;
+    }
+
+    void setLineJoin(Qt::PenJoinStyle join)
+    {
+        m_stroke.setJoinStyle(join);
+        m_strokeLineJoinSet = 1;
+    }
+
+    void setMiterLimit(qreal limit)
+    {
+        m_stroke.setMiterLimit(limit);
+        m_strokeMiterLimitSet = 1;
+    }
+
+    void setOpacity(qreal opacity)
+    {
+        m_strokeOpacity = opacity;
+        m_strokeOpacitySet = 1;
+    }
+
+    void setWidth(qreal width)
+    {
+        m_stroke.setWidthF(width);
+        m_strokeWidthSet = 1;
+        Q_ASSERT(!m_strokeDashArraySet); // set width before dash array.
+    }
+
+    qreal width()
+    {
+        return m_stroke.widthF();
+    }
+
+    void setVectorEffect(bool nonScalingStroke)
+    {
+        m_vectorEffect = nonScalingStroke;
+        m_vectorEffectSet = 1;
+    }
+
+    QSvgFillStyleProperty* style() const
+    {
+        return m_style;
+    }
+
+    void setGradientId(const QString &Id)
+    {
+        m_gradientId = Id;
+    }
+
+    QString gradientId() const
+    {
+        return m_gradientId;
+    }
+
+    void setGradientResolved(bool resolved)
+    {
+        m_gradientResolved = resolved;
+    }
+
+    bool isGradientResolved() const
+    {
+        return m_gradientResolved;
+    }
+
+    QPen stroke() const
+    {
+        return m_stroke;
+    }
+
+private:
+    // stroke            v 	v 	'inherit' | <Paint.datatype>
+    // stroke-dasharray  v 	v 	'inherit' | <StrokeDashArrayValue.datatype>
+    // stroke-dashoffset v 	v 	'inherit' | <StrokeDashOffsetValue.datatype>
+    // stroke-linecap    v 	v 	'butt' | 'round' | 'square' | 'inherit'
+    // stroke-linejoin   v 	v 	'miter' | 'round' | 'bevel' | 'inherit'
+    // stroke-miterlimit v 	v 	'inherit' | <StrokeMiterLimitValue.datatype>
+    // stroke-opacity    v 	v 	'inherit' | <OpacityValue.datatype>
+    // stroke-width      v 	v 	'inherit' | <StrokeWidthValue.datatype>
+    QPen m_stroke;
+    QPen m_oldStroke;
+    qreal m_strokeOpacity;
+    qreal m_oldStrokeOpacity;
+    qreal m_strokeDashOffset;
+    qreal m_oldStrokeDashOffset;
+
+    QSvgFillStyleProperty *m_style;
+    QString m_gradientId;
+    uint m_gradientResolved : 1;
+    uint m_vectorEffect : 1;
+    uint m_oldVectorEffect : 1;
+
+    uint m_strokeSet : 1;
+    uint m_strokeDashArraySet : 1;
+    uint m_strokeDashOffsetSet : 1;
+    uint m_strokeLineCapSet : 1;
+    uint m_strokeLineJoinSet : 1;
+    uint m_strokeMiterLimitSet : 1;
+    uint m_strokeOpacitySet : 1;
+    uint m_strokeWidthSet : 1;
+    uint m_vectorEffectSet : 1;
+};
+
+class QSvgSolidColorStyle : public QSvgFillStyleProperty
+{
+public:
+    QSvgSolidColorStyle(const QColor &color);
+    virtual Type type() const;
+
+    const QColor & qcolor() const
+    {
+        return m_solidColor;
+    }
+
+    QBrush brush(QPainter *, QSvgExtraStates &)
+    {
+        return m_solidColor;
+    }
+
+private:
+    // solid-color       v 	x 	'inherit' | <SVGColor.datatype>
+    // solid-opacity     v 	x 	'inherit' | <OpacityValue.datatype>
+    QColor m_solidColor;
+
+    QBrush m_oldFill;
+    QPen   m_oldStroke;
+};
+
+class QSvgGradientStyle : public QSvgFillStyleProperty
+{
+public:
+    QSvgGradientStyle(QGradient *grad);
+    ~QSvgGradientStyle() { delete m_gradient; }
+    virtual Type type() const;
+
+    void setStopLink(const QString &link, QSvgTinyDocument *doc);
+    QString stopLink() const { return m_link; }
+    void resolveStops();
+
+    void setMatrix(const QMatrix &matrix);
+    QMatrix  qmatrix() const
+    {
+        return m_matrix;
+    }
+
+    QGradient *qgradient() const
+    {
+        return m_gradient;
+    }
+
+    bool gradientStopsSet() const
+    {
+        return m_gradientStopsSet;
+    }
+
+    void setGradientStopsSet(bool set)
+    {
+        m_gradientStopsSet = set;
+    }
+
+    QBrush brush(QPainter *, QSvgExtraStates &);
+private:
+    QGradient      *m_gradient;
+    QMatrix m_matrix;
+
+    QSvgTinyDocument *m_doc;
+    QString           m_link;
+    bool m_gradientStopsSet;
+};
+
+class QSvgTransformStyle : public QSvgStyleProperty
+{
+public:
+    QSvgTransformStyle(const QTransform &transform);
+    virtual void apply(QPainter *p, const QSvgNode *node, QSvgExtraStates &states);
+    virtual void revert(QPainter *p, QSvgExtraStates &states);
+    virtual Type type() const;
+
+    const QTransform & qtransform() const
+    {
+        return m_transform;
+    }
+private:
+    //7.6 The transform  attribute
+    QTransform m_transform;
+    QTransform m_oldWorldTransform;
+};
+
+
+class QSvgAnimateTransform : public QSvgStyleProperty
+{
+public:
+    enum TransformType
+    {
+        Empty,
+        Translate,
+        Scale,
+        Rotate,
+        SkewX,
+        SkewY
+    };
+    enum Additive
+    {
+        Sum,
+        Replace
+    };
+public:
+    QSvgAnimateTransform(int startMs, int endMs, int by = 0);
+    void setArgs(TransformType type, Additive additive, const QVector<qreal> &args);
+    void setFreeze(bool freeze);
+    void setRepeatCount(qreal repeatCount);
+    virtual void apply(QPainter *p, const QSvgNode *node, QSvgExtraStates &states);
+    virtual void revert(QPainter *p, QSvgExtraStates &states);
+    virtual Type type() const;
+    QSvgAnimateTransform::Additive additiveType() const
+    {
+        return m_additive;
+    }
+
+    bool animActive(qreal totalTimeElapsed)
+    {
+        if (totalTimeElapsed < m_from)
+            return false;
+        if (m_freeze || m_repeatCount < 0) // fill="freeze" or repeat="indefinite"
+            return true;
+        if (m_totalRunningTime == 0)
+            return false;
+        qreal animationFrame = (totalTimeElapsed - m_from) / m_totalRunningTime;
+        if (animationFrame > m_repeatCount)
+            return false;
+        return true;
+    }
+
+    bool transformApplied() const
+    {
+        return m_transformApplied;
+    }
+
+    // Call this instead of revert if you know that revert is unnecessary.
+    void clearTransformApplied()
+    {
+        m_transformApplied = false;
+    }
+
+protected:
+    void resolveMatrix(const QSvgNode *node);
+private:
+    qreal m_from, m_to, m_by;
+    qreal m_totalRunningTime;
+    TransformType m_type;
+    Additive m_additive;
+    QVector<qreal> m_args;
+    int m_count;
+    QTransform m_transform;
+    QTransform m_oldWorldTransform;
+    bool m_finished;
+    bool m_freeze;
+    qreal m_repeatCount;
+    bool m_transformApplied;
+};
+
+
+class QSvgAnimateColor : public QSvgStyleProperty
+{
+public:
+    QSvgAnimateColor(int startMs, int endMs, int by = 0);
+    void setArgs(bool fill, const QList<QColor> &colors);
+    void setFreeze(bool freeze);
+    void setRepeatCount(qreal repeatCount);
+    virtual void apply(QPainter *p, const QSvgNode *node, QSvgExtraStates &states);
+    virtual void revert(QPainter *p, QSvgExtraStates &states);
+    virtual Type type() const;
+private:
+    qreal m_from, m_to, m_by;
+    qreal m_totalRunningTime;
+    QList<QColor> m_colors;
+    QBrush m_oldBrush;
+    QPen   m_oldPen;
+    bool m_fill;
+    bool m_finished;
+    bool m_freeze;
+    qreal m_repeatCount;
+};
+
+
+class QSvgCompOpStyle : public QSvgStyleProperty
+{
+public:
+    QSvgCompOpStyle(QPainter::CompositionMode mode);
+    virtual void apply(QPainter *p, const QSvgNode *node, QSvgExtraStates &states);
+    virtual void revert(QPainter *p, QSvgExtraStates &states);
+    virtual Type type() const;
+
+    const QPainter::CompositionMode & compOp() const
+    {
+        return m_mode;
+    }
+private:
+    //comp-op attribute
+    QPainter::CompositionMode m_mode;
+
+    QPainter::CompositionMode m_oldMode;
+};
+
+
+class QSvgStyle
+{
+public:
+    QSvgStyle()
+        : quality(0),
+          fill(0),
+          viewportFill(0),
+          font(0),
+          stroke(0),
+          solidColor(0),
+          gradient(0),
+          transform(0),
+          animateColor(0),
+          opacity(0),
+          compop(0)
+    {}
+    ~QSvgStyle();
+
+    void apply(QPainter *p, const QSvgNode *node, QSvgExtraStates &states);
+    void revert(QPainter *p, QSvgExtraStates &states);
+    QSvgRefCounter<QSvgQualityStyle>      quality;
+    QSvgRefCounter<QSvgFillStyle>         fill;
+    QSvgRefCounter<QSvgViewportFillStyle> viewportFill;
+    QSvgRefCounter<QSvgFontStyle>         font;
+    QSvgRefCounter<QSvgStrokeStyle>       stroke;
+    QSvgRefCounter<QSvgSolidColorStyle>   solidColor;
+    QSvgRefCounter<QSvgGradientStyle>     gradient;
+    QSvgRefCounter<QSvgTransformStyle>    transform;
+    QSvgRefCounter<QSvgAnimateColor>      animateColor;
+    QList<QSvgRefCounter<QSvgAnimateTransform> >   animateTransforms;
+    QSvgRefCounter<QSvgOpacityStyle>      opacity;
+    QSvgRefCounter<QSvgCompOpStyle>       compop;
+};
+
+/********************************************************/
+// NOT implemented:
+
+// color           v 	v 	'inherit' | <Color.datatype>
+//QColor m_color;
+
+// display         v 	x 	'inline' | 'block' | 'list-item'
+//                                 | 'run-in' | 'compact' | 'marker' |
+//                                 'table' | 'inline-table' |
+//                                 'table-row-group' | 'table-header-group' |
+//                                 'table-footer-group' | 'table-row' |
+//                                 'table-column-group' | 'table-column' |
+//                                 'table-cell' | 'table-caption' |
+//                                 'none' | 'inherit'
+//QSvgDisplayStyle m_display;
+
+// display-align   v 	v 	'auto' | 'before' | 'center' | 'after' | 'inherit'
+//QSvgDisplayAlign m_displayAlign;
+
+// line-increment  v 	v 	'auto' | 'inherit' | <Number.datatype>
+//int m_lineIncrement;
+
+// text-anchor       v 	v 	'start' | 'middle' | 'end' | 'inherit'
+//QSvgTextAnchor m_textAnchor;
+
+// visibility 	v 	v 	'visible' | 'hidden' | 'inherit'
+//QSvgVisibility m_visibility;
+
+/******************************************************/
+// the following do not make sense for us
+
+// pointer-events  v 	v 	'visiblePainted' | 'visibleFill' | 'visibleStroke' |
+//                              'visible' | 'painted' | 'fill' | 'stroke' | 'all' |
+//                              'none' | 'inherit'
+//QSvgPointEvents m_pointerEvents;
+
+// audio-level     v  	x  	'inherit' | <Number.datatype>
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SVG
+#endif // QSVGSTYLE_P_H
diff --git a/src/svg/qsvgtinydocument.cpp b/src/svg/qsvgtinydocument.cpp
new file mode 100644
index 0000000..7bd8004
--- /dev/null
+++ b/src/svg/qsvgtinydocument.cpp
@@ -0,0 +1,492 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtSvg module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qsvgtinydocument_p.h"
+
+#ifndef QT_NO_SVG
+
+#include "qsvghandler_p.h"
+#include "qsvgfont_p.h"
+
+#include "qpainter.h"
+#include "qfile.h"
+#include "qbuffer.h"
+#include "qbytearray.h"
+#include "qqueue.h"
+#include "qstack.h"
+#include "qdebug.h"
+
+#ifndef QT_NO_COMPRESS
+#include <zlib.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+QSvgTinyDocument::QSvgTinyDocument()
+    : QSvgStructureNode(0)
+    , m_widthPercent(false)
+    , m_heightPercent(false)
+    , m_animated(false)
+    , m_animationDuration(0)
+    , m_fps(30)
+{
+}
+
+QSvgTinyDocument::~QSvgTinyDocument()
+{
+}
+
+#ifndef QT_NO_COMPRESS
+#   ifdef QT_BUILD_INTERNAL
+Q_AUTOTEST_EXPORT QByteArray qt_inflateGZipDataFrom(QIODevice *device);
+#   else
+static QByteArray qt_inflateGZipDataFrom(QIODevice *device);
+#   endif
+
+QByteArray qt_inflateGZipDataFrom(QIODevice *device)
+{
+    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) {
+        qWarning("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();
+            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);
+                    qWarning("Error while inflating gzip file: %s",
+                            (zlibStream.msg != NULL ? zlibStream.msg : "Unknown error"));
+                    destination.chop(zlibStream.avail_out);
+                    return destination;
+                }
+            }
+
+        // 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 (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;
+}
+#endif
+
+QSvgTinyDocument * QSvgTinyDocument::load(const QString &fileName)
+{
+    QFile file(fileName);
+    if (!file.open(QFile::ReadOnly)) {
+        qWarning("Cannot open file '%s', because: %s",
+                 qPrintable(fileName), qPrintable(file.errorString()));
+        return 0;
+    }
+
+#ifndef QT_NO_COMPRESS
+    if (fileName.endsWith(QLatin1String(".svgz"), Qt::CaseInsensitive)
+            || fileName.endsWith(QLatin1String(".svg.gz"), Qt::CaseInsensitive)) {
+        return load(qt_inflateGZipDataFrom(&file));
+    }
+#endif
+
+    QSvgTinyDocument *doc = 0;
+    QSvgHandler handler(&file);
+    if (handler.ok()) {
+        doc = handler.document();
+        doc->m_animationDuration = handler.animationDuration();
+    } else {
+        qWarning("Cannot read file '%s', because: %s (line %d)",
+                 qPrintable(fileName), qPrintable(handler.errorString()), handler.lineNumber());
+    }
+    return doc;
+}
+
+QSvgTinyDocument * QSvgTinyDocument::load(const QByteArray &contents)
+{
+#ifndef QT_NO_COMPRESS
+    // Check for gzip magic number and inflate if appropriate
+    if (contents.startsWith("\x1f\x8b")) {
+        QBuffer buffer(const_cast<QByteArray *>(&contents));
+        return load(qt_inflateGZipDataFrom(&buffer));
+    }
+#endif
+
+    QSvgHandler handler(contents);
+
+    QSvgTinyDocument *doc = 0;
+    if (handler.ok()) {
+        doc = handler.document();
+        doc->m_animationDuration = handler.animationDuration();
+    }
+    return doc;
+}
+
+QSvgTinyDocument * QSvgTinyDocument::load(QXmlStreamReader *contents)
+{
+    QSvgHandler handler(contents);
+
+    QSvgTinyDocument *doc = 0;
+    if (handler.ok()) {
+        doc = handler.document();
+        doc->m_animationDuration = handler.animationDuration();
+    }
+    return doc;
+}
+
+void QSvgTinyDocument::draw(QPainter *p, const QRectF &bounds)
+{
+    if (m_time.isNull()) {
+        m_time.start();
+    }
+
+    if (displayMode() == QSvgNode::NoneMode)
+        return;
+
+    p->save();
+    //sets default style on the painter
+    //### not the most optimal way
+    mapSourceToTarget(p, bounds);
+    QPen pen(Qt::NoBrush, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
+    pen.setMiterLimit(4);
+    p->setPen(pen);
+    p->setBrush(Qt::black);
+    p->setRenderHint(QPainter::Antialiasing);
+    p->setRenderHint(QPainter::SmoothPixmapTransform);
+    QList<QSvgNode*>::iterator itr = m_renderers.begin();
+    applyStyle(p, m_states);
+    while (itr != m_renderers.end()) {
+        QSvgNode *node = *itr;
+        if ((node->isVisible()) && (node->displayMode() != QSvgNode::NoneMode))
+            node->draw(p, m_states);
+        ++itr;
+    }
+    revertStyle(p, m_states);
+    p->restore();
+}
+
+
+void QSvgTinyDocument::draw(QPainter *p, const QString &id,
+                            const QRectF &bounds)
+{
+    QSvgNode *node = scopeNode(id);
+
+    if (!node) {
+        qDebug("Couldn't find node %s. Skipping rendering.", qPrintable(id));
+        return;
+    }
+    if (m_time.isNull()) {
+        m_time.start();
+    }
+
+    if (node->displayMode() == QSvgNode::NoneMode)
+        return;
+
+    p->save();
+
+    const QRectF elementBounds = node->transformedBounds();
+
+    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::MiterJoin);
+    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 QSvgTinyDocument::type() const
+{
+    return DOC;
+}
+
+void QSvgTinyDocument::setWidth(int len, bool percent)
+{
+    m_size.setWidth(len);
+    m_widthPercent = percent;
+}
+
+void QSvgTinyDocument::setHeight(int len, bool percent)
+{
+    m_size.setHeight(len);
+    m_heightPercent = percent;
+}
+
+void QSvgTinyDocument::setViewBox(const QRectF &rect)
+{
+    m_viewBox = rect;
+}
+
+void QSvgTinyDocument::addSvgFont(QSvgFont *font)
+{
+    m_fonts.insert(font->familyName(), font);
+}
+
+QSvgFont * QSvgTinyDocument::svgFont(const QString &family) const
+{
+    return m_fonts[family];
+}
+
+void QSvgTinyDocument::addNamedNode(const QString &id, QSvgNode *node)
+{
+    m_namedNodes.insert(id, node);
+}
+
+QSvgNode *QSvgTinyDocument::namedNode(const QString &id) const
+{
+    return m_namedNodes.value(id);
+}
+
+void QSvgTinyDocument::addNamedStyle(const QString &id, QSvgFillStyleProperty *style)
+{
+    m_namedStyles.insert(id, style);
+}
+
+QSvgFillStyleProperty *QSvgTinyDocument::namedStyle(const QString &id) const
+{
+    return m_namedStyles.value(id);
+}
+
+void QSvgTinyDocument::restartAnimation()
+{
+    m_time.restart();
+}
+
+bool QSvgTinyDocument::animated() const
+{
+    return m_animated;
+}
+
+void QSvgTinyDocument::setAnimated(bool a)
+{
+    m_animated = a;
+}
+
+void QSvgTinyDocument::draw(QPainter *p)
+{
+    draw(p, QRectF());
+}
+
+void QSvgTinyDocument::draw(QPainter *p, QSvgExtraStates &)
+{
+    draw(p);
+}
+
+void QSvgTinyDocument::mapSourceToTarget(QPainter *p, const QRectF &targetRect, const QRectF &sourceRect)
+{
+    QRectF target = targetRect;
+    if (target.isNull()) {
+        QPaintDevice *dev = p->device();
+        QRectF deviceRect(0, 0, dev->width(), dev->height());
+        if (deviceRect.isNull()) {
+            if (sourceRect.isNull())
+                target = QRectF(QPointF(0, 0), size());
+            else
+                target = QRectF(QPointF(0, 0), sourceRect.size());
+        } else {
+            target = deviceRect;
+        }
+    }
+
+    QRectF source = sourceRect;
+    if (source.isNull())
+        source = viewBox();
+
+    if (source != target && !source.isNull()) {
+        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());
+    }
+}
+
+QRectF QSvgTinyDocument::boundsOnElement(const QString &id) const
+{
+    const QSvgNode *node = scopeNode(id);
+    if (!node)
+        node = this;
+    return node->transformedBounds();
+}
+
+bool QSvgTinyDocument::elementExists(const QString &id) const
+{
+    QSvgNode *node = scopeNode(id);
+
+    return (node!=0);
+}
+
+QMatrix QSvgTinyDocument::matrixForElement(const QString &id) const
+{
+    QSvgNode *node = scopeNode(id);
+
+    if (!node) {
+        qDebug("Couldn't find node %s. Skipping rendering.", qPrintable(id));
+        return QMatrix();
+    }
+
+    QTransform t;
+
+    node = node->parent();
+    while (node) {
+        if (node->m_style.transform)
+            t *= node->m_style.transform->qtransform();
+        node = node->parent();
+    }
+    
+    return t.toAffine();
+}
+
+int QSvgTinyDocument::currentFrame() const
+{
+    double runningPercentage = qMin(m_time.elapsed()/double(m_animationDuration), 1.);
+
+    int totalFrames = m_fps * m_animationDuration;
+
+    return int(runningPercentage * totalFrames);
+}
+
+void QSvgTinyDocument::setCurrentFrame(int frame)
+{
+    int totalFrames = m_fps * m_animationDuration;
+    double framePercentage = frame/double(totalFrames);
+    double timeForFrame = m_animationDuration * framePercentage; //in S
+    timeForFrame *= 1000; //in ms
+    int timeToAdd = int(timeForFrame - m_time.elapsed());
+    m_time = m_time.addMSecs(timeToAdd);
+}
+
+void QSvgTinyDocument::setFramesPerSecond(int num)
+{
+    m_fps = num;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SVG
diff --git a/src/svg/qsvgtinydocument_p.h b/src/svg/qsvgtinydocument_p.h
new file mode 100644
index 0000000..e54a41f
--- /dev/null
+++ b/src/svg/qsvgtinydocument_p.h
@@ -0,0 +1,200 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtSvg module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSVGTINYDOCUMENT_P_H
+#define QSVGTINYDOCUMENT_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qsvgstructure_p.h"
+
+#ifndef QT_NO_SVG
+
+#include "QtCore/qrect.h"
+#include "QtCore/qlist.h"
+#include "QtCore/qhash.h"
+#include "QtCore/qdatetime.h"
+#include "QtCore/qxmlstream.h"
+#include "qsvgstyle_p.h"
+#include "qsvgfont_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QPainter;
+class QByteArray;
+class QSvgFont;
+
+class Q_SVG_EXPORT QSvgTinyDocument : public QSvgStructureNode
+{
+public:
+    static QSvgTinyDocument * load(const QString &file);
+    static QSvgTinyDocument * load(const QByteArray &contents);
+    static QSvgTinyDocument * load(QXmlStreamReader *contents);
+public:
+    QSvgTinyDocument();
+    ~QSvgTinyDocument();
+    Type type() const;
+
+    QSize size() const;
+    void setWidth(int len, bool percent);
+    void setHeight(int len, bool percent);
+    int width() const;
+    int height() const;
+    bool widthPercent() const;
+    bool heightPercent() const;
+
+    bool preserveAspectRatio() const;
+
+    QRectF viewBox() const;
+    void setViewBox(const QRectF &rect);
+
+    virtual void draw(QPainter *p, QSvgExtraStates &);//from the QSvgNode
+
+    void draw(QPainter *p);
+    void draw(QPainter *p, const QRectF &bounds);
+    void draw(QPainter *p, const QString &id,
+              const QRectF &bounds=QRectF());
+
+    QMatrix matrixForElement(const QString &id) const;
+    QRectF boundsOnElement(const QString &id) const;
+    bool   elementExists(const QString &id) const;
+
+    void addSvgFont(QSvgFont *);
+    QSvgFont *svgFont(const QString &family) const;
+    void addNamedNode(const QString &id, QSvgNode *node);
+    QSvgNode *namedNode(const QString &id) const;
+    void addNamedStyle(const QString &id, QSvgFillStyleProperty *style);
+    QSvgFillStyleProperty *namedStyle(const QString &id) const;
+
+    void restartAnimation();
+    int currentElapsed() const;
+    bool animated() const;
+    void setAnimated(bool a);
+    int animationDuration() const;
+    int currentFrame() const;
+    void setCurrentFrame(int);
+    void setFramesPerSecond(int num);
+private:
+    void mapSourceToTarget(QPainter *p, const QRectF &targetRect, const QRectF &sourceRect = QRectF());
+private:
+    QSize  m_size;
+    bool   m_widthPercent;
+    bool   m_heightPercent;
+
+    mutable QRectF m_viewBox;
+
+    QHash<QString, QSvgRefCounter<QSvgFont> > m_fonts;
+    QHash<QString, QSvgNode *> m_namedNodes;
+    QHash<QString, QSvgRefCounter<QSvgFillStyleProperty> > m_namedStyles;
+
+    QTime m_time;
+    bool  m_animated;
+    int   m_animationDuration;
+    int   m_fps;
+
+    QSvgExtraStates m_states;
+};
+
+inline QSize QSvgTinyDocument::size() const
+{
+    if (m_size.isEmpty()) {
+        return viewBox().size().toSize();
+    } else {
+        return m_size;
+    }
+}
+
+inline int QSvgTinyDocument::width() const
+{
+    return size().width();
+}
+
+inline int QSvgTinyDocument::height() const
+{
+    return size().height();
+}
+
+inline bool QSvgTinyDocument::widthPercent() const
+{
+    return m_widthPercent;
+}
+
+inline bool QSvgTinyDocument::heightPercent() const
+{
+    return m_heightPercent;
+}
+
+inline QRectF QSvgTinyDocument::viewBox() const
+{
+    if (m_viewBox.isNull())
+        m_viewBox = transformedBounds();
+
+    return m_viewBox;
+}
+
+inline bool QSvgTinyDocument::preserveAspectRatio() const
+{
+    return false;
+}
+
+inline int QSvgTinyDocument::currentElapsed() const
+{
+    return m_time.elapsed();
+}
+
+inline int QSvgTinyDocument::animationDuration() const
+{
+    return m_animationDuration;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SVG
+#endif // QSVGTINYDOCUMENT_P_H
diff --git a/src/svg/qsvgwidget.cpp b/src/svg/qsvgwidget.cpp
new file mode 100644
index 0000000..d43db92
--- /dev/null
+++ b/src/svg/qsvgwidget.cpp
@@ -0,0 +1,173 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtSvg module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qsvgwidget.h"
+
+#ifndef QT_NO_SVGWIDGET
+
+#include "qsvgrenderer.h"
+
+#include "qpainter.h"
+#include "private/qwidget_p.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QSvgWidget
+    \ingroup painting
+
+    \brief The QSvgWidget class provides a widget that is used to display the contents of
+    Scalable Vector Graphics (SVG) files.
+    \since 4.1
+
+    This class enables developers to display SVG drawings alongside standard widgets, and
+    is used in much the same way as QLabel is used for displaying text and bitmap images.
+
+    Since QSvgWidget is a subclass of QWidget, SVG drawings are rendered using the properties
+    of the display. More control can be exercised over the rendering process with the
+    QSvgRenderer class, as this can be used to paint onto other paint devices, such as QImage
+    and QGLWidget. The renderer used by the widget can be obtained with the renderer()
+    function.
+
+    Each QSvgWidget can be constructed with the file name of a SVG file, or they can be
+    constructed without a specific file to render and one can be supplied later. The load()
+    functions provide two different ways to load an SVG file: they accept either the file name
+    of an SVG file or a QByteArray containing the serialized XML representation of an SVG file.
+
+    By default, the widget provides a size hint to reflect the size of the drawing that it
+    displays. If no data has been loaded, the widget provides the default QWidget size hint.
+    Subclass this class and reimplement sizeHint() if you need to customize this behavior.
+
+    \sa QSvgRenderer, {QtSvg Module}, QPicture
+*/
+
+class QSvgWidgetPrivate : public QWidgetPrivate
+{
+    Q_DECLARE_PUBLIC(QSvgWidget)
+public:
+    QSvgRenderer *renderer;
+};
+
+/*!
+    Constructs a new SVG display widget with the given \a parent.
+*/
+QSvgWidget::QSvgWidget(QWidget *parent)
+    : QWidget(*new QSvgWidgetPrivate, parent, 0)
+{
+    d_func()->renderer = new QSvgRenderer(this);
+    QObject::connect(d_func()->renderer, SIGNAL(repaintNeeded()),
+                     this, SLOT(update()));
+}
+
+/*!
+    Constructs a new SVG display widget with the given \a parent and loads the contents
+    of the specified \a file.
+*/
+QSvgWidget::QSvgWidget(const QString &file, QWidget *parent)
+    : QWidget(*new QSvgWidgetPrivate, parent, 0)
+{
+    d_func()->renderer = new QSvgRenderer(file, this);
+    QObject::connect(d_func()->renderer, SIGNAL(repaintNeeded()),
+                     this, SLOT(update()));
+}
+
+/*!
+    Destroys the widget.
+*/
+QSvgWidget::~QSvgWidget()
+{
+
+}
+
+/*!
+    Returns the renderer used to display the contents of the widget.
+*/
+QSvgRenderer * QSvgWidget::renderer() const
+{
+    Q_D(const QSvgWidget);
+    return d->renderer;
+}
+
+
+/*!
+    \reimp
+*/
+QSize QSvgWidget::sizeHint() const
+{
+    Q_D(const QSvgWidget);
+    if (d->renderer->isValid())
+        return d->renderer->defaultSize();
+    else
+        return QSize(128, 64);
+}
+
+
+/*!
+    \reimp
+*/
+void QSvgWidget::paintEvent(QPaintEvent *)
+{
+    Q_D(QSvgWidget);
+    QPainter p(this);
+    d->renderer->render(&p);
+}
+
+/*!
+    Loads the contents of the specified SVG \a file and updates the widget.
+*/
+void QSvgWidget::load(const QString &file)
+{
+    Q_D(const QSvgWidget);
+    d->renderer->load(file);
+}
+
+/*!
+    Loads the specified SVG format \a contents and updates the widget.
+*/
+void QSvgWidget::load(const QByteArray &contents)
+{
+    Q_D(const QSvgWidget);
+    d->renderer->load(contents);
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SVGWIDGET
diff --git a/src/svg/qsvgwidget.h b/src/svg/qsvgwidget.h
new file mode 100644
index 0000000..d404e36
--- /dev/null
+++ b/src/svg/qsvgwidget.h
@@ -0,0 +1,85 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtSvg module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSVGWIDGET_H
+#define QSVGWIDGET_H
+
+#include <QtGui/qwidget.h>
+
+#ifndef QT_NO_SVGWIDGET
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Svg)
+
+class QSvgWidgetPrivate;
+class QPaintEvent;
+class QSvgRenderer;
+
+class Q_SVG_EXPORT QSvgWidget : public QWidget
+{
+    Q_OBJECT
+public:
+    QSvgWidget(QWidget *parent=0);
+    QSvgWidget(const QString &file, QWidget *parent=0);
+    ~QSvgWidget();
+
+    QSvgRenderer *renderer() const;
+
+    QSize sizeHint() const;
+public Q_SLOTS:
+    void load(const QString &file);
+    void load(const QByteArray &contents);
+protected:
+    void paintEvent(QPaintEvent *event);
+private:
+    Q_DISABLE_COPY(QSvgWidget)
+    Q_DECLARE_PRIVATE(QSvgWidget)
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QT_NO_SVGWIDGET
+#endif // QSVGWIDGET_H
diff --git a/src/svg/svg.pro b/src/svg/svg.pro
new file mode 100644
index 0000000..79f284a
--- /dev/null
+++ b/src/svg/svg.pro
@@ -0,0 +1,45 @@
+TARGET     = QtSvg
+QPRO_PWD   = $$PWD
+QT         = core gui
+DEFINES   += QT_BUILD_SVG_LIB
+DEFINES   += QT_NO_USING_NAMESPACE
+win32-msvc*|win32-icc:QMAKE_LFLAGS += /BASE:0x66000000
+solaris-cc*:QMAKE_CXXFLAGS_RELEASE -= -O2
+
+unix|win32-g++*:QMAKE_PKGCONFIG_REQUIRES = QtCore QtGui
+
+include(../qbase.pri)
+
+
+HEADERS += \
+	qsvggraphics_p.h        \
+	qsvghandler_p.h         \
+	qsvgnode_p.h            \
+	qsvgstructure_p.h       \
+	qsvgstyle_p.h           \
+        qsvgfont_p.h            \
+	qsvgtinydocument_p.h    \
+	qsvgrenderer.h          \
+        qsvgwidget.h            \
+        qgraphicssvgitem.h      \
+        qsvggenerator.h
+
+
+SOURCES += \
+	qsvggraphics.cpp        \
+	qsvghandler.cpp         \
+	qsvgnode.cpp            \
+	qsvgstructure.cpp       \  
+	qsvgstyle.cpp           \
+        qsvgfont.cpp            \
+	qsvgtinydocument.cpp    \
+	qsvgrenderer.cpp        \
+        qsvgwidget.cpp          \
+        qgraphicssvgitem.cpp    \
+        qsvggenerator.cpp
+
+INCLUDEPATH += ../3rdparty/harfbuzz/src
+
+symbian:TARGET.UID3=0x2001B2E2
+
+include(../3rdparty/zlib_dependency.pri)