QFontDatabasePrivate Class Reference

Classes
struct	ApplicationFont

Public Functions
int	addAppFont (const QByteArray &fontData, const QString &fileName)
void	addFont (const QString &familyname, const char *foundryname, int weight, bool italic, int pixelSize, const QByteArray &file, int fileIndex, bool antialiased, const QList< QFontDatabase::WritingSystem > &writingSystems=QList< QFontDatabase::WritingSystem >())
void	addQPF2File (const QByteArray &file)
QStringList	addTTFile (const QByteArray &file, const QByteArray &fontData=QByteArray())
QtFontFamily *	family (const QString &f, bool=false)
void	free ()
void	invalidate ()
bool	isApplicationFont (const QString &fileName)
bool	loadFromCache (const QString &fontPath)
	QFontDatabasePrivate ()
	~QFontDatabasePrivate ()

Public Variables
QVector< ApplicationFont >	applicationFonts
int	count
IDWriteFactory *	directWriteFactory
IDWriteGdiInterop *	directWriteGdiInterop
QStringList	fallbackFamilies
QtFontFamily **	families
bool	reregisterAppFonts
QDataStream *	stream
QString	systemLang

Detailed Description

Definition at line 644 of file qfontdatabase.cpp.

Constructors and Destructors

QFontDatabasePrivate()

QFontDatabasePrivate::QFontDatabasePrivate ( )

inline

Definition at line 647 of file qfontdatabase.cpp.

        : count(0), families(0), reregisterAppFonts(false)
#if defined(Q_WS_QWS)
          , stream(0)
#endif
#if defined(Q_OS_SYMBIAN) && defined(QT_NO_FREETYPE)
          , symbianExtras(0)
#endif
#if defined(Q_WS_WIN) && !defined(QT_NO_DIRECTWRITE)
          , directWriteFactory(0)
          , directWriteGdiInterop(0)
#endif
    { }

~QFontDatabasePrivate()

QFontDatabasePrivate::~QFontDatabasePrivate ( )

inline

Definition at line 661 of file qfontdatabase.cpp.

                            {
        free();
#if defined(Q_OS_SYMBIAN) && defined(QT_NO_FREETYPE)
        if (symbianExtras)
            delete symbianExtras;
#endif
#if defined(Q_WS_WIN) && !defined(QT_NO_DIRECTWRITE)
    if (directWriteGdiInterop)
        directWriteGdiInterop->Release();
    if (directWriteFactory != 0)
        directWriteFactory->Release();
#endif
    }

Functions

addAppFont()

int QFontDatabasePrivate::addAppFont	(	const QByteArray &	fontData,
		const QString &	fileName
	)

Definition at line 2600 of file qfontdatabase.cpp.

{
    QFontDatabasePrivate::ApplicationFont font;
    font.data = fontData;
    font.fileName = fileName;

    int i;
    for (i = 0; i < applicationFonts.count(); ++i)
        if (applicationFonts.at(i).families.isEmpty())
            break;
    if (i >= applicationFonts.count()) {
        applicationFonts.append(ApplicationFont());
        i = applicationFonts.count() - 1;
    }

    if (font.fileName.isEmpty() && !fontData.isEmpty())
        font.fileName = QString::fromLatin1(":qmemoryfonts/") + QString::number(i);

    registerFont(&font);
    if (font.families.isEmpty())
        return -1;

    applicationFonts[i] = font;

    invalidate();
    return i;
}

addFont()

void QFontDatabasePrivate::addFont	(	const QString &	familyname,
		const char *	foundryname,
		int	weight,
		bool	italic,
		int	pixelSize,
		const QByteArray &	file,
		int	fileIndex,
		bool	antialiased,
		const QList< QFontDatabase::WritingSystem > &	writingSystems = QList<QFontDatabase::WritingSystem>()
	)

Definition at line 789 of file qfontdatabase.cpp.

Referenced by addQPF2File(), initializeDb(), and loadFromCache().

