UIFont / CTFont — vad är det, typer av teckensnitt och Core Text

Vad är UIFont och CTFont?

UIFont — är en UIKit-klass som representerar ett teckensnitt för att visa text i UI-komponenter: UILabel, UITextView, UITextField. Den ger ett enkelt gränssnitt för att hämta system- och anpassade teckensnitt med angivelse av storlek, vikt och stil. UIFont tillåter inte direkt hantering av kerning, ligaturer och OpenType-funktioner — för detta används Core Text.

CTFont — är en Core Text-typ (CTFontRef) som ger lågnivååtkomst till teckensnittsdata. CTFont arbetar direkt med Core Graphics för rendering, stödjer alla OpenType- och TrueType-funktioner, inklusive alternativa glyfer, ligaturer och variabla teckensnitt. CTFont används internt av UIKit för rendering av UIFont, men är också direkt tillgängligt för anpassad ritning.

Toll-Free Bridging

UIFont och CTFont stödjer toll-free bridging — konvertering mellan typer utan extra kostnad. Castning av UIFont as CTFont eller CTFont as UIFont är möjligt i Swift och Objective-C. Detta gör det möjligt att använda högnivå UIKit-API för konfiguration och lågnivå Core Text för rendering utan att kopiera teckensnittsdata.

Teckensnittsbeskrivning (Font Descriptor)

Båda klasserna använder UIFontDescriptor (UIKit) / CTFontDescriptor (Core Text) för att beskriva teckensnittsegenskaper: namn, storlek, vikt, stil, transformationsmatris. En descriptor är en ordbok med attribut som kan modifieras för att skapa nya teckensnitt baserat på befintliga. Till exempel, lägg till traitItalic i en descriptor för att få den kursiva versionen av samma teckensnitt.

UIFont — UIKit-teckensnitt

UIFont erbjuder flera fabriksmetoder för att skapa teckensnitt. systemFont(ofSize:) returnerar systemteckensnittet San Francisco (iOS) eller Helvetica (äldre versioner). boldSystemFont, italicSystemFont — varianter med stil. preferredFont(forTextStyle:) returnerar ett Dynamic Type-teckensnitt för den angivna stilen: .headline, .body, .caption1, .footnote. Dessa teckensnitt skalas automatiskt när textstorleksinställningarna ändras i systemet.

För att ladda anpassade teckensnitt används UIFont(name:size:) med teckensnittets PostScript-namn. Teckensnittet måste tidigare ha lagts till i Info.plist och ingå i applikationens bundle. Enligt Apple rekommenderas att använda UIFont för alla standard UI-komponenter och bara byta till CTFont när anpassad rendering behövs.

Dynamic Type

Dynamic Type — adaptivt teckensnittssystem introducerat i iOS 7. Användaren väljer önskad textstorlek i Inställningar — från mycket liten till mycket stor. UIFont.preferredFont returnerar automatiskt ett teckensnitt med lämplig storlek. För korrekt funktion måste alla UILabel ha adjustsFontForContentSizeCategory = true. Dynamic Type är obligatoriskt för tillgänglighetskompatibilitet.

UIFontDescriptor

UIFontDescriptor gör det möjligt att ändra teckensnittsattribut utan att skapa en ny instans från grunden. Metoderna addingAttributes(_:), withSymbolicTraits(_:), withFamily(_:) returnerar en ny descriptor med ändrade parametrar. Detta är praktiskt för att få teckensnittsvarianter: lägg till traitBold till ett systemteckensnitt för att få den fetstilade versionen utan att känna till PostScript-namnet.

CTFont — Core Text-teckensnitt

CTFont (CTFontRef) — är en Core Text-typ för lågnivåarbete med teckensnitt. Den skapas med funktionerna CTFontCreateWithName, CTFontCreateWithFontDescriptor, CTFontCreateCopyWithAttributes. Varje funktion returnerar ett teckensnitt med angivet gränssnitt, storlek och valfria attribut. CTFont används i Core Graphics för rendering av text på anpassade UIView via drawRect.

CTFont ger åtkomst till metriker som inte är tillgängliga i UIFont: CTFontGetGlyphsForCharacters returnerar en array av glyfer för angivna tecken, CTFontGetAdvancesForGlyphs — bredden på varje glyf, CTFontGetBoundingBox — en glyfs gränser. Detta är nödvändigt för att bygga anpassade textlayouter: kolumner, rotation, textflöde.

Teckensnittsmetriker

CTFontGetAscent, CTFontGetDescent, CTFontGetLeading returnerar vertikala metriker för teckensnittet. CTFontGetUnitsPerEm — antal enheter per em-square, används för att beräkna proportioner. CTFontGetGlyphCount — totalt antal glyfer i teckensnittet. Dessa data är kritiska för trycktypografi och anpassad sättning där exakt placering av varje tecken krävs.

OpenType och variabla teckensnitt

CTFont stödjer OpenType-funktioner: CTFontCopyFeatures returnerar en ordbok över tillgängliga teckensnittsfunktioner (ligaturer, alternativa tecken, kerning), CTFontEnableFeature aktiverar ett specifikt alternativ. Variabla teckensnitt (Variable Fonts) konfigureras via CTFontCopyVariation och CTFontCreateCopyWithVariation, vilket gör det möjligt att ändra weight, width och slant i ett kontinuerligt intervall.

Hur man använder UIFont i kod

Att skapa UIFont i Swift görs via en av fabriksmetoderna eller direkt initiering efter namn. Den vanligaste metoden är systemFont(ofSize:weight:) för systemteckensnitt eller preferredFont(forTextStyle:) för Dynamic Type. För anpassade teckensnitt används UIFont(name:size:) med angivande av PostScript-namnet.

Systemteckensnitt med olika vikter

UIFont.systemFont(ofSize:weight:) accepterar UIFont.Weight — från .ultraLight till .black. Denna metod returnerar systemteckensnittet San Francisco med motsvarande vikt. UIFont.monospacedSystemFont, UIFont.monospacedDigitSystemFont returnerar monospace-teckensnitt för kod och siffror. Alla systemteckensnitt stödjer automatiskt 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

Varje teckensnitt kan direkt tilldelas UILabel-egenskapen font eller användas i NSAttributedString via NSFontAttributeName. Systemteckensnitt cachas av iOS, så att återskapa ett systemteckensnitt medför ingen extra kostnad.

Anpassat teckensnitt från Bundle

För att använda ett anpassat teckensnitt, lägg till TTF- eller OTF-filen i projektets bundle och ange den i Info.plist (UIAppFonts). Teckensnittets PostScript-namn kan hittas via UIFont.familyNames och UIFont.fontNames(forFamilyName:). Efter registrering är teckensnittet tillgängligt via UIFont(name:size:) på valfri plats i applikationen.

// Hämta alla teckensnittsfamiljnamn
for family in UIFont.familyNames {
    let names = UIFont.fontNames(forFamilyName: family)
    print("\(familj): \(namn)")
}
// Ladda anpassat teckensnitt
if let customFont = UIFont(name: "MyCustomFont-Regular", size: 18) {
    label.font = customFont
}

Om teckensnittsnamnet är felaktigt returnerar UIFont(name:size:) nil. Det rekommenderas att i förväg skriva ut alla tillgängliga namn på teckensnitt via UIFont.familyNames och UIFont.fontNames(forFamilyName:) under felsökning för att säkerställa att teckensnittet är korrekt registrerat.

Anpassade teckensnitt med UIFont och CTFont

Inläsning av anpassade teckensnitt är möjligt på två sätt: statisk registrering via Info.plist (UIAppFonts) och dynamisk registrering via CTFontManagerRegisterGraphicsFont. Första sättet är enklare — teckensnittet är tillgängligt direkt efter att applikationen startat. Det andra används för teckensnitt som laddas från nätverket eller laddas ner på begäran.

Dynamisk registrering är användbar för resurser på begäran: om applikationen innehåller 20+ teckensnitt behöver inte alla ingå i den initiala bunten, utan kan laddas ner vid första användningen. CTFontManagerRegisterFontsForURLs registrerar teckensnitt från angivna URL:er. Efter registrering blir teckensnittet tillgängligt via UIFont(name:size:) som vanligt.

CTFontCreateWithName för anpassat teckensnitt

För anpassad rendering via Core Text, använd CTFontCreateWithName med teckensnittets PostScript-namn. Skillnaden mot UIFont är att CTFont kan skapas med en transformationsmatris (CTFontCreateWithNameAndOptions) — för att skapa distorderade teckensnitt: lutning, skalning på X-axeln, rotation. Detta är inte tillgängligt i UIFont utan att använda affina transformationer.

// Skapa CTFont med snedställningsmatris
var matrix = CGAffineTransform(a: 1, b: 0, c: 0.2, d: 1, tx: 0, ty: 0)
let ctFont = CTFontCreateWithName(
    "Helvetica" as CFString,
    24, &matrix)
// Använd toll-free bridging med UIFont
let uiFont = ctFont as UIFont
label.font = uiFont

Transformationsmatrisen gör det möjligt att skapa italic-varianter utan en separat teckensnittsfil. Parametern c (skew) lägger till lutning på tecknen. Matrisen möjliggör också horisontell skalning av teckensnittet — att skapa komprimerade eller utvidgade varianter av samma teckensnitt.

Skillnader mellan UIFont och CTFont

Huvudskillnaden mellan UIFont och CTFont är abstraktionsnivån. UIFont ger ett enkelt API för vanliga uppgifter: hämta systemteckensnitt, ändra storlek, applicera på UILabel. CTFont ger full kontroll över teckensnittet: åtkomst till glyfer, metriker, OpenType-tabeller och variabla axlar. Valet beror på uppgiften.

För 95% av iOS-utvecklingsuppgifterna räcker UIFont. Core Text med CTFont är motiverat vid skapande av textredigerare, PDF-generatorer, böcker med typografisk sättning eller applikationer med anpassad visning av sällsynta språk.

Prestanda och bästa praxis

Att arbeta med teckensnitt i iOS kräver hänsyn till prestanda. Varje unikt teckensnitt laddas in i minnet vid första användningen och upptar resurser. Systemteckensnitten San Francisco är förladdade och skapar ingen extra kostnad. Anpassade teckensnitt laddas från fil och cachas av systemet efter första inläsningen.

Det rekommenderas att begränsa antalet unika teckensnitt i applikationen till 3–5 familjer. Varje teckensnitt upptar från 50 KB till 2 MB i minnet. Att använda olika vikter av samma familj (regular, bold, medium) är effektivare än att ladda flera olika familjer.

Cachning av UIFont

Systemet cachar skapade instanser av UIFont, så upprepade anrop av UIFont.systemFont(ofSize: 16, weight: .regular) skapar inte ett nytt objekt. Dock cachas UIFont(name:size:) för anpassade teckensnitt inte alltid — det rekommenderas att spara ofta använda teckensnitt i statiska egenskaper eller en NSCache-cache för att undvika omladdning från fil.

Asynkron inläsning av teckensnitt

Vid dynamisk registrering av teckensnitt via CTFontManagerRegisterGraphicsFont kan processen vara asynkron om teckensnittsfilen laddas ner från nätverket. I detta fall bör UILabel eller UITextView visa ett reservsystemteckensnitt tills inläsningen är klar. Efter registrering blir teckensnittet tillgängligt och skärmen uppdaterar automatiskt textvisningen.