UIFont / CTFont — was ist das, Schriftarten und Core Text

Was sind UIFont und CTFont?

UIFont ist eine UIKit-Klasse, die eine Schriftart zur Textanzeige in UI-Komponenten repräsentiert: UILabel, UITextView, UITextField. Sie bietet eine einfache Schnittstelle zum Abrufen von System- und benutzerdefinierten Schriftarten mit angegebener Größe, Gewichtung und Stil. UIFont erlaubt keine direkte Kontrolle über Kerning, Ligaturen und OpenType-Funktionen — dafür wird Core Text verwendet.

CTFont ist ein Core Text-Typ (CTFontRef), der Low-Level-Zugriff auf Schriftdaten bietet. CTFont arbeitet direkt mit Core Graphics für das Rendering und unterstützt alle OpenType- und TrueType-Funktionen, einschließlich alternativer Glyphen, Ligaturen und variabler Schriftarten. CTFont wird intern von UIKit zum Rendern von UIFont verwendet, ist aber auch direkt für benutzerdefinierte Zeichnungen verfügbar.

Toll-Free Bridging

UIFont und CTFont unterstützen Toll-Free Bridging — die Konvertierung zwischen Typen ohne zusätzlichen Aufwand. Das Casting von UIFont as CTFont oder CTFont as UIFont ist in Swift und Objective-C möglich. Dies erlaubt die Verwendung der hochlevel UIKit-API für die Konfiguration und des low-level Core Text für das Rendering ohne Kopieren von Schriftdaten.

Schriftdeskriptor

Beide Klassen verwenden UIFontDescriptor (UIKit) / CTFontDescriptor (Core Text) zur Beschreibung von Schriftmerkmalen: Name, Größe, Gewichtung, Stil, Transformationsmatrix. Ein Deskriptor ist ein Attributwörterbuch, das modifiziert werden kann, um neue Schriftarten auf Basis vorhandener zu erstellen. Zum Beispiel traitItalic zu einem Deskriptor hinzufügen und eine kursive Version derselben Schrift erhalten.

UIFont — UIKit-Schriftarten

UIFont bietet mehrere Factory-Methoden zum Erstellen von Schriftarten. systemFont(ofSize:) gibt die Systemschrift San Francisco (iOS) oder Helvetica (ältere Versionen) zurück. boldSystemFont, italicSystemFont — Varianten mit bestimmten Stilen. preferredFont(forTextStyle:) gibt eine Dynamic Type-Schrift für den angegebenen Stil zurück: .headline, .body, .caption1, .footnote. Diese Schriftarten werden automatisch skaliert, wenn sich die Texteinstellungen im System ändern.

Zum Laden benutzerdefinierter Schriftarten wird UIFont(name:size:) mit dem PostScript-Namen der Schrift verwendet. Die Schrift muss zuerst zur Info.plist hinzugefügt und im App-Bundle enthalten sein. Laut Apple wird empfohlen, UIFont für alle Standard-UI-Komponenten zu verwenden und nur bei Bedarf an benutzerdefiniertem Rendering auf CTFont umzusteigen.

Dynamic Type

Dynamic Type ist ein adaptives Schriftsystem, das mit iOS 7 eingeführt wurde. Der Benutzer wählt in den Einstellungen seine bevorzugte Textgröße — von extra klein bis extra groß. UIFont.preferredFont gibt automatisch eine Schrift in der entsprechenden Größe zurück. Für den korrekten Betrieb müssen alle UILabel adjustsFontForContentSizeCategory = true haben. Dynamic Type ist für die Barrierefreiheit erforderlich.

UIFontDescriptor

UIFontDescriptor erlaubt das Ändern von Schriftattributen, ohne eine neue Instanz von Grund auf zu erstellen. Die Methoden addingAttributes(_:), withSymbolicTraits(_:), withFamily(_:) geben einen neuen Deskriptor mit geänderten Parametern zurück. Dies ist praktisch, um Schriftvarianten zu erhalten: traitBold zur Systemschrift hinzufügen und eine fette Version erhalten, ohne den PostScript-Namen zu kennen.

CTFont — Core Text-Schriftarten

CTFont (CTFontRef) ist ein Core Text-Typ für die Low-Level-Arbeit mit Schriftarten. Es wird durch CTFontCreateWithName, CTFontCreateWithFontDescriptor, CTFontCreateCopyWithAttributes erstellt. Jede Funktion gibt eine Schrift mit der angegebenen Schnittstelle, Größe und optionalen Attributen zurück. CTFont wird in Core Graphics zum Rendern von Text auf benutzerdefinierten UIView über drawRect verwendet.

