Changeset 222

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.

Location:

trunk/src/gui/text

Files:

• qfontdatabase.cpp (modified) (8 diffs)
• qfontdatabase_pm.cpp (modified) (5 diffs)
• qfontengine_pm.cpp (modified) (1 diff)
• qfontengine_pm_p.h (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>
@@ -148 +145 @@
                                 uint yres = 0, uint avgwidth = 0, bool add = false);
 #endif // Q_WS_X11
-#ifdef Q_WS_QWS
+#if
     QByteArray fileName;
     int fileIndex;
-#endif
-#ifdef Q_WS_PM
-    unsigned short pointSize; // in deca-points
-    LONG lMatch;
 #endif
 };
@@ -219 +212 @@
         weightName = setwidthName = 0;
 #endif // Q_WS_X11
-#if defined(Q_WS_PM)
-        faceName[0] = 0;
-#endif
     }
 
@@ -234 +224 @@
             free(pixelSizes[count].encodings);
 #endif
-#ifdef Q_WS_QWS
+#if
             pixelSizes[count].fileName.~QByteArray();
 #endif
@@ -252 +242 @@
     const char *setwidthName;
 #endif // Q_WS_X11
-#ifdef Q_WS_QWS
+#if
     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
 };
 
@@ -280 +262 @@
 }
 
-#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)
@@ -310 +280 @@
     pixelSizes[count].encodings = 0;
 #endif
-#ifdef Q_WS_QWS
+#if
     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++);
@@ -401 +367 @@
     {
         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() {

trunk/src/gui/text/qfontdatabase_pm.cpp

@@ -46 +46 @@
 #include "qfontengine_pm_p.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
+
     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 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;
 }

trunk/src/gui/text/qfontengine_pm.cpp

@@ -58 +58 @@
     : QFontEngineFT(fd)
 {
-    QFontEngine::FaceId face_id;
-    // @todo temporary:
-    ULONG bootDrive = 0;
-    DosQuerySysInfo(QSV_BOOT_DRIVE, QSV_BOOT_DRIVE, (PVOID)&bootDrive,
-                    sizeof(bootDrive));
-    QByteArray font(1, bootDrive + 'A' - 1);
-    font += ":\\PSFONTS\\HELV.PFB";
-
-    face_id.filename = font;
-    face_id.index = 0;
-
-    init(face_id, true /*antialias*/);
 }
 

trunk/src/gui/text/qfontengine_pm_p.h

@@ -68 +68 @@
 #ifndef QT_NO_FREETYPE
 
-class QFreetypeFace;
-
 class Q_GUI_EXPORT QFontEnginePMFT : public QFontEngineFT
 {