qfontdatabase.cpp File Reference

#include <qdir.h>
#include "qfontdatabase.h"
#include "qdebug.h"
#include "qalgorithms.h"
#include "qapplication.h"
#include "qvarlengtharray.h"
#include "qthread.h"
#include "qmutex.h"
#include "private/qunicodetables_p.h"
#include "qfontengine_p.h"
#include <locale.h>
#include <stdlib.h>
#include <limits.h>
#include <ft2build.h>
#include <FT_TRUETYPE_TABLES_H>
#include <dwrite.h>
#include "qfontdatabase_x11.cpp"

Go to the source code of this file.

Classes
class	QFontDatabasePrivate
struct	QFontDatabasePrivate::ApplicationFont
struct	QtFontDesc
struct	QtFontEncoding
struct	QtFontFamily
struct	QtFontFoundry
struct	QtFontSize
struct	QtFontStyle
struct	QtFontStyle::Key

Macros
#define	FD_DEBUG   if (false) qDebug
#define	FM_DEBUG   if (false) qDebug
#define	JapaneseCsbBit   17
#define	KoreanCsbBit   21
#define	SimplifiedChineseCsbBit   18
#define	SMOOTH_SCALABLE   0xffff
#define	TraditionalChineseCsbBit   20

Functions
static QtFontStyle *	bestStyle (QtFontFoundry *foundry, const QtFontStyle::Key &styleKey, const QString &styleName=QString())
static QStringList	familyList (const QFontDef &req)
static QtFontEncoding *	findEncoding (int script, int styleStrategy, QtFontSize *size, int force_encoding_id)
static void	getEngineData (const QFontPrivate *d, const QFontCache::Key &key)
static int	getFontWeight (const QString &weightString)
static void	parseFontName (const QString &name, QString &foundry, QString &family)
	This makes sense of the font family name: More...
QList< QFontDatabase::WritingSystem >	qt_determine_writing_systems_from_truetype_bits (quint32 unicodeRange[4], quint32 codePageRange[2])
Q_GUI_EXPORT QByteArray	qt_fontdata_from_index (int index)
QMutex *	qt_fontdatabase_mutex ()
static void	qt_mac_get_fixed_pitch (QtFontFamily *f)
int	qt_script_for_writing_system (QFontDatabase::WritingSystem writingSystem)
Q_AUTOTEST_EXPORT void	qt_setQtEnableTestFont (bool value)
static bool	requiresOpenType (int writingSystem)
static bool	scriptRequiresOpenType (int script)
static QString	styleStringHelper (int weight, QFont::Style style)
QFont::Weight	weightFromInteger (int weight)

Variables
bool	qt_enable_test_font = false
static int	requiredUnicodeBits [QFontDatabase::WritingSystemsCount][2]
static const int	scriptForWritingSystem []

Macro Definition Documentation

FD_DEBUG

#define FD_DEBUG   if (false) qDebug

Definition at line 74 of file qfontdatabase.cpp.

Referenced by initializeDb(), and load().

FM_DEBUG

#define FM_DEBUG   if (false) qDebug

Definition at line 81 of file qfontdatabase.cpp.

Referenced by bestStyle(), findEncoding(), QFontDatabase::findFont(), loadEngine(), loadFc(), loadRaw(), loadWin(), QFontDatabase::loadXlfd(), qt_fontSetForPattern(), registerFont(), and tryPatternLoad().

JapaneseCsbBit

#define JapaneseCsbBit   17

Definition at line 584 of file qfontdatabase.cpp.

Referenced by qt_determine_writing_systems_from_truetype_bits().

KoreanCsbBit

#define KoreanCsbBit   21

Definition at line 585 of file qfontdatabase.cpp.

Referenced by qt_determine_writing_systems_from_truetype_bits().

SimplifiedChineseCsbBit

#define SimplifiedChineseCsbBit   18

Definition at line 582 of file qfontdatabase.cpp.

Referenced by qt_determine_writing_systems_from_truetype_bits().

SMOOTH_SCALABLE

#define SMOOTH_SCALABLE   0xffff

Definition at line 90 of file qfontdatabase.cpp.

