UIFont / CTFont — qué es, tipos de fuentes y Core Text

¿Qué son UIFont y CTFont?

UIFont es una clase de UIKit que representa una fuente para mostrar texto en componentes de UI: UILabel, UITextView, UITextField. Proporciona una interfaz simple para obtener fuentes del sistema y personalizadas con tamaño, peso y estilo especificados. UIFont no permite el control directo sobre kerning, ligaduras y funciones OpenType — para eso se usa Core Text.

CTFont es un tipo de Core Text (CTFontRef) que proporciona acceso de bajo nivel a los datos de la fuente. CTFont trabaja directamente con Core Graphics para renderizar, soporta todas las funciones OpenType y TrueType, incluyendo glifos alternativos, ligaduras y fuentes variables. CTFont se usa internamente por UIKit para renderizar UIFont, pero también está disponible directamente para dibujo personalizado.

Toll-Free Bridging

UIFont y CTFont soportan toll-free bridging — conversión entre tipos sin costo adicional. El casting UIFont as CTFont o CTFont as UIFont es posible en Swift y Objective-C. Esto permite usar la API de alto nivel de UIKit para configuración y Core Text de bajo nivel para renderizado sin copiar datos de fuente.

Descriptor de fuente

Ambas clases usan UIFontDescriptor (UIKit) / CTFontDescriptor (Core Text) para describir las características de la fuente: nombre, tamaño, peso, estilo, matriz de transformación. Un descriptor es un diccionario de atributos que se puede modificar para crear nuevas fuentes basadas en existentes. Por ejemplo, agregar traitItalic a un descriptor y obtener una versión cursiva de la misma fuente.

UIFont — fuentes de UIKit

UIFont proporciona varios métodos de fábrica para crear fuentes. systemFont(ofSize:) devuelve la fuente del sistema San Francisco (iOS) o Helvetica (versiones antiguas). boldSystemFont, italicSystemFont — variantes con estilos específicos. preferredFont(forTextStyle:) devuelve una fuente Dynamic Type para el estilo dado: .headline, .body, .caption1, .footnote. Estas fuentes se escalan automáticamente cuando cambian los ajustes de tamaño de texto en el sistema.

Para cargar fuentes personalizadas, se usa UIFont(name:size:) con el nombre PostScript de la fuente. La fuente debe agregarse primero a Info.plist e incluirse en el bundle de la aplicación. Según Apple, se recomienda usar UIFont para todos los componentes de UI estándar y cambiar a CTFont solo cuando se necesite renderizado personalizado.

Dynamic Type

Dynamic Type es un sistema de fuentes adaptativo introducido en iOS 7. El usuario selecciona su tamaño de texto preferido en Ajustes — desde extra pequeño hasta extra grande. UIFont.preferredFont devuelve automáticamente una fuente del tamaño apropiado. Para un funcionamiento correcto, todos los UILabel deben tener adjustsFontForContentSizeCategory = true. Dynamic Type es obligatorio para la compatibilidad de accesibilidad.

UIFontDescriptor

UIFontDescriptor permite modificar atributos de fuente sin crear una nueva instancia desde cero. Los métodos addingAttributes(_:), withSymbolicTraits(_:), withFamily(_:) devuelven un nuevo descriptor con parámetros modificados. Esto es conveniente para obtener variantes de fuente: agregar traitBold a la fuente del sistema y obtener una versión en negrita sin conocer el nombre PostScript.

CTFont — fuentes de Core Text

CTFont (CTFontRef) es un tipo de Core Text para trabajo de bajo nivel con fuentes. Se crea con CTFontCreateWithName, CTFontCreateWithFontDescriptor, CTFontCreateCopyWithAttributes. Cada función devuelve una fuente con la interfaz, tamaño y atributos opcionales especificados. CTFont se usa en Core Graphics para renderizar texto en UIView personalizado mediante drawRect.

CTFont proporciona acceso a métricas no disponibles en UIFont: CTFontGetGlyphsForCharacters devuelve un array de glifos para caracteres dados, CTFontGetAdvancesForGlyphs — el ancho de cada glifo, CTFontGetBoundingBox — los límites del glifo. Esto es necesario para construir diseños de texto personalizados: columnas, rotación, ajuste.

Métricas de fuente

CTFontGetAscent, CTFontGetDescent, CTFontGetLeading devuelven métricas verticales de fuente. CTFontGetUnitsPerEm — número de unidades por em-cuadrado, usado para cálculo de proporciones. CTFontGetGlyphCount — número total de glifos en la fuente. Estos datos son críticos para la tipografía de impresión y diseños personalizados donde se requiere posicionamiento preciso de cada carácter.

OpenType y fuentes variables

CTFont soporta funciones OpenType: CTFontCopyFeatures devuelve un diccionario de funciones disponibles de la fuente (ligaduras, caracteres alternativos, kerning), CTFontEnableFeature activa una opción específica. Las fuentes variables se configuran mediante CTFontCopyVariation y CTFontCreateCopyWithVariation, permitiendo cambiar weight, width y slant en un rango continuo.

Cómo usar UIFont en código

La creación de UIFont en Swift se realiza a través de uno de los métodos de fábrica o inicialización directa por nombre. La forma más común es systemFont(ofSize:weight:) para fuentes del sistema o preferredFont(forTextStyle:) para Dynamic Type. Para fuentes personalizadas, se usa UIFont(name:size:) con el nombre PostScript especificado.

Fuente del sistema con diferentes pesos

