Changeset 500 for trunk/src/gui/text

Timestamp:

Feb 2, 2010, 10:46:30 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

gui/text: Implemented QFontDatabase::addApplicationFont()/removeApplicationFont() and friends (closes #89).

Location:

trunk/src/gui/text

Files:

• qfontdatabase.cpp (modified) (3 diffs)
• qfontdatabase_pm.cpp (modified) (13 diffs)

trunk/src/gui/text/qfontdatabase.cpp

@@ -582 +582 @@
         : count(0), families(0), reregisterAppFonts(false)
 #if defined(Q_WS_QWS)
-          , stream(0)
+        , stream(0)
+#endif
+#if defined(Q_WS_PM)
+        , valid(false)
 #endif
     { }
@@ -634 +637 @@
     QStringList fallbackFamilies;
 #endif
+
+
+
+
 };
 
@@ -640 +647 @@
     QFontCache::instance()->clear();
     free();
+
+
+
     emit static_cast<QApplication *>(QApplication::instance())->fontDatabaseChanged();
 }

trunk/src/gui/text/qfontdatabase_pm.cpp

@@ -61 +61 @@
 QT_BEGIN_NAMESPACE
 
+
+
 struct FaceData
 {
+
     int index;
     QString familyName;
@@ -120 +123 @@
 typedef QHash<QString, FileData> FontFileHash;
 static FontFileHash knownFontFiles;
-static bool knownFontFilesInitialized = false;
 
 static bool lookupFamilyName(FT_Face ftface, QString &familyName)
@@ -287 +289 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 static void populateDatabase(const QString& fam)
 {
@@ -313 +431 @@
     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;
+    if (!db->valid) {
+        // Obtain the initial list of known font files from the font cache in
+        // the registry. This list is used as an in-process cache which speeds
+        // speed up populating by eliminating the need to access the registry
+        // each time an unknown family is requested. This list is also necessary
+        // to detect deleted font files.
+        FD_DEBUG("populateDatabase: INVALID, getting font list from the cache");
+        db->valid = true;
+        knownFontFiles.clear();
         QStringList files = fontCache.childGroups();
         foreach(QString file, files) {
@@ -333 +456 @@
     QList<QFileInfo> fontFiles;
 
+
     ULONG bufSize = 0;
     BOOL ok = PrfQueryProfileSize(HINI_USERPROFILE, "PM_Fonts", 0, &bufSize);
@@ -360 +484 @@
                                 file.append(".PFB");
                             }
-                            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));
-                                }
-                            }
+                            fontFiles << QFileInfo(QFile::decodeName(file));
                         }
                     }
@@ -392 +494 @@
     }
 
-    extern FT_Library qt_getFreetype(); // qfontengine_ft.cpp
+    // add the application-defined fonts (only file-based)
+    foreach(const QFontDatabasePrivate::ApplicationFont &font, db->applicationFonts) {
+        if (!font.fileName.startsWith(QLatin1String(":qmemoryfonts/")))
+            fontFiles << QFileInfo(font.fileName);
+    }
+
+    // go through each font file and check if we have a valid cahce for it
+    for (QList<QFileInfo>::iterator it = fontFiles.begin(); it != fontFiles.end();) {
+        QFileInfo fileInfo = *it;
+        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
+                FD_DEBUG("populateDatabase: NEW/UPDATED font file %s",
+                         qPrintable(fileName));
+                cached.fileInfo = fileInfo;
+                cached.seen = true;
+                // keep it in the list for further inspection
+                ++it;
+                continue;
+            } else {
+                // just set the 'seen' flag and skip this font
+                // (it's already in the database)
+                FD_DEBUG("populateDatabase: UNCHANGED font file %s",
+                         qPrintable(fileName));
+                cached.seen = true;
+            }
+        }
+        // remove from the list, nothing to do with it
+        it = fontFiles.erase(it);
+    }
+
     FT_Library lib = qt_getFreetype();
 
-    // go through each font file and get available faces
+    QList<FaceData> foundFaces;
+
+    // go through each new/outdated font file and get available faces
     foreach(const QFileInfo &fileInfo, fontFiles) {
-        QString fileKey = fileInfo.absoluteFilePath().toLower();
+        QString fileKey = fileInfo.FilePath().toLower();
         QByteArray file = QFile::encodeName(fileKey);
 
@@ -411 +551 @@
             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;
-
-                if (!lookupFamilyName(face, cached.familyName))
-                    cached.familyName = QString::fromLocal8Bit(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);
-                }
-                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);
-            }
+            cachedFaces = readFreeTypeFont(lib, file);
 
             // store the data into the cache
             fontCache.setValue(QLatin1String("DateTime"), fileInfo.lastModified());
             fontCache.setValue(QLatin1String("Size"), fileInfo.size());
+
+
+
+
             foreach(FaceData cached, cachedFaces) {
                 QByteArray rawData;
@@ -525 +572 @@
         } else {
             // take the face data from the cache
-
             QStringList faces = fontCache.childGroups();
 
@@ -534 +580 @@
                 bool ok = false;
                 FaceData cached;
+
                 cached.index = face.toInt(&ok);
                 if (!ok || cached.index < 0) // not a valid index
@@ -549 +596 @@
         }
 
+
+
         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 || cached.fixedPitch);
