Font Descriptor: kernconcepten en mogelijkheden van de lettertype-descriptor

Wat is Font Descriptor en waarom is het nodig

Font Descriptor — is een object dat de kenmerken van een lettertype beschrijft als een set sleutel-waardeparen, niet als een specifiek lettertypebestand. In plaats van een lettertype op naam te maken, specificeert de ontwikkelaar de familie, snede, grootte en optionele attributen, en het systeem kiest de beste overeenkomst. Deze benadering is cruciaal voor adaptieve typografie: dezelfde descriptor kan werken op verschillende iOS-versies waar de set beschikbare lettertypen verschilt. Volgens iOS Human Interface Guidelines is lettertypematching via descriptoren de aanbevolen manier om met dynamische lettertypen te werken.

Zonder Font Descriptor zou de ontwikkelaar de beschikbaarheid van elk lettertype op naam moeten controleren en handmatig fallback-varianten moeten bepalen. De descriptor automatiseert dit proces: het bevat een compatibiliteitsmatrix van sneden — normaal, vet, cursief, vet cursief — en bij afwezigheid van een exacte overeenkomst retourneert het de dichtstbijzijnde beschikbare. Systeemmatching werkt op het niveau van Core Text en is zowel op iOS als macOS beschikbaar via de uniforme NSFontDescriptor API.

Descriptoren worden ook gebruikt voor aangepaste lettertypen — geladen via Info.plist of handmatig toegevoegd. Als een lettertype in het systeem is geregistreerd, wordt de descriptor ervan op dezelfde manier gemaakt als voor een systeemlettertype. Cross-platform notitie: het concept van een descriptor bestaat ook in Android via Typeface.Builder, maar de iOS-implementatie via UIFontDescriptor biedt aanzienlijk meer attributen — meer dan 20 tegenover 5 in Android.

Belangrijkste eigenschappen en attributen van Font Descriptor

UIFontDescriptor bevat attributen gegroepeerd in het fontAttributes-woordenboek van het type [UIFontDescriptor.AttributeName: Any]. Belangrijke attributen omvatten de lettertypefamilie (family), naam (name), grootte (size), snede (traits), transformatiematrix (matrix), optische grootte (opticalSize) en tekststijl (textStyle). Volgens Apple WWDC 2019 Session 227 is het gebruik van tekststijlen — Dynamic Type — verplicht voor accessibility-compatibele applicaties.

Het traits-attribuut — is een woordenboek dat symbolische kenmerken bevat: dikte (UIFontWeightTrait), cursief (UIFontSlantTrait), breedte (UIFontWidthTrait) en andere. Deze waarden worden gebruikt door de lettertypematcher voor het selecteren van de snede. Bijvoorbeeld UIFontWeightTrait met waarde 0.0 — normale snede, 0.3 — vet. Het systeem mapt numerieke waarden automatisch naar beschikbare lettertypevarianten.

Extra attributen omvatten featureSettings voor OpenType-functies (ligaturen, kerning, cijferproporties), visibleName voor weergave aan de gebruiker, matrix voor affiene transformaties van het lettertype en cascadeList voor trapsgewijze lijsten van fallback-lettertypen. De volledige lijst met attributen dekt praktisch alle typografiescenario’s in iOS en macOS.

UIFont maken via Font Descriptor in Swift

De primaire manier om met Font Descriptor in iOS te werken — het maken van een descriptor met daaropvolgende generatie van UIFont. Dit is de voorkeursbenadering wanneer u een lettertype met specifieke kenmerken moet krijgen zonder de exacte naam te kennen. Het proces bestaat uit twee stappen: het maken van UIFontDescriptor via een initialisator en het aanroepen van de methode font(withSize:) op de descriptor.

import UIKit

// Maak lettertype-descriptor voor familie
let descriptor = UIFontDescriptor.init(
    fontAttributes: [
        .family: "SF Pro",
        .traits: [
            .weight: UIFont.Weight.bold
        ]
    ]
)

// Genereer UIFont uit descriptor
let font = descriptor.font(withSize: 17)

Deze benadering garandeert dat het systeem de beste overeenkomst kiest voor de vette snede van SF Pro op het huidige apparaat. Belangrijkste voordeel — de code is niet afhankelijk van de iOS-versie: op iOS 13 wordt SF Pro gebruikt, op oudere versies — Helvetica Neue of het standaard systeemlettertype.

Voor het maken van een lettertype met dynamische grootte wordt een initialisator met tekststijl en schaal gebruikt. Dynamic Type past de grootte automatisch aan de gebruikersinstellingen aan:

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

// Maak lettertype vet
let boldDescriptor = bodyDescriptor.withSymbolicTraits([.traitBold])

// Genereer UIFont met behoud van dynamische grootte
let boldBodyFont = UIFont(
    descriptor: boldDescriptor!,
    size: bodyDescriptor.pointSize
)

Belangrijk: de methode withSymbolicTraits retourneert een optionele descriptor — als de gevraagde snede niet beschikbaar is, wordt nil geretourneerd. Controleer altijd de optional voor gebruik.

Attributen wijzigen door toevoegen en vervangen

Font Descriptor ondersteunt een immutabel model — elke wijzigingsmethode retourneert een nieuwe descriptor met het gewijzigde attribuut. Dit komt overeen met waarde-semantiek en maakt de code voorspelbaar: de oorspronkelijke descriptor verandert nooit. De belangrijkste wijzigingsmethoden: addingAttributes voor het toevoegen van attributen, withFace voor het wijzigen van de snede, withSize voor het wijzigen van de grootte, withMatrix voor affiene transformatie.

