Introduce QtOpenGL module for Symbian.

Task-number: QT-2139
Reviewed-by: Gunnar Sletta

13 files changed, 467 insertions, 24 deletions

diff --git a/src/gui/kernel/qapplication_s60.cpp b/src/gui/kernel/qapplication_s60.cpp
index 670bf34..7c5e790 100644
--- a/src/gui/kernel/qapplication_s60.cpp
+++ b/src/gui/kernel/qapplication_s60.cpp
@@ -1107,17 +1107,19 @@ void QSymbianControl::Draw(const TRect& controlRect) const
         CFbsBitmap *bitmap = s60Surface->symbianBitmap();
         CWindowGc &gc = SystemGc();
 
-        switch(qwidget->d_func()->extraData()->nativePaintMode) {
+        QWExtra::NativePaintMode nativePaintMode = qwidget->d_func()->extraData()->nativePaintMode;
+        if(qwidget->d_func()->paintOnScreen())
+            nativePaintMode = QWExtra::Disable;
+
+        switch(nativePaintMode) {
         case QWExtra::Disable:
             // Do nothing
             break;
-
         case QWExtra::Blit:
             if (qwidget->d_func()->isOpaque)
                 gc.SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);
             gc.BitBlt(controlRect.iTl, bitmap, backingStoreRect);
             break;
-
         case QWExtra::ZeroFill:
             if (Window().DisplayMode() == EColor16MA
                 || Window().DisplayMode() == Q_SYMBIAN_ECOLOR16MAP) {
@@ -1130,7 +1132,6 @@ void QSymbianControl::Draw(const TRect& controlRect) const
                 gc.Clear(controlRect);
             };
             break;
-
         default:
             Q_ASSERT(false);
         }
diff --git a/src/gui/kernel/qwidget.cpp b/src/gui/kernel/qwidget.cpp
index dad4848..8b8641f 100644
--- a/src/gui/kernel/qwidget.cpp
+++ b/src/gui/kernel/qwidget.cpp
@@ -1274,7 +1274,16 @@ void QWidgetPrivate::init(QWidget *parentWidget, Qt::WindowFlags f)
     q->setAttribute(Qt::WA_WState_Hidden);
 
     //give potential windows a bigger "pre-initial" size; create_sys() will give them a new size later
+#ifdef Q_OS_SYMBIAN
+    if(q->inherits("QGLWidget")) {
+        // Don't waste GPU mem for unnecessary large egl surface
+        data.crect = parentWidget ? QRect(0,0,2,2) : QRect(0,0,2,2);
+    } else {
+        data.crect = parentWidget ? QRect(0,0,100,30) : QRect(0,0,360,640);
+    }
+#else
     data.crect = parentWidget ? QRect(0,0,100,30) : QRect(0,0,640,480);
+#endif
 
     focus_next = focus_prev = q;
 
@@ -9957,7 +9966,7 @@ void QWidget::setParent(QWidget *parent, Qt::WindowFlags f)
         desktopWidget = parent;
     bool newParent = (parent != parentWidget()) || !wasCreated || desktopWidget;
 
-#if defined(Q_WS_X11) || defined(Q_WS_WIN) || defined(Q_WS_MAC)
+#if defined(Q_WS_X11) || defined(Q_WS_WIN) || defined(Q_WS_MAC) || defined(Q_OS_SYMBIAN)
     if (newParent && parent && !desktopWidget) {
         if (testAttribute(Qt::WA_NativeWindow) && !qApp->testAttribute(Qt::AA_DontCreateNativeWidgetSiblings))
             parent->d_func()->enforceNativeChildren();
@@ -10611,7 +10620,7 @@ void QWidget::setAttribute(Qt::WidgetAttribute attribute, bool on)
     }
     case Qt::WA_PaintOnScreen:
         d->updateIsOpaque();
-#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined(Q_WS_MAC)
+#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_OS_SYMBIAN)
         // Recreate the widget if it's already created as an alien widget and
         // WA_PaintOnScreen is enabled. Paint on screen widgets must have win id.
         // So must their children.
