Merge branch '4.7-upstream' into 4.7-doc

9 files changed, 214 insertions, 162 deletions

diff --git a/src/corelib/global/qendian.h b/src/corelib/global/qendian.h
index d53504a..08415bf 100644
--- a/src/corelib/global/qendian.h
+++ b/src/corelib/global/qendian.h
@@ -44,9 +44,8 @@
 
 #include <QtCore/qglobal.h>
 
-#ifdef Q_OS_LINUX
-# include <features.h>
-#endif
+// include stdlib.h and hope that it defines __GLIBC__ for glibc-based systems
+#include <stdlib.h>
 
 #ifdef __GLIBC__
 #include <byteswap.h>
diff --git a/src/declarative/declarative.pro b/src/declarative/declarative.pro
index 93ad861..1ad888b 100644
--- a/src/declarative/declarative.pro
+++ b/src/declarative/declarative.pro
@@ -2,7 +2,6 @@ TARGET     = QtDeclarative
 QPRO_PWD   = $$PWD
 QT         = core gui script network
 contains(QT_CONFIG, svg): QT += svg
-contains(QT_CONFIG, opengl): QT += opengl
 DEFINES   += QT_BUILD_DECLARATIVE_LIB QT_NO_URL_CAST_FROM_STRING
 win32-msvc*|win32-icc:QMAKE_LFLAGS += /BASE:0x66000000
 solaris-cc*:QMAKE_CXXFLAGS_RELEASE -= -O2
