QT_BEGIN_NAMESPACE
Q_GUI_EXPORT void qt_registerFont(const QString &familyName, const QString &foundryname, int weight,
QFont::Style style, int stretch, bool antialiased, bool scalable, int pixelSize,
const QSupportedWritingSystems &writingSystems, void *handle)
{
QFontDatabasePrivate *d = privateDb();
QtFontStyle::Key styleKey;
styleKey.style = style;
styleKey.weight = weight;
styleKey.stretch = stretch;
QtFontFamily *f = d->family(familyName, true);
for (int i = 0; i < QFontDatabase::WritingSystemsCount; ++i) {
if (writingSystems.supported(QFontDatabase::WritingSystem(i))) {
f->writingSystems[i] = QtFontFamily::Supported;
} else {
f->writingSystems[i] = QtFontFamily::Unsupported;
}
}
QtFontFoundry *foundry = f->foundry(foundryname, true);
QtFontStyle *fontStyle = foundry->style(styleKey, QString(), true);
fontStyle->smoothScalable = scalable;
fontStyle->antialiased = antialiased;
QtFontSize *size = fontStyle->pixelSize(pixelSize?pixelSize:SMOOTH_SCALABLE, true);
size->handle = handle;
}
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)
{
// 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, true);
style->smoothScalable = (pixelSize == 0);
style->antialiased = antialiased;
QtFontSize *size = style->pixelSize(pixelSize?pixelSize:SMOOTH_SCALABLE, true);
size->fileName = file;
size->fileIndex = fileIndex;
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));
}
}
static
void addFontToDatabase(QString familyName, const QString &scriptName,
TEXTMETRIC *textmetric,
const FONTSIGNATURE *signature,
int type)
{
const int script = -1;
const QString foundryName;
Q_UNUSED(script);
bool italic = false;
int weight;
bool fixed;
bool ttf;
bool scalable;
int size;
// QString escript = QString::fromWCharArray(f->elfScript);
// qDebug("script=%s", escript.latin1());
NEWTEXTMETRIC *tm = (NEWTEXTMETRIC *)textmetric;
fixed = !(tm->tmPitchAndFamily & TMPF_FIXED_PITCH);
ttf = (tm->tmPitchAndFamily & TMPF_TRUETYPE);
scalable = tm->tmPitchAndFamily & (TMPF_VECTOR|TMPF_TRUETYPE);
size = scalable ? SMOOTH_SCALABLE : tm->tmHeight;
italic = tm->tmItalic;
weight = tm->tmWeight;
// the "@family" fonts are just the same as "family". Ignore them.
if (familyName[0] != QLatin1Char('@') && !familyName.startsWith(QLatin1String("WST_"))) {
QtFontStyle::Key styleKey;
styleKey.style = italic ? QFont::StyleItalic : QFont::StyleNormal;
styleKey.weight = weightFromInteger(weight);
QtFontFamily *family = privateDb()->family(familyName, true);
if(ttf && localizedName(familyName) && family->english_name.isEmpty())
family->english_name = getEnglishName(familyName);
QtFontFoundry *foundry = family->foundry(foundryName, true);
QtFontStyle *style = foundry->style(styleKey, QString(), true);
style->smoothScalable = scalable;
style->pixelSize( size, TRUE);
// add fonts windows can generate for us:
if (styleKey.weight <= QFont::DemiBold) {
QtFontStyle::Key key(styleKey);
key.weight = QFont::Bold;
QtFontStyle *style = foundry->style(key, QString(), true);
style->smoothScalable = scalable;
style->pixelSize( size, TRUE);
}
if (styleKey.style != QFont::StyleItalic) {
QtFontStyle::Key key(styleKey);
key.style = QFont::StyleItalic;
QtFontStyle *style = foundry->style(key, QString(), true);
style->smoothScalable = scalable;
style->pixelSize( size, TRUE);
}
if (styleKey.weight <= QFont::DemiBold && styleKey.style != QFont::StyleItalic) {
QtFontStyle::Key key(styleKey);
key.weight = QFont::Bold;
key.style = QFont::StyleItalic;
QtFontStyle *style = foundry->style(key, QString(), true);
style->smoothScalable = scalable;
style->pixelSize( size, TRUE);
}
family->fixedPitch = fixed;
if (!family->writingSystemCheck && type & TRUETYPE_FONTTYPE) {
quint32 unicodeRange[4] = {
signature->fsUsb[0], signature->fsUsb[1],
signature->fsUsb[2], signature->fsUsb[3]
};
#ifdef Q_WS_WINCE
if (signature->fsUsb[0] == 0) {
// If the unicode ranges bit mask is zero then
// EnumFontFamiliesEx failed to determine it properly.
// In this case we just pretend that the font supports all languages.
unicodeRange[0] = 0xbfffffff; // second most significant bit must be zero
unicodeRange[1] = 0xffffffff;
unicodeRange[2] = 0xffffffff;
unicodeRange[3] = 0xffffffff;
}
#endif
quint32 codePageRange[2] = {
signature->fsCsb[0], signature->fsCsb[1]
};
QList<QFontDatabase::WritingSystem> systems = qt_determine_writing_systems_from_truetype_bits(unicodeRange, codePageRange);
for (int i = 0; i < systems.count(); ++i) {
QFontDatabase::WritingSystem writingSystem = systems.at(i);
// ### Hack to work around problem with Thai text on Windows 7. Segoe UI contains
// the symbol for Baht, and Windows thus reports that it supports the Thai script.
// Since it's the default UI font on this platform, most widgets will be unable to
// display Thai text by default. As a temporary work around, we special case Segoe UI
// and remove the Thai script from its list of supported writing systems.
if (writingSystem != QFontDatabase::Thai || familyName != QLatin1String("Segoe UI"))
family->writingSystems[writingSystem] = QtFontFamily::Supported;
}
} else if (!family->writingSystemCheck) {
//qDebug("family='%s' script=%s", family->name.latin1(), script.latin1());
if (scriptName == QLatin1String("Western")
|| scriptName == QLatin1String("Baltic")
|| scriptName == QLatin1String("Central European")
|| scriptName == QLatin1String("Turkish")
|| scriptName == QLatin1String("Vietnamese"))
family->writingSystems[QFontDatabase::Latin] = QtFontFamily::Supported;
else if (scriptName == QLatin1String("Thai"))
family->writingSystems[QFontDatabase::Thai] = QtFontFamily::Supported;
else if (scriptName == QLatin1String("Symbol")
|| scriptName == QLatin1String("Other"))
family->writingSystems[QFontDatabase::Symbol] = QtFontFamily::Supported;
else if (scriptName == QLatin1String("OEM/Dos"))
family->writingSystems[QFontDatabase::Latin] = QtFontFamily::Supported;
else if (scriptName == QLatin1String("CHINESE_GB2312"))
family->writingSystems[QFontDatabase::SimplifiedChinese] = QtFontFamily::Supported;
else if (scriptName == QLatin1String("CHINESE_BIG5"))
family->writingSystems[QFontDatabase::TraditionalChinese] = QtFontFamily::Supported;
else if (scriptName == QLatin1String("Cyrillic"))
family->writingSystems[QFontDatabase::Cyrillic] = QtFontFamily::Supported;
else if (scriptName == QLatin1String("Hangul"))
family->writingSystems[QFontDatabase::Korean] = QtFontFamily::Supported;
else if (scriptName == QLatin1String("Hebrew"))
family->writingSystems[QFontDatabase::Hebrew] = QtFontFamily::Supported;
else if (scriptName == QLatin1String("Greek"))
family->writingSystems[QFontDatabase::Greek] = QtFontFamily::Supported;
else if (scriptName == QLatin1String("Japanese"))
family->writingSystems[QFontDatabase::Japanese] = QtFontFamily::Supported;
else if (scriptName == QLatin1String("Arabic"))
family->writingSystems[QFontDatabase::Arabic] = QtFontFamily::Supported;
}
}
}
static void initializeDb()
{
QFontDatabasePrivate *db = privateDb();
if(!db || db->count)
return;
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)
if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5) {
QCFType<CTFontCollectionRef> collection = CTFontCollectionCreateFromAvailableFonts(0);
if(!collection)
return;
QCFType<CFArrayRef> fonts = CTFontCollectionCreateMatchingFontDescriptors(collection);
if(!fonts)
return;
QString foundry_name = "CoreText";
const int numFonts = CFArrayGetCount(fonts);
for(int i = 0; i < numFonts; ++i) {
CTFontDescriptorRef font = (CTFontDescriptorRef)CFArrayGetValueAtIndex(fonts, i);
QCFString family_name = (CFStringRef)CTFontDescriptorCopyAttribute(font, kCTFontFamilyNameAttribute);
QtFontFamily *family = db->family(family_name, true);
for(int ws = 1; ws < QFontDatabase::WritingSystemsCount; ++ws)
family->writingSystems[ws] = QtFontFamily::Supported;
QtFontFoundry *foundry = family->foundry(foundry_name, true);
QtFontStyle::Key styleKey;
if(QCFType<CFDictionaryRef> styles = (CFDictionaryRef)CTFontDescriptorCopyAttribute(font, kCTFontTraitsAttribute)) {
if(CFNumberRef weight = (CFNumberRef)CFDictionaryGetValue(styles, kCTFontWeightTrait)) {
Q_ASSERT(CFNumberIsFloatType(weight));
double d;
if(CFNumberGetValue(weight, kCFNumberDoubleType, &d)) {
//qDebug() << "BOLD" << (QString)family_name << d;
styleKey.weight = (d > 0.0) ? QFont::Bold : QFont::Normal;
}
}
if(CFNumberRef italic = (CFNumberRef)CFDictionaryGetValue(styles, kCTFontSlantTrait)) {
Q_ASSERT(CFNumberIsFloatType(italic));
double d;
if(CFNumberGetValue(italic, kCFNumberDoubleType, &d)) {
//qDebug() << "ITALIC" << (QString)family_name << d;
if (d > 0.0)
styleKey.style = QFont::StyleItalic;
}
}
}
QtFontStyle *style = foundry->style(styleKey, true);
style->smoothScalable = true;
if(QCFType<CFNumberRef> size = (CFNumberRef)CTFontDescriptorCopyAttribute(font, kCTFontSizeAttribute)) {
//qDebug() << "WHEE";
int pixel_size=0;
if(CFNumberIsFloatType(size)) {
double d;
CFNumberGetValue(size, kCFNumberDoubleType, &d);
pixel_size = d;
} else {
CFNumberGetValue(size, kCFNumberIntType, &pixel_size);
}
//qDebug() << "SIZE" << (QString)family_name << pixel_size;
if(pixel_size)
style->pixelSize(pixel_size, true);
} else {
//qDebug() << "WTF?";
}
}
} else
#endif
{
FMFontIterator it;
if (!FMCreateFontIterator(0, 0, kFMUseGlobalScopeOption, &it)) {
while (true) {
FMFont fmFont;
if (FMGetNextFont(&it, &fmFont) != noErr)
break;
FMFontFamily fmFamily;
FMFontStyle fmStyle;
QString familyName;
QtFontStyle::Key styleKey;
ATSFontRef atsFont = FMGetATSFontRefFromFont(fmFont);
if (!FMGetFontFamilyInstanceFromFont(fmFont, &fmFamily, &fmStyle)) {
{ //sanity check the font, and see if we can use it at all! --Sam
ATSUFontID fontID;
if(ATSUFONDtoFontID(fmFamily, 0, &fontID) != noErr)
continue;
}
if (fmStyle & ::italic)
styleKey.style = QFont::StyleItalic;
if (fmStyle & ::bold)
styleKey.weight = QFont::Bold;
ATSFontFamilyRef familyRef = FMGetATSFontFamilyRefFromFontFamily(fmFamily);
QCFString cfFamilyName;;
ATSFontFamilyGetName(familyRef, kATSOptionFlagsDefault, &cfFamilyName);
familyName = cfFamilyName;
} else {
QCFString cfFontName;
ATSFontGetName(atsFont, kATSOptionFlagsDefault, &cfFontName);
familyName = cfFontName;
quint16 macStyle = 0;
{
uchar data[4];
ByteCount len = 4;
if (ATSFontGetTable(atsFont, MAKE_TAG('h', 'e', 'a', 'd'), 44, 4, &data, &len) == noErr)
macStyle = qFromBigEndian<quint16>(data);
}
if (macStyle & 1)
styleKey.weight = QFont::Bold;
if (macStyle & 2)
styleKey.style = QFont::StyleItalic;
}
QtFontFamily *family = db->family(familyName, true);
QtFontFoundry *foundry = family->foundry(QString(), true);
QtFontStyle *style = foundry->style(styleKey, true);
style->pixelSize(0, true);
style->smoothScalable = true;
initWritingSystems(family, atsFont);
}
FMDisposeFontIterator(&it);
}
}
}
