QCoreTextFontDatabase Class Reference

#include <qcoretextfontdatabase.h>

Inheritance diagram for QCoreTextFontDatabase:

Public Functions
QStringList	fallbacksForFamily (const QString family, const QFont::Style &style, const QFont::StyleHint &styleHint, const QUnicodeTables::Script &script) const
	Returns a list of alternative fonts for the specified family and style and script using the styleHint given. More...
QFontEngine *	fontEngine (const QFontDef &fontDef, QUnicodeTables::Script script, void *handle)
	Returns the font engine that can be used to render the font described by the font definition, fontDef, in the specified script. More...
void	populateFontDatabase ()
	This function is called once at startup by Qts internal fontdatabase. More...
Public Functions inherited from QPlatformFontDatabase
virtual QStringList	addApplicationFont (const QByteArray &fontData, const QString &fileName)
	Adds an application font described by the font contained supplied fontData or using the font contained in the file referenced by fileName. More...
virtual QString	fontDir () const
	Returns the path to the font directory. More...
virtual QFontEngine *	fontEngine (const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference)
virtual void	releaseHandle (void *handle)
	Releases the font handle and deletes any associated data loaded from a file. More...

Properties
QHash< QFont::StyleHint, QStringList >	fallbackLists

Additional Inherited Members
Static Public Functions inherited from QPlatformFontDatabase
static void	registerFont (const QString &familyname, const QString &foundryname, QFont::Weight weight, QFont::Style style, QFont::Stretch stretch, bool antialiased, bool scalable, int pixelSize, const QSupportedWritingSystems &writingSystems, void *handle)
	Registers a font with the given set of attributes describing the font's foundry, family name, style and stretch information, pixel size, and supported writing systems. More...
static void	registerQPF2Font (const QByteArray &dataArray, void *handle)
	Registers the pre-rendered QPF2 font contained in the given dataArray. More...

Detailed Description

Definition at line 49 of file qcoretextfontdatabase.h.

Functions

fallbacksForFamily()

QStringList QCoreTextFontDatabase::fallbacksForFamily ( const QString  family, const QFont::Style &  style, const QFont::StyleHint &  styleHint, const QUnicodeTables::Script &  script  ) const

virtual

Returns a list of alternative fonts for the specified family and style and script using the styleHint given.

Reimplemented from QPlatformFontDatabase.

Definition at line 52 of file qcoretextfontdatabase.mm.

{
    Q_UNUSED(family);
    Q_UNUSED(style);
    Q_UNUSED(script);
    if (fallbackLists.isEmpty())
        const_cast<QCoreTextFontDatabase *>(this)->populateFontDatabase();

    return fallbackLists[styleHint];
}

fontEngine()

QFontEngine * QCoreTextFontDatabase::fontEngine ( const QFontDef &  fontDef, QUnicodeTables::Script  script, void *  handle  )

virtual

Returns the font engine that can be used to render the font described by the font definition, fontDef, in the specified script.

Reimplemented from QPlatformFontDatabase.

Definition at line 208 of file qcoretextfontdatabase.mm.

{
    Q_UNUSED(script)
    Q_UNUSED(handle)
    CTFontSymbolicTraits symbolicTraits = 0;
    if (fontDef.weight >= QFont::Bold)
        symbolicTraits |= kCTFontBoldTrait;
    switch (fontDef.style) {
    case QFont::StyleNormal:
        break;
    case QFont::StyleItalic:
    case QFont::StyleOblique:
        symbolicTraits |= kCTFontItalicTrait;
        break;
    }

    CGAffineTransform transform = CGAffineTransformIdentity;
    if (fontDef.stretch != 100) {
        transform = CGAffineTransformMakeScale(float(fontDef.stretch) / float(100), 1);
    }

    QCFType<CTFontRef> baseFont = CTFontCreateWithName(QCFString(fontDef.family), fontDef.pixelSize, &transform);
    QCFType<CTFontRef> ctFont = NULL;
    // There is a side effect in Core Text: if we apply 0 as symbolic traits to a font in normal weight,
    // we will get the light version of that font (while the way supposed to work doesn't:
    // setting kCTFontWeightTrait to some value between -1.0 to 0.0 has no effect on font selection)
    if (fontDef.weight != QFont::Normal || symbolicTraits)
        ctFont = CTFontCreateCopyWithSymbolicTraits(baseFont, fontDef.pixelSize, &transform, symbolicTraits, symbolicTraits);

    // CTFontCreateCopyWithSymbolicTraits returns NULL if we ask for a trait that does
    // not exist for the given font. (for example italic)
    if (ctFont == 0) {
        ctFont = baseFont;
    }

    if (ctFont)
        return new QCoreTextFontEngine(ctFont, fontDef);
    return 0;
}