Referenced by QFontDatabasePrivate::addFont(), addFontToDatabase(), findEncoding(), initializeDb(), loadFontConfig(), loadSingleEngine(), QFontDatabase::loadXlfd(), loadXlfds(), and qt_registerFont().

TraditionalChineseCsbBit

#define TraditionalChineseCsbBit   20

Definition at line 583 of file qfontdatabase.cpp.

Referenced by qt_determine_writing_systems_from_truetype_bits().

Function Documentation

bestStyle()

static QtFontStyle* bestStyle ( QtFontFoundry *  foundry, const QtFontStyle::Key &  styleKey, const QString &  styleName = QString()  )

static

Definition at line 1125 of file qfontdatabase.cpp.

Referenced by findEncoding(), and QFontDatabase::font().

{
    int best = 0;
    int dist = 0xffff;

    for ( int i = 0; i < foundry->count; i++ ) {
        QtFontStyle *style = foundry->styles[i];

        if (!styleName.isEmpty() && styleName == style->styleName) {
            dist = 0;
            best = i;
            break;
        }

        int d = qAbs( styleKey.weight - style->key.weight );

        if ( styleKey.stretch != 0 && style->key.stretch != 0 ) {
            d += qAbs( styleKey.stretch - style->key.stretch );
        }

        if (styleKey.style != style->key.style) {
            if (styleKey.style != QFont::StyleNormal && style->key.style != QFont::StyleNormal)
                // one is italic, the other oblique
                d += 0x0001;
            else
                d += 0x1000;
        }

        if ( d < dist ) {
            best = i;
            dist = d;
        }
    }

    FM_DEBUG( "          best style has distance 0x%x", dist );
    return foundry->styles[best];
}

familyList()

static QStringList familyList ( const QFontDef &  req )

static

Definition at line 1065 of file qfontdatabase.cpp.

Referenced by QFontDialogPrivate::_q_familyHighlighted(), QFontDialogPrivate::_q_updateSample(), QFontDatabase::findFont(), getFcPattern(), QFontDialogPrivate::init(), loadFromDatabase(), loadWin(), QFontDatabase::loadXlfd(), QFontDialogPrivate::updateFamilies(), QFontDialogPrivate::updateSizes(), and QFontDialogPrivate::updateStyles().

{
    // list of families to try
    QStringList family_list;
    if (req.family.isEmpty())
        return family_list;

    QStringList list = req.family.split(QLatin1Char(','));
    for (int i = 0; i < list.size(); ++i) {
        QString str = list.at(i).trimmed();
        if ((str.startsWith(QLatin1Char('"')) && str.endsWith(QLatin1Char('"')))
            || (str.startsWith(QLatin1Char('\'')) && str.endsWith(QLatin1Char('\''))))
            str = str.mid(1, str.length() - 2);
        family_list << str;
    }

    // append the substitute list for each family in family_list
    QStringList subs_list;
    QStringList::ConstIterator it = family_list.constBegin(), end = family_list.constEnd();
    for (; it != end; ++it)
        subs_list += QFont::substitutes(*it);
//         qDebug() << "adding substs: " << subs_list;

    family_list += subs_list;

    return family_list;
}

findEncoding()

static QtFontEncoding* findEncoding ( int  script, int  styleStrategy, QtFontSize *  size, int  force_encoding_id  )

static

Definition at line 1165 of file qfontdatabase.cpp.

{
    QtFontEncoding *encoding = 0;

    if (force_encoding_id >= 0) {
        encoding = size->encodingID(force_encoding_id);
        if (!encoding)
            FM_DEBUG("            required encoding_id not available");
        return encoding;
    }

    if (styleStrategy & (QFont::OpenGLCompatible | QFont::PreferBitmap)) {
        FM_DEBUG("            PreferBitmap and/or OpenGL set, skipping Freetype");
    } else {
        encoding = size->encodingID(-1); // -1 == prefer Freetype
        if (encoding)
            return encoding;
    }

    // FT not available, find an XLFD font, trying the default encoding first
    encoding = size->encodingID(QFontPrivate::defaultEncodingID);
    if (encoding) {
        // does it support the requested script?
        bool supportsScript = false;
        for (int ws = 1; !supportsScript && ws < QFontDatabase::WritingSystemsCount; ++ws) {
            if (scriptForWritingSystem[ws] != script)
                continue;
            supportsScript = writingSystems_for_xlfd_encoding[encoding->encoding][ws];
        }
        if (!supportsScript)
            encoding = 0;
    }
    // find the first encoding that supports the requested script
    for (int ws = 1; !encoding && ws < QFontDatabase::WritingSystemsCount; ++ws) {
        if (scriptForWritingSystem[ws] != script)
            continue;
        for (int x = 0; !encoding && x < size->count; ++x) {
            const int enc = size->encodings[x].encoding;
            if (writingSystems_for_xlfd_encoding[enc][ws])
                encoding = size->encodings + x;
        }
    }

    return encoding;
}

