Changeset 230

Timestamp:

Oct 16, 2009, 3:22:12 PM (16 years ago)

Author:

Dmitry A. Kuminov

Message:

gui: Implemented simple font caching through the QSettings registry. This gets upto 10x faster font population times at application startup and when unknown families are requested.

File:

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

trunk/src/gui/text/qfontdatabase_pm.cpp

@@ -46 +46 @@
 #include "qfontengine_pm_p.h"
 
+
+
+
+
+
 #include <ft2build.h>
 #include FT_FREETYPE_H
@@ -53 +58 @@
 
 QT_BEGIN_NAMESPACE
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 static void populateDatabase(const QString& fam)
@@ -72 +138 @@
     const QString foundryName;
 
-    QList<QByteArray> fontFiles;
+#ifdef QFONTDATABASE_DEBUG
+    QTime timer;
+    timer.start();
+#endif
+
+    QSettings fontCache(QSettings::UserScope, QLatin1String("Trolltech"));
+    fontCache.beginGroup(QLatin1String("Qt/Fonts/Cache 1.0"));
+
+    if (!knownFontFilesInitialized) {
+        // get the initial list of know font files from the cache (necessary to
+        // detect deleted font files)
+        knownFontFilesInitialized = true;
+        QStringList files = fontCache.childGroups();
+        foreach(QString file, files) {
+            file.replace("|", "/");
+            knownFontFiles.insert(file, FileData());
+            // note that QFileInfo is empty so the file will be considered as
+            // NEW which is necessary for the font to get into the database
+        }
+    } else {
+        // reset the 'seen' flag
+        for (FontFileHash::iterator it = knownFontFiles.begin();
+             it != knownFontFiles.end(); ++it)
+            it.value().seen = false;
+    }
+
+    QList<QFileInfo> fontFiles;
 
     ULONG bufSize = 0;
@@ -101 +193 @@
                                 file.append(".PFB");
                             }
-                            fontFiles << file;
+                            QFileInfo fileInfo(QFile::decodeName(file));
+                            QString fileName = fileInfo.canonicalFilePath().toLower();
+                            if (!fileName.isEmpty()) { // file may have been deleted
+                                fileInfo.setFile(fileName);
+                                // check the in-process file name cache
+                                FileData &cached = knownFontFiles[fileName];
+                                if (cached.fileInfo.filePath().isEmpty() ||
+                                    cached.fileInfo.lastModified() != fileInfo.lastModified() ||
+                                    cached.fileInfo.size() != fileInfo.size()) {
+                                    // no cache entry or outdated, process it
+                                    cached.fileInfo = fileInfo;
+                                    cached.seen = true;
+                                    fontFiles << fileInfo;
+                                    FD_DEBUG("populateDatabase: NEW/UPDATED font file %s",
+                                             qPrintable(fileName));
+                                } else {
+                                    // just set the 'seen' flag and skip this font
+                                    // (it's already in the database)
+                                    knownFontFiles[fileName].seen = true;
+                                    FD_DEBUG("populateDatabase: UNCHANGED font file %s",
+                                             qPrintable(fileName));
+                                }
+                            }
                         }
                     }
@@ -114 +228 @@
     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;