{
//    qDebug() << "Adding font" << familyname << weight << italic << pixelSize << file << fileIndex << antialiased;
    QtFontStyle::Key styleKey;
    styleKey.style = italic ? QFont::StyleItalic : QFont::StyleNormal;
    styleKey.weight = weight;
    styleKey.stretch = 100;
    QtFontFamily *f = family(familyname, true);

    if (writingSystems.isEmpty()) {
        for (int ws = 1; ws < QFontDatabase::WritingSystemsCount; ++ws) {
            f->writingSystems[ws] = QtFontFamily::Supported;
        }
        f->bogusWritingSystems = true;
    } else {
        for (int i = 0; i < writingSystems.count(); ++i) {
            f->writingSystems[writingSystems.at(i)] = QtFontFamily::Supported;
        }
    }

    QtFontFoundry *foundry = f->foundry(QString::fromLatin1(foundryname), true);
    QtFontStyle *style = foundry->style(styleKey, QString(), true);
    style->smoothScalable = (pixelSize == 0);
    style->antialiased = antialiased;
    QtFontSize *size = style->pixelSize(pixelSize?pixelSize:SMOOTH_SCALABLE, true);
    size->fileName = file;
    size->fileIndex = fileIndex;

#if defined(Q_WS_QWS)
    if (stream) {
        *stream << familyname << foundry->name << weight << quint8(italic) << pixelSize
                << file << fileIndex << quint8(antialiased);
        *stream << quint8(writingSystems.count());
        for (int i = 0; i < writingSystems.count(); ++i)
            *stream << quint8(writingSystems.at(i));
    }
#else // ..in case of defined(Q_OS_SYMBIAN) && !defined(QT_NO_FREETYPE)
    f->fontFilename = file;
    f->fontFileIndex = fileIndex;
#endif
}

addQPF2File()

void QFontDatabasePrivate::addQPF2File

(

const QByteArray &

file

)

Definition at line 95 of file qfontdatabase_qws.cpp.

Referenced by initializeDb().

{
#ifndef QT_FONTS_ARE_RESOURCES
    struct stat st;
    if (stat(file.constData(), &st))
        return;
    int f = QT_OPEN(file, O_RDONLY, 0);
    if (f < 0)
        return;
    const uchar *data = (const uchar *)mmap(0, st.st_size, PROT_READ, MAP_SHARED, f, 0);
    const int dataSize = st.st_size;
#else
    QResource res(QLatin1String(file.constData()));
    const uchar *data = res.data();
    const int dataSize = res.size();
    //qDebug() << "addQPF2File" << file << data;
#endif
    if (data && data != (const uchar *)MAP_FAILED) {
        if (QFontEngineQPF::verifyHeader(data, dataSize)) {
            QString fontName = QFontEngineQPF::extractHeaderField(data, QFontEngineQPF::Tag_FontName).toString();
            int pixelSize = QFontEngineQPF::extractHeaderField(data, QFontEngineQPF::Tag_PixelSize).toInt();
            QVariant weight = QFontEngineQPF::extractHeaderField(data, QFontEngineQPF::Tag_Weight);
            QVariant style = QFontEngineQPF::extractHeaderField(data, QFontEngineQPF::Tag_Style);
            QByteArray writingSystemBits = QFontEngineQPF::extractHeaderField(data, QFontEngineQPF::Tag_WritingSystems).toByteArray();

            if (!fontName.isEmpty() && pixelSize) {
                int fontWeight = 50;
                if (weight.type() == QVariant::Int || weight.type() == QVariant::UInt)
                    fontWeight = weight.toInt();

                bool italic = static_cast<QFont::Style>(style.toInt()) & QFont::StyleItalic;

                QList<QFontDatabase::WritingSystem> writingSystems;
                for (int i = 0; i < writingSystemBits.count(); ++i) {
                    uchar currentByte = writingSystemBits.at(i);
                    for (int j = 0; j < 8; ++j) {
                        if (currentByte & 1)
                            writingSystems << QFontDatabase::WritingSystem(i * 8 + j);
                        currentByte >>= 1;
                    }
                }

                addFont(fontName, /*foundry*/ "prerendered", fontWeight, italic,
                        pixelSize, file, /*fileIndex*/ 0,
                        /*antialiased*/ true, writingSystems);
            }
        } else {
            qDebug() << "header verification of QPF2 font" << file << "failed. maybe it is corrupt?";
        }
#ifndef QT_FONTS_ARE_RESOURCES
        munmap((void *)data, st.st_size);
#endif
    }
#ifndef QT_FONTS_ARE_RESOURCES
    QT_CLOSE(f);
#endif
}

addTTFile()

QStringList QFontDatabasePrivate::addTTFile	(	const QByteArray &	file,
		const QByteArray &	fontData = QByteArray()
	)

Definition at line 835 of file qfontdatabase.cpp.

Referenced by initializeDb(), and registerFont().

