Merge remote branch 'origin/4.7' into qt-4.8-from-4.7

Conflicts:
	doc/src/external-resources.qdoc
	src/gui/text/qtextlayout.cpp
	src/opengl/qwindowsurface_gl.cpp

14 files changed, 1077 insertions, 509 deletions

diff --git a/doc/src/external-resources.qdoc b/doc/src/external-resources.qdoc
index 5431ec8..2794d48 100644
--- a/doc/src/external-resources.qdoc
+++ b/doc/src/external-resources.qdoc
@@ -493,3 +493,8 @@
     \externalpage http://msdn.microsoft.com/en-us/library/dd318066.aspx
     \title Microsoft Active Accessibility Event Constants
 */
+
+/*!
+    \externalpage http://www.developer.nokia.com/Community/Wiki/Graphics_memory_handling
+    \title Graphics Out Of Memory monitor
+*/
diff --git a/doc/src/platforms/platform-notes.qdoc b/doc/src/platforms/platform-notes.qdoc
index c2e47c2..175cf1c 100644
--- a/doc/src/platforms/platform-notes.qdoc
+++ b/doc/src/platforms/platform-notes.qdoc
@@ -815,11 +815,43 @@
     plugin. If the Helix plugin fails to load, the MMF plugin, if present on
     the device, will be loaded instead.
 
-    \section1 QtOpenGL Support
-
-    Qt 4.7 introduces the QtOpenGL module to Symbian^3. QtOpenGL is supported on
-    devices which support OpenGL ES 2.0. Symbian platforms prior to Symbian^3
-    are not supported.
+    \section1 Hardware Accelerated Rendering
+
+    The default graphics system on Symbian^3 is OpenVG, which uses OpenVG
+    hardware to accelerate \l QPainter functions. There are a few exceptions,
+    where Qt will use software rendering fallback.
+
+    Devices like the N8 and C7 only have 32Mb of GPU memory and limited support
+    for EGL surface transparency. These devices can be identified by querying
+    the\c GL_RENDERER or \c VG_RENDERER string which evaluates to \c {VideoCore III}.
+    On these devices, Qt will use software rendering in cases listed below.
+
+        \list
+        \o Translucent windows
+        \o Dialogs
+        \o Popups
+        \endlist
+
+    \section1 QtOpenGL Support in Symbian
+
+     Qt 4.7 introduces the \l {QtOpenGL} module to Symbian^3. QtOpenGL is
+     supported on devices which support OpenGL ES 2.0. Symbian platforms prior
+     to Symbian^3 are not supported.
+
+    \l QGLWidget usage as a \l QGraphicsView viewport is not recommended on
+    Symbian. The OpenVG graphics system is not able to manage OpenGL graphics
+    resources. Also, a QGLWidget object is not able to release its GPU resources
+    when the application goes to the background. If OpenGL functionality is
+    needed, OpenGL graphics system usage is recommended. If an application
+    decides to use QGLWidget, then it is the application's responsibility to
+    destroy and release QGLWidget and related OpenGL resources when the
+    application goes to the background. Otherwise, the \l{Graphics Out Of Memory monitor}
+    may decide to kill the application as it consumes GPU resources while in the
+    background.
+
+    \note \l QGLBuffer, \l QGLFramebufferObject, \l QGLPixelBuffer, \l
+    QGLShader, and \l QGLShaderProgram are direct GPU resources and it is the
+    application's responsibility to manage them.
 
     \section1 UI Performance in devices prior to Symbian^3
 