diff --git a/src/declarative/qml/qdeclarativeimport.cpp b/src/declarative/qml/qdeclarativeimport.cpp
index acc13de..94765f2 100644
--- a/src/declarative/qml/qdeclarativeimport.cpp
+++ b/src/declarative/qml/qdeclarativeimport.cpp
@@ -382,7 +382,13 @@ bool QDeclarativeImportsPrivate::importExtension(const QString &absoluteFilePath
         foreach (const QDeclarativeDirParser::Plugin &plugin, qmldirParser.plugins()) {
 
             QString resolvedFilePath = database->resolvePlugin(dir, plugin.path, plugin.name);
-
+#if defined(QT_LIBINFIX) && defined(Q_OS_SYMBIAN)
+            if (resolvedFilePath.isEmpty()) {
+                // In case of libinfixed build, attempt to load libinfixed version, too.
+                QString infixedPluginName = plugin.name + QLatin1String(QT_LIBINFIX);
+                resolvedFilePath = database->resolvePlugin(dir, plugin.path, infixedPluginName);
+            }
+#endif
             if (!resolvedFilePath.isEmpty()) {
                 if (!database->importPlugin(resolvedFilePath, uri, errorString)) {
                     if (errorString)
diff --git a/src/gui/dialogs/dialogs.pri b/src/gui/dialogs/dialogs.pri
index c25b6d5..12e3a71 100644
--- a/src/gui/dialogs/dialogs.pri
+++ b/src/gui/dialogs/dialogs.pri
@@ -109,7 +109,7 @@ SOURCES += \
         dialogs/qprintpreviewdialog.cpp
 
 symbian:contains(QT_CONFIG, s60) {
-    LIBS += -lcommondialogs
+    LIBS += -lCommonDialogs
     SOURCES += dialogs/qfiledialog_symbian.cpp \
                dialogs/qcolordialog_symbian.cpp
 }
diff --git a/src/gui/graphicsview/qgraphicsscene.cpp b/src/gui/graphicsview/qgraphicsscene.cpp
index a0015dc..726e6d7 100644
--- a/src/gui/graphicsview/qgraphicsscene.cpp
+++ b/src/gui/graphicsview/qgraphicsscene.cpp
@@ -4583,13 +4583,13 @@ void QGraphicsScenePrivate::drawItemHelper(QGraphicsItem *item, QPainter *painte
             itemCache->exposed.clear();
             deviceData->cacheIndent = QPoint();
             pix = QPixmap();
-        } else {
+        } else if (!viewRect.isNull()) {
             allowPartialCacheExposure = deviceData->cacheIndent != QPoint();
         }
 
         // Allow partial cache exposure if the device rect isn't fully contained and
         // deviceRect is 20% taller or wider than the viewRect.
-        if (!allowPartialCacheExposure && !viewRect.contains(deviceRect)) {
+        if (!allowPartialCacheExposure && !viewRect.isNull() && !viewRect.contains(deviceRect)) {
             allowPartialCacheExposure = (viewRect.width() * 1.2 < deviceRect.width())
                                          || (viewRect.height() * 1.2 < deviceRect.height());
         }
diff --git a/src/gui/text/qfontdatabase_s60.cpp b/src/gui/text/qfontdatabase_s60.cpp
index 5e168c6..9a77a7a 100644
--- a/src/gui/text/qfontdatabase_s60.cpp
+++ b/src/gui/text/qfontdatabase_s60.cpp
@@ -116,7 +116,6 @@ public:
     const QSymbianTypeFaceExtras *extras(const QString &typeface, bool bold, bool italic) const;
     void addFontFileToFontStore(const QFileInfo &fontFileInfo);
 
-#ifndef Q_SYMBIAN_HAS_FONTTABLE_API
     struct CFontFromFontStoreReleaser {
         static inline void cleanup(CFont *font)
         {
@@ -127,7 +126,6 @@ public:
             dbExtras->m_store->ReleaseFont(font);
         }
     };
-#endif // !Q_SYMBIAN_HAS_FONTTABLE_API
 
     struct CFontFromScreenDeviceReleaser {
         static inline void cleanup(CFont *font)
@@ -138,37 +136,38 @@ public:
         }
     };
 
-#ifndef Q_SYMBIAN_HAS_FONTTABLE_API
+// m_heap, m_store, m_rasterizer and m_extras are used if Symbian
+// does not provide the Font Table API
     RHeap* m_heap;
     CFontStore *m_store;
     COpenFontRasterizer *m_rasterizer;
     mutable QList<const QSymbianTypeFaceExtras *> m_extras;
-#endif // !Q_SYMBIAN_HAS_FONTTABLE_API
+
     mutable QHash<QString, const QSymbianTypeFaceExtras *> m_extrasHash;
 };
 
 QSymbianFontDatabaseExtrasImplementation::QSymbianFontDatabaseExtrasImplementation()
 {
-#ifndef Q_SYMBIAN_HAS_FONTTABLE_API
-    QStringList filters;
-    filters.append(QLatin1String("*.ttf"));
-    filters.append(QLatin1String("*.ccc"));
-    filters.append(QLatin1String("*.ltt"));
-    const QFileInfoList fontFiles = alternativeFilePaths(QLatin1String("resource\\Fonts"), filters);
-
-    const TInt heapMinLength = 0x1000;
-    const TInt heapMaxLength = qMax(0x20000 * fontFiles.count(), heapMinLength);
-    m_heap = User::ChunkHeap(NULL, heapMinLength, heapMaxLength);
-    QT_TRAP_THROWING(
-        m_store = CFontStore::NewL(m_heap);
-        m_rasterizer = COpenFontRasterizer::NewL(TUid::Uid(0x101F7F5E));
-        CleanupStack::PushL(m_rasterizer);
-        m_store->InstallRasterizerL(m_rasterizer);
-        CleanupStack::Pop(m_rasterizer););
-
-    foreach (const QFileInfo &fontFileInfo, fontFiles)
-        addFontFileToFontStore(fontFileInfo);
-#endif // !Q_SYMBIAN_HAS_FONTTABLE_API
+    if (!QSymbianTypeFaceExtras::symbianFontTableApiAvailable()) {
+        QStringList filters;
+        filters.append(QLatin1String("*.ttf"));
+        filters.append(QLatin1String("*.ccc"));
+        filters.append(QLatin1String("*.ltt"));
+        const QFileInfoList fontFiles = alternativeFilePaths(QLatin1String("resource\\Fonts"), filters);
+
+        const TInt heapMinLength = 0x1000;
+        const TInt heapMaxLength = qMax(0x20000 * fontFiles.count(), heapMinLength);
+        m_heap = User::ChunkHeap(NULL, heapMinLength, heapMaxLength);
+        QT_TRAP_THROWING(
+            m_store = CFontStore::NewL(m_heap);
+            m_rasterizer = COpenFontRasterizer::NewL(TUid::Uid(0x101F7F5E));
+            CleanupStack::PushL(m_rasterizer);
+            m_store->InstallRasterizerL(m_rasterizer);
+            CleanupStack::Pop(m_rasterizer););
+
+        foreach (const QFileInfo &fontFileInfo, fontFiles)
+            addFontFileToFontStore(fontFileInfo);
+    }
 }
 
 void qt_cleanup_symbianFontDatabaseExtras()
@@ -177,26 +176,26 @@ void qt_cleanup_symbianFontDatabaseExtras()
             static_cast<const QSymbianFontDatabaseExtrasImplementation*>(privateDb()->symbianExtras);
     if (!dbExtras)
         return; // initializeDb() has never been called
-#ifdef Q_SYMBIAN_HAS_FONTTABLE_API
-    qDeleteAll(dbExtras->m_extrasHash);
-#else // Q_SYMBIAN_HAS_FONTTABLE_API
-    typedef QList<const QSymbianTypeFaceExtras *>::iterator iterator;
-    for (iterator p = dbExtras->m_extras.begin(); p != dbExtras->m_extras.end(); ++p) {
-        dbExtras->m_store->ReleaseFont((*p)->fontOwner());
-        delete *p;
+    if (QSymbianTypeFaceExtras::symbianFontTableApiAvailable()) {
+        qDeleteAll(dbExtras->m_extrasHash);
+    } else {
+        typedef QList<const QSymbianTypeFaceExtras *>::iterator iterator;
+        for (iterator p = dbExtras->m_extras.begin(); p != dbExtras->m_extras.end(); ++p) {
+            dbExtras->m_store->ReleaseFont((*p)->fontOwner());
+            delete *p;
+        }
+        dbExtras->m_extras.clear();
     }
-    dbExtras->m_extras.clear();
-#endif // Q_SYMBIAN_HAS_FONTTABLE_API
     dbExtras->m_extrasHash.clear();
 }
 
 QSymbianFontDatabaseExtrasImplementation::~QSymbianFontDatabaseExtrasImplementation()
 {
     qt_cleanup_symbianFontDatabaseExtras();
-#ifndef Q_SYMBIAN_HAS_FONTTABLE_API
-    delete m_store;
-    m_heap->Close();
-#endif // !Q_SYMBIAN_HAS_FONTTABLE_API
+    if (!QSymbianTypeFaceExtras::symbianFontTableApiAvailable()) {
+        delete m_store;
+        m_heap->Close();
+    }
 }
 
 #ifndef FNTSTORE_H_INLINES_SUPPORT_FMM
@@ -228,44 +227,45 @@ const QSymbianTypeFaceExtras *QSymbianFontDatabaseExtrasImplementation::extras(c
             searchSpec.iFontStyle.SetPosture(EPostureItalic);
 
         CFont* font = NULL;
-#ifdef Q_SYMBIAN_HAS_FONTTABLE_API
-        const TInt err = S60->screenDevice()->GetNearestFontToDesignHeightInPixels(font, searchSpec);
-        Q_ASSERT(err == KErrNone && font);
-        QScopedPointer<CFont, CFontFromScreenDeviceReleaser> sFont(font);
-        QSymbianTypeFaceExtras *extras = new QSymbianTypeFaceExtras(font);
-        sFont.take();
-        m_extrasHash.insert(searchKey, extras);
-#else // Q_SYMBIAN_HAS_FONTTABLE_API
-        const TInt err = m_store->GetNearestFontToDesignHeightInPixels(font, searchSpec);
-        Q_ASSERT(err == KErrNone && font);
-        const CBitmapFont *bitmapFont = static_cast<CBitmapFont*>(font);
-        COpenFont *openFont =
-#ifdef FNTSTORE_H_INLINES_SUPPORT_FMM
-            bitmapFont->OpenFont();
-#else // FNTSTORE_H_INLINES_SUPPORT_FMM
-            OpenFontFromBitmapFont(bitmapFont);
-#endif // FNTSTORE_H_INLINES_SUPPORT_FMM
-        const TOpenFontFaceAttrib* const attrib = openFont->FaceAttrib();
-        const QString foundKey =
-                QString((const QChar*)attrib->FullName().Ptr(), attrib->FullName().Length());
-        if (!m_extrasHash.contains(foundKey)) {
-            QScopedPointer<CFont, CFontFromFontStoreReleaser> sFont(font);
-            QSymbianTypeFaceExtras *extras = new QSymbianTypeFaceExtras(font, openFont);
+        if (QSymbianTypeFaceExtras::symbianFontTableApiAvailable()) {
+            const TInt err = S60->screenDevice()->GetNearestFontToDesignHeightInPixels(font, searchSpec);
+            Q_ASSERT(err == KErrNone && font);
+            QScopedPointer<CFont, CFontFromScreenDeviceReleaser> sFont(font);
+            QSymbianTypeFaceExtras *extras = new QSymbianTypeFaceExtras(font);
             sFont.take();
-            m_extras.append(extras);
             m_extrasHash.insert(searchKey, extras);
-            m_extrasHash.insert(foundKey, extras);
         } else {
-            m_store->ReleaseFont(font);
-            m_extrasHash.insert(searchKey, m_extrasHash.value(foundKey));
+            const TInt err = m_store->GetNearestFontToDesignHeightInPixels(font, searchSpec);
+            Q_ASSERT(err == KErrNone && font);
+            const CBitmapFont *bitmapFont = static_cast<CBitmapFont*>(font);
+            COpenFont *openFont =
+#ifdef FNTSTORE_H_INLINES_SUPPORT_FMM
+                bitmapFont->OpenFont();
+#else // FNTSTORE_H_INLINES_SUPPORT_FMM
+                OpenFontFromBitmapFont(bitmapFont);
+#endif // FNTSTORE_H_INLINES_SUPPORT_FMM
+            const TOpenFontFaceAttrib* const attrib = openFont->FaceAttrib();
+            const QString foundKey =
+                    QString((const QChar*)attrib->FullName().Ptr(), attrib->FullName().Length());
+            if (!m_extrasHash.contains(foundKey)) {
+                QScopedPointer<CFont, CFontFromFontStoreReleaser> sFont(font);
+                QSymbianTypeFaceExtras *extras = new QSymbianTypeFaceExtras(font, openFont);
+                sFont.take();
+                m_extras.append(extras);
+                m_extrasHash.insert(searchKey, extras);
+                m_extrasHash.insert(foundKey, extras);
+            } else {
+                m_store->ReleaseFont(font);
+                m_extrasHash.insert(searchKey, m_extrasHash.value(foundKey));
+            }
         }
-#endif // Q_SYMBIAN_HAS_FONTTABLE_API
     }
     return m_extrasHash.value(searchKey);
 }
 
 void QSymbianFontDatabaseExtrasImplementation::addFontFileToFontStore(const QFileInfo &fontFileInfo)
 {
+    Q_ASSERT(!QSymbianTypeFaceExtras::symbianFontTableApiAvailable());
     const QString fontFile = QDir::toNativeSeparators(fontFileInfo.absoluteFilePath());
     TPtrC fontFilePtr(qt_QString2TPtrC(fontFile));
     QT_TRAP_THROWING(m_store->AddFileL(fontFilePtr));
diff --git a/src/gui/text/qfontengine_s60.cpp b/src/gui/text/qfontengine_s60.cpp
index bf30e1c..f8e5b4a 100644
--- a/src/gui/text/qfontengine_s60.cpp
+++ b/src/gui/text/qfontengine_s60.cpp
@@ -46,114 +46,115 @@
 #include <private/qapplication_p.h>
 #include "qimage.h"
 #include <private/qt_s60_p.h>
+#include <private/qpixmap_s60_p.h>
 
 #include <e32base.h>
 #include <e32std.h>
 #include <eikenv.h>
 #include <gdi.h>
-#if defined(Q_SYMBIAN_HAS_FONTTABLE_API) || defined(Q_SYMBIAN_HAS_GLYPHOUTLINE_API)
+#if defined(Q_SYMBIAN_HAS_GLYPHOUTLINE_API)
 #include <graphics/gdi/gdiplatapi.h>
-#endif // Q_SYMBIAN_HAS_FONTTABLE_API || Q_SYMBIAN_HAS_GLYPHOUTLINE_API
+#endif // Q_SYMBIAN_HAS_GLYPHOUTLINE_API
+
+// Replication of TGetFontTableParam & friends.
+// There is unfortunately no compile time flag like SYMBIAN_FONT_TABLE_API
+// that would help us to only replicate these things for Symbian versions
+// that do not yet have the font table Api. Symbian's public SDK does
+// generally not define any usable macros.
+class QSymbianTGetFontTableParam
+{
+public:
+    TUint32 iTag;
+    TAny *iContent;
+    TInt iLength;
+};
+const TUid QSymbianKFontGetFontTable      = {0x102872C1};
+const TUid QSymbianKFontReleaseFontTable  = {0x2002AC24};
 
 QT_BEGIN_NAMESPACE
 
-#ifdef Q_SYMBIAN_HAS_FONTTABLE_API
 QSymbianTypeFaceExtras::QSymbianTypeFaceExtras(CFont* cFont, COpenFont *openFont)
     : m_cFont(cFont)
     , m_symbolCMap(false)
+    , m_openFont(openFont)
 {
-    Q_UNUSED(openFont)
+    if (!symbianFontTableApiAvailable()) {
+        TAny *trueTypeExtension = NULL;
+        m_openFont->ExtendedInterface(KUidOpenFontTrueTypeExtension, trueTypeExtension);
+        m_trueTypeExtension = static_cast<MOpenFontTrueTypeExtension*>(trueTypeExtension);
+        Q_ASSERT(m_trueTypeExtension);
+    }
 }
 
 QSymbianTypeFaceExtras::~QSymbianTypeFaceExtras()
 {
-    S60->screenDevice()->ReleaseFont(m_cFont);
+    if (symbianFontTableApiAvailable())
+        S60->screenDevice()->ReleaseFont(m_cFont);
 }
 
 QByteArray QSymbianTypeFaceExtras::getSfntTable(uint tag) const
 {
-    RFontTable fontTable;
-    if (fontTable.Open(*m_cFont, tag) != KErrNone)
+    if (symbianFontTableApiAvailable()) {
+        QSymbianTGetFontTableParam fontTableParams = { tag, 0, 0 };
+        if (m_cFont->ExtendedFunction(QSymbianKFontGetFontTable, &fontTableParams) == KErrNone) {
+            const char* const fontTableContent =
+                    static_cast<const char *>(fontTableParams.iContent);
+            const QByteArray fontTable(fontTableContent, fontTableParams.iLength);
+            m_cFont->ExtendedFunction(QSymbianKFontReleaseFontTable, &fontTableParams);
+            return fontTable;
+        }
         return QByteArray();
-    const QByteArray byteArray(reinterpret_cast<const char *>
-            (fontTable.TableContent()),fontTable.TableLength());
-    fontTable.Close();
-    return byteArray;
+    } else {
+        Q_ASSERT(m_trueTypeExtension->HasTrueTypeTable(tag));
+        TInt error = KErrNone;
+        TInt tableByteLength = 0;
+        TAny *table = q_check_ptr(m_trueTypeExtension->GetTrueTypeTable(error, tag, &tableByteLength));
+        const QByteArray result(static_cast<const char*>(table), tableByteLength);
+        m_trueTypeExtension->ReleaseTrueTypeTable(table);
+        return result;
+    }
 }
 
 bool QSymbianTypeFaceExtras::getSfntTableData(uint tag, uchar *buffer, uint *length) const
 {
-    RFontTable fontTable;
-    if (fontTable.Open(*m_cFont, tag) != KErrNone)
-        return false;
-
     bool result = true;
-    const TInt tableByteLength = fontTable.TableLength();
-
-    if (*length > 0 && *length < tableByteLength) {
-        result = false; // Caller did not allocate enough memory
+    if (symbianFontTableApiAvailable()) {
+        QSymbianTGetFontTableParam fontTableParams = { tag, 0, 0 };
+        if (m_cFont->ExtendedFunction(QSymbianKFontGetFontTable, &fontTableParams) == KErrNone) {
+            if (*length > 0 && *length < fontTableParams.iLength) {
+                result = false; // Caller did not allocate enough memory
+            } else {
+                *length = fontTableParams.iLength;
+                if (buffer)
+                    memcpy(buffer, fontTableParams.iContent, fontTableParams.iLength);
+            }
+            m_cFont->ExtendedFunction(QSymbianKFontReleaseFontTable, &fontTableParams);
+        } else {
+            result = false;
+        }
     } else {
-        *length = tableByteLength;
-        if (buffer)
-            memcpy(buffer, fontTable.TableContent(), tableByteLength);
-    }
-
-    fontTable.Close();
-    return result;
-}
-
-#else // Q_SYMBIAN_HAS_FONTTABLE_API
-QSymbianTypeFaceExtras::QSymbianTypeFaceExtras(CFont* cFont, COpenFont *openFont)
-    : m_cFont(cFont)
-    , m_symbolCMap(false)
-    , m_openFont(openFont)
-{
-    TAny *trueTypeExtension = NULL;
-    m_openFont->ExtendedInterface(KUidOpenFontTrueTypeExtension, trueTypeExtension);
-    m_trueTypeExtension = static_cast<MOpenFontTrueTypeExtension*>(trueTypeExtension);
-    Q_ASSERT(m_trueTypeExtension);
-}
-
-QSymbianTypeFaceExtras::~QSymbianTypeFaceExtras()
-{
-}
-
-QByteArray QSymbianTypeFaceExtras::getSfntTable(uint tag) const
-{
-    Q_ASSERT(m_trueTypeExtension->HasTrueTypeTable(tag));
-    TInt error = KErrNone;
-    TInt tableByteLength = 0;
-    TAny *table = q_check_ptr(m_trueTypeExtension->GetTrueTypeTable(error, tag, &tableByteLength));
-    QByteArray result(static_cast<const char*>(table), tableByteLength);
-    m_trueTypeExtension->ReleaseTrueTypeTable(table);
-    return result;
-}
+        if (!m_trueTypeExtension->HasTrueTypeTable(tag))
+            return false;
 
-bool QSymbianTypeFaceExtras::getSfntTableData(uint tag, uchar *buffer, uint *length) const
-{
-    if (!m_trueTypeExtension->HasTrueTypeTable(tag))
-        return false;
+        TInt error = KErrNone;
+        TInt tableByteLength;
+        TAny *table =
+                q_check_ptr(m_trueTypeExtension->GetTrueTypeTable(error, tag, &tableByteLength));
 
-    bool result = true;
-    TInt error = KErrNone;
-    TInt tableByteLength;
-    TAny *table =
-        q_check_ptr(m_trueTypeExtension->GetTrueTypeTable(error, tag, &tableByteLength));
+        if (error != KErrNone) {
+            return false;
+        } else if (*length > 0 && *length < tableByteLength) {
+            result = false; // Caller did not allocate enough memory
+        } else {
+            *length = tableByteLength;
+            if (buffer)
+                memcpy(buffer, table, tableByteLength);
+        }
 
-    if (error != KErrNone) {
-        return false;
-    } else if (*length > 0 && *length < tableByteLength) {
-        result = false; // Caller did not allocate enough memory
-    } else {
-        *length = tableByteLength;
-        if (buffer)
-            memcpy(buffer, table, tableByteLength);
+        m_trueTypeExtension->ReleaseTrueTypeTable(table);
     }
-
-    m_trueTypeExtension->ReleaseTrueTypeTable(table);
     return result;
 }
-#endif // Q_SYMBIAN_HAS_FONTTABLE_API
 
 const uchar *QSymbianTypeFaceExtras::cmap() const
 {
@@ -195,6 +196,39 @@ QFixed QSymbianTypeFaceExtras::unitsPerEm() const
     return m_unitsPerEm;
 }
 
+bool QSymbianTypeFaceExtras::symbianFontTableApiAvailable()
+{
+    enum FontTableApiAvailability {
+        Unknown,
+        Available,
+        Unavailable
+    };
+    static FontTableApiAvailability availability =
+            QSysInfo::symbianVersion() < QSysInfo::SV_SF_3 ?
+                Unavailable : Unknown;
+    if (availability == Unknown) {
+        // Actually, we should ask CFeatureDiscovery::IsFeatureSupportedL()
+        // with FfFontTable here. But since at the time of writing, the
+        // FfFontTable flag check either gave false positives or false
+        // negatives. Here comes an implicit check via CFont::ExtendedFunction.
+        QSymbianTGetFontTableParam fontTableParams = {
+            MAKE_TAG('O', 'S', '/', '2'), 0, 0 };
+        QSymbianFbsHeapLock lock(QSymbianFbsHeapLock::Unlock);
+        CFont *font;
+        const TInt getFontErr = S60->screenDevice()->GetNearestFontInTwips(font, TFontSpec());
+        Q_ASSERT(getFontErr == KErrNone);
+        if (font->ExtendedFunction(QSymbianKFontGetFontTable, &fontTableParams) == KErrNone) {
+            font->ExtendedFunction(QSymbianKFontReleaseFontTable, &fontTableParams);
+            availability = Available;
+        } else {
+            availability = Unavailable;
+        }
+        S60->screenDevice()->ReleaseFont(font);
+        lock.relock();
+    }
+    return availability == Available;
+}
+
 // duplicated from qfontengine_xyz.cpp
 static inline unsigned int getChar(const QChar *str, int &i, const int len)
 {
diff --git a/src/gui/text/qfontengine_s60_p.h b/src/gui/text/qfontengine_s60_p.h
index c65ce55..cdf2185 100644
--- a/src/gui/text/qfontengine_s60_p.h
+++ b/src/gui/text/qfontengine_s60_p.h
@@ -58,13 +58,11 @@
 #include "qsize.h"
 #include <openfont.h>
 
-#ifdef SYMBIAN_GDI_GLYPHDATA
-#define Q_SYMBIAN_HAS_FONTTABLE_API
-#endif
-
-#ifdef Q_SYMBIAN_HAS_FONTTABLE_API
+// The glyph outline code is intentionally disabled. It will be reactivated as
+// soon as the glyph outline API is backported from Symbian(^4) to Symbian(^3).
+#if 0
 #define Q_SYMBIAN_HAS_GLYPHOUTLINE_API
-#endif // Q_SYMBIAN_HAS_FONTTABLE_API
+#endif
 
 class CFont;
 
@@ -83,16 +81,18 @@ public:
     CFont *fontOwner() const;
     bool isSymbolCMap() const;
     QFixed unitsPerEm() const;
+    static bool symbianFontTableApiAvailable();
 
 private:
     CFont* m_cFont;
     mutable bool m_symbolCMap;
     mutable QByteArray m_cmapTable;
     mutable QFixed m_unitsPerEm;
-#ifndef Q_SYMBIAN_HAS_FONTTABLE_API
+
+    // m_openFont and m_openFont are used if Symbian does not provide
+    // the Font Table API
     COpenFont *m_openFont;
     mutable MOpenFontTrueTypeExtension *m_trueTypeExtension;
-#endif // Q_SYMBIAN_HAS_FONTTABLE_API
 };
 
 class QFontEngineS60 : public QFontEngine
diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
index 3ddc15a..4a64f39 100644
--- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
+++ b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
@@ -1464,6 +1464,7 @@ namespace {
         QSize cacheSize;
         QGL2PEXVertexArray vertexCoordinateArray;
         QGL2PEXVertexArray textureCoordinateArray;
+        QFontEngineGlyphCache::Type glyphType;
     };
 
 }
@@ -1477,22 +1478,29 @@ void QGL2PaintEngineExPrivate::drawCachedGlyphs(QFontEngineGlyphCache::Type glyp
 
     QOpenGL2PaintEngineState *s = q->state();
 
+    bool recreateVertexArrays = false;
+
     QGLTextureGlyphCache *cache =
         (QGLTextureGlyphCache *) staticTextItem->fontEngine()->glyphCache(ctx, glyphType, QTransform());
     if (!cache || cache->cacheType() != glyphType) {
         cache = new QGLTextureGlyphCache(ctx, glyphType, QTransform());
         staticTextItem->fontEngine()->setGlyphCache(ctx, cache);
+        recreateVertexArrays = true;
     } else if (cache->context() == 0) { // Old context has been destroyed, new context has same ptr value
         cache->setContext(ctx);
     }
 
-    bool recreateVertexArrays = false;
-    if (staticTextItem->userDataNeedsUpdate)
+    if (staticTextItem->userDataNeedsUpdate) {
         recreateVertexArrays = true;
-    else if (staticTextItem->userData() == 0)
+    } else if (staticTextItem->userData() == 0) {
         recreateVertexArrays = true;
-    else if (staticTextItem->userData()->type != QStaticTextUserData::OpenGLUserData)
+    } else if (staticTextItem->userData()->type != QStaticTextUserData::OpenGLUserData) {
         recreateVertexArrays = true;
+    } else {
+        QOpenGLStaticTextUserData *userData = static_cast<QOpenGLStaticTextUserData *>(staticTextItem->userData());
+        if (userData->glyphType != glyphType)
+            recreateVertexArrays = true;
+    }
 
     // We only need to update the cache with new glyphs if we are actually going to recreate the vertex arrays.
     // If the cache size has changed, we do need to regenerate the vertices, but we don't need to repopulate the
@@ -1504,8 +1512,8 @@ void QGL2PaintEngineExPrivate::drawCachedGlyphs(QFontEngineGlyphCache::Type glyp
 	    // No space in cache. We need to clear the cache and try again
             cache->clear();
             cache->populate(staticTextItem->fontEngine(), staticTextItem->numGlyphs,
-			    staticTextItem->glyphs, staticTextItem->glyphPositions);
-	}
+                            staticTextItem->glyphs, staticTextItem->glyphPositions);
+        }
     }
 
     if (cache->width() == 0 || cache->height() == 0)
@@ -1535,6 +1543,8 @@ void QGL2PaintEngineExPrivate::drawCachedGlyphs(QFontEngineGlyphCache::Type glyp
             userData = static_cast<QOpenGLStaticTextUserData*>(staticTextItem->userData());
         }
 
+        userData->glyphType = glyphType;
+
         // Use cache if backend optimizations is turned on
         vertexCoordinates = &userData->vertexCoordinateArray;
         textureCoordinates = &userData->textureCoordinateArray;
@@ -2139,7 +2149,11 @@ void QGL2PaintEngineEx::clip(const QVectorPath &path, Qt::ClipOperation op)
         const QPointF* const points = reinterpret_cast<const QPointF*>(path.points());
         QRectF rect(points[0], points[2]);
 
-        if (state()->matrix.type() <= QTransform::TxScale) {
+        if (state()->matrix.type() <= QTransform::TxScale
+            || (state()->matrix.type() == QTransform::TxRotate
+                && qFuzzyIsNull(state()->matrix.m11())
+                && qFuzzyIsNull(state()->matrix.m22())))
+        {
             state()->rectangleClip = state()->rectangleClip.intersected(state()->matrix.mapRect(rect).toRect());
             d->updateClipScissorTest();
             return;