Une tâche de facturation ouvre un modèle client, écrit 42750 en B3 et enregistre. Diffz ensuite les packages décompressés et la liste des changements dépasse largement la seule cellule : xl/theme/theme1.xml contient désormais la palette Office standard au lieu du sarcelle et de l'ardoise du client, le <extLst> au bas du XML de feuille a perdu le groupe de sparklines et une règle de format conditionnel plus récente, et xl/calcChain.xml a tout simplement disparu. Excel ouvre le résultat, propose une réparation, et les couleurs de la marque sont parties. Le code n'a touché qu'une cellule. Tout le reste a changé parce que la sauvegarde a reconstruit le package à partir de ce que le modèle en mémoire connaissait, et trois parties d'un modèle type se situent hors de ce qu'un modèle de feuille de calcul contient normalement
Pourquoi une modification d'une cellule réécrit tout le package XLSX
Un fichier .xlsx est un ZIP de parties XML : xl/workbook.xml, un xl/worksheets/sheetN.xml par feuille, xl/styles.xml, xl/sharedStrings.xml, le thème, la chaîne de calcul, et tous les dessins, tableaux et caches de pivot que le classeur porte. Une bibliothèque qui lit valeurs et formules dans des objets puis régénère chaque partie depuis ces objets à la sauvegarde a un point faible. Tout ce pour quoi le modèle d'objets n'a pas d'emplacement n'arrive jamais en mémoire, si bien que la partie régénérée en sort dépourvue. Personne n'a besoin de supprimer les sparklines ; elles n'ont simplement nulle part où vivre entre Open et SaveAs
ECMA-376 avait vu venir la moitié du problème. SpreadsheetML réserve extLst (ECMA-376 Partie 1, §18.2.10 pour l'élément au niveau du classeur, avec des éléments correspondants sur les feuilles, les styles et les formats conditionnels) comme zone de stockage pour fonctionnalités futures. Un producteur plus récent enveloppe chaque fonctionnalité dans un élément <ext> dont l'attribut uri nomme la fonctionnalité, et un consommateur plus ancien est censé transporter ce qu'il ne comprend pas. Les sparklines, les listes de segments, les options plus récentes de barres de données et de jeux d'icônes et la validation de données étendue voyagent toutes ainsi dans les fichiers qu'Excel écrit aujourd'hui. Supprimer des blocs <ext> inconnus casse donc le contrat de compatibilité ascendante autour duquel le format a été bâti, et les dégâts n'apparaissent que quand le client rouvre le fichier dans Excel
Le thème et la chaîne de calcul échouent pour des raisons différentes, donc chacun exige son propre traitement. Le reste de cet article détaille comment HotXLS gère les trois, ce qu'un appelant Delphi peut observer et vérifier, et où la garantie s'arrête
Garder un theme1.xml personnalisé intact en Delphi
HotXLS conserve le thème d'un classeur en gardant les octets d'origine de xl/theme/theme1.xml du package ouvert et en réécrivant cette partie telle quelle au SaveAs. La partie thème (ECMA-376 Partie 1, §14.2.7) est du DrawingML : un jeu de couleurs à douze emplacements, un jeu de polices, un jeu de formats de remplissages, lignes et effets. Les styles de cellule y pointent avec des références comme <color theme="4"/>, si bien que le moteur de feuille de calcul n'a qu'à résoudre des emplacements, jamais à comprendre les dégradés ou les styles d'effets. Régénérer un thème Office fixe à chaque sauvegarde est précisément ce qui transforme le sarcelle du client en bleu Office. Un classeur créé de toutes pièces, sans thème à transporter, reçoit à la place le thème Office intégré
Le cas courant n'a besoin d'aucun code de thème. Notez l'index de feuille : Sheets est basé sur 1 dans le moteur XLSX, et Cells[3, 2] désigne la ligne 3, colonne 2, c'est-à-dire B3
var
Book: TXLSXWorkbook;
begin
Book := TXLSXWorkbook.Create;
try
Book.Open('branded-invoice.xlsx');
Book.Sheets[1].Cells[3, 2].Value := 42750.00; // la seule modification
Book.SaveAs('branded-invoice-out.xlsx');
// xl/theme/theme1.xml dans la sortie porte le thème propre du modèle
finally
Book.Free;
end;
end;
Les octets bruts sont la fidélité la plus forte possible pour une telle partie : pas d'analyse, pas de resérialisation, rien qui puisse dériver. Quand la sauvegarde écrit du Strict OOXML au lieu du dialecte transitional, le thème capturé passe par le traducteur de namespaces au lieu d'être copié, car une copie d'octets garderait des URI de namespaces transitional dans un package Strict
Le piège est côté API. TXLSXWorkbook expose ThemeMajorFont et ThemeMinorFont, et après Open ils rapportent les polices de titres et de corps analysées dans le jeu de polices du modèle. Les modifier semble être la manière naturelle de changer de police, mais ils ne façonnent que le thème Office intégré que reçoivent les nouveaux classeurs. Sur un classeur qui a apporté son propre thème, la partie capturée gagne et ces deux propriétés ne changent rien au fichier enregistré. Les couleurs sont traitées autrement : ThemeColor[Slot] adresse les douze emplacements du clrScheme, et une surcharge est écrite dans le thème préservé en remplaçant seulement la couleur de cet emplacement, sans toucher au jeu de polices, au jeu de formats ni aux extensions de thème
Book.Open('branded-invoice.xlsx');
// Aucun effet sur le fichier enregistré : le thème propre du modèle est préservé
Book.ThemeMajorFont := 'Segoe UI Semibold';
// Atteint bien le fichier : seul l'emplacement accent1 de theme1.xml change
Book.ThemeColor[xlsxThemeAccent1] := $FF0F7B6C; // $AARRGGBB
Book.SaveAs('rebranded.xlsx');
Cette séparation est délibérée. Une surcharge de couleur est une édition étroite et bien définie d'un seul élément, donc le reste du thème du designer peut rester exactement comme il était. Une réécriture du jeu de polices toucherait des listes de polices par script qu'une API orientée données n'a aucun bon moyen d'exprimer. Si un modèle a besoin d'une nouvelle police, changez-la dans Excel et livrez le nouveau modèle ; cela garde le thème entre les mains de celui qui possède la marque
Qu'advient-il des blocs extLst inconnus lors de l'enregistrement ?
HotXLS capture chaque bloc <ext> au niveau de la feuille qu'il ne modélise pas nativement et le rejoue dans le extLst de la feuille enregistrée. Les blocs qu'il modélise sont analysés en objets typés et reconstruits depuis eux : les groupes de sparklines vont dans SparklineGroups, l'extension de validation de données x14 est lue dans la collection de validation de données, et les listes de segments sont réémises par le modèle de segments. Tout le reste atterrit, un fragment XML par bloc, dans la liste de chaînes en lecture seule RawWorksheetExts de chaque TXLSXWorksheet, ce qui permet à un test d'inspecter exactement ce qui sera transporté
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 balise ouvrante montre l'uri
// Déclarations de namespaces que les fragments ont empruntées à la racine <worksheet>
WriteLn(Sheet.RawExtNamespaceDecls);
finally
Book.Free;
end;
end;
La capture fonctionne depuis le flux d'événements XML, car un lecteur en flux distribue des éléments, du texte et des balises fermantes mais aucun décalage d'octets vers la source. Chaque sous-arbre inconnu est reconstruit depuis ces événements au fil de leur passage. Un compteur de profondeur naïf casse ici : il incrémente à chaque balise ouvrante et décrémente à chaque balise fermante, et un enfant auto-fermant tel que <x14:cfvo type="min"/> arrive comme un seul événement d'ouverture marqué vide sans balise fermante pour suivre. Si on le compte comme un élément ouvert, le compteur ne revient jamais à zéro et la capture avale le reste de la feuille. La boucle de capture de HotXLS n'incrémente la profondeur que pour une balise ouvrante non vide, et un <ext/> lui-même vide est stocké immédiatement comme fragment d'une ligne
Reconstruire depuis les événements a un effet de bord visible. Le guillemetage des attributs, l'espace entre les éléments et le choix entre <a></a> et <a/> reviennent normalisés, si bien qu'un fragment est équivalent en sens à l'original mais pas identique octet pour octet. Excel analyse le XML ; il ne compare pas des octets. Un outil de diff qui compare du texte signalera cependant le changement, et cela vaut la peine de le savoir avant que quelqu'un ne le déclare comme régression
Les namespaces sont la deuxième chose qui peut mal tourner avec un fragment rejoué. Excel déclare d'habitude les préfixes dont il a besoin sur l'élément <ext> lui-même, ce qui rend le fragment autonome, mais un bloc peut aussi s'appuyer sur un préfixe tel que x14ac ou xr déclaré une seule fois sur la racine <worksheet> source. Rejouez ce fragment dans une feuille sans la déclaration et le XML enregistré n'est pas bien formé côté namespaces. HotXLS scanne chaque fragment capturé à la recherche des préfixes qu'il utilise sans les déclarer, enregistre les déclarations correspondantes de la source dans RawExtNamespaceDecls, et les écrit sur la racine de la feuille enregistrée. Comme les fragments sont de simples chaînes, la duplication d'une feuille au sein d'un classeur ou entre classeurs peut les transporter vers la nouvelle feuille aussi
Écrire calcChain.xml pour qu'Excel fasse confiance à vos formules
HotXLS écrit xl/calcChain.xml (la partie chaîne de calcul, ECMA-376 Partie 1, §12.3.1) chaque fois que le classeur enregistré contient au moins une cellule à formule, avec sa substitution de content-type et sa relation de classeur. Chaque entrée est un élément <c r="D10" i="1"/> : la référence de cellule plus l'index de feuille basé sur 1, que le rédacteur émet sur chaque entrée même si le schéma permet à une série d'entrées d'une même feuille de l'omettre. L'explicite est plus simple et tout aussi valide
L'ordre dépend de ce que le classeur connaît déjà. Quand le graphe de dépendances des formules existe et est à jour, l'état juste après Recalculate, la chaîne suit un ordre topologique complet : chaque formule après les cellules dont elle dépend, avec les membres des références circulaires ajoutés à la fin pour que la chaîne liste quand même chaque cellule à formule. Quand le graphe est périmé ou n'a jamais été construit, les cellules à formule sont listées en ordre de document, feuille par feuille. Les deux sont légaux. Les notes d'implémentation de Microsoft pour le format, [MS-XLSX], décrivent la chaîne comme un indice qu'Excel vérifie et réordonne pendant le calcul, donc une liste complète dans n'importe quel ordre se charge proprement
Book.Open('model.xlsx');
Book.Sheets[1].Cells[10, 4].Formula := '=SUM(D2:D9)';
// Enregistrer ici liste les cellules à formule en ordre de document, car changer
// une formule a invalidé le graphe de dépendances.
Book.Recalculate; // reconstruit le graphe et rafraîchit les valeurs en cache
Book.SaveAs('model-out.xlsx');
// calcChain.xml suit désormais l'ordre des dépendances : D10 après D2:D9
SaveAs ne construit pas le graphe de sa propre initiative. Une construction complète des dépendances signifie résoudre chaque référence dans chaque formule, ce qui sur un grand modèle est du vrai travail qu'un appelant qui ne voulait qu'écrire un fichier n'a jamais demandé. Si les valeurs en cache de la sortie comptent pour vous, et c'est habituellement le cas pour tout ce qu'un système aval lit sans ouvrir Excel, appelez Recalculate avant d'enregistrer de toute façon ; la chaîne ordonnée par dépendances vient gratuitement avec
Pourquoi émettre une partie qu'Excel traite comme indicative ? Parce que son absence se remarque. Heuristiques de réparation, visionneuses tierces et outils de diff attendent tous qu'un classeur à formules porte une chaîne de calcul, et un package sans elle ne ressemble à rien de ce qu'Excel produit lui-même. Écrire une chaîne valide maintient la sortie dans la forme contre laquelle le reste de l'écosystème a été exercé, et coûte une passe sur les cellules à formule
Où s'arrête l'aller-retour sans perte
HotXLS ne copie pas tout le package octet pour octet, et la sortie ne devrait pas être jugée ainsi. Le XML des feuilles, styles.xml, les chaînes partagées et la partie classeur sont régénérés depuis le modèle analysé, donc fidèles en contenu mais pas binaire-identiques à l'entrée. Les en-têtes locaux du ZIP portent à eux seuls des horodatages neufs. Les fragments <ext> capturés reviennent normalisés, comme décrit ci-dessus. ThemeMajorFont et ThemeMinorFont restent hors d'un thème préservé, tandis que les surcharges ThemeColor y entrent emplacement par emplacement
Le filet de préservation a une forme définie : les fonctionnalités que le moteur modélise nativement, comme les sparklines et la validation de données étendue, qui sont analysées et réécrites ; le contenu <ext> étranger au niveau de la feuille, qui est rejoué ; et la partie thème, qui est transportée telle que capturée. Les projets VBA et les références de classeurs externes traversent la sauvegarde selon la même approche consistant à garder ce qu'on ne modélise pas, traitée dans l'article connexe sur la préservation des projets VBA et des liens externes, et les propriétés de document dans docProps ont leur propre API de lecture-écriture. Une partie d'un complément exotique ni modélisée ni dans un point d'extension se situe hors des trois mécanismes couverts ici
La vérification qui compte utilise vos propres fichiers. Ouvrez un modèle de production riche en fonctionnalités, changez une valeur, enregistrez, décompressez les deux packages et diffz partie par partie. Attendez-vous à des différences dans la feuille modifiée, dans styles.xml et dans le formatage des attributs à l'intérieur d'extLst ; la partie thème doit correspondre à l'entrée, les éléments <ext> doivent lister les mêmes valeurs de uri, et calcChain.xml doit nommer chaque cellule à formule. Tout ce qui dépasse cette liste mérite qu'on le traque avant que le modèle n'entre en production
Préservation du thème, rejeu des extLst étrangers et sortie de la chaîne de calcul font partie du moteur XLSX du HotXLS Delphi Excel Component ; la page produit liste le reste de ce qu'il lit et écrit pour les projets Delphi et C++Builder