Font Descriptor: nyckelbegrepp och möjligheter för typsnittsbeskrivaren

Vad är Font Descriptor och varför behövs det

Font Descriptor — är ett objekt som beskriver typsnittets egenskaper som en uppsättning nyckel-värdepar, inte som en specifik typsnittsfil. Istället för att skapa ett typsnitt efter namn anger utvecklaren familj, stil, storlek och valfria attribut, och systemet väljer den bästa matchningen. Detta tillvägagångssätt är avgörande för adaptiv typografi: samma beskrivare kan fungera på olika iOS-versioner där uppsättningen av tillgängliga typsnitt skiljer sig. Enligt iOS Human Interface Guidelines är typsnittsmatchningsfunktion via beskrivare det rekommenderade sättet att arbeta med dynamiska typsnitt.

Utan Font Descriptor skulle utvecklaren behöva kontrollera tillgängligheten för varje typsnitt efter namn och manuellt bestämma reservvarianter. Beskrivaren automatiserar denna process: den innehåller en kompatibilitetsmatris för stilar — normal, fet, kursiv, fet kursiv — och om ingen exakt matchning finns, returnerar den närmaste tillgängliga. Systemmatchningsfunktion fungerar på Core Text-nivå och är tillgänglig både på iOS och macOS via det enhetliga NSFontDescriptor API:t.

Beskrivare används också för anpassade typsnitt — laddade via Info.plist eller tillagda manuellt. Om ett typsnitt är registrerat i systemet skapas dess beskrivare precis som för ett systemtypsnitt. Cross-platform-notering: konceptet med en beskrivare finns också i Android via Typeface.Builder, men iOS-implementeringen via UIFontDescriptor ger betydligt fler attribut — över 20 jämfört med 5 i Android.

Huvudegenskaper och attribut för Font Descriptor

UIFontDescriptor innehåller attribut grupperade i ordboken fontAttributes av typen [UIFontDescriptor.AttributeName: Any]. Nyckelattributen omfattar typsnittsfamilj (family), namn (name), storlek (size), stil (traits), transformationsmatris (matrix), optisk storlek (opticalSize) och textstil (textStyle). Enligt Apple WWDC 2019 Session 227 är användning av textstilar — Dynamic Type — obligatorisk för applikationer som är kompatibla med tillgänglighet.

Attributet traits — är en ordbok som innehåller symboliska egenskaper: tjocklek (UIFontWeightTrait), kursiv (UIFontSlantTrait), bredd (UIFontWidthTrait) och andra. Dessa värden används av typsnittsmatchningsfunktionen för att välja stil. Till exempel UIFontWeightTrait med värdet 0.0 — normal stil, 0.3 — fet. Systemet mappar automatiskt numeriska värden till tillgängliga typsnittsvarianter.

Ytterligare attribut omfattar featureSettings för OpenType-funktioner (ligaturer, kerning, sifferproportioner), visibleName för visning för användaren, matrix för affina transformationer av typsnittet och cascadeList för kaskadlistor av reservtypsnitt. Den fullständiga listan över attribut täcker praktiskt taget alla typografiscenarier i iOS och macOS.

Skapa UIFont via Font Descriptor i Swift

Det primära sättet att arbeta med Font Descriptor i iOS — skapa en beskrivare med efterföljande generering av UIFont. Detta är det föredragna tillvägagångssättet när du behöver få ett typsnitt med specifika egenskaper utan att känna till det exakta namnet. Processen består av två steg: skapa UIFontDescriptor via en initierare och anropa metoden font(withSize:) på beskrivaren.

import UIKit

// Skapa typsnittsbeskrivare för familj
let descriptor = UIFontDescriptor.init(
    fontAttributes: [
        .family: "SF Pro",
        .traits: [
            .weight: UIFont.Weight.bold
        ]
    ]
)

// Generera UIFont från beskrivare
let font = descriptor.font(withSize: 17)

Detta tillvägagångssätt garanterar att systemet väljer den bästa matchningen för den feta stilen av SF Pro på den aktuella enheten. Främsta fördelen — koden är inte beroende av iOS-versionen: på iOS 13 används SF Pro, på äldre versioner — Helvetica Neue eller standard systemtypsnittet.

För att skapa ett typsnitt med dynamisk storlek används en initierare med textstil och skalning. Dynamic Type justerar automatiskt storleken efter användarens inställningar:

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

// Gör typsnittet fet
let boldDescriptor = bodyDescriptor.withSymbolicTraits([.traitBold])

// Generera UIFont med bevarad dynamisk storlek
let boldBodyFont = UIFont(
    descriptor: boldDescriptor!,
    size: bodyDescriptor.pointSize
)

Viktigt: metoden withSymbolicTraits returnerar en valfri beskrivare — om den begärda stilen inte är tillgänglig returneras nil. Kontrollera alltid det valfria värdet före användning.

Ändra attribut genom att lägga till och ersätta

Font Descriptor stöder en oföränderlig modell — varje ändringsmetod returnerar en ny beskrivare med det ändrade attributet. Detta motsvarar värdesemantik och gör koden förutsägbar: den ursprungliga beskrivaren ändras aldrig. De viktigaste ändringsmetoderna: addingAttributes för att lägga till attribut, withFace för att ändra stil, withSize för att ändra storlek, withMatrix för affin transformation.

Metoden addingAttributes — den mest flexibla. Den accepterar en ordbok med attribut och returnerar en ny beskrivare. Vid nyckelöverensstämmelse ersätter nya värden de gamla. Detta gör det möjligt att kombinera ändringar: lägga till vikt, ändra storlek och aktivera ligaturer i ett anrop. Enligt Apple Technical Q&A QA1682 är addingAttributes den rekommenderade metoden för massändring via tillägg.

Praktisk tillämpning: skapa ett typsnitt för monospace-text i en kodredigerare. Utvecklaren tar systemets monospace-beskrivare, lägger till minskad vikt för tunna linjer och ökar bokstavsavståndet via featureSettings. Detta ger mer läsbar kod utan att ladda ett separat typsnitt.

let monoDescriptor = UIFontDescriptor.monospacedDigitFontDescriptor()

// Lägg till anpassade attribut
let customDescriptor = monoDescriptor.addingAttributes([
    .size: 14,
    .traits: [
        .weight: UIFont.Weight.medium
    ]
])

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

Begränsning: inte alla attribut kan ändras efter att beskrivaren skapats. Till exempel anges typsnittsfamiljen (family) en gång vid initiering. Om du behöver ändra familjen, skapa en ny beskrivare. Detta beror på Core Text-arkitekturen, där beskrivaren är bunden till en specifik typsnittsresurs.

Typsnittsmatchningsfunktion och sökning efter systemtypsnitt

Typsnittsmatchningsfunktion — den viktigaste funktionen i Font Descriptor, som automatiskt väljer den bästa matchningen för de begärda attributen från installerade typsnitt. Processen omfattar tre faser: filtrering (uteslutning av icke-matchande typsnitt), rangordning (sortering efter matchningsgrad) och val (returnering av bästa resultatet). Matchning utförs på Core Text-nivå — ramverket som ligger till grund för all iOS-typografi.

För att söka efter alla typsnitt som matchar en beskrivare används metoden matchingFontDescriptors. Den returnerar en array av beskrivare sorterade efter relevans. Utvecklaren kan välja exakt matchning (första elementet) eller bläddra bland varianter för anpassad logik. Enligt Apple Font Handling Guide är detta det enda sättet att få en lista över tillgängliga stilar för en specifik familj utan uppräkning efter namn.

Användningsscenario: vid val av typsnitt i textinställningsgränssnittet. Användaren väljer en familj och applikationen hämtar via matchingFontDescriptors alla tillgängliga stilar och visar dem i en picker. Utan matchning skulle du behöva hårdkoda listan över varianter som ändras mellan iOS-versioner.

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

// Hämta alla tillgängliga stilar
let matchingDescriptors = searchDescriptor
    .matchingFontDescriptors(withMandatoryKeys: nil)

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

Mandatory keys — parameter som begränsar sökningen. Om [.family] anges returnerar matchning alla typsnitt i den angivna familjen. Om [.family, .traits] anges — endast de som matchar både familj och stil. Användning av mandatory keys snabbar upp matchning vid sökning efter en delmängd av typsnitt.

Prestanda: matchning är en synkron operation som tar 0,5 till 5 ms på iOS. För en enskild sökning är detta omärkbart, men vid massiv genomgång av beskrivare (till exempel i en picker med 50+ typsnitt) rekommenderas cachning av resultat. Apple rekommenderar att utföra matchning en gång vid skärmladdning och spara arrayen av beskrivare.

Integration med Core Text och CTFontDescriptor

Core Text — ett lågnivå C-baserat ramverk för att arbeta med typografi på iOS och macOS. Dess motsvarighet till UIFontDescriptor — CTFontDescriptor, som ger samma möjligheter på Core Foundation-nivå. CTFontDescriptor används i Core Text API för att skapa typsnitt, mäta text och rendera komplex typografi. UIFontDescriptor är i huvudsak ett Objective-C-omslag runt CTFontDescriptor med en utökad uppsättning attribut.

Toll-free bridging mellan UIFontDescriptor och CTFontDescriptor gör det möjligt att överföra beskrivare mellan UIKit och Core Text utan konvertering. Detta är avgörande för applikationer som använder anpassad textrendering — till exempel textredigerare baserade på TextKit eller kodredigerare med syntaxmarkering. Exempel: CTFontDescriptorCreateCopyWithAttribute skapar en kopia av beskrivaren med ett tillagt attribut — motsvarigheten till addingAttributes från UIFontDescriptor.

Nyckelattribut kCTFontURLAttribute i CTFontDescriptor innehåller URL:en till typsnittsfilen. Detta gör det möjligt att avgöra om typsnittet är system- eller anpassat. För anpassade typsnitt leder URL:en till typsnittsfilen (.ttf eller .otf), för systemtypsnitt — till systemets typsnittskatalog. Data via beskrivaren är skrivskyddade; ändring av typsnittsfilen via URL stöds inte.

För avancerad typografi — anpassade ligaturer, kontextuella ersättningar, alternativa glyfer — används CTFontDescriptorCopyAttribute med nyckeln kCTFontFeatureSettingsAttribute. Detta attribut innehåller en array av ordböcker med OpenType-funktioner som kan läggas till via beskrivaren. Enligt Apple Core Text Programming Guide ger kombinationen av UIFontDescriptor med Core Text fullständig kontroll över applikationens typografi.