diff --git a/mkspecs/common/symbian/symbian.conf b/mkspecs/common/symbian/symbian.conf
index 5bf8728..4025c54 100644
--- a/mkspecs/common/symbian/symbian.conf
+++ b/mkspecs/common/symbian/symbian.conf
@@ -88,6 +88,9 @@ QMAKE_LIBS_S60          = -lavkon -leikcoctl -lgfxtrans
 
 exists($${EPOCROOT}epoc32/include/platform/sgresource/sgimage.h) {
     QMAKE_LIBS_OPENVG += -lsgresource
+    QMAKE_LIBS_OPENGL_QT += -lsgresource
+    QMAKE_LIBS_OPENGL_ES1_QT += -lsgresource
+    QMAKE_LIBS_OPENGL_ES2_QT += -lsgresource
 }
 
 contains(QMAKE_HOST.os,Windows) {
diff --git a/src/gui/inputmethod/qcoefepinputcontext_s60.cpp b/src/gui/inputmethod/qcoefepinputcontext_s60.cpp
index f8d7e28..5fe25b2 100644
--- a/src/gui/inputmethod/qcoefepinputcontext_s60.cpp
+++ b/src/gui/inputmethod/qcoefepinputcontext_s60.cpp
@@ -54,6 +54,7 @@
 
 #include <fepitfr.h>
 #include <hal.h>
+#include <e32property.h>
 
 #include <limits.h>
 // You only find these enumerations on SDK 5 onwards, so we need to provide our own
@@ -72,6 +73,10 @@
 // EAknEditorFlagEnablePartialScreen is only valid from Sym^3 onwards.
 #define QT_EAknEditorFlagEnablePartialScreen 0x200000
 
+// Properties to detect VKB status from AknFepInternalPSKeys.h
+#define QT_EPSUidAknFep 0x100056de
+#define QT_EAknFepTouchInputActive 0x00000004
+
 QT_BEGIN_NAMESPACE
 
 Q_GUI_EXPORT void qt_s60_setPartialScreenInputMode(bool enable)
@@ -312,28 +317,46 @@ bool QCoeFepInputContext::filterEvent(const QEvent *event)
         return false;
 
     if (event->type() == QEvent::RequestSoftwareInputPanel) {
-        // Notify S60 that we want the virtual keyboard to show up.
-        QSymbianControl *sControl;
-        sControl = focusWidget()->effectiveWinId()->MopGetObject(sControl);
-        Q_ASSERT(sControl);
-
-        // The FEP UI temporarily steals focus when it shows up the first time, causing
-        // all sorts of weird effects on the focused widgets. Since it will immediately give
-        // back focus to us, we temporarily disable focus handling until the job's done.
-        if (sControl) {
-            sControl->setIgnoreFocusChanged(true);
+        // Only request virtual keyboard if it is not yet active or if this is the first time
+        // panel is requested for this application.
+        static bool firstTime = true;
+        int vkbActive = 0;
+
+        if (firstTime) {
+            // Sometimes the global QT_EAknFepTouchInputActive value can be left incorrect at
+            // application exit if the application is exited when input panel is active.
+            // Therefore we always want to open the panel the first time application requests it.
+            firstTime = false;
+        } else {
+            const TUid KPSUidAknFep = {QT_EPSUidAknFep};
+            // No need to check for return value, as vkbActive stays zero in that case
+            RProperty::Get(KPSUidAknFep, QT_EAknFepTouchInputActive, vkbActive);
         }
 
-        ensureInputCapabilitiesChanged();
-        m_fepState->ReportAknEdStateEventL(MAknEdStateObserver::QT_EAknActivatePenInputRequest);
+        if (!vkbActive) {
+            // Notify S60 that we want the virtual keyboard to show up.
+            QSymbianControl *sControl;
+            sControl = focusWidget()->effectiveWinId()->MopGetObject(sControl);
+            Q_ASSERT(sControl);
+
+            // The FEP UI temporarily steals focus when it shows up the first time, causing
+            // all sorts of weird effects on the focused widgets. Since it will immediately give
+            // back focus to us, we temporarily disable focus handling until the job's done.
+            if (sControl) {
+                sControl->setIgnoreFocusChanged(true);
+            }
+
+            ensureInputCapabilitiesChanged();
+            m_fepState->ReportAknEdStateEventL(MAknEdStateObserver::QT_EAknActivatePenInputRequest);
 
-        if (sControl) {
-            sControl->setIgnoreFocusChanged(false);
+            if (sControl) {
+                sControl->setIgnoreFocusChanged(false);
+            }
+            //If m_pointerHandler has already been set, it means that fep inline editing is in progress.
+            //When this is happening, do not filter out pointer events.
+            if (!m_pointerHandler)
+                return true;
         }
-        //If m_pointerHandler has already been set, it means that fep inline editing is in progress.
-        //When this is happening, do not filter out pointer events.
-        if (!m_pointerHandler)
-            return true;
     }
 
     return false;
diff --git a/src/gui/styles/qs60style.cpp b/src/gui/styles/qs60style.cpp
index b0ea0d1..b47b4c8 100644
--- a/src/gui/styles/qs60style.cpp
+++ b/src/gui/styles/qs60style.cpp
@@ -3345,6 +3345,12 @@ QIcon QS60Style::standardIconImplementation(StandardPixmap standardIcon,
             QS60StylePrivate::SF_StateEnabled :
             QS60StylePrivate::SF_StateDisabled;
 
+    int metric = PM_ToolBarIconSize;
+#if defined(Q_WS_S60)
+    //Support version specific standard icons only with Symbian/S60 platform.
+    QSysInfo::S60Version versionSupport = QSysInfo::SV_S60_Unknown;
+#endif
+
     switch(standardIcon) {
         case SP_MessageBoxWarning:
             // By default, S60 messagebox icons have 4:3 ratio. Value is from S60 LAF documentation.
@@ -3415,11 +3421,353 @@ QIcon QS60Style::standardIconImplementation(StandardPixmap standardIcon,
             adjustedFlags |= QS60StylePrivate::SF_PointEast;
             part = QS60StyleEnums::SP_QgnIndiSubmenu;
             break;
+        case SP_TitleBarMenuButton:
+#if defined(Q_WS_S60)
+            versionSupport = QSysInfo::SV_S60_5_3;
+#endif
+            metric = PM_SmallIconSize;
+            part = QS60StyleEnums::SP_QtgToolBarOptions;
+            break;
+        case SP_DirHomeIcon:
+            metric = PM_SmallIconSize;
+            part = QS60StyleEnums::SP_QgnIndiBrowserTbHome;
+            break;
+        case SP_BrowserReload:
+            metric = PM_SmallIconSize;
+            part = QS60StyleEnums::SP_QgnIndiBrowserTbReload;
+            break;
+        case SP_BrowserStop:
+            metric = PM_SmallIconSize;
+            part = QS60StyleEnums::SP_QgnIndiBrowserTbStop;
+            break;
+#if defined(Q_WS_S60)
+        case SP_MediaPlay:
+            versionSupport = QSysInfo::SV_S60_5_3;
+            metric = PM_SmallIconSize;
+            part = QS60StyleEnums::SP_QtgToolBarPlay;
+            break;
+        case SP_MediaStop:
+            versionSupport = QSysInfo::SV_S60_5_3;
+            metric = PM_SmallIconSize;
+            part = QS60StyleEnums::SP_QtgToolBarStop;
+            break;
+        case SP_MediaPause:
+            versionSupport = QSysInfo::SV_S60_5_3;
+            metric = PM_SmallIconSize;
+            part = QS60StyleEnums::SP_QtgToolBarPause;
+            break;
+        case SP_MediaSkipForward:
+            versionSupport = QSysInfo::SV_S60_5_3;
+            metric = PM_SmallIconSize;
+            part = QS60StyleEnums::SP_QtgToolBarNext;
+            break;
+        case SP_MediaSkipBackward:
+            versionSupport = QSysInfo::SV_S60_5_3;
+            metric = PM_SmallIconSize;
+            part = QS60StyleEnums::SP_QtgToolBarPrevious;
+            break;
+        case SP_MediaSeekForward:
+            versionSupport = QSysInfo::SV_S60_5_3;
+            metric = PM_SmallIconSize;
+            part = QS60StyleEnums::SP_QtgToolBarForward;
+            break;
+        case SP_MediaSeekBackward:
+            versionSupport = QSysInfo::SV_S60_5_3;
+            metric = PM_SmallIconSize;
+            part = QS60StyleEnums::SP_QtgToolBarRewind;
+            break;
+#endif
+// Custom icons
+        case SP_CustomToolBarAdd:
+            part = QS60StyleEnums::SP_QtgToolBarAdd;
+            break;
+        case SP_CustomToolBarAddDetail:
+            part = QS60StyleEnums::SP_QtgToolBarAddDetail;
+            break;
+        case SP_CustomToolBarAgain:
+            part = QS60StyleEnums::SP_QtgToolBarAgain;
+            break;
+        case SP_CustomToolBarAgenda:
+            part = QS60StyleEnums::SP_QtgToolBarAgenda;
+            break;
+        case SP_CustomToolBarAudioOff:
+            part = QS60StyleEnums::SP_QtgToolBarAudioOff;
+            break;
+        case SP_CustomToolBarAudioOn:
+            part = QS60StyleEnums::SP_QtgToolBarAudioOn;
+            break;
+        case SP_CustomToolBarBack:
+            part = QS60StyleEnums::SP_QtgToolBarBack;
+            break;
+        case SP_CustomToolBarBluetoothOff:
+            part = QS60StyleEnums::SP_QtgToolBarBluetoothOff;
+            break;
+        case SP_CustomToolBarBluetoothOn:
+            part = QS60StyleEnums::SP_QtgToolBarBluetoothOn;
+            break;
+        case SP_CustomToolBarCancel:
+            part = QS60StyleEnums::SP_QtgToolBarCancel;
+            break;
+        case SP_CustomToolBarDelete:
+            part = QS60StyleEnums::SP_QtgToolBarDelete;
+            break;
+        case SP_CustomToolBarDone:
+            part = QS60StyleEnums::SP_QtgToolBarDone;
+            break;
+        case SP_CustomToolBarEdit:
+            part = QS60StyleEnums::SP_QtgToolBarEdit;
+            break;
+        case SP_CustomToolBarEmailSend:
+            part = QS60StyleEnums::SP_QtgToolBarEmailSend;
+            break;
+        case SP_CustomToolBarEmergencyCall:
+            part = QS60StyleEnums::SP_QtgToolBarEmergencyCall;
+            break;
+        case SP_CustomToolBarFavouriteAdd:
+            part = QS60StyleEnums::SP_QtgToolBarFavouriteAdd;
+            break;
+        case SP_CustomToolBarFavouriteRemove:
+            part = QS60StyleEnums::SP_QtgToolBarFavouriteRemove;
+            break;
+        case SP_CustomToolBarFavourites:
+            part = QS60StyleEnums::SP_QtgToolBarFavourites;
+            break;
+        case SP_CustomToolBarGo:
+            part = QS60StyleEnums::SP_QtgToolBarGo;
+            break;
+        case SP_CustomToolBarHome:
+            part = QS60StyleEnums::SP_QtgToolBarHome;
+            break;
+        case SP_CustomToolBarList:
+            part = QS60StyleEnums::SP_QtgToolBarList;
+            break;
+        case SP_CustomToolBarLock:
+            part = QS60StyleEnums::SP_QtgToolBarLock;
+            break;
+        case SP_CustomToolBarLogs:
+            part = QS60StyleEnums::SP_QtgToolBarLogs;
+            break;
+        case SP_CustomToolBarMenu:
+            part = QS60StyleEnums::SP_QtgToolBarMenu;
+            break;
+        case SP_CustomToolBarNewContact:
+            part = QS60StyleEnums::SP_QtgToolBarNewContact;
+            break;
+        case SP_CustomToolBarNewGroup:
+            part = QS60StyleEnums::SP_QtgToolBarNewGroup;
+            break;
+        case SP_CustomToolBarNowPlay:
+            part = QS60StyleEnums::SP_QtgToolBarNowPlay;
+            break;
+        case SP_CustomToolBarOptions:
+            part = QS60StyleEnums::SP_QtgToolBarOptions;
+            break;
+        case SP_CustomToolBarOther:
+            part = QS60StyleEnums::SP_QtgToolBarOther;
+            break;
+        case SP_CustomToolBarOvi:
+            part = QS60StyleEnums::SP_QtgToolBarOvi;
+            break;
+        case SP_CustomToolBarRead:
+            part = QS60StyleEnums::SP_QtgToolBarRead;
+            break;
+        case SP_CustomToolBarRefresh:
+            part = QS60StyleEnums::SP_QtgToolBarRefresh;
+            break;
+        case SP_CustomToolBarRemoveDetail:
+            part = QS60StyleEnums::SP_QtgToolBarRemoveDetail;
+            break;
+        case SP_CustomToolBarRepeat:
+            part = QS60StyleEnums::SP_QtgToolBarRepeat;
+            break;
+        case SP_CustomToolBarRepeatOff:
+            part = QS60StyleEnums::SP_QtgToolBarRepeatOff;
+            break;
+        case SP_CustomToolBarRepeatOne:
+            part = QS60StyleEnums::SP_QtgToolBarRepeatOne;
+            break;
+        case SP_CustomToolBarSearch:
+            part = QS60StyleEnums::SP_QtgToolBarSearch;
+            break;
+        case SP_CustomToolBarSelfTimer:
+            part = QS60StyleEnums::SP_QtgToolBarSelfTimer;
+            break;
+        case SP_CustomToolBarSend:
+            part = QS60StyleEnums::SP_QtgToolBarSend;
+            break;
+        case SP_CustomToolBarShare:
+            part = QS60StyleEnums::SP_QtgToolBarShare;
+            break;
+        case SP_CustomToolBarShift:
+            part = QS60StyleEnums::SP_QtgToolBarShift;
+            break;
+        case SP_CustomToolBarShuffle:
+            part = QS60StyleEnums::SP_QtgToolBarShuffle;
+            break;
+        case SP_CustomToolBarShuffleOff:
+            part = QS60StyleEnums::SP_QtgToolBarShuffleOff;
+            break;
+        case SP_CustomToolBarSignalOff:
+            part = QS60StyleEnums::SP_QtgToolBarSignalOff;
+            break;
+        case SP_CustomToolBarSignalOn:
+            part = QS60StyleEnums::SP_QtgToolBarSignalOn;
+            break;
+        case SP_CustomToolBarSync:
+            part = QS60StyleEnums::SP_QtgToolBarSync;
+            break;
+        case SP_CustomToolBarUnlock:
+            part = QS60StyleEnums::SP_QtgToolBarUnlock;
+            break;
+        case SP_CustomToolBarUnmark:
+            part = QS60StyleEnums::SP_QtgToolBarUnmark;
+            break;
+        case SP_CustomToolBarView:
+            part = QS60StyleEnums::SP_QtgToolBarView;
+            break;
+        case SP_CustomToolBarWlanOff:
+            part = QS60StyleEnums::SP_QtgToolBarWlanOff;
+            break;
+        case SP_CustomToolBarWlanOn:
+            part = QS60StyleEnums::SP_QtgToolBarWlanOn;
+            break;
+#if defined(Q_WS_S60)
+        case SP_CustomCameraCaptureButton:
+            versionSupport = QSysInfo::SV_S60_5_2;
+            part = QS60StyleEnums::SP_QtgGrafCameraButtonCaptureNormal;
+            break;
+        case SP_CustomCameraCaptureButtonPressed:
+            versionSupport = QSysInfo::SV_S60_5_2;
+            part = QS60StyleEnums::SP_QtgGrafCameraButtonCapturePressed;
+            break;
+        case SP_CustomCameraPauseButton:
+            versionSupport = QSysInfo::SV_S60_5_2;
+            part = QS60StyleEnums::SP_QtgGrafCameraButtonPauseNormal;
+            break;
+        case SP_CustomCameraPauseButtonPressed:
+            versionSupport = QSysInfo::SV_S60_5_2;
+            part = QS60StyleEnums::SP_QtgGrafCameraButtonPausePressed;
+            break;
+        case SP_CustomCameraPlayButton:
+            versionSupport = QSysInfo::SV_S60_5_2;
+            part = QS60StyleEnums::SP_QtgGrafCameraButtonPlayNormal;
+            break;
+        case SP_CustomCameraPlayButtonPressed:
+            versionSupport = QSysInfo::SV_S60_5_2;
+            part = QS60StyleEnums::SP_QtgGrafCameraButtonPlayPressed;
+            break;
+        case SP_CustomCameraRecButton:
+            versionSupport = QSysInfo::SV_S60_5_2;
+            part = QS60StyleEnums::SP_QtgGrafCameraButtonRecNormal;
+            break;
+        case SP_CustomCameraRecButtonPressed:
+            versionSupport = QSysInfo::SV_S60_5_2;
+            part = QS60StyleEnums::SP_QtgGrafCameraButtonRecPressed;
+            break;
+        case SP_CustomCameraStopButton:
+            versionSupport = QSysInfo::SV_S60_5_2;
+            part = QS60StyleEnums::SP_QtgGrafCameraButtonStopNormal;
+            break;
+        case SP_CustomCameraStopButtonPressed:
+            versionSupport = QSysInfo::SV_S60_5_2;
+            part = QS60StyleEnums::SP_QtgGrafCameraButtonStopPressed;
+            break;
+#endif
+        case SP_CustomTabAll:
+            part = QS60StyleEnums::SP_QtgTabAll;
+            break;
+        case SP_CustomTabArtist:
+            part = QS60StyleEnums::SP_QtgTabArtist;
+            break;
+        case SP_CustomTabFavourite:
+            part = QS60StyleEnums::SP_QtgTabFavourite;
+            break;
+        case SP_CustomTabGenre:
+            part = QS60StyleEnums::SP_QtgTabGenre;
+            break;
+        case SP_CustomTabLanguage:
+            part = QS60StyleEnums::SP_QtgTabLanguage;
+            break;
+        case SP_CustomTabMusicAlbum:
+            part = QS60StyleEnums::SP_QtgTabMusicAlbum;
+            break;
+        case SP_CustomTabPhotosAlbum:
+            part = QS60StyleEnums::SP_QtgTabPhotosAlbum;
+            break;
+        case SP_CustomTabPhotosAll:
+            part = QS60StyleEnums::SP_QtgTabPhotosAll;
+            break;
+        case SP_CustomTabPlaylist:
+            part = QS60StyleEnums::SP_QtgTabPlaylist;
+            break;
+        case SP_CustomTabServices:
+            part = QS60StyleEnums::SP_QtgTabServices;
+            break;
+        case SP_CustomTabSongs:
+            part = QS60StyleEnums::SP_QtgTabSongs;
+            break;
+        case SP_CustomTabVideos:
+            part = QS60StyleEnums::SP_QtgTabVideos;
+            break;
+        case SP_CustomToolBarEditDisabled:
+            part = QS60StyleEnums::SP_QtgToolBarEditDisabled;
+            break;
+        case SP_CustomToolBarImageTools:
+            part = QS60StyleEnums::SP_QtgToolBarImageTools;
+            break;
+        case SP_CustomToolBarNextFrame:
+            part = QS60StyleEnums::SP_QtgToolBarNextFrame;
+            break;
+        case SP_CustomToolBarPreviousFrame:
+            part = QS60StyleEnums::SP_QtgToolBarPreviousFrame;
+            break;
+        case SP_CustomToolBarRedoDisabled:
+            part = QS60StyleEnums::SP_QtgToolBarRedoDisabled;
+            break;
+        case SP_CustomToolBarRedo:
+            part = QS60StyleEnums::SP_QtgToolBarRedo;
+            break;
+        case SP_CustomToolBarRemoveDisabled:
+            part = QS60StyleEnums::SP_QtgToolBarRemoveDisabled;
+            break;
+        case SP_CustomToolBarSearchDisabled:
+            part = QS60StyleEnums::SP_QtgToolBarSearchDisabled;
+            break;
+        case SP_CustomToolBarSelectContent:
+            part = QS60StyleEnums::SP_QtgToolBarSelectContent;
+            break;
+        case SP_CustomToolBarSendDimmed:
+            part = QS60StyleEnums::SP_QtgToolBarSendDimmed;
+            break;
+        case SP_CustomToolBarTools:
+            part = QS60StyleEnums::SP_QtgToolBarTools;
+            break;
+        case SP_CustomToolBarTrim:
+            part = QS60StyleEnums::SP_QtgToolBarTrim;
+            break;
         default:
             return QCommonStyle::standardIconImplementation(standardIcon, option, widget);
     }
+
+#if defined(Q_WS_S60)
+    //If new custom standardIcon is missing version information, assume S60 5.3.
+    if (standardIcon & QStyle::SP_CustomBase) {
+        if (versionSupport == QSysInfo::SV_Unknown)
+            versionSupport = QSysInfo::SV_S60_5_3;
+        metric = PM_SmallIconSize;
+    }
+
+    // Toolbar icons are only available from SV_S60_5_3 onwards. Use common style for earlier releases.
+    if ((versionSupport != QSysInfo::SV_Unknown) && QSysInfo::s60Version() < versionSupport) {
+        return QCommonStyle::standardIconImplementation(standardIcon, option, widget);
+    }
+#else
+    if (standardIcon >= SP_CustomToolBarAdd)
+        metric = PM_SmallIconSize;
+#endif
+
     const QS60StylePrivate::SkinElementFlags flags = adjustedFlags;
-    const int iconDimension = QS60StylePrivate::pixelMetric(PM_ToolBarIconSize);
+    const int iconDimension = QS60StylePrivate::pixelMetric(metric);
     const QRect iconSize = (!option) ? 
         QRect(0, 0, iconDimension * iconWidthMultiplier, iconDimension * iconHeightMultiplier) : option->rect;
     const QPixmap cachedPixMap(QS60StylePrivate::cachedPart(part, iconSize.size(), 0, flags));
diff --git a/src/gui/styles/qs60style.h b/src/gui/styles/qs60style.h
index 8ec5eb9..0e76cf2 100644
--- a/src/gui/styles/qs60style.h
+++ b/src/gui/styles/qs60style.h
@@ -62,6 +62,94 @@ enum {
     PM_CbaIconHeight
     };
 
+enum {
+    SP_CustomToolBarAdd = QStyle::SP_CustomBase + 1,
+    SP_CustomToolBarAddDetail,
+    SP_CustomToolBarAgain,
+    SP_CustomToolBarAgenda,
+    SP_CustomToolBarAudioOff,
+    SP_CustomToolBarAudioOn,
+    SP_CustomToolBarBack,
+    SP_CustomToolBarBluetoothOff,
+    SP_CustomToolBarBluetoothOn,
+    SP_CustomToolBarCancel,
+    SP_CustomToolBarDelete,
+    SP_CustomToolBarDone,
+    SP_CustomToolBarEdit,
+    SP_CustomToolBarEditDisabled,
+    SP_CustomToolBarEmailSend,
+    SP_CustomToolBarEmergencyCall,
+    SP_CustomToolBarFavouriteAdd,
+    SP_CustomToolBarFavouriteRemove,
+    SP_CustomToolBarFavourites,
+    SP_CustomToolBarGo,
+    SP_CustomToolBarHome,
+    SP_CustomToolBarImageTools,
+    SP_CustomToolBarList,
+    SP_CustomToolBarLock,
+    SP_CustomToolBarLogs,
+    SP_CustomToolBarMenu,
+    SP_CustomToolBarNewContact,
+    SP_CustomToolBarNewGroup,
+    SP_CustomToolBarNextFrame,
+    SP_CustomToolBarNowPlay,
+    SP_CustomToolBarOptions,
+    SP_CustomToolBarOther,
+    SP_CustomToolBarOvi,
+    SP_CustomToolBarPreviousFrame,
+    SP_CustomToolBarRead,
+    SP_CustomToolBarRedoDisabled,
+    SP_CustomToolBarRedo,
+    SP_CustomToolBarRefresh,
+    SP_CustomToolBarRemoveDetail,
+    SP_CustomToolBarRemoveDisabled,
+    SP_CustomToolBarRepeat,
+    SP_CustomToolBarRepeatOff,
+    SP_CustomToolBarRepeatOne,
+    SP_CustomToolBarSearch,
+    SP_CustomToolBarSearchDisabled,
+    SP_CustomToolBarSelectContent,
+    SP_CustomToolBarSelfTimer,
+    SP_CustomToolBarSend,
+    SP_CustomToolBarSendDimmed,
+    SP_CustomToolBarShare,
+    SP_CustomToolBarShift,
+    SP_CustomToolBarShuffle,
+    SP_CustomToolBarShuffleOff,
+    SP_CustomToolBarSignalOff,
+    SP_CustomToolBarSignalOn,
+    SP_CustomToolBarSync,
+    SP_CustomToolBarTools,
+    SP_CustomToolBarTrim,
+    SP_CustomToolBarUnlock,
+    SP_CustomToolBarUnmark,
+    SP_CustomToolBarView,
+    SP_CustomToolBarWlanOff,
+    SP_CustomToolBarWlanOn,
+    SP_CustomCameraCaptureButton,
+    SP_CustomCameraCaptureButtonPressed,
+    SP_CustomCameraPauseButton,
+    SP_CustomCameraPauseButtonPressed,
+    SP_CustomCameraPlayButton,
+    SP_CustomCameraPlayButtonPressed,
+    SP_CustomCameraRecButton,
+    SP_CustomCameraRecButtonPressed,
+    SP_CustomCameraStopButton,
+    SP_CustomCameraStopButtonPressed,
+    SP_CustomTabAll,
+    SP_CustomTabArtist,
+    SP_CustomTabFavourite,
+    SP_CustomTabGenre,
+    SP_CustomTabLanguage,
+    SP_CustomTabMusicAlbum,
+    SP_CustomTabPhotosAlbum,
+    SP_CustomTabPhotosAll,
+    SP_CustomTabPlaylist,
+    SP_CustomTabServices,
+    SP_CustomTabSongs,
+    SP_CustomTabVideos
+};
+
 class QS60StylePrivate;
 
 class Q_GUI_EXPORT QS60Style : public QCommonStyle
diff --git a/src/gui/styles/qs60style_p.h b/src/gui/styles/qs60style_p.h
index 62c4b00..de3cab7 100644
--- a/src/gui/styles/qs60style_p.h
+++ b/src/gui/styles/qs60style_p.h
@@ -142,11 +142,11 @@ public:
         SP_QgnGrafNsliderMiddle,
         SP_QgnIndiCheckboxOff,
         SP_QgnIndiCheckboxOn,
-        SP_QgnIndiHlColSuper,     // Available in S60 release 3.2 and later.
-        SP_QgnIndiHlExpSuper,     // Available in S60 release 3.2 and later.
-        SP_QgnIndiHlLineBranch,   // Available in S60 release 3.2 and later.
-        SP_QgnIndiHlLineEnd,      // Available in S60 release 3.2 and later.
-        SP_QgnIndiHlLineStraight, // Available in S60 release 3.2 and later.
+        SP_QgnIndiHlColSuper,
+        SP_QgnIndiHlExpSuper,
+        SP_QgnIndiHlLineBranch,
+        SP_QgnIndiHlLineEnd,
+        SP_QgnIndiHlLineStraight,
         SP_QgnIndiMarkedAdd,
         SP_QgnIndiNaviArrowLeft,
         SP_QgnIndiNaviArrowRight,
@@ -311,6 +311,102 @@ public:
         SP_QsnFrListSideLPressed,
         SP_QsnFrListSideRPressed,
         SP_QsnFrListCenterPressed,
+        SP_QtgToolBarAdd,
+        SP_QtgToolBarAddDetail,
+        SP_QtgToolBarAgain,
+        SP_QtgToolBarAgenda,
+        SP_QtgToolBarAudioOff,
+        SP_QtgToolBarAudioOn,
+        SP_QtgToolBarBack,
+        SP_QtgToolBarBluetoothOff,
+        SP_QtgToolBarBluetoothOn,
+        SP_QtgToolBarCancel,
+        SP_QtgToolBarDelete,
+        SP_QtgToolBarDetails,
+        SP_QtgToolBarDone,
+        SP_QtgToolBarEdit,
+        SP_QtgToolBarEditDisabled,
+        SP_QtgToolBarEmailSend,
+        SP_QtgToolBarEmergencyCall,
+        SP_QtgToolBarFavouriteAdd,
+        SP_QtgToolBarFavouriteRemove,
+        SP_QtgToolBarFavourites,
+        SP_QtgToolBarForward,
+        SP_QtgToolBarGo,
+        SP_QtgToolBarHome,
+        SP_QtgToolBarImageTools,
+        SP_QtgToolBarList,
+        SP_QtgToolBarLock,
+        SP_QtgToolBarLogs,
+        SP_QtgToolBarMenu,
+        SP_QtgToolBarNewContact,
+        SP_QtgToolBarNewGroup,
+        SP_QtgToolBarNext,
+        SP_QtgToolBarNextFrame,
+        SP_QtgToolBarNowPlay,
+        SP_QtgToolBarOptions,
+        SP_QtgToolBarOther,
+        SP_QtgToolBarOvi,
+        SP_QtgToolBarPause,
+        SP_QtgToolBarPlay,
+        SP_QtgToolBarPrevious,
+        SP_QtgToolBarPreviousFrame,
+        SP_QtgToolBarRead,
+        SP_QtgToolBarRedo,
+        SP_QtgToolBarRedoDisabled,
+        SP_QtgToolBarRefresh,
+        SP_QtgToolBarRemoveDetail,
+        SP_QtgToolBarRemoveDisabled,
+        SP_QtgToolBarRepeat,
+        SP_QtgToolBarRepeatOff,
+        SP_QtgToolBarRepeatOne,
+        SP_QtgToolBarRewind,
+        SP_QtgToolBarSearch,
+        SP_QtgToolBarSearchDisabled,
+        SP_QtgToolBarSelectContent,
+        SP_QtgToolBarSelfTimer,
+        SP_QtgToolBarSend,
+        SP_QtgToolBarSendDimmed,
+        SP_QtgToolBarShare,
+        SP_QtgToolBarShift,
+        SP_QtgToolBarShuffle,
+        SP_QtgToolBarShuffleOff,
+        SP_QtgToolBarSignalOff,
+        SP_QtgToolBarSignalOn,
+        SP_QtgToolBarStop,
+        SP_QtgToolBarSync,
+        SP_QtgToolBarTools,
+        SP_QtgToolBarTrim,
+        SP_QtgToolBarUnlock,
+        SP_QtgToolBarUnmark,
+        SP_QtgToolBarView,
+        SP_QtgToolBarWlanOff,
+        SP_QtgToolBarWlanOn,
+        SP_QtgGrafCameraButtonCaptureNormal,
+        SP_QtgGrafCameraButtonCapturePressed,
+        SP_QtgGrafCameraButtonPauseNormal,
+        SP_QtgGrafCameraButtonPausePressed,
+        SP_QtgGrafCameraButtonPlayNormal,
+        SP_QtgGrafCameraButtonPlayPressed,
+        SP_QtgGrafCameraButtonRecNormal,
+        SP_QtgGrafCameraButtonRecPressed,
+        SP_QtgGrafCameraButtonStopNormal,
+        SP_QtgGrafCameraButtonStopPressed,
+        SP_QtgTabAll,
+        SP_QtgTabArtist,
+        SP_QtgTabFavourite,
+        SP_QtgTabGenre,
+        SP_QtgTabLanguage,
+        SP_QtgTabMusicAlbum,
+        SP_QtgTabPhotosAlbum,
+        SP_QtgTabPhotosAll,
+        SP_QtgTabPlaylist,
+        SP_QtgTabServices,
+        SP_QtgTabSongs,
+        SP_QtgTabVideos,
+        SP_QgnIndiBrowserTbReload,
+        SP_QgnIndiBrowserTbHome,
+        SP_QgnIndiBrowserTbStop,
     };
 
     enum ColorLists {
diff --git a/src/gui/styles/qs60style_s60.cpp b/src/gui/styles/qs60style_s60.cpp
index 14fdbd3..59d5da4 100644
--- a/src/gui/styles/qs60style_s60.cpp
+++ b/src/gui/styles/qs60style_s60.cpp
@@ -413,6 +413,106 @@ const partMapEntry QS60StyleModeSpecifics::m_partMap[] = {
     /* SP_QsnFrListSideLPressed */       {KAknsIIDQsnFrListSideL,       ENoDraw,     ES60_3_X,    EAknsMajorSkin, 0x2691},
     /* SP_QsnFrListSideRPressed */       {KAknsIIDQsnFrListSideR,       ENoDraw,     ES60_3_X,    EAknsMajorSkin, 0x2692},
     /* SP_QsnFrListCenterPressed */      {KAknsIIDQsnFrListCenter,      ENoDraw,     ES60_3_X,    EAknsMajorSkin, 0x2693},
+
+    /* SP_QtgToolBarAdd */               {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x27c0}, //KAknsIIDQtgToolbarAdd
+    /* SP_QtgToolBarAddDetail */         {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2778}, //KAknsIIDQtgToolbarAddDetail
+    /* SP_QtgToolbarAgain */             {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x271a}, //KAknsIIDQtgToolbarAgain
+    /* SP_QtgToolBarAgenda */            {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x281a}, //KAknsIIDQtgToolbarAgenda
+    /* SP_QtgToolBarAudioOff */          {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2751}, //KAknsIIDQtgToolbarAudioOff
+    /* SP_QtgToolBarAudioOn */           {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2752}, //KAknsIIDQtgToolbarAudioOn
+    /* SP_CustomToolBarBack */           {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x271b}, //KAknsIIDQtgToolbarBack
+    /* SP_QtgToolBarBluetoothOff */      {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2753}, //KAknsIIDQtgToolbarBluetoothOff
+    /* SP_QtgToolBarBluetoothOn */       {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2754}, //KAknsIIDQtgToolbarBluetoothOn
+    /* SP_QtgToolBarCancel */            {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2895}, //KAknsIIDQtgToolbarCancel
+    /* SP_QtgToolBarDelete */            {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2755}, //KAknsIIDQtgToolbarDelete
+    /* SP_QtgToolBarDetails */           {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x271e}, //KAknsIIDQtgToolbarDetails
+    /* SP_QtgToolBarDone */              {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x271f}, //KAknsIIDQtgToolbarDone
+    /* SP_QtgToolBarEdit */              {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2720}, //KAknsIIDQtgToolbarEdit
+    /* SP_QtgToolBarEditDisabled */      {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2946}, //KAknsIIDQtgToolbarEditDisabled
+    /* SP_QtgToolBarEmailSend */         {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x292f}, //KAknsIIDQtgToolbarEmailSend
+    /* SP_QtgToolBarEmergencyCall */     {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2721}, //KAknsIIDQtgToolbarEmergencyCall
+    /* SP_QtgToolBarFavouriteAdd */      {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x28ed}, //KAknsIIDQtgToolbarFavouriteAdd
+    /* SP_QtgToolBarFavouriteRemove */   {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x28ee}, //KAknsIIDQtgToolbarFavouriteRemove
+    /* SP_QtgToolBarFavourites */        {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x28b8}, //KAknsIIDQtgToolbarFavourites
+    /* SP_QtgToolBarForward */           {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x281b}, //KAknsIIDQtgToolbarForward
+    /* SP_QtgToolBarGo */                {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2930}, //KAknsIIDQtgToolbarGo
+    /* SP_QtgToolBarHome */              {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2722}, //KAknsIIDQtgToolbarHome
+    /* SP_QtgToolBarImageTools */        {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2947}, //KAknsIIDQtgToolbarImageTools
+    /* SP_QtgToolBarList */              {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x28b9}, //KAknsIIDQtgToolbarList
+    /* SP_QtgToolBarLock */              {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2723}, //KAknsIIDQtgToolbarLock
+    /* SP_QtgToolBarLogs */              {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x281c}, //KAknsIIDQtgToolbarLogs
+    /* SP_QtgToolBarMenu */              {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2724}, //KAknsIIDQtgToolbarMenu
+    /* SP_QtgToolBarNewContact */        {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2779}, //KAknsIIDQtgToolbarNewContact
+    /* SP_QtgToolBarNewGroup */          {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x277a}, //KAknsIIDQtgToolbarNewGroup
+    /* SP_QtgToolBarNext */              {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x281d}, //KAknsIIDQtgToolbarNext
+    /* SP_QtgToolBarNextFrame */         {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2981}, //KAknsIIDQtgToolbarNextFrame
+    /* SP_QtgToolBarNowPlay */           {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x28ef}, //KAknsIIDQtgToolbarNowplay
+    /* SP_QtgToolBarOptions */           {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2725}, //KAknsIIDQtgToolbarOptions
+    /* SP_QtgToolBarOther */             {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2726}, //KAknsIIDQtgToolbarOther
+    /* SP_QtgToolBarOvi */               {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2931}, //KAknsIIDQtgToolbarOvi
+    /* SP_QtgToolBarPause */             {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2727}, //KAknsIIDQtgToolbarPause
+    /* SP_QtgToolBarPlay */              {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2728}, //KAknsIIDQtgToolbarPlay
+    /* SP_QtgToolBarPrevious */          {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x281e}, //KAknsIIDQtgToolbarPrevious
+    /* SP_QtgToolBarPreviousFrame */     {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2982}, //KAknsIIDQtgToolbarPreviousFrame
+    /* SP_QtgToolBarRead */              {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2729}, //KAknsIIDQtgToolbarRead
+    /* SP_QtgToolBarRedo */              {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2948}, //KAknsIIDQtgToolbarRedo
+    /* SP_QtgToolBarRedoDisabled */      {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2949}, //KAknsIIDQtgToolbarRedoDisabled
+    /* SP_QtgToolBarRefresh */           {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2932}, //KAknsIIDQtgToolbarRefresh
+    /* SP_QtgToolBarRemoveDetail */      {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x277b}, //KAknsIIDQtgToolbarRemoveDetail
+    /* SP_QtgToolBarRemoveDisabled */    {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x294a}, //KAknsIIDQtgToolbarRemoveDisabled
+    /* SP_QtgToolBarRepeat */            {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x281f}, //KAknsIIDQtgToolbarRepeat
+    /* SP_QtgToolBarRepeatOff */         {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2820}, //KAknsIIDQtgToolbarRepeatOff
+    /* SP_QtgToolBarRepeatOne */         {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2821}, //KAknsIIDQtgToolbarRepeatOne
+    /* SP_QtgToolBarRewind */            {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2822}, //KAknsIIDQtgToolbarRewind
+    /* SP_QtgToolBarSearch */            {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x272a}, //KAknsIIDQtgToolbarSearch
+    /* SP_QtgToolBarSearchDisabled */    {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x294b}, //KAknsIIDQtgToolbarSearchDisabled
+    /* SP_QtgToolBarSelectContent */     {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x294c}, //KAknsIIDQtgToolbarSelectContent
+    /* SP_QtgToolBarSelfTimer */         {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2756}, //KAknsIIDQtgToolbarSelfTimer
+    /* SP_QtgToolBarSend */              {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x272b}, //KAknsIIDQtgToolbarSend
+    /* SP_QtgToolBarSendDimmed */        {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x29b0}, //KAknsIIDQtgToolbarSendDimmed
+    /* SP_QtgToolBarShare */             {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2823}, //KAknsIIDQtgToolbarShare
+    /* SP_QtgToolBarShift */             {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x272c}, //KAknsIIDQtgToolbarShift
+    /* SP_QtgToolBarShuffle */           {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2824}, //KAknsIIDQtgToolbarShuffle
+    /* SP_QtgToolBarShuffleOff */        {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2825}, //KAknsIIDQtgToolbarShuffleOff
+    /* SP_QtgToolBarSignalOff */         {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2757}, //KAknsIIDQtgToolbarSignalOff
+    /* SP_QtgToolBarSignalOn */          {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2758}, //KAknsIIDQtgToolbarSignalOn
+    /* SP_QtgToolBarStop */              {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x272d}, //KAknsIIDQtgToolbarStop
+    /* SP_QtgToolBarSync */              {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2894}, //KAknsIIDQtgToolbarSync
+    /* SP_QtgToolBarTools */             {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2983}, //KAknsIIDQtgToolbarTools
+    /* SP_QtgToolBarTrim */              {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2954}, //KAknsIIDQtgToolbarTrim
+    /* SP_QtgToolBarUnlock */            {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x272e}, //KAknsIIDQtgToolbarUnlock
+    /* SP_QtgToolBarUnmark */            {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x272f}, //KAknsIIDQtgToolbarUnmark
+    /* SP_QtgToolBarView */              {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2730}, //KAknsIIDQtgToolbarView
+    /* SP_QtgToolBarWlanOff */           {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2759}, //KAknsIIDQtgToolbarWlanOff
+    /* SP_QtgToolBarWlanOn */            {KAknsIIDNone,                 EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x275a}, //KAknsIIDQtgToolbarWlanOn
+
+    /* SP_QtgGrafCameraButtonCaptureNormal */   {KAknsIIDNone,  EDrawIcon,   ES60_Pre52,  EAknsMajorGeneric, 0x2743}, //KAknsIIDQtgGrafCameraButtonCaptureNormal (already in 9.2)
+    /* SP_QtgGrafCameraButtonCapturePressed */  {KAknsIIDNone,  EDrawIcon,   ES60_Pre52,  EAknsMajorGeneric, 0x2744}, //KAknsIIDQtgGrafCameraButtonCapturePressed
+    /* SP_QtgGrafCameraButtonPauseNormal */     {KAknsIIDNone,  EDrawIcon,   ES60_Pre52,  EAknsMajorGeneric, 0x2745}, //KAknsIIDQtgGrafCameraButtonPauseNormal
+    /* SP_QtgGrafCameraButtonPausePressed */    {KAknsIIDNone,  EDrawIcon,   ES60_Pre52,  EAknsMajorGeneric, 0x2746}, //KAknsIIDQtgGrafCameraButtonPausePressed
+    /* SP_QtgGrafCameraButtonPlayNormal */      {KAknsIIDNone,  EDrawIcon,   ES60_Pre52,  EAknsMajorGeneric, 0x2747}, //KAknsIIDQtgGrafCameraButtonPlayNormal
+    /* SP_QtgGrafCameraButtonPlayPressed */     {KAknsIIDNone,  EDrawIcon,   ES60_Pre52,  EAknsMajorGeneric, 0x2748}, //KAknsIIDQtgGrafCameraButtonPlayPressed
+    /* SP_QtgGrafCameraButtonRecNormal */       {KAknsIIDNone,  EDrawIcon,   ES60_Pre52,  EAknsMajorGeneric, 0x2749}, //KAknsIIDQtgGrafCameraButtonRecNormal
+    /* SP_QtgGrafCameraButtonRecPressed */      {KAknsIIDNone,  EDrawIcon,   ES60_Pre52,  EAknsMajorGeneric, 0x274a}, //KAknsIIDQtgGrafCameraButtonRecPressed
+    /* SP_QtgGrafCameraButtonStopNormal */      {KAknsIIDNone,  EDrawIcon,   ES60_Pre52,  EAknsMajorGeneric, 0x274b}, //KAknsIIDQtgGrafCameraButtonStopNormal
+    /* SP_QtgGrafCameraButtonStopPressed */     {KAknsIIDNone,  EDrawIcon,   ES60_Pre52,  EAknsMajorGeneric, 0x274c}, //KAknsIIDQtgGrafCameraButtonStopPressed
+
+    /* SP_QtgTabAll */                          {KAknsIIDNone,  EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2851}, //KAknsIIDQtgTabAll
+    /* SP_QtgTabArtist */                       {KAknsIIDNone,  EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x288f}, //KAknsIIDQtgTabArtist
+    /* SP_QtgTabFavourite */                    {KAknsIIDNone,  EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x28eb}, //KAknsIIDQtgTabFavourite
+    /* SP_QtgTabGenre */                        {KAknsIIDNone,  EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2890}, //KAknsIIDQtgTabGenre
+    /* SP_QtgTabLanguage */                     {KAknsIIDNone,  EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x28ec}, //KAknsIIDQtgTabLanguage
+    /* SP_QtgTabMusicAlbum */                   {KAknsIIDNone,  EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2891}, //KAknsIIDQtgTabMusicAlbum
+    /* SP_QtgTabPhotosAlbum */                  {KAknsIIDNone,  EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2818}, //KAknsIIDQtgTabPhotosAlbum
+    /* SP_QtgTabPhotosAll */                    {KAknsIIDNone,  EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2819}, //KAknsIIDQtgTabPhotosAll
+    /* SP_QtgTabPlaylist */                     {KAknsIIDNone,  EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2892}, //KAknsIIDQtgTabPlaylist
+    /* SP_QtgTabServices */                     {KAknsIIDNone,  EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x274f}, //KAknsIIDQtgTabServices
+    /* SP_QtgTabSongs */                        {KAknsIIDNone,  EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2893}, //KAknsIIDQtgTabSongs
+    /* SP_QtgTabVideos */                       {KAknsIIDNone,  EDrawIcon,   ES60_Pre53,  EAknsMajorGeneric, 0x2750}, //KAknsIIDQtgTabVideos
+
+    /* SP_QgnIndiBrowserTbReload */             {KAknsIIDQgnIndiBrowserTbReload,   EDrawIcon,   ES60_All, -1, -1},
+    /* SP_QgnIndiBrowserTbHome */               {KAknsIIDQgnIndiBrowserTbHome,     EDrawIcon,   ES60_All, -1, -1},
+    /* SP_QgnIndiBrowserTbStop */               {KAknsIIDQgnIndiBrowserTbStop,     EDrawIcon,   ES60_All, -1, -1},
 };
 
 QPixmap QS60StyleModeSpecifics::skinnedGraphics(
diff --git a/src/opengl/qgl.cpp b/src/opengl/qgl.cpp
index 9520b2b..cedccaa 100644
--- a/src/opengl/qgl.cpp
+++ b/src/opengl/qgl.cpp
@@ -6102,6 +6102,7 @@ void QGLTexture::freeTexture()
     }
 
     id = 0;
+    boundPixmap = 0;
     boundKey = 0;
 }
 #endif
diff --git a/src/opengl/qgl_symbian.cpp b/src/opengl/qgl_symbian.cpp
index 21671a6..b8e5c22 100644
--- a/src/opengl/qgl_symbian.cpp
+++ b/src/opengl/qgl_symbian.cpp
@@ -40,7 +40,6 @@
 ****************************************************************************/
 
 #include "qgl.h"
-#include <fbs.h>
 #include <private/qt_s60_p.h>
 #include <private/qpixmap_raster_symbian_p.h>
 #include <private/qimagepixmapcleanuphooks_p.h>
@@ -55,7 +54,7 @@
 #include "qpixmapdata_gl_p.h"
 #include "qgltexturepool_p.h"
 #include "qcolormap.h"
-#include <QDebug>
+
 
 QT_BEGIN_NAMESPACE
 
@@ -73,7 +72,7 @@ QT_BEGIN_NAMESPACE
 #endif
 #endif
 
-extern int qt_gl_pixmap_serial;
+Q_OPENGL_EXPORT extern QGLWidget* qt_gl_share_widget();
 
 /*
     QGLTemporaryContext implementation
@@ -266,6 +265,11 @@ void QGLWidget::resizeEvent(QResizeEvent *)
     if (!isValid())
         return;
 
+    // Shared widget can ignore resize events which
+    // may happen due to orientation change
+    if (this == qt_gl_share_widget())
+        return;
+
     if (QGLContext::currentContext())
         doneCurrent();
 
@@ -378,103 +382,4 @@ void QGLWidgetPrivate::recreateEglSurface()
     eglSurfaceWindowId = currentId;
 }
 
-static inline bool knownGoodFormat(QImage::Format format)
-{
-    switch (format) {
-        case QImage::Format_RGB16: // EColor64K
-        case QImage::Format_RGB32: // EColor16MU
-        case QImage::Format_ARGB32_Premultiplied: // EColor16MAP
-            return true;
-        default:
-            return false;
-    }
-}
-
-void QGLPixmapData::fromNativeType(void* pixmap, NativeType type)
-{
-    if (type == QPixmapData::FbsBitmap) {
-        CFbsBitmap *bitmap = reinterpret_cast<CFbsBitmap *>(pixmap);
-        QSize size(bitmap->SizeInPixels().iWidth, bitmap->SizeInPixels().iHeight);
-        if (size.width() == w && size.height() == h)
-            setSerialNumber(++qt_gl_pixmap_serial);
-        resize(size.width(), size.height());
-        m_source = QVolatileImage(bitmap);
-        if (pixelType() == BitmapType) {
-            m_source.ensureFormat(QImage::Format_MonoLSB);
-        } else if (!knownGoodFormat(m_source.format())) {
-            m_source.beginDataAccess();
-            QImage::Format format = idealFormat(m_source.imageRef(), Qt::AutoColor);
-            m_source.endDataAccess(true);
-            m_source.ensureFormat(format);
-        }
-        m_hasAlpha = m_source.hasAlphaChannel();
-        m_hasFillColor = false;
-        m_dirty = true;
-
-    } else if (type == QPixmapData::VolatileImage && pixmap) {
-        // Support QS60Style in more efficient skin graphics retrieval.
-        QVolatileImage *img = static_cast<QVolatileImage *>(pixmap);
-        if (img->width() == w && img->height() == h)
-            setSerialNumber(++qt_gl_pixmap_serial);
-        resize(img->width(), img->height());
-        m_source = *img;
-        m_hasAlpha = m_source.hasAlphaChannel();
-        m_hasFillColor = false;
-        m_dirty = true;
-    } else if (type == QPixmapData::NativeImageHandleProvider && pixmap) {
-        destroyTexture();
-        nativeImageHandleProvider = static_cast<QNativeImageHandleProvider *>(pixmap);
-        // Cannot defer the retrieval, we need at least the size right away.
-        createFromNativeImageHandleProvider();
-    }
-}
-
-void* QGLPixmapData::toNativeType(NativeType type)
-{
-    if (type == QPixmapData::FbsBitmap) {
-        if (m_source.isNull())
-            m_source = QVolatileImage(w, h, QImage::Format_ARGB32_Premultiplied);
-        return m_source.duplicateNativeImage();
-    }
-    return 0;
-}
-
-bool QGLPixmapData::initFromNativeImageHandle(void *handle, const QString &type)
-{
-    if (type == QLatin1String("RSgImage")) {
-        fromNativeType(handle, QPixmapData::SgImage);
-        return true;
-    } else if (type == QLatin1String("CFbsBitmap")) {
-        fromNativeType(handle, QPixmapData::FbsBitmap);
-        return true;
-    }
-    return false;
-}
-
-void QGLPixmapData::createFromNativeImageHandleProvider()
-{
-    void *handle = 0;
-    QString type;
-    nativeImageHandleProvider->get(&handle, &type);
-    if (handle) {
-        if (initFromNativeImageHandle(handle, type)) {
-            nativeImageHandle = handle;
-            nativeImageType = type;
-        } else {
-            qWarning("QGLPixmapData: Unknown native image type '%s'", qPrintable(type));
-        }
-    } else {
-        qWarning("QGLPixmapData: Native handle is null");
-    }
-}
-
-void QGLPixmapData::releaseNativeImageHandle()
-{
-    if (nativeImageHandleProvider && nativeImageHandle) {
-        nativeImageHandleProvider->release(nativeImageHandle, nativeImageType);
-        nativeImageHandle = 0;
-        nativeImageType = QString();
-    }
-}
-
 QT_END_NAMESPACE
diff --git a/src/opengl/qpixmapdata_gl_p.h b/src/opengl/qpixmapdata_gl_p.h
index bf1a303..3d22ad1 100644
--- a/src/opengl/qpixmapdata_gl_p.h
+++ b/src/opengl/qpixmapdata_gl_p.h
@@ -61,6 +61,9 @@
 
 #ifdef Q_OS_SYMBIAN
 #include "private/qvolatileimage_p.h"
+#ifdef QT_SYMBIAN_SUPPORTS_SGIMAGE
+#  include <sgresource/sgimage.h>
+#endif
 #endif
 
 QT_BEGIN_NAMESPACE
@@ -72,8 +75,7 @@ class QGLPixmapData;
 
 #ifdef Q_OS_SYMBIAN
 class QNativeImageHandleProvider;
-#endif
-
+#else
 class QGLFramebufferObjectPool
 {
 public:
@@ -102,7 +104,7 @@ public:
 private:
     QGLPixmapData *data;
 };
-
+#endif
 
 class Q_OPENGL_EXPORT QGLPixmapData : public QPixmapData
 {
@@ -194,6 +196,9 @@ private:
     mutable QNativeImageHandleProvider *nativeImageHandleProvider;
     void *nativeImageHandle;
     QString nativeImageType;
+#ifdef QT_SYMBIAN_SUPPORTS_SGIMAGE
+    RSgImage *m_sgImage;
+#endif
 #else
     mutable QImage m_source;
 #endif
@@ -208,9 +213,9 @@ private:
     mutable bool m_hasFillColor;
 
     mutable bool m_hasAlpha;
-
+#ifndef Q_OS_SYMBIAN
     mutable QGLPixmapGLPaintDevice m_glDevice;
-
+#endif
     friend class QGLPixmapGLPaintDevice;
     friend class QMeeGoPixmapData;
     friend class QMeeGoLivePixmapData;
diff --git a/src/opengl/qpixmapdata_symbiangl.cpp b/src/opengl/qpixmapdata_symbiangl.cpp
index ab8a9e8..78e5ee7 100644
--- a/src/opengl/qpixmapdata_symbiangl.cpp
+++ b/src/opengl/qpixmapdata_symbiangl.cpp
@@ -59,181 +59,66 @@
 #include <qimagereader.h>
 #include <qbuffer.h>
 
+#include <fbs.h>
+
 #include "qgltexturepool_p.h"
 
 QT_BEGIN_NAMESPACE
 
 Q_OPENGL_EXPORT extern QGLWidget* qt_gl_share_widget();
 
-static inline int areaDiff(const QSize &size, const QGLFramebufferObject *fbo)
-{
-    return qAbs(size.width() * size.height() - fbo->width() * fbo->height());
-}
-
-extern int qt_next_power_of_two(int v);
-
-static inline QSize maybeRoundToNextPowerOfTwo(const QSize &sz)
-{
-#ifdef QT_OPENGL_ES_2
-    QSize rounded(qt_next_power_of_two(sz.width()), qt_next_power_of_two(sz.height()));
-    if (rounded.width() * rounded.height() < 1.20 * sz.width() * sz.height())
-        return rounded;
-#endif
-    return sz;
-}
-
-
-QGLFramebufferObject *QGLFramebufferObjectPool::acquire(const QSize &requestSize, const QGLFramebufferObjectFormat &requestFormat, bool strictSize)
+class QGLSgImageTextureCleanup
 {
-    QGLFramebufferObject *chosen = 0;
-    QGLFramebufferObject *candidate = 0;
-    for (int i = 0; !chosen && i < m_fbos.size(); ++i) {
-        QGLFramebufferObject *fbo = m_fbos.at(i);
+public:
+    QGLSgImageTextureCleanup(const QGLContext *context = 0) {}
 
-        if (strictSize) {
-            if (fbo->size() == requestSize && fbo->format() == requestFormat) {
-                chosen = fbo;
-                break;
-            } else {
-                continue;
-            }
-        }
-
-        if (fbo->format() == requestFormat) {
-            // choose the fbo with a matching format and the closest size
-            if (!candidate || areaDiff(requestSize, candidate) > areaDiff(requestSize, fbo))
-                candidate = fbo;
-        }
-
-        if (candidate) {
-            m_fbos.removeOne(candidate);
-
-            const QSize fboSize = candidate->size();
-            QSize sz = fboSize;
-
-            if (sz.width() < requestSize.width())
-                sz.setWidth(qMax(requestSize.width(), qRound(sz.width() * 1.5)));
-            if (sz.height() < requestSize.height())
-                sz.setHeight(qMax(requestSize.height(), qRound(sz.height() * 1.5)));
-
-            // wasting too much space?
-            if (sz.width() * sz.height() > requestSize.width() * requestSize.height() * 4)
-                sz = requestSize;
-
-            if (sz != fboSize) {
-                delete candidate;
-                candidate = new QGLFramebufferObject(maybeRoundToNextPowerOfTwo(sz), requestFormat);
-            }
-
-            chosen = candidate;
+    ~QGLSgImageTextureCleanup()
+    {
+        QList<qint64> keys = m_cache.keys();
+        while(keys.size() > 0) {
+            QGLPixmapData *data = m_cache.take(keys.takeAt(0));
+            if (data)
+                data->destroyTexture();
         }
     }
 
-    if (!chosen) {
-        if (strictSize)
-            chosen = new QGLFramebufferObject(requestSize, requestFormat);
-        else
-            chosen = new QGLFramebufferObject(maybeRoundToNextPowerOfTwo(requestSize), requestFormat);
-    }
+    static QGLSgImageTextureCleanup *cleanupForContext(const QGLContext *context);
 
-    if (!chosen->isValid()) {
-        delete chosen;
-        chosen = 0;
+    void insert(quint64 key, QGLPixmapData *data)
+    {
+        m_cache.insert(key, data);
     }
 
-    return chosen;
-}
+    void remove(quint64 key)
+    {
+        m_cache.take(key);
+    }
 
-void QGLFramebufferObjectPool::release(QGLFramebufferObject *fbo)
-{
-    if (fbo)
-        m_fbos << fbo;
-}
+private:
 
+    QCache<qint64, QGLPixmapData> m_cache;
+};
 
-QPaintEngine* QGLPixmapGLPaintDevice::paintEngine() const
+#if QT_VERSION >= 0x040800
+Q_GLOBAL_STATIC(QGLContextGroupResource<QGLSgImageTextureCleanup>, qt_sgimage_texture_cleanup)
+#else
+static void qt_sgimage_texture_cleanup_free(void *data)
 {
-    return data->paintEngine();
+    delete reinterpret_cast<QGLSgImageTextureCleanup *>(data);
 }
+Q_GLOBAL_STATIC_WITH_ARGS(QGLContextResource, qt_sgimage_texture_cleanup, (qt_sgimage_texture_cleanup_free))
+#endif
 
-void QGLPixmapGLPaintDevice::beginPaint()
+QGLSgImageTextureCleanup *QGLSgImageTextureCleanup::cleanupForContext(const QGLContext *context)
 {
-    if (!data->isValid())
-        return;
-
-    // QGLPaintDevice::beginPaint will store the current binding and replace
-    // it with m_thisFBO:
-    m_thisFBO = data->m_renderFbo->handle();
-    QGLPaintDevice::beginPaint();
-
-    Q_ASSERT(data->paintEngine()->type() == QPaintEngine::OpenGL2);
-
-    // QPixmap::fill() is deferred until now, where we actually need to do the fill:
-    if (data->needsFill()) {
-        const QColor &c = data->fillColor();
-        float alpha = c.alphaF();
-        glDisable(GL_SCISSOR_TEST);
-        glClearColor(c.redF() * alpha, c.greenF() * alpha, c.blueF() * alpha, alpha);
-        glClear(GL_COLOR_BUFFER_BIT);
+    QGLSgImageTextureCleanup *p = reinterpret_cast<QGLSgImageTextureCleanup *>(qt_sgimage_texture_cleanup()->value(context));
+#if QT_VERSION < 0x040800
+    if (!p) {
+        QGLShareContextScope scope(context);
+        qt_sgimage_texture_cleanup()->insert(context, p = new QGLSgImageTextureCleanup);
     }
-    else if (!data->isUninitialized()) {
-        // If the pixmap (GL Texture) has valid content (it has been
-        // uploaded from an image or rendered into before), we need to
-        // copy it from the texture to the render FBO.
-
-        glDisable(GL_DEPTH_TEST);
-        glDisable(GL_SCISSOR_TEST);
-        glDisable(GL_BLEND);
-
-#if !defined(QT_OPENGL_ES_2)
-        glMatrixMode(GL_MODELVIEW);
-        glLoadIdentity();
-
-        glMatrixMode(GL_PROJECTION);
-        glLoadIdentity();
-        glOrtho(0, data->width(), data->height(), 0, -999999, 999999);
 #endif
-
-        glViewport(0, 0, data->width(), data->height());
-
-        // Pass false to bind so it doesn't copy the FBO into the texture!
-        context()->drawTexture(QRect(0, 0, data->width(), data->height()), data->bind(false));
-    }
-}
-
-void QGLPixmapGLPaintDevice::endPaint()
-{
-    if (!data->isValid())
-        return;
-
-    data->copyBackFromRenderFbo(false);
-
-    // Base's endPaint will restore the previous FBO binding
-    QGLPaintDevice::endPaint();
-
-    qgl_fbo_pool()->release(data->m_renderFbo);
-    data->m_renderFbo = 0;
-}
-
-QGLContext* QGLPixmapGLPaintDevice::context() const
-{
-    data->ensureCreated();
-    return data->m_ctx;
-}
-
-QSize QGLPixmapGLPaintDevice::size() const
-{
-    return data->size();
-}
-
-bool QGLPixmapGLPaintDevice::alphaRequested() const
-{
-    return data->m_hasAlpha;
-}
-
-void QGLPixmapGLPaintDevice::setPixmapData(QGLPixmapData* d)
-{
-    data = d;
+    return p;
 }
 
 int qt_gl_pixmap_serial = 0;
@@ -245,16 +130,28 @@ QGLPixmapData::QGLPixmapData(PixelType type)
     , m_ctx(0)
     , nativeImageHandleProvider(0)
     , nativeImageHandle(0)
+#ifdef QT_SYMBIAN_SUPPORTS_SGIMAGE
+    , m_sgImage(0)
+#endif
     , m_dirty(false)
     , m_hasFillColor(false)
     , m_hasAlpha(false)
 {
     setSerialNumber(++qt_gl_pixmap_serial);
-    m_glDevice.setPixmapData(this);
 }
 
 QGLPixmapData::~QGLPixmapData()
 {
+    if (m_sgImage) {
+        if (m_texture.id) {
+            QGLSgImageTextureCleanup::cleanupForContext(m_ctx)->remove(m_texture.id);
+            destroyTexture();
+        }
+
+        m_sgImage->Close();
+        delete m_sgImage;
+        m_sgImage = 0;
+    }
     delete m_engine;
 }
 
@@ -276,6 +173,16 @@ bool QGLPixmapData::isValidContext(const QGLContext *ctx) const
     // That's why if source pixels are valid we return false
     // to simulate raster pixmaps. Only QPixmaps created from
     // SgImage will enable usage of QGLPixmapData.
+#ifdef QT_SYMBIAN_SUPPORTS_SGIMAGE
+    if (m_sgImage) {
+        // SgImage texture
+        if (ctx == m_ctx)
+            return true;
+
+        const QGLContext *share_ctx = qt_gl_share_widget()->context();
+        return ctx == share_ctx || QGLContext::areSharing(ctx, share_ctx);
+    }
+#endif
     return false;
 }
 
@@ -314,72 +221,45 @@ void QGLPixmapData::ensureCreated() const
     QGLShareContextScope ctx(qt_gl_share_widget()->context());
     m_ctx = ctx;
 
-    const GLenum internal_format = m_hasAlpha ? GL_RGBA : GL_RGB;
-#ifdef QT_OPENGL_ES_2
-    const GLenum external_format = internal_format;
-#else
-    const GLenum external_format = qt_gl_preferredTextureFormat();
-#endif
-    const GLenum target = GL_TEXTURE_2D;
-
-    GLenum type = GL_UNSIGNED_BYTE;
-    // Avoid conversion when pixmap is created from CFbsBitmap of EColor64K.
-    if (!m_source.isNull() && m_source.format() == QImage::Format_RGB16)
-        type = GL_UNSIGNED_SHORT_5_6_5;
-
-    if (!m_texture.id) {
-        m_texture.id = QGLTexturePool::instance()->createTexture(
-                                                                target,
-                                                                0, internal_format,
-                                                                w, h,
-                                                                external_format,
-                                                                type,
-                                                                &m_texture);
-        if (!m_texture.id) {
-            m_texture.failedToAlloc = true;
-            return;
-        }
-        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+#ifdef QT_SYMBIAN_SUPPORTS_SGIMAGE
+    if (m_sgImage) {
+        qt_resolve_eglimage_gl_extensions(ctx); // ensure initialized
 
-        m_texture.inTexturePool = true;
-    } else if (m_texture.inTexturePool) {
-        glBindTexture(target, m_texture.id);
-        QGLTexturePool::instance()->useTexture(&m_texture);
-    }
+        bool textureIsBound = false;
+        GLuint newTextureId;
 
-    if (!m_source.isNull() && m_texture.id) {
-        if (external_format == GL_RGB) {
-            m_source.beginDataAccess();
-            QImage tx;
-            if (type == GL_UNSIGNED_BYTE)
-                tx = m_source.imageRef().convertToFormat(QImage::Format_RGB888).mirrored(false, true);
-            else if (type == GL_UNSIGNED_SHORT_5_6_5)
-                tx = m_source.imageRef().mirrored(false, true);
-            m_source.endDataAccess(true);
+        EGLint imgAttr[] = { EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE };
+        EGLImageKHR image = QEgl::eglCreateImageKHR(QEgl::display()
+                                                , EGL_NO_CONTEXT
+                                                , EGL_NATIVE_PIXMAP_KHR
+                                                , (EGLClientBuffer)m_sgImage
+                                                , imgAttr);
 
-            glBindTexture(target, m_texture.id);
-            if (!tx.isNull())
-                glTexSubImage2D(target, 0, 0, 0, w, h, external_format,
-                                type, tx.constBits());
-            else
-                qWarning("QGLPixmapData: Failed to create GL_RGB image of size %dx%d", w, h);
-        } else {
-            // do byte swizzling ARGB -> RGBA
-            m_source.beginDataAccess();
-            const QImage tx = ctx->d_func()->convertToGLFormat(m_source.imageRef(), true, external_format);
-            m_source.endDataAccess(true);
-            glBindTexture(target, m_texture.id);
-            if (!tx.isNull())
-                glTexSubImage2D(target, 0, 0, 0, w, h, external_format,
-                                type, tx.constBits());
-            else
-                qWarning("QGLPixmapData: Failed to create GL_RGBA image of size %dx%d", w, h);
+        glGenTextures(1, &newTextureId);
+        glBindTexture( GL_TEXTURE_2D, newTextureId);
+
+        if (image != EGL_NO_IMAGE_KHR) {
+            glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image);
+            GLint err = glGetError();
+            if (err == GL_NO_ERROR)
+                textureIsBound = true;
+
+            QEgl::eglDestroyImageKHR(QEgl::display(), image);
         }
 
-        if (useFramebufferObjects())
-            m_source = QVolatileImage();
+        if (textureIsBound) {
+            glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+            glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+            m_texture.id = newTextureId;
+            m_texture.boundPixmap = const_cast<QGLPixmapData*>(this);
+            QGLSgImageTextureCleanup::cleanupForContext(m_ctx)->insert(m_texture.id, const_cast<QGLPixmapData*>(this));
+        } else {
+            qWarning("QGLPixmapData: Failed to create texture from a SgImage image of size %dx%d", w, h);
+            glDeleteTextures(1, &newTextureId);
+        }
     }
+#endif
 }
 
 
@@ -539,42 +419,7 @@ bool QGLPixmapData::scroll(int dx, int dy, const QRect &rect)
 
 void QGLPixmapData::copy(const QPixmapData *data, const QRect &rect)
 {
-    if (data->classId() != QPixmapData::OpenGLClass || !static_cast<const QGLPixmapData *>(data)->useFramebufferObjects()) {
-        QPixmapData::copy(data, rect);
-        return;
-    }
-
-    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);
-    }
+    QPixmapData::copy(data, rect);
 }
 
 void QGLPixmapData::fill(const QColor &color)
@@ -591,11 +436,6 @@ void QGLPixmapData::fill(const QColor &color)
         m_hasAlpha = color.alpha() != 255;
     }
 
-    if (useFramebufferObjects()) {
-        m_source = QVolatileImage();
-        m_hasFillColor = true;
-        m_fillColor = color;
-    } else {
         forceToImage();
 
         if (m_source.depth() == 32) {
@@ -606,7 +446,6 @@ void QGLPixmapData::fill(const QColor &color)
                 m_source.fill(1);
             else
                 m_source.fill(0);
-        }
     }
 }
 
@@ -646,9 +485,7 @@ QImage QGLPixmapData::toImage() const
     if (!isValid())
         return QImage();
 
-    if (m_renderFbo) {
-        copyBackFromRenderFbo(true);
-    } else if (!m_source.isNull()) {
+    if (!m_source.isNull()) {
         // QVolatileImage::toImage() will make a copy always so no check
         // for active painting is needed.
         QImage img = m_source.toImage();
@@ -669,58 +506,9 @@ QImage QGLPixmapData::toImage() const
     return qt_gl_read_texture(QSize(w, h), true, true);
 }
 
-struct TextureBuffer
-{
-    QGLFramebufferObject *fbo;
-    QGL2PaintEngineEx *engine;
-};
-
-Q_GLOBAL_STATIC(QGLFramebufferObjectPool, _qgl_fbo_pool)
-QGLFramebufferObjectPool* qgl_fbo_pool()
-{
-    return _qgl_fbo_pool();
-}
-
 void QGLPixmapData::copyBackFromRenderFbo(bool keepCurrentFboBound) const
 {
-    if (!isValid())
-        return;
-
-    m_hasFillColor = false;
-
-    const QGLContext *share_ctx = qt_gl_share_widget()->context();
-    QGLShareContextScope ctx(share_ctx);
-
-    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);
-
-    const int x0 = 0;
-    const int x1 = w;
-    const int y0 = 0;
-    const int y1 = h;
-
-    if (!m_renderFbo->isBound())
-        glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, m_renderFbo->handle());
-
-    glDisable(GL_SCISSOR_TEST);
-
-    glBlitFramebufferEXT(x0, y0, x1, y1,
-            x0, y0, x1, y1,
-            GL_COLOR_BUFFER_BIT,
-            GL_NEAREST);
-
-    if (keepCurrentFboBound) {
-        glBindFramebuffer(GL_FRAMEBUFFER_EXT, ctx->d_ptr->current_fbo);
-    } else {
-        glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, m_renderFbo->handle());
-        ctx->d_ptr->current_fbo = m_renderFbo->handle();
-    }
+    // We don't use FBOs on Symbian
 }
 
 bool QGLPixmapData::useFramebufferObjects() const
@@ -734,32 +522,6 @@ QPaintEngine* QGLPixmapData::paintEngine() const
     if (!isValid())
         return 0;
 
-    if (m_renderFbo)
-        return m_engine;
-
-    if (useFramebufferObjects()) {
-        extern QGLWidget* qt_gl_share_widget();
-
-        if (!QGLContext::currentContext())
-            qt_gl_share_widget()->makeCurrent();
-        QGLShareContextScope ctx(qt_gl_share_widget()->context());
-
-        QGLFramebufferObjectFormat format;
-        format.setAttachment(QGLFramebufferObject::CombinedDepthStencil);
-        format.setSamples(4);
-        format.setInternalTextureFormat(GLenum(m_hasAlpha ? GL_RGBA : GL_RGB));
-
-        m_renderFbo = qgl_fbo_pool()->acquire(size(), format);
-
-        if (m_renderFbo) {
-            if (!m_engine)
-                m_engine = new QGL2PaintEngineEx;
-            return m_engine;
-        }
-
-        qWarning() << "Failed to create pixmap texture buffer of size " << size() << ", falling back to raster paint engine";
-    }
-
     // If the application wants to paint into the QPixmap, we first
     // force it to QImage format and then paint into that.
     // This is simpler than juggling multiple GL contexts.
@@ -774,25 +536,16 @@ QPaintEngine* QGLPixmapData::paintEngine() const
 
 extern QRgb qt_gl_convertToGLFormat(QRgb src_pixel, GLenum texture_format);
 
-// If copyBack is true, bind will copy the contents of the render
-// FBO to the texture (which is not bound to the texture, as it's
-// a multisample FBO).
 GLuint QGLPixmapData::bind(bool copyBack) const
 {
-    if (m_renderFbo && copyBack) {
-        copyBackFromRenderFbo(true);
-    } else {
-        ensureCreated();
-    }
+    ensureCreated();
 
     GLuint id = m_texture.id;
     glBindTexture(GL_TEXTURE_2D, id);
 
     if (m_hasFillColor) {
-        if (!useFramebufferObjects()) {
             m_source = QVolatileImage(w, h, QImage::Format_ARGB32_Premultiplied);
             m_source.fill(PREMUL(m_fillColor.rgba()));
-        }
 
         m_hasFillColor = false;
 
@@ -861,7 +614,21 @@ void QGLPixmapData::forceToImage()
 
 void QGLPixmapData::destroyTexture()
 {
-    // Destroy SgImage texture
+    if (m_texture.id) {
+        QGLWidget *shareWidget = qt_gl_share_widget();
+        if (shareWidget) {
+            m_texture.options |= QGLContext::MemoryManagedBindOption;
+            m_texture.freeTexture();
+            m_texture.options &= ~QGLContext::MemoryManagedBindOption;
+        } else if(QGLContext::currentContext()) {
+            glDeleteTextures(1, &m_texture.id);
+            m_texture.id = 0;
+            m_texture.boundPixmap = 0;
+            m_texture.boundKey = 0;
+        }
+        m_ctx = 0;
+        m_dirty = true;
+    }
 }
 
 void QGLPixmapData::detachTextureFromPool()
@@ -886,7 +653,180 @@ void QGLPixmapData::reclaimTexture()
 
 QGLPaintDevice *QGLPixmapData::glDevice() const
 {
-    return &m_glDevice;
+    return 0;
+}
+
+static inline bool knownGoodFormat(QImage::Format format)
+{
+    switch (format) {
+        case QImage::Format_RGB16: // EColor64K
+        case QImage::Format_RGB32: // EColor16MU
+        case QImage::Format_ARGB32_Premultiplied: // EColor16MAP
+            return true;
+        default:
+            return false;
+    }
+}
+
+static inline int symbianPixeFormatBitsPerPixel(TUidPixelFormat pixelFormat)
+{
+    switch (pixelFormat) {
+        case EUidPixelFormatP_1:
+        case EUidPixelFormatL_1:
+            return 1;
+        case EUidPixelFormatP_2:
+        case EUidPixelFormatL_2:
+            return 2;
+        case EUidPixelFormatP_4:
+        case EUidPixelFormatL_4:
+            return 4;
+        case EUidPixelFormatRGB_332:
+        case EUidPixelFormatA_8:
+        case EUidPixelFormatBGR_332:
+        case EUidPixelFormatP_8:
+        case EUidPixelFormatL_8:
+            return 8;
+        case EUidPixelFormatRGB_565:
+        case EUidPixelFormatBGR_565:
+        case EUidPixelFormatARGB_1555:
+        case EUidPixelFormatXRGB_1555:
+        case EUidPixelFormatARGB_4444:
+        case EUidPixelFormatARGB_8332:
+        case EUidPixelFormatBGRX_5551:
+        case EUidPixelFormatBGRA_5551:
+        case EUidPixelFormatBGRA_4444:
+        case EUidPixelFormatBGRX_4444:
+        case EUidPixelFormatAP_88:
+        case EUidPixelFormatXRGB_4444:
+        case EUidPixelFormatXBGR_4444:
+            return 16;
+        case EUidPixelFormatBGR_888:
+        case EUidPixelFormatRGB_888:
+            return 24;
+        case EUidPixelFormatXRGB_8888:
+        case EUidPixelFormatBGRX_8888:
+        case EUidPixelFormatXBGR_8888:
+        case EUidPixelFormatBGRA_8888:
+        case EUidPixelFormatARGB_8888:
+        case EUidPixelFormatABGR_8888:
+        case EUidPixelFormatARGB_8888_PRE:
+        case EUidPixelFormatABGR_8888_PRE:
+        case EUidPixelFormatBGRA_8888_PRE:
+        case EUidPixelFormatARGB_2101010:
+        case EUidPixelFormatABGR_2101010:
+            return 32;
+        default:
+            return 32;
+    };
+}
+
+void QGLPixmapData::fromNativeType(void* pixmap, NativeType type)
+{
+    if (type == QPixmapData::SgImage && pixmap) {
+#if defined(QT_SYMBIAN_SUPPORTS_SGIMAGE) && !defined(QT_NO_EGL)
+        RSgImage *sgImage = reinterpret_cast<RSgImage*>(pixmap);
+
+        m_sgImage = new RSgImage;
+        m_sgImage->Open(sgImage->Id());
+
+        TSgImageInfo info;
+        sgImage->GetInfo(info);
+
+        w = info.iSizeInPixels.iWidth;
+        h = info.iSizeInPixels.iHeight;
+        d = symbianPixeFormatBitsPerPixel((TUidPixelFormat)info.iPixelFormat);
+
+        m_source = QVolatileImage();
+        m_hasAlpha = true;
+        m_hasFillColor = false;
+        m_dirty = true;
+        is_null = (w <= 0 || h <= 0);
+#endif
+    } else if (type == QPixmapData::FbsBitmap && pixmap) {
+        CFbsBitmap *bitmap = reinterpret_cast<CFbsBitmap *>(pixmap);
+        QSize size(bitmap->SizeInPixels().iWidth, bitmap->SizeInPixels().iHeight);
+        if (size.width() == w && size.height() == h)
+            setSerialNumber(++qt_gl_pixmap_serial);
+        resize(size.width(), size.height());
+        m_source = QVolatileImage(bitmap);
+        if (pixelType() == BitmapType) {
+            m_source.ensureFormat(QImage::Format_MonoLSB);
+        } else if (!knownGoodFormat(m_source.format())) {
+            m_source.beginDataAccess();
+            QImage::Format format = idealFormat(m_source.imageRef(), Qt::AutoColor);
+            m_source.endDataAccess(true);
+            m_source.ensureFormat(format);
+        }
+        m_hasAlpha = m_source.hasAlphaChannel();
+        m_hasFillColor = false;
+        m_dirty = true;
+        d = m_source.depth();
+    } else if (type == QPixmapData::VolatileImage && pixmap) {
+        // Support QS60Style in more efficient skin graphics retrieval.
+        QVolatileImage *img = static_cast<QVolatileImage *>(pixmap);
+        if (img->width() == w && img->height() == h)
+            setSerialNumber(++qt_gl_pixmap_serial);
+        resize(img->width(), img->height());
+        m_source = *img;
+        m_hasAlpha = m_source.hasAlphaChannel();
+        m_hasFillColor = false;
+        m_dirty = true;
+        d = m_source.depth();
+    } else if (type == QPixmapData::NativeImageHandleProvider && pixmap) {
+        destroyTexture();
+        nativeImageHandleProvider = static_cast<QNativeImageHandleProvider *>(pixmap);
+        // Cannot defer the retrieval, we need at least the size right away.
+        createFromNativeImageHandleProvider();
+    }
+}
+
+void* QGLPixmapData::toNativeType(NativeType type)
+{
+    if (type == QPixmapData::FbsBitmap) {
+        if (m_source.isNull())
+            m_source = QVolatileImage(w, h, QImage::Format_ARGB32_Premultiplied);
+        return m_source.duplicateNativeImage();
+    }
+
+    return 0;
+}
+
+bool QGLPixmapData::initFromNativeImageHandle(void *handle, const QString &type)
+{
+    if (type == QLatin1String("RSgImage")) {
+        fromNativeType(handle, QPixmapData::SgImage);
+        return true;
+    } else if (type == QLatin1String("CFbsBitmap")) {
+        fromNativeType(handle, QPixmapData::FbsBitmap);
+        return true;
+    }
+    return false;
+}
+
+void QGLPixmapData::createFromNativeImageHandleProvider()
+{
+    void *handle = 0;
+    QString type;
+    nativeImageHandleProvider->get(&handle, &type);
+    if (handle) {
+        if (initFromNativeImageHandle(handle, type)) {
+            nativeImageHandle = handle;
+            nativeImageType = type;
+        } else {
+            qWarning("QGLPixmapData: Unknown native image type '%s'", qPrintable(type));
+        }
+    } else {
+        qWarning("QGLPixmapData: Native handle is null");
+    }
+}
+
+void QGLPixmapData::releaseNativeImageHandle()
+{
+    if (nativeImageHandleProvider && nativeImageHandle) {
+        nativeImageHandleProvider->release(nativeImageHandle, nativeImageType);
+        nativeImageHandle = 0;
+        nativeImageType = QString();
+    }
 }
 
 QT_END_NAMESPACE
diff --git a/src/opengl/qwindowsurface_gl.cpp b/src/opengl/qwindowsurface_gl.cpp
index 9ad7f6a..d93efb4 100644
--- a/src/opengl/qwindowsurface_gl.cpp
+++ b/src/opengl/qwindowsurface_gl.cpp
@@ -184,7 +184,7 @@ QGLGraphicsSystem::QGLGraphicsSystem(bool useX11GL)
 class QGLGlobalShareWidget
 {
 public:
-    QGLGlobalShareWidget() : refCount(0), widget(0), initializing(false) {
+    QGLGlobalShareWidget() : widget(0), initializing(false) {
         created = true;
     }
 
@@ -227,8 +227,6 @@ public:
     static bool cleanedUp;
     static bool created;
 
-    int refCount;
-
 private:
     QGLWidget *widget;
     bool initializing;
@@ -369,15 +367,11 @@ QGLWindowSurface::~QGLWindowSurface()
     if (QGLGlobalShareWidget::cleanedUp)
         return;
 
-    --(_qt_gl_share_widget()->refCount);
-
 #ifdef Q_OS_SYMBIAN
-    if (_qt_gl_share_widget()->refCount <= 0) {
-        // Destroy the context if necessary.
-        if (!qt_gl_share_widget()->context()->isSharing())
-            qt_destroy_gl_share_widget();
-    }
-#endif // QGL_USE_TEXTURE_POOL
+    // Destroy the context if necessary.
+    if (!qt_gl_share_widget()->context()->isSharing())
+        qt_destroy_gl_share_widget();
+#endif
 }
 
 void QGLWindowSurface::deleted(QObject *object)
@@ -427,9 +421,6 @@ void QGLWindowSurface::hijackWindow(QWidget *widget)
 
     ctx->create(qt_gl_share_context());
 
-    if (widget != qt_gl_share_widget())
-        ++(_qt_gl_share_widget()->refCount);
-
 #ifndef QT_NO_EGL
     static bool checkedForNOKSwapRegion = false;
     static bool haveNOKSwapRegion = false;
@@ -745,6 +736,7 @@ void QGLWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &
 
             glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, 0);
         } else {
+#ifndef Q_OS_SYMBIAN // We don't have FBO pool on Symbian
             // can't do sub-region blits with multisample FBOs
             QGLFramebufferObject *temp = qgl_fbo_pool()->acquire(d_ptr->fbo->size(), QGLFramebufferObjectFormat());
 
@@ -767,6 +759,7 @@ void QGLWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &
             glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, 0);
 
             qgl_fbo_pool()->release(temp);
+#endif // Q_OS_SYMBIAN
         }
 
         ctx->d_ptr->current_fbo = 0;
@@ -856,18 +849,43 @@ void QGLWindowSurface::updateGeometry() {
     if (wd->extraData() && wd->extraData()->glContext) {
 #ifdef Q_OS_SYMBIAN // Symbian needs to recreate the context when native window size changes
         if (d_ptr->size != geometry().size()) {
-            if (window() != qt_gl_share_widget())
-                --(_qt_gl_share_widget()->refCount);
+            QGLContext *ctx = reinterpret_cast<QGLContext *>(wd->extraData()->glContext);
+
+            if (ctx == QGLContext::currentContext())
+                 ctx->doneCurrent();
+
+            ctx->d_func()->destroyEglSurfaceForDevice();
+
+            // Delete other contexts (shouldn't happen too often, if at all)
+            while (d_ptr->contexts.size()) {
+                QGLContext **ctxPtrPtr = d_ptr->contexts.takeFirst();
+                if ((*ctxPtrPtr) != ctx)
+                    delete *ctxPtrPtr;
+            }
+            union { QGLContext **ctxPtrPtr; void **voidPtrPtr; };
+            voidPtrPtr = &wd->extraData()->glContext;
+            d_ptr->contexts << ctxPtrPtr;
+
+            ctx->d_func()->eglSurface = ctx->d_func()->eglContext->createSurface(window());
+
+            // Swap behaviour has been checked already in previous hijackWindow call.
+            // Reset swap behaviour based on that flag.
+            if (d_ptr->destructive_swap_buffers) {
+                eglSurfaceAttrib(QEgl::display(), ctx->d_func()->eglSurfaceForDevice(),
+                                    EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED);
+
+                if (eglGetError() != EGL_SUCCESS)
+                    qWarning("QGLWindowSurface::updateGeometry() - could not re-enable destroyed swap behaviour");
+            } else {
+                eglSurfaceAttrib(QEgl::display(), ctx->d_func()->eglSurfaceForDevice(),
+                                    EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED);
 
-            delete wd->extraData()->glContext;
-            wd->extraData()->glContext = 0;
-            d_ptr->ctx = 0;
+                if (eglGetError() != EGL_SUCCESS)
+                    qWarning("QGLWindowSurface::updateGeometry() - could not re-enable preserved swap behaviour");                
+            }
         }
-        else
 #endif
-        {
-            hijack = false; // we already have gl context for widget
-        }
+        hijack = false; // we already have gl context for widget
     }
 
     if (hijack)
diff --git a/src/s60installs/s60installs.pro b/src/s60installs/s60installs.pro
index d96b46a..0164141 100755
--- a/src/s60installs/s60installs.pro
+++ b/src/s60installs/s60installs.pro
@@ -137,19 +137,23 @@ symbian: {
         folderlistmodelImport.sources = $$QT_BUILD_TREE/imports/Qt/labs/folderlistmodel/qmlfolderlistmodelplugin$${QT_LIBINFIX}.dll
         gesturesImport.sources = $$QT_BUILD_TREE/imports/Qt/labs/gestures/qmlgesturesplugin$${QT_LIBINFIX}.dll
         particlesImport.sources = $$QT_BUILD_TREE/imports/Qt/labs/particles/qmlparticlesplugin$${QT_LIBINFIX}.dll
-        shadersImport.sources = $$QT_BUILD_TREE/imports/Qt/labs/shaders/qmlshadersplugin$${QT_LIBINFIX}.dll
 
         folderlistmodelImport.sources += $$QT_SOURCE_TREE/src/imports/folderlistmodel/qmldir
         gesturesImport.sources += $$QT_SOURCE_TREE/src/imports/gestures/qmldir
         particlesImport.sources += $$QT_SOURCE_TREE/src/imports/particles/qmldir
-        shadersImport.sources += $$QT_SOURCE_TREE/src/imports/shaders/qmldir
 
         folderlistmodelImport.path = c:$$QT_IMPORTS_BASE_DIR/Qt/labs/folderlistmodel
         gesturesImport.path = c:$$QT_IMPORTS_BASE_DIR/Qt/labs/gestures
         particlesImport.path = c:$$QT_IMPORTS_BASE_DIR/Qt/labs/particles
-        shadersImport.path = c:$$QT_IMPORTS_BASE_DIR/Qt/labs/shaders
 
-        DEPLOYMENT += folderlistmodelImport gesturesImport particlesImport shadersImport
+        DEPLOYMENT += folderlistmodelImport gesturesImport particlesImport
+
+        contains(QT_CONFIG, opengl) {
+            shadersImport.sources = $$QT_BUILD_TREE/imports/Qt/labs/shaders/qmlshadersplugin$${QT_LIBINFIX}.dll \
+                                    $$QT_SOURCE_TREE/src/imports/shaders/qmldir
+            shadersImport.path = c:$$QT_IMPORTS_BASE_DIR/Qt/labs/shaders
+            DEPLOYMENT += shadersImport
+        }
     }
 
     graphicssystems_plugins.path = c:$$QT_PLUGINS_BASE_DIR/graphicssystems