-
-        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;
-
-            QString familyName = QString::fromLatin1(face->family_name);
-
-            // familyName may contain extra spaces (at least this is true for
-            // TNR.PFB that is reported as "Times New Roman ". Trim them.
-            familyName = familyName.trimmed();
-
-            QtFontStyle::Key styleKey;
-
-            styleKey.style = face->style_flags & FT_STYLE_FLAG_ITALIC ?
-                QFont::StyleItalic : QFont::StyleNormal;
-
-            QList<QFontDatabase::WritingSystem> systems;
-
-            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;
+    // go through each font file and get available faces
+    foreach(const QFileInfo &fileInfo, fontFiles) {
+        QString fileKey = fileInfo.absoluteFilePath().toLower();
+        QByteArray file = QFile::encodeName(fileKey);
+
+        // QSettings uses / for splitting into groups, suppress it
+        fileKey.replace("/", "|");
+
+        QList<FaceData> cachedFaces;
+
+        // first, look up the cached data
+        fontCache.beginGroup(fileKey);
+
+        if (fontCache.value(QLatin1String("DateTime")).toDateTime() != fileInfo.lastModified() ||
+            fontCache.value(QLatin1String("Size")).toUInt() != fileInfo.size()) {
+            // the cache is outdated or doesn't exist, query the font file
+
+            FT_Long numFaces = 0;
+            FT_Face face;
+
+            FT_Error rc = FT_New_Face(lib, file, -1, &face);
+            if (rc == 0) {
+                numFaces = face->num_faces;
+                FT_Done_Face(face);
+            } else {
+                // invalid/unsupported font file, numFaces is left 0 so that
+                // only DateTime and Size will be cached indicating that this
+                // file is not recognized
+            }
+
+            FD_DEBUG("populateDatabase: Font file %s: FT error %d, has %ld faces",
+                     file.constData(), (int) rc, numFaces);
+
+            // go throuhg each face
+            for (FT_Long idx = 0; idx < numFaces; ++idx) {
+                rc = FT_New_Face(lib, file, idx, &face);
+                if (rc != 0)
+                    continue;
+
+                FaceData cached;
+
+                cached.index = idx;
+                cached.familyName = QString::fromLatin1(face->family_name);
+
+                // familyName may contain extra spaces (at least this is true for
+                // TNR.PFB that is reported as "Times New Roman ". Trim them.
+                cached.familyName = cached.familyName.trimmed();
+
+                cached.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);
                 }
-
-                quint32 unicodeRange[4] = {
-                    os2_table->ulUnicodeRange1, os2_table->ulUnicodeRange2,
-                    os2_table->ulUnicodeRange3, os2_table->ulUnicodeRange4
-                };
-                quint32 codePageRange[2] = {
-                    os2_table->ulCodePageRange1, os2_table->ulCodePageRange2
-                };
-                systems = determineWritingSystemsFromTrueTypeBits(unicodeRange, codePageRange);
-            } 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);
+                if (os2_table) {
+                    // map weight and width values
+                    if (os2_table->usWeightClass < 400)
+                        cached.styleKey.weight = QFont::Light;
+                    else if (os2_table->usWeightClass < 600)
+                        cached.styleKey.weight = QFont::Normal;
+                    else if (os2_table->usWeightClass < 700)
+                        cached.styleKey.weight = QFont::DemiBold;
+                    else if (os2_table->usWeightClass < 800)
+                        cached.styleKey.weight = QFont::Bold;
+                    else
+                        cached.styleKey.weight = QFont::Black;
+
+                    switch (os2_table->usWidthClass) {
+                        case 1: cached.styleKey.stretch = QFont::UltraCondensed; break;
+                        case 2: cached.styleKey.stretch = QFont::ExtraCondensed; break;
+                        case 3: cached.styleKey.stretch = QFont::Condensed; break;
+                        case 4: cached.styleKey.stretch = QFont::SemiCondensed; break;
+                        case 5: cached.styleKey.stretch = QFont::Unstretched; break;
+                        case 6: cached.styleKey.stretch = QFont::SemiExpanded; break;
+                        case 7: cached.styleKey.stretch = QFont::Expanded; break;
+                        case 8: cached.styleKey.stretch = QFont::ExtraExpanded; break;
+                        case 9: cached.styleKey.stretch = QFont::UltraExpanded; break;
+                        default: cached.styleKey.stretch = QFont::Unstretched; break;
+                    }
+
+                    quint32 unicodeRange[4] = {
+                        os2_table->ulUnicodeRange1, os2_table->ulUnicodeRange2,
+                        os2_table->ulUnicodeRange3, os2_table->ulUnicodeRange4
+                    };
+                    quint32 codePageRange[2] = {
+                        os2_table->ulCodePageRange1, os2_table->ulCodePageRange2
+                    };
+                    cached.systems =
+                        determineWritingSystemsFromTrueTypeBits(unicodeRange, codePageRange);
+                } else {
+                    // we've only got simple weight information and no stretch
+                    cached.styleKey.weight = face->style_flags & FT_STYLE_FLAG_BOLD ?
+                        QFont::Bold : QFont::Normal;
+                    cached.styleKey.stretch = QFont::Unstretched;
+                }
+
+                cached.fixedPitch = face->face_flags & FT_FACE_FLAG_FIXED_WIDTH;
+
+                cached.smoothScalable = face->face_flags & FT_FACE_FLAG_SCALABLE;
+
+                // 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) {
+                        cached.pixelSizes << face->available_sizes[i].height;
+                    }
+                }
+
+                cachedFaces << cached;
+
+                FT_Done_Face(face);
+            }
+
+            // store the data into the cache
+            fontCache.setValue(QLatin1String("DateTime"), fileInfo.lastModified());
+            fontCache.setValue(QLatin1String("Size"), fileInfo.size());
+            foreach(FaceData cached, cachedFaces) {
+                QByteArray rawData;
+                QDataStream data(&rawData, QIODevice::WriteOnly);
+                data << cached;
+
+                QString face = QString::number(cached.index);
+                fontCache.beginGroup(face);
+                fontCache.setValue(QLatin1String("Info"), rawData);
+                fontCache.endGroup();
+            }
+        } else {
+            // take the face data from the cache
+
+            QStringList faces = fontCache.childGroups();
+
+            FD_DEBUG("populateDatabase: Font file %s: IN CACHE, has %d faces",
+                     file.constData(), faces.count());
+
+            foreach(QString face, faces) {
+                bool ok = false;
+                FaceData cached;
+                cached.index = face.toInt(&ok);
+                if (!ok || cached.index < 0) // not a valid index
+                    continue;
+
+                fontCache.beginGroup(face);
+                QByteArray rawData =
+                    fontCache.value(QLatin1String("Info")).toByteArray();
+                QDataStream data(rawData);
+                data >> cached;
+                fontCache.endGroup();
+
+                cachedFaces << cached;
+            }
+        }
+
+        fontCache.endGroup();
+
+        // go throuhg each cached face and add it to the database
+        foreach(FaceData cached, cachedFaces) {
+
+            QtFontFamily *family = privateDb()->family(cached.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;
-
-            if (systems.isEmpty() || familyName.compare("Workplace Sans")) {
+            Q_ASSERT(!family->fixedPitch || );
+            family->fixedPitch = ;
+
+            if (familyName.compare("Workplace Sans")) {
                 // it was hard or impossible to determine the actual writing system
                 // of the font (as in case of OS/2 bitmap and PFB fonts for which it is
@@ -210 +405 @@
                     family->writingSystems[ws] = QtFontFamily::Supported;
             } else {
-                for (int i = 0; i < systems.count(); ++i)
-                    family->writingSystems[systems.at(i)] = QtFontFamily::Supported;
+                for (int i = 0; i < systems.count(); ++i)
+                    family->writingSystems[systems.at(i)] = QtFontFamily::Supported;
             }
 
             QtFontFoundry *foundry = family->foundry(foundryName, true);
-            QtFontStyle *style = foundry->style(styleKey, 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) {
+            if (cached.smoothScalable && !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
@@ -229 +423 @@
                     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);
-        }
-    }
+                size->fileIndex = cached.index;
+            }
+
+            foreach(unsigned short pixelSize, cached.pixelSizes) {
+                QtFontSize *size = style->pixelSize(pixelSize, true);
+                // the first bitmap style with a given pixel and point size wins
+                if (!size->fileName.isEmpty())
+                    continue;
+                size->fileName = file;
+                size->fileIndex = cached.index;
+            }
+        }
+    }
+
+    // go through the known file list to detect what files have been removed
+    for (FontFileHash::iterator it = knownFontFiles.begin();
+         it != knownFontFiles.end();) {
+        if (!it.value().seen) {
+            FD_DEBUG("populateDatabase: DELETED font file %s",
+                     qPrintable(it.key()));
+            // remove from the both caches
+            QString fileKey = it.key();
+            fileKey.replace("/", "|");
+            fontCache.remove(fileKey);
+            it = knownFontFiles.erase(it);
+            // @todo should we remove all references to this file from the
+            // font database? My concern is that this font may be in use by Qt
+            // and its glyphs may be still cached when file deletion happens
+        } else {
+            ++it;
+        }
+    }
+
+#ifdef QFONTDATABASE_DEBUG
+    FD_DEBUG("populateDatabase: took %d ms", timer.elapsed());
+#endif
 }