Changeset 220 for trunk/src

Timestamp:

Oct 12, 2009, 11:37:39 PM (16 years ago)

Author:

Dmitry A. Kuminov

Message:

gui: Added enumeration of installed PM fonts.

Location:

trunk/src/gui/text

Files:

• qfontdatabase.cpp (modified) (9 diffs)
• qfontdatabase_pm.cpp (modified) (2 diffs)
• text.pri (modified) (1 diff)

trunk/src/gui/text/qfontdatabase.cpp

@@ -54 +54 @@
 #include <locale.h>
 #endif
+#ifdef Q_WS_PM
+#include "qt_os2.h"
+#endif
+
 #include <stdlib.h>
 #include <limits.h>
@@ -74 +78 @@
 #  define for if(0){}else for
 #endif
+
+#define SMOOTH_SCALABLE 0xffff
 
 QT_BEGIN_NAMESPACE
@@ -146 +152 @@
     int fileIndex;
 #endif
+#ifdef Q_WS_PM
+    unsigned short pointSize; // in deca-points
+    LONG lMatch;
+#endif
 };
 
@@ -209 +219 @@
         weightName = setwidthName = 0;
 #endif // Q_WS_X11
+#if defined(Q_WS_PM)
+        faceName[0] = 0;
+#endif
     }
 
@@ -242 +255 @@
     bool antialiased;
 #endif
-
+#ifdef Q_WS_PM
+    CHAR faceName[FACESIZE];
+#endif
+
+#ifdef Q_WS_PM
+    QtFontSize *pixelSize(unsigned short size, bool = false,
+                          unsigned short pointSize = 0);
+#else
     QtFontSize *pixelSize(unsigned short size, bool = false);
+#endif
 };
 
@@ -259 +280 @@
 }
 
+#ifdef Q_WS_PM
+QtFontSize *QtFontStyle::pixelSize(unsigned short size, bool add,
+                                   unsigned short pointSize)
+#else
 QtFontSize *QtFontStyle::pixelSize(unsigned short size, bool add)