getEngineData()

static void getEngineData ( const QFontPrivate *  d, const QFontCache::Key &  key  )

static

Definition at line 1051 of file qfontdatabase.cpp.

Referenced by QFontDatabase::findFont(), loadWin(), and QFontDatabase::loadXlfd().

{
    // look for the requested font in the engine data cache
    d->engineData = QFontCache::instance()->findEngineData(key);
    if (!d->engineData) {
        // create a new one
        d->engineData = new QFontEngineData;
        QFontCache::instance()->insertEngineData(key, d->engineData);
    } else {
        d->engineData->ref.ref();
    }
}

getFontWeight()

static int getFontWeight ( const QString &  weightString )

static

Definition at line 101 of file qfontdatabase.cpp.

Referenced by getStyle(), QtFontStyle::Key::Key(), and qt_fillFontDef().

{
    QString s = weightString.toLower();

    // Test in decreasing order of commonness
    if (s == QLatin1String("medium") ||
        s == QLatin1String("normal")
        || s.compare(QApplication::translate("QFontDatabase", "Normal"), Qt::CaseInsensitive) == 0)
        return QFont::Normal;
    if (s == QLatin1String("bold")
        || s.compare(QApplication::translate("QFontDatabase", "Bold"), Qt::CaseInsensitive) == 0)
        return QFont::Bold;
    if (s == QLatin1String("demibold") || s == QLatin1String("demi bold")
        || s.compare(QApplication::translate("QFontDatabase", "Demi Bold"), Qt::CaseInsensitive) == 0)
        return QFont::DemiBold;
    if (s == QLatin1String("black")
        || s.compare(QApplication::translate("QFontDatabase", "Black"), Qt::CaseInsensitive) == 0)
        return QFont::Black;
    if (s == QLatin1String("light"))
        return QFont::Light;

    if (s.contains(QLatin1String("bold"))
        || s.contains(QApplication::translate("QFontDatabase", "Bold"), Qt::CaseInsensitive)) {
        if (s.contains(QLatin1String("demi"))
            || s.compare(QApplication::translate("QFontDatabase", "Demi"), Qt::CaseInsensitive) == 0)
            return (int) QFont::DemiBold;
        return (int) QFont::Bold;
    }

    if (s.contains(QLatin1String("light"))
        || s.compare(QApplication::translate("QFontDatabase", "Light"), Qt::CaseInsensitive) == 0)
        return (int) QFont::Light;

    if (s.contains(QLatin1String("black"))
        || s.compare(QApplication::translate("QFontDatabase", "Black"), Qt::CaseInsensitive) == 0)
        return (int) QFont::Black;

    return (int) QFont::Normal;
}

parseFontName()

static void parseFontName ( const QString &  name, QString &  foundry, QString &  family  )

static

This makes sense of the font family name:

if the family name contains a '[' and a ']', then we take the text between the square brackets as the foundry, and the text before the square brackets as the family (ie.

Warning

This function is not part of the public interface.

"Arial [Monotype]")

Definition at line 970 of file qfontdatabase.cpp.

Referenced by QFontDatabase::bold(), QFontDatabase::font(), getFcPattern(), QFontDatabase::hasFamily(), QFontDatabase::isBitmapScalable(), QFontDatabase::isFixedPitch(), QFontDatabase::isSmoothlyScalable(), QFontDatabase::italic(), loadWin(), QFontDatabase::loadXlfd(), QFontDatabase::parseFontName(), QFontDatabase::pointSizes(), registerFont(), QFontDatabase::smoothSizes(), QFontDatabase::styles(), QFontDatabase::weight(), and QFontDatabase::writingSystems().

