Merge branch '4.7' of scm.dev.nokia.troll.no:qt/qt-s60-public into 4.7-integration

* '4.7' of scm.dev.nokia.troll.no:qt/qt-s60-public:
  Fix build error on S60 3.1 environments
  QRuntimeGraphicsSystem
  Fix replacement functions in platform_paths.prf

7 files changed, 690 insertions, 12 deletions

diff --git a/src/gui/painting/painting.pri b/src/gui/painting/painting.pri
index ed8ee76..123af1c 100644
--- a/src/gui/painting/painting.pri
+++ b/src/gui/painting/painting.pri
@@ -118,12 +118,14 @@ embedded {
 } else {
     HEADERS += \
         painting/qgraphicssystem_raster_p.h \
+        painting/qgraphicssystem_runtime_p.h \
         painting/qgraphicssystemfactory_p.h \
         painting/qgraphicssystemplugin_p.h \
         painting/qwindowsurface_raster_p.h \
 
     SOURCES += \
         painting/qgraphicssystem_raster.cpp \
+        painting/qgraphicssystem_runtime.cpp \
         painting/qgraphicssystemfactory.cpp \
         painting/qgraphicssystemplugin.cpp \
         painting/qwindowsurface_raster.cpp \
diff --git a/src/gui/painting/qgraphicssystem_runtime.cpp b/src/gui/painting/qgraphicssystem_runtime.cpp
new file mode 100644
index 0000000..dfa9bd3
--- /dev/null
+++ b/src/gui/painting/qgraphicssystem_runtime.cpp
@@ -0,0 +1,443 @@
+#include <private/qgraphicssystem_runtime_p.h>
+#include <private/qgraphicssystem_raster_p.h>
+#include <private/qgraphicssystemfactory_p.h>
+#include <private/qapplication_p.h>
+#include <private/qwidget_p.h>
+#include <QtCore/QDebug>
+#include <QtCore/QTimer>
+#include <QtGui/QBitmap>
+
+QT_BEGIN_NAMESPACE
+
+#define READBACK(f)                                         \
+    m_graphicsSystem->decreaseMemoryUsage(memoryUsage());   \
+    f                                                       \
+    readBackInfo();                                         \
+    m_graphicsSystem->increaseMemoryUsage(memoryUsage());   \
+
+
+class QDeferredGraphicsSystemChange : public QObject
+{
+    Q_OBJECT
+
+public:
+    QDeferredGraphicsSystemChange(QRuntimeGraphicsSystem *gs, const QString& graphicsSystemName)
+    : m_graphicsSystem(gs), m_graphicsSystemName(graphicsSystemName)
+    {
+    }
+
+    void launch()
+    {
+        QTimer::singleShot(0, this, SLOT(doChange()));
+    }
+
+private slots:
+
+    void doChange()
+    {
+        m_graphicsSystem->setGraphicsSystem(m_graphicsSystemName);
+        deleteLater();
+    }
+
+private:
+
+    QRuntimeGraphicsSystem *m_graphicsSystem;
+    QString m_graphicsSystemName;
+};
+
+QRuntimePixmapData::QRuntimePixmapData(const QRuntimeGraphicsSystem *gs, PixelType type)
+        : QPixmapData(type, RuntimeClass), m_graphicsSystem(gs)
+{
+    setSerialNumber((int)this);
+}
+
+QRuntimePixmapData::~QRuntimePixmapData()
+{
+    m_graphicsSystem->removePixmapData(this);
+    delete m_data;
+}
+
+void QRuntimePixmapData::readBackInfo()
+{
+    w = m_data->width();
+    h = m_data->height();
+    d = m_data->depth();
+    is_null = m_data->isNull();
+}
+
+
+QPixmapData *QRuntimePixmapData::createCompatiblePixmapData() const
+{
+    QRuntimePixmapData *rtData = new QRuntimePixmapData(m_graphicsSystem, pixelType());
+    rtData->m_data = m_data->createCompatiblePixmapData();
+    return rtData;
+}
+
+
+void QRuntimePixmapData::resize(int width, int height)
+{
+    READBACK(
+        m_data->resize(width, height);
+    )
+}
+
+
+void QRuntimePixmapData::fromImage(const QImage &image,
+                                   Qt::ImageConversionFlags flags)
+{
+    READBACK(
+        m_data->fromImage(image, flags);
+    )
+}
+
+
+bool QRuntimePixmapData::fromFile(const QString &filename, const char *format,
+                                  Qt::ImageConversionFlags flags)
+{
+    bool success(false);
+    READBACK(
+        success = m_data->fromFile(filename, format, flags);
+    )
+    return success;
+}
+
+bool QRuntimePixmapData::fromData(const uchar *buffer, uint len, const char *format,
+                                  Qt::ImageConversionFlags flags)
+{
+    bool success(false);
+    READBACK(
+        success = m_data->fromData(buffer, len, format, flags);
+    )
+    return success;
+}
+
+
+void QRuntimePixmapData::copy(const QPixmapData *data, const QRect &rect)
+{
+    if (data->runtimeData()) {
+        READBACK(
+            m_data->copy(data->runtimeData(), rect);
+        )
+    } else {
+        READBACK(
+            m_data->copy(data, rect);
+        )
+    }
+}
+
+bool QRuntimePixmapData::scroll(int dx, int dy, const QRect &rect)
+{
+    return m_data->scroll(dx, dy, rect);
+}
+
+
+int QRuntimePixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const
+{
+    return m_data->metric(metric);
+}
+
+void QRuntimePixmapData::fill(const QColor &color)
+{
+    return m_data->fill(color);
+}
+
+QBitmap QRuntimePixmapData::mask() const
+{
+    return m_data->mask();
+}
+
+void QRuntimePixmapData::setMask(const QBitmap &mask)
+{
+    READBACK(
+        m_data->setMask(mask);
+    )
+}
+
+bool QRuntimePixmapData::hasAlphaChannel() const
+{
+    return m_data->hasAlphaChannel();
+}
+
+QPixmap QRuntimePixmapData::transformed(const QTransform &matrix,
+                                        Qt::TransformationMode mode) const
+{
+    return m_data->transformed(matrix, mode);
+}
+
+void QRuntimePixmapData::setAlphaChannel(const QPixmap &alphaChannel)
+{
+    READBACK(
+        m_data->setAlphaChannel(alphaChannel);
+    )
+}
+
+QPixmap QRuntimePixmapData::alphaChannel() const
+{
+    return m_data->alphaChannel();
+}
+
+QImage QRuntimePixmapData::toImage() const
+{
+    return m_data->toImage();
+}
+
+QPaintEngine* QRuntimePixmapData::paintEngine() const
+{
+    return m_data->paintEngine();
+}
+
+QImage* QRuntimePixmapData::buffer()
+{
+    return m_data->buffer();
+}
+
+#if defined(Q_OS_SYMBIAN)
+void* QRuntimePixmapData::toNativeType(NativeType type)
+{
+    return m_data->toNativeType(type);
+}
+
+void QRuntimePixmapData::fromNativeType(void *pixmap, NativeType type)
+{
+    m_data->fromNativeType(pixmap, type);
+    readBackInfo();
+}
+#endif
+
+QPixmapData* QRuntimePixmapData::runtimeData() const
+{
+    return m_data;
+}
+
+uint QRuntimePixmapData::memoryUsage() const
+{
+    if(is_null || d == 0)
+        return 0;
+    return w * h * (d / 8);
+}
+
+
+QRuntimeWindowSurface::QRuntimeWindowSurface(const QRuntimeGraphicsSystem *gs, QWidget *window)
+    : QWindowSurface(window), m_windowSurface(0), m_pendingWindowSurface(0), m_graphicsSystem(gs)
+{
+
+}
+
+QRuntimeWindowSurface::~QRuntimeWindowSurface()
+{
+    m_graphicsSystem->removeWindowSurface(this);
+    delete m_windowSurface;
+}
+
+QPaintDevice *QRuntimeWindowSurface::paintDevice()
+{
+    return m_windowSurface->paintDevice();
+}
+
+void QRuntimeWindowSurface::flush(QWidget *widget, const QRegion &region,
+                                  const QPoint &offset)
+{
+    m_windowSurface->flush(widget, region, offset);
+
+    int destroyPolicy = m_graphicsSystem->windowSurfaceDestroyPolicy();
+    if(m_pendingWindowSurface &&
+        destroyPolicy == QRuntimeGraphicsSystem::DestroyAfterFirstFlush) {
+#ifdef QT_DEBUG
+        qDebug() << "QRuntimeWindowSurface::flush() - destroy pending window surface";
+#endif
+        delete m_pendingWindowSurface;
+        m_pendingWindowSurface = 0;
+    }
+}
+
+void QRuntimeWindowSurface::setGeometry(const QRect &rect)
+{
+    m_graphicsSystem->decreaseMemoryUsage(memoryUsage());
+    m_windowSurface->setGeometry(rect);
+    m_graphicsSystem->increaseMemoryUsage(memoryUsage());
+}
+
+bool QRuntimeWindowSurface::scroll(const QRegion &area, int dx, int dy)
+{
+    return m_windowSurface->scroll(area, dx, dy);
+}
+
+void QRuntimeWindowSurface::beginPaint(const QRegion &rgn)
+{
+    m_windowSurface->beginPaint(rgn);
+}
+
+void QRuntimeWindowSurface::endPaint(const QRegion &rgn)
+{
+    m_windowSurface->endPaint(rgn);
+}
+
+QImage* QRuntimeWindowSurface::buffer(const QWidget *widget)
+{
+    return m_windowSurface->buffer(widget);
+}
+
+QPixmap QRuntimeWindowSurface::grabWidget(const QWidget *widget, const QRect& rectangle) const
+{
+    return m_windowSurface->grabWidget(widget, rectangle);
+}
+
+QPoint QRuntimeWindowSurface::offset(const QWidget *widget) const
+{
+    return m_windowSurface->offset(widget);
+}
+
+uint QRuntimeWindowSurface::memoryUsage() const
+{
+    QPaintDevice *pdev = m_windowSurface->paintDevice();
+    if (pdev && pdev->depth() != 0)
+        return pdev->width() * pdev->height() * (pdev->depth()/8);
+
+    return 0;
+}
+
+QRuntimeGraphicsSystem::QRuntimeGraphicsSystem()
+    : m_memoryUsage(0), m_windowSurfaceDestroyPolicy(DestroyImmediately),
+	m_graphicsSystem(0), m_graphicsSystemChangeMemoryLimit(0)
+{
+    QApplicationPrivate::graphics_system_name = QLatin1String("runtime");
+
+#ifdef Q_OS_SYMBIAN
+    m_graphicsSystemName = QLatin1String("openvg");
+    m_windowSurfaceDestroyPolicy = DestroyAfterFirstFlush;
+#else
+    m_graphicsSystemName = QLatin1String("raster");
+#endif
+
+    m_graphicsSystem = QGraphicsSystemFactory::create(m_graphicsSystemName);
+}
+
+
+QPixmapData *QRuntimeGraphicsSystem::createPixmapData(QPixmapData::PixelType type) const
+{
+    Q_ASSERT(m_graphicsSystem);
+    QPixmapData *data = m_graphicsSystem->createPixmapData(type);
+
+    QRuntimePixmapData *rtData = new QRuntimePixmapData(this, type);
+    rtData->m_data = data;
+    m_pixmapDatas << rtData;
+
+    return rtData;
+}
+
+QWindowSurface *QRuntimeGraphicsSystem::createWindowSurface(QWidget *widget) const
+{
+    Q_ASSERT(m_graphicsSystem);
+    QRuntimeWindowSurface *rtSurface = new QRuntimeWindowSurface(this, widget);
+    rtSurface->m_windowSurface = m_graphicsSystem->createWindowSurface(widget);
+    widget->setWindowSurface(rtSurface);
+    m_windowSurfaces << rtSurface;
+    increaseMemoryUsage(rtSurface->memoryUsage());
+    return rtSurface;
+}
+
+/*!
+    Sets graphics system when resource memory consumption is under /a memoryUsageLimit.
+*/
+void QRuntimeGraphicsSystem::setGraphicsSystem(const QString &name, uint memoryUsageLimit)
+{
+#ifdef QT_DEBUG
+    qDebug() << "QRuntimeGraphicsSystem::setGraphicsSystem( "<< name <<", " << memoryUsageLimit << ")";
+    qDebug() << "        current approximated graphics system memory usage " << memoryUsage() << " bytes";
+#endif
+    if (memoryUsage() >= memoryUsageLimit) {
+        m_graphicsSystemChangeMemoryLimit = memoryUsageLimit;
+        m_pendingGraphicsSystemName = name;
+    } else {
+        setGraphicsSystem(name);
+    }
+}
+
+void QRuntimeGraphicsSystem::setGraphicsSystem(const QString &name)
+{
+    if (m_graphicsSystemName == name)
+        return;
+#ifdef QT_DEBUG
+    qDebug() << "QRuntimeGraphicsSystem::setGraphicsSystem( " << name << " )";
+    qDebug() << "        current approximated graphics system memory usage "<< memoryUsage() << " bytes";
+#endif
+    delete m_graphicsSystem;
+    m_graphicsSystem = QGraphicsSystemFactory::create(name);
+    m_graphicsSystemName = name;
+
+    Q_ASSERT(m_graphicsSystem);
+
+    m_graphicsSystemChangeMemoryLimit = 0;
+    m_pendingGraphicsSystemName = QString();
+
+    for (int i = 0; i < m_pixmapDatas.size(); ++i) {
+        QRuntimePixmapData *proxy = m_pixmapDatas.at(i);
+        QPixmapData *newData = m_graphicsSystem->createPixmapData(proxy->m_data->pixelType());
+        // ### TODO Optimize. Openvg and s60raster graphics systems could switch internal ARGB32_PRE QImage buffers.
+        newData->fromImage(proxy->m_data->toImage(), Qt::AutoColor | Qt::OrderedAlphaDither);
+        delete proxy->m_data;
+        proxy->m_data = newData;
+        proxy->readBackInfo();
+    }
+
+    for (int i = 0; i < m_windowSurfaces.size(); ++i) {
+        QRuntimeWindowSurface *proxy = m_windowSurfaces.at(i);
+        QWidget *widget = proxy->m_windowSurface->window();
+
+        if(m_windowSurfaceDestroyPolicy == DestroyImmediately) {
+            delete proxy->m_windowSurface;
+            proxy->m_pendingWindowSurface = 0;
+        } else {
+            proxy->m_pendingWindowSurface = proxy->m_windowSurface;
+        }
+
+        proxy->m_windowSurface = m_graphicsSystem->createWindowSurface(widget);
+        qt_widget_private(widget)->invalidateBuffer(widget->rect());
+    }
+}
+
+void QRuntimeGraphicsSystem::removePixmapData(QRuntimePixmapData *pixmapData) const
+{
+    int index = m_pixmapDatas.lastIndexOf(pixmapData);
+    m_pixmapDatas.removeAt(index);
+    decreaseMemoryUsage(pixmapData->memoryUsage(), true);
+}
+
+void QRuntimeGraphicsSystem::removeWindowSurface(QRuntimeWindowSurface *windowSurface) const
+{
+    int index = m_windowSurfaces.lastIndexOf(windowSurface);
+    m_windowSurfaces.removeAt(index);
+    decreaseMemoryUsage(windowSurface->memoryUsage(), true);
+}
+
+void QRuntimeGraphicsSystem::increaseMemoryUsage(uint amount) const
+{
+    m_memoryUsage += amount;
+
+    if (m_graphicsSystemChangeMemoryLimit &&
+        m_memoryUsage < m_graphicsSystemChangeMemoryLimit) {
+
+        QRuntimeGraphicsSystem *gs = const_cast<QRuntimeGraphicsSystem*>(this);
+        QDeferredGraphicsSystemChange *deferredChange =
+                    new QDeferredGraphicsSystemChange(gs, m_pendingGraphicsSystemName);
+        deferredChange->launch();
+    }
+}
+
+void QRuntimeGraphicsSystem::decreaseMemoryUsage(uint amount, bool persistent) const
+{
+    m_memoryUsage -= amount;
+
+    if (persistent && m_graphicsSystemChangeMemoryLimit &&
+        m_memoryUsage < m_graphicsSystemChangeMemoryLimit) {
+
+        QRuntimeGraphicsSystem *gs = const_cast<QRuntimeGraphicsSystem*>(this);
+        QDeferredGraphicsSystemChange *deferredChange =
+                    new QDeferredGraphicsSystemChange(gs, m_pendingGraphicsSystemName);
+        deferredChange->launch();
+    }
+}
+
+#include "qgraphicssystem_runtime.moc"
+
+QT_END_NAMESPACE
diff --git a/src/gui/painting/qgraphicssystem_runtime_p.h b/src/gui/painting/qgraphicssystem_runtime_p.h
new file mode 100644
index 0000000..445f83d
--- /dev/null
+++ b/src/gui/painting/qgraphicssystem_runtime_p.h
@@ -0,0 +1,197 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 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 QGRAPHICSSYSTEM_RUNTIME_P_H
+#define QGRAPHICSSYSTEM_RUNTIME_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qgraphicssystem_p.h"
+
+#include <private/qpixmapdata_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QRuntimeGraphicsSystem;
+
+class QRuntimePixmapData : public QPixmapData {
+public:
+    QRuntimePixmapData(const QRuntimeGraphicsSystem *gs, PixelType type);
+    ~QRuntimePixmapData();
+
+    virtual QPixmapData *createCompatiblePixmapData() const;
+    virtual void resize(int width, int height);
+    virtual void fromImage(const QImage &image,
+                           Qt::ImageConversionFlags flags);
+
+    virtual bool fromFile(const QString &filename, const char *format,
+                          Qt::ImageConversionFlags flags);
+    virtual bool fromData(const uchar *buffer, uint len, const char *format,
+                          Qt::ImageConversionFlags flags);
+
+    virtual void copy(const QPixmapData *data, const QRect &rect);
+    virtual bool scroll(int dx, int dy, const QRect &rect);
+
+    virtual int metric(QPaintDevice::PaintDeviceMetric metric) const;
+    virtual void fill(const QColor &color);
+    virtual QBitmap mask() const;
+    virtual void setMask(const QBitmap &mask);
+    virtual bool hasAlphaChannel() const;
+    virtual QPixmap transformed(const QTransform &matrix,
+                                Qt::TransformationMode mode) const;
+    virtual void setAlphaChannel(const QPixmap &alphaChannel);
+    virtual QPixmap alphaChannel() const;
+    virtual QImage toImage() const;
+    virtual QPaintEngine *paintEngine() const;
+
+    virtual QImage *buffer();
+
+    void readBackInfo();
+
+    QPixmapData *m_data;
+
+#if defined(Q_OS_SYMBIAN)
+    void* toNativeType(NativeType type);
+    void fromNativeType(void* pixmap, NativeType type);
+#endif
+
+    virtual QPixmapData *runtimeData() const;
+
+    virtual uint memoryUsage() const;
+
+private:
+    const QRuntimeGraphicsSystem *m_graphicsSystem;
+
+};
+
+class QRuntimeWindowSurface : public QWindowSurface {
+public:
+    QRuntimeWindowSurface(const QRuntimeGraphicsSystem *gs, QWidget *window);
+    ~QRuntimeWindowSurface();
+
+    virtual QPaintDevice *paintDevice();
+    virtual void flush(QWidget *widget, const QRegion &region,
+                       const QPoint &offset);
+    virtual void setGeometry(const QRect &rect);
+
+    virtual bool scroll(const QRegion &area, int dx, int dy);
+
+    virtual void beginPaint(const QRegion &);
+    virtual void endPaint(const QRegion &);
+
+    virtual QImage* buffer(const QWidget *widget);
+    virtual QPixmap grabWidget(const QWidget *widget, const QRect& rectangle = QRect()) const;
+
+    virtual QPoint offset(const QWidget *widget) const;
+
+    virtual uint memoryUsage() const;
+
+    QWindowSurface *m_windowSurface;
+    QWindowSurface *m_pendingWindowSurface;
+
+private:
+    const QRuntimeGraphicsSystem *m_graphicsSystem;
+};
+
+class QRuntimeGraphicsSystem : public QGraphicsSystem
+{
+public:
+
+    enum WindowSurfaceDestroyPolicy
+    {
+        DestroyImmediately,
+        DestroyAfterFirstFlush
+    };
+
+public:
+    QRuntimeGraphicsSystem();
+
+    QPixmapData *createPixmapData(QPixmapData::PixelType type) const;
+    QWindowSurface *createWindowSurface(QWidget *widget) const;
+
+    void removePixmapData(QRuntimePixmapData *pixmapData) const;
+    void removeWindowSurface(QRuntimeWindowSurface *windowSurface) const;
+
+    void setGraphicsSystem(const QString &name, uint memoryUsageLimit);
+    void setGraphicsSystem(const QString &name);
+    QString graphicsSystemName() const { return m_graphicsSystemName; }
+
+    void setWindowSurfaceDestroyPolicy(WindowSurfaceDestroyPolicy policy)
+    {
+        m_windowSurfaceDestroyPolicy = policy;
+    }
+
+    int windowSurfaceDestroyPolicy() const { return m_windowSurfaceDestroyPolicy; }
+
+    int memoryUsage() const { return m_memoryUsage; }
+
+private:
+
+    void increaseMemoryUsage(uint amount) const;
+    void decreaseMemoryUsage(uint amount, bool persistent = false) const;
+
+private:
+    mutable uint m_memoryUsage;
+    int m_windowSurfaceDestroyPolicy;
+    QGraphicsSystem *m_graphicsSystem;
+    mutable QList<QRuntimePixmapData *> m_pixmapDatas;
+    mutable QList<QRuntimeWindowSurface *> m_windowSurfaces;
+    QString m_graphicsSystemName;
+
+    uint m_graphicsSystemChangeMemoryLimit;
+    QString m_pendingGraphicsSystemName;
+
+    friend class QRuntimePixmapData;
+    friend class QRuntimeWindowSurface;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/gui/painting/qgraphicssystemfactory.cpp b/src/gui/painting/qgraphicssystemfactory.cpp
index 3c09894..ee6fbd8 100644
--- a/src/gui/painting/qgraphicssystemfactory.cpp
+++ b/src/gui/painting/qgraphicssystemfactory.cpp
@@ -46,6 +46,7 @@
 
 #include "qapplication.h"
 #include "qgraphicssystem_raster_p.h"
+#include "qgraphicssystem_runtime_p.h"
 #include "qdebug.h"
 
 QT_BEGIN_NAMESPACE
@@ -68,6 +69,10 @@ QGraphicsSystem *QGraphicsSystemFactory::create(const QString& key)
     if (system.isEmpty()) {
         system = QLatin1String("openvg");
     }
+#elif defined (QT_GRAPHICSSYSTEM_RUNTIME)
+    if (system.isEmpty()) {
+        system = QLatin1String("runtime");
+    }
 #elif defined (QT_GRAPHICSSYSTEM_RASTER) && !defined(Q_WS_WIN) && !defined(Q_OS_SYMBIAN)
     if (system.isEmpty()) {
         system = QLatin1String("raster");
@@ -76,6 +81,8 @@ QGraphicsSystem *QGraphicsSystemFactory::create(const QString& key)
 
     if (system == QLatin1String("raster"))
         return new QRasterGraphicsSystem;
+    else if (system == QLatin1String("runtime"))
+        return new QRuntimeGraphicsSystem;
     else if (system.isEmpty() || system == QLatin1String("native"))
         return 0;
 
diff --git a/src/gui/painting/qpaintengine_raster.cpp b/src/gui/painting/qpaintengine_raster.cpp
index 6f395f6..48974e8 100644
--- a/src/gui/painting/qpaintengine_raster.cpp
+++ b/src/gui/painting/qpaintengine_raster.cpp
@@ -441,8 +441,9 @@ bool QRasterPaintEngine::begin(QPaintDevice *device)
 
     if (device->devType() == QInternal::Pixmap) {
         QPixmap *pixmap = static_cast<QPixmap *>(device);
-        if (pixmap->data->classId() == QPixmapData::RasterClass)
-            d->device = pixmap->data->buffer();
+        QPixmapData *pd = pixmap->pixmapData();
+        if (pd->classId() == QPixmapData::RasterClass)
+            d->device = pd->buffer();
     } else {
         d->device = device;
     }
@@ -2358,8 +2359,9 @@ void QRasterPaintEngine::drawPixmap(const QPointF &pos, const QPixmap &pixmap)
     qDebug() << " - QRasterPaintEngine::drawPixmap(), pos=" << pos << " pixmap=" << pixmap.size() << "depth=" << pixmap.depth();
 #endif
 
-    if (pixmap.data->classId() == QPixmapData::RasterClass) {
-        const QImage &image = static_cast<QRasterPixmapData *>(pixmap.data.data())->image;
+    QPixmapData *pd = pixmap.pixmapData();
+    if (pd->classId() == QPixmapData::RasterClass) {
+        const QImage &image = static_cast<QRasterPixmapData *>(pd)->image;
         if (image.depth() == 1) {
             Q_D(QRasterPaintEngine);
             QRasterPaintEngineState *s = state();
@@ -2398,8 +2400,9 @@ void QRasterPaintEngine::drawPixmap(const QRectF &r, const QPixmap &pixmap, cons
     qDebug() << " - QRasterPaintEngine::drawPixmap(), r=" << r << " sr=" << sr << " pixmap=" << pixmap.size() << "depth=" << pixmap.depth();
 #endif
 
-    if (pixmap.data->classId() == QPixmapData::RasterClass) {
-        const QImage &image = static_cast<QRasterPixmapData *>(pixmap.data.data())->image;
+    QPixmapData* pd = pixmap.pixmapData();
+    if (pd->classId() == QPixmapData::RasterClass) {
+        const QImage &image = static_cast<QRasterPixmapData *>(pd)->image;
         if (image.depth() == 1) {
             Q_D(QRasterPaintEngine);
             QRasterPaintEngineState *s = state();
@@ -2703,8 +2706,9 @@ void QRasterPaintEngine::drawTiledPixmap(const QRectF &r, const QPixmap &pixmap,
 
     QImage image;
 
-    if (pixmap.data->classId() == QPixmapData::RasterClass) {
-        image = static_cast<QRasterPixmapData *>(pixmap.data.data())->image;
+    QPixmapData *pd = pixmap.pixmapData();
+    if (pd->classId() == QPixmapData::RasterClass) {
+        image = static_cast<QRasterPixmapData *>(pd)->image;
     } else {
         image = pixmap.toImage();
     }
diff --git a/src/gui/painting/qwindowsurface.cpp b/src/gui/painting/qwindowsurface.cpp
index e18ea3f..2fe9036 100644
--- a/src/gui/painting/qwindowsurface.cpp
+++ b/src/gui/painting/qwindowsurface.cpp
@@ -116,8 +116,6 @@ public:
 QWindowSurface::QWindowSurface(QWidget *window)
     : d_ptr(new QWindowSurfacePrivate(window))
 {
-    if (window)
-        window->setWindowSurface(this);
 }
 
 /*!
diff --git a/src/gui/painting/qwindowsurface_s60.cpp b/src/gui/painting/qwindowsurface_s60.cpp
index b25dce5..93d4d18 100644
--- a/src/gui/painting/qwindowsurface_s60.cpp
+++ b/src/gui/painting/qwindowsurface_s60.cpp
@@ -43,10 +43,15 @@
 
 #include <QtGui/qpaintdevice.h>
 #include <private/qwidget_p.h>
-#include "qwindowsurface_s60_p.h"
+#include <private/qwindowsurface_s60_p.h>
 #include <private/qpixmap_s60_p.h>
 #include <private/qt_s60_p.h>
-#include "private/qdrawhelper_p.h"
+#include <private/qapplication_p.h>
+#include <private/qdrawhelper_p.h>
+
+#ifdef QT_GRAPHICSSYSTEM_RUNTIME
+#include <private/qgraphicssystem_runtime_p.h>
+#endif
 
 QT_BEGIN_NAMESPACE
 
@@ -79,13 +84,35 @@ QS60WindowSurface::QS60WindowSurface(QWidget* widget)
 
     setStaticContentsSupport(true);
 }
+
 QS60WindowSurface::~QS60WindowSurface()
 {
+#if defined(QT_GRAPHICSSYSTEM_RUNTIME) && defined(Q_SYMBIAN_SUPPORTS_SURFACES)
+    if(QApplicationPrivate::graphics_system_name == QLatin1String("runtime")) {
+        QRuntimeGraphicsSystem *runtimeGraphicsSystem =
+                static_cast<QRuntimeGraphicsSystem*>(QApplicationPrivate::graphics_system);
+        if(runtimeGraphicsSystem->graphicsSystemName() == QLatin1String("openvg")) {
+
+            // Graphics system has been switched from raster to openvg.
+            // Issue empty redraw to clear the UI surface
+
+            QWidget *w = window();
+            RWindow *const window = static_cast<RWindow *>(w->winId()->DrawableWindow());
+            window->BeginRedraw();
+            window->EndRedraw();
+        }
+    }
+#endif
+
     delete d_ptr;
 }
 
 void QS60WindowSurface::beginPaint(const QRegion &rgn)
 {
+#ifdef Q_SYMBIAN_SUPPORTS_SURFACES
+    S60->wsSession().Finish();
+#endif
+
     if (!qt_widget_private(window())->isOpaque) {
         QS60PixmapData *pixmapData = static_cast<QS60PixmapData *>(d_ptr->device.data_ptr().data());
         pixmapData->beginDataAccess();