+#endif
 {
     for (int i = 0; i < count; i++) {
+#ifdef Q_WS_PM
+        if (pixelSizes[i].pixelSize == size &&
+        (size == SMOOTH_SCALABLE || !pointSize ||
+         pixelSizes[i].pointSize == pointSize))
+        return pixelSizes + i;
+#else
         if (pixelSizes[i].pixelSize == size)
             return pixelSizes + i;
+#endif
     }
     if (!add)
@@ -280 +313 @@
     new (&pixelSizes[count].fileName) QByteArray;
     pixelSizes[count].fileIndex = 0;
+#endif
+#ifdef Q_WS_PM
+    pixelSizes[count].pointSize = pointSize;
+    pixelSizes[count].lMatch = 0;
 #endif
     return pixelSizes + (count++);
@@ -364 +401 @@
     {
         memset(writingSystems, 0, sizeof(writingSystems));
+#ifdef Q_WS_PM
+        // the concept of writing systems isn't used, let's support just Any
+        writingSystems[QFontDatabase::Any] = Supported;
+#endif
     }
     ~QtFontFamily() {
@@ -867 +908 @@
 }
 
-#define SMOOTH_SCALABLE 0xffff
-
 QT_BEGIN_INCLUDE_NAMESPACE
 #if defined(Q_WS_X11)

trunk/src/gui/text/qfontdatabase_pm.cpp

@@ -48 +48 @@
 QT_BEGIN_NAMESPACE
 
+static void populateDatabase(const QString& fam)
+{
+    QFontDatabasePrivate *db = privateDb();
+    if (!db)
+        return;
+
+    QtFontFamily *family = 0;
+    if(!fam.isEmpty()) {
+        family = db->family(fam);
+        if(family)
+            return;
+    } else if (db->count) {
+        return;
+    }
+
+    // we don't recognize foundries on OS/2, use an empty one
+    const QString foundryName;
+
+    int hps = qt_display_ps();
+
+    LONG cFonts = 0;
+    cFonts = GpiQueryFonts(hps, QF_PUBLIC, NULL, &cFonts, 0, NULL);
+    PFONTMETRICS afm = new FONTMETRICS[cFonts];
+    GpiQueryFonts(hps, QF_PUBLIC, NULL, &cFonts, sizeof(FONTMETRICS), afm);
+
+    LONG info[2];
+    DevQueryCaps(GpiQueryDevice(hps), CAPS_HORIZONTAL_FONT_RES, 2, info);
+    LONG xRes = info[0], yRes = info[1];
+
+    for (PFONTMETRICS fm = afm ; cFonts ; cFonts--, fm++) {
+        // ignore the default (lMatch = 0) GPI font, since it is always
+        // present with non-zero lMatch in the list
+        if (!fm->lMatch)
+            continue;
+
+        QString familyName = QString::fromLocal8Bit(fm->szFamilyname);
+        bool italic = fm->fsSelection & FM_SEL_ITALIC;
+        bool fixed = fm->fsType & FM_TYPE_FIXED;
+        bool scalable = fm->fsDefn & FM_DEFN_OUTLINE;
+        USHORT weight = fm->usWeightClass;
+        USHORT width = fm->usWidthClass;
+
+        // ignore bitmap fonts that do not match the current device resolution
+        if (!scalable && (fm->sXDeviceRes != xRes || fm->sYDeviceRes != yRes))
+            continue;
+
+        // the "@family" fonts are just the same as "family". Ignore them.
+        if (familyName[0] == '@')
+            continue;
+
+        QtFontStyle::Key styleKey;
+        styleKey.style = italic ? QFont::StyleItalic : QFont::StyleNormal;
+
+        if (weight < 4)
+            styleKey.weight = QFont::Light;
+        else if (weight < 6)
+            styleKey.weight = QFont::Normal;
+        else if (weight < 7)
+            styleKey.weight = QFont::DemiBold;
+        else if (weight < 8)
+            styleKey.weight = QFont::Bold;
+        else
+            styleKey.weight = QFont::Black;
+
+        switch (width) {
+            case 1: styleKey.stretch = QFont::UltraCondensed; break;
+            case 2: styleKey.stretch = QFont::ExtraCondensed; break;
+            case 3: styleKey.stretch = QFont::Condensed; break;
+            case 4: styleKey.stretch = QFont::SemiCondensed; break;
+            case 5: styleKey.stretch = QFont::Unstretched; break;
+            case 6: styleKey.stretch = QFont::SemiExpanded; break;
+            case 7: styleKey.stretch = QFont::Expanded; break;
+            case 8: styleKey.stretch = QFont::ExtraExpanded; break;
+            case 9: styleKey.stretch = QFont::UltraExpanded; break;
+            default: styleKey.stretch = QFont::Unstretched; break;
+        }
+
+        // @todo why?
+        familyName.replace('-', ' ');
+
+        QtFontFamily *family = privateDb()->family(familyName, true);
+        // @todo is it possible that the same family is both fixed and not?
+        family->fixedPitch = fixed;
+
+        QtFontFoundry *foundry = family->foundry(foundryName, true);
+        QtFontStyle *style = foundry->style(styleKey, true);
+
+        // add new scalable style only if it hasn't been already added --
+        // the first one of two duplicate (in Qt terms) non-bitmap font
+        // styles wins.
+        if (scalable && style->smoothScalable)
+            continue;
+
+        if (style->faceName[0]) {
+            // if a duplicate (having the same style in Qt terms) bitmap
+            // font is encountered but it has the different facename, ignore
+            // it (we have only one facename field per style -- it should be
+            // the same for all sizes otherwise we will not be able to create
+            // a font with some sizes later).
+            if (strcmp(style->faceName, fm->szFacename))
+                continue;
+        } else {
+            strcpy(style->faceName, fm->szFacename);
+        }
+
+        if (scalable) {
+            style->smoothScalable = TRUE;
+            QtFontSize *size =
+                style->pixelSize(SMOOTH_SCALABLE, TRUE, fm->sNominalPointSize);
+            size->lMatch = fm->lMatch;
+        } else {
+            QtFontSize *size =
+                style->pixelSize(fm->lEmHeight, TRUE, fm->sNominalPointSize);
+            // the first bitmap style with a given pixel and point size wins
+            if (size->lMatch)
+                continue;
+            size->lMatch = fm->lMatch;
+        }
+    }
+
+    delete[] afm;
+}
+
 static void initializeDb()
 {
+    QFontDatabasePrivate *db = privateDb();
+    if (!db || db->count)
+        return;
+
+    populateDatabase(QString());
+
+#ifdef QFONTDATABASE_DEBUG
+    // print the database
+    for (int f = 0; f < db->count; f++) {
+        QtFontFamily *family = db->families[f];
+        qDebug("    %s: %p", qPrintable(family->name), family);
+        populateDatabase(family->name);
+
+#if 1
+        qDebug("        scripts supported:");
+        for (int i = 0; i < QUnicodeTables::ScriptCount; i++)
+            if(family->writingSystems[i] & QtFontFamily::Supported)
+                qDebug("            %d", i);
+        for (int fd = 0; fd < family->count; fd++) {
+            QtFontFoundry *foundry = family->foundries[fd];
+            qDebug("        %s", qPrintable(foundry->name));
+            for (int s = 0; s < foundry->count; s++) {
+                QtFontStyle *style = foundry->styles[s];
+                qDebug("            style: style=%d weight=%d smooth=%d",  style->key.style,
+                       style->key.weight, style->smoothScalable);
+                if(!style->smoothScalable) {
+                    for(int i = 0; i < style->count; ++i) {
+                        qDebug("                %d", style->pixelSizes[i].pixelSize);
+                    }
+                }
+            }
+        }
+#endif
+    }
+#endif // QFONTDATABASE_DEBUG
+}
+
+static inline void load(const QString &family = QString(), int = -1)
+{
+    populateDatabase(family);
+}
+
+static void registerFont(QFontDatabasePrivate::ApplicationFont *fnt)
+{
     // @todo implement
 }
 
-static inline void load(const QString &family = QString(), int = -1)
-{
-    // @todo implement
-}
-
-static void registerFont(QFontDatabasePrivate::ApplicationFont *fnt)
-{
-    // @todo implement
+static QFontEngine *loadPM(const QFontPrivate *d, int script, const QFontDef &req)
+{
+    // @todo initializeDb() and stuff, get the engine
+    QFontDef fd = req;
+    QFontEngine *fe = new QFontEnginePMFT(fd);
+    return fe;
 }
 
@@ -95 +260 @@
             fe->fontDef = req;
         } else {
-            // @todo initializeDb() and stuff, get the engine
-            QFontDef fd = req;
-            fe = new QFontEnginePMFT(fd);
+            QMutexLocker locker(fontDatabaseMutex());
+            if (!privateDb()->count)
+                initializeDb();
+            fe = loadPM(d, script, req);
         }
         if (!fe) {

trunk/src/gui/text/text.pri

@@ -189 +189 @@
 contains(QT_CONFIG, fontconfig) {
     CONFIG += opentype
+} else {
+    DEFINES *= QT_NO_FONTCONFIG
 }