Font Descriptor: Schlüsselkonzepte und Möglichkeiten des Schriftartdeskriptors

Was ist ein Font Descriptor und warum wird er benötigt

Font Descriptor ist ein Objekt, das Schriftarteigenschaften als eine Reihe von Schlüssel-Wert-Paaren beschreibt, anstatt als eine bestimmte Schriftdatei. Anstatt eine Schrift mit Namen zu erstellen, gibt der Entwickler die Familie, Schriftart, Größe und optionale Attribute an, und das System wählt die beste Übereinstimmung. Dieser Ansatz ist entscheidend für adaptive Typografie: Derselbe Deskriptor kann auf verschiedenen iOS-Versionen funktionieren, bei denen sich die Menge der verfügbaren Schriftarten unterscheidet. Gemäß den iOS Human Interface Guidelines ist der Schriftabgleich über Deskriptoren die empfohlene Methode für die Arbeit mit dynamischen Schriftarten.

Ohne Font Descriptor müssten Entwickler die Verfügbarkeit jeder Schriftart mit Namen überprüfen und manuell Fallback-Optionen definieren. Der Deskriptor automatisiert diesen Prozess: Er enthält eine Kompatibilitätsmatrix von Schriftarten (normal, fett, kursiv, fett kursiv) und wenn keine genaue Übereinstimmung gefunden wird, gibt er die nächstgelegene verfügbare zurück. Systemabgleich funktioniert auf Core Text-Ebene und ist sowohl auf iOS als auch auf macOS über die einheitliche NSFontDescriptor-API verfügbar.

Deskriptoren werden auch für benutzerdefinierte Schriftarten verwendet — geladen über Info.plist oder manuell hinzugefügt. Wenn eine Schriftart im System registriert ist, wird ihr Deskriptor auf die gleiche Weise wie für eine Systemart erstellt. Plattformübergreifender Hinweis: Das Konzept eines Deskriptors existiert auch in Android über Typeface.Builder, aber die iOS-Implementierung über UIFontDescriptor bietet deutlich mehr Attribute — über 20 im Vergleich zu 5 in Android.

Wichtige Eigenschaften und Attribute von Font Descriptor

UIFontDescriptor enthält Attribute, die in einem fontAttributes-Wörterbuch vom Typ [UIFontDescriptor.AttributeName: Any] gruppiert sind. Zu den wichtigsten Attributen gehören Schriftfamilie, Name, Größe, Merkmale, Transformationsmatrix, optische Größe und Textstil. Laut Apple WWDC 2019 Session 227 ist die Verwendung von Textstilen (Dynamic Type) für barrierefreie Anwendungen obligatorisch.

Das Merkmale-Attribut (traits) ist ein Wörterbuch mit symbolischen Eigenschaften: Gewicht (UIFontWeightTrait), Neigung (UIFontSlantTrait), Breite (UIFontWidthTrait) und andere. Diese Werte werden vom Schriftabgleicher verwendet, um eine Schriftart auszuwählen. Zum Beispiel UIFontWeightTrait mit einem Wert von 0.0 — normale Schriftart, 0.3 — fett. Das System bildet numerische Werte automatisch auf verfügbare Schriftvarianten ab.

Zusätzliche Attribute umfassen featureSettings für OpenType-Funktionen (Ligaturen, Kerning, Zahlenproportionen), visibleName zur Anzeige für den Benutzer, matrix für affine Schrifttransformationen und cascadeList für kaskadierende Fallback-Schriftlisten. Die vollständige Attributliste deckt praktisch alle Typografie-Szenarien in iOS und macOS ab.

Erstellen von UIFont über Font Descriptor in Swift

Die primäre Methode zur Arbeit mit Font Descriptor in iOS besteht darin, einen Deskriptor zu erstellen und daraus dann einen UIFont zu generieren. Dies ist der bevorzugte Ansatz, wenn Sie eine Schriftart mit bestimmten Eigenschaften benötigen, ohne den genauen Namen zu kennen. Der Prozess besteht aus zwei Schritten: Erstellen eines UIFontDescriptor über einen Initialisierer und Aufrufen der Methode font(withSize:) auf dem Deskriptor.

import UIKit

// Schriftdeskriptor für Familie erstellen
let descriptor = UIFontDescriptor.init(
    fontAttributes: [
        .family: "SF Pro",
        .traits: [
            .weight: UIFont.Weight.bold
        ]
    ]
)

// UIFont aus Deskriptor generieren
let font = descriptor.font(withSize: 17)