diff --git a/src/gui/kernel/qwidget_s60.cpp b/src/gui/kernel/qwidget_s60.cpp
index 7ab9fbc..7494f92 100644
--- a/src/gui/kernel/qwidget_s60.cpp
+++ b/src/gui/kernel/qwidget_s60.cpp
@@ -486,7 +486,7 @@ void QWidgetPrivate::show_sys()
 
 #ifdef Q_WS_S60
         // Lazily initialize the S60 screen furniture when the first window is shown.
-        if (!QApplication::testAttribute(Qt::AA_S60DontConstructApplicationPanes)
+        if (q->isWindow() && !QApplication::testAttribute(Qt::AA_S60DontConstructApplicationPanes)
                 && !S60->buttonGroupContainer() && !S60->statusPane()) {
 
             if (!q->testAttribute(Qt::WA_DontShowOnScreen)) {
diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
index d3f6a29..18192e3 100644
--- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
+++ b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
@@ -90,7 +90,10 @@
 
 QT_BEGIN_NAMESPACE
 
-//#define QT_GL_NO_SCISSOR_TEST
+#if defined(Q_OS_SYMBIAN)
+#define QT_GL_NO_SCISSOR_TEST
+#endif
+
 #if defined(Q_WS_WIN)
 extern Q_GUI_EXPORT bool qt_cleartype_enabled;
 #endif
@@ -374,12 +377,12 @@ void QGL2PaintEngineExPrivate::updateMatrix()
         dx = ceilf(dx - 0.5f);
         dy = ceilf(dy - 0.5f);
     }
-
+#ifndef Q_OS_SYMBIAN
     if (addOffset) {
         dx += 0.49f;
         dy += 0.49f;
     }
-
+#endif
     pmvMatrix[0][0] = (wfactor * transform.m11())  - transform.m13();
     pmvMatrix[1][0] = (wfactor * transform.m21())  - transform.m23();
     pmvMatrix[2][0] = (wfactor * dx) - transform.m33();
@@ -686,7 +689,12 @@ void QGL2PaintEngineExPrivate::fill(const QVectorPath& path)
     const QPointF* const points = reinterpret_cast<const QPointF*>(path.points());
 
     // ### Remove before release...
-    static bool do_vectorpath_cache = qgetenv("QT_OPENGL_NO_PATH_CACHE").isEmpty();
+#ifdef Q_OS_SYMBIAN
+    // ### There are some unresolved issues in Symbian vector path caching.
+    static bool do_vectorpath_cache = false;
+#else
+    static bool do_vectorpath_cache = true;
+#endif
 
     // Check to see if there's any hints
     if (path.shape() == QVectorPath::RectangleHint) {
diff --git a/src/opengl/gl2paintengineex/qtriangulator.cpp b/src/opengl/gl2paintengineex/qtriangulator.cpp
index df7cbc2..f14b0a4 100644
--- a/src/opengl/gl2paintengineex/qtriangulator.cpp
+++ b/src/opengl/gl2paintengineex/qtriangulator.cpp
@@ -65,7 +65,11 @@ QT_BEGIN_NAMESPACE
 
 // Quick sort.
 template <class T, class LessThan>
+#ifdef Q_CC_RVCT // RVCT 2.2 doesn't see recursive _static_ template function
+void sort(T *array, int count, LessThan lessThan)
+#else
 static void sort(T *array, int count, LessThan lessThan)
+#endif
 {
     // If the number of elements fall below some threshold, use insertion sort.
     const int INSERTION_SORT_LIMIT = 7; // About 7 is fastest on my computer...
@@ -122,7 +126,11 @@ sort_loop_end:
 
 // Quick sort.
 template <class T>
+#ifdef Q_CC_RVCT
+void sort(T *array, int count) // RVCT 2.2 doesn't see recursive _static_ template function
+#else
 static void sort(T *array, int count)
+#endif
 {
     // If the number of elements fall below some threshold, use insertion sort.
     const int INSERTION_SORT_LIMIT = 25; // About 25 is fastest on my computer...
diff --git a/src/opengl/opengl.pro b/src/opengl/opengl.pro
index d6011cf..0e82467 100644
--- a/src/opengl/opengl.pro
+++ b/src/opengl/opengl.pro
@@ -11,18 +11,18 @@ unix:QMAKE_PKGCONFIG_REQUIRES = QtCore QtGui
 
 include(../qbase.pri)
 
-!win32:!embedded:!mac:CONFIG	   += x11
+!win32:!embedded:!mac:!symbian:CONFIG	   += x11
 contains(QT_CONFIG, opengl):CONFIG += opengl
 contains(QT_CONFIG, opengles1):CONFIG += opengles1
 contains(QT_CONFIG, opengles2):CONFIG += opengles2
 contains(QT_CONFIG, egl):CONFIG += egl
 
 HEADERS += qgl.h \
-	   qgl_p.h \
-	   qglcolormap.h \
-	   qglpixelbuffer.h \
+           qgl_p.h \
+           qglcolormap.h \
+           qglpixelbuffer.h \
            qglpixelbuffer_p.h \
-	   qglframebufferobject.h  \
+           qglframebufferobject.h  \
            qglframebufferobject_p.h  \
            qglextensions_p.h \
            qglpaintdevice_p.h \
@@ -30,9 +30,9 @@ HEADERS += qgl.h \
 
 
 SOURCES	+= qgl.cpp \
-	   qglcolormap.cpp \
-	   qglpixelbuffer.cpp \
-	   qglframebufferobject.cpp \
+           qglcolormap.cpp \
+           qglpixelbuffer.cpp \
+           qglframebufferobject.cpp \
            qglextensions.cpp \
            qglpaintdevice.cpp \
            qglbuffer.cpp \
@@ -119,7 +119,7 @@ mac {
 win32:!wince*: {
     DEFINES += QT_NO_EGL
     SOURCES += qgl_win.cpp \
-	       qglpixelbuffer_win.cpp
+	           qglpixelbuffer_win.cpp
 }
 wince*: {
     SOURCES += qgl_wince.cpp \
@@ -147,4 +147,14 @@ embedded {
     }
 }
 
+symbian {
+    SOURCES += qgl_symbian.cpp \
+               qglpixelbuffer_egl.cpp \
+               qgl_egl.cpp
+
+    HEADERS += qgl_egl_p.h
+
+    symbian:TARGET.UID3 = 0x2002131A
+}
+
 INCLUDEPATH += ../3rdparty/harfbuzz/src
diff --git a/src/opengl/qgl.cpp b/src/opengl/qgl.cpp
index 74bde36..1802107 100644
--- a/src/opengl/qgl.cpp
+++ b/src/opengl/qgl.cpp
@@ -96,7 +96,7 @@
 
 QT_BEGIN_NAMESPACE
 
-#if defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_WS_QWS)
+#if defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_WS_QWS) || defined(Q_OS_SYMBIAN)
 QGLExtensionFuncs QGLContextPrivate::qt_extensionFuncs;
 #endif
 
@@ -2264,7 +2264,7 @@ static void convertToGLFormatHelper(QImage &dst, const QImage &img, GLenum textu
     }
 }
 
-#if defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_WS_QWS)
+#if defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_WS_QWS) || defined(Q_OS_SYMBIAN)
 QGLExtensionFuncs& QGLContextPrivate::extensionFuncs(const QGLContext *)
 {
     return qt_extensionFuncs;
@@ -4197,6 +4197,34 @@ bool QGLWidget::event(QEvent *e)
         d->glcx->d_ptr->clearDrawable();
 #  endif
     }
+#elif defined(Q_OS_SYMBIAN)
+    // prevents errors on some systems, where we get a flush to a
+    // hidden widget
+    if (e->type() == QEvent::Hide) {
+        makeCurrent();
+        glFinish();
+        doneCurrent();
+    } else if (e->type() == QEvent::ParentChange) {
+        // if we've reparented a window that has the current context
+        // bound, we need to rebind that context to the new window id
+        if (d->glcx == QGLContext::currentContext())
+            makeCurrent();
+
+        if (testAttribute(Qt::WA_TranslucentBackground))
+            setContext(new QGLContext(d->glcx->requestedFormat(), this));
+    }
+
+    // A re-parent is likely to destroy the Symbian window and re-create it. It is important
+    // that we free the EGL surface _before_ the winID changes - otherwise we can leak.
+    if (e->type() == QEvent::ParentAboutToChange)
+        d->glcx->d_func()->destroyEglSurfaceForDevice();
+
+    if ((e->type() == QEvent::ParentChange) || (e->type() == QEvent::WindowStateChange)) {
+        // The window may have been re-created during re-parent or state change - if so, the EGL
+        // surface will need to be re-created.
+        d->recreateEglSurface();
+    }
+
 #endif
 
     return QWidget::event(e);
diff --git a/src/opengl/qgl_egl.cpp b/src/opengl/qgl_egl.cpp
index a154325..ebd1169 100644
--- a/src/opengl/qgl_egl.cpp
+++ b/src/opengl/qgl_egl.cpp
@@ -230,7 +230,7 @@ void QGLContext::swapBuffers() const
 void QGLContextPrivate::destroyEglSurfaceForDevice()
 {
     if (eglSurface != EGL_NO_SURFACE) {
-#ifdef Q_WS_X11
+#if defined(Q_WS_X11) || defined(Q_OS_SYMBIAN)
         // Make sure we don't call eglDestroySurface on a surface which
         // was created for a different winId. This applies only to QGLWidget
         // paint device, so make sure this is the one we're operating on
diff --git a/src/opengl/qgl_p.h b/src/opengl/qgl_p.h
index ca0d3fa..387c8f7 100644
--- a/src/opengl/qgl_p.h
+++ b/src/opengl/qgl_p.h
@@ -167,6 +167,9 @@ public:
 #if defined(Q_WS_X11) && !defined(QT_NO_EGL)
                        , eglSurfaceWindowId(0)
 #endif
+#if defined(Q_OS_SYMBIAN)
+                       , eglSurfaceWindowId(0)
+#endif
     {
         isGLWidget = 1;
     }
@@ -208,6 +211,10 @@ public:
 #elif defined(Q_WS_QWS)
     QWSGLWindowSurface *wsurf;
 #endif
+#ifdef Q_OS_SYMBIAN
+    void recreateEglSurface();
+    WId eglSurfaceWindowId;
+#endif
 };
 
 class QGLContextResource;
@@ -417,7 +424,7 @@ public:
     static inline QGLExtensionFuncs& extensionFuncs(const QGLContext *ctx) { return ctx->d_ptr->group->extensionFuncs(); }
 #endif
 
-#if defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_WS_QWS)
+#if defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_WS_QWS) || defined(Q_OS_SYMBIAN)
     static QGLExtensionFuncs qt_extensionFuncs;
     static Q_OPENGL_EXPORT QGLExtensionFuncs& extensionFuncs(const QGLContext *);
 #endif
diff --git a/src/opengl/qgl_symbian.cpp b/src/opengl/qgl_symbian.cpp
new file mode 100644
index 0000000..73fe4c9
--- /dev/null
+++ b/src/opengl/qgl_symbian.cpp
@@ -0,0 +1,362 @@
+/****************************************************************************
+**
+** 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 QtOpenGL module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "qgl.h"
+#include <coemain.h>
+#include <coecntrl.h>
+#include <w32std.h>
+#include <private/qpixmap_s60_p.h>
+#include <private/qimagepixmapcleanuphooks_p.h>
+#include <private/qgl_p.h>
+#include <private/qpaintengine_opengl_p.h>
+#include <private/qwidget_p.h> // to access QWExtra
+#include "qgl_egl_p.h"
+#include "qcolormap.h"
+#include <QDebug>
+
+QT_BEGIN_NAMESPACE
+
+// Turn off "direct to window" rendering if EGL cannot support it.
+#if !defined(EGL_RENDER_BUFFER) || !defined(EGL_SINGLE_BUFFER)
+#if defined(QGL_DIRECT_TO_WINDOW)
+#undef QGL_DIRECT_TO_WINDOW
+#endif
+#endif
+
+// Determine if preserved window contents should be used.
+#if !defined(EGL_SWAP_BEHAVIOR) || !defined(EGL_BUFFER_PRESERVED)
+#if !defined(QGL_NO_PRESERVED_SWAP)
+#define QGL_NO_PRESERVED_SWAP 1
+#endif
+#endif
+
+/*
+    QGLTemporaryContext implementation
+*/
+
+
+class QGLTemporaryContextPrivate
+{
+public:
+    bool initialized;
+    RWindow *window;
+    EGLContext context;
+    EGLSurface surface;
+    EGLDisplay display;
+};
+
+QGLTemporaryContext::QGLTemporaryContext(bool, QWidget *)
+    : d(new QGLTemporaryContextPrivate)
+{
+    d->initialized = false;
+    d->window = 0;
+    d->context = 0;
+    d->surface = 0;
+
+    d->display = d->display = QEgl::display();
+
+    EGLConfig config;
+    int numConfigs = 0;
+    EGLint attribs[] = {
+        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
+#ifdef QT_OPENGL_ES_2
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+#endif
+        EGL_NONE
+    };
+
+    eglChooseConfig(d->display, attribs, &config, 1, &numConfigs);
+    if (!numConfigs) {
+        qWarning("QGLTemporaryContext: No EGL configurations available.");
+        return;
+    }
+
+    d->window = new RWindow(CCoeEnv::Static()->WsSession());
+    d->window->Construct(CCoeEnv::Static()->RootWin(),(uint)this);
+
+    d->surface = eglCreateWindowSurface(d->display, config, (EGLNativeWindowType) d->window, NULL);
+
+    if (d->surface == EGL_NO_SURFACE) {
+        qWarning("QGLTemporaryContext: Error creating EGL surface.");
+        delete d->window;
+        d->window = 0;
+        return;
+    }
+
+    EGLint contextAttribs[] = {
+#ifdef QT_OPENGL_ES_2
+        EGL_CONTEXT_CLIENT_VERSION, 2,
+#endif
+        EGL_NONE
+    };
+    d->context = eglCreateContext(d->display, config, 0, contextAttribs);
+    if (d->context != EGL_NO_CONTEXT
+        && eglMakeCurrent(d->display, d->surface, d->surface, d->context))
+    {
+        d->initialized = true;
+    } else {
+        qWarning("QGLTemporaryContext: Error creating EGL context.");
+        d->window = 0;
+        return;
+    }
+}
+
+QGLTemporaryContext::~QGLTemporaryContext()
+{
+    if (d->initialized) {
+        eglMakeCurrent(d->display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+        eglDestroyContext(d->display, d->context);
+        eglDestroySurface(d->display, d->surface);
+        delete d->window;
+    }
+}
+
+bool QGLFormat::hasOpenGLOverlays()
+{
+    return false;
+}
+
+// Chooses the EGL config and creates the EGL context
+bool QGLContext::chooseContext(const QGLContext* shareContext) // almost same as in qgl_x11egl.cpp
+{
+    Q_D(QGLContext);
+
+    if (!device())
+        return false;
+
+    int devType = device()->devType();
+
+    if ((devType != QInternal::Widget) && (devType != QInternal::Pbuffer)) {
+        qWarning("WARNING: Creating a QGLContext not supported on device type %d", devType);
+        return false;
+    }
+
+    // Get the display and initialize it.
+    if (d->eglContext == 0) {
+        d->eglContext = new QEglContext();
+        d->ownsEglContext = true;
+        d->eglContext->setApi(QEgl::OpenGL);
+
+	    // If the device is a widget with WA_TranslucentBackground set, make sure the glFormat
+        // has the alpha channel option set:
+        if (devType == QInternal::Widget) {
+            QWidget* widget = static_cast<QWidget*>(device());
+            if (widget->testAttribute(Qt::WA_TranslucentBackground))
+                d->glFormat.setAlpha(true);
+        }
+
+        // Construct the configuration we need for this surface.
+        QEglProperties configProps;
+        configProps.setDeviceType(devType);
+        configProps.setPaintDeviceFormat(device());
+        configProps.setRenderableType(QEgl::OpenGL);
+        configProps.setValue(EGL_SURFACE_TYPE, EGL_WINDOW_BIT|EGL_SWAP_BEHAVIOR_PRESERVED_BIT);
+
+        qt_eglproperties_set_glformat(configProps, d->glFormat);
+
+        if (!d->eglContext->chooseConfig(configProps, QEgl::BestPixelFormat)) {
+            delete d->eglContext;
+            d->eglContext = 0;
+            return false;
+        }
+
+        // Create a new context for the configuration.
+        QEglContext* eglSharedContext = shareContext ? shareContext->d_func()->eglContext : 0;
+        if (!d->eglContext->createContext(eglSharedContext)) {
+            delete d->eglContext;
+            d->eglContext = 0;
+            return false;
+        }
+        d->sharing = d->eglContext->isSharing();
+        if (d->sharing && shareContext)
+            const_cast<QGLContext *>(shareContext)->d_func()->sharing = true;
+	}
+
+    // Inform the higher layers about the actual format properties
+    qt_glformat_from_eglconfig(d->glFormat, d->eglContext->config());
+
+    // Do don't create the EGLSurface for everything.
+    //    QWidget - yes, create the EGLSurface and store it in QGLContextPrivate::eglSurface
+    //    QGLWidget - yes, create the EGLSurface and store it in QGLContextPrivate::eglSurface
+    //    QGLPixelBuffer - no, it creates the surface itself and stores it in QGLPixelBufferPrivate::pbuf
+
+    if (devType == QInternal::Widget) {
+        if (d->eglSurface != EGL_NO_SURFACE)
+            eglDestroySurface(d->eglContext->display(), d->eglSurface);
+
+        d->eglSurface = QEgl::createSurface(device(), d->eglContext->config());
+
+#if !defined(QGL_NO_PRESERVED_SWAP)
+        eglGetError();  // Clear error state first.
+        eglSurfaceAttrib(QEgl::display(), d->eglSurface,
+                EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED);
+        if (eglGetError() != EGL_SUCCESS) {
+            qWarning("QGLContext: could not enable preserved swap");
+        }
+#endif
+
+        setWindowCreated(true);
+    }
+
+    return true;
+}
+
+void QGLWidget::resizeEvent(QResizeEvent *)
+{
+    Q_D(QGLWidget);
+    if (!isValid())
+        return;
+
+    if (QGLContext::currentContext())
+        doneCurrent();
+
+    // Symbian needs to recreate the surface on resize.
+    d->recreateEglSurface();
+
+    makeCurrent();
+    if (!d->glcx->initialized())
+        glInit();
+    resizeGL(width(), height());
+    //handle overlay
+}
+
+const QGLContext* QGLWidget::overlayContext() const
+{
+    return 0;
+}
+
+void QGLWidget::makeOverlayCurrent()
+{
+    //handle overlay
+}
+
+void QGLWidget::updateOverlayGL()
+{
+    //handle overlay
+}
+
+void QGLWidget::setContext(QGLContext *context, const QGLContext* shareContext, bool deleteOldContext)
+{
+    Q_D(QGLWidget);
+    if (context == 0) {
+        qWarning("QGLWidget::setContext: Cannot set null context");
+        return;
+    }
+    if (!context->deviceIsPixmap() && context->device() != this) {
+        qWarning("QGLWidget::setContext: Context must refer to this widget");
+        return;
+    }
+
+    if (d->glcx)
+        d->glcx->doneCurrent();
+    QGLContext* oldcx = d->glcx;
+    d->glcx = context;
+
+    bool createFailed = false;
+    if (!d->glcx->isValid()) {
+        // Create the QGLContext here, which in turn chooses the EGL config
+        // and creates the EGL context:
+        if (!d->glcx->create(shareContext ? shareContext : oldcx))
+            createFailed = true;
+    }
+    if (createFailed) {
+        if (deleteOldContext)
+            delete oldcx;
+        return;
+    }
+
+    d->eglSurfaceWindowId = winId(); // Remember the window id we created the surface for
+}
+
+void QGLWidgetPrivate::init(QGLContext *context, const QGLWidget* shareWidget)
+{
+    Q_Q(QGLWidget);
+
+    initContext(context, shareWidget);
+
+    if(q->isValid() && glcx->format().hasOverlay()) {
+        //no overlay
+        qWarning("QtOpenGL ES doesn't currently support overlays");
+    }
+}
+
+void QGLWidgetPrivate::cleanupColormaps()
+{
+}
+
+const QGLColormap & QGLWidget::colormap() const
+{
+    return d_func()->cmap;
+}
+
+void QGLWidget::setColormap(const QGLColormap &)
+{
+}
+
+void QGLWidgetPrivate::recreateEglSurface()
+{
+    Q_Q(QGLWidget);
+
+    WId currentId = q->winId();
+
+    if (glcx->d_func()->eglSurface != EGL_NO_SURFACE) {
+        eglDestroySurface(glcx->d_func()->eglContext->display(),
+                                                glcx->d_func()->eglSurface);
+    }
+
+    glcx->d_func()->eglSurface = QEgl::createSurface(glcx->device(),
+                                       glcx->d_func()->eglContext->config());
+
+#if !defined(QGL_NO_PRESERVED_SWAP)
+        eglGetError();  // Clear error state first.
+        eglSurfaceAttrib(QEgl::display(), glcx->d_func()->eglSurface,
+                                    EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED);
+        if (eglGetError() != EGL_SUCCESS) {
+            qWarning("QGLContext: could not enable preserved swap");
+        }
+#endif
+
+    eglSurfaceWindowId = currentId;
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/plugins/graphicssystems/opengl/opengl.pro b/src/plugins/graphicssystems/opengl/opengl.pro
index 7d6fe3f..47e15c5 100644
--- a/src/plugins/graphicssystems/opengl/opengl.pro
+++ b/src/plugins/graphicssystems/opengl/opengl.pro
@@ -9,3 +9,5 @@ SOURCES = main.cpp
 
 target.path += $$[QT_INSTALL_PLUGINS]/graphicssystems
 INSTALLS += target
+
+symbian: TARGET.UID3 = 0x2002131B
diff --git a/src/s60installs/qt.iby b/src/s60installs/qt.iby
index 935bdc5..b6cdce9 100644
--- a/src/s60installs/qt.iby
+++ b/src/s60installs/qt.iby
@@ -20,6 +20,7 @@ file=ABI_DIR\BUILD_DIR\phonon.dll            SHARED_LIB_DIR\phonon.dll
 file=ABI_DIR\BUILD_DIR\QtMultimedia.dll      SHARED_LIB_DIR\QtMultimedia.dll
 file=ABI_DIR\BUILD_DIR\QtXmlPatterns.dll     SHARED_LIB_DIR\QtXmlPatterns.dll
 file=ABI_DIR\BUILD_DIR\QtDeclarative.dll     SHARED_LIB_DIR\QtDeclarative.dll
+file=ABI_DIR\BUILD_DIR\QtOpenGL.dll          SHARED_LIB_DIR\QtOpenGL.dll
 
 // imageformats
 file=ABI_DIR\BUILD_DIR\qgif.dll              SHARED_LIB_DIR\qgif.dll
@@ -50,6 +51,7 @@ file=ABI_DIR\BUILD_DIR\qaudio.dll            SHARED_LIB_DIR\qaudio.dll
 
 // graphicssystems
 file=ABI_DIR\BUILD_DIR\qvggraphicssystem.dll SHARED_LIB_DIR\qvggraphicssystem.dll
+file=ABI_DIR\BUILD_DIR\qglgraphicssystem.dll SHARED_LIB_DIR\qglgraphicssystem.dll
 
 // S60 version compatibility plugins for 5.0 (3.1 and 3.2 devices are never likely to have this in ROM,
 // so don't bother including those plugins
@@ -95,6 +97,7 @@ data=\epoc32\data\qt\qtlibspluginstubs\qaudio.qtplugin resource\qt\plugins\audio
 
 // graphicssystems
 data=\epoc32\data\z\resource\qt\plugins\graphicssystems\qvggraphicssystem.qtplugin      resource\qt\plugins\graphicssystems\qvggraphicssystem.qtplugin
+data=\epoc32\data\z\resource\qt\plugins\graphicssystems\qglgraphicssystem.qtplugin      resource\qt\plugins\graphicssystems\qglgraphicssystem.qtplugin
 
 // Stub sis file
 data=ZSYSTEM\install\qt_stub.sis    System\Install\qt_stub.sis
diff --git a/src/s60installs/s60installs.pro b/src/s60installs/s60installs.pro
index 8a8167b..9e1d582 100644
--- a/src/s60installs/s60installs.pro
+++ b/src/s60installs/s60installs.pro
@@ -189,6 +189,11 @@ symbian: {
             "[0x1028315F],0,0,0,{\"S60ProductID\"}"
     }
 
+    contains(QT_CONFIG, opengl) {
+        qtlibraries.sources += $$QMAKE_LIBDIR_QT/QtOpenGL$${QT_LIBINFIX}.dll
+        graphicssystems_plugins.sources += $$QT_BUILD_TREE/plugins/graphicssystems/qglgraphicssystem$${QT_LIBINFIX}.dll
+    }
+
     contains(QT_CONFIG, multimedia){
         qtlibraries.sources += $$QMAKE_LIBDIR_QT/QtMultimedia$${QT_LIBINFIX}.dll
     }