UIFont.systemFont(ofSize:weight:) acepta UIFont.Weight — desde .ultraLight hasta .black. Este método devuelve la fuente del sistema San Francisco con el peso correspondiente. UIFont.monospacedSystemFont, UIFont.monospacedDigitSystemFont devuelven fuentes monoespaciadas para código y números. Todas las fuentes del sistema soportan automáticamente 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

Cada fuente se puede asignar directamente a la propiedad font de UILabel o usar en NSAttributedString mediante NSFontAttributeName. Las fuentes del sistema se almacenan en caché por iOS, por lo que recrear una fuente del sistema no genera sobrecarga.

Fuente personalizada desde Bundle

Para usar una fuente personalizada, agregue el archivo TTF u OTF al bundle del proyecto y especifíquelo en Info.plist (UIAppFonts). El nombre PostScript de la fuente se puede encontrar mediante UIFont.familyNames y UIFont.fontNames(forFamilyName:). Después del registro, la fuente está disponible mediante UIFont(name:size:) desde cualquier parte de la aplicación.

// Obtener todos los nombres de familias de fuentes
for family in UIFont.familyNames {
    let names = UIFont.fontNames(forFamilyName: family)
    print("\(family): \(names)")
}
// Cargar fuente personalizada
if let customFont = UIFont(name: "MyCustomFont-Regular", size: 18) {
    label.font = customFont
}

Si el nombre de la fuente se especifica incorrectamente, UIFont(name:size:) devuelve nil. Se recomienda imprimir todos los nombres de fuente disponibles mediante UIFont.familyNames y UIFont.fontNames(forFamilyName:) durante la depuración para asegurarse de que la fuente esté registrada correctamente.

Fuentes personalizadas con UIFont y CTFont

La carga de fuentes personalizadas es posible de dos maneras: registro estático mediante Info.plist (UIAppFonts) y registro dinámico mediante CTFontManagerRegisterGraphicsFont. El primer método es más simple — la fuente está disponible inmediatamente después del inicio de la aplicación. El segundo se usa para fuentes descargadas de la red o recursos bajo demanda.

El registro dinámico es útil para recursos bajo demanda: si la aplicación contiene más de 20 fuentes, todas pueden excluirse del bundle inicial y descargarse en el primer uso. CTFontManagerRegisterFontsForURLs registra fuentes desde URLs especificadas. Después del registro, la fuente está disponible mediante UIFont(name:size:) como de costumbre.

CTFontCreateWithName para fuente personalizada

Para renderizado personalizado mediante Core Text, use CTFontCreateWithName con el nombre PostScript de la fuente. La diferencia con UIFont es que CTFont puede crearse con una matriz de transformación (CTFontCreateWithNameAndOptions) — para crear fuentes distorsionadas: inclinación, escalado en eje X, rotación. Esto no está disponible en UIFont sin usar transformaciones afines.

// Crear CTFont con matriz de deformación
var matrix = CGAffineTransform(a: 1, b: 0, c: 0.2, d: 1, tx: 0, ty: 0)
let ctFont = CTFontCreateWithName(
    "Helvetica" as CFString,
    24, &matrix)
// Usar toll-free bridging con UIFont
let uiFont = ctFont as UIFont
label.font = uiFont

La matriz de transformación permite crear variantes cursivas sin un archivo de fuente separado. El parámetro c (skew) agrega inclinación a los caracteres. La matriz también permite escalar la fuente horizontalmente — creando variantes condensadas o expandidas de una misma fuente.

Diferencias entre UIFont y CTFont

La principal diferencia entre UIFont y CTFont es el nivel de abstracción. UIFont proporciona una API simple para tareas comunes: obtener una fuente del sistema, cambiar tamaño, aplicar a UILabel. CTFont proporciona control total sobre la fuente: acceso a glifos, métricas, tablas OpenType y ejes variables. La elección depende de la tarea.

Para el 95% de las tareas de desarrollo iOS, UIFont es suficiente. Core Text con CTFont se justifica al crear editores de texto, generadores de PDF, libros con maquetación tipográfica o aplicaciones con renderizado personalizado de idiomas raros.

Rendimiento y mejores prácticas

Trabajar con fuentes en iOS requiere considerar el rendimiento. Cada fuente única se carga en memoria en el primer acceso y consume recursos. Las fuentes del sistema San Francisco están precargadas y no generan sobrecarga. Las fuentes personalizadas se cargan desde archivo y el sistema las almacena en caché después de la primera carga.

Se recomienda limitar el número de fuentes únicas en una aplicación a 3-5 familias. Cada fuente ocupa de 50 KB a 2 MB en memoria. Usar diferentes pesos de una misma familia (regular, bold, medium) es más eficiente que cargar varias familias diferentes.

Caché de UIFont

El sistema almacena en caché las instancias creadas de UIFont, por lo que las llamadas repetidas a UIFont.systemFont(ofSize: 16, weight: .regular) no crean un nuevo objeto. Sin embargo, UIFont(name:size:) para fuentes personalizadas no siempre se almacena en caché — se recomienda guardar las fuentes usadas frecuentemente en propiedades estáticas o NSCache para evitar recargar desde archivo.

Carga asíncrona de fuentes

Al registrar fuentes dinámicamente mediante CTFontManagerRegisterGraphicsFont, el proceso puede ser asíncrono si el archivo de fuente se descarga de la red. En este caso, UILabel o UITextView deben mostrar una fuente del sistema de respaldo hasta que se complete la carga. Después del registro, la fuente está disponible y la pantalla actualiza automáticamente la visualización del texto.