{
    QStringList families;
    extern FT_Library qt_getFreetype();
    FT_Library library = qt_getFreetype();

    int index = 0;
    int numFaces = 0;
    do {
        FT_Face face;
        FT_Error error;
        if (!fontData.isEmpty()) {
            error = FT_New_Memory_Face(library, (const FT_Byte *)fontData.constData(), fontData.size(), index, &face);
        } else {
            error = FT_New_Face(library, file, index, &face);
        }
        if (error != FT_Err_Ok) {
            qDebug() << "FT_New_Face failed with index" << index << ":" << hex << error;
            break;
        }
        numFaces = face->num_faces;

        int weight = QFont::Normal;
        bool italic = face->style_flags & FT_STYLE_FLAG_ITALIC;

        if (face->style_flags & FT_STYLE_FLAG_BOLD)
            weight = QFont::Bold;

        QList<QFontDatabase::WritingSystem> writingSystems;
        // detect symbol fonts
        for (int i = 0; i < face->num_charmaps; ++i) {
            FT_CharMap cm = face->charmaps[i];
            if (cm->encoding == ft_encoding_adobe_custom
                    || cm->encoding == ft_encoding_symbol) {
                writingSystems.append(QFontDatabase::Symbol);
                break;
            }
        }
        if (writingSystems.isEmpty()) {
            TT_OS2 *os2 = (TT_OS2 *)FT_Get_Sfnt_Table(face, ft_sfnt_os2);
            if (os2) {
                quint32 unicodeRange[4] = {
                    static_cast<quint32>(os2->ulUnicodeRange1), static_cast<quint32>(os2->ulUnicodeRange2), static_cast<quint32>(os2->ulUnicodeRange3), static_cast<quint32>(os2->ulUnicodeRange4)
                };
                quint32 codePageRange[2] = {
                    static_cast<quint32>(os2->ulCodePageRange1), static_cast<quint32>(os2->ulCodePageRange2)
                };

                writingSystems = qt_determine_writing_systems_from_truetype_bits(unicodeRange, codePageRange);
                //for (int i = 0; i < writingSystems.count(); ++i)
                //    qDebug() << QFontDatabase::writingSystemName(writingSystems.at(i));
            }
        }

        QString family = QString::fromAscii(face->family_name);
        families.append(family);
        addFont(family, /*foundry*/ "", weight, italic,
                /*pixelsize*/ 0, file, index, /*antialias*/ true, writingSystems);

        FT_Done_Face(face);
        ++index;
    } while (index < numFaces);
    return families;
}

family()

QtFontFamily * QFontDatabasePrivate::family	(	const QString &	f,
		bool	create = false
	)

Definition at line 749 of file qfontdatabase.cpp.

Referenced by checkSymbolFonts(), initializeDb(), loadFontConfig(), loadXlfds(), populate_database(), qt_applyFontDatabaseSettings(), and qt_registerFont().

{
    int low = 0;
    int high = count;
    int pos = count / 2;
    int res = 1;
    if (count) {
        while ((res = families[pos]->name.compare(f, Qt::CaseInsensitive)) && pos != low) {
            if (res > 0)
                high = pos;
            else
                low = pos;
            pos = (high + low) / 2;
        }
        if (!res)
            return families[pos];
    }
    if (!create)
        return 0;

    if (res < 0)
        pos++;

    // qDebug() << "adding family " << f.toLatin1() << " at " << pos << " total=" << count;
    if (!(count % 8)) {
        QtFontFamily **newFamilies = (QtFontFamily **)
                   realloc(families,
                            (((count+8) >> 3) << 3) * sizeof(QtFontFamily *));
        Q_CHECK_PTR(newFamilies);
        families = newFamilies;
    }

    QtFontFamily *family = new QtFontFamily(f);
    memmove(families + pos + 1, families + pos, (count-pos)*sizeof(QtFontFamily *));
    families[pos] = family;
    count++;
    return families[pos];
}

free()

void QFontDatabasePrivate::free ( )

inline

Definition at line 675 of file qfontdatabase.cpp.

                {
        while (count--)
            delete families[count];
        ::free(families);
        families = 0;
        count = 0;
        // don't clear the memory fonts!
    }

invalidate()

void QFontDatabasePrivate::invalidate

(

)

Definition at line 742 of file qfontdatabase.cpp.

Referenced by registerFont(), and QFontDatabase::removeApplicationFont().

{
    QFontCache::instance()->clear();
    free();
    emit static_cast<QApplication *>(QApplication::instance())->fontDatabaseChanged();
}

isApplicationFont()

bool QFontDatabasePrivate::isApplicationFont

(

const QString &

fileName

)

Definition at line 2628 of file qfontdatabase.cpp.

{
    for (int i = 0; i < applicationFonts.count(); ++i)
        if (applicationFonts.at(i).fileName == fileName)
            return true;
    return false;
}

loadFromCache()

bool QFontDatabasePrivate::loadFromCache

(

const QString &

fontPath

)

Definition at line 161 of file qfontdatabase_qws.cpp.

Referenced by initializeDb().

