Merge branch '4.7-upstream' into 4.7-doc

47 files changed, 2534 insertions, 46 deletions

diff --git a/bin/syncqt b/bin/syncqt
index 907869d..c73d119 100755
--- a/bin/syncqt
+++ b/bin/syncqt
@@ -51,6 +51,7 @@ my %modules = ( # path to module name map
         "QtWebKit" => "$basedir/src/3rdparty/webkit/WebCore",
         "phonon" => "$basedir/src/phonon",
         "QtMultimedia" => "$basedir/src/multimedia",
+        "QtMeeGoGraphicsSystemHelper" => "$basedir/tools/qmeegographicssystemhelper",
 );
 my %moduleheaders = ( # restrict the module headers to those found in relative path
         "QtWebKit" => "../WebKit/qt/Api",
diff --git a/mkspecs/features/qt.prf b/mkspecs/features/qt.prf
index 4fd804d..e59319f 100644
--- a/mkspecs/features/qt.prf
+++ b/mkspecs/features/qt.prf
@@ -36,7 +36,7 @@ INCLUDEPATH = $$QMAKE_INCDIR_QT $$INCLUDEPATH #prepending prevents us from picki
 win32:INCLUDEPATH += $$QMAKE_INCDIR_QT/ActiveQt
 
 # As order does matter for static libs, we reorder the QT variable here
-TMPLIBS = declarative webkit phonon multimedia dbus testlib script scripttools svg qt3support sql xmlpatterns xml egl opengl openvg gui network core
+TMPLIBS = declarative webkit phonon multimedia dbus testlib script scripttools svg qt3support sql xmlpatterns xml egl opengl openvg gui network core meegographicssystemhelper
 for(QTLIB, $$list($$TMPLIBS)) {
    contains(QT, $$QTLIB): QT_ORDERED += $$QTLIB
 }
@@ -175,6 +175,7 @@ for(QTLIB, $$list($$lower($$unique(QT)))) {
        }
    } else:isEqual(QTLIB, declarative):qlib = QtDeclarative
    else:isEqual(QTLIB, multimedia):qlib = QtMultimedia
+   else:isEqual(QTLIB, meegographicssystemhelper):qlib = QtMeeGoGraphicsSystemHelper
    else:message("Unknown QT: $$QTLIB"):qlib =
    !isEmpty(qlib) {
       target_qt:isEqual(TARGET, qlib) {
diff --git a/src/activeqt/control/qaxserverbase.cpp b/src/activeqt/control/qaxserverbase.cpp
index ca16b39..d8e7ea3 100644
--- a/src/activeqt/control/qaxserverbase.cpp
+++ b/src/activeqt/control/qaxserverbase.cpp
@@ -2730,6 +2730,19 @@ HRESULT WINAPI QAxServerBase::Load(IStream *pStm)
 	qtarray.resize(stat.cbSize.LowPart);
         ULONG read;
 	pStm->Read(qtarray.data(), stat.cbSize.LowPart, &read);
+    } else if (hres == E_NOTIMPL) {
+        ULONG read = 0;
+        while (hres != S_FALSE) {
+            QByteArray arrayRead;
+            arrayRead.resize(4098);
+            hres = pStm->Read(arrayRead.data(), arrayRead.size(), &read);
+            if (hres != S_OK && hres != S_FALSE) {
+                qtarray.resize(0);
+                break;
+            } else if (read == 0)
+                break;
+            qtarray.append(arrayRead);
+        }
     }
     const QMetaObject *mo = qt.object->metaObject();
 
diff --git a/src/corelib/plugin/qfactoryloader.cpp b/src/corelib/plugin/qfactoryloader.cpp
index 62d565a..a26dcd8 100644
--- a/src/corelib/plugin/qfactoryloader.cpp
+++ b/src/corelib/plugin/qfactoryloader.cpp
@@ -244,6 +244,14 @@ QObject *QFactoryLoader::instance(const QString &key) const
     return 0;
 }
 
