Font Descriptor: conceptos clave y capacidades del descriptor de fuentes

Qué es un Font Descriptor y por qué se necesita

Font Descriptor es un objeto que describe las características de una fuente como un conjunto de pares clave-valor, en lugar de un archivo de fuente específico. En lugar de crear una fuente por su nombre, el desarrollador especifica la familia, el estilo, el tamaño y los atributos opcionales, y el sistema selecciona la mejor coincidencia. Este enfoque es crítico para la tipografía adaptable: el mismo descriptor puede funcionar en diferentes versiones de iOS donde el conjunto de fuentes disponibles varía. Según las Guías de Interfaz Humana de iOS, la coincidencia de fuentes mediante descriptores es la forma recomendada de trabajar con fuentes dinámicas.

Sin Font Descriptor, los desarrolladores tendrían que verificar la disponibilidad de cada fuente por nombre y definir manualmente las opciones de respaldo. El descriptor automatiza este proceso: contiene una matriz de compatibilidad de estilos (regular, negrita, cursiva, negrita cursiva) y, cuando no se encuentra una coincidencia exacta, devuelve la más cercana disponible. La coincidencia del sistema funciona a nivel de Core Text y está disponible tanto en iOS como en macOS a través de la API unificada NSFontDescriptor.

Los descriptores también se utilizan para fuentes personalizadas, cargadas mediante Info.plist o añadidas manualmente. Si una fuente está registrada en el sistema, su descriptor se crea exactamente igual que para una fuente del sistema. Nota multiplataforma: el concepto de descriptor también existe en Android a través de Typeface.Builder, pero la implementación en iOS mediante UIFontDescriptor proporciona muchos más atributos (más de 20 frente a 5 en Android).

Propiedades y atributos principales de Font Descriptor

UIFontDescriptor contiene atributos agrupados en un diccionario fontAttributes de tipo [UIFontDescriptor.AttributeName: Any]. Los atributos clave incluyen la familia de la fuente, el nombre, el tamaño, los rasgos, la matriz de transformación, el tamaño óptico y el estilo de texto. Según la sesión 227 de la WWDC 2019 de Apple, el uso de estilos de texto (Dynamic Type) es obligatorio para aplicaciones compatibles con accesibilidad.

El atributo traits es un diccionario que contiene características simbólicas: peso (UIFontWeightTrait), inclinación (UIFontSlantTrait), anchura (UIFontWidthTrait) y otras. Estos valores los utiliza el motor de coincidencia para seleccionar un estilo. Por ejemplo, UIFontWeightTrait con un valor de 0.0 corresponde al estilo regular, 0.3 a negrita. El sistema asigna automáticamente los valores numéricos a las variantes de fuente disponibles.

Los atributos adicionales incluyen featureSettings para funciones OpenType (ligaduras, kerning, proporciones numéricas), visibleName para mostrar al usuario, matrix para transformaciones afines de la fuente y cascadeList para listas en cascada de fuentes de respaldo. La lista completa de atributos cubre prácticamente todos los escenarios tipográficos en iOS y macOS.

Crear UIFont mediante Font Descriptor en Swift

La forma principal de trabajar con Font Descriptor en iOS es crear un descriptor y luego generar un UIFont a partir de él. Este es el enfoque preferido cuando se necesita una fuente con características específicas sin conocer el nombre exacto. El proceso consta de dos pasos: crear un UIFontDescriptor mediante un inicializador y llamar al método font(withSize:) en el descriptor.

import UIKit

// Crear descriptor de fuente para la familia
let descriptor = UIFontDescriptor.init(
    fontAttributes: [
        .family: "SF Pro",
        .traits: [
            .weight: UIFont.Weight.bold
        ]
    ]
)

// Generar UIFont a partir del descriptor
let font = descriptor.font(withSize: 17)

Este enfoque garantiza que el sistema seleccione la mejor coincidencia para el estilo negrita de SF Pro en el dispositivo actual. Ventaja clave: el código no depende de la versión de iOS: en iOS 13 se usará SF Pro; en versiones anteriores, Helvetica Neue o la fuente del sistema predeterminada.

Para crear una fuente con un tamaño dinámico, utiliza el inicializador con estilo de texto y escala. Dynamic Type ajusta automáticamente el tamaño según la configuración del usuario:

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

// Hacer la fuente en negrita
let boldDescriptor = bodyDescriptor.withSymbolicTraits([.traitBold])

// Generar UIFont conservando el tamaño dinámico
let boldBodyFont = UIFont(
    descriptor: boldDescriptor!,
    size: bodyDescriptor.pointSize
)

Importante: el método withSymbolicTraits devuelve un descriptor opcional. Si el estilo solicitado no está disponible, devuelve nil. Siempre verifica el opcional antes de usarlo.

Modificación de atributos mediante adición y sustitución

Font Descriptor admite un modelo inmutable: cada método de modificación devuelve un nuevo descriptor con el atributo modificado. Esto sigue la semántica de valor y hace que el código sea predecible: el descriptor original nunca cambia. Los principales métodos de modificación son: addingAttributes para añadir atributos, withFace para cambiar el estilo, withSize para cambiar el tamaño y withMatrix para la transformación afín.