Dieser Ansatz garantiert, dass das System die beste Übereinstimmung für die fette Schriftart von SF Pro auf dem aktuellen Gerät auswählt. Hauptvorteil — der Code ist unabhängig von der iOS-Version: Unter iOS 13 wird SF Pro verwendet, unter früheren Versionen Helvetica Neue oder die Standardsystemschrift.

Um eine Schriftart mit dynamischer Größe zu erstellen, verwenden Sie den Initialisierer mit Textstil und Skalierung. Dynamic Type passt die Größe automatisch an die Benutzereinstellungen an:

// Dynamic Type Deskriptor
let bodyDescriptor = UIFontDescriptor
    .preferredFontDescriptor(withTextStyle: .body)

// Schrift fett machen
let boldDescriptor = bodyDescriptor.withSymbolicTraits([.traitBold])

// UIFont unter Beibehaltung der dynamischen Größe generieren
let boldBodyFont = UIFont(
    descriptor: boldDescriptor!,
    size: bodyDescriptor.pointSize
)

Wichtig: Die Methode withSymbolicTraits gibt einen optionalen Deskriptor zurück — wenn die angeforderte Schriftart nicht verfügbar ist, wird nil zurückgegeben. Überprüfen Sie immer das Optional vor der Verwendung.

Ändern von Attributen durch Hinzufügen und Ersetzen

Font Descriptor unterstützt ein unveränderliches Modell — jede Änderungsmethode gibt einen neuen Deskriptor mit dem geänderten Attribut zurück. Dies folgt der Wertsemantik und macht den Code vorhersagbar: Der ursprüngliche Deskriptor ändert sich nie. Die wichtigsten Änderungsmethoden sind: addingAttributes zum Hinzufügen von Attributen, withFace zum Ändern der Schriftart, withSize zum Ändern der Größe und withMatrix für affine Transformation.

Die Methode addingAttributes ist die flexibelste. Sie nimmt ein Wörterbuch von Attributen entgegen und gibt einen neuen Deskriptor zurück. Bei übereinstimmenden Schlüsseln ersetzen neue Werte alte. Dies ermöglicht das Kombinieren von Änderungen: Gewicht hinzufügen, Größe ändern und Ligaturen in einem einzigen Aufruf aktivieren. Laut Apple Technical Q&A QA1682 ist addingAttributes die empfohlene Methode für Massenänderungen über Erweiterungen.

Praktischer Anwendungsfall: Erstellen einer Schriftart für nichtproportionale Texte in einem Code-Editor. Der Entwickler nimmt den systemeigenen nichtproportionalen Deskriptor, fügt ein reduziertes Gewicht für dünne Linien hinzu und erhöht den Zeichenabstand über featureSettings. Dies ergibt lesbareren Code ohne Laden einer separaten Schriftart.

let monoDescriptor = UIFontDescriptor.monospacedDigitFontDescriptor()

// Benutzerdefinierte Attribute hinzufügen
let customDescriptor = monoDescriptor.addingAttributes([
    .size: 14,
    .traits: [
        .weight: UIFont.Weight.medium
    ]
])

let monoFont = UIFont(
    descriptor: customDescriptor,
    size: 14
)

Einschränkung: Nicht alle Attribute können nach der Erstellung des Deskriptors geändert werden. Beispielsweise wird die Schriftfamilie einmal bei der Initialisierung festgelegt. Wenn Sie die Familie ändern müssen, erstellen Sie einen neuen Deskriptor. Dies hängt mit der Core Text-Architektur zusammen, bei der der Deskriptor an eine bestimmte Schriftressource gebunden ist.

Schriftabgleich und Systemschnittstellensuche

Schriftabgleich ist eine Schlüsselfunktion von Font Descriptor, die automatisch die beste Übereinstimmung für die angeforderten Attribute unter den installierten Schriftarten auswählt. Der Prozess umfasst drei Phasen: Filtern (Ausschluss inkompatibler Schriftarten), Einstufen (Sortieren nach Übereinstimmungsgrad) und Auswahl (Rückgabe des besten Ergebnisses). Der Abgleich erfolgt auf Core Text-Ebene — dem Framework, das aller iOS-Typografie zugrunde liegt.