{
#ifdef Q_WS_QWS
    const bool weAreTheServer = QWSServer::instance();
#else
    const bool weAreTheServer = true; // assume single-process
#endif

    QString fontDirFile = fontPath + QLatin1String("/fontdir");

    QFile binaryDb(qws_fontCacheDir() + QLatin1String("/fontdb"));

    if (weAreTheServer) {
        QDateTime dbTimeStamp = QFileInfo(binaryDb.fileName()).lastModified();

        QDateTime fontPathTimeStamp = QFileInfo(fontPath).lastModified();
        if (dbTimeStamp < fontPathTimeStamp)
            return false; // let the caller create the cache

        if (QFile::exists(fontDirFile)) {
            QDateTime fontDirTimeStamp = QFileInfo(fontDirFile).lastModified();
            if (dbTimeStamp < fontDirTimeStamp)
                return false;
        }
    }

    if (!binaryDb.open(QIODevice::ReadOnly)) {
        if (weAreTheServer)
            return false; // let the caller create the cache
        qFatal("QFontDatabase::loadFromCache: Could not open font database cache!");
    }

    QDataStream stream(&binaryDb);
    quint8 version = 0;
    quint8 dataStreamVersion = 0;
    stream >> version >> dataStreamVersion;
    if (version != DatabaseVersion || dataStreamVersion != stream.version()) {
        if (weAreTheServer)
            return false; // let the caller create the cache
        qFatal("QFontDatabase::loadFromCache: Wrong version of the font database cache detected. Found %d/%d expected %d/%d",
               version, dataStreamVersion, DatabaseVersion, stream.version());
    }

    QString originalFontPath;
    stream >> originalFontPath;
    if (originalFontPath != fontPath) {
        if (weAreTheServer)
            return false; // let the caller create the cache
        qFatal("QFontDatabase::loadFromCache: Font path doesn't match. Found %s in database, expected %s", qPrintable(originalFontPath), qPrintable(fontPath));
    }

    QString familyname;
    stream >> familyname;
    //qDebug() << "populating database from" << binaryDb.fileName();
    while (!familyname.isEmpty() && !stream.atEnd()) {
        QString foundryname;
        int weight;
        quint8 italic;
        int pixelSize;
        QByteArray file;
        int fileIndex;
        quint8 antialiased;
        quint8 writingSystemCount;

        QList<QFontDatabase::WritingSystem> writingSystems;

        stream >> foundryname >> weight >> italic >> pixelSize
               >> file >> fileIndex >> antialiased >> writingSystemCount;

        for (quint8 i = 0; i < writingSystemCount; ++i) {
            quint8 ws;
            stream >> ws;
            writingSystems.append(QFontDatabase::WritingSystem(ws));
        }

        addFont(familyname, foundryname.toLatin1().constData(), weight, italic, pixelSize, file, fileIndex, antialiased,
                writingSystems);

        stream >> familyname;
    }

    stream >> fallbackFamilies;
    //qDebug() << "fallback families from cache:" << fallbackFamilies;
    return true;
}

Properties

applicationFonts

QVector<ApplicationFont> QFontDatabasePrivate::applicationFonts

Definition at line 712 of file qfontdatabase.cpp.

Referenced by initializeDb(), populate_database(), registerFont(), QFontDatabase::removeAllApplicationFonts(), and QFontDatabase::removeApplicationFont().

count

int QFontDatabasePrivate::count

Definition at line 684 of file qfontdatabase.cpp.

Referenced by checkSymbolFonts(), fallbackFamilies(), findEncoding(), initializeDb(), loadFromDatabase(), populate_database(), qt_applyFontDatabaseSettings(), and registerFont().

directWriteFactory

IDWriteFactory* QFontDatabasePrivate::directWriteFactory

Definition at line 691 of file qfontdatabase.cpp.

Referenced by loadEngine().

directWriteGdiInterop

IDWriteGdiInterop* QFontDatabasePrivate::directWriteGdiInterop

Definition at line 692 of file qfontdatabase.cpp.

Referenced by loadEngine().

fallbackFamilies

QStringList QFontDatabasePrivate::fallbackFamilies

Definition at line 738 of file qfontdatabase.cpp.

Referenced by initializeDb(), loadFromCache(), qt_applyFontDatabaseSettings(), and registerFont().

families

QtFontFamily** QFontDatabasePrivate::families

Definition at line 688 of file qfontdatabase.cpp.

Referenced by checkSymbolFonts(), fallbackFamilies(), findEncoding(), initializeDb(), loadFromDatabase(), and qt_applyFontDatabaseSettings().

reregisterAppFonts

bool QFontDatabasePrivate::reregisterAppFonts

Definition at line 714 of file qfontdatabase.cpp.

Referenced by initializeDb(), and registerFont().

stream

QDataStream* QFontDatabasePrivate::stream

Definition at line 733 of file qfontdatabase.cpp.

Referenced by initializeDb(), and loadFromCache().

systemLang

QString QFontDatabasePrivate::systemLang

Definition at line 686 of file qfontdatabase.cpp.

Referenced by loadFontConfig(), and registerFont().

---

The documentation for this class was generated from the following files:

• /src/gui/text/qfontdatabase.cpp
• /src/gui/text/qfontdatabase_qws.cpp