{
    int i = name.indexOf(QLatin1Char('['));
    int li = name.lastIndexOf(QLatin1Char(']'));
    if (i >= 0 && li >= 0 && i < li) {
        foundry = name.mid(i + 1, li - i - 1);
        if (i > 0 && name[i - 1] == QLatin1Char(' '))
            i--;
        family = name.left(i);
    } else {
        foundry.clear();
        family = name;
    }

    // capitalize the family/foundry names
    bool space = true;
    QChar *s = family.data();
    int len = family.length();
    while(len--) {
        if (space) *s = s->toUpper();
        space = s->isSpace();
        ++s;
    }

    space = true;
    s = foundry.data();
    len = foundry.length();
    while(len--) {
        if (space) *s = s->toUpper();
        space = s->isSpace();
        ++s;
    }
}

qt_determine_writing_systems_from_truetype_bits()

QList<QFontDatabase::WritingSystem> qt_determine_writing_systems_from_truetype_bits	(	quint32	unicodeRange[4],
		quint32	codePageRange[2]
	)

Definition at line 587 of file qfontdatabase.cpp.

Referenced by addFontToDatabase(), QFontDatabasePrivate::addTTFile(), QRawFont::fontTable(), initWritingSystems(), and QRawFont::supportedWritingSystems().

{
    QList<QFontDatabase::WritingSystem> writingSystems;
    bool hasScript = false;

    int i;
    for(i = 0; i < QFontDatabase::WritingSystemsCount; i++) {
        int bit = requiredUnicodeBits[i][0];
        int index = bit/32;
        int flag =  1 << (bit&31);
        if (bit != 126 && unicodeRange[index] & flag) {
            bit = requiredUnicodeBits[i][1];
            index = bit/32;

            flag =  1 << (bit&31);
            if (bit == 127 || unicodeRange[index] & flag) {
                writingSystems.append(QFontDatabase::WritingSystem(i));
                hasScript = true;
                // qDebug("font %s: index=%d, flag=%8x supports script %d", familyName.latin1(), index, flag, i);
            }
        }
    }
    if(codePageRange[0] & (1 << SimplifiedChineseCsbBit)) {
        writingSystems.append(QFontDatabase::SimplifiedChinese);
        hasScript = true;
        //qDebug("font %s supports Simplified Chinese", familyName.latin1());
    }
    if(codePageRange[0] & (1 << TraditionalChineseCsbBit)) {
        writingSystems.append(QFontDatabase::TraditionalChinese);
        hasScript = true;
        //qDebug("font %s supports Traditional Chinese", familyName.latin1());
    }
    if(codePageRange[0] & (1 << JapaneseCsbBit)) {
        writingSystems.append(QFontDatabase::Japanese);
        hasScript = true;
        //qDebug("font %s supports Japanese", familyName.latin1());
    }
    if(codePageRange[0] & (1 << KoreanCsbBit)) {
        writingSystems.append(QFontDatabase::Korean);
        hasScript = true;
        //qDebug("font %s supports Korean", familyName.latin1());
    }
    if (!hasScript)
        writingSystems.append(QFontDatabase::Symbol);

    return writingSystems;
}

qt_fontdata_from_index()

Q_GUI_EXPORT QByteArray qt_fontdata_from_index

(

int

index

)

Definition at line 2594 of file qfontdatabase.cpp.

Referenced by QFreetypeFace::getFace().

{
    QMutexLocker locker(fontDatabaseMutex());
    return privateDb()->applicationFonts.value(index).data;
}

qt_fontdatabase_mutex()

QMutex* qt_fontdatabase_mutex

(

)

Definition at line 1097 of file qfontdatabase.cpp.

Referenced by QFontPrivate::engineForScript(), QFontEngineMultiFT::loadEngine(), QFontEngineFT::stringToCMap(), QFontEngineMultiFT::~QFontEngineMultiFT(), and QFontPrivate::~QFontPrivate().

{
    return fontDatabaseMutex();
}

qt_mac_get_fixed_pitch()