Um alle Schriftarten zu finden, die zu einem Deskriptor passen, verwenden Sie die Methode matchingFontDescriptors. Sie gibt ein Array von nach Relevanz sortierten Deskriptoren zurück. Der Entwickler kann die genaue Übereinstimmung (erstes Element) auswählen oder für benutzerdefinierte Logik durch die Optionen iterieren. Laut dem Apple Font Handling Guide ist dies die einzige Möglichkeit, eine Liste verfügbarer Schriftarten für eine bestimmte Familie zu erhalten, ohne sie mit Namen aufzuzählen.

Anwendungsfall: bei der Auswahl einer Schriftart in einer Texteinstellungsoberfläche. Der Benutzer wählt eine Familie aus, und die Anwendung verwendet matchingFontDescriptors, um alle verfügbaren Schriftarten zu erhalten und in einer Auswahl anzuzeigen. Ohne Abgleich müssten Entwickler eine Liste von Optionen hartcodieren, die sich zwischen iOS-Versionen ändert.

let searchDescriptor = UIFontDescriptor.init(
    fontAttributes: [.family: "SF Mono"]
)

// Alle verfügbaren Schriftarten abrufen
let matchingDescriptors = searchDescriptor
    .matchingFontDescriptors(withMandatoryKeys: nil)

for descriptor in matchingDescriptors {
    print(descriptor.object(forKey: .visibleName) ?? "unnamed")
}

Erforderliche Schlüssel (mandatory keys) — ein Parameter, der die Suche einschränkt. Wenn Sie [.family] angeben, gibt der Abgleich alle Schriftarten der angegebenen Familie zurück. Wenn Sie [.family, .traits] angeben — nur diejenigen, die sowohl mit Familie als auch Schriftart übereinstimmen. Die Verwendung erforderlicher Schlüssel beschleunigt den Abgleich bei der Suche nach einer Teilmenge von Schriftarten.

Leistung: Der Abgleich ist ein synchroner Vorgang, der auf iOS 0,5 bis 5 ms dauert. Für eine einzelne Suche ist dies vernachlässigbar, aber bei Masseniteration über Deskriptoren (z. B. in einer Auswahl mit über 50 Schriftarten) wird empfohlen, die Ergebnisse zwischenzuspeichern. Apple empfiehlt, den Abgleich einmal beim Laden des Bildschirms durchzuführen und das Deskriptorarray zu speichern.

Integration mit Core Text und CTFontDescriptor

Core Text ist ein C-basiertes Low-Level-Framework für die Arbeit mit Typografie auf iOS und macOS. Sein Gegenstück zu UIFontDescriptor ist CTFontDescriptor, das dieselben Fähigkeiten auf Core Foundation-Ebene bietet. CTFontDescriptor wird in Core Text-APIs zum Erstellen von Schriftarten, Messen von Text und Rendern komplexer Typografie verwendet. UIFontDescriptor ist im Wesentlichen ein Objective-C-Wrapper um CTFontDescriptor mit einem erweiterten Satz von Attributen.

Das toll-free Bridging zwischen UIFontDescriptor und CTFontDescriptor ermöglicht die Übergabe von Deskriptoren zwischen UIKit und Core Text ohne Konvertierung. Dies ist entscheidend für Anwendungen, die benutzerdefiniertes Text-Rendering verwenden — zum Beispiel Texteditoren auf Basis von TextKit oder Code-Editoren mit Syntaxhervorhebung. Beispiel: CTFontDescriptorCreateCopyWithAttribute erstellt eine Kopie des Deskriptors mit einem hinzugefügten Attribut — ein Analogon zu addingAttributes von UIFontDescriptor.

Das Schlüsselattribut kCTFontURLAttribute in CTFontDescriptor enthält die URL der Schriftdatei. Dies ermöglicht die Bestimmung, ob eine Schriftart systemeigen oder benutzerdefiniert ist. Bei benutzerdefinierten Schriftarten zeigt die URL auf die Schriftdatei (.ttf oder .otf); bei Systemschriftarten auf das Systemschriftverzeichnis. Daten über den Deskriptor sind schreibgeschützt; das Ändern der Schriftdatei über URL wird nicht unterstützt.

Für erweiterte Typografie — benutzerdefinierte Ligaturen, kontextuelle Ersetzungen, alternative Glyphen — verwenden Sie CTFontDescriptorCopyAttribute mit dem Schlüssel kCTFontFeatureSettingsAttribute. Dieses Attribut enthält ein Array von OpenType-Funktionswörterbüchern, die über den Deskriptor hinzugefügt werden können. Laut dem Apple Core Text Programming Guide gibt die Kombination von UIFontDescriptor mit Core Text die vollständige Kontrolle über die Anwendungstypografie.