Un trabajo de facturación abre una plantilla de cliente, escribe 42750 en B3 y guarda. Si después comparáis los paquetes descomprimidos, la lista de cambios es mucho más larga que una celda: xl/theme/theme1.xml contiene ahora la paleta de Office de serie en lugar del verde azulado y el gris pizarra del cliente, el <extLst> del final del XML de la hoja ha perdido el grupo de minigráficos y una regla de formato condicional más moderna, y xl/calcChain.xml desaparece sin más. Excel abre el resultado, ofrece una reparación, y los colores de marca se han esfumado. El código tocó una celda. Todo lo demás cambió porque el guardado reconstruyó el paquete a partir de lo que el modelo en memoria sabía, y tres partes de una plantilla típica quedan fuera de lo que un modelo de hoja de cálculo normalmente guarda
Por qué una edición de una celda reescribe el paquete XLSX entero
Un fichero .xlsx es un ZIP de partes XML: xl/workbook.xml, un xl/worksheets/sheetN.xml por hoja, xl/styles.xml, xl/sharedStrings.xml, el tema, la cadena de cálculo y los dibujos, tablas y cachés de tabla dinámica que lleve el libro. Una librería que lee valores y fórmulas en objetos y regenera cada parte desde esos objetos al guardar tiene un punto débil. Cualquier cosa para la que el modelo de objetos no tiene hueco nunca llega a memoria, así que la parte regenerada sale sin ella. Nadie tiene que borrar los minigráficos; sencillamente no tienen dónde vivir entre Open y SaveAs
ECMA-376 vio venir la mitad de esto. SpreadsheetML reserva extLst (ECMA-376 Parte 1, §18.2.10 para el elemento a nivel de libro, con elementos equivalentes en hojas, estilos y formatos condicionales) como área de almacenamiento de características futuras. Un productor más moderno envuelve cada característica en un elemento <ext> cuyo atributo uri nombra la característica, y se espera que un consumidor más antiguo transporte lo que no entiende. Los minigráficos, las listas de segmentaciones, las opciones de barras de datos y conjuntos de iconos más recientes y la validación de datos extendida viajan así en los ficheros que Excel escribe hoy. Soltar bloques <ext> desconocidos rompe por tanto el contrato de compatibilidad hacia delante sobre el que se construyó el formato, y el daño solo aparece cuando el cliente reabre el fichero en Excel
El tema y la cadena de cálculo fallan por razones distintas, así que cada uno necesita su propio tratamiento. El resto del artículo repasa cómo maneja HotXLS los tres, qué puede observar y comprobar quien llama desde Delphi, y dónde se detiene la garantía
Mantener intacto un theme1.xml personalizado en Delphi
HotXLS conserva el tema de un libro guardando los bytes originales de xl/theme/theme1.xml del paquete abierto y escribiendo esa parte tal cual en el SaveAs. La parte del tema (ECMA-376 Parte 1, §14.2.7) es DrawingML: un esquema de color con doce slots, un esquema de fuentes y un esquema de formato de rellenos, líneas y efectos. Los estilos de celda apuntan a él con <color theme="4"/> y referencias parecidas, de modo que el motor de hoja de cálculo solo necesita resolver slots, nunca entender degradados ni estilos de efecto. Regenerar un tema de Office fijo en cada guardado es exactamente lo que convierte el verde azulado del cliente en azul de Office. Un libro creado desde cero, sin tema que transportar, recibe el tema de Office integrado
El caso de todos los días no necesita nada de código de tema. Fijaos en el índice de hoja: Sheets es 1-based en el motor XLSX, y Cells[3, 2] es fila 3, columna 2, o sea B3
var
Book: TXLSXWorkbook;
begin
Book := TXLSXWorkbook.Create;
try
Book.Open('branded-invoice.xlsx');
Book.Sheets[1].Cells[3, 2].Value := 42750.00; // la única edición
Book.SaveAs('branded-invoice-out.xlsx');
// xl/theme/theme1.xml en la salida lleva el tema de la propia plantilla
finally
Book.Free;
end;
end;
Los bytes en bruto son la máxima fidelidad que podéis obtener para una parte así: sin parseo, sin reserialización, nada que derive. Cuando el guardado escribe Strict OOXML en lugar del dialecto transicional, el tema capturado pasa por el traductor de namespaces en lugar de copiarse, porque una copia byte a byte dejaría URIs de namespace transicionales dentro de un paquete Strict
La trampa está en el lado de la API. TXLSXWorkbook expone ThemeMajorFont y ThemeMinorFont, y tras el Open informan de las tipografías de encabezado y cuerpo parseadas del esquema de fuentes de la plantilla. Asignarlas parece la forma natural de cambiar fuentes, pero solo dan forma al tema de Office integrado que reciben los libros nuevos. En un libro que trajo su propio tema, la parte capturada gana y esos dos setters no cambian nada en el fichero guardado. Los colores se manejan distinto: ThemeColor[Slot] direcciona los doce slots del clrScheme, y una sobrescritura se escribe en el tema preservado sustituyendo solo el color de ese slot, dejando intactos el esquema de fuentes, el esquema de formato y cualquier extensión del tema
Book.Open('branded-invoice.xlsx');
// Sin efecto sobre el fichero guardado: se preserva el tema de la propia plantilla
Book.ThemeMajorFont := 'Segoe UI Semibold';
// Sí llega al fichero: solo cambia el slot accent1 dentro de theme1.xml
Book.ThemeColor[xlsxThemeAccent1] := $FF0F7B6C; // $AARRGGBB
Book.SaveAs('rebranded.xlsx');
Esa división es deliberada. Una sobrescritura de color es una edición estrecha y bien definida sobre un elemento, así que el resto del tema de un diseñador puede quedarse exactamente como estaba. Reescribir el esquema de fuentes tocaría listas de fuentes por escritura que una API orientada a datos no tiene una buena forma de expresar. Si una plantilla necesita una tipografía nueva, cambiadla en Excel y distribuid la plantilla nueva; eso mantiene el tema en manos de quien posee la marca
¿Qué pasa con los bloques extLst desconocidos al guardar?
HotXLS captura cada bloque <ext> a nivel de hoja que no modela de forma nativa y lo reproduce dentro del extLst de la hoja guardada. Los bloques que sí modela se parsean a objetos tipados y se reconstruyen desde ellos: los grupos de minigráficos van a SparklineGroups, la extensión de validación de datos x14 se lee en la colección de validación de datos y las listas de segmentaciones las vuelve a emitir el modelo de segmentaciones. Todo lo demás aterriza, un fragmento XML por bloque, en la lista de cadenas de solo lectura RawWorksheetExts de cada TXLSXWorksheet, lo que significa que un test puede inspeccionar exactamente qué se va a transportar hacia delante
var
Book: TXLSXWorkbook;
Sheet: TXLSXWorksheet;
i: Integer;
begin
Book := TXLSXWorkbook.Create;
try
Book.Open('from-newer-excel.xlsx');
Sheet := Book.Sheets[1];
WriteLn(Format('%d foreign ext block(s), %d sparkline group(s)',
[Sheet.RawWorksheetExts.Count, Sheet.SparklineGroups.Count]));
for i := 0 to Sheet.RawWorksheetExts.Count - 1 do
WriteLn(Copy(Sheet.RawWorksheetExts[i], 1, 100)); // la etiqueta de apertura muestra el uri
// Declaraciones de namespace que los fragmentos tomaron prestadas de la raíz <worksheet>
WriteLn(Sheet.RawExtNamespaceDecls);
finally
Book.Free;
end;
end;
La captura funciona desde el stream de eventos XML, porque un lector en streaming entrega elementos, texto y etiquetas de cierre pero ningún offset de bytes sobre el origen. Cada subárbol desconocido se reconstruye a partir de esos eventos a su paso. Un contador de profundidad ingenuo se rompe aquí: incrementa en cada etiqueta de apertura y decrementa en cada etiqueta de cierre, y un hijo de autocierre como <x14:cfvo type="min"/> llega como un único evento de apertura marcado como vacío sin etiqueta de cierre que lo siga. Contadlo como elemento abierto y el contador nunca vuelve a cero, así que la captura se traga el resto de la hoja. El bucle de captura de HotXLS solo incrementa la profundidad para una etiqueta de apertura que no esté vacía, y un <ext/> que esté vacío en sí mismo se almacena inmediatamente como fragmento de una línea
Reconstruir desde eventos tiene un efecto lateral visible. Las comillas de los atributos, el espacio en blanco entre elementos y la elección entre <a></a> y <a/> vuelven normalizados, de modo que un fragmento es equivalente en significado al original pero no idéntico byte a byte. Excel parsea el XML; no compara bytes. Una herramienta de diff que compare texto marcará el cambio, eso sí, y conviene saberlo antes de que alguien lo registre como regresión
Los namespaces son lo segundo que puede salir mal con un fragmento reproducido. Excel suele declarar los prefijos que necesita en el propio elemento <ext>, lo que hace el fragmento autosuficiente, pero un bloque también puede apoyarse en un prefijo como x14ac o xr declarado una sola vez en la raíz <worksheet> de origen. Reproducid ese fragmento en una hoja sin la declaración y el XML guardado no está bien formado en namespaces. HotXLS escanea cada fragmento capturado en busca de prefijos que use pero no declare, registra las declaraciones correspondientes del origen en RawExtNamespaceDecls y las escribe en la raíz de la hoja guardada. Como los fragmentos son cadenas planas, duplicar una hoja dentro o entre libros también puede llevarlos a la hoja nueva
Escribir calcChain.xml para que Excel confíe en vuestras fórmulas
HotXLS escribe xl/calcChain.xml (la parte Calculation Chain, ECMA-376 Parte 1, §12.3.1) siempre que el libro guardado contenga al menos una celda con fórmula, junto con su override de content-type y su relación de libro. Cada entrada es un elemento <c r="D10" i="1"/>: la referencia de celda más el índice de hoja 1-based, que el escritor emite en cada entrada aunque el esquema permite omitirlo en una racha de entradas de la misma hoja. Lo explícito es más simple e igual de válido
El orden depende de lo que el libro ya sabe. Cuando el grafo de dependencias de fórmulas existe y está al día, que es el estado justo después de Recalculate, la cadena sigue un orden topológico completo: cada fórmula después de las celdas de las que depende, con los miembros de referencias circulares añadidos al final para que la cadena siga enumerando cada celda con fórmula. Cuando el grafo está obsoleto o nunca se construyó, las celdas con fórmula se enumeran en orden de documento, hoja por hoja. Ambos son legales. Las notas de implementación de Microsoft para el formato, [MS-XLSX], describen la cadena como una pista que Excel comprueba y reordena mientras calcula, así que un listado completo en cualquier orden carga limpiamente
Book.Open('model.xlsx');
Book.Sheets[1].Cells[10, 4].Formula := '=SUM(D2:D9)';
// Guardar aquí enumera las celdas con fórmula en orden de documento, porque
// cambiar una fórmula invalidó el grafo de dependencias.
Book.Recalculate; // reconstruye el grafo y refresca los valores cacheados
Book.SaveAs('model-out.xlsx');
// calcChain.xml ahora sigue el orden de dependencias: D10 después de D2:D9
SaveAs no construye el grafo por iniciativa propia. Una construcción completa de dependencias significa resolver cada referencia en cada fórmula, lo que en un modelo grande es trabajo de verdad que quien solo quería escribir un fichero nunca pidió. Si os importan los valores cacheados de la salida, y suelen importar para cualquier cosa que un sistema posterior lee sin abrir Excel, llamad a Recalculate antes de guardar de todos modos; la cadena ordenada por dependencias viene gratis
¿Por qué emitir una parte que Excel trata como orientativa? Porque su ausencia destaca. Las heurísticas de reparación, los visores de terceros y las herramientas de diff esperan todos que un libro con fórmulas lleve una cadena de cálculo, y un paquete sin ella no se parece a nada que el propio Excel produzca. Escribir una cadena válida mantiene la salida dentro de la forma contra la que se ha ejercitado el resto del ecosistema, y cuesta una pasada por las celdas con fórmula
Dónde termina el viaje de ida y vuelta sin pérdidas
HotXLS no copia el paquete entero byte a byte, y la salida no debería juzgarse así. El XML de las hojas, styles.xml, las cadenas compartidas y la parte del libro se regeneran desde el modelo parseado, así que son fieles en contenido pero no idénticos en binario a la entrada. Solo las cabeceras locales del ZIP llevan timestamps frescos. Los fragmentos <ext> capturados vuelven normalizados, como se ha descrito arriba. ThemeMajorFont y ThemeMinorFont se quedan fuera de un tema preservado, mientras que las sobrescrituras ThemeColor entran en él slot a slot
La red de preservación tiene una forma definida: las características que el motor modela de forma nativa, como los minigráficos y la validación de datos extendida, que se parsean y se reescriben; el contenido <ext> ajeno a nivel de hoja, que se reproduce; y la parte del tema, que se transporta tal como se capturó. Los proyectos VBA y las referencias a libros externos atraviesan el guardado con el mismo enfoque de conservar lo que no se modela, cubierto en el artículo compañero sobre preservación de VBA y enlaces externos, y las propiedades de documento en docProps tienen su propia API de lectura y escritura. Una parte de un complemento exótico que no esté modelada ni dentro de un punto de extensión queda fuera de los tres mecanismos cubiertos aquí
La comprobación que importa usa vuestros propios ficheros. Abri una plantilla de producción rica en características, cambiad un valor, guardad, descomprimid ambos paquetes y comparad parte por parte. Esperad diferencias en la hoja que editasteis, en styles.xml y en el formato de atributos dentro del extLst; la parte del tema debería coincidir con la entrada, los elementos <ext> deberían enumerar los mismos valores de uri, y calcChain.xml debería nombrar cada celda con fórmula. Cualquier cosa fuera de esa lista merece persecución antes de que la plantilla entre en producción
La preservación del tema, la reproducción del extLst ajeno y la salida de la cadena de cálculo forman parte del motor XLSX del HotXLS Delphi Excel Component; la página de producto enumera el resto de lo que lee y escribe para proyectos Delphi y C++Builder