static void qt_mac_get_fixed_pitch ( QtFontFamily *  f )

inlinestatic

Definition at line 473 of file qfontdatabase.cpp.

Referenced by findEncoding(), and QFontDatabase::isFixedPitch().

{
    if(f && !f->fixedPitchComputed) {
        QFontMetrics fm(f->name);
        f->fixedPitch = fm.width(QLatin1Char('i')) == fm.width(QLatin1Char('m'));
        f->fixedPitchComputed = true;
    }
}

qt_script_for_writing_system()

int qt_script_for_writing_system

(

QFontDatabase::WritingSystem

writingSystem

)

Definition at line 938 of file qfontdatabase.cpp.

Referenced by QRawFont::fromFont(), and QRawFont::supportsCharacter().

{
    return scriptForWritingSystem[writingSystem];
}

qt_setQtEnableTestFont()

Q_AUTOTEST_EXPORT void qt_setQtEnableTestFont

(

bool

value

)

Definition at line 96 of file qfontdatabase.cpp.

{
    qt_enable_test_font = value;
}

requiresOpenType()

static bool requiresOpenType ( int  writingSystem )

inlinestatic

Definition at line 945 of file qfontdatabase.cpp.

Referenced by loadFontConfig().

{
    return ((writingSystem >= QFontDatabase::Syriac && writingSystem <= QFontDatabase::Sinhala)
            || writingSystem == QFontDatabase::Khmer || writingSystem == QFontDatabase::Nko);
}

scriptRequiresOpenType()

static bool scriptRequiresOpenType ( int  script )

inlinestatic

Definition at line 950 of file qfontdatabase.cpp.

Referenced by loadEngine(), registerFont(), and tryPatternLoad().

{
    return ((script >= QUnicodeTables::Syriac && script <= QUnicodeTables::Sinhala)
            || script == QUnicodeTables::Khmer || script == QUnicodeTables::Nko);
}

styleStringHelper()

static QString styleStringHelper ( int  weight, QFont::Style  style  )

static

Definition at line 1503 of file qfontdatabase.cpp.

Referenced by initializeDb(), QFontDatabase::styles(), and QFontDatabase::styleString().

{
    QString result;
    if (weight >= QFont::Black)
        result = QApplication::translate("QFontDatabase", "Black");
    else if (weight >= QFont::Bold)
        result = QApplication::translate("QFontDatabase", "Bold");
    else if (weight >= QFont::DemiBold)
        result = QApplication::translate("QFontDatabase", "Demi Bold");
    else if (weight < QFont::Normal)
        result = QApplication::translate("QFontDatabase", "Light");

    if (style == QFont::StyleItalic)
        result += QLatin1Char(' ') + QApplication::translate("QFontDatabase", "Italic");
    else if (style == QFont::StyleOblique)
        result += QLatin1Char(' ') + QApplication::translate("QFontDatabase", "Oblique");

    if (result.isEmpty())
        result = QApplication::translate("QFontDatabase", "Normal");

    return result.simplified();
}

weightFromInteger()

QFont::Weight weightFromInteger

(

int

weight

)

Definition at line 142 of file qfontdatabase.cpp.

Referenced by addFontToDatabase(), getEnglishName(), qt_LOGFONTtoQFont(), and resolveGdi32().

{
    if (weight < 400)
        return QFont::Light;
    else if (weight < 600)
        return QFont::Normal;
    else if (weight < 700)
        return QFont::DemiBold;
    else if (weight < 800)
        return QFont::Bold;
    else
        return QFont::Black;
}

Variable Documentation

qt_enable_test_font

bool qt_enable_test_font = false

Definition at line 92 of file qfontdatabase.cpp.

Referenced by QFontDatabase::findFont(), QFontDatabase::load(), loadWin(), QFontDatabase::loadXlfd(), qt_setQtEnableTestFont(), and registerFont().

requiredUnicodeBits

int requiredUnicodeBits[QFontDatabase::WritingSystemsCount][2]

static

Definition at line 511 of file qfontdatabase.cpp.

scriptForWritingSystem

const int scriptForWritingSystem[]

static

Definition at line 901 of file qfontdatabase.cpp.

Referenced by load().