populateFontDatabase()

void QCoreTextFontDatabase::populateFontDatabase ( )

virtual

This function is called once at startup by Qts internal fontdatabase.

Reimplement this function in a subclass for a convenient place to initialise the internal fontdatabase.

The default implementation looks in the fontDir() location and registers all qpf2 fonts.

Reimplemented from QPlatformFontDatabase.

Definition at line 112 of file qcoretextfontdatabase.mm.

{
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    QCFType<CTFontCollectionRef> collection = CTFontCollectionCreateFromAvailableFonts(0);
    if (!collection)
        return;
    QCFType<CFArrayRef> fonts = CTFontCollectionCreateMatchingFontDescriptors(collection);
    if (!fonts)
        return;
    QSupportedWritingSystems supportedWritingSystems;
    for (int i = 0; i < QFontDatabase::WritingSystemsCount; ++i)
        supportedWritingSystems.setSupported((QFontDatabase::WritingSystem)i, true);
    QString foundry_name = "CoreText";
    const int numFonts = CFArrayGetCount(fonts);
    QHash<QString, QString> psNameToFamily;
    for (int i = 0; i < numFonts; ++i) {
        CTFontDescriptorRef font = (CTFontDescriptorRef)CFArrayGetValueAtIndex(fonts, i);

        QCFString family_name = (CFStringRef)CTFontDescriptorCopyAttribute(font, kCTFontFamilyNameAttribute);
//        QCFString style_name = (CFStringRef)CTFontDescriptorCopyAttribute(font, kCTFontStyleNameAttribute);

        QFont::Weight fontWeight = QFont::Normal;
        QFont::Style fontStyle = QFont::StyleNormal;
        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)) {
                    if (d > 0.0)
                        fontWeight = QFont::Bold;
                }
            }
            if (CFNumberRef italic = (CFNumberRef)CFDictionaryGetValue(styles, kCTFontSlantTrait)) {
                Q_ASSERT(CFNumberIsFloatType(italic));
                double d;
                if (CFNumberGetValue(italic, kCFNumberDoubleType, &d)) {
                    if (d > 0.0)
                        fontStyle = QFont::StyleItalic;
                }
            }
        }

        int pixelSize = 0;
        if (QCFType<CFNumberRef> size = (CFNumberRef)CTFontDescriptorCopyAttribute(font, kCTFontSizeAttribute)) {
            if (CFNumberIsFloatType(size)) {
                double d;
                CFNumberGetValue(size, kCFNumberDoubleType, &d);
                pixelSize = d;
            } else {
                CFNumberGetValue(size, kCFNumberIntType, &pixelSize);
            }
        }
        QString familyName = QCFString::toQString(family_name);
        registerFont(familyName,
                     foundry_name,
                     fontWeight,
                     fontStyle,
                     QFont::Unstretched,
                     true,
                     true,
                     pixelSize,
                     supportedWritingSystems,
                     0);

        CFStringRef psName = (CFStringRef) CTFontDescriptorCopyAttribute(font,
                                                                         kCTFontNameAttribute);
        psNameToFamily[QCFString::toQString(psName)] = familyName;
        CFRelease(psName);
    }

    NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
    NSArray *languages = [defaults stringArrayForKey: @"AppleLanguages"];

    NSDictionary *fallbackDict = [NSDictionary dictionaryWithContentsOfFile: @"/System/Library/Frameworks/CoreText.framework/DefaultFontFallbacks.plist"];
    for (NSString *style in [fallbackDict allKeys]) {
        NSArray *list = [fallbackDict valueForKey: style];
        QFont::StyleHint styleHint = styleHintFromNSString(style);
        QStringList fallbackList;
        for (id item in list) {
            if ([item isKindOfClass: [NSArray class]]) {
                NSArray *langs = [(NSArray *) item sortedArrayUsingFunction: languageMapSort
                                                                             context: languages];
                for (NSArray *map in langs)
                    fallbackList.append(familyNameFromPostScriptName(&psNameToFamily, [map objectAtIndex: 1]));
            } else if ([item isKindOfClass: [NSString class]]) {
                fallbackList.append(familyNameFromPostScriptName(&psNameToFamily, item));
            }
        }

        fallbackLists[styleHint] = fallbackList;
    }

    [pool release];
}

Properties

fallbackLists

QHash<QFont::StyleHint, QStringList> QCoreTextFontDatabase::fallbackLists

private

Definition at line 61 of file qcoretextfontdatabase.h.

Referenced by fallbacksForFamily(), and populateFontDatabase().

---

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

• /src/plugins/platforms/fontdatabases/coretext/qcoretextfontdatabase.h
• /src/plugins/platforms/fontdatabases/coretext/qcoretextfontdatabase.mm