Font Descriptor: concetti chiave e capacità del descrittore di font

Cos'è un Font Descriptor e perché serve

Font Descriptor è un oggetto che descrive le caratteristiche di un font come un insieme di coppie chiave-valore, anziché un file di font specifico. Invece di creare un font per nome, lo sviluppatore specifica la famiglia, lo stile, la dimensione e gli attributi opzionali, e il sistema seleziona la migliore corrispondenza. Questo approccio è fondamentale per la tipografia adattiva: lo stesso descrittore può funzionare su diverse versioni di iOS dove l'insieme dei font disponibili varia. Secondo le Linee Guida per l'Interfaccia Umana di iOS, la corrispondenza dei font tramite descrittori è il modo consigliato per lavorare con i font dinamici.

Senza Font Descriptor, gli sviluppatori dovrebbero verificare la disponibilità di ogni font per nome e definire manualmente le opzioni di fallback. Il descrittore automatizza questo processo: contiene una matrice di compatibilità degli stili (normale, grassetto, corsivo, grassetto corsivo) e quando non viene trovata una corrispondenza esatta, restituisce quella disponibile più vicina. La corrispondenza di sistema funziona a livello di Core Text ed è disponibile sia su iOS che su macOS tramite l'API unificata NSFontDescriptor.

I descrittori sono utilizzati anche per font personalizzati — caricati tramite Info.plist o aggiunti manualmente. Se un font è registrato nel sistema, il suo descrittore viene creato esattamente come per un font di sistema. Nota multipiattaforma: il concetto di descrittore esiste anche in Android tramite Typeface.Builder, ma l'implementazione iOS tramite UIFontDescriptor fornisce significativamente più attributi — oltre 20 rispetto a 5 in Android.

Proprietà e attributi principali di Font Descriptor

UIFontDescriptor contiene attributi raggruppati in un dizionario fontAttributes di tipo [UIFontDescriptor.AttributeName: Any]. Gli attributi chiave includono la famiglia del font, il nome, la dimensione, i tratti, la matrice di trasformazione, la dimensione ottica e lo stile di testo. Secondo la sessione 227 della WWDC 2019 di Apple, l'uso degli stili di testo — Dynamic Type — è obbligatorio per le applicazioni compatibili con l'accessibilità.

L'attributo traits è un dizionario contenente caratteristiche simboliche: peso (UIFontWeightTrait), inclinazione (UIFontSlantTrait), larghezza (UIFontWidthTrait) e altri. Questi valori sono utilizzati dal corrisponditore di font per selezionare uno stile. Ad esempio, UIFontWeightTrait con valore 0.0 — stile normale, 0.3 — grassetto. Il sistema mappa automaticamente i valori numerici nelle varianti di font disponibili.

Gli attributi aggiuntivi includono featureSettings per le funzionalità OpenType (legature, crenatura, proporzioni numeriche), visibleName per la visualizzazione all'utente, matrix per le trasformazioni affini del font e cascadeList per gli elenchi a cascata di font di fallback. L'elenco completo degli attributi copre praticamente tutti gli scenari tipografici in iOS e macOS.

Creare UIFont tramite Font Descriptor in Swift

Il modo principale per lavorare con Font Descriptor in iOS è creare un descrittore e poi generare un UIFont da esso. Questo è l'approccio preferito quando si ha bisogno di un font con caratteristiche specifiche senza conoscere il nome esatto. Il processo consiste in due passaggi: creare un UIFontDescriptor tramite un inizializzatore e chiamare il metodo font(withSize:) sul descrittore.

import UIKit

// Creare descrittore di font per la famiglia
let descriptor = UIFontDescriptor.init(
    fontAttributes: [
        .family: "SF Pro",
        .traits: [
            .weight: UIFont.Weight.bold
        ]
    ]
)

// Generare UIFont dal descrittore
let font = descriptor.font(withSize: 17)

Questo approccio garantisce che il sistema selezioni la migliore corrispondenza per lo stile grassetto di SF Pro sul dispositivo corrente. Vantaggio chiave — il codice non dipende dalla versione di iOS: su iOS 13 verrà utilizzato SF Pro; sulle versioni precedenti, Helvetica Neue o il font di sistema predefinito.

Per creare un font con dimensione dinamica, utilizza l'inizializzatore con stile di testo e scala. Dynamic Type adatta automaticamente la dimensione alle impostazioni dell'utente:

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

// Rendere il font grassetto
let boldDescriptor = bodyDescriptor.withSymbolicTraits([.traitBold])

// Generare UIFont preservando la dimensione dinamica
let boldBodyFont = UIFont(
    descriptor: boldDescriptor!,
    size: bodyDescriptor.pointSize
)

Importante: il metodo withSymbolicTraits restituisce un descrittore opzionale — se lo stile richiesto non è disponibile, restituisce nil. Controlla sempre l'opzionale prima dell'uso.

Modifica degli attributi tramite aggiunta e sostituzione

Font Descriptor supporta un modello immutabile — ogni metodo di modifica restituisce un nuovo descrittore con l'attributo modificato. Questo segue la semantica del valore e rende il codice prevedibile: il descrittore originale non cambia mai. I principali metodi di modifica sono: addingAttributes per aggiungere attributi, withFace per cambiare lo stile, withSize per cambiare la dimensione e withMatrix per la trasformazione affine.

Il metodo addingAttributes è il più flessibile. Prende un dizionario di attributi e restituisce un nuovo descrittore. Quando le chiavi corrispondono, i nuovi valori sostituiscono i vecchi. Ciò consente di combinare modifiche: aggiungere peso, cambiare dimensione e attivare legature in una singola chiamata. Secondo la Domanda Tecnica Apple QA1682, addingAttributes è il modo consigliato per la modifica in massa tramite estensione.

Caso d'uso pratico: creare un font per testo monospaziato in un editor di codice. Lo sviluppatore prende il descrittore monospaziato di sistema, aggiunge un peso ridotto per linee sottili e aumenta la spaziatura tra lettere tramite featureSettings. Ciò fornisce codice più leggibile senza caricare un font separato.

let monoDescriptor = UIFontDescriptor.monospacedDigitFontDescriptor()

// Aggiungere attributi personalizzati
let customDescriptor = monoDescriptor.addingAttributes([
    .size: 14,
    .traits: [
        .weight: UIFont.Weight.medium
    ]
])

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

Limitazione: non tutti gli attributi possono essere modificati dopo la creazione del descrittore. Ad esempio, la famiglia del font viene impostata una volta durante l'inizializzazione. Se devi cambiare la famiglia, crea un nuovo descrittore. Ciò è legato all'architettura di Core Text, dove il descrittore è legato a una risorsa di font specifica.

Corrispondenza dei font e ricerca dei font di sistema

La corrispondenza dei font è una funzionalità chiave di Font Descriptor che seleziona automaticamente la migliore corrispondenza per gli attributi richiesti tra i font installati. Il processo include tre fasi: filtraggio (esclusione dei font incompatibili), classificazione (ordinamento per grado di corrispondenza) e selezione (restituzione del miglior risultato). La corrispondenza viene eseguita a livello di Core Text — il framework alla base di tutta la tipografia iOS.

Per trovare tutti i font corrispondenti a un descrittore, utilizza il metodo matchingFontDescriptors. Restituisce un array di descrittori ordinati per pertinenza. Lo sviluppatore può selezionare la corrispondenza esatta (primo elemento) o iterare tra le opzioni per logica personalizzata. Secondo la Guida alla Gestione dei Font di Apple, questo è l'unico modo per ottenere un elenco di stili disponibili per una famiglia specifica senza enumerarli per nome.

Caso d'uso: durante la selezione di un font in un'interfaccia di impostazioni del testo. L'utente sceglie una famiglia e l'applicazione utilizza matchingFontDescriptors per ottenere tutti gli stili disponibili e visualizzarli in un selettore. Senza corrispondenza, gli sviluppatori dovrebbero codificare un elenco di opzioni che cambia tra le versioni di iOS.

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

// Ottenere tutti gli stili disponibili
let matchingDescriptors = searchDescriptor
    .matchingFontDescriptors(withMandatoryKeys: nil)

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

Chiavi obbligatorie — un parametro che restringe la ricerca. Se specifichi [.family], la corrispondenza restituisce tutti i font della famiglia specificata. Se specifichi [.family, .traits] — solo quelli che corrispondono sia a famiglia che a stile. L'uso di chiavi obbligatorie accelera la corrispondenza durante la ricerca di un sottoinsieme di font.

Prestazioni: la corrispondenza è un'operazione sincrona che richiede da 0,5 a 5 ms su iOS. Per una singola ricerca, è trascurabile, ma per l'iterazione in massa sui descrittori (ad esempio, in un selettore con oltre 50 font), si consiglia di memorizzare nella cache i risultati. Apple consiglia di eseguire la corrispondenza una volta al caricamento dello schermo e salvare l'array di descrittori.

Integrazione con Core Text e CTFontDescriptor

Core Text è un framework di basso livello basato su C per lavorare con la tipografia su iOS e macOS. La sua controparte di UIFontDescriptor è CTFontDescriptor, che fornisce le stesse capacità a livello di Core Foundation. CTFontDescriptor viene utilizzato nelle API di Core Text per creare font, misurare testo e renderizzare tipografia complessa. UIFontDescriptor è essenzialmente un wrapper Objective-C attorno a CTFontDescriptor con un insieme esteso di attributi.

Il ponte toll-free tra UIFontDescriptor e CTFontDescriptor consente di passare descrittori tra UIKit e Core Text senza conversione. Ciò è fondamentale per le applicazioni che utilizzano rendering del testo personalizzato — ad esempio, editor di testo basati su TextKit o editor di codice con evidenziazione della sintassi. Esempio: CTFontDescriptorCreateCopyWithAttribute crea una copia del descrittore con un attributo aggiunto — un analogo di addingAttributes di UIFontDescriptor.

L'attributo chiave kCTFontURLAttribute in CTFontDescriptor contiene l'URL del file del font. Ciò consente di determinare se un font è di sistema o personalizzato. Per i font personalizzati, l'URL punta al file del font (.ttf o .otf); per i font di sistema, punta alla directory dei font di sistema. I dati tramite il descrittore sono di sola lettura; la modifica del file del font tramite URL non è supportata.

Per la tipografia avanzata — legature personalizzate, sostituzioni contestuali, glifi alternativi — utilizza CTFontDescriptorCopyAttribute con la chiave kCTFontFeatureSettingsAttribute. Questo attributo contiene un array di dizionari di funzionalità OpenType che possono essere aggiunti tramite il descrittore. Secondo la Guida alla Programmazione di Core Text di Apple, combinare UIFontDescriptor con Core Text dà il controllo completo sulla tipografia dell'applicazione.