-            family->fixedPitch = cached.fixedPitch;
-
-            if (cached.systems.isEmpty()) {
-                // 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
-                // usually simply reported that they support standard/system codepages).
-                // Pretend that we support all writing systems to not miss the one.
-                //
-                // @todo find a proper way to detect actual supported scripts to make
-                // sure these fonts are not matched for scripts they don't support.
-                for (int ws = 0; ws < QFontDatabase::WritingSystemsCount; ++ws)
-                    family->writingSystems[ws] = QtFontFamily::Supported;
-            } else {
-                for (int i = 0; i < cached.systems.count(); ++i)
-                    family->writingSystems[cached.systems.at(i)] = QtFontFamily::Supported;
-            }
-
-            QtFontFoundry *foundry = family->foundry(foundryName, true);
-            QtFontStyle *style = foundry->style(cached.styleKey, true);
-
-            // so far, all recognized fonts are antialiased
-            style->antialiased = true;
-
-            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
-                // styles wins.
-                style->smoothScalable = true;
-                QtFontSize *size =
-                    style->pixelSize(SMOOTH_SCALABLE, true);
-                size->fileName = file;
-                size->fileIndex = cached.index;
-                size->systems = cached.systems;
-            }
-
-            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;
-                size->systems = cached.systems;
-            }
+    }
+
+    // get available faces of the application-defined fonts (memory-based)
+    foreach(const QFontDatabasePrivate::ApplicationFont &font, db->applicationFonts) {
+        if (font.fileName.startsWith(QLatin1String(":qmemoryfonts/"))) {
+            QList<FaceData> faces = readFreeTypeFont(lib, font.fileName.toLatin1(),
+                                                     &font.data);
+            foundFaces << faces;
+        }
+    }
+
+    // go throuhg each found face and add it to the database
+    foreach(const FaceData &face, foundFaces) {
+
+        QtFontFamily *family = privateDb()->family(face.familyName, true);
+
+        // @todo is it possible that the same family is both fixed and not?
+        Q_ASSERT(!family->fixedPitch || face.fixedPitch);
+        family->fixedPitch = face.fixedPitch;
+
+        if (face.systems.isEmpty()) {
+            // 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
+            // usually simply reported that they support standard/system codepages).
+            // Pretend that we support all writing systems to not miss the one.
+            //
+            // @todo find a proper way to detect actual supported scripts to make
+            // sure these fonts are not matched for scripts they don't support.
+            for (int ws = 0; ws < QFontDatabase::WritingSystemsCount; ++ws)
+                family->writingSystems[ws] = QtFontFamily::Supported;
+        } else {
+            for (int i = 0; i < face.systems.count(); ++i)
+                family->writingSystems[face.systems.at(i)] = QtFontFamily::Supported;
+        }
+
+        QtFontFoundry *foundry = family->foundry(foundryName, true);
+        QtFontStyle *style = foundry->style(face.styleKey, true);
+
+        // so far, all recognized fonts are antialiased
+        style->antialiased = true;
+
+        if (face.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
+            // styles wins.
+            style->smoothScalable = true;
+            QtFontSize *size =
+                style->pixelSize(SMOOTH_SCALABLE, true);
+            size->fileName = face.file;
+            size->fileIndex = face.index;
+            size->systems = face.systems;
+        }
+
+        foreach(unsigned short pixelSize, face.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 = face.file;
+            size->fileIndex = face.index;
+            size->systems = face.systems;
         }
     }
@@ -683 +741 @@
 static void registerFont(QFontDatabasePrivate::ApplicationFont *fnt)
 {
-    // @todo implement
+    Q_ASSERT(fnt);
+    if (!fnt)
+        return;
+
+    QByteArray file =
+        QFile::encodeName(QDir::current().absoluteFilePath(fnt->fileName));
+
+    FT_Library lib = qt_getFreetype();
+    QList<FaceData> faces = readFreeTypeFont(lib, file, &fnt->data);
+
+    QStringList families;
+
+    foreach(const FaceData &face, faces)
+        if (!families.contains(face.familyName))
+            families << face.familyName;
+
+    fnt->families = families;
 }
 
@@ -896 +970 @@
 bool QFontDatabase::removeApplicationFont(int handle)
 {
-    // @todo implement
+    // nothing special to do here; just empty the given ApplicationFont entry
+
+    QMutexLocker locker(fontDatabaseMutex());
+
+    QFontDatabasePrivate *db = privateDb();
+    if (handle < 0 || handle >= db->applicationFonts.count())
+        return false;
+
+    db->applicationFonts[handle] = QFontDatabasePrivate::ApplicationFont();
+
+    db->invalidate();
+    return true;
+}
+
+bool QFontDatabase::removeAllApplicationFonts()
+{
+    // nothing special to do here; just empty all ApplicationFont entries
+
+    QMutexLocker locker(fontDatabaseMutex());
+
+    QFontDatabasePrivate *db = privateDb();
+    if (db->applicationFonts.isEmpty())
+        return false;
+
+    db->applicationFonts.clear();
+    db->invalidate();
+    return true;
+}
+
+bool QFontDatabase::supportsThreadedFontRendering()
+{
+    // qt_getFreetype() returns a global static FT_Library object but
+    // FreeType2 docs say that each thread should use its own FT_Library
+    // object. For this reason, we return false here to prevent apps from
+    // rendering fonts on threads other than the main GUI thread.
     return false;
 }
 
-bool QFontDatabase::removeAllApplicationFonts()
-{
-    // @todo implement
-    return false;
-}
-
-bool QFontDatabase::supportsThreadedFontRendering()
-{
-    // @todo implement
-    return false;
-}
-
 QT_END_NAMESPACE