+#ifdef Q_WS_X11
+QLibraryPrivate *QFactoryLoader::library(const QString &key) const
+{
+    Q_D(const QFactoryLoader);
+    return d->keyMap.value(d->cs ? key : key.toLower());
+}
+#endif
+
 void QFactoryLoader::refreshAll()
 {
     QMutexLocker locker(qt_factoryloader_mutex());
diff --git a/src/corelib/plugin/qfactoryloader_p.h b/src/corelib/plugin/qfactoryloader_p.h
index 10e6e2a..068c6c7 100644
--- a/src/corelib/plugin/qfactoryloader_p.h
+++ b/src/corelib/plugin/qfactoryloader_p.h
@@ -77,6 +77,10 @@ public:
     QStringList keys() const;
     QObject *instance(const QString &key) const;
 
+#ifdef Q_WS_X11
+    QLibraryPrivate *library(const QString &key) const;
+#endif
+
     void update();
 
     static void refreshAll();
diff --git a/src/declarative/graphicsitems/qdeclarativeimagebase.cpp b/src/declarative/graphicsitems/qdeclarativeimagebase.cpp
index f0293d6..02b4807 100644
--- a/src/declarative/graphicsitems/qdeclarativeimagebase.cpp
+++ b/src/declarative/graphicsitems/qdeclarativeimagebase.cpp
@@ -129,27 +129,25 @@ QSize QDeclarativeImageBase::sourceSize() const
 void QDeclarativeImageBase::load()
 {
     Q_D(QDeclarativeImageBase);
-    if (d->progress != 0.0) {
-        d->progress = 0.0;
-        emit progressChanged(d->progress);
-    }
 
     if (d->url.isEmpty()) {
         d->pix.clear();
         d->status = Null;
+        d->progress = 0.0;
         setImplicitWidth(0);
         setImplicitHeight(0);
+        emit progressChanged(d->progress);
         emit statusChanged(d->status);
         pixmapChange();
         update();
     } else {
-
-        d->status = Loading;
-        emit statusChanged(d->status);
-
         d->pix.load(qmlEngine(this), d->url, d->sourcesize, d->async);
 
         if (d->pix.isLoading()) {
+            d->progress = 0.0;
+            d->status = Loading;
+            emit progressChanged(d->progress);
+            emit statusChanged(d->status);
 
             static int thisRequestProgress = -1;
             static int thisRequestFinished = -1;
@@ -173,6 +171,9 @@ void QDeclarativeImageBase::requestFinished()
 {
     Q_D(QDeclarativeImageBase);
 
+    QDeclarativeImageBase::Status oldStatus = d->status;
+    qreal oldProgress = d->progress;
+
     if (d->pix.isError()) {
         d->status = Error;
         qmlInfo(this) << d->pix.error();
@@ -191,8 +192,10 @@ void QDeclarativeImageBase::requestFinished()
         emit sourceSizeChanged();
     }
 
-    emit statusChanged(d->status);
-    emit progressChanged(d->progress);
+    if (d->status != oldStatus)
+        emit statusChanged(d->status);
+    if (d->progress != oldProgress)
+        emit progressChanged(d->progress);
     pixmapChange();
     update();
 }
diff --git a/src/declarative/graphicsitems/qdeclarativeimagebase_p.h b/src/declarative/graphicsitems/qdeclarativeimagebase_p.h
index f5896b1..68eb8d0 100644
--- a/src/declarative/graphicsitems/qdeclarativeimagebase_p.h
+++ b/src/declarative/graphicsitems/qdeclarativeimagebase_p.h
@@ -58,7 +58,6 @@ class Q_AUTOTEST_EXPORT QDeclarativeImageBase : public QDeclarativeItem
     Q_PROPERTY(QUrl source READ source WRITE setSource NOTIFY sourceChanged)
     Q_PROPERTY(qreal progress READ progress NOTIFY progressChanged)
     Q_PROPERTY(bool asynchronous READ asynchronous WRITE setAsynchronous NOTIFY asynchronousChanged)
-
     Q_PROPERTY(QSize sourceSize READ sourceSize WRITE setSourceSize NOTIFY sourceSizeChanged)
 
 public:
@@ -79,7 +78,7 @@ public:
 Q_SIGNALS:
     void sourceChanged(const QUrl &);
     void sourceSizeChanged();
-    void statusChanged(Status);
+    void statusChanged(QDeclarativeImageBase::Status);
     void progressChanged(qreal progress);
     void asynchronousChanged();
 
diff --git a/src/gui/egl/qeglcontext_p.h b/src/gui/egl/qeglcontext_p.h
index cae8164..5bc8f09 100644
--- a/src/gui/egl/qeglcontext_p.h
+++ b/src/gui/egl/qeglcontext_p.h
@@ -107,6 +107,9 @@ private:
 
     static QEglContext *currentContext(QEgl::API api);
     static void setCurrentContext(QEgl::API api, QEglContext *context);
+
+    friend class QMeeGoGraphicsSystem;
+    friend class QMeeGoPixmapData;
 };
 
 QT_END_NAMESPACE
diff --git a/src/gui/graphicsview/qgraphicslayoutitem.cpp b/src/gui/graphicsview/qgraphicslayoutitem.cpp
index 3707591..634f68c 100644
--- a/src/gui/graphicsview/qgraphicslayoutitem.cpp
+++ b/src/gui/graphicsview/qgraphicslayoutitem.cpp
@@ -234,7 +234,7 @@ void QGraphicsLayoutItemPrivate::setSize(Qt::SizeHint which, const QSizeF &size)
     if (userSizeHints) {
         if (size == userSizeHints[which])
             return;
-    } else if (!size.isValid()) {
+    } else if (size.width() < 0 && size.height() < 0) {
         return;
     }
 
diff --git a/src/gui/inputmethod/qcoefepinputcontext_s60.cpp b/src/gui/inputmethod/qcoefepinputcontext_s60.cpp
index b08b9a9..af86d77 100644
--- a/src/gui/inputmethod/qcoefepinputcontext_s60.cpp
+++ b/src/gui/inputmethod/qcoefepinputcontext_s60.cpp
@@ -382,6 +382,9 @@ void QCoeFepInputContext::applyHints(Qt::InputMethodHints hints)
     const bool anytextmodes = hints & (ImhUppercaseOnly | ImhLowercaseOnly | ImhEmailCharactersOnly | ImhUrlCharactersOnly);
     const bool numbersOnly = anynumbermodes && !anytextmodes;
     const bool noOnlys = !(hints & ImhExclusiveInputMask);
+    // if alphanumeric input, or if multiple incompatible number modes are selected;
+    // then make all symbols available in numeric mode too.
+    const bool needsCharMap= !numbersOnly || ((hints & ImhFormattedNumbersOnly) && (hints & ImhDialableCharactersOnly));
     TInt flags;
     Qt::InputMethodHints oldHints = hints;
 
@@ -481,9 +484,7 @@ void QCoeFepInputContext::applyHints(Qt::InputMethodHints hints)
     if (hints & ImhNoPredictiveText || hints & ImhHiddenText) {
         flags |= EAknEditorFlagNoT9;
     }
-    // if alphanumeric input, or if multiple incompatible number modes are selected;
-    // then make all symbols available in numeric mode too.
-    if (!numbersOnly || ((hints & ImhFormattedNumbersOnly) && (hints & ImhDialableCharactersOnly)))
+    if (needsCharMap)
         flags |= EAknEditorFlagUseSCTNumericCharmap;
     m_fepState->SetFlags(flags);
     ReportAknEdStateEvent(MAknEdStateObserver::EAknEdwinStateFlagsUpdate);
@@ -508,8 +509,10 @@ void QCoeFepInputContext::applyHints(Qt::InputMethodHints hints)
         m_fepState->SetSpecialCharacterTableResourceId(R_AVKON_URL_SPECIAL_CHARACTER_TABLE_DIALOG);
     } else if (hints & ImhEmailCharactersOnly) {
         m_fepState->SetSpecialCharacterTableResourceId(R_AVKON_EMAIL_ADDR_SPECIAL_CHARACTER_TABLE_DIALOG);
-    } else {
+    } else if (needsCharMap) {
         m_fepState->SetSpecialCharacterTableResourceId(R_AVKON_SPECIAL_CHARACTER_TABLE_DIALOG);
+    } else {
+        m_fepState->SetSpecialCharacterTableResourceId(0);
     }
 
     if (hints & ImhHiddenText) {
diff --git a/src/gui/kernel/qapplication.cpp b/src/gui/kernel/qapplication.cpp
index 82dd83a..e99f6ca 100644
--- a/src/gui/kernel/qapplication.cpp
+++ b/src/gui/kernel/qapplication.cpp
@@ -94,6 +94,10 @@
 
 #include <stdlib.h>
 
+#if defined(Q_WS_X11) && !defined(QT_NO_EGL)
+#include <link.h>
+#endif
+
 #include "qapplication_p.h"
 #include "qevent_p.h"
 #include "qwidget_p.h"
@@ -768,6 +772,13 @@ QApplication::QApplication(int &argc, char **argv, Type type , int _internal)
     : QCoreApplication(*new QApplicationPrivate(argc, argv, type))
 { Q_D(QApplication); d->construct();  QApplicationPrivate::app_compile_version = _internal;}
 
+#if defined(Q_WS_X11) && !defined(QT_NO_EGL)
+static int qt_matchLibraryName(dl_phdr_info *info, size_t, void *data)
+{
+    const char *name = static_cast<const char *>(data);
+    return strstr(info->dlpi_name, name) != 0;
+}
+#endif
 
 /*!
     \internal
@@ -785,6 +796,19 @@ void QApplicationPrivate::construct(
     // the environment variable has the lowest precedence of runtime graphicssystem switches
     if (graphics_system_name.isEmpty())
         graphics_system_name = QString::fromLocal8Bit(qgetenv("QT_GRAPHICSSYSTEM"));
+
+#if defined(Q_WS_X11) && !defined(QT_NO_EGL)
+    if (graphics_system_name.isEmpty()) {
+        bool linksWithMeeGoTouch = dl_iterate_phdr(qt_matchLibraryName, const_cast<char *>("libmeegotouchcore"));
+        bool linksWithMeeGoGraphicsSystemHelper = dl_iterate_phdr(qt_matchLibraryName, const_cast<char *>("libQtMeeGoGraphicsSystemHelper"));
+
+        if (linksWithMeeGoTouch && !linksWithMeeGoGraphicsSystemHelper) {
+            qWarning("Running non-meego graphics system enabled  MeeGo touch, forcing native graphicssystem\n");
+            graphics_system_name = QLatin1String("native");
+        }
+    }
+#endif
+
     // Must be called before initialize()
     qt_init(this, qt_appType
 #ifdef Q_WS_X11
diff --git a/src/gui/painting/qgraphicssystem_runtime_p.h b/src/gui/painting/qgraphicssystem_runtime_p.h
index 0232241..421fbeb 100644
--- a/src/gui/painting/qgraphicssystem_runtime_p.h
+++ b/src/gui/painting/qgraphicssystem_runtime_p.h
@@ -177,6 +177,7 @@ private:
 
     friend class QRuntimePixmapData;
     friend class QRuntimeWindowSurface;
+    friend class QMeeGoGraphicsSystem;
 };
 
 QT_END_NAMESPACE
diff --git a/src/gui/text/qfontengine_win.cpp b/src/gui/text/qfontengine_win.cpp
index 82de0d5..ef1b504 100644
--- a/src/gui/text/qfontengine_win.cpp
+++ b/src/gui/text/qfontengine_win.cpp
@@ -1296,6 +1296,7 @@ QFontEngineMultiWin::QFontEngineMultiWin(QFontEngineWin *first, const QStringLis
     engines[0] = first;
     first->ref.ref();
     fontDef = engines[0]->fontDef;
+    cache_cost = first->cache_cost;
 }
 
 void QFontEngineMultiWin::loadEngine(int at)
@@ -1317,6 +1318,8 @@ void QFontEngineMultiWin::loadEngine(int at)
     engines[at] = new QFontEngineWin(fam, hfont, stockFont, lf);
     engines[at]->ref.ref();
     engines[at]->fontDef = fontDef;
+
+    // TODO: increase cost in QFontCache for the font engine loaded here
 }
 
 QT_END_NAMESPACE
diff --git a/src/gui/text/qstatictext.cpp b/src/gui/text/qstatictext.cpp
index b950b13..7a5dec4 100644
--- a/src/gui/text/qstatictext.cpp
+++ b/src/gui/text/qstatictext.cpp
@@ -448,7 +448,6 @@ namespace {
             currentItem.font = ti.font();
             currentItem.charOffset = m_chars.size();
             currentItem.numChars = ti.num_chars;
-            currentItem.numGlyphs = ti.glyphs.numGlyphs;
             currentItem.glyphOffset = m_glyphs.size(); // Store offset into glyph pool
             currentItem.positionOffset = m_glyphs.size(); // Offset into position pool
             currentItem.useBackendOptimizations = m_useBackendOptimizations;
@@ -463,8 +462,8 @@ namespace {
             ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
 
             int size = glyphs.size();
-            Q_ASSERT(size == ti.glyphs.numGlyphs);
             Q_ASSERT(size == positions.size());
+            currentItem.numGlyphs = size;
 
             m_glyphs.resize(m_glyphs.size() + size);
             m_positions.resize(m_glyphs.size());
diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
index 18192e3..aa217f6 100644
--- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
+++ b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
@@ -591,6 +591,12 @@ void QGL2PaintEngineEx::endNativePainting()
     d->nativePaintingActive = false;
 }
 
+void QGL2PaintEngineEx::invalidateState()
+{
+    Q_D(QGL2PaintEngineEx);
+    d->needsSync = true;
+}
+
 bool QGL2PaintEngineEx::isNativePaintingActive() const {
     Q_D(const QGL2PaintEngineEx);
     return d->nativePaintingActive;
diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h b/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h
index 59b90d8..b255e75 100644
--- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h
+++ b/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h
@@ -151,6 +151,8 @@ public:
     void beginNativePainting();
     void endNativePainting();
 
+    void invalidateState();
+
     QPixmapFilter *pixmapFilter(int type, const QPixmapFilter *prototype);
 
     void setRenderTextActive(bool);
diff --git a/src/opengl/qpixmapdata_gl.cpp b/src/opengl/qpixmapdata_gl.cpp
index 1efd398..89000bb 100644
--- a/src/opengl/qpixmapdata_gl.cpp
+++ b/src/opengl/qpixmapdata_gl.cpp
@@ -472,13 +472,42 @@ bool QGLPixmapData::scroll(int dx, int dy, const QRect &rect)
 
 void QGLPixmapData::copy(const QPixmapData *data, const QRect &rect)
 {
-    if (data->classId() != QPixmapData::OpenGLClass) {
+    if (data->classId() != QPixmapData::OpenGLClass || !static_cast<const QGLPixmapData *>(data)->useFramebufferObjects()) {
         QPixmapData::copy(data, rect);
         return;
     }
 
-    // can be optimized to do a framebuffer blit or similar ...
-    QPixmapData::copy(data, rect);
+    const QGLPixmapData *other = static_cast<const QGLPixmapData *>(data);
+    if (other->m_renderFbo) {
+        QGLShareContextScope ctx(qt_gl_share_widget()->context());
+
+        resize(rect.width(), rect.height());
+        m_hasAlpha = other->m_hasAlpha;
+        ensureCreated();
+
+        if (!ctx->d_ptr->fbo)
+            glGenFramebuffers(1, &ctx->d_ptr->fbo);
+
+        glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, ctx->d_ptr->fbo);
+        glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
+                GL_TEXTURE_2D, m_texture.id, 0);
+
+        if (!other->m_renderFbo->isBound())
+            glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, other->m_renderFbo->handle());
+
+        glDisable(GL_SCISSOR_TEST);
+        if (ctx->d_ptr->active_engine && ctx->d_ptr->active_engine->type() == QPaintEngine::OpenGL2)
+            static_cast<QGL2PaintEngineEx *>(ctx->d_ptr->active_engine)->invalidateState();
+
+        glBlitFramebufferEXT(rect.x(), rect.y(), rect.x() + rect.width(), rect.y() + rect.height(),
+                0, 0, w, h,
+                GL_COLOR_BUFFER_BIT,
+                GL_NEAREST);
+
+        glBindFramebuffer(GL_FRAMEBUFFER_EXT, ctx->d_ptr->current_fbo);
+    } else {
+        QPixmapData::copy(data, rect);
+    }
 }
 
 void QGLPixmapData::fill(const QColor &color)
@@ -623,11 +652,12 @@ void QGLPixmapData::copyBackFromRenderFbo(bool keepCurrentFboBound) const
     }
 }
 
-bool QGLPixmapData::useFramebufferObjects()
+bool QGLPixmapData::useFramebufferObjects() const
 {
     return QGLFramebufferObject::hasOpenGLFramebufferObjects()
            && QGLFramebufferObject::hasOpenGLFramebufferBlit()
-           && qt_gl_preferGL2Engine();
+           && qt_gl_preferGL2Engine()
+           && (w * h > 32*32); // avoid overhead of FBOs for small pixmaps
 }
 
 QPaintEngine* QGLPixmapData::paintEngine() const
diff --git a/src/opengl/qpixmapdata_gl_p.h b/src/opengl/qpixmapdata_gl_p.h
index 736a28e..f000993 100644
--- a/src/opengl/qpixmapdata_gl_p.h
+++ b/src/opengl/qpixmapdata_gl_p.h
@@ -145,7 +145,7 @@ private:
     void copyBackFromRenderFbo(bool keepCurrentFboBound) const;
     QSize size() const { return QSize(w, h); }
 
-    static bool useFramebufferObjects();
+    bool useFramebufferObjects() const;
 
     QImage fillImage(const QColor &color) const;
 
@@ -168,6 +168,7 @@ private:
     mutable QGLPixmapGLPaintDevice m_glDevice;
 
     friend class QGLPixmapGLPaintDevice;
+    friend class QMeeGoPixmapData;
 };
 
 QT_END_NAMESPACE
diff --git a/src/opengl/qwindowsurface_gl.cpp b/src/opengl/qwindowsurface_gl.cpp
index d602000..f98dcff 100644
--- a/src/opengl/qwindowsurface_gl.cpp
+++ b/src/opengl/qwindowsurface_gl.cpp
@@ -190,7 +190,10 @@ public:
     QGLWidget *shareWidget() {
         if (!initializing && !widget && !cleanedUp) {
             initializing = true;
-            widget = new QGLWidget;
+
+            widget = new QGLWidget(QGLFormat(QGL::SingleBuffer | QGL::NoDepthBuffer | QGL::NoStencilBuffer));
+            widget->resize(1, 1);
+
             // We dont need this internal widget to appear in QApplication::topLevelWidgets()
             if (QWidgetPrivate::allWidgets)
                 QWidgetPrivate::allWidgets->remove(widget);
@@ -342,12 +345,14 @@ QGLWindowSurface::~QGLWindowSurface()
 
 void QGLWindowSurface::deleted(QObject *object)
 {
-    // Make sure that the fbo is destroyed before destroying its context.
-    delete d_ptr->fbo;
-    d_ptr->fbo = 0;
-
     QWidget *widget = qobject_cast<QWidget *>(object);
     if (widget) {
+        if (widget == window()) {
+            // Make sure that the fbo is destroyed before destroying its context.
+            delete d_ptr->fbo;
+            d_ptr->fbo = 0;
+        }
+
         QWidgetPrivate *widgetPrivate = widget->d_func();
         if (widgetPrivate->extraData()) {
             union { QGLContext **ctxPtr; void **voidPtr; };
@@ -419,6 +424,8 @@ QPaintDevice *QGLWindowSurface::paintDevice()
 
     QGLContext *ctx = reinterpret_cast<QGLContext *>(window()->d_func()->extraData()->glContext);
     ctx->makeCurrent();
+
+    Q_ASSERT(d_ptr->fbo);
     return d_ptr->fbo;
 }
 
@@ -574,7 +581,9 @@ void QGLWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &
         const int ty1 = parent->height() - rect.top();
 
         if (window() == parent || d_ptr->fbo->format().samples() <= 1) {
-            // glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, 0);
+            if (ctx->d_ptr->current_fbo != 0)
+                glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, 0);
+
             glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, d_ptr->fbo->handle());
 
             glBlitFramebufferEXT(sx0, sy0, sx1, sy1,
@@ -607,6 +616,8 @@ void QGLWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &
 
             qgl_fbo_pool()->release(temp);
         }
+
+        ctx->d_ptr->current_fbo = 0;
     }
 #if !defined(QT_OPENGL_ES_2)
     else {
diff --git a/src/plugins/graphicssystems/graphicssystems.pro b/src/plugins/graphicssystems/graphicssystems.pro
index 0788933..29a1f34 100644
--- a/src/plugins/graphicssystems/graphicssystems.pro
+++ b/src/plugins/graphicssystems/graphicssystems.pro
@@ -7,3 +7,7 @@ contains(QT_CONFIG, shivavg) {
     # Only works under X11 at present
     !win32:!embedded:!mac:SUBDIRS += shivavg
 }
+
+!win32:!embedded:!mac:!symbian:CONFIG += x11
+
+x11:contains(QT_CONFIG, opengles2):contains(QT_CONFIG, egl):SUBDIRS += meego
diff --git a/src/plugins/graphicssystems/meego/meego.pro b/src/plugins/graphicssystems/meego/meego.pro
new file mode 100644
index 0000000..d750d34
--- /dev/null
+++ b/src/plugins/graphicssystems/meego/meego.pro
@@ -0,0 +1,13 @@
+TARGET = qmeegographicssystem
+include(../../qpluginbase.pri)
+
+QT += gui opengl
+
+QTDIR_build:DESTDIR = $$QT_BUILD_TREE/plugins/graphicssystems
+
+HEADERS = qmeegographicssystem.h qmeegopixmapdata.h qmeegoextensions.h
+SOURCES = qmeegographicssystem.cpp qmeegographicssystem.h qmeegographicssystemplugin.h qmeegographicssystemplugin.cpp qmeegopixmapdata.h qmeegopixmapdata.cpp qmeegoextensions.h qmeegoextensions.cpp
+
+target.path += $$[QT_INSTALL_PLUGINS]/graphicssystems
+INSTALLS += target
+
diff --git a/src/plugins/graphicssystems/meego/qmeegoextensions.cpp b/src/plugins/graphicssystems/meego/qmeegoextensions.cpp
new file mode 100644
index 0000000..e7f6439
--- /dev/null
+++ b/src/plugins/graphicssystems/meego/qmeegoextensions.cpp
@@ -0,0 +1,129 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "qmeegoextensions.h"
+#include <private/qeglcontext_p.h>
+#include <private/qpixmapdata_gl_p.h>
+
+bool QMeeGoExtensions::initialized = false;
+bool QMeeGoExtensions::hasImageShared = false;
+bool QMeeGoExtensions::hasSurfaceScaling = false;
+
+/* Extension funcs */
+
+typedef EGLBoolean (EGLAPIENTRY *eglQueryImageNOKFunc)(EGLDisplay, EGLImageKHR, EGLint, EGLint*);
+typedef EGLNativeSharedImageTypeNOK (EGLAPIENTRY *eglCreateSharedImageNOKFunc)(EGLDisplay, EGLImageKHR, EGLint*);
+typedef EGLBoolean (EGLAPIENTRY *eglDestroySharedImageNOKFunc)(EGLDisplay, EGLNativeSharedImageTypeNOK);
+typedef EGLBoolean (EGLAPIENTRY *eglSetSurfaceScalingNOKFunc)(EGLDisplay, EGLSurface, EGLint, EGLint, EGLint, EGLint);
+
+static eglQueryImageNOKFunc _eglQueryImageNOK = 0;
+static eglCreateSharedImageNOKFunc _eglCreateSharedImageNOK = 0;
+static eglDestroySharedImageNOKFunc _eglDestroySharedImageNOK = 0;
+static eglSetSurfaceScalingNOKFunc _eglSetSurfaceScalingNOK = 0;
+
+/* Public */
+
+void QMeeGoExtensions::ensureInitialized()
+{
+    if (!initialized)
+        initialize();
+
+    initialized = true;
+}
+
+EGLNativeSharedImageTypeNOK QMeeGoExtensions::eglCreateSharedImageNOK(EGLDisplay dpy, EGLImageKHR image, EGLint *props)
+{
+    if (! hasImageShared)
+        qFatal("EGL_NOK_image_shared not found but trying to use capability!");
+        
+    return _eglCreateSharedImageNOK(dpy, image, props);
+}
+
+bool QMeeGoExtensions::eglQueryImageNOK(EGLDisplay dpy, EGLImageKHR image, EGLint prop, EGLint *v)
+{
+    if (! hasImageShared)
+        qFatal("EGL_NOK_image_shared not found but trying to use capability!");
+
+    return _eglQueryImageNOK(dpy, image, prop, v);
+}
+
+bool QMeeGoExtensions::eglDestroySharedImageNOK(EGLDisplay dpy, EGLNativeSharedImageTypeNOK img)
+{
+    if (! hasImageShared)
+        qFatal("EGL_NOK_image_shared not found but trying to use capability!");
+
+    return _eglDestroySharedImageNOK(dpy, img);
+}
+
+bool QMeeGoExtensions::eglSetSurfaceScalingNOK(EGLDisplay dpy, EGLSurface surface, int x, int y, int width, int height)
+{
+    if (! hasSurfaceScaling)
+        qFatal("EGL_NOK_surface_scaling not found but trying to use capability!");
+
+   return _eglSetSurfaceScalingNOK(dpy, surface, x, y, width, height);
+}
+
+/* Private */
+
+void QMeeGoExtensions::initialize()
+{
+    QGLContext *ctx = (QGLContext *) QGLContext::currentContext();
+    qt_resolve_eglimage_gl_extensions(ctx);
+    
+    if (QEgl::hasExtension("EGL_NOK_image_shared")) {
+        qDebug("MeegoGraphics: found EGL_NOK_image_shared");
+        _eglQueryImageNOK = (eglQueryImageNOKFunc) eglGetProcAddress("eglQueryImageNOK");
+        _eglCreateSharedImageNOK = (eglCreateSharedImageNOKFunc) eglGetProcAddress("eglCreateSharedImageNOK");
+        _eglDestroySharedImageNOK = (eglDestroySharedImageNOKFunc) eglGetProcAddress("eglDestroySharedImageNOK");
+        
+        Q_ASSERT(_eglQueryImageNOK && _eglCreateSharedImageNOK && _eglDestroySharedImageNOK);
+        hasImageShared = true;
+    }
+    
+    if (QEgl::hasExtension("EGL_NOK_surface_scaling")) {
+        qDebug("MeegoGraphics: found EGL_NOK_surface_scaling");
+        _eglSetSurfaceScalingNOK = (eglSetSurfaceScalingNOKFunc) eglGetProcAddress("eglSetSurfaceScalingNOK");
+        
+        Q_ASSERT(_eglSetSurfaceScalingNOK);
+        hasSurfaceScaling = true;
+    }
+}
+
diff --git a/src/plugins/graphicssystems/meego/qmeegoextensions.h b/src/plugins/graphicssystems/meego/qmeegoextensions.h
new file mode 100644
index 0000000..7f219de
--- /dev/null
+++ b/src/plugins/graphicssystems/meego/qmeegoextensions.h
@@ -0,0 +1,89 @@
+/****************************************************************************
+**
+** 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 MEXTENSIONS_H
+#define MEXTENSIONS_H
+
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+#include <private/qgl_p.h>
+#include <private/qeglcontext_p.h>
+#include <private/qpixmapdata_gl_p.h>
+
+/* Extensions decls */
+
+#ifndef EGL_SHARED_IMAGE_NOK
+#define EGL_SHARED_IMAGE_NOK 0x30DA
+typedef void* EGLNativeSharedImageTypeNOK;
+#endif
+
+#ifndef EGL_GL_TEXTURE_2D_KHR
+#define EGL_GL_TEXTURE_2D_KHR 0x30B1
+#endif
+
+#ifndef EGL_FIXED_WIDTH_NOK
+#define EGL_FIXED_WIDTH_NOK 0x30DB
+#define EGL_FIXED_HEIGHT_NOK 0x30DC
+#endif
+
+/* Class */
+
+class QMeeGoExtensions
+{
+public:
+    static void ensureInitialized();
+
+    static EGLNativeSharedImageTypeNOK eglCreateSharedImageNOK(EGLDisplay dpy, EGLImageKHR image, EGLint *props);
+    static bool eglQueryImageNOK(EGLDisplay dpy, EGLImageKHR image, EGLint prop, EGLint *v);
+    static bool eglDestroySharedImageNOK(EGLDisplay dpy, EGLNativeSharedImageTypeNOK img);
+    static bool eglSetSurfaceScalingNOK(EGLDisplay dpy, EGLSurface surface, int x, int y, int width, int height);
+
+private:
+    static void initialize();
+
+    static bool initialized;
+    static bool hasImageShared;
+    static bool hasSurfaceScaling;
+};
+
+#endif
diff --git a/src/plugins/graphicssystems/meego/qmeegographicssystem.cpp b/src/plugins/graphicssystems/meego/qmeegographicssystem.cpp
new file mode 100644
index 0000000..e2c8425
--- /dev/null
+++ b/src/plugins/graphicssystems/meego/qmeegographicssystem.cpp
@@ -0,0 +1,248 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include <QDebug>
+#include <private/qpixmap_raster_p.h>
+#include <private/qwindowsurface_gl_p.h>
+#include <private/qegl_p.h>
+#include <private/qglextensions_p.h>
+#include <private/qgl_p.h>
+#include <private/qimagepixmapcleanuphooks_p.h>
+#include <private/qapplication_p.h>
+#include <private/qgraphicssystem_runtime_p.h>
+#include <private/qimage_p.h>
+#include <private/qeglproperties_p.h>
+#include <private/qeglcontext_p.h>
+
+#include "qmeegopixmapdata.h"
+#include "qmeegographicssystem.h"
+#include "qmeegoextensions.h"
+
+bool QMeeGoGraphicsSystem::surfaceWasCreated = false;
+
+QMeeGoGraphicsSystem::QMeeGoGraphicsSystem()
+{
+    qDebug("Using the meego graphics system");
+}
+
+QMeeGoGraphicsSystem::~QMeeGoGraphicsSystem()
+{
+    qDebug("Meego graphics system destroyed");
+    qt_destroy_gl_share_widget();
+}
+
+QWindowSurface* QMeeGoGraphicsSystem::createWindowSurface(QWidget *widget) const
+{
+    QMeeGoGraphicsSystem::surfaceWasCreated = true;
+    QWindowSurface *surface = new QGLWindowSurface(widget);
+    surface->window()->setAttribute(Qt::WA_NoSystemBackground);
+    return surface;
+}
+
+QPixmapData *QMeeGoGraphicsSystem::createPixmapData(QPixmapData::PixelType type) const
+{
+    // Long story short: without this it's possible to hit an 
+    // unitialized paintDevice due to a Qt bug too complex to even 
+    // explain here... not to mention fix without going crazy. 
+    // MDK
+    QGLShareContextScope ctx(qt_gl_share_widget()->context());
+ 
+    return new QRasterPixmapData(type);
+}
+
+QPixmapData *QMeeGoGraphicsSystem::createPixmapData(QPixmapData *origin)
+{
+    // If the pixmap is a raster type...
+    // and if the pixmap pointer matches our mapping...
+    // create a shared image instead with the given handle.
+
+    if (origin->classId() == QPixmapData::RasterClass) {
+        QRasterPixmapData *rasterClass = static_cast <QRasterPixmapData *> (origin);
+        void *rawResource = static_cast <void *> (rasterClass->buffer()->data_ptr()->data);
+
+        if (QMeeGoPixmapData::sharedImagesMap.contains(rawResource))
+            return new QMeeGoPixmapData();
+    } 
+        
+    return new QRasterPixmapData(origin->pixelType());
+}
+
+QPixmapData* QMeeGoGraphicsSystem::wrapPixmapData(QPixmapData *pmd)
+{
+    QString name = QApplicationPrivate::instance()->graphics_system_name;
+    if (name == "runtime") {
+        QRuntimeGraphicsSystem *rsystem = (QRuntimeGraphicsSystem *) QApplicationPrivate::instance()->graphics_system;
+        QRuntimePixmapData *rt = new QRuntimePixmapData(rsystem, pmd->pixelType());;
+        rt->m_data = pmd;
+        rt->readBackInfo();
+        rsystem->m_pixmapDatas << rt;
+        return rt;
+    } else
+        return pmd;
+}
+
+void QMeeGoGraphicsSystem::setSurfaceFixedSize(int /*width*/, int /*height*/)
+{
+    if (QMeeGoGraphicsSystem::surfaceWasCreated)
+        qWarning("Trying to set surface fixed size but surface already created!");
+
+#ifdef QT_WAS_PATCHED
+    QEglProperties *properties = new QEglProperties();
+    properties->setValue(EGL_FIXED_WIDTH_NOK, width);
+    properties->setValue(EGL_FIXED_HEIGHT_NOK, height);
+    QGLContextPrivate::setExtraWindowSurfaceCreationProps(properties);
+#endif
+}
+
+void QMeeGoGraphicsSystem::setSurfaceScaling(int x, int y, int width, int height)
+{
+    QMeeGoExtensions::ensureInitialized();
+    QMeeGoExtensions::eglSetSurfaceScalingNOK(QEgl::display(), QEglContext::currentContext(QEgl::OpenGL)->currentSurface, x, y, width, height);
+}
+
+void QMeeGoGraphicsSystem::setTranslucent(bool translucent)
+{
+    QGLWindowSurface::surfaceFormat.setSampleBuffers(false);
+    QGLWindowSurface::surfaceFormat.setSamples(0);
+    QGLWindowSurface::surfaceFormat.setAlpha(translucent);
+}
+
+QPixmapData *QMeeGoGraphicsSystem::pixmapDataFromEGLSharedImage(Qt::HANDLE handle, const QImage &softImage)
+{
+    if (softImage.format() != QImage::Format_ARGB32_Premultiplied &&
+        softImage.format() != QImage::Format_ARGB32) {
+        qFatal("For egl shared images, the soft image has to be ARGB32 or ARGB32_Premultiplied");
+        return NULL;
+    }
+    
+    if (QMeeGoGraphicsSystem::meeGoRunning()) {
+        QMeeGoPixmapData *pmd = new QMeeGoPixmapData;
+        pmd->fromEGLSharedImage(handle, softImage);
+        return QMeeGoGraphicsSystem::wrapPixmapData(pmd);
+    } else {
+        QRasterPixmapData *pmd = new QRasterPixmapData(QPixmapData::PixmapType);
+        pmd->fromImage(softImage, Qt::NoOpaqueDetection);
+
+        // Make sure that the image was not converted in any way
+        if (pmd->buffer()->data_ptr()->data !=
+            const_cast<QImage &>(softImage).data_ptr()->data)
+            qFatal("Iternal misalignment of raster data detected. Prolly a QImage copy fail.");
+
+        QMeeGoPixmapData::registerSharedImage(handle, softImage);
+        return QMeeGoGraphicsSystem::wrapPixmapData(pmd);
+    }
+}
+
+void QMeeGoGraphicsSystem::updateEGLSharedImagePixmap(QPixmap *pixmap)
+{
+    QMeeGoPixmapData *pmd = (QMeeGoPixmapData *) pixmap->pixmapData();
+    
+    // Basic sanity check to make sure this is really a QMeeGoPixmapData...
+    if (pmd->classId() != QPixmapData::OpenGLClass) 
+        qFatal("Trying to updated EGLSharedImage pixmap but it's not really a shared image pixmap!");
+
+    pmd->updateFromSoftImage();
+}
+
+QPixmapData *QMeeGoGraphicsSystem::pixmapDataWithGLTexture(int w, int h)
+{
+    QGLPixmapData *pmd = new QGLPixmapData(QPixmapData::PixmapType);
+    pmd->resize(w, h);
+    return QMeeGoGraphicsSystem::wrapPixmapData(pmd);
+}
+
+bool QMeeGoGraphicsSystem::meeGoRunning()
+{
+    if (! QApplicationPrivate::instance()) {
+        qWarning("Application not running just yet... hard to know what system running!");
+        return false;
+    }
+
+    QString name = QApplicationPrivate::instance()->graphics_system_name;
+    if (name == "runtime") {
+        QRuntimeGraphicsSystem *rsystem = (QRuntimeGraphicsSystem *) QApplicationPrivate::instance()->graphics_system;
+        name = rsystem->graphicsSystemName();
+    }
+
+    return (name == "meego");
+}
+
+/* C API */
+
+int qt_meego_image_to_egl_shared_image(const QImage &image)
+{
+    return QMeeGoPixmapData::imageToEGLSharedImage(image);
+}
+
+QPixmapData* qt_meego_pixmapdata_from_egl_shared_image(Qt::HANDLE handle, const QImage &softImage)
+{
+    return QMeeGoGraphicsSystem::pixmapDataFromEGLSharedImage(handle, softImage);
+}
+
+QPixmapData* qt_meego_pixmapdata_with_gl_texture(int w, int h)
+{
+    return QMeeGoGraphicsSystem::pixmapDataWithGLTexture(w, h);
+}
+
+bool qt_meego_destroy_egl_shared_image(Qt::HANDLE handle)
+{
+    return QMeeGoPixmapData::destroyEGLSharedImage(handle);
+}
+
+void qt_meego_set_surface_fixed_size(int width, int height)
+{
+    QMeeGoGraphicsSystem::setSurfaceFixedSize(width, height);
+}
+
+void qt_meego_set_surface_scaling(int x, int y, int width, int height)
+{
+    QMeeGoGraphicsSystem::setSurfaceScaling(x, y, width, height);
+}
+
+void qt_meego_set_translucent(bool translucent)
+{
+    QMeeGoGraphicsSystem::setTranslucent(translucent);
+}
+
+void qt_meego_update_egl_shared_image_pixmap(QPixmap *pixmap)
+{
+    QMeeGoGraphicsSystem::updateEGLSharedImagePixmap(pixmap);
+}
diff --git a/src/plugins/graphicssystems/meego/qmeegographicssystem.h b/src/plugins/graphicssystems/meego/qmeegographicssystem.h
new file mode 100644
index 0000000..905f0c3
--- /dev/null
+++ b/src/plugins/graphicssystems/meego/qmeegographicssystem.h
@@ -0,0 +1,85 @@
+/****************************************************************************
+**
+** 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 MGRAPHICSSYSTEM_H
+#define MGRAPHICSSYSTEM_H
+
+#include <private/qgraphicssystem_p.h>
+
+class QMeeGoGraphicsSystem : public QGraphicsSystem
+{
+public:
+    QMeeGoGraphicsSystem();
+    ~QMeeGoGraphicsSystem();
+
+    virtual QWindowSurface *createWindowSurface(QWidget *widget) const;
+    virtual QPixmapData *createPixmapData(QPixmapData::PixelType) const;
+    virtual QPixmapData *createPixmapData(QPixmapData *origin);
+
+    static QPixmapData *wrapPixmapData(QPixmapData *pmd);
+    static void setSurfaceFixedSize(int width, int height);
+    static void setSurfaceScaling(int x, int y, int width, int height);
+    static void setTranslucent(bool translucent);
+
+    static QPixmapData *pixmapDataFromEGLSharedImage(Qt::HANDLE handle, const QImage &softImage);
+    static QPixmapData *pixmapDataWithGLTexture(int w, int h);
+    static void updateEGLSharedImagePixmap(QPixmap *pixmap);
+
+private:
+    static bool meeGoRunning();
+
+    static bool surfaceWasCreated;
+};
+
+/* C api */
+
+extern "C" {
+    Q_DECL_EXPORT int qt_meego_image_to_egl_shared_image(const QImage &image);
+    Q_DECL_EXPORT QPixmapData* qt_meego_pixmapdata_from_egl_shared_image(Qt::HANDLE handle, const QImage &softImage);
+    Q_DECL_EXPORT QPixmapData* qt_meego_pixmapdata_with_gl_texture(int w, int h);
+    Q_DECL_EXPORT void qt_meego_update_egl_shared_image_pixmap(QPixmap *pixmap);
+    Q_DECL_EXPORT bool qt_meego_destroy_egl_shared_image(Qt::HANDLE handle);
+    Q_DECL_EXPORT void qt_meego_set_surface_fixed_size(int width, int height);
+    Q_DECL_EXPORT void qt_meego_set_surface_scaling(int x, int y, int width, int height);
+    Q_DECL_EXPORT void qt_meego_set_translucent(bool translucent);
+}
+
+#endif 
diff --git a/src/plugins/graphicssystems/meego/qmeegographicssystemplugin.cpp b/src/plugins/graphicssystems/meego/qmeegographicssystemplugin.cpp
new file mode 100644
index 0000000..7c142eb
--- /dev/null
+++ b/src/plugins/graphicssystems/meego/qmeegographicssystemplugin.cpp
@@ -0,0 +1,58 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include <QDebug>
+#include "qmeegographicssystemplugin.h"
+#include "qmeegographicssystem.h"
+
+QStringList QMeeGoGraphicsSystemPlugin::keys() const
+{
+    QStringList list;
+    list << "meego";
+    return list;
+}
+
+QGraphicsSystem *QMeeGoGraphicsSystemPlugin::create(const QString&)
+{
+    return new QMeeGoGraphicsSystem;
+}
+
+Q_EXPORT_PLUGIN2(meego, QMeeGoGraphicsSystemPlugin)
diff --git a/src/plugins/graphicssystems/meego/qmeegographicssystemplugin.h b/src/plugins/graphicssystems/meego/qmeegographicssystemplugin.h
new file mode 100644
index 0000000..336458f
--- /dev/null
+++ b/src/plugins/graphicssystems/meego/qmeegographicssystemplugin.h
@@ -0,0 +1,54 @@
+/****************************************************************************
+**
+** 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 MGRAPHICSSYSTEMPLUGIN_H
+#define MGRAPHICSSYSTEMPLUGIN_H
+
+#include <private/qgraphicssystemplugin_p.h>
+
+class QMeeGoGraphicsSystemPlugin : public QGraphicsSystemPlugin
+{
+public:
+    virtual QStringList keys() const;
+    virtual QGraphicsSystem *create(const QString&);
+};
+
+#endif
diff --git a/src/plugins/graphicssystems/meego/qmeegopixmapdata.cpp b/src/plugins/graphicssystems/meego/qmeegopixmapdata.cpp
new file mode 100644
index 0000000..33611dc
--- /dev/null
+++ b/src/plugins/graphicssystems/meego/qmeegopixmapdata.cpp
@@ -0,0 +1,206 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "qmeegopixmapdata.h"
+#include "qmeegoextensions.h"
+#include <private/qimage_p.h>
+#include <private/qwindowsurface_gl_p.h>
+#include <private/qeglcontext_p.h>
+#include <private/qapplication_p.h>
+#include <private/qgraphicssystem_runtime_p.h>
+
+static EGLint preserved_image_attribs[] = { EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE };
+
+QHash <void*, QMeeGoImageInfo*> QMeeGoPixmapData::sharedImagesMap;
+
+/* Public */
+
+QMeeGoPixmapData::QMeeGoPixmapData() : QGLPixmapData(QPixmapData::PixmapType)
+{
+}
+
+void QMeeGoPixmapData::fromTexture(GLuint textureId, int w, int h, bool alpha)
+{
+    resize(w, h); 
+    texture()->id = textureId;
+    m_hasAlpha = alpha;
+    softImage = QImage();
+}
+
+QImage QMeeGoPixmapData::toImage() const
+{
+    return softImage;
+}
+
+void QMeeGoPixmapData::fromImage(const QImage &image,
+                                 Qt::ImageConversionFlags flags)
+{
+    void *rawResource = static_cast <void *> (((QImage &) image).data_ptr()->data);
+
+    if (sharedImagesMap.contains(rawResource)) {
+        QMeeGoImageInfo *info = sharedImagesMap.value(rawResource);
+        fromEGLSharedImage(info->handle, image);
+    } else {
+        // This should *never* happen since the graphics system should never
+        // create a QMeeGoPixmapData for an origin that doesn't contain a raster
+        // image we know about. But...
+        qWarning("QMeeGoPixmapData::fromImage called on non-know resource. Falling back...");
+        QGLPixmapData::fromImage(image, flags);
+    }
+}
+
+void QMeeGoPixmapData::fromEGLSharedImage(Qt::HANDLE handle, const QImage &si)
+{
+    if (si.isNull())
+        qFatal("Trying to build pixmap with an empty/null softimage!");
+        
+    QGLShareContextScope ctx(qt_gl_share_widget()->context());
+   
+    QMeeGoExtensions::ensureInitialized();
+ 
+    bool textureIsBound = false;
+    GLuint newTextureId;
+    GLint newWidth, newHeight;
+
+    glGenTextures(1, &newTextureId);
+    glBindTexture(GL_TEXTURE_2D, newTextureId);
+    
+    glFinish();
+    EGLImageKHR image = QEgl::eglCreateImageKHR(QEgl::display(), EGL_NO_CONTEXT, EGL_SHARED_IMAGE_NOK,
+                                                (EGLClientBuffer)handle, preserved_image_attribs);
+
+    if (image != EGL_NO_IMAGE_KHR) {
+        glFinish();
+        glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image);
+        GLint err = glGetError();
+        if (err == GL_NO_ERROR)
+            textureIsBound = true;
+        
+        QMeeGoExtensions::eglQueryImageNOK(QEgl::display(), image, EGL_WIDTH, &newWidth);
+        QMeeGoExtensions::eglQueryImageNOK(QEgl::display(), image, EGL_HEIGHT, &newHeight);
+          
+        QEgl::eglDestroyImageKHR(QEgl::display(), image);
+        glFinish();
+    }
+        
+    if (textureIsBound) {
+        // FIXME Remove this ugly hasAlphaChannel check when Qt lands the NoOpaqueCheck flag fix
+        // for QGLPixmapData.
+        fromTexture(newTextureId, newWidth, newHeight, 
+                    (si.hasAlphaChannel() && const_cast<QImage &>(si).data_ptr()->checkForAlphaPixels()));
+        softImage = si;
+        QMeeGoPixmapData::registerSharedImage(handle, softImage);
+    } else {
+        qWarning("Failed to create a texture from a shared image!");
+        glDeleteTextures(1, &newTextureId);
+    }
+}
+
+Qt::HANDLE QMeeGoPixmapData::imageToEGLSharedImage(const QImage &image)
+{
+    QGLShareContextScope ctx(qt_gl_share_widget()->context());
+
+    QMeeGoExtensions::ensureInitialized();
+
+    glFinish();
+    QGLPixmapData pixmapData(QPixmapData::PixmapType);
+    pixmapData.fromImage(image, 0);
+    GLuint textureId = pixmapData.bind();
+
+    glFinish();
+    EGLImageKHR eglimage = QEgl::eglCreateImageKHR(QEgl::display(), QEglContext::currentContext(QEgl::OpenGL)->context(),
+                                                                                                EGL_GL_TEXTURE_2D_KHR,
+                                                                                                (EGLClientBuffer) textureId,
+                                                                                                preserved_image_attribs);
+    glFinish();
+
+    if (eglimage) {
+        EGLNativeSharedImageTypeNOK handle = QMeeGoExtensions::eglCreateSharedImageNOK(QEgl::display(), eglimage, NULL);
+        QEgl::eglDestroyImageKHR(QEgl::display(), eglimage);
+        glFinish();
+        return (Qt::HANDLE) handle;
+    } else {
+        qWarning("Failed to create shared image from pixmap/texture!");
+        return 0;
+    }
+}
+
+void QMeeGoPixmapData::updateFromSoftImage()
+{
+    m_dirty = true;
+    m_source = softImage;
+    ensureCreated();
+    
+    if (softImage.width() != w || softImage.height() != h)
+        qWarning("Ooops, looks like softImage changed dimensions since last updated! Corruption ahead?!");
+}
+
+bool QMeeGoPixmapData::destroyEGLSharedImage(Qt::HANDLE h)
+{
+    QGLShareContextScope ctx(qt_gl_share_widget()->context());   
+    QMeeGoExtensions::ensureInitialized();
+
+    QMutableHashIterator <void*, QMeeGoImageInfo*> i(sharedImagesMap);
+    while (i.hasNext()) {
+        i.next();
+        if (i.value()->handle == h)
+            i.remove();
+    }
+
+    return QMeeGoExtensions::eglDestroySharedImageNOK(QEgl::display(), (EGLNativeSharedImageTypeNOK) h);
+}
+
+void QMeeGoPixmapData::registerSharedImage(Qt::HANDLE handle, const QImage &si)
+{
+    void *raw = static_cast <void *> (((QImage) si).data_ptr()->data);
+    QMeeGoImageInfo *info;
+    
+    if (! sharedImagesMap.contains(raw)) {
+        info = new QMeeGoImageInfo;
+        info->handle = handle;
+        info->rawFormat = si.format();
+        sharedImagesMap.insert(raw, info);
+    } else {
+        info = sharedImagesMap.value(raw);
+        if (info->handle != handle || info->rawFormat != si.format())
+            qWarning("Inconsistency detected: overwriting entry in sharedImagesMap but handle/format different");
+    }
+}
diff --git a/src/plugins/graphicssystems/meego/qmeegopixmapdata.h b/src/plugins/graphicssystems/meego/qmeegopixmapdata.h
new file mode 100644
index 0000000..8af33bd
--- /dev/null
+++ b/src/plugins/graphicssystems/meego/qmeegopixmapdata.h
@@ -0,0 +1,73 @@
+/****************************************************************************
+**
+** 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 MPIXMAPDATA_H
+#define MPIXMAPDATA_H
+
+#include <private/qpixmapdata_gl_p.h>
+
+struct QMeeGoImageInfo
+{
+    Qt::HANDLE handle;
+    QImage::Format rawFormat;
+};
+
+class QMeeGoPixmapData : public QGLPixmapData
+{
+public:
+    QMeeGoPixmapData();
+    void fromTexture(GLuint textureId, int w, int h, bool alpha);
+
+    virtual void fromEGLSharedImage(Qt::HANDLE handle, const QImage &softImage);
+    virtual void fromImage (const QImage &image, Qt::ImageConversionFlags flags);
+    virtual QImage toImage() const;
+    virtual void updateFromSoftImage();
+
+    QImage softImage;
+
+    static QHash <void*, QMeeGoImageInfo*> sharedImagesMap;
+
+    static Qt::HANDLE imageToEGLSharedImage(const QImage &image);
+    static bool destroyEGLSharedImage(Qt::HANDLE h);
+    static void registerSharedImage(Qt::HANDLE handle, const QImage &si);
+};
+
+#endif
diff --git a/tests/auto/declarative/qdeclarativeimage/tst_qdeclarativeimage.cpp b/tests/auto/declarative/qdeclarativeimage/tst_qdeclarativeimage.cpp
index 8cfb487..2686127 100644
--- a/tests/auto/declarative/qdeclarativeimage/tst_qdeclarativeimage.cpp
+++ b/tests/auto/declarative/qdeclarativeimage/tst_qdeclarativeimage.cpp
@@ -52,7 +52,9 @@
 #include <private/qdeclarativeloader_p.h>
 #include <QtDeclarative/qdeclarativecontext.h>
 #include <QtDeclarative/qdeclarativeexpression.h>
+#include <QtTest/QSignalSpy>
 
+#include "../../../shared/util.h"
 #include "../shared/testhttpserver.h"
 
 #ifdef Q_OS_SYMBIAN
@@ -63,18 +65,7 @@
 #define SERVER_PORT 14451
 #define SERVER_ADDR "http://127.0.0.1:14451"
 
-#define TRY_WAIT(expr) \
-    do { \
-        for (int ii = 0; ii < 60; ++ii) { \
-            if ((expr)) break; \
-            QTest::qWait(50); \
-        } \
-        QVERIFY((expr)); \
-    } while (false)
-
-
 class tst_qdeclarativeimage : public QObject
-
 {
     Q_OBJECT
 public:
@@ -91,6 +82,7 @@ private slots:
     void svg();
     void big();
     void tiling_QTBUG_6716();
+    void noLoading();
 
 private:
     template<typename T>
@@ -173,18 +165,18 @@ void tst_qdeclarativeimage::imageSource()
         QVERIFY(obj->asynchronous() == true);
 
     if (remote || async)
-        TRY_WAIT(obj->status() == QDeclarativeImage::Loading);
+        QTRY_VERIFY(obj->status() == QDeclarativeImage::Loading);
 
     QCOMPARE(obj->source(), remote ? source : QUrl(source));
 
     if (error.isEmpty()) {
-        TRY_WAIT(obj->status() == QDeclarativeImage::Ready);
+        QTRY_VERIFY(obj->status() == QDeclarativeImage::Ready);
         QCOMPARE(obj->width(), qreal(width));
         QCOMPARE(obj->height(), qreal(height));
         QCOMPARE(obj->fillMode(), QDeclarativeImage::Stretch);
         QCOMPARE(obj->progress(), 1.0);
     } else {
-        TRY_WAIT(obj->status() == QDeclarativeImage::Error);
+        QTRY_VERIFY(obj->status() == QDeclarativeImage::Error);
     }
 
     delete obj;
@@ -355,6 +347,54 @@ void tst_qdeclarativeimage::tiling_QTBUG_6716()
     }
 }
 
+void tst_qdeclarativeimage::noLoading()
+{
+    TestHTTPServer server(SERVER_PORT);
+    QVERIFY(server.isValid());
+    server.serveDirectory(SRCDIR "/data");
+    server.addRedirect("oldcolors.png", SERVER_ADDR "/colors.png");
+
+    QString componentStr = "import Qt 4.7\nImage { source: srcImage }";
+    QDeclarativeContext *ctxt = engine.rootContext();
+    ctxt->setContextProperty("srcImage", QUrl::fromLocalFile(SRCDIR "/data/heart.png"));
+    QDeclarativeComponent component(&engine);
+    component.setData(componentStr.toLatin1(), QUrl::fromLocalFile(""));
+    QDeclarativeImage *obj = qobject_cast<QDeclarativeImage*>(component.create());
+    QVERIFY(obj != 0);
+    QVERIFY(obj->status() == QDeclarativeImage::Ready);
+
+    QSignalSpy sourceSpy(obj, SIGNAL(sourceChanged(const QUrl &)));
+    QSignalSpy progressSpy(obj, SIGNAL(progressChanged(qreal)));
+    QSignalSpy statusSpy(obj, SIGNAL(statusChanged(QDeclarativeImageBase::Status)));
+
+    // Loading local file
+    ctxt->setContextProperty("srcImage", QUrl::fromLocalFile(SRCDIR "/data/colors.png"));
+    QTRY_VERIFY(obj->status() == QDeclarativeImage::Ready);
+    QTRY_VERIFY(obj->progress() == 1.0);
+    QTRY_COMPARE(sourceSpy.count(), 1);
+    QTRY_COMPARE(progressSpy.count(), 0);
+    QTRY_COMPARE(statusSpy.count(), 0);
+
+    // Loading remote file
+    ctxt->setContextProperty("srcImage", QString(SERVER_ADDR) + "/oldcolors.png");
+    QTRY_VERIFY(obj->status() == QDeclarativeImage::Loading);
+    QTRY_VERIFY(obj->progress() == 0.0);
+    QTRY_VERIFY(obj->status() == QDeclarativeImage::Ready);
+    QTRY_VERIFY(obj->progress() == 1.0);
+    QTRY_COMPARE(sourceSpy.count(), 2);
+    QTRY_COMPARE(progressSpy.count(), 2);
+    QTRY_COMPARE(statusSpy.count(), 2);
+
+    // Loading remote file again - should not go through 'Loading' state.
+    ctxt->setContextProperty("srcImage", QUrl::fromLocalFile(SRCDIR "/data/colors.png"));
+    ctxt->setContextProperty("srcImage", QString(SERVER_ADDR) + "/oldcolors.png");
+    QTRY_VERIFY(obj->status() == QDeclarativeImage::Ready);
+    QTRY_VERIFY(obj->progress() == 1.0);
+    QTRY_COMPARE(sourceSpy.count(), 4);
+    QTRY_COMPARE(progressSpy.count(), 2);
+    QTRY_COMPARE(statusSpy.count(), 2);
+}
+
 /*
    Find an item with the specified objectName.  If index is supplied then the
    item must also evaluate the {index} expression equal to index
diff --git a/tests/auto/qgraphicslayoutitem/tst_qgraphicslayoutitem.cpp b/tests/auto/qgraphicslayoutitem/tst_qgraphicslayoutitem.cpp
index 879e12b..dbffa6e 100644
--- a/tests/auto/qgraphicslayoutitem/tst_qgraphicslayoutitem.cpp
+++ b/tests/auto/qgraphicslayoutitem/tst_qgraphicslayoutitem.cpp
@@ -75,6 +75,7 @@ private slots:
     void setPreferredSize_data();
     void setPreferredSize();
     void setSizePolicy_data();
+    void setPreferredSize2();
     void setSizePolicy();
 };
 
@@ -343,6 +344,13 @@ void tst_QGraphicsLayoutItem::setPreferredSize()
     }
 }
 
+void tst_QGraphicsLayoutItem::setPreferredSize2()
+{
+    SubQGraphicsLayoutItem layoutItem;
+    layoutItem.setPreferredSize(QSizeF(30, -1));
+    QCOMPARE(layoutItem.preferredWidth(), qreal(30));
+}
+
 void tst_QGraphicsLayoutItem::setSizePolicy_data()
 {
     QTest::addColumn<QSizePolicy>("policy");
diff --git a/tests/auto/qinputcontext/tst_qinputcontext.cpp b/tests/auto/qinputcontext/tst_qinputcontext.cpp
index 52e655b..d077bc1 100644
--- a/tests/auto/qinputcontext/tst_qinputcontext.cpp
+++ b/tests/auto/qinputcontext/tst_qinputcontext.cpp
@@ -884,6 +884,27 @@ void tst_QInputContext::symbianTestCoeFepInputContext_data()
             << QString("44")
             << QString("");
     events.clear();
+
+    // Test that the symbol key successfully does nothing when in number-only mode.
+    events << FepReplayEvent(EEventKeyDown, EStdKeyLeftFunc, 0, 0, 0);
+    events << FepReplayEvent(EEventKeyUp, EStdKeyLeftFunc, 0, 0, 0);
+    QTest::newRow("Dead symbols key")
+            << true
+            << Qt::InputMethodHints(Qt::ImhDigitsOnly)
+            << 0
+            << QLineEdit::Normal
+            << events
+            << QString("")
+            << QString("");
+    QTest::newRow("Dead symbols key and password")
+            << true
+            << Qt::InputMethodHints(Qt::ImhDigitsOnly)
+            << 0
+            << QLineEdit::Password
+            << events
+            << QString("")
+            << QString("");
+    events.clear();
 #endif
 }
 
diff --git a/tests/auto/qstatictext/tst_qstatictext.cpp b/tests/auto/qstatictext/tst_qstatictext.cpp
index 2a60e9e..68c3ea9 100644
--- a/tests/auto/qstatictext/tst_qstatictext.cpp
+++ b/tests/auto/qstatictext/tst_qstatictext.cpp
@@ -91,6 +91,8 @@ private slots:
     void drawStruckOutText();
     void drawOverlinedText();
     void drawUnderlinedText();
+
+    void unprintableCharacter_qtbug12614();
 };
 
 void tst_QStaticText::init()
@@ -753,5 +755,14 @@ void tst_QStaticText::drawUnderlinedText()
     QCOMPARE(imageDrawText, imageDrawStaticText);
 }
 
+void tst_QStaticText::unprintableCharacter_qtbug12614()
+{
+    QString s(QChar(0x200B)); // U+200B, ZERO WIDTH SPACE
+
+    QStaticText staticText(s);
+
+    QVERIFY(staticText.size().isValid()); // Force layout. Should not crash.
+}
+
 QTEST_MAIN(tst_QStaticText)
 #include "tst_qstatictext.moc"
diff --git a/tools/qmeegographicssystemhelper/qmeegographicssystemhelper.cpp b/tools/qmeegographicssystemhelper/qmeegographicssystemhelper.cpp
new file mode 100644
index 0000000..0670ac4
--- /dev/null
+++ b/tools/qmeegographicssystemhelper/qmeegographicssystemhelper.cpp
@@ -0,0 +1,133 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#define ENSURE_RUNNING_MEEGO {if (! QMeeGoGraphicsSystemHelper::isRunningMeeGo()) { qFatal("Using meego functionality but not running meego graphics system!"); }}
+
+#include "qmeegographicssystemhelper.h"
+#include <private/qapplication_p.h>
+#include <private/qgraphicssystem_runtime_p.h>
+#include <private/qpixmap_raster_p.h>
+#include "qmeegoruntime.h"
+
+QString QMeeGoGraphicsSystemHelper::runningGraphicsSystemName()
+{
+    if (! QApplicationPrivate::instance()) {
+        qWarning("Querying graphics system but application not running yet!");
+        return QString();
+    }
+
+    QString name = QApplicationPrivate::instance()->graphics_system_name;
+    if (name == QLatin1String("runtime")) {
+        QRuntimeGraphicsSystem *rsystem = (QRuntimeGraphicsSystem *) QApplicationPrivate::instance()->graphics_system;
+        name = rsystem->graphicsSystemName();
+    }
+
+    return name;
+}
+
+bool QMeeGoGraphicsSystemHelper::isRunningMeeGo()
+{
+    return (runningGraphicsSystemName() == QLatin1String("meego"));
+}
+
+void QMeeGoGraphicsSystemHelper::switchToMeeGo()
+{
+    if (isRunningMeeGo())
+        return;
+
+    if (QApplicationPrivate::instance()->graphics_system_name != QLatin1String("runtime"))
+        qWarning("Can't switch to meego - switching only supported with 'runtime' graphics system.");
+    else {
+        QApplication *app = static_cast<QApplication *>(QCoreApplication::instance());
+        app->setGraphicsSystem(QLatin1String("meego"));
+    }
+}
+
+void QMeeGoGraphicsSystemHelper::switchToRaster()
+{
+    if (runningGraphicsSystemName() == QLatin1String("raster"))
+        return;
+
+    if (QApplicationPrivate::instance()->graphics_system_name != QLatin1String("runtime"))
+        qWarning("Can't switch to raster - switching only supported with 'runtime' graphics system.");
+    else {
+        QApplication *app = static_cast<QApplication *>(QCoreApplication::instance());
+        app->setGraphicsSystem(QLatin1String("raster"));
+    }
+}
+
+Qt::HANDLE QMeeGoGraphicsSystemHelper::imageToEGLSharedImage(const QImage &image)
+{
+    ENSURE_RUNNING_MEEGO;
+    return QMeeGoRuntime::imageToEGLSharedImage(image);
+}
+
+QPixmap QMeeGoGraphicsSystemHelper::pixmapFromEGLSharedImage(Qt::HANDLE handle, const QImage &softImage)
+{
+    // This function is supported when not running meego too. A raster-backed
+    // pixmap will be created... but when you switch back to 'meego', it'll 
+    // be replaced with a EGL shared image backing.
+    return QMeeGoRuntime::pixmapFromEGLSharedImage(handle, softImage);
+}
+
+QPixmap QMeeGoGraphicsSystemHelper::pixmapWithGLTexture(int w, int h)
+{
+    ENSURE_RUNNING_MEEGO;
+    return QMeeGoRuntime::pixmapWithGLTexture(w, h);
+}
+
+bool QMeeGoGraphicsSystemHelper::destroyEGLSharedImage(Qt::HANDLE handle)
+{
+    ENSURE_RUNNING_MEEGO;
+    return QMeeGoRuntime::destroyEGLSharedImage(handle);
+}
+
+void QMeeGoGraphicsSystemHelper::updateEGLSharedImagePixmap(QPixmap *p)
+{
+    ENSURE_RUNNING_MEEGO;
+    return QMeeGoRuntime::updateEGLSharedImagePixmap(p);
+}
+
+void QMeeGoGraphicsSystemHelper::setTranslucent(bool translucent)
+{
+    ENSURE_RUNNING_MEEGO;
+    QMeeGoRuntime::setTranslucent(translucent);
+}
diff --git a/tools/qmeegographicssystemhelper/qmeegographicssystemhelper.h b/tools/qmeegographicssystemhelper/qmeegographicssystemhelper.h
new file mode 100644
index 0000000..02f2fa2
--- /dev/null
+++ b/tools/qmeegographicssystemhelper/qmeegographicssystemhelper.h
@@ -0,0 +1,175 @@
+/****************************************************************************
+**
+** 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 QMEEGOGRAPHICSSYSTEMHELPER_H
+#define QMEEGOGRAPHICSSYSTEMHELPER_H
+
+#include <QPixmap>
+#include <QImage>
+#include "qmeegolivepixmap.h"
+
+class QLibrary;
+
+//! The base class for accressing special meego graphics system features. 
+/*!
+ This class is a helper class with static-only methods for accessing various
+ meego graphics system functionalities. The way it works is that the helper
+ dynamically calls-in to the loaded graphicssystem plugin... therefore, you're 
+ expected to make sure that you're indeed running with 'meego' before using any
+ of the specialized methods. 
+
+ In example:
+
+ \code
+ QPixmap p;
+ if (QMeeGoGraphicsSystemHelper::isRunningMeeGo()) {
+    p = QMeeGoGraphicsSystemHelper::pixmapWithGLTexture(64, 64);
+ } else {
+    p = QPixmap(64, 64);
+ }
+ \endcode
+
+ Calling any of the meego-specific features while not running meego might
+ give unpredictable results. The only functions safe to call at all times are:
+
+ \code
+ QMeeGoGraphicsSystemHelper::isRunningMeeGo();
+ QMeeGoGraphicsSystemHelper::runningGraphicsSystemName(); 
+ QMeeGoGraphicsSystemHelper::switchToMeeGo();
+ QMeeGoGraphicsSystemHelper::switchToRaster();
+ \endcode
+*/
+
+class Q_DECL_EXPORT QMeeGoGraphicsSystemHelper 
+{
+public:
+    //! Returns true if running meego.
+    /*! 
+     Returns true if the currently active (running) system is 'meego' with OpenGL. 
+     This returns both true if the app was started with 'meego' or was started with
+     'runtime' graphics system and the currently active system through the runtime
+     switching is 'meego'.
+    */
+    static bool isRunningMeeGo();
+
+    //! Switches to meego graphics system. 
+    /*!
+     When running with the 'runtime' graphics system, sets the currently active 
+     system to 'meego'. The window surface and all the resources are automatically
+     migrated to OpenGL. Will fail if the active graphics system is not 'runtime'.
+    */
+    static void switchToMeeGo();
+
+    //! Switches to raster graphics system
+    /*!
+     When running with the 'runtime' graphics system, sets the currently active
+     system to 'raster'. The window surface and the graphics resources (including the 
+     EGL shared image resources) are automatically migrated back to the CPU. All OpenGL 
+     resources (surface, context, cache, font cache) are automaticall anihilated.
+    */
+    static void switchToRaster();
+
+    //! Returns the name of the active graphics system
+    /*!
+     Returns the name of the currently active system. If running with 'runtime' graphics 
+     system, returns the name of the active system inside the runtime graphics system
+    */
+    static QString runningGraphicsSystemName();
+
+    //! Creates a new EGL shared image.
+    /*! 
+     Creates a new EGL shared image from the given image. The EGL shared image wraps
+     a GL texture in the native format and can be easily accessed from other processes.
+    */
+    static Qt::HANDLE imageToEGLSharedImage(const QImage &image);
+
+    //! Creates a QPixmap from an EGL shared image
+    /*!
+     Creates a new QPixmap from the given EGL shared image handle. The QPixmap can be 
+     used for painting like any other pixmap. The softImage should point to an alternative, 
+     software version of the graphical resource -- ie. obtained from theme daemon. The 
+     softImage can be allocated on a QSharedMemory slice for easy sharing across processes
+     too. When the application is migrated ToRaster, this softImage will replace the
+     contents of the sharedImage.
+     
+     It's ok to call this function too when not running 'meego' graphics system. In this
+     case it'll create a QPixmap backed with a raster data (from softImage)... but when 
+     the system is switched back to 'meego', the QPixmap will be migrated to a EGL-shared image
+     backed storage (handle).
+    */
+    static QPixmap pixmapFromEGLSharedImage(Qt::HANDLE handle, const QImage &softImage);
+
+    //! Destroys an EGL shared image. 
+    /*!
+     Destroys an EGLSharedImage previously created with an ::imageToEGLSharedImage call.
+     Returns true if the image was found and the destruction was successfull. Notice that
+     this destroys the image for all processes using it. 
+    */
+    static bool destroyEGLSharedImage(Qt::HANDLE handle);
+    
+    //! Updates the QPixmap backed with an EGLShared image. 
+    /*! 
+     This function re-reads the softImage that was specified when creating the pixmap with
+     ::pixmapFromEGLSharedImage and updates the EGL Shared image contents. It can be used
+     to share cross-proccess mutable EGLShared images. 
+    */
+    static void updateEGLSharedImagePixmap(QPixmap *p);
+
+    //! Create a new QPixmap with a GL texture.
+    /*!
+     Creates a new QPixmap which is backed by an OpenGL local texture. Drawing to this
+     QPixmap will be accelerated by hardware -- unlike the normal (new QPixmap()) pixmaps, 
+     which are backed by a software engine and only migrated to GPU when used. Migrating those
+     GL-backed pixmaps when going ToRaster is expsensive (they need to be downloaded from 
+     GPU to CPU) so use wisely. 
+    */
+    static QPixmap pixmapWithGLTexture(int w, int h);
+    
+    //! Sets translucency (alpha) on the base window surface.
+    /*!
+     This function needs to be called *before* any widget/content is created. 
+     When called with true, the base window surface will be translucent and initialized
+     with QGLFormat.alpha == true.
+    */
+    static void setTranslucent(bool translucent);
+};
+
+#endif
diff --git a/tools/qmeegographicssystemhelper/qmeegographicssystemhelper.pro b/tools/qmeegographicssystemhelper/qmeegographicssystemhelper.pro
new file mode 100644
index 0000000..1e6e233
--- /dev/null
+++ b/tools/qmeegographicssystemhelper/qmeegographicssystemhelper.pro
@@ -0,0 +1,10 @@
+TEMPLATE = lib
+TARGET = QtMeeGoGraphicsSystemHelper
+
+include(../../src/qbase.pri)
+
+QT += gui
+INCLUDEPATH += '../../src/plugins/graphicssystems/meego'
+
+HEADERS = qmeegographicssystemhelper.h qmeegooverlaywidget.h qmeegolivepixmap.h qmeegoliveimage.h qmeegoruntime.h qmeegoliveimage_p.h qmeegolivepixmap_p.h
+SOURCES = qmeegographicssystemhelper.cpp qmeegooverlaywidget.cpp qmeegoruntime.cpp qmeegolivepixmap.cpp qmeegoliveimage.cpp
diff --git a/tools/qmeegographicssystemhelper/qmeegoliveimage.cpp b/tools/qmeegographicssystemhelper/qmeegoliveimage.cpp
new file mode 100644
index 0000000..83a1e28
--- /dev/null
+++ b/tools/qmeegographicssystemhelper/qmeegoliveimage.cpp
@@ -0,0 +1,115 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "qmeegoliveimage.h"
+#include "qmeegoliveimage_p.h"
+#include "qmeegolivepixmap.h"
+#include "qmeegolivepixmap_p.h"
+
+/* QMeeGoLiveImagePrivate */
+
+QMeeGoLiveImagePrivate::QMeeGoLiveImagePrivate()
+{
+}
+
+QMeeGoLiveImagePrivate::~QMeeGoLiveImagePrivate()
+{
+    if (attachedPixmaps.length() > 0)
+        qWarning("Destroying QMeeGoLiveImage but it still has QMeeGoLivePixmaps attached!");
+}
+
+void QMeeGoLiveImagePrivate::attachPixmap(QMeeGoLivePixmap* pixmap)
+{
+    attachedPixmaps << pixmap;
+}
+
+void QMeeGoLiveImagePrivate::detachPixmap(QMeeGoLivePixmap* pixmap)
+{
+    attachedPixmaps.removeAll(pixmap);
+}
+
+/* QMeeGoLiveImage */
+
+QMeeGoLiveImage* QMeeGoLiveImage::liveImageWithSize(int w, int h, Format format, int buffers)
+{
+    if (format != Format_ARGB32_Premultiplied) {
+        qWarning("Only _ARGB32_Premultiplied format is supported for live images now!");
+        return 0;
+    }
+    
+    if (buffers != 1) {
+        qWarning("Only single-buffer streams are supported at the moment");
+        return 0;
+    }
+    
+    QMeeGoLiveImage *liveImage = new QMeeGoLiveImage(w, h);
+    return liveImage;
+}
+
+QMeeGoLiveImage::QMeeGoLiveImage(int w, int h) : QImage(w, h, QImage::Format_ARGB32_Premultiplied), d_ptr(new QMeeGoLiveImagePrivate())
+{
+    Q_D(QMeeGoLiveImage);
+    d->q_ptr = this;
+}
+
+QMeeGoLiveImage::~QMeeGoLiveImage()
+{
+}
+
+void QMeeGoLiveImage::lock(int buffer)
+{
+    if (buffer != 0)
+        qWarning("Only locking 0 buffer is supported at the moment!");
+}
+
+void QMeeGoLiveImage::release(int buffer)
+{
+    Q_D(QMeeGoLiveImage);
+    
+    if (buffer != 0) {
+        qWarning("Only locking 0 buffer is supported at the moment!");
+        return;
+    }
+
+    // We need to copy the update image to all the client QMeeGoLivePixmap's
+    foreach (QMeeGoLivePixmap* livePixmap, d->attachedPixmaps) 
+        livePixmap->d_ptr->copyBackFrom((const void *) bits());
+}
diff --git a/tools/qmeegographicssystemhelper/qmeegoliveimage.h b/tools/qmeegographicssystemhelper/qmeegoliveimage.h
new file mode 100644
index 0000000..1e21e7b
--- /dev/null
+++ b/tools/qmeegographicssystemhelper/qmeegoliveimage.h
@@ -0,0 +1,106 @@
+/****************************************************************************
+**
+** 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 QMEEGOLIVEIMAGE_H
+#define QMEEGOLIVEIMAGE_H
+
+#include <QImage>
+
+class QMeeGoLivePixmap;
+class QMeeGoLiveImagePrivate;
+
+//! A streamable QImage subclass.
+/*!
+*/
+
+class QMeeGoLiveImage : public QImage
+{
+public:
+    //! Format specifier.
+    /*! 
+     Used to specify the format of the underlying image data for QMeeGoLiveImage. 
+    */
+    enum Format {
+        Format_ARGB32_Premultiplied //! 32bit, AARRGGBB format. The typical Qt format.
+    };
+    
+    //! Locks the access to the image. 
+    /*! 
+     All drawing/access to the underlying image data needs to happen between 
+     ::lock() and ::unlock() pairs.
+     */
+    void lock(int buffer = 0);
+    
+    //! Unlocks the access to the image. 
+    /*! 
+     All drawing/access to the underlying image data needs to happen between 
+     ::lock() and ::unlock() pairs.
+     */
+    void release(int buffer = 0);
+    
+    //! Destroys the image.
+    /*!
+      It's a mistake to destroy an image before destroying all the QMeeGoLivePixmaps
+      built on top of it. You should first destroy all the QMeeGoLivePixmaps.
+     */
+    virtual ~QMeeGoLiveImage();
+    
+    //! Creates and returns a new live image with the given parameters.
+    /*!
+     The new image is created with the given width w and the given height h. 
+     The format specifies the color format used by the image. Optionally, a 
+     number of buffers can be specfied for a stream-like behavior.
+     */
+    static QMeeGoLiveImage* liveImageWithSize(int w, int h, Format format, int buffers = 1);
+
+private:
+    QMeeGoLiveImage(int w, int h); //! Private bits.
+    Q_DISABLE_COPY(QMeeGoLiveImage)
+    Q_DECLARE_PRIVATE(QMeeGoLiveImage)
+
+protected:
+    QScopedPointer<QMeeGoLiveImagePrivate> d_ptr;
+
+    friend class QMeeGoLivePixmap;
+    friend class QMeeGoLivePixmapPrivate;
+};
+
+#endif
diff --git a/tools/qmeegographicssystemhelper/qmeegoliveimage_p.h b/tools/qmeegographicssystemhelper/qmeegoliveimage_p.h
new file mode 100644
index 0000000..085fed4
--- /dev/null
+++ b/tools/qmeegographicssystemhelper/qmeegoliveimage_p.h
@@ -0,0 +1,63 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "qmeegoliveimage.h"
+
+#ifndef QMEEGOLIVEIMAGE_P_H
+#define QMEEGOLIVEIMAGE_P_H
+
+class QMeeGoLiveImagePrivate
+{
+public:
+    Q_DECLARE_PUBLIC(QMeeGoLiveImage);
+    QMeeGoLiveImagePrivate();
+    virtual ~QMeeGoLiveImagePrivate();
+    void attachPixmap(QMeeGoLivePixmap* pixmap);
+    void detachPixmap(QMeeGoLivePixmap* pixmap);
+        
+    QList <QMeeGoLivePixmap*> attachedPixmaps;
+    QMeeGoLiveImage *q_ptr;
+    
+    friend class QMeeGoLivePixmap;
+    friend class QMeeGoLivePixmapPrivate;
+};
+
+#endif
diff --git a/tools/qmeegographicssystemhelper/qmeegolivepixmap.cpp b/tools/qmeegographicssystemhelper/qmeegolivepixmap.cpp
new file mode 100644
index 0000000..2a1c04b
--- /dev/null
+++ b/tools/qmeegographicssystemhelper/qmeegolivepixmap.cpp
@@ -0,0 +1,163 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "qmeegolivepixmap.h"
+#include <private/qimage_p.h>
+#include <private/qpixmap_raster_p.h>
+#include "qmeegolivepixmap_p.h"
+#include "qmeegoliveimage_p.h"
+#include <QSharedMemory>
+
+/* QMeeGoLivePixmapPrivate */
+
+QMeeGoLivePixmapPrivate::QMeeGoLivePixmapPrivate() : shm(0), shmSerial(0), owns(true), parentImage(0)
+{
+}
+
+void QMeeGoLivePixmapPrivate::copyBackFrom(const void *raw)
+{
+    Q_Q(QMeeGoLivePixmap);
+    
+    q->detach();
+    shm->lock();
+    uchar *dest = ((uchar *) shm->data()) + (2 * sizeof(int));
+    memcpy(dest, raw, q->width() * q->height() * 4);
+    shm->unlock();
+}
+
+QMeeGoLivePixmapPrivate::~QMeeGoLivePixmapPrivate()
+{
+    Q_Q(QMeeGoLivePixmap);
+    
+    if (parentImage)
+        parentImage->d_ptr->detachPixmap(q);
+
+    if (shm)
+        shm->detach();
+        
+    if (owns)
+        delete shm;        
+}
+
+/* QMeeGoLivePixmap */
+
+QMeeGoLivePixmap::QMeeGoLivePixmap(QPixmapData *p) : QPixmap(p), d_ptr(new QMeeGoLivePixmapPrivate())
+{
+    Q_D(QMeeGoLivePixmap);
+    d->q_ptr = this;
+}
+
+QMeeGoLivePixmap* QMeeGoLivePixmap::fromLiveImage(QMeeGoLiveImage *liveImage)
+{
+    static int counter = 100;
+    QSharedMemory *shm = NULL;
+    uchar* imgData = NULL;
+    int *header = NULL;
+    int w = liveImage->width();
+    int h = liveImage->height();
+    
+    counter++;
+    shm = new QSharedMemory(QString(QLatin1String("QMeeGoLivePixmap%1")).arg(counter));
+    shm->create((w * h * 4) + 2 * sizeof(int)); // +2 to store width & height
+    shm->attach();
+    
+    imgData = ((uchar *) shm->data()) + (2 * sizeof(int));
+    header = (int *) shm->data();
+    
+    header[0] = w;
+    header[1] = h;
+    
+    QImage img(imgData, w, h, QImage::Format_ARGB32_Premultiplied);
+    
+    QPixmapData *pmd = new QRasterPixmapData(QPixmapData::PixmapType);
+    pmd->fromImage(img, Qt::NoOpaqueDetection);
+    
+    QMeeGoLivePixmap *livePixmap = new QMeeGoLivePixmap(pmd);
+    livePixmap->d_ptr->shm = shm;
+    livePixmap->d_ptr->owns = true;
+    livePixmap->d_ptr->shmSerial = counter;
+    livePixmap->d_ptr->parentImage = liveImage;
+    
+    liveImage->d_ptr->attachPixmap(livePixmap);
+
+    return livePixmap;    
+}
+
+QMeeGoLivePixmap* QMeeGoLivePixmap::fromHandle(Qt::HANDLE handle)
+{
+    QSharedMemory *shm = NULL;
+    int *header;
+    int width;
+    int height;
+    uchar* imgData;
+    
+    shm = new QSharedMemory(QString(QLatin1String("QMeeGoLivePixmap%1")).arg(handle));
+    shm->attach();
+    
+    shm->lock();
+    header = (int *) shm->data();
+    width = header[0];
+    height = header[1];
+    shm->unlock();
+    
+    imgData = ((uchar *) shm->data()) + (2 * sizeof(int));
+    QImage img(imgData, width, height, QImage::Format_ARGB32_Premultiplied);
+    
+    QPixmapData *pmd = new QRasterPixmapData(QPixmapData::PixmapType);
+    pmd->fromImage(img, Qt::NoOpaqueDetection);
+
+    QMeeGoLivePixmap *livePixmap = new QMeeGoLivePixmap(pmd);
+    livePixmap->d_ptr->shm = shm;
+    livePixmap->d_ptr->owns = false;
+    livePixmap->d_ptr->shmSerial = handle;
+
+    return livePixmap;
+}
+
+QMeeGoLivePixmap::~QMeeGoLivePixmap()
+{
+}
+
+Qt::HANDLE QMeeGoLivePixmap::handle()
+{
+    Q_D(QMeeGoLivePixmap);
+    return d->shmSerial;
+}
diff --git a/tools/qmeegographicssystemhelper/qmeegolivepixmap.h b/tools/qmeegographicssystemhelper/qmeegolivepixmap.h
new file mode 100644
index 0000000..2fa9db2
--- /dev/null
+++ b/tools/qmeegographicssystemhelper/qmeegolivepixmap.h
@@ -0,0 +1,98 @@
+/****************************************************************************
+**
+** 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 QMEEGOLIVEPIXMAP_H
+#define QMEEGOLIVEPIXMAP_H
+
+#include <QPixmap>
+#include "qmeegoliveimage.h"
+
+class QMeeGoLivePixmapPrivate;
+class QSharedMemory;
+class QImage;
+
+//! A pixmap representing streamed content.
+/*!
+*/
+
+class QMeeGoLivePixmap : public QPixmap
+{
+public:
+    //! Creates new pixmap from the given QMeeGoLiveImage.
+    /*! 
+     The created QMeeGoLivePixmap will be attached to the given QMeeGoLiveImage. 
+     Updates to the QMeeGoLiveImage will be represented on this newly created
+     QMeeGoLivePixmap.
+    */
+    static QMeeGoLivePixmap* fromLiveImage(QMeeGoLiveImage *liveImage);
+    
+    //! Creates a new QMeeGoLivePixmap from the specified handle.
+    /*! 
+     The handle can be used to share QMeeGoLivePixmap cross-process.
+    */
+    static QMeeGoLivePixmap* fromHandle(Qt::HANDLE handle);
+    
+    //! Returns the handle for this QMeeGoLivePixmap.
+    /*! 
+     The handle can be used to share QMeeGoLivePixmap cross-process.
+    */
+    Qt::HANDLE handle();
+    
+    //! Destroys the QMeeGoLivePixmap.
+    /*! 
+     All QMeeGoLivePixmaps attached to a given QMeeGoLiveImage have to be destroyed 
+     before the QMeeGoLiveImage itself is destroyed.
+    */
+    virtual ~QMeeGoLivePixmap();
+
+private:
+    QMeeGoLivePixmap(QPixmapData *p);
+    Q_DISABLE_COPY(QMeeGoLivePixmap)
+    Q_DECLARE_PRIVATE(QMeeGoLivePixmap)
+
+protected:
+    QScopedPointer<QMeeGoLivePixmapPrivate> d_ptr; //! Private bits.
+
+    friend class QMeeGoLiveImage;
+    friend class QMeeGoLiveImagePrivate;
+};
+
+#endif
diff --git a/tools/qmeegographicssystemhelper/qmeegolivepixmap_p.h b/tools/qmeegographicssystemhelper/qmeegolivepixmap_p.h
new file mode 100644
index 0000000..c2591dc
--- /dev/null
+++ b/tools/qmeegographicssystemhelper/qmeegolivepixmap_p.h
@@ -0,0 +1,66 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "qmeegolivepixmap.h"
+
+#ifndef QMEEGOLIVEPIXMAP_P_H
+#define QMEEGOLIVEPIXMAP_P_H
+
+class QMeeGoLivePixmapPrivate
+{
+public:
+    Q_DECLARE_PUBLIC(QMeeGoLivePixmap);
+    QMeeGoLivePixmapPrivate();
+    void copyBackFrom(const void *raw);
+    virtual ~QMeeGoLivePixmapPrivate();
+    
+    QSharedMemory *shm;
+    int shmSerial;
+    bool owns;
+    QMeeGoLiveImage *parentImage;
+    
+    QMeeGoLivePixmap *q_ptr;
+    
+    friend class QMeeGoLiveImage;
+    friend class QMeeGoLiveImagePrivate;
+};
+
+#endif
diff --git a/tools/qmeegographicssystemhelper/qmeegooverlaywidget.cpp b/tools/qmeegographicssystemhelper/qmeegooverlaywidget.cpp
new file mode 100644
index 0000000..f9f14ae
--- /dev/null
+++ b/tools/qmeegographicssystemhelper/qmeegooverlaywidget.cpp
@@ -0,0 +1,99 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include <QDebug>
+#include <QEvent>
+#include <QMouseEvent>
+#include <QCoreApplication>
+#include "qmeegooverlaywidget.h"
+#include "qmeegographicssystemhelper.h"
+#include "qmeegoruntime.h"
+
+QMeeGoOverlayWidget::QMeeGoOverlayWidget(int surfaceWidth, int surfaceHeight, QWidget *parent) : QWidget(parent, 0), 
+    sw(surfaceWidth), 
+    sh(surfaceHeight)
+{
+    if (! QMeeGoGraphicsSystemHelper::isRunningMeeGo())
+        qFatal("QMeeGoOverlayWidget can only be used when running with 'meego' graphics system!");
+
+    QMeeGoRuntime::setSurfaceFixedSize(surfaceWidth, surfaceHeight);
+
+    scaleW = sw / 864.0;
+    scaleH = sh / 480.0;
+    installEventFilter(this);
+}
+
+QPoint QMeeGoOverlayWidget::convertPoint(const QPoint &p)
+{
+    int x = p.x() * scaleW;
+    int y = p.y() * scaleH;
+    return QPoint(x, y);
+}
+
+void QMeeGoOverlayWidget::showEvent(QShowEvent *)
+{
+    QMeeGoRuntime::setSurfaceScaling(0, 0, width(), height());
+}
+
+bool QMeeGoOverlayWidget::eventFilter(QObject *, QEvent *event)
+{
+    if (event->spontaneous() == false)
+        return false;
+
+    switch(event->type()) {
+        case QEvent::MouseButtonPress:
+        case QEvent::MouseButtonRelease:
+        {
+            QMouseEvent *e = static_cast <QMouseEvent *>(event);
+            QMouseEvent newEvent = QMouseEvent(e->type(), 
+                                               convertPoint(e->pos()), 
+                                               convertPoint(e->globalPos()), 
+                                               e->button(), 
+                                               e->buttons(), 
+                                               e->modifiers());
+            QCoreApplication::sendEvent(this, &newEvent);
+            return true;
+        }
+
+        default:
+            return false;
+    }
+}
diff --git a/tools/qmeegographicssystemhelper/qmeegooverlaywidget.h b/tools/qmeegographicssystemhelper/qmeegooverlaywidget.h
new file mode 100644
index 0000000..c2c08b4
--- /dev/null
+++ b/tools/qmeegographicssystemhelper/qmeegooverlaywidget.h
@@ -0,0 +1,86 @@
+/****************************************************************************
+**
+** 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 QMEEGOOVERLAYWIDGET_H
+#define QMEEGOOVERLAYWIDGET_H
+
+#include <QWidget>
+
+//! A widget automatically scaling it's content.
+/*!
+*/
+
+class QMeeGoOverlayWidget : public QWidget
+{
+public:
+    //! Constructs a new scaling widget.
+    /*!
+     The real surface used for this widget will have the specified
+     width and height.
+    */
+    QMeeGoOverlayWidget(int surfaceWidth, int surfaceHeight, QWidget *parent = 0);
+
+
+    //! Event filtering function. 
+    /*!
+      Converts coordinates for mouse/touch event. Do not
+      call manually.
+    */
+    bool eventFilter(QObject *obj, QEvent *event);
+
+    //! Standard override.
+    /*!
+     The surface scaling on the target paint device is being
+     set when the widget is displayed for the first time.
+    */
+    virtual void showEvent(QShowEvent *event);
+
+private:
+    //! Converts coordinates between real & virtual area of the widget.
+    QPoint convertPoint(const QPoint &p);
+
+    int sw; /// Surface real width.
+    int sh; /// Surface real height.
+    float scaleW; /// Width scaling factor.
+    float scaleH; /// Height scaling factor.
+};
+
+#endif
diff --git a/tools/qmeegographicssystemhelper/qmeegoruntime.cpp b/tools/qmeegographicssystemhelper/qmeegoruntime.cpp
new file mode 100644
index 0000000..70b5dc1
--- /dev/null
+++ b/tools/qmeegographicssystemhelper/qmeegoruntime.cpp
@@ -0,0 +1,158 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "qmeegoruntime.h"
+
+#include <private/qlibrary_p.h>
+#include <private/qfactoryloader_p.h>
+#include <private/qgraphicssystemplugin_p.h>
+
+#define ENSURE_INITIALIZED {if (!initialized) initialize();}
+
+bool QMeeGoRuntime::initialized = false;
+
+typedef int (*QMeeGoImageToEglSharedImageFunc) (const QImage&);
+typedef QPixmapData* (*QMeeGoPixmapDataFromEglSharedImageFunc) (Qt::HANDLE handle, const QImage&);
+typedef QPixmapData* (*QMeeGoPixmapDataWithGLTextureFunc) (int w, int h);
+typedef bool (*QMeeGoDestroyEGLSharedImageFunc) (Qt::HANDLE handle);
+typedef void (*QMeeGoUpdateEglSharedImagePixmapFunc) (QPixmap*);
+typedef void (*QMeeGoSetSurfaceFixedSizeFunc) (int w, int h);
+typedef void (*QMeeGoSetSurfaceScalingFunc) (int x, int y, int w, int h);
+typedef void (*QMeeGoSetTranslucentFunc) (bool translucent);
+
+static QMeeGoImageToEglSharedImageFunc qt_meego_image_to_egl_shared_image = NULL;
+static QMeeGoPixmapDataFromEglSharedImageFunc qt_meego_pixmapdata_from_egl_shared_image = NULL;
+static QMeeGoPixmapDataWithGLTextureFunc qt_meego_pixmapdata_with_gl_texture = NULL;
+static QMeeGoDestroyEGLSharedImageFunc qt_meego_destroy_egl_shared_image = NULL;
+static QMeeGoUpdateEglSharedImagePixmapFunc qt_meego_update_egl_shared_image_pixmap = NULL;
+static QMeeGoSetSurfaceFixedSizeFunc qt_meego_set_surface_fixed_size = NULL;
+static QMeeGoSetSurfaceScalingFunc qt_meego_set_surface_scaling = NULL;
+static QMeeGoSetTranslucentFunc qt_meego_set_translucent = NULL;
+
+void QMeeGoRuntime::initialize()
+{
+    QFactoryLoader loader(QGraphicsSystemFactoryInterface_iid, QLatin1String("/graphicssystems"), Qt::CaseInsensitive);
+
+    QLibraryPrivate *libraryPrivate = loader.library(QLatin1String("meego"));
+    Q_ASSERT(libraryPrivate);
+
+    QLibrary library(libraryPrivate->fileName, libraryPrivate->fullVersion);
+
+    bool success = library.load();
+
+    if (success) {
+        qt_meego_image_to_egl_shared_image = (QMeeGoImageToEglSharedImageFunc) library.resolve("qt_meego_image_to_egl_shared_image");
+        qt_meego_pixmapdata_from_egl_shared_image = (QMeeGoPixmapDataFromEglSharedImageFunc)  library.resolve("qt_meego_pixmapdata_from_egl_shared_image");
+        qt_meego_pixmapdata_with_gl_texture = (QMeeGoPixmapDataWithGLTextureFunc) library.resolve("qt_meego_pixmapdata_with_gl_texture");
+        qt_meego_destroy_egl_shared_image = (QMeeGoDestroyEGLSharedImageFunc) library.resolve("qt_meego_destroy_egl_shared_image");
+        qt_meego_update_egl_shared_image_pixmap = (QMeeGoUpdateEglSharedImagePixmapFunc) library.resolve("qt_meego_update_egl_shared_image_pixmap");
+        qt_meego_set_surface_fixed_size = (QMeeGoSetSurfaceFixedSizeFunc) library.resolve("qt_meego_set_surface_fixed_size");
+        qt_meego_set_surface_scaling = (QMeeGoSetSurfaceScalingFunc) library.resolve("qt_meego_set_surface_scaling");
+        qt_meego_set_translucent = (QMeeGoSetTranslucentFunc) library.resolve("qt_meego_set_translucent");
+
+        if (qt_meego_image_to_egl_shared_image && qt_meego_pixmapdata_from_egl_shared_image && qt_meego_pixmapdata_with_gl_texture
+            && qt_meego_destroy_egl_shared_image && qt_meego_update_egl_shared_image_pixmap && qt_meego_set_surface_fixed_size
+            && qt_meego_set_surface_scaling && qt_meego_set_translucent)
+        {
+            qDebug("Successfully resolved MeeGo graphics system: %s %s\n", qPrintable(libraryPrivate->fileName), qPrintable(libraryPrivate->fullVersion));
+        }
+    } else {
+        Q_ASSERT(false);
+    }
+
+    initialized = true;
+}
+
+Qt::HANDLE QMeeGoRuntime::imageToEGLSharedImage(const QImage &image)
+{
+    ENSURE_INITIALIZED;
+    Q_ASSERT(qt_meego_image_to_egl_shared_image);
+    return qt_meego_image_to_egl_shared_image(image);
+}
+
+QPixmap QMeeGoRuntime::pixmapFromEGLSharedImage(Qt::HANDLE handle, const QImage &softImage)
+{
+    ENSURE_INITIALIZED;
+    Q_ASSERT(qt_meego_pixmapdata_from_egl_shared_image);
+    return QPixmap(qt_meego_pixmapdata_from_egl_shared_image(handle, softImage));
+}
+
+QPixmap QMeeGoRuntime::pixmapWithGLTexture(int w, int h)
+{
+    ENSURE_INITIALIZED;
+    Q_ASSERT(qt_meego_pixmapdata_with_gl_texture);
+    return QPixmap(qt_meego_pixmapdata_with_gl_texture(w, h));
+}
+
+bool QMeeGoRuntime::destroyEGLSharedImage(Qt::HANDLE handle)
+{
+    ENSURE_INITIALIZED;
+    Q_ASSERT(qt_meego_destroy_egl_shared_image);
+    return qt_meego_destroy_egl_shared_image(handle);
+}
+
+void QMeeGoRuntime::updateEGLSharedImagePixmap(QPixmap *p)
+{
+    ENSURE_INITIALIZED;
+    Q_ASSERT(qt_meego_update_egl_shared_image_pixmap);
+    return qt_meego_update_egl_shared_image_pixmap(p);
+}
+
+void QMeeGoRuntime::setSurfaceFixedSize(int w, int h)
+{
+    ENSURE_INITIALIZED;
+    Q_ASSERT(qt_meego_set_surface_fixed_size);
+    qt_meego_set_surface_fixed_size(w, h);
+}
+
+void QMeeGoRuntime::setSurfaceScaling(int x, int y, int w, int h)
+{
+    ENSURE_INITIALIZED;
+    Q_ASSERT(qt_meego_set_surface_scaling);
+    qt_meego_set_surface_scaling(x, y, w, h);
+}
+
+void QMeeGoRuntime::setTranslucent(bool translucent)
+{
+    ENSURE_INITIALIZED;
+    Q_ASSERT(qt_meego_set_translucent);
+    qt_meego_set_translucent(translucent);
+}
diff --git a/tools/qmeegographicssystemhelper/qmeegoruntime.h b/tools/qmeegographicssystemhelper/qmeegoruntime.h
new file mode 100644
index 0000000..82fdb52
--- /dev/null
+++ b/tools/qmeegographicssystemhelper/qmeegoruntime.h
@@ -0,0 +1,61 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include <QPixmap>
+#include <QImage>
+
+class QMeeGoRuntime
+{
+public:
+    static void initialize();
+
+    static Qt::HANDLE imageToEGLSharedImage(const QImage &image);
+    static QPixmap pixmapFromEGLSharedImage(Qt::HANDLE handle, const QImage &softImage);
+    static QPixmap pixmapWithGLTexture(int w, int h);
+    static bool destroyEGLSharedImage(Qt::HANDLE handle);
+    static void updateEGLSharedImagePixmap(QPixmap *p);
+    static void setSurfaceFixedSize(int w, int h);
+    static void setSurfaceScaling(int x, int y, int w, int h);
+    static void setTranslucent(bool translucent);
+
+private:
+    static bool initialized;
+};
diff --git a/tools/tools.pro b/tools/tools.pro
index f254230..8f23fe4 100644
--- a/tools/tools.pro
+++ b/tools/tools.pro
@@ -43,3 +43,7 @@ embedded: SUBDIRS += makeqpf
 
 CONFIG+=ordered
 QTDIR_build:REQUIRES = "contains(QT_CONFIG, full-config)"
+
+!win32:!embedded:!mac:!symbian:CONFIG += x11
+
+x11:contains(QT_CONFIG, opengles2):contains(QT_CONFIG, egl):SUBDIRS += qmeegographicssystemhelper