Runtime dependency on Symbians Font Table API

The Symbian Font Table API is a feature from (the former)
Symbian^4 which will be backported into Symbian^3 in a
random minor OS version. In order to keep Qt source and binary
compatible between these minor versions, we cannot decide at
compile time whether or not to use the new Font Table API.

This patch changes many "#ifdef Q_SYMBIAN_HAS_FONTTABLE_API"
into "if (symbianFontTableApiAvailable())". The Font Table
feature is detected at runtime. Currently, CFeatureDiscovery
is not used, because at the time of writing, that feature flag
test would give false positives or false negatives. Instead,
CFont::ExtendedFunction() is called with KFontGetFontTable to
see if the return value is KErrNone, which indicates that the
feature is available. The avalibility information gets cached,
so the hack happens only once per application run.

The font table Api feature comes with helper classes such as
"RFontTable" and  "TGetFontTableParam". But we cannot use those,
because we want to stay source and binary compatible across the
Symbian(^3) versions without the Font table API and those with.
So, in Qt, RFontTable is simply not used and TGetFontTableParam
is replicated as "QSymbianTGetFontTableParam". Same for
KFontGetFontTable, KFontReleaseFontTable and later also
FfFontTable.

This patch has been looked at by colleagues, who verified the
overall #ifdef to if() conversion, but did not feel entitled to
give their official Reviewed-By for an obscure topic like Qt
font support on Symbian. (It sucks to be the only creature in
this universe who -kind of- knows how Qt text handling and
Symbian text handling interact)

Task-Number: QTBUG-15515

1 files changed, 108 insertions, 74 deletions

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)
 {