Capítulo 2.1 · Parte I · Fundamentos
Arquitectura: el pipeline de composición
La pasada de colocación y sus rondas: cómo coloca el motor las líneas, los flotantes, las notas y las columnas, y cómo repite la pasada hasta que la maquetación se estabiliza.
En pocas palabras
Esta página es para programadores que quieren saber cómo coloca Postext cada cosa en la página. Postext recorre el texto de principio a fin y pone en su sitio cada línea, imagen, tabla, nota y recuadro. Si un paso posterior cambia algo anterior, como el número de página de una referencia, vuelve a empezar la pasada. Se detiene cuando ya nada se mueve. La página enumera cada paso, lo que decide y cuántas veces puede repetirse.
#Pipeline de composición
Una sola pasada de colocación, que se repite tantas veces como haga falta. Eso es todo el pipeline de composición.
La pasada (placeDocumentPass, en packages/postext/src/pipeline/build/pass.ts) recorre el contenido del primer bloque al último. Con cada bloque hace todo lo necesario para componerlo: lo mide al ancho de la columna en la que va a entrar, comprueba si cabe, lo parte o lo pasa a la columna siguiente según las reglas de corte y de cohesión, ofrece un hueco a los flotantes que cita y devuelve el flujo a la rejilla base (véase Sistema de ritmo vertical). Los flotantes, las viudas y la rejilla no tienen una pasada propia: se resuelven a medida que se coloca cada bloque.
Algunas decisiones no se pueden tomar dentro de un solo recorrido, porque dependen de dónde termine: los números de página que imprime un índice, la altura a la que un recuadro a ancho de página (el que ocupa todo el ancho de la página) corta las columnas de encima, las líneas que aún le faltan a una columna corta. Para esas decisiones, buildDocument repite la pasada con indicaciones obtenidas del resultado de la anterior. Las cinco etapas siguientes acompañan a un bloque a lo largo de la pasada; El controlador de pasadas y Equilibrado de columnas explican las repeticiones.
#Etapa 1: estructuración del contenido
- Entrada:
PostextContentsin procesar - Acción: Analizar el Markdown y convertirlo en bloques de contenido, resolver por id las referencias a recursos en
resources[], sacar del flujo las definiciones de las notas al pie ([^id]:) y numerar sus llamadas por orden de cita, dar una nota a los enlaces externos cuandolinks.printes'notes'(o su dirección entre paréntesis con'inline'), numerar los encabezados y planificar los flotantes: qué recursos flotan y detrás de qué bloque (notes[]no se lee) - Salida: Una lista plana de bloques de contenido (con su tipo y su contenido, pero sin página ni columna asignadas) y el plan de los flotantes
- Se ejecuta: al principio de cada pasada de colocación. A partir de la segunda pasada, el análisis se toma de su memoria; lo demás se vuelve a calcular
#Etapa 2: medición del texto
- Entrada: Un bloque de contenido con texto y el ancho de la columna en la que va a entrar
- Acción: Medir las líneas del bloque a ese ancho mediante el módulo de medida (
packages/postext/src/measure/), que añade sobre Pretext la separación silábica, la justificación, los tramos con formato en línea y el corte de líneas de Knuth-Plass. El resultado son lasVDTLine[]del bloque y su altura total - Detalle clave: Las mediciones se guardan en caché.
cachedMeasureBlock/cachedMeasureRichBlock(enmeasure/cache.ts) usan como clave el texto, las fuentes, el ancho y todas las opciones que afectan a la maquetación, así que volver a medir un párrafo que no ha cambiado se reduce a consultar un mapa - Salida: Las líneas del bloque, con dimensiones precisas en píxeles
- Se ejecuta: cuando el recorrido llega al bloque, no antes, porque el ancho depende de dónde caiga: una columna junto a una columna lateral, las líneas que rodean una figura, las subcolumnas de un grupo
:::columns. Un bloque que pasa a una columna de otro ancho se vuelve a medir a ese ancho
El módulo reparte claramente las responsabilidades: plain.ts mide los tramos sin formato; rich.ts, los tramos que mezclan negrita, cursiva y fórmulas; font.ts construye las cadenas de fuente y gestiona el ciclo de vida de las cachés, y canvas.ts envuelve las primitivas básicas del canvas para medir el ancho del texto. Hay un detalle del ciclo de vida que importa en la práctica: los anchos de glifo medidos con una fuente de reserva no deben seguir usándose cuando llega la fuente real. canvas.ts guarda sus anchos por cadena de fuente, junto con una generación de medida; evictFontFamilies (al que llaman watchFonts, prepareFonts y loadBundleFonts cuando una compilación detecta que han cambiado los estilos de una familia) descarta los anchos de esas familias y vacía la caché de Pretext. Una MeasurementCache llenada en una generación anterior descarta entonces sus bloques de esas familias en su siguiente consulta. clearMeasurementCache() hace lo mismo con todas las familias. Los propios estilos se cargan antes de maquetar, en fonts/prepare.ts (prepareFonts), y fonts/faces.ts recupera los que ha usado un documento ya maquetado, para los avisos fontFallback.
Los párrafos en chino, japonés y coreano siguen otro camino dentro del mismo módulo. Un párrafo con más caracteres CJK que espacios entre palabras pasa al compositor CJK (cjkCompose.ts). Este divide el texto en unidades (un carácter, un tramo de texto latino, una raya o unos puntos suspensivos de dos cuadratines, una caja indivisible como un chip o una llamada de nota), mide cada unidad una sola vez y llena las líneas por orden, la primera que sirve, con las reglas de inicio y final de línea de cjkClasses.ts. Si un signo no puede abrir la línea siguiente, la línea le hace sitio cediendo parte del blanco de la puntuación (cjkPunctuation.ts) antes de pasar un carácter abajo. Después, una línea justificada reparte el espacio entre sus caracteres. El resultado son VDTLine normales cuyos segmentos contienen lo que necesitan los renderizadores para pintarlos tal como se midieron: tracking (píxeles tras cada carácter, ya incluidos en el ancho del segmento), inkOffset para un signo que cedió blanco, hangs, los espacios entre caracteres han y latinos como segmentos autospace, y las marcas, las lecturas ruby y las filas warichu de las anotaciones chinas. En un documento japonés, el mismo compositor sigue JLReq: las clases de kinsoku de los niveles japoneses se leen, en el momento del corte, en los caracteres de los extremos de cada unidad; los blancos de la puntuación se comprimen y se devuelven en el orden de JLReq; rubyJis.ts coloca los furigana (espaciado 1:2:1, desbordamiento sobre los kana, palabras jukugo), y las marcas de kanbun ensanchan la unidad de su carácter. El coste crece linealmente con la longitud del párrafo: el capítulo 1 de 紅樓夢 (6949 caracteres) se compone midiendo 1298 caracteres, una vez cada carácter distinto, mientras que medir prefijos del párrafo costaba 636 948 mediciones. Consulta Composición china.
En el fondo, aquí es donde Pretext demuestra su valor. La llamada a prepare() es la parte costosa: analiza el texto con el motor de fuentes del canvas y guarda el resultado en caché. ¿Y la llamada a layout()? Aritmética pura, prácticamente gratis. Esa división lo es todo. Una vez preparado el texto, el motor puede volver a cortarlo con un coste insignificante: a otro ancho, para un párrafo que continúa en una columna más estrecha, o con una línea más, para un párrafo que el equilibrado de columnas alarga. Se prepara una vez y se maqueta tantas veces como haga falta.
// Simplificado: cómo usa pretext el módulo de medida internamente
const prepared = prepare(paragraphText, '16px/1.5 Inter');
const { height } = layout(prepared, columnWidth, 24); // line-height de 24px
// => "Este párrafo mide 168px de alto a 320px de ancho de columna — son 7 líneas."#Etapa 3: colocación en páginas y columnas
- Entrada: Un bloque medido
- Acción: Componer el bloque en la columna en curso. Crear los nodos
VDTPageyVDTColumna medida que el flujo los necesita. Llevar la cuenta deavailableHeighten cada columna. Si un bloque no cabe, partirlo (etapa 5) o pasar a la columna o página siguiente - Estrategia: Colocación voraz: cada bloque va al primer sitio en el que cabe. Los saltos de columna y de página siguen la asignación válida más sencilla
- Salida: El bloque tiene
pageIndex,columnIndexybboxasignados
En este momento el VDT se convierte en un documento de verdad. Antes de esta etapa, un bloque es una entrada de una lista plana, sin dirección. La colocación asigna cada bloque a una página y a una columna, como quien vierte agua en una hilera de recipientes: se llena la columna 1 hasta que rebosa, se pasa a la columna 2 y, cuando la página está llena, se empieza otra.
Antes de colocar ningún bloque de contenido en una página, la pasada reserva sitio para los elementos estructurales: las cabeceras y los pies de página (que se maquetan como posiciones de diseño a partir de config.header / config.footer) y las bandas de flotantes que ya estén pendientes para la página recién abierta. Estas reservas reducen el availableHeight de cada columna, así que, cuando los bloques de contenido empiezan a entrar, el motor ya sabe exactamente cuánto sitio hay.
Bandas de columnas y columnas a ancho de página. page.columns es un array plano en orden de lectura, pero una página no siempre es una sola fila de columnas. En una maquetación de varias columnas, un bloque en línea a ancho de página corta la página en bandas apiladas. Hay cuatro elementos que cuentan como tales: un :::callout cuyo estilo o cuya línea de apertura fija span: 'page', un grupo :::columns{span="page"} en el texto corrido, un ::resource en línea cuya colocación se resuelve en { position: 'here', span: 'page' } y una tira de cómic compuesta a lo ancho de la página en el punto donde está escrita (:::strip{span=page}). Los tres últimos se envuelven, antes de colocarlos, en un recuadro a ancho de página sin marco (pipeline/columns/flowColumns.ts, pipeline/floats/spanEmbeds.ts), de modo que un único mecanismo compone los cuatro. En el corte ocurren tres cosas: las columnas de texto de la banda en curso se cierran en la línea de corte (su altura se limita y availableHeight queda a cero); el bloque recibe su propia columna a todo el ancho, con kind: 'span', y debajo se añade una banda nueva de columnas de texto (band + 1, con la misma x, el mismo ancho y el mismo pie que la banda a la que sustituye). Las columnas siempre se añaden al final, así que columnIndex sigue apuntando a page.columns[i], y los renderizadores no necesitan ningún dibujo especial: cada columna se recorta a su propio bbox (ampliado por columnClipRect con 2 pt para la tinta de los glifos, más lo que sobresalgan por los lados de la columna sus elementos de diseño superpuestos, como la pestaña de un encabezado o el distintivo de un recuadro, y lo que suba por encima de su borde superior el diseño de un encabezado; el pie sigue siendo el borde; el rectángulo es el mismo en los backends de canvas y de PDF), y el filete entre columnas se dibuja en cada banda entre las columnas de texto contiguas, empezando por debajo de la banda que ocupa un encabezado a ancho de página en la cabeza de la página (columnRuleSegments), con el filete propio de la página cuando una sección con estilo define uno (VDTPage.columnRule, que se lee con pageColumnRule). El equilibrado de columnas no tiene en cuenta las columnas a ancho de página, las columnas laterales ni las bandas de altura cero. Un bloque a ancho de página corta directamente donde la banda está a la misma altura (al principio de la página, justo después de un encabezado de apertura, de otro bloque a ancho de página o de una banda de flotantes superior). Si llega a una banda desigual, propone en su lugar un tope de banda (packages/postext/src/pipeline/columns/bandCaps.ts): las columnas de la banda que abre un bloque de contenido concreto se acortan a ceil(Σ usado / N / rejilla) líneas. Después, buildDocument repite la pasada de colocación con ese tope. Si la banda acortada se desborda, el tope crece una línea cada vez, hasta MAX_BAND_CAP_RETRIES = 3 veces, y luego se descarta, con lo que el bloque pasa al principio de la página siguiente. Con el tope en vigor, el texto llena las columnas acortadas respetando todas las reglas de colocación y termina a la misma altura en el corte, y las columnas cerradas conservan la holgura que les quede como availableHeight, para que la absorba el equilibrado. El mismo mecanismo iguala la banda de cierre de cada capítulo y del documento (headings.balancing.trailing): cuando la pasada llega a una apertura de capítulo, a un :::part, a un recuadro placement: 'fixed' que cierra el capítulo o al final del documento y las columnas de la banda en curso están desiguales, ese límite propone un tope kind: 'trailing', asociado al bloque que marca el límite. Un tope se asocia al bloque que abre su banda, y ese bloque se desplaza cada vez que una página anterior absorbe líneas de equilibrado. Por eso, los topes de cierre se resuelven después de que se haya estabilizado el equilibrado de columnas, con sus indicaciones congeladas, y una breve ronda de pulido permite luego que las palancas rellenen lo que el corte dejó corto. Los recuadros placement: 'fixed' salen del flujo. El recuadro se ancla al área de contenido, a la caja de corte o a la caja de sangrado de la página; las columnas de texto que cubre ceden esa zona (se recortan por abajo o por arriba, como con una banda de flotantes, y pasan a la página siguiente si hay conflicto), y el marco y sus hijos van a page.floats.
Páginas verticales. Con layout.writingMode: 'vertical-rl', la pasada maqueta una página horizontal girada un cuarto de vuelta en el sentido de las agujas del reloj. En esa página, el área de contenido, las columnas, los bloques, las líneas, los flotantes y las zonas de notas al pie están en coordenadas de flujo, y VDTPage.flow contiene el giro que los traslada a la hoja: un punto (x, y) del flujo cae en (ancho de página − y, x). Nada de lo que viene después necesita saberlo: los cortes, los flotantes, las reglas de cohesión y el equilibrado funcionan en el marco del flujo como en cualquier otra página, una columna del flujo es un piso en la hoja, y cada backend aplica el giro al pintar (flowToPage y pageToFlow convierten puntos en los dos sentidos). Los titulillos, los folios, las marcas de corte y el fondo siguen en coordenadas de la hoja. Las figuras y las tablas se maquetan como bloques derechos que se vuelven a girar dentro del marco, y los caracteres que van de pie se vuelven a girar uno a uno al pintar.
Páginas de cómic y páginas compuestas. Hay dos clases de página que no llena el flujo de columnas; sus columnas quedan vacías. Una página de cómic (:::page, role: 'comic') se corta en viñetas según su expresión de división, la imagen de cada viñeta se recorta a su celda y los bocadillos, cartelas y onomatopeyas se rotulan a partir del guion (comics/layoutPage.ts); el resultado es VDTPage.comic. Una página compuesta (::::page{template="…"}, role: 'composed') se compone a partir de una plantilla de pageTemplates con layoutComposedPage (pipeline/composedPages/composedLayout.ts): coloca los marcos de la plantilla, vierte en cada marco el contenido que recibe con el compositor de cajas y, cuando el contenido de un marco no cabe, sube una escalera de reajustes (el espacio libre, el grupo del marco, imágenes más pequeñas, texto más pequeño, continuación en otra página), componiendo de nuevo la página entera en cada paso. El contenido que aun así no cabe se recorta y se avisa como frameOverflow. Los marcos están en VDTPage.composed, y sus cajas y su contenido van a page.floats. El texto corrido de antes y de después de una página así fluye por las páginas que la rodean. Consulta Páginas compuestas y Cómics.
#Etapa 4: colocación de recursos
- Entrada: El plan de los flotantes de la etapa 1 y las páginas colocadas hasta ese momento
- Acción: Colocar como flotante cada recurso citado en el primer hueco libre después de su primera cita: el pie de la columna que lo cita, la cabeza o el pie de la siguiente columna vacía, o una banda de la página siguiente (
packages/postext/src/pipeline/floats/floatPlacement.tsplanifica los flotantes ypipeline/floats/floatSlots.tsenumera y mide los huecos; la pasada de colocación reserva las bandas a medida que avanza) - Se ejecuta: en cuanto se ha colocado el bloque que contiene la primera cita, dentro del mismo recorrido; el texto que se coloca después fluye junto a la banda
- Resolución de la colocación: Por recurso, el motor resuelve
resource.placement→ elresourceType.defaultPlacementde su tipo → el valor por defecto integrado{ position: 'auto', span: 'column' }
| Campo de colocación | Comportamiento |
|---|---|
position: 'auto' | El recurso ocupa el primer hueco libre después de su cita, arriba o abajo. Es el valor por defecto |
position: 'top' | Solo huecos superiores: una banda en la cabeza de la siguiente columna o página vacía, que desplaza hacia abajo el contenido de la columna |
position: 'bottom' | Solo huecos inferiores: una banda al pie de una columna o de la página, que acorta la columna de encima |
position: 'here' | No flota: el recurso se inserta en línea en su directiva ::resource, exactamente donde aparece en el flujo |
span: 'column' | La banda ocupa una sola columna (en una página recién abierta, el motor elige la columna con más sitio libre) |
span: 'page' | La banda ocupa todo el ancho de contenido, por encima de todas las columnas, e interrumpe el flujo de las columnas. Las bandas a todo el ancho se reservan primero, de modo que los flotantes de una columna se acomodan en el espacio que queda |
span: 'side' | El recurso se compone en la columna lateral de una disposición de columna y media que reserva esa columna a los flotantes (layout.), apilado junto al párrafo que lo cita por primera vez. En una página sin esa columna, se comporta como 'column' |
ResourcePlacement tiene más campos que estos dos: rotate, width, align, columns, captionSide, shrink, minScale, captionMeasure, wrap, wrapGap y citingPage. Configuración → Tipos de recurso y Formato del documento › Colocación explican para qué sirve cada uno.
- Colocación diferida: Un flotante que no cabe en ningún hueco de la página en curso espera a la siguiente página que abra el flujo y, en un límite de capítulo, se coloca en páginas que se abren antes del límite. Una imagen conserva su tamaño, salvo que
placement.shrink(olayout.floatShrink, para todo el documento) permita reducirla al sitio que tiene un hueco. Una tabla demasiado alta para una página nueva se corta entre filas y continúa en las páginas siguientes, repitiendo sus filas de cabecera (tableStyle.overflow: 'split', el valor por defecto) - Salida: Los recursos colocados en bandas de página (
page.floats), con la altura de las columnas afectadas reducida para que el texto fluya alrededor de las bandas
La colocación de recursos es la parte más interesante, porque los flotantes no solo ocupan sitio: también cambian la forma del espacio que los rodea. Una vez colocado el bloque que contiene una cita, al flotante pendiente se le ofrecen los huecos libres de la página en curso que vienen después: el pie de esa columna y, a continuación, la cabeza y el pie de la siguiente columna vacía (para un flotante a ancho de página, el pie de la página, siempre que a todas las columnas les quede sitio). Un flotante que no cabe en ninguna parte espera a la página siguiente, donde los flotantes pendientes reservan sus bandas antes de que entre el texto. Los flotantes que acaban al pie de una misma columna se colocan en su orden. Cuando llega uno más al pie, los flotantes del pie de esa columna se vuelven a disponer desde abajo, con el último en la posición más baja, de modo que la figura 1 queda encima de la figura 2 (pipeline/build/pass/floats/footStack.ts). Conservan su sitio una banda bajo un tope de banda, junto a una columna lateral, rodeada por el texto o girada, y un recuadro anclado a un tope. Las columnas se encogen para caber entre las bandas, el texto fluye sin interrupciones por las columnas más estrechas, y el lector ve la figura cerca del punto en que se menciona (aunque no justo en él). Es la práctica habitual en la composición profesional; los libros lo hacen constantemente.
Reglas de colocación. Además del tipo de colocación, los flotantes siguen unas restricciones editoriales estrictas:
- Siempre después de la cita. Un flotante se coloca en el primer hueco libre después de su primera cita en el texto, nunca antes. El lector encuentra primero la cita y luego ve el recurso. Si un flotante no cabe, se aplaza hacia delante, a un hueco o una página posterior, nunca hacia atrás.
- Orden de cita dentro de cada serie. Los flotantes pendientes se ofrecen a cada hueco por orden de primera cita, y uno que no cabe en ninguna parte retiene a los que lo siguen en su serie de numeración: la tabla 3 nunca se coloca después de la tabla 4, ni la figura 12 antes que la figura 11. Las series no se retienen entre sí: una tabla en espera deja pasar a una figura posterior. Para que una tabla larga no tenga que esperar a una página nueva, si se le ofrece la cabeza de una columna vacía, se corta a la altura de esa columna y continúa en el hueco siguiente (la columna de al lado o las bandas de la página siguiente), repitiendo sus filas de cabecera.
- Barrera de capítulo. Los flotantes nunca salen de su capítulo. En una apertura de capítulo (un nivel de encabezado con
breakBeforeospan: 'page'), en un:::part, en un estilo de recuadro confloatBarrier: truey al final del documento, todos los flotantes pendientes se colocan primero (en los huecos libres de la página y, después, en páginas que se abren antes del límite, cada una de las cuales coloca a la fuerza al menos un flotante) y solo entonces se aplica el salto de página propio del límite. Antes de abrir una de esas páginas, a una figura o una tabla que siga pendiente se le vuelven a ofrecer los huecos libres de la página en curso, sea cual sea suposition: un flotante de cabeza de página citado en la última página de un capítulo ocupa el pie de esa página, bajo las columnas equilibradas, en lugar de una página propia (los recuadros flotantes conservan su colocación). Un:::pagebreakenvía los flotantes pendientes a la página que lo sigue, después de las páginas de relleno para la paridad. - Espacio mínimo para el texto. En una página recién abierta, solo se reserva una banda si en las columnas afectadas siguen cabiendo al menos 3 líneas de texto base, con una excepción: un flotante demasiado grande puede colocarse a la fuerza en una banda que todavía es solo texto, para que una figura enorme no pueda bloquear la cola indefinidamente. Un hueco de la página en curso debe caber en la altura que le queda a la columna; allí, la regla de las 3 líneas solo se aplica junto a otra banda de flotantes.
- Margen de respiro. Un espacio igual a una línea del texto base separa cada banda del texto que tiene al lado.
- Alineación con la rejilla base. Las bandas superiores se redondean hacia arriba a un múltiplo de la rejilla base (ampliando el espacio bajo el flotante), de modo que todas las líneas desplazadas siguen cayendo en la rejilla. Los flotantes inferiores se anclan de forma que la última línea base del pie quede sobre la rejilla: el pie comparte su línea base con la última línea de texto de las columnas vecinas, y las páginas terminan a la misma altura en todas las columnas y en las páginas enfrentadas.
Numeración por tipo y por primera cita. Los recursos no se numeran en el Markdown. pipeline/resources/resourceNumbering.ts asigna a cada recurso su número la primera vez que se cita en el orden de lectura, según su ResourceType: numberingTemplate combina el contador del tipo, {n}, con los contadores de encabezado {h1}..{h6} vigentes en el punto de la cita (por ejemplo, '{h1}.{n}' → «1.7»); resetOn controla cuándo se reinicia el contador ('never' o en cualquier nivel de encabezado), y counterFormat elige números decimales, romanos o letras. Los tipos integrados Figura y Tabla proceden de defaultResourceTypes(locale), traducidos al idioma del documento. Como la numeración sigue el orden de primera cita, al insertar una figura nueva a mitad del documento se renumera automáticamente todo lo que viene después, sin tocar el texto de origen.
#Etapa 5: cortes y reglas de cohesión
Esta etapa es la que distingue un motor de maquetación de un simple volcado de texto. Aplica las reglas de calidad editorial que los tipógrafos profesionales llevan siglos aplicando a mano, y que el dibujo ingenuo de texto pasa por alto por completo.
Tres mecanismos se reparten el trabajo, y cada uno actúa allí donde está la información que necesita: una penalización por línea corta dentro del algoritmo de corte de líneas, una partición puntuada allí donde un párrafo llega al final de una columna y unas reglas estructurales de cohesión entre bloques.
Viudas, huérfanas y líneas cortas
Las viudas y las huérfanas son los signos más visibles de una composición poco profesional:
- Una viuda es una sola línea de un párrafo que se queda aislada al pie de una columna. El párrafo continúa en la columna siguiente, pero esa línea suelta parece abandonada (como si la columna hubiera terminado antes de tiempo).
- Una huérfana es una sola línea de un párrafo que se queda aislada en la cabeza de una columna. El grueso del párrafo está en la columna anterior, pero una línea ha pasado a la siguiente (y parece desconectada de su contexto).
- Una línea corta (runt, en inglés) es la última línea de un párrafo cuando se reduce a una sola palabra corta (o dos): visualmente, demasiado corta para parecer una línea de texto de verdad. Es estructuralmente menos grave que una viuda, pero igual de molesta para un lector atento.
Las líneas cortas se resuelven en el algoritmo de corte de líneas. Una línea corta solo depende del párrafo: su última línea es igual de corta caiga donde caiga. Por eso es la única de las tres reglas que tiene en cuenta el algoritmo de Knuth-Plass. Cuando un conjunto de cortes haría terminar el párrafo en una línea cuyo contenido mide menos que runtMinCharacters × normalSpaceWidth (con el valor por defecto de runtMinCharacters, 20, un contenido tan ancho como veinte espacios entre palabras, de 8 a 12 letras más o menos), el algoritmo suma runtPenalty (1000 por defecto) a la badness de esa línea dentro de la fórmula cuadrática de deméritos; así compite en la misma escala que la badness de las líneas (que se satura en 10000), en lugar de quedar eclipsada por ella. La penalización se suma a los deméritos habituales (badness, coste de la separación silábica, salto entre clases de ajuste) en una única optimización global, y el algoritmo casi siempre encuentra un conjunto de cortes sin línea corta. Si no lo encuentra, bodyText.tightenRunts compone el párrafo con una línea menos, siempre que sus espacios entre palabras, y un poco de espaciado negativo entre letras, puedan absorber la diferencia. El módulo de medida pasa la penalización al algoritmo de corte (measure/plain.ts, measure/rich.ts), y knuthPlass/breakpoints.ts la aplica.
Las viudas y las huérfanas se resuelven al final de la columna. El algoritmo de corte de líneas corta un párrafo para un ancho dado. No sabe en qué punto de la página quedará el párrafo, así que no puede saber cuáles de sus líneas cerrarán una columna. La pasada de colocación sí lo sabe. Cuando no caben todas las líneas de un párrafo en lo que queda de columna, chooseParagraphSplit (en pipeline/blocks/orphanWidow.ts) prueba todas las particiones k de las líneas ya cortadas, desde 0 hasta el número de líneas que caben: k líneas se quedan y el resto abre la columna siguiente. Cada candidata recibe una puntuación:
slackWeight · slack²por las líneas que deja vacías al pie de la columna, siendoslacklas líneas que caben menosk(valor por defecto deslackWeight: 10);- más
widowPenalty(valor por defecto 1000) cuando deja menos dewidowMinLineslíneas al final de la columna; - más
orphanPenalty(valor por defecto 1000) cuando pasa menos deorphanMinLineslíneas al inicio de la siguiente.
Gana la partición con la puntuación más baja, y k = 0 pasa el párrafo entero. Las reglas son blandas, y los números indican hasta qué punto: una penalización de 1000 equivale al coste de holgura de diez líneas vacías (10 · 10² = 1000), así que, con los valores por defecto, una partición que cumple las dos reglas gana siempre que deje vacías menos de diez líneas de la columna. Por encima de eso, una viuda o una huérfana puede salir más barata. La partición elige entre las líneas que ya ha creado el algoritmo de corte; no vuelve a cortar el párrafo. Los elementos de lista pasan por la misma partición mediante avoidOrphansInLists y avoidWidowsInLists, y reciben la penalización por línea corta mediante avoidRuntsInLists (todos, true por defecto).
Todo esto se puede ajustar en BodyTextConfig: consulta Configuración → Huérfanas, viudas, líneas cortas y reglas de cohesión. Si pones a 0 cualquier *Penalty, esa regla queda desactivada en la práctica.
Reglas estructurales de cohesión (keep-together)
Algunos grupos son mayores que un solo párrafo: abarcan bloques contiguos y no se pueden resolver solo con el corte de líneas. La pasada de colocación los aplica a medida que coloca cada bloque, y pasa grupos enteros a la columna o página siguiente cuando, de lo contrario, quedarían partidos por un salto:
- Encabezado con su primer párrafo. Un encabezado nunca debe quedarse al pie de una columna si el párrafo que introduce va a empezar en la columna siguiente. De ello se encarga
headings.keepWithNext(truepor defecto): si no hay sitio para el encabezado más el mínimo de viudas del texto base (bodyText.widowMinLines,2por defecto) del bloque siguiente (o solo una línea, siavoidWidowsestá desactivado), el encabezado pasa a la columna siguiente para ir con su texto. - Encabezados seguidos. Cuando aparecen varios encabezados seguidos (por ejemplo, un h2, luego un h3 y luego un párrafo), todo el grupo debe permanecer junto. Ninguno de los encabezados puede quedarse suelto al pie de una columna sin el contenido que introduce.
- Listas introducidas con dos puntos. Cuando un párrafo termina con dos puntos que introducen directamente una lista, la línea de los dos puntos debe quedarse con el principio de la lista. De ello se encarga
bodyText.keepColonWithList(truepor defecto): si, al colocar el párrafo, no quedara sitio para que empiece el primer elemento de la lista (el elemento entero cuando las reglas de huérfanas y viudas de las listas lo mantienen unido; una línea conbodyText.colonListRoom: 'line', como hasta postext 1.4), la última línea, la de los dos puntos (o el párrafo entero, si solo tiene una línea), pasa a la columna siguiente junto con la lista. Si esta regla obliga a pasar el párrafo entero y justo antes hay en la columna una serie de encabezados, esos encabezados también pasan, para no incumplir sin avisokeepWithNext. La única excepción es cuando la columna solo contiene el encabezado (o los encabezados) que ya había pasado un movimiento anterior: en ese caso, el motor mantiene el párrafo junto al encabezado y acepta la separación, menos grave, entre los dos puntos y la lista, para no entrar en un bucle. - Figura con su pie. Una figura y su pie forman una unidad inseparable. Siempre se mueven juntos.
Cuando detecta que se incumple una regla de cohesión, el motor pasa todo el grupo a la columna o página siguiente. La columna que deja termina entonces corta, en tantas líneas como habría ocupado el grupo. Rellenarla es tarea del Equilibrado de columnas.
Bien hechas, estas correcciones son invisibles (un lector nunca debería notarlas). Pero su ausencia salta a la vista de cualquiera que lea con atención: esa línea incómoda al principio de una columna, esos huecos desiguales donde el motor renunció a encajar el texto. Las editoriales profesionales tienen guías de estilo enteras dedicadas a evitar justo estos problemas. Postext los resuelve automáticamente.
#El controlador de pasadas
buildDocument es un controlador que envuelve la pasada de colocación (buildDocumentGen y buildDocumentBalanced, en pipeline/build.ts). Ejecuta la pasada una vez. Después lee lo que ha comunicado la pasada y, cuando una decisión necesita revisarse, repite la pasada entera con indicaciones (PassHints): los topes, las líneas adicionales y los números que debe aplicar la pasada siguiente. Si no se da ninguna de las condiciones de la tabla siguiente, esa primera pasada es toda la compilación.
Las repeticiones se organizan en rondas, cada una dedicada a un tipo de decisión, en este orden:
| Ronda | Se ejecuta cuando | Qué se indica a la pasada siguiente | Límite |
|---|---|---|---|
| 1. Índice | El documento imprime números de página que no ha proporcionado la aplicación anfitriona: un :::toc o un :::index sin outline en el contenido, o una referencia que imprime la página de un ancla | El esquema con las páginas de la compilación anterior | MAX_TOC_ROUNDS: 3 compilaciones además de la primera |
| 2. Números de nota | footnotes.numbering es 'page', 'column' o 'spread' y las notas van al pie de la columna o de la doble página, de modo que el número de cada nota depende de dónde la coloque la maquetación | El número que recibió cada nota en la compilación anterior (footnoteNumbers) | MAX_FOOTNOTE_ROUNDS: 3 compilaciones además de la primera |
| 3. Pies laterales | Un recuadro o un flotante laterales se han superpuesto al pie que una figura colocó en la columna lateral (placement.captionSide) | Esos pies van debajo de sus figuras (captionUnder) | 3 pasadas |
| 4. Flotantes en la página de la cita | Un flotante con placement.citingPage se ha colocado en una página o columna posterior a la línea que lo cita | Esa página, o esa columna, empieza con el flotante en la cabeza (citingPageFloats) | MAX_CITING_PAGE_ROUNDS: 3 rondas de propuestas y, después, una pasada por cada tanda de flotantes que una pasada no haya podido mantener ahí |
| 5. Topes de banda | Un bloque a ancho de página ha llegado a una banda con las columnas desiguales (véase Etapa 3) | La altura a la que cortar esa banda (bandCaps) | MAX_BAND_PASSES: 4 pasadas de propuestas y reintentos. Un tope crece una línea hasta 3 veces (MAX_BAND_CAP_RETRIES) y después se descarta |
| 6. Equilibrado de columnas | headings. está activado y una columna equilibrable termina corta | Las líneas de la rejilla que se añaden a cada bloque y los párrafos que deben cortarse con una línea más (balanceExtraPx, balanceLooseness) | MAX_BALANCING_PASSES: 10 intentos por segmento. MAX_BALANCING_PASSES_PER_DOCUMENT: 30 pasadas por documento |
| 7. Bandas de cierre | El equilibrado está activado con headings., y un capítulo o el documento termina en una banda con las columnas desiguales | Un tope de cierre para esa banda, con las indicaciones del equilibrado congeladas | MAX_BAND_PASSES: 4 pasadas de propuestas y reintentos, cada tope con sus 3 reintentos |
| 8. Pulido | La ronda 7 conservó un tope de cierre | Otra vez el equilibrado de columnas, sobre la maquetación con el tope, con segmentos nuevos | 10 intentos por segmento y 30 pasadas, contados desde cero |
Las rondas 3 a 8 se ejecutan una tras otra dentro de una misma compilación (buildDocumentBalanced). Las rondas 1 y 2 quedan fuera: una ronda de índice o de números de nota es una compilación completa, con sus propias rondas 3 a 8. No hay un límite para la compilación en su conjunto; solo existen estos.
Cada repetición es una colocación completa. Una indicación no parchea el árbol de la pasada anterior: la pasada vuelve a colocar el documento con la indicación en vigor, de modo que un encabezado con dos líneas más encima, o una banda cortada seis líneas más arriba, pasa por las mismas reglas de corte y de cohesión que todo lo demás. Después, el controlador comprueba el resultado: un tope de banda cuyo recuadro no ha caído en el corte se agranda o se descarta, y una pasada de equilibrado que no ha mejorado un segmento se descarta para ese segmento. Lo que devuelve el controlador son páginas colocadas por una pasada: una pasada entera o, tras el equilibrado de columnas, las páginas de cada segmento tomadas de la mejor pasada que tuvo ese segmento.
Lo que informa el documento. doc.iterationCount cuenta las pasadas de colocación que hay detrás de la maquetación devuelta: la primera y las de las rondas de topes de banda, de equilibrado y de bandas de cierre. No incluye las pasadas de pies laterales ni las de la página de la cita, ni tampoco las compilaciones anteriores de una ronda de índice o de números de nota; BuildDocumentOptions.onPass se llama en cada pasada, con lo que ha tardado. doc.converged solo se refiere al equilibrado de columnas. Vale true cuando todos los segmentos han terminado sin ninguna línea vacía en sus columnas equilibrables o sin ninguna palanca que proponer, y false cuando un segmento se ha detenido en una pasada que no lo mejoraba, o ha agotado sus intentos, con un hueco todavía abierto. Con el equilibrado desactivado, vale true. Un documento con converged: false está completo: contiene la mejor maquetación que ha encontrado el controlador, y alguna de sus columnas termina corta.
#Equilibrado de columnas
- Se ejecuta: en las rondas 6 y 8 del controlador (activado por defecto;
headings.balancing.enabled: falselo desactiva, y está desactivado por defecto en el texto vertical y en una retícula de caracteres; véase Configuración → Equilibrado de columnas) - Entrada: La mejor maquetación obtenida hasta el momento y las líneas vacías de la rejilla al pie de cada columna equilibrable (
collectColumnGaps, enpipeline/columns/columnBalancing.ts) - Acción: Proponer palancas que rellenen cada columna corta sin sacar nada de ella, ejecutar la pasada de colocación con esas palancas y conservar el resultado para un segmento cuando su puntuación de huecos haya bajado
- Salida: Columnas que terminan en la última línea de la rejilla de la página, con cada palanca registrada en el bloque al que se aplicó (
VDTBlock.balancing)
Las columnas desiguales se notan enseguida, y las reglas de corte las producen constantemente: un encabezado que ha pasado a la columna siguiente para quedarse con su texto, un párrafo que ha pasado entero para evitar una viuda, una figura que no cabía. Una columna que termina dos líneas más arriba que la de al lado parece inacabada, como si la maquetación se hubiera rendido a medio camino.
Para arreglarlo, ningún bloque cambia de columna. Cada salto de columna está ligado al elemento que no cabía: el bloque que abre la columna siguiente era demasiado alto para el sitio que quedaba, y lo sigue siendo para un sitio menor. Así que una columna corta se puede rellenar desde dentro, como mucho hasta cubrir su hueco, sin que nada pase a la columna siguiente. El ajuste es local, que es justo lo que hace a mano un maquetista: añadir una línea de espacio allí donde el ojo la acepta. Una columna es equilibrable si el contenido ha seguido más allá de ella en una columna posterior de la misma página o, en el caso de la última columna de una página, si la página continúa en la siguiente. La última página de un capítulo puede terminar corta; su banda de cierre la iguala un tope de cierre (véase Etapa 3).
Para cada hueco, las palancas se proponen por orden de prioridad editorial, el mismo que sigue Configuración → Equilibrado de columnas:
- Un recuadro que cierra la columna toma como espacio superior el sitio que queda bajo su pie, de modo que su pie cae en la última línea de la rejilla de la página, a la altura de la última línea de la columna de al lado. Se registra como
trailingCallout. - Una imagen con zona segura (
Resource.safeArea), colocada en línea en la columna o como flotante en su cabeza o en su pie y solo sobre esa columna, crece en líneas enteras de la rejilla, recortada dentro de su zona segura. Una imagen más alta no deja ningún hueco en la página, así que esta palanca actúa antes de añadir ningún espacio. Se registra comoflexFigure. - Los encabezados toman líneas enteras de la rejilla por encima, de una en una y por turnos, empezando por el encabezado más importante (el de nivel más bajo), que así recibe la mayor parte. Un encabezado situado al principio de una columna no recibe ninguna, para que las columnas sigan empezando en la parte superior de la página. De este modo, un encabezado solo toma sus primeras líneas antes de que se prueben las palancas siguientes, y las demás, hasta su máximo, cuando esas ya no tienen nada más que dar. Se registra como
heading. - Los finales de lista toman una línea de la rejilla donde termina una lista. Se registra como
listEnd. - Bajo las fórmulas, los recuadros y los flotantes superiores se añade una línea de la rejilla: bajo una fórmula en bloque o un recuadro tras el que continúa el texto (
afterDisplay), y entre una figura o una tabla que encabeza la columna y el texto de debajo (afterFloat). - Los párrafos aflojados son el último recurso. Los párrafos de la columna, empezando por los más largos, se vuelven a cortar con una línea más cada uno (el
\looseness=+1de TeX, mediante la opciónloosenessdel algoritmo de Knuth-Plass), y esa composición más larga solo se acepta si todas las líneas se mantienen dentro debodyText.maxWordSpacing. Si el espacio entre palabras no basta para ganar la línea, el párrafo puede recibir además el menor espaciado positivo entre letras con el que se consiga, hasta un máximo. Se registra comolooseParagraph.
Los máximos, los interruptores y las excepciones (una retícula de caracteres, las páginas de cierre, un flotante sobre varias columnas) son claves de headings.balancing. La página de configuración las enumera y se mantiene al día; esta página no las repite.
Una propuesta se comprueba aplicándola. La pasada que aplica las palancas es una colocación completa, y a veces una palanca acaba moviendo contenido de una columna a otra: un párrafo partido cuya primera parte ya no cabe, un flotante que ha perdido su hueco. Las páginas que siguen a ese punto fluyen de otra manera, y se abren huecos en otros sitios. El controlador lo detecta en la puntuación, descarta la pasada para ese segmento y veta las palancas que acaba de aplicar en la primera columna que ha cambiado; así, la propuesta siguiente conserva las palancas que han funcionado y deja fuera la que ha provocado el efecto en cadena.
El equilibrado converge por segmentos. Las páginas que hay entre dos saltos explícitos (la apertura de un capítulo, un :::pagebreak) se maquetan con independencia unas de otras: nada fluye a través de un salto así, de modo que una palanca de equilibrado dentro de una serie de páginas nunca puede mover una línea de otra serie. Por eso, el bucle del equilibrado de columnas evalúa cada segmento por separado. Su puntuación de huecos es el número de líneas vacías de la rejilla al pie de sus columnas equilibrables. Cada pasada sigue colocando el documento entero, pero cada segmento conserva o rechaza su parte de las palancas según su propia puntuación, veta sus propios efectos en cadena, se estanca por su cuenta y gasta su propio presupuesto de intentos; un segmento que empeora en un reintento recupera sus páginas de la mejor pasada que tenía, mientras los demás siguen avanzando. Así, un libro de treinta capítulos se equilibra exactamente igual que si se equilibraran sus capítulos uno a uno (el PDF del libro completo y el PDF de un capítulo suelto son idénticos para ese capítulo), en lugar de que un efecto en cadena en cualquier punto le cueste una pasada a todas las páginas del libro.
Los límites son una válvula de seguridad. Algunas columnas no se pueden cerrar: una que solo contiene párrafos cortos no tiene ninguna palanca de la que tirar, y otra cuyas palancas desplazan cada una un bloque a la columna siguiente no tiene ninguna que se pueda conservar. El motor se queda con la mejor maquetación que ha encontrado y deja corta esa columna. Como las palancas quedan registradas en los bloques, una hoja de pruebas o un test puede enumerar las columnas que no ha cerrado nada (véase Configuración → Qué palanca actuó).