De methode addingAttributes — de meest flexibele. Het accepteert een woordenboek met attributen en retourneert een nieuwe descriptor. Bij overeenkomst van sleutels vervangen nieuwe waarden de oude. Dit maakt het mogelijk wijzigingen te combineren: gewicht toevoegen, grootte wijzigen en ligaturen inschakelen in één aanroep. Volgens Apple Technical Q&A QA1682 is addingAttributes de aanbevolen manier voor bulkwijziging via extensie.

Praktische toepassing: het maken van een lettertype voor monospace-tekst in een code-editor. De ontwikkelaar neemt de systeem-monospace-descriptor, voegt een verminderd gewicht toe voor dunne lijnen en vergroot de spatie tussen letters via featureSettings. Dit geeft beter leesbare code zonder een apart lettertype te laden.

let monoDescriptor = UIFontDescriptor.monospacedDigitFontDescriptor()

// Voeg aangepaste attributen toe
let customDescriptor = monoDescriptor.addingAttributes([
    .size: 14,
    .traits: [
        .weight: UIFont.Weight.medium
    ]
])

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

Beperking: niet alle attributen kunnen worden gewijzigd na het maken van de descriptor. De lettertypefamilie (family) wordt bijvoorbeeld eenmalig ingesteld bij initialisatie. Als u de familie moet wijzigen, maak dan een nieuwe descriptor. Dit hangt samen met de architectuur van Core Text, waar de descriptor is gekoppeld aan een specifieke lettertypebron.

Lettertypematching en zoeken naar systeemlettertypen

Lettertypematching — de belangrijkste functie van Font Descriptor, die automatisch de beste overeenkomst selecteert voor de gevraagde attributen uit de geïnstalleerde lettertypen. Het proces omvat drie fasen: filteren (uitsluiten van niet-overeenkomende lettertypen), rangschikken (sorteren op mate van overeenkomst) en selecteren (retourneren van het beste resultaat). Matching wordt uitgevoerd op het niveau van Core Text — het framework dat aan de basis ligt van alle iOS-typografie.

Voor het zoeken naar alle lettertypen die overeenkomen met een descriptor, wordt de methode matchingFontDescriptors gebruikt. Het retourneert een reeks descriptoren, gesorteerd op relevantie. De ontwikkelaar kan de exacte overeenkomst kiezen (eerste element) of de varianten doorlopen voor aangepaste logica. Volgens Apple Font Handling Guide is dit de enige manier om de lijst van beschikbare sneden voor een specifieke familie te krijgen zonder opsomming op naam.

Gebruiksscenario: bij het selecteren van een lettertype in de tekstinstellingeninterface. De gebruiker kiest een familie en de applicatie haalt via matchingFontDescriptors alle beschikbare sneden op en toont ze in een picker. Zonder matching zou u de lijst met varianten, die tussen iOS-versies verandert, hard moeten coderen.

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

// Haal alle beschikbare sneden op
let matchingDescriptors = searchDescriptor
    .matchingFontDescriptors(withMandatoryKeys: nil)

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

Mandatory keys — parameter die het zoeken beperkt. Als [.family] wordt opgegeven, retourneert matching alle lettertypen van de opgegeven familie. Als [.family, .traits] wordt opgegeven — alleen die zowel qua familie als snede overeenkomen. Het gebruik van mandatory keys versnelt matching bij het zoeken naar een subset van lettertypen.

Prestaties: matching is een synchrone bewerking die 0,5 tot 5 ms duurt op iOS. Voor een enkele zoekopdracht is dit onmerkbaar, maar bij het massaal doorlopen van descriptoren (bijvoorbeeld in een picker met 50+ lettertypen) wordt caching van resultaten aanbevolen. Apple raadt aan om matching eenmalig uit te voeren bij het laden van het scherm en de reeks descriptoren te bewaren.

Integratie met Core Text en CTFontDescriptor

Core Text — een laag-niveau C-framework voor het werken met typografie op iOS en macOS. Het equivalent van UIFontDescriptor — CTFontDescriptor, dat dezelfde mogelijkheden biedt op het niveau van Core Foundation. CTFontDescriptor wordt gebruikt in de Core Text API voor het maken van lettertypen, het meten van tekst en het renderen van complexe typografie. UIFontDescriptor is in wezen een Objective-C-wrapper rond CTFontDescriptor met een uitgebreide set attributen.

Toll-free bridging tussen UIFontDescriptor en CTFontDescriptor maakt het mogelijk descriptoren tussen UIKit en Core Text door te geven zonder conversie. Dit is cruciaal voor applicaties die aangepaste tekstweergave gebruiken — bijvoorbeeld teksteditors op basis van TextKit of code-editors met syntaxishighlighting. Voorbeeld: CTFontDescriptorCreateCopyWithAttribute maakt een kopie van de descriptor met een toegevoegd attribuut — het equivalent van addingAttributes uit UIFontDescriptor.

Sleutelattribuut kCTFontURLAttribute in CTFontDescriptor bevat de URL van het lettertypebestand. Hiermee kan worden bepaald of het lettertype systeem- of aangepast is. Voor aangepaste lettertypen verwijst de URL naar het lettertypebestand (.ttf of .otf), voor systeemlettertypen — naar de systeemlettertypemap. Gegevens via de descriptor zijn alleen-lezen; het wijzigen van het lettertypebestand via URL wordt niet ondersteund.

Voor geavanceerde typografie — aangepaste ligaturen, contextuele vervangingen, alternatieve glyphs — wordt CTFontDescriptorCopyAttribute gebruikt met de sleutel kCTFontFeatureSettingsAttribute. Dit attribuut bevat een reeks woordenboeken van OpenType-functies die via de descriptor kunnen worden toegevoegd. Volgens Apple Core Text Programming Guide geeft het combineren van UIFontDescriptor met Core Text volledige controle over de typografie van de applicatie.