Un equipo de diseño pide Inter en peso 620 y anchura 87,5 para las cabeceras de un informe, el generador de informes incrusta el archivo de fuente, y el PDF se abre con las cabeceras en Regular plano. Busca el 620 en el archivo y no lo encontrarás en ningún sitio. Es lo esperado: un diccionario de fuentes PDF (ISO 32000-1 §9.6 y §9.8) describe un programa de glifos fijo con anchuras fijas, y no existe ninguna entrada donde puedan vivir coordenadas de eje, así que un lector que recibe una fuente variable dibuja los contornos almacenados en el archivo, que son los de la instancia predeterminada. Para que el peso 620 llegue al papel, las coordenadas tienen que quedar fijadas en los contornos antes de que la fuente llegue al PDF
Fijar el valor es más que escribir un número en una cabecera. Significa producir una nueva fuente estática autosuficiente cuyos contornos, avances, cajas delimitadoras y tablas de composición coinciden con la posición elegida en el espacio de diseño, y luego incrustar esa fuente en lugar de la original
Lo que una instancia estática tiene que reconstruir
HotPDF construye esa instancia estática durante el registro de la fuente, y en una fuente variable de tipo TrueType el trabajo alcanza casi todas las tablas del archivo. Una fuente variable OpenType almacena un contorno predeterminado por glifo más deltas en la tabla gvar, cada conjunto de deltas atado a una región del espacio de diseño. Para cada glifo, la biblioteca calcula con qué intensidad se aplica cada región en tus coordenadas, acumula los deltas ponderados en coma flotante entre todas las tuplas y redondea cada punto una sola vez al final. Redondear por tupla dejaría que los errores se acumulen en los glifos que caen en muchas regiones solapadas
Después se regenera todo lo derivado de los puntos movidos. La tabla glyf se reescribe y loca se emite en formato de offsets largos; hmtx (y vmtx cuando existe) recibe una entrada completa por glifo; la caja delimitadora global de head y los campos resumen de hhea y vhea — avance máximo, side bearings mínimos, extensión máxima — se recalculan a partir de las métricas finales; y los checksums sfnt se reconstruyen. Los valores de toda la fuente también se actualizan: los deltas de cvar van a la tabla cvt, MVAR ajusta el ascendente, el descendente y otras métricas parecidas, y los datos de variación en GDEF, GPOS y las variaciones de características de GSUB se resuelven en la posición elegida
Incluso los metadatos descriptivos se mueven. El usWeightClass de OS/2 toma el valor de wght, así que el peso 620 queda registrado como 620; usWidthClass se deduce del porcentaje de wdth, y 87,5 cae justo en la clase 4, semicondensada; un eje slnt escribe su ángulo en post.italicAngle. Al final salen las tablas de variación: fvar, avar, gvar, HVAR, VVAR, MVAR, STAT y cvar, más DSIG, cuya firma cubría bytes que ya no existen. Una fuente que conservara fvar después de mover sus contornos invitaría a cualquier consumidor consciente de las variaciones a aplicar los mismos deltas una segunda vez
Las fuentes variables de tipo CFF2 siguen otro camino. Sus charstrings llevan operadores blend que un programa de fuente estático no puede expresar, así que HotPDF convierte una fuente CFF2 en una instancia estática cada vez que se registra, aunque todos los ejes estén en sus valores predeterminados. Esa conversión y su incrustación como CFF con clave CID están tratadas en la incrustación de fuentes variables CFF2
Puntos fantasma y la trampa del doble recuento
La regla más sutil tiene que ver con las métricas, y la especificación OpenType facilita equivocarse con ella. En gvar, el recuento de puntos de un glifo son sus puntos de contorno (o sus componentes, en un glifo compuesto) más cuatro puntos fantasma que codifican el side bearing izquierdo, el ancho de avance y sus equivalentes verticales. Esos puntos fantasma reciben deltas como cualquier otro punto
Una fuente que tiene gvar muy a menudo trae también HVAR, porque HVAR permite a un renderer hallar los avances sin decodificar contornos. Aplícalas ambas y cada avance se mueve dos veces; el texto justificado se va desplazando a la derecha un poco más con cada glifo. Cuando hay gvar, HotPDF deduce las métricas horizontales y verticales de los puntos fantasma interpolados e ignora HVAR y VVAR. Solo una fuente sin gvar ve su almacén de variación de métricas fijado directamente en hmtx y vmtx. Esa precedencia es la más segura: gvar es la única tabla que mueve contornos y métricas en la misma operación, así que su respuesta nunca puede contradecir al glifo que describe
Dos reglas más mantienen la geometría fiel. Los puntos no listados en un conjunto de deltas disperso se infieren por contorno con IUP (interpolate untouched points), y los puntos fantasma nunca participan en esa interpolación. En los glifos compuestos, los deltas mueven los offsets de componente solo cuando el componente se posiciona con valores XY; los componentes emparejados por puntos toman su posición de los attachment points en su lugar. Las cajas hijas se recalculan después de forma recursiva, con el anidamiento limitado a 64 niveles, de modo que un grafo de componentes malformado que se referencia a sí mismo acabe en una fuente rechazada y no en una recursión sin fin
Leer el espacio de diseño con InspectVariableFont
InspectVariableFont es la primera llamada que hay que hacer, porque te dice qué ejes existen y qué rango acepta cada uno. Devuelve False ante un archivo que falta o una fuente sin fvar; en una colección .ttc lee el primer miembro. Cada registro THPDFVariableFontAxis lleva el Tag de cuatro bytes, MinimumValue, DefaultValue, MaximumValue, Flags y un NameID. Cada instancia con nombre lleva un SubfamilyNameID, Flags, un PostScriptNameID y una entrada en Coordinates por eje, en orden de ejes
// ClampToAxis es una ayuda que añades tú; HotPDF no recorta por ti
function ClampToAxis(const Axis: THPDFVariableFontAxis; Value: Single): Single;
begin
Result := Value;
if Result < Axis.MinimumValue then Result := Axis.MinimumValue;
if Result > Axis.MaximumValue then Result := Axis.MaximumValue;
end;
procedure ListDesignSpace(Pdf: THotPDF; const FontPath: string);
var
Axes: THPDFVariableFontAxisArray;
Instances: THPDFVariableFontNamedInstanceArray;
I, J: Integer;
Coords: string;
begin
if not Pdf.InspectVariableFont(FontPath, Axes, Instances) then
begin
Writeln('static font: register it without axis selections');
Exit;
end;
for I := 0 to High(Axes) do
Writeln(Format('%s min=%.1f default=%.1f max=%.1f',
[string(Axes[I].Tag), Axes[I].MinimumValue,
Axes[I].DefaultValue, Axes[I].MaximumValue]));
for I := 0 to High(Instances) do
begin
Coords := '';
for J := 0 to High(Instances[I].Coordinates) do
Coords := Coords + Format('%s=%g ',
[string(Axes[J].Tag), Instances[I].Coordinates[J]]);
Writeln(Format('named instance %d: %s', [I, Coords]));
end;
end;
El rango importa porque HotPDF rechaza los valores fuera de rango. Seleccionar el peso 1000 en una fuente cuyo eje wght se detiene en 900 hace que el registro lance una excepción que nombra el eje, el valor pedido y el rango permitido. Recortar en silencio habría producido un PDF que no cuadra con la vista previa en pantalla, así que la comprobación vive en tu interfaz, donde los límites del deslizador pueden salir directamente de MinimumValue y MaximumValue
¿Por qué las selecciones de eje deben preceder a RegisterUnicodeTTF?
Las selecciones de eje se leen una sola vez, cuando RegisterUnicodeTTF carga el archivo de fuente, así que hay que fijarlas antes. SetVariableFontAxis toma una etiqueta de cuatro bytes de ASCII imprimible y un valor finito; cualquier otra cosa lanza la excepción al momento, y fijar de nuevo la misma etiqueta sustituye al valor anterior. GetVariableFontAxisSelections devuelve lo que está pendiente y ClearVariableFontAxes vacía la lista. Tras el registro, GetRegisteredVariableFontAxes informa del conjunto completo de coordenadas que quedó congelado en la última fuente registrada, con los ejes sin seleccionar rellenados con sus valores predeterminados
var
Pdf: THotPDF;
Frozen: THPDFVariableFontAxisValueArray;
I: Integer;
begin
Pdf := THotPDF.Create(nil);
try
Pdf.FileName := 'quarterly.pdf';
Pdf.BeginDoc;
Pdf.SetVariableFontAxis('wght', 620); // seminegrita, no es una instancia con nombre
Pdf.SetVariableFontAxis('wdth', 87.5); // semicondensada
Pdf.RegisterUnicodeTTF('C:\Fonts\Inter.ttf');
Pdf.ClearVariableFontAxes; // nada pendiente para la siguiente fuente
Frozen := Pdf.GetRegisteredVariableFontAxes;
for I := 0 to High(Frozen) do
Writeln(Format('%s = %g', [string(Frozen[I].Tag), Frozen[I].Value]));
Pdf.CurrentPage.SetFont('Inter', [], 14, DEFAULT_CHARSET);
Pdf.CurrentPage.UnicodeTextOut(60, 70, 0, 'Quarterly results');
Pdf.EndDoc;
finally
Pdf.Free;
end;
end;
La llamada a ClearVariableFontAxes justo después del registro es la línea que la gente se salta. Las selecciones siguen pendientes hasta que se limpian, así que si la siguiente llamada a RegisterUnicodeTTF carga una fuente estática, lanza una excepción porque le suministraste selecciones de eje a una fuente no variable; si carga otra familia variable sin eje wdth, lanza una excepción porque ese eje no existe. Los dos fallos aparecen lejos del código que fijó los ejes. Limpia tras cada registro y la selección queda atada a la única fuente para la que estaba pensada
Cuando cada valor resuelto coincide con el predeterminado de su eje, una fuente variable TrueType se registra tal cual, porque sus contornos almacenados ya son la instancia predeterminada. La reconstrucción descrita arriba solo se ejecuta para coordenadas no predeterminadas o para contornos CFF2
Aportar tu propio instanciador mediante OnVariableFontInstance
OnVariableFontInstance se dispara durante el registro siempre que al menos un eje esté lejos de su valor predeterminado, y recibe los bytes originales de la fuente junto con las coordenadas resueltas. Un handler puede dejar Handled en False y dejar que el instanciador incorporado siga, o ponerlo a True y devolver su propia fuente estática en InstanceFontBytes. HotPDF comprueba una fuente devuelta antes de usarla: menos de 12 bytes, o una fuente que aún contenga fvar, lanza una excepción en lugar de incrustarla
procedure TReportBuilder.VariableFontInstance(Sender: TObject;
const SourceFontBytes: TBytes;
const AxisValues: THPDFVariableFontAxisValueArray;
out InstanceFontBytes: TBytes; out Handled: Boolean);
var
I: Integer;
Coords: string;
begin
InstanceFontBytes := nil;
Handled := False; // deja que siga el instanciador incorporado
Coords := '';
for I := 0 to High(AxisValues) do
Coords := Coords + Format('%s=%g ',
[string(AxisValues[I].Tag), AxisValues[I].Value]);
// FLog es tu propio logger; deja registrado lo que contendrá este PDF
FLog.Add(Format('instancing %d-byte font at %s',
[Length(SourceFontBytes), Coords]));
end;
// cableado: Pdf.OnVariableFontInstance := VariableFontInstance;
La mayoría de las aplicaciones deberían usar el handler solo para registrar en el log, como arriba. Sustituir el instanciador tiene sentido cuando un pipeline de fuentes fuera de la aplicación ya produce instancias estáticas aprobadas y el PDF tiene que coincidir con ellas byte a byte; en cualquier otro caso, el camino incorporado mantiene métricas, tablas de composición y metadatos consistentes entre sí, y esa consistencia es el sentido último de la instanciación
Cómo interactúa la instanciación con la subdivisión y la composición tipográfica
La instanciación se ejecuta antes de la subdivisión, así que el subdivisor ve una fuente estática normal: calcula el cierre de glifos, conserva los glifos que el documento usa y suelta el resto, como se describe en el cierre de subconjuntos y los glifos compuestos. La identidad que HotPDF usa para la caché se deriva de los bytes de la instancia, así que dos conjuntos de coordenadas de la misma familia jamás comparten una entrada de caché
La composición tipográfica lee las tablas de layout instanciadas. GSUB y GPOS sobreviven a la instanciación con sus datos de variación ya resueltos, así que las ligaduras y las alternativas descritas en las alternativas estilísticas de OpenType GSUB siguen funcionando, y una fuente que use variaciones de características para cambiar un glifo por encima de cierto peso recibe el cambio que corresponde a 620. El posicionamiento es donde el código de layout se equivoca. Una instancia semicondensada tiene avances más estrechos que los predeterminados, y GetWideTextWidth mide con los avances de la fuente realmente registrada. Mide después de RegisterUnicodeTTF y los saltos de línea que calculas son los que se imprimen
La instanciación de fuentes variables ocupa el mismo pipeline que la incrustación, la subdivisión y la composición tipográfica, y el conjunto completo de funciones tipográficas para Delphi y C++Builder está listado en la página del componente PDF HotPDF para Delphi