CTFont bietet Zugriff auf Metriken, die in UIFont nicht verfügbar sind: CTFontGetGlyphsForCharacters gibt ein Array von Glyphen für angegebene Zeichen zurück, CTFontGetAdvancesForGlyphs — die Breite jeder Glyphe, CTFontGetBoundingBox — Glyphengrenzen. Dies ist für den Aufbau benutzerdefinierter Textlayouts erforderlich: Spalten, Rotation, Umbruch.

Schriftmetriken

CTFontGetAscent, CTFontGetDescent, CTFontGetLeading geben vertikale Schriftmetriken zurück. CTFontGetUnitsPerEm — Anzahl der Einheiten pro Em-Quadrat, verwendet für Proportionenberechnung. CTFontGetGlyphCount — Gesamtzahl der Glyphen in der Schrift. Diese Daten sind für Drucktypografie und benutzerdefinierte Layouts entscheidend, bei denen eine präzise Positionierung jedes Zeichens erforderlich ist.

OpenType und variable Schriftarten

CTFont unterstützt OpenType-Funktionen: CTFontCopyFeatures gibt ein Wörterbuch der verfügbaren Schriftfunktionen zurück (Ligaturen, alternative Zeichen, Kerning), CTFontEnableFeature aktiviert eine bestimmte Option. Variable Schriftarten werden über CTFontCopyVariation und CTFontCreateCopyWithVariation konfiguriert, wodurch weight, width und slant in einem kontinuierlichen Bereich geändert werden können.

Wie man UIFont im Code verwendet

Die Erstellung von UIFont in Swift erfolgt über eine der Factory-Methoden oder direkte Initialisierung nach Name. Der gebräuchlichste Weg ist systemFont(ofSize:weight:) für Systemschriften oder preferredFont(forTextStyle:) für Dynamic Type. Für benutzerdefinierte Schriftarten wird UIFont(name:size:) mit dem angegebenen PostScript-Namen verwendet.

Systemschrift mit verschiedenen Gewichtungen

UIFont.systemFont(ofSize:weight:) akzeptiert UIFont.Weight — von .ultraLight bis .black. Diese Methode gibt die San Francisco Systemschrift mit der entsprechenden Gewichtung zurück. UIFont.monospacedSystemFont, UIFont.monospacedDigitSystemFont geben dicktengleiche Schriften für Code und Zahlen zurück. Alle Systemschriften unterstützen automatisch Dynamic Type.

let regularFont = UIFont.systemFont(ofSize: 16, weight: .regular)
let boldFont = UIFont.systemFont(ofSize: 16, weight: .bold)
let headlineFont = UIFont.preferredFont(forTextStyle: .headline)
let monoFont = UIFont.monospacedSystemFont(ofSize: 14, weight: .regular)
label.font = headlineFont

Jede Schrift kann direkt der font-Eigenschaft von UILabel zugewiesen oder in NSAttributedString über NSFontAttributeName verwendet werden. Systemschriften werden von iOS zwischengespeichert, daher verursacht das erneute Erstellen einer Systemschrift keinen Overhead.

Benutzerdefinierte Schrift aus dem Bundle

Um eine benutzerdefinierte Schrift zu verwenden, fügen Sie die TTF- oder OTF-Datei zum Projekt-Bundle hinzu und geben Sie sie in Info.plist (UIAppFonts) an. Der PostScript-Name der Schrift kann über UIFont.familyNames und UIFont.fontNames(forFamilyName:) ermittelt werden. Nach der Registrierung ist die Schrift über UIFont(name:size:) von überall in der App verfügbar.

// Alle Schriftfamiliennamen abrufen
for family in UIFont.familyNames {
    let names = UIFont.fontNames(forFamilyName: family)
    print("\(family): \(names)")
}
// Benutzerdefinierte Schrift laden
if let customFont = UIFont(name: "MyCustomFont-Regular", size: 18) {
    label.font = customFont
}

Wenn der Schriftname falsch angegeben wird, gibt UIFont(name:size:) nil zurück. Es wird empfohlen, während des Debuggens alle verfügbaren Schriftnamen über UIFont.familyNames und UIFont.fontNames(forFamilyName:) auszugeben, um sicherzustellen, dass die Schrift korrekt registriert ist.

Benutzerdefinierte Schriftarten mit UIFont und CTFont

Das Laden benutzerdefinierter Schriften ist auf zwei Arten möglich: statische Registrierung über Info.plist (UIAppFonts) und dynamische Registrierung über CTFontManagerRegisterGraphicsFont. Die erste Methode ist einfacher — die Schrift ist sofort nach dem App-Start verfügbar. Die zweite wird für aus dem Netzwerk heruntergeladene oder On-Demand-Ressourcen verwendet.

Die dynamische Registrierung ist nützlich für On-Demand-Ressourcen: Wenn die App 20+ Schriftarten enthält, können alle aus dem initialen Bundle ausgeschlossen und bei der ersten Verwendung heruntergeladen werden. CTFontManagerRegisterFontsForURLs registriert Schriftarten von angegebenen URLs. Nach der Registrierung ist die Schrift wie gewohnt über UIFont(name:size:) verfügbar.

CTFontCreateWithName für benutzerdefinierte Schrift

Für benutzerdefiniertes Rendering über Core Text verwenden Sie CTFontCreateWithName mit dem PostScript-Namen der Schrift. Der Unterschied zu UIFont besteht darin, dass CTFont mit einer Transformationsmatrix erstellt werden kann (CTFontCreateWithNameAndOptions) — zum Erstellen verzerrter Schriften: Neigung, X-Achsen-Skalierung, Rotation. Dies ist in UIFont ohne affine Transformationen nicht verfügbar.

// CTFont mit Scherungsmatrix erstellen
var matrix = CGAffineTransform(a: 1, b: 0, c: 0.2, d: 1, tx: 0, ty: 0)
let ctFont = CTFontCreateWithName(
    "Helvetica" as CFString,
    24, &matrix)
// Toll-Free Bridging mit UIFont verwenden
let uiFont = ctFont as UIFont
label.font = uiFont

Die Transformationsmatrix ermöglicht das Erstellen kursiver Varianten ohne separate Schriftdatei. Der Parameter c (skew) fügt Zeichen eine Neigung hinzu. Die Matrix erlaubt auch das horizontale Skalieren der Schrift — Erstellen von kondensierten oder erweiterten Varianten einer Schrift.

Unterschiede zwischen UIFont und CTFont

Der Hauptunterschied zwischen UIFont und CTFont ist die Abstraktionsebene. UIFont bietet eine einfache API für häufige Aufgaben: Systemschrift abrufen, Größe ändern, auf UILabel anwenden. CTFont bietet vollständige Kontrolle über die Schrift: Zugriff auf Glyphen, Metriken, OpenType-Tabellen und variable Achsen. Die Wahl hängt von der Aufgabe ab.

Für 95% der iOS-Entwicklungsaufgaben ist UIFont ausreichend. Core Text mit CTFont ist gerechtfertigt bei der Erstellung von Texteditoren, PDF-Generatoren, Büchern mit typografischem Layout oder Apps mit benutzerdefiniertem Rendering seltener Sprachen.

Leistung und Best Practices

Das Arbeiten mit Schriftarten unter iOS erfordert die Berücksichtigung der Leistung. Jede eindeutige Schrift wird beim ersten Zugriff in den Speicher geladen und verbraucht Ressourcen. Die San Francisco Systemschriften sind vorab geladen und verursachen keinen Overhead. Benutzerdefinierte Schriften werden aus der Datei geladen und nach dem ersten Laden vom System zwischengespeichert.

Es wird empfohlen, die Anzahl der eindeutigen Schriften in einer App auf 3-5 Familien zu beschränken. Jede Schrift belegt 50 KB bis 2 MB im Speicher. Die Verwendung verschiedener Gewichtungen einer Familie (regular, bold, medium) ist effizienter als das Laden mehrerer verschiedener Familien.

UIFont-Zwischenspeicherung

Das System speichert erstellte UIFont-Instanzen zwischen, daher erstellen wiederholte Aufrufe von UIFont.systemFont(ofSize: 16, weight: .regular) kein neues Objekt. Allerdings wird UIFont(name:size:) für benutzerdefinierte Schriften nicht immer zwischengespeichert — es wird empfohlen, häufig verwendete Schriften in statischen Eigenschaften oder NSCache zu speichern, um ein erneutes Laden aus der Datei zu vermeiden.

Asynchrones Schriftladen

Bei der dynamischen Registrierung von Schriften über CTFontManagerRegisterGraphicsFont kann der Prozess asynchron sein, wenn die Schriftdatei aus dem Netzwerk heruntergeladen wird. In diesem Fall sollten UILabel oder UITextView eine Fallback-Systemschrift anzeigen, bis der Ladevorgang abgeschlossen ist. Nach der Registrierung wird die Schrift verfügbar und der Bildschirm aktualisiert automatisch die Textanzeige.