Changeset 222 for trunk/src/gui/text/qfontdatabase_pm.cpp

Timestamp:

Oct 14, 2009, 2:32:13 AM (16 years ago)

Author:

Dmitry A. Kuminov

Message:

gui: Changed to using the Freetype2 library for populating the fonts. Implemented font matching against populated fonts.

File:

• trunk/src/gui/text/qfontdatabase_pm.cpp (modified) (5 diffs)

trunk/src/gui/text/qfontdatabase_pm.cpp

@@ -46 +46 @@
 #include "qfontengine_pm_p.h"
 
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_TYPES_H
+#include FT_TRUETYPE_TABLES_H
+
 QT_BEGIN_NAMESPACE
 
@@ -66 +71 @@
     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)
+    QList<QByteArray> fontFiles;
+
+    ULONG bufSize = 0;
+    BOOL ok = PrfQueryProfileSize(HINI_USERPROFILE, "PM_Fonts", 0, &bufSize);
+    Q_ASSERT(ok);
+    if (ok) {
+        char *buffer = new char[bufSize + 1 /*terminating NULL*/];
+        Q_ASSERT(buffer);
+        if (buffer) {
+            ULONG bufLen = PrfQueryProfileString(HINI_USERPROFILE, "PM_Fonts", 0, 0,
+                                                 buffer, bufSize);
+            if (bufLen) {
+                char *key = buffer;
+                while (*key) {
+                    ULONG keySize = 0;
+                    ok = PrfQueryProfileSize(HINI_USERPROFILE, "PM_Fonts", key,
+                                             &keySize);
+                    if (ok) {
+                        QByteArray file(keySize, 0);
+                        ULONG keyLen =
+                            PrfQueryProfileString(HINI_USERPROFILE, "PM_Fonts", key, 0,
+                                                  file.data(), file.size());
+                        file.truncate(keyLen - 1 /*terminating NULL*/);
+                        if (!file.isEmpty()) {
+                            // FreeType doesn't understand .OFM but understands .PFB
+                            if (file.toUpper().endsWith(".OFM")) {
+                                file.chop(4);
+                                file.append(".PFB");
+                            }
+                            fontFiles << file;
+                        }
+                    }
+                    key += strlen(key) + 1;
+                }
+            }
+            delete buffer;
+        }
+    }
+
+    extern FT_Library qt_getFreetype(); // qfontengine_ft.cpp
+    FT_Library lib = qt_getFreetype();
+
+    foreach(const QByteArray &file, fontFiles) {
+        FT_Face face;
+        FT_Error rc = FT_New_Face(lib, file, -1, &face);
+
+        FD_DEBUG("populateDatabase: Font file %s: FT error %d, has %ld faces",
+                 file.constData(), (int) rc, rc ? -1 : face->num_faces);
+        if (rc != 0)
             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))
+        FT_Long numFaces = face->num_faces;
+        FT_Done_Face(face);
+
+        // go throuhg each face
+        for (FT_Long idx = 0; idx < numFaces; ++idx) {
+            rc = FT_New_Face(lib, file, idx, &face);
+            if (rc != 0)
                 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;
+
+            QString familyName = QString::fromLatin1(face->family_name);
+
+            QtFontStyle::Key styleKey;
+
+            styleKey.style = face->style_flags & FT_STYLE_FLAG_ITALIC ?
+                QFont::StyleItalic : QFont::StyleNormal;
+
+            TT_OS2 *os2_table = 0;
+            if (face->face_flags & FT_FACE_FLAG_SFNT) {
+                os2_table = (TT_OS2 *)FT_Get_Sfnt_Table(face, ft_sfnt_os2);
+            }
+            if (os2_table) {
+                // map weight and width values
+                if (os2_table->usWeightClass < 400)
+                    styleKey.weight = QFont::Light;
+                else if (os2_table->usWeightClass < 600)
+                    styleKey.weight = QFont::Normal;
+                else if (os2_table->usWeightClass < 700)
+                    styleKey.weight = QFont::DemiBold;
+                else if (os2_table->usWeightClass < 800)
+                    styleKey.weight = QFont::Bold;
+                else
+                    styleKey.weight = QFont::Black;
+
+                switch (os2_table->usWidthClass) {
+                    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;
+                }
+            } else {
+                // we've only got simple weight information and no stretch
+                styleKey.weight = face->style_flags & FT_STYLE_FLAG_BOLD ?
+                    QFont::Bold : QFont::Normal;
+                styleKey.stretch = QFont::Unstretched;
+            }
+
+            QtFontFamily *family = privateDb()->family(familyName, true);
+
+            // @todo is it possible that the same family is both fixed and not?
+            Q_ASSERT(!family->fixedPitch || face->face_flags & FT_FACE_FLAG_FIXED_WIDTH);
+            family->fixedPitch = face->face_flags & FT_FACE_FLAG_FIXED_WIDTH;
+
+            // writing systems aren't used ATM, let's support just Any
+            family->writingSystems[QFontDatabase::Any] = QtFontFamily::Supported;
+
+            QtFontFoundry *foundry = family->foundry(foundryName, true);
+            QtFontStyle *style = foundry->style(styleKey, true);
+
+            // so far, all recognized fonts are antialiased
+            style->antialiased = true;
+
+            if ((face->face_flags & FT_FACE_FLAG_SCALABLE) &&
+                !style->smoothScalable) {
+                // 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.
+                style->smoothScalable = true;
+                QtFontSize *size =
+                    style->pixelSize(SMOOTH_SCALABLE, true);
+                size->fileName = file;
+                size->fileIndex = idx;
+            }
+
+            // the font may both be scalable and contain fixed size bitmaps
+            if (face->face_flags & FT_FACE_FLAG_FIXED_SIZES) {
+                for (FT_Int i = 0; i < face->num_fixed_sizes; ++i) {
+                    QtFontSize *size =
+                        style->pixelSize(face->available_sizes[i].height, true);
+                    // the first bitmap style with a given pixel and point size wins
+                    if (!size->fileName.isEmpty())
+                        continue;
+                    size->fileName = file;
+                    size->fileIndex = idx;
+                }
+            }
+
+            FT_Done_Face(face);
+        }
+    }
 }
 
@@ -181 +229 @@
 #ifdef QFONTDATABASE_DEBUG
     // print the database
+    qDebug("initializeDb:");
     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:");
@@ -193 +241 @@
         for (int fd = 0; fd < family->count; fd++) {
             QtFontFoundry *foundry = family->foundries[fd];
-            qDebug("        %s", qPrintable(foundry->name));
+            qDebug("        %s", foundry->name.isEmpty() ? "(empty foundry)" :
+                   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);
-                    }
+                for(int i = 0; i < style->count; ++i) {
+                    if (style->pixelSizes[i].pixelSize == SMOOTH_SCALABLE)
+                        qDebug("                smooth %s:%d",
+                               style->pixelSizes[i].fileName.constData(),
+                               style->pixelSizes[i].fileIndex);
+                    else
+                        qDebug("                %d px %s:%d", style->pixelSizes[i].pixelSize,
+                               style->pixelSizes[i].fileName.constData(),
+                               style->pixelSizes[i].fileIndex);
                 }
             }
@@ -220 +274 @@
 }
 
+static const char *styleHint(const QFontDef &request)
+{
+    const char *stylehint = 0;
+    switch (request.styleHint) {
+    case QFont::SansSerif:
+        stylehint = "Helvetica";
+        break;
+    case QFont::Serif:
+        stylehint = "Roman";
+        break;
+    case QFont::TypeWriter:
+        stylehint = "Courier";
+        break;
+    default:
+        if (request.fixedPitch)
+            stylehint = "Courier";
+        else
+            stylehint = "Helvetica";
+        break;
+    }
+    return stylehint;
+}
+
+static QFontDef fontDescToFontDef(const QFontDef &req, const QtFontDesc &desc)
+{
+    static LONG dpi = -1;
+    if (dpi == -1) {
+        // PM cannot change resolutions on the fly so cache it
+        int hps = qt_display_ps();
+        DevQueryCaps(GpiQueryDevice(hps), CAPS_HORIZONTAL_FONT_RES, 1, &dpi);
+    }
+
+    QFontDef fontDef;
+
+    fontDef.family = desc.family->name;
+
+    if (desc.size->pixelSize == SMOOTH_SCALABLE) {
+        // scalable font matched, calculate the missing size (points or pixels)
+        fontDef.pointSize = req.pointSize;
+        fontDef.pixelSize = req.pixelSize;
+        if (req.pointSize < 0) {
+            fontDef.pointSize = req.pixelSize * 72. / dpi;
+        } else if (req.pixelSize == -1) {
+            fontDef.pixelSize = qRound(req.pointSize * dpi / 72.);
+        }
+    } else {
+        // non-scalable font matched, calculate both point and pixel size
+        fontDef.pixelSize = desc.size->pixelSize;
+        fontDef.pointSize = desc.size->pixelSize * 72. / dpi;
+    }
+
+    fontDef.styleStrategy = req.styleStrategy;
+    fontDef.styleHint = req.styleHint;
+
+    fontDef.weight = desc.style->key.weight;
+    fontDef.fixedPitch = desc.family->fixedPitch;
+    fontDef.style = desc.style->key.style;
+    fontDef.stretch = desc.style->key.stretch;
+
+    return fontDef;
+}
+
+static QFontEngine *loadEngine(const QFontDef &req, const QtFontDesc &desc)
+{
+    QFontEngineFT *fe = new QFontEnginePMFT(fontDescToFontDef(req, desc));
+    Q_ASSERT(fe);
+    if (fe) {
+        QFontEngine::FaceId faceId;
+        faceId.filename = desc.size->fileName;
+        faceId.index = desc.size->fileIndex;
+        fe->init(faceId, desc.style->antialiased);
+        if (fe->invalid()) {
+            FM_DEBUG("   --> invalid!\n");
+            delete fe;
+            fe = 0;
+        }
+    }
+    return fe;
+}
+
 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);
+    // list of families to try
+    QStringList families = familyList(req);
+
+    const char *stylehint = styleHint(d->request);
+    if (stylehint)
+        families << QLatin1String(stylehint);
+
+    // add the default family
+    QString defaultFamily = QApplication::font().family();
+    if (! families.contains(defaultFamily))
+        families << defaultFamily;
+
+    // add QFont::defaultFamily() to the list, for compatibility with
+    // previous versions
+    families << QApplication::font().defaultFamily();
+
+    // null family means find the first font matching the specified script
+    families << QString();
+
+    QtFontDesc desc;
+    QFontEngine *fe = 0;
+    QList<int> blacklistedFamilies;
+
+    while (!fe) {
+        for (int i = 0; i < families.size(); ++i) {
+            QString family, foundry;
+            parseFontName(families.at(i), foundry, family);
+            FM_DEBUG("loadPM: >>>>>>>>>>>>>> trying to match '%s'", qPrintable(family));
+            QT_PREPEND_NAMESPACE(match)(script, req, family, foundry, -1, &desc, blacklistedFamilies);
+            if (desc.family)
+                break;
+        }
+        if (!desc.family)
+            break;
+        fe = loadEngine(req, desc);
+        if (!fe)
+            blacklistedFamilies.append(desc.familyIndex);
+    }
     return fe;
 }