El método addingAttributes es el más flexible. Toma un diccionario de atributos y devuelve un nuevo descriptor. Cuando las claves coinciden, los valores nuevos reemplazan a los antiguos. Esto permite combinar cambios: añadir peso, cambiar el tamaño y activar ligaduras en una sola llamada. Según la Pregunta Técnica QA1682 de Apple, addingAttributes es la forma recomendada para modificaciones masivas mediante extensión.

Caso de uso práctico: crear una fuente para texto monoespaciado en un editor de código. El desarrollador toma el descriptor monoespaciado del sistema, añade un peso reducido para líneas finas y aumenta el interletraje mediante featureSettings. Esto proporciona un código más legible sin cargar una fuente separada.

let monoDescriptor = UIFontDescriptor.monospacedDigitFontDescriptor()

// Añadir atributos personalizados
let customDescriptor = monoDescriptor.addingAttributes([
    .size: 14,
    .traits: [
        .weight: UIFont.Weight.medium
    ]
])

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

Limitación: no todos los atributos se pueden cambiar después de crear el descriptor. Por ejemplo, la familia de la fuente se establece una vez durante la inicialización. Si necesitas cambiar la familia, crea un nuevo descriptor. Esto está relacionado con la arquitectura de Core Text, donde el descriptor está vinculado a un recurso de fuente específico.

Coincidencia de fuentes y búsqueda de fuentes del sistema

La coincidencia de fuentes es una característica clave de Font Descriptor que selecciona automáticamente la mejor coincidencia para los atributos solicitados entre las fuentes instaladas. El proceso incluye tres etapas: filtrado (exclusión de fuentes incompatibles), clasificación (ordenación por grado de coincidencia) y selección (devolución del mejor resultado). La coincidencia se realiza a nivel de Core Text, el framework subyacente de toda la tipografía de iOS.

Para encontrar todas las fuentes que coinciden con un descriptor, utiliza el método matchingFontDescriptors. Devuelve un array de descriptores ordenados por relevancia. El desarrollador puede seleccionar la coincidencia exacta (primer elemento) o iterar entre las opciones para una lógica personalizada. Según la Guía de Manejo de Fuentes de Apple, esta es la única forma de obtener una lista de estilos disponibles para una familia específica sin tener que enumerarlos por nombre.

Caso de uso: al seleccionar una fuente en una interfaz de configuración de texto. El usuario elige una familia y la aplicación utiliza matchingFontDescriptors para obtener todos los estilos disponibles y mostrarlos en un selector. Sin la coincidencia, los desarrolladores tendrían que codificar una lista de opciones que cambia entre versiones de iOS.

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

// Obtener todos los estilos disponibles
let matchingDescriptors = searchDescriptor
    .matchingFontDescriptors(withMandatoryKeys: nil)

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

Claves obligatorias: un parámetro que restringe la búsqueda. Si especificas [.family], la coincidencia devuelve todas las fuentes de la familia especificada. Si especificas [.family, .traits], solo aquellas que coinciden tanto en familia como en estilo. El uso de claves obligatorias acelera la coincidencia al buscar un subconjunto de fuentes.

Rendimiento: la coincidencia es una operación síncrona que toma de 0.5 a 5 ms en iOS. Para una búsqueda única, esto es insignificante, pero para la iteración masiva sobre descriptores (por ejemplo, en un selector con más de 50 fuentes), se recomienda almacenar en caché los resultados. Apple recomienda realizar la coincidencia una vez al cargar la pantalla y guardar el array de descriptores.

Integración con Core Text y CTFontDescriptor

Core Text es un framework de bajo nivel basado en C para trabajar con tipografía en iOS y macOS. Su contraparte de UIFontDescriptor es CTFontDescriptor, que proporciona las mismas capacidades a nivel de Core Foundation. CTFontDescriptor se utiliza en las API de Core Text para crear fuentes, medir texto y renderizar tipografía compleja. UIFontDescriptor es esencialmente un envoltorio de Objective-C alrededor de CTFontDescriptor con un conjunto extendido de atributos.

El puente toll-free entre UIFontDescriptor y CTFontDescriptor permite pasar descriptores entre UIKit y Core Text sin conversión. Esto es crítico para aplicaciones que utilizan renderizado de texto personalizado, como editores de texto basados en TextKit o editores de código con resaltado de sintaxis. Ejemplo: CTFontDescriptorCreateCopyWithAttribute crea una copia del descriptor con un atributo añadido, un análogo de addingAttributes de UIFontDescriptor.

El atributo clave kCTFontURLAttribute en CTFontDescriptor contiene la URL del archivo de la fuente. Esto permite determinar si una fuente es del sistema o personalizada. Para fuentes personalizadas, la URL apunta al archivo de la fuente (.ttf o .otf); para fuentes del sistema, apunta al directorio de fuentes del sistema. Los datos a través del descriptor son de solo lectura; no se admite la modificación del archivo de fuente mediante URL.

Para tipografía avanzada (ligaduras personalizadas, sustituciones contextuales, glifos alternativos), utiliza CTFontDescriptorCopyAttribute con la clave kCTFontFeatureSettingsAttribute. Este atributo contiene un array de diccionarios de funciones OpenType que se pueden añadir a través del descriptor. Según la Guía de Programación de Core Text de Apple, combinar UIFontDescriptor con Core Text proporciona control total sobre la tipografía de la aplicación.