Membres d'API supplémentaires de la bibliothèque

Cette page complète la référence des types publics qui prennent en charge les API principales de classeur, de feuille de calcul, de rendu, d'importation, de diagnostics et de visionneuse mais ne nécessitent pas de guide dédié distinct

Filtrage et mise en forme conditionnelle

TXLSCfValue, TXLSDataBarSpec, TXLSColorScaleSpec, TXLSIconSetSpecet TXLSDxfStyle acceptent AttachWriteGuardOwner, reliant l'objet de règle à son classeur propriétaire afin que les modifications acquièrent automatiquement une garde d'écriture ; le propriétaire implémente TXLSCondFormatWriteGuardOwner, dont l'unique méthode AcquireWriteGuard remet à la règle la garde d'écriture du classeur. TXLSDxfStyle ajoute FontColorIndex avec FontColorIsIndexed ainsi que les paires FillFgColorIndex / FillFgColorIsIndexed et FillBgColorIndex / FillBgColorIsIndexed pour les couleurs de règles par index de palette, plus les surcharges de police différentielle FontName, FontSizeet FontScheme (chaîne vide, une taille en points ou un emplacement de police de thème tel que major / minor) à côté des membres gras, italique, souligné et couleur existants ; chaque affectation acquiert la garde d'écriture et marque la règle comme sale pour réémission

TXLSConnections, TXLSDataTableset TXLSQueryTables exposent OnAcquireWriteGuard (types TXLSConnectionAcquireWriteGuard, TXLSDataTableAcquireWriteGuardet TXLSQueryTableAcquireWriteGuard), le hook que leurs chemins de modification utilisent pour obtenir le IXLSWorkbookWriteGuard du classeur propriétaire avant toute mutation et pour faire avancer ensuite la génération du classeur ; la garde enregistre StartGenerationet Complete marque l'écriture comme terminée afin que les caches dépendants puissent être reconstruits

Les connexions de données préservées portent une description typée : TXLSConnectionKind (xlckUnknown, xlckOdbc, xlckDao, xlckFile, xlckWeb, xlckOleDb, xlckText, xlckAdo) classe la connexion, TXLSConnectionCredentials (xlccIntegrated, xlccNone, xlccStored, xlccPrompt) enregistre son mode d'authentification, et chaque valeur de paramètre de connexion est étiquetée avec un TXLSConnectionParameterValueKind (xlcpvNone, xlcpvBoolean, xlcpvDouble, xlcpvInteger, xlcpvString, xlcpvCell). Les tables de données d'analyse de scénarios signalent leur type de définition stockée via TXLSDataTableKind

Tables de données d'analyse de scénarios et regroupement de tableaux croisés dynamiques

Les seuils des jeux d'icônes peuvent être restitués ou validés par programmation : XLSCfIconSetCount indique combien d'icônes définit un TXLSIconSetType , et XLSBuildCfIconGeometry remplit un TXLSCfIconGeometry avec les primitives (TXLSCfIconPrimitive, de type TXLSCfIconPrimitiveKind: cfipPolygon, cfipEllipse, cfipRect, cfipLine) et les points (TXLSCfIconPoint) qui dessinent une icône, afin que les moteurs de rendu personnalisés reprennent les formes d'icônes intégrées d'Excel

Diagnostics, traçage des formules et validation

Schémas de validation d'importation

TXLSImportCheck de lxImportCheck valide une TXLSXWorksheet contre des règles détenues par l'application ; il examine les valeurs scalaires stockées et les résultats de formules stockés, avec des coordonnées de feuille en base 1 et aucune conversion implicite texte-vers-nombre, texte-vers-date ou texte-vers-booléen

Validator := TXLSImportCheck.Create;
try
  Validator.HeaderRow := 1;
  Rule := Validator.AddRule(2);
  Rule.Name := 'quantity';
  Rule.Flags := [irRequired, irValueType, irValueRange];
  Rule.ValueKind := ivkInteger;
  Rule.MinimumValue := 1;
  Rule.MaximumValue := 1000;

  Validator.AddUniqueRule([1, 3]).Name := 'account-and-region';
  Validator.AddCrossColumnRule(4, 5, icLessOrEqual).Name := 'start-before-end';
  FailureCount := Validator.Check(Sheet);
  if FailureCount > 0 then
    Validator.Annotate(Sheet, 'Import validator');
finally
  Validator.Free;
end;

HeaderRow > 0 démarre la vérification à la ligne suivante et prend la précédence sur FirstRow ; sinon FirstRow vaut 1 par défaut ; LastRow = 0 utilise la dernière ligne utilisée de la feuille, tandis qu'un LastRow positif peut inclure des cellules absentes sans les créer ; les colonnes doivent être entre 1 et 16 384 et les bornes actives de lignes de données entre 1 et 1 048 576

Règles de colonnes et types explicites

AddRule(Column) remplace et libère toute règle précédente pour cette colonne ; les prédicats par type de valeur, plage, longueur et motif ignorent les valeurs manquantes, nulls et chaînes vides, tandis que irRequired les signale ; l'unicité conserve les politiques distinctes décrites ci-dessous ; les blancs non vides restent une valeur ; un nombre ne vaut pas booléen, une date ne vaut pas nombre ordinaire, et une chaîne d'apparence numérique reste du texte

L'affectation de MinimumValue ou MaximumValue active cette borne ; HasMinimum ou HasMaximum peut la désactiver à nouveau ; les deux commutateurs d'inclusivité valent True par défaut ; les bornes doivent être des nombres ou des dates typés finis, et deux bornes doivent être comparables et décrire un intervalle non vide ; des bornes inversées, manquantes, incompatibles ou vides lèvent une exception avant le début de la validation de la feuille

Les bornes numériques comparent des valeurs numériques et les bornes de dates comparent des dates ; les comparaisons entier-à-entier préservent tous les bits Int64 et UInt64 ; les valeurs d'une catégorie incompatible échouent au contrôle de plage ; les prédicats de longueur de texte et de regex continuent d'inspecter la représentation texte du scalaire, et les contrôles regex conservent le comportement IsMatch existant, donc utilisez des ancres comme ^...$ quand le texte complet doit correspondre ; une regex invalide désactive son contrôle de motif par compatibilité

Valeurs Excel formatées en dates

Une cellule importée d'Excel peut contenir un numéro sériel numérique même quand son format de nombre affiche une date ; choisissez explicitement un mode sériel quand c'est le schéma d'importation accepté ; le mode n'affecte que la validation et ne change jamais la valeur stockée de la cellule

Rule := Validator.AddRule(4);
Rule.Flags := [irRequired, irValueType, irValueRange];
Rule.ValueKind := ivkDate;
if Sheet.Workbook.Date1904 then
  Rule.DateSerialMode := idsExcel1904
else
  Rule.DateSerialMode := idsExcel1900;
Rule.MinimumValue := VarFromDateTime(EncodeDate(2026, 1, 1));
Rule.MaximumValue := VarFromDateTime(EncodeDate(2026, 12, 31));

VarFromDateTime est déclaré dans Variants et EncodeDate dans SysUtils ; les numéros sériels numériques doivent être non négatifs et se résoudre avant le 1er janvier 10000 ; les sériels fractionnaires conservent leur heure du jour ; le système 1900 rejette tout sériel de 60 inclus à 61 exclus parce que cet intervalle dénote le jour bissextile fictif ; le système 1904 mappe le sériel zéro au 1er janvier 1904

Les bornes de dates incluent l'heure du jour, si bien qu'un maximum fixé à minuit le 31 décembre exclut les heures ultérieures de ce jour ; utilisez une borne supérieure exclusive au 1er janvier de l'année suivante quand la totalité du dernier jour doit être acceptée ; les dates textuelles comme 10/08/2026 restent du texte quel que soit le mode sériel configuré

Unicité composite et comparaisons inter-colonnes

Les clés composites conservent le type Variant exact et l'identité de texte de chaque membre ; Integer(1), Double(1), la chaîne '1', un booléen et une date sont des membres distincts ; il n'y a pas de casse unifiée, de normalisation Unicode, d'analyse de locale ni d'ambiguïté de délimiteur ; des combinaisons comme ('ab', 'c') et ('a', 'bc') restent différentes ; chaque passe de validation démarre un index de tuples frais

Quand SkipIncompleteRows = True, un membre manquant, null ou chaîne vide exclut cette ligne de l'unicité de tuple ; le mettre à False inclut ces membres avec leurs identités Variant d'origine ; un doublon signale sa première colonne de tuple comme adresse de cellule et sa première ligne correspondante via FirstDuplicateRow

Le irUnique mono-colonne existant conserve son comportement de correspondance textuelle insensible à la casse et ignore les valeurs manquantes ou null ; utilisez AddUniqueRule([Column]) quand une identité typée stricte est requise pour une colonne

Les comparaisons inter-colonnes ne convertissent jamais des chaînes en nombres, des nombres en booléens, ni des nombres ordinaires en dates ; des catégories mixtes incompatibles échouent même pour icNotEqual ; les comparaisons de chaînes distinguent Unicode composé et décomposé, préservent les caractères null incorporés, et utilisent l'ordre du préfixe le plus court d'abord ; quand SkipBlankValues = False, l'un ou l'autre opérande vide produit une violation inter-colonnes

Résultats structurés et classeurs de correction

Check(Sheet) renvoie le nombre de violations, et ViolationCount plus Violation(Index) en base zéro énumèrent le rapport ; une règle de colonne signale son premier prédicat en échec, tandis que des règles de tuple et de comparaison configurées indépendamment peuvent ajouter d'autres violations pour la même cellule ; affectez des Name significatifs quand les appelants ont besoin d'identifiants stables de règles applicatives

Les cellules de formules sont validées à partir de leurs valeurs en cache stockées ; une formule sans résultat en cache stocké signale ivFormulaCacheMissing, et un résultat d'erreur signale ivCellError ; recalculez explicitement avant la vérification quand des résultats de formules frais sont requis ; la validation n'accède pas à des sources externes, n'altère pas les définitions de formules et n'évalue pas les formules sans cache

OnVerifyCell conserve la signature du callback TlxImportVerifyCell et s'exécute après les prédicats de colonnes applicables réussis et les contrôles d'unicité ; il renvoie un booléen et peut définir un message d'erreur applicatif ; les callbacks doivent laisser le classeur et le schéma de validation inchangés, et les écritures au classeur sont rejetées par le bail de lecture ; les exceptions de callbacks se propagent et le bail est libéré pour les opérations suivantes

Check n'annote jamais, ne supprime pas de lignes ni ne matérialise de valeurs packées ; utilisez Annotate après la vérification pour appliquer des polices rouges et ajouter du texte d'erreur aux commentaires existants, ou appelez explicitement KeepOnlyViolations pour retirer les lignes non en échec et créer un classeur de correction ; ces méthodes modifient la feuille fournie, donc appelez-les sur le classeur voulu après examen du rapport

La validation emprunte la feuille et le classeur pour l'appel synchrone ; elle n'adopte pas la propriété d'objet de l'appelant et n'exige pas un classeur détenu par interface ; un bail de lecture protège les instantanés pertinents de cellules stockées et l'accès aux caches de formules stockés pendant toute la vérification

Stratégies d'enregistrement des liens externes

TXLSExternalLinkUpdateMode = (xluPromptUser, xluNever, xluAlways);

property IXLSWorkbook.SaveExternalLinkValues: Boolean;
property IXLSWorkbook.UpdateLinks: TXLSExternalLinkUpdateMode;
property TXLSXWorkbook.SaveExternalLinkValues: Boolean;
property TXLSXWorkbook.UpdateLinks: TXLSExternalLinkUpdateMode;
      

Audit de calcul et indicateurs de classeur

function TXLSWorkbook.RecalcAndVerify(MaxIssues: Integer = 10000): TXLSCalculationAuditReport;
function TXLSXWorkbook.RecalcAndVerify(MaxIssues: Integer = 10000): TXLSCalculationAuditReport;
function TXLSWorkbook.RecalcAndVerifyEx(const Options: TXLSRecalcAuditOptions): TXLSCalculationAuditReport;
function TXLSXWorkbook.RecalcAndVerifyEx(const Options: TXLSRecalcAuditOptions): TXLSCalculationAuditReport;
function TXLSWorkbook.RunCalculationAudit(const Options: TXLSRecalcAuditOptions): TXLSCalculationAuditReport;
function TXLSWorkbook.FormulaIsVolatile(Formula: WideString): Boolean;

function TXLSWorkbook.AuditOverlayHash(SheetIndex, Row, Col: Integer): Integer;
function TXLSWorkbook.AuditOverlayRead(SheetIndex, Row, Col: Integer; var Value: Variant): Boolean;
procedure TXLSWorkbook.AuditOverlayWrite(SheetIndex, Row, Col: Integer; const Value: Variant);
procedure TXLSWorkbook.AuditOverlayClear;

TXLSCalculationAuditIssueKind = (xlcaiCacheMismatch, xlcaiParseFailure,
  xlcaiMissingFunction, xlcaiMissingName, xlcaiUnsupportedArguments,
  xlcaiCircularReference, xlcaiExternalReferenceDenied,
  xlcaiExternalReferenceMissing, xlcaiDataTableSkipped, xlcaiCancelled,
  xlcaiInternalFailure);

TXLSCalculationAuditIssue = record
  Kind: TXLSCalculationAuditIssueKind;
  SheetIndex: Integer;
  SheetName: WideString;
  Row: Integer;
  Col: Integer;
  Formula: WideString;
  Symbol: WideString;
  Expected: Variant;
  Actual: Variant;
  ResultCode: Integer;
  Stack: WideString;
  ExternalTarget: WideString;
end;
TXLSCalculationAuditIssues = array of TXLSCalculationAuditIssue;

TXLSRecalcAuditProgress = procedure(ASender: TObject;
  ACurrent, ATotal: Integer; var ACancel: Boolean) of object;

property WorkbookCodeName: WideString;
property CalculationThreadMode: TXLSCalculationThreadMode;
property ForceFullCalculationState: TXLSOptionalBooleanState;
property RefreshAllOnLoadState: TXLSOptionalBooleanState;
      

État des formules de table et de l'IME

property TXLSXTable.ColumnCalculatedFormulaArrayStates[Index: Integer]: TXLSTableFormulaArrayState;
property TXLSXTable.ColumnTotalsFormulaArrayStates[Index: Integer]: TXLSTableFormulaArrayState;
property TDataValidation.ImeMode: TXLSDataValidationImeMode;
property TXLSXDataValidation.ImeModeKind: TXLSDataValidationImeMode;
      

Inspection et suppression des volets de tâches des compléments web

function IXLSWorkbook.HasWebAddinTaskPanes: Boolean;
function IXLSWorkbook.WebAddinTaskPaneCount: Integer;
function IXLSWorkbook.RemoveWebAddinTaskPanes: Integer;
function TXLSXWorkbook.HasWebAddinTaskPanes: Boolean;
function TXLSXWorkbook.WebAddinTaskPaneCount: Integer;
function TXLSXWorkbook.RemoveWebAddinTaskPanes: Integer;
      

Politique d'affichage des objets du classeur

TXLSObjectDisplayMode = (xlsodmShowAll, xlsodmShowPlaceholders,
  xlsodmHideAll);

property IXLSWorkbook.ObjectDisplayMode: TXLSObjectDisplayMode;
property TXLSWorkbook.ObjectDisplayMode: TXLSObjectDisplayMode;
property TXLSXWorkbook.ObjectDisplayMode: TXLSObjectDisplayMode;
property TXLSPaginationModel.ExportObjectPlaceholders: Boolean;
property TXLSPDFExport.ExportObjectPlaceholders: Boolean;
property TXLSSvgExport.ExportObjectPlaceholders: Boolean;
property TXLSPageImageExporter.ExportObjectPlaceholders: Boolean;
property TXLSPrintDocument.ExportObjectPlaceholders: Boolean;
property TXLSXHtmlExportOptions.ExportObjectPlaceholders: Boolean;
      

Valeurs d'étalonnage de rendu et instantanés

TXLSRenderCalibration = record
  WidthCorrection: Double;
  HeightCorrection: Double;
  LineSpacing: Double;
  CellMarginFactor: Double;
  ScreenScaling: Integer;
  MeasurementDpi: Integer;
end;

function XLSDefaultRenderCalibration: TXLSRenderCalibration;
function XLSValidateRenderCalibration(const AValue: TXLSRenderCalibration;
  out AInvalidField: TXLSRenderCalibrationField): Boolean;
      

Géométrie de rendu et mesure des polices

TXLSRenderGeometryBackend = (xlsrgbAutoFit, xlsrgbPagination, xlsrgbPdf,
  xlsrgbSvg, xlsrgbBitmap, xlsrgbPrintPreview, xlsrgbViewer, xlsrgbHtml);

TXLSRenderFont = record
  Name: WideString;
  Size: Double;
  Styles: TXLSRenderFontStyles;
  Charset: Byte;
end;

function CreateXLSRenderGeometry(
  const ACalibration: TXLSRenderCalibration;
  AWorkbookGeneration: UInt64;
  ABackend: TXLSRenderGeometryBackend;
  ACacheCapacity: Integer = 4096): IXLSRenderGeometry;

property TXLSHTMLExport.RenderGeometry: IXLSRenderGeometry;
property TXLSXHtmlExportSession.RenderGeometry: IXLSRenderGeometry;
      

Importation, génération de code, comparaison et surveillance

Comparaison de classeurs

TXLSXWorkbookCompare de lxCompare compare deux instances TXLSXWorkbook sans recalculer de formules ni modifier l'un ou l'autre classeur ; les feuilles sont appariées par nom insensible à la casse, et un simple changement d'ordre des feuilles ne produit pas de différence

La valeur Options par défaut est vide et les deux tolérances valent zéro par défaut ; la comparaison par défaut signale les feuilles ajoutées ou retirées, les cellules stockées ajoutées ou retirées, les valeurs littérales typées changées, le texte de formules changé, et les plages fusionnées ajoutées ou retirées

La comparaison littérale distingue nombres, texte, booléens, dates, erreurs et vides : le nombre 1 diffère du texte '1', un booléen diffère de son orthographe textuelle, les dates conservent leur propre type, et les erreurs se comparent par leur code d'erreur stocké ; les types de stockage numériques de valeurs égales se comparent comme égales, tandis que des valeurs Int64 distinctes restent distinctes pendant la comparaison exacte

Options a le type TlxCompareOptions, un ensemble de TlxCompareOption ; activer une option ajoute ses différences à la comparaison par défaut

SetFeatureLimits(MaxBytes, MaxItems) valide les deux limites positives avant de changer l'un ou l'autre réglage ; MaxFeatureBytes vaut 64 Mio par défaut et MaxFeatureItems 1 000 000 par défaut, et les setters individuels conservent la même validation atomique

Les budgets de fonctionnalités couvrent les octets canoniques détachés agrégés et les entrées comptées des deux classeurs, y compris segments de texte enrichi, nœuds XML de filtres, champs de tableaux croisés dynamiques, membres de domaines et valeurs d'enregistrements, et connexions de Slicers ou Timelines ; les lecteurs vérifient les comptages et les entrées de texte importantes avant de construire le XML natif, appliquent des flux de sortie bornés, et lèvent EXLSXSemanticBudget quand une limite est dépassée

SetNumericTolerance(AbsoluteTolerance, RelativeTolerance) valide les deux arguments avant de changer l'un ou l'autre réglage ; les deux doivent être finis et non négatifs, et les setters individuels AbsoluteTolerance et RelativeTolerance utilisent la même validation

Les littéraux numériques et les valeurs de caches numériques se comparent comme égales quand leur différence absolue est au plus AbsoluteTolerance ou leur différence relative à la plus grande valeur absolue est au plus RelativeTolerance ; un seuil de zéro conserve l'égalité exacte, le calcul relatif évite le débordement pour des valeurs opposées extrêmes, et la tolérance ne convertit pas le texte et ne s'applique ni aux dates, ni aux styles, ni à la géométrie

LeftName et RightName définissent des noms d'affichage facultatifs utilisés par les lignes de Report, avec left et right par défaut ; les noms n'affectent que le rapport, pas l'appariement de feuilles ni la comparaison

Comparer := TXLSXWorkbookCompare.Create;
try
  Comparer.Options := [lcoFormulaCachedResults, lcoCellStyles,
    lcoAxisGeometry];
  Comparer.SetNumericTolerance(0.001, 0.000001);
  DifferenceCount := Comparer.Compare(LeftWorkbook, RightWorkbook);
  for I := 0 to DifferenceCount - 1 do
  begin
    Entry := Comparer.Diff(I);
    ReportLines.Add(Entry.Describe);
  end;
finally
  Comparer.Free;
end;

Compare renvoie le nombre de différences, Count relit ce nombre ensuite, et Diff(Index) utilise l'indexation en base zéro pour renvoyer un TlxCompareDiff détenu par le comparateur ; conservez le comparateur pendant la lecture de ses entrées, et récupérez à nouveau les entrées après une autre comparaison réussie

Chaque entrée fournit Kind, Sheet, Row et Col en base 1 quand applicables, Ref, LeftText, RightText, et des valeurs typées LeftKind / RightKind ; TlxCompareValueKind contient lcvNone, lcvBlank, lcvNumber, lcvText, lcvBoolean, lcvDateTime, lcvErroret lcvFormula, avec lcvNone utilisé pour un côté absent ou une différence hors valeur

TlxCompareKind conserve lckSheetAdded, lckSheetRemoved, lckCellAdded, lckCellRemoved, lckValueChanged, lckFormulaChanged, lckMergeAddedet lckMergeRemoved, et ajoute lckFormulaCacheChanged, lckStyleChanged, lckRowGeometryChangedet lckColumnGeometryChanged

Les différences de styles transportent des empreintes canoniques stables de styles dans LeftText et RightText ; les différences de géométrie transportent l'état comparé de taille, masquage, plan et repli, avec Ref identifiant l'intervalle d'axe contigu affecté, Row fixé à sa première ligne et Col à zéro pour les lignes, ou Col fixé à sa première colonne et Row à zéro pour les colonnes

Les différences de fonctionnalités utilisent lckDefinedNameChanged, lckDataValidationChanged, lckConditionalFormatChanged, lckTableChanged, lckDrawingChanged, lckPivotTableChanged, lckPivotCacheChanged, lckSlicerChangedou lckTimelineChanged ; Change vaut lccChanged, lccAddedou lccRemoved, et chaque côté présent transporte son empreinte canonique de définition tandis qu'un côté absent transporte une chaîne vide

lckRichTextChanged identifie une définition de segment changée à sa coordonnée de cellule et transporte des empreintes canoniques de segments dans LeftText et RightText ; la tolérance numérique s'applique aux littéraux de cellules et aux caches de formules, tandis que les définitions typées de fonctionnalités se comparent exactement

Les références de fonctionnalités identifient des noms à portée ou des noms de tables, ou utilisent des positions de séquence en base 1 pour les définitions de validation, de mise en forme conditionnelle et de dessins ; insérer ou déplacer une fonctionnalité ordonnée peut changer plusieurs positions, tandis que les entrées de noms au niveau classeur ont un Sheet vide

lckBlankStyleRegionChanged identifie un rectangle vide changé via Row, Col, LastRow et LastCol inclusifs, et son Ref A1 ; les coordonnées stockées sont traitées par la comparaison ordinaire de cellules et lcoCellStyles, donc activez les deux options de styles pour inspecter ensemble les cellules stockées et les zones vides

Describe formate une entrée, tandis que Report(List) ajoute les entrées formatées à un TStrings détenu par l'appelant ; un changement de valeur typée inclut des étiquettes de types quand les types diffèrent, et les résultats se trient par nom de feuille, ligne, colonne, genre de différence et référence plutôt que par l'ordre d'insertion des cellules

La comparaison détient des baux de lecture, parcourt les cellules stockées via des instantanés détachés de curseurs, et retient le stockage packé ; la géométrie partitionne les frontières de métadonnées stockées et les étendues compactes de lignes répétées, tandis que la comparaison de styles vides balaie les frontières de rectangles actifs et de cellules stockées sans scanner une grille rectangulaire d'un million de lignes ; le travail croît avec les fonctionnalités stockées, les intersections de régions et les différences signalées

Une comparaison en échec préserve le résultat réussi précédent ; une affectation de tolérance invalide préserve aussi les réglages et le résultat existants, tandis que passer un classeur nil efface le résultat et renvoie zéro

Cette comparaison couvre le contenu de cellules stockées de la façade XLSX et les définitions typées de fonctionnalités sélectionnées ; l'orthographe des formules de noms, validations, mises en forme conditionnelles, tables et graphiques se normalise via l'analyseur sémantique de formules, tandis que les formules calculées de tableaux croisés dynamiques conservent leur texte de définition stocké

Les filtres de tables acceptent les formes prises en charge de filtres personnalisés, de listes de valeurs, de groupes de dates, de couleurs, d'icônes, dynamiques et de top-count, et les conditions de tri ; les colonnes de filtres indépendantes et les entrées d'ensembles de valeurs normalisent leur ordre, les défauts booléens et les orthographes numériques se normalisent, et l'ordre des conditions de tri reste significatif

La comparaison typée de tableaux croisés dynamiques, Slicers et Timelines résout les sources de feuilles locales prises en charge et les liaisons non-OLAP sans rafraîchir ni évaluer la disponibilité ; les indications natives de disponibilité des Slicers sont des métadonnées d'affichage dérivées, tandis que les sélections de membres et les métadonnées natives reconnues de tri sont comparées

Les propriétés natives opaques de dessins, les modèles de tableaux croisés dynamiques binaires incomplets, les sources de tableaux croisés dynamiques externes ou OLAP, les enregistrements supplémentaires bruts de tableaux croisés dynamiques et le XML d'extensions, le XML de filtres inconnu, et les attributs ou enfants d'extensions de Slicers ou Timelines non modélisés lèvent EXLSSemanticSnapshot ; la préservation de ces données n'implique pas d'équivalence sémantique

Les fonctionnalités sélectionnées importées de tableaux croisés dynamiques et de PivotCaches valident aussi le XML natif préservé avant de comparer la projection typée, y compris les métadonnées de champs imbriqués et les enregistrements de caches ; les espaces de noms, attributs, enfants et charges d'extensions inconnus échouent explicitement dans les mêmes limites coopératives de fonctionnalités, tandis que les liaisons de caches de Slicers modélisées restent prises en charge

TSimpleDomNode.RawName expose le QName d'élément d'origine à côté du Name normalisé par le lecteur, permettant une inspection sensible aux espaces de noms sans changer la correspondance de noms existante de l'analyseur

Les réglages de classeur et les métadonnées opaques de package restent hors de la comparaison ; la comparaison de styles de base n'évalue pas l'apparence des mises en forme conditionnelles ou des styles de tables, et la comparaison de dessins préserve les frontières d'images, de zones de texte, de graphiques et de groupes ordonnés prises en charge par l'instantané sémantique

Propriétés effectives du texte enrichi

TMsoFbtOpt.StoredPids renvoie les identifiants de propriétés OfficeArt stockés en ordre trié, tandis que TMsoFbtSp.PersistentFlags expose les indicateurs natifs de formes sans allouer de propriétés ni d'ancres

TMsoShapeContainer.HasPreservedObjectData identifie les octets de queues OBJ retenus ; HasOrdinaryEmbeddedPictureObjectData vérifie que les queues d'images ne contiennent que des enregistrements reconnus de formats de presse-papiers et d'indicateurs d'image à zéro, et rejette les enregistrements liés ou inconnus sans copier la charge

TMSOShapeTextBox.HasValidTextRuns vérifie les frontières de segments TXO stockés et les champs réservés sans créer de segments ; TMsoDrawing.HasUnmodeledAppearance identifie les données natives de dessins sautées par l'analyseur typé, permettant à la capture de rejeter explicitement une apparence non résolue

TXLSXRichTextRun.BoldSet, ItalicSet, StrikethroughSet, UnderlineSet, VertAlignSet et ColorSet distinguent les propriétés de police héritées des surcharges explicites, y compris les indicateurs false, none, les couleurs de baseline et automatiques ; les setters marquent la propriété explicite même quand sa valeur égale le défaut initial du nouveau segment

TXLSXRichText.HasUnsupportedAppearance signale les propriétés riches natives que le modèle typé de segments ne peut pas représenter ; la capture portable et la comparaison effective de texte enrichi rejettent explicitement de tels segments, tandis que les propriétés de segments partagés/en ligne et les blancs pris en charge conservent leur sémantique importée

La comparaison effective de texte enrichi applique les surcharges false explicites avant de fusionner les segments adjacents égaux ; les propriétés héritées et explicitement effacées restent distinctes pendant la déduplication de chaînes partagées et les aller-retours XML pris en charge

TXMLReader.ResolveNamespaceUri(Prefix, Uri) résout la liaison d'espace de noms courante en portée sans changer la position du lecteur, en renvoyant false quand aucune liaison n'existe ; un préfixe vide demande l'espace de noms par défaut, et les QNames bruts restent disponibles pour l'inspection sensible aux espaces de noms

Les enregistrements immuables rich/scene, l'extension de source de capture et le contrat de transfert HXRSNP02 sont décrits dans la sortie headless portable

Inspection détachée de styles et d'axes

TXLSXWorksheet.ReadSemanticCellStyle(Row, Col) renvoie un TXLSSemanticCellStyle détaché pour des coordonnées valides en base 1, en résolvant les styles stockés et packés, les défauts de feuille, les superpositions de styles applicables, les formats de dates implicites, les couleurs indexées et les couleurs de thème sans matérialiser de cellules ni changer les pools de styles ; l'appel public acquiert un bail de lecture et exclut les règles de mise en forme conditionnelle et de styles de tables

TXLSXWorksheet.GetStoredAxisSpans(IsRow) renvoie TXLSXAxisSpans, un tableau d'enregistrements TXLSXAxisSpan avec FirstIndex et LastIndex inclusifs en base 1 ; il signale les empreintes de métadonnées de taille, masquage, plan et repli, préserve les étendues compactes de hauteurs de lignes répétées, et laisse le défaut effectif de la feuille disponible via ses propriétés ordinaires

Les étendues renvoyées décrivent des empreintes de métadonnées stockées plutôt qu'une partition normalisée disjointe ; les applications comparant deux axes peuvent combiner leurs frontières premières et dernières, puis inspecter l'état effectif une fois par intervalle résultant

TXLSXWorksheet.GetStoredStyleRegions renvoie des TXLSXStyleRegions détachées contenant les frontières inclusives FirstRow, FirstCol, LastRowet LastCol des empreintes compactes de mise en forme virtuelle ; ces empreintes peuvent se chevaucher, et les appelants lisent leur apparence effective avec ReadSemanticCellStyle

TXLSXWorkbook.ReadSemanticFeatures(Kind, Sheet, MaxBytes, MaxItems) renvoie des entrées détachées TXLSXSemanticFeatures avec une Key stable, des octets canoniques de Definition, et un ItemCount compté ; les limites positives facultatives valent 64 Mio et 1 000 000 d'entrées par défaut

TXLSXSemanticFeatureKind contient xlsxSemanticDefinedNames, xlsxSemanticDataValidations, xlsxSemanticConditionalFormats, xlsxSemanticTables, xlsxSemanticDrawings, xlsxSemanticPivotTables, xlsxSemanticPivotCaches, xlsxSemanticSlicers, xlsxSemanticSlicerCaches, xlsxSemanticTimelineset xlsxSemanticTimelineCaches

Les noms définis et les trois genres de caches utilisent une portée à l'échelle du classeur et permettent une feuille nil ; les autres genres exigent une feuille appartenant au classeur, les règles et dessins conservent leur séquence stockée, et les tableaux et tampons renvoyés sont des copies détenues par l'appelant ; ces lecteurs acquièrent des baux de lecture et héritent de la couverture typée et du comportement explicite de données non prises en charge décrits ci-dessus

TXLSXWorksheet.ReadSemanticRichText(Row, Col, IncludePlainText, MaxBytes, MaxItems, ConsumedItems) renvoie les octets canoniques détachés de segments pour des coordonnées en base 1, ou un tampon vide quand aucun texte enrichi n'existe et que IncludePlainText est false ; le ConsumedItems: PInteger facultatif reçoit le nombre de segments capturés, et la capture de texte simple retient le stockage packé

TXLSPivotCacheField.GroupItemTypes[Index] expose le genre typé correspondant à GroupItemLabels[Index] et rejette un index hors du domaine d'étiquettes groupées stocké

Métadonnées de formules et callbacks de requêtes de tableaux croisés dynamiques

TXLSGetCellFormulaText et TXLSCalculator.OnGetCellFormulaText lisent le texte d'expression stocké avec un SheetIndex en base 1 et des Row/Col en base zéro, en renvoyant lxOk ou un code d'erreur typé et en respectant la protection de masquage des formules ; TXLSGetPivotTable et OnGetPivotTable localisent une table empruntée avec un SheetIndex en base 1 et des coordonnées de plage en base zéro

Les moteurs de classeurs câblent ces callbacks facultatifs dans les contextes de calcul normal, en lecture seule et isolé ; les callbacks ne recalculent pas les cibles, ne rafraîchissent pas les sources de tableaux croisés dynamiques et ne transfèrent pas de propriété

TXLSPivotDataConstraint stocke un FieldName et un Item typé, avec TXLSPivotDataConstraints collectant les paires champ/élément ; TXLSPivotTable.GetDataValue interroge un agrégat visible pris en charge depuis un instantané détaché de table/cache et IntersectsQueryRange utilise des bornes de feuille en base 1, cellules de filtres de rapport modélisées comprises

TlxPivotQueryBudget reçoit synchroniquement des estimations de travail et de mémoire et renvoie si l'évaluation peut continuer ; EXLSPivotQueryBudget et EXLSPivotQueryUnsupported distinguent les limites épuisées des modèles de caches ou d'agrégats non pris en charge

TXLSPivotCache.QueryModelIsComplete enregistre la préparation décodée des requêtes indépendamment de la complétude de la relecture brute BIFF ; QueryRecordsValid expose la validité des enregistrements importés et SetQueryRecordValidity applique la précédence du lecteur de format sans rafraîchir les enregistrements

Octets de pages de codes explicites

Passez le RawByteString renvoyé directement à AddRawString ou à une opération de flux orientée octets ; le convertir en AnsiString par défaut peut recoder ses octets sur les systèmes FPC natifs

Noms définis classiques et blocs de formules matricielles

Pools classiques de polices, de formats et de styles

Assistants de package et de stockage binaire

Ajouts de dessin et de visionneuse de classeur

Pagination, sortie d'images et impression

Modèles de graphiques classiques et objets graphiques de feuille de calcul

Modèle de décodage typé des graphiques

L'état décodé du graphique est exposé sous forme d'enregistrements et d'énumérations simples afin que le code d'inspection n'ait jamais à parcourir les enregistrements BIFF bruts : TXLSChartInfo porte le résumé décodé du graphique avec TXLSChartTypeFamily (cfBar, cfLine, cfPie, cfArea, cfScatter, cfRadar, cfDoughnut, cfSurface, cfBubble), chaque série signale un TXLSChartSeriesType, et TXLSChart3DState plus TXLSChart3DInfo décrivent les vues tridimensionnelles. TXLSChartAxisType (catCategory, catValue, catSeries, catDate) et TXLSChartLegendPosition classent les axes et les légendes, tandis que le modèle d'axe de dates utilise TXLSChartDateUnit (xcduDays, xcduMonths, xcduYears) et TXLSChartDateValues. TXLSCustomChart expose le modèle décodé via TXLSChartInfo; les annotations de courbes de tendance et de barres d'erreur sont des objets typés (TXLSChartTrendline, TXLSChartErrorBars) accessibles depuis chaque série

Enregistrements de création de graphiques

La création de feuilles graphiques et du builder accepte des enregistrements simples au lieu de graphes d'objets : TXLSChartTrendlineInfo, TXLSChartErrorBarsInfo, TXLSChartDataLabelsInfoet TXLSChartSeriesStyleInfo remplissent les entrées de série passées à TXLSWorksheets.AddChartSheet et au builder de graphiques partagé, et TXLSPivotChartInfo décrit l'habillage de graphique croisé dynamique utilisé lorsqu'un graphique est rattaché à un tableau croisé dynamique

Inspection des remplissages de graphiques classiques

TXLSCustomChart.GetChartModel décode les tables de propriétés OfficeArt natives prises en charge et les tables de propriétés tertiaires dans les enregistrements GelFrame, y compris les propriétés qui suivent des entrées de charges complexes ; la représentation existante du builder reste prise en charge, et des bornes de tables malformées laissent le remplissage typé antérieur inchangé et signalent l'enregistrement non pris en charge

L'inspection de graphiques valide la charge complète stockée de texte et d'annotations avant d'ajouter un état typé : des noms de courbes de tendance ou des séparateurs d'étiquettes de données tronqués signalent leur identifiant d'enregistrement via _UnsupportedSemanticRecordID, tandis que des en-têtes SeriesText nil ou trop petits signalent cet enregistrement comme non pris en charge pour BIFF5 comme pour BIFF8 ; une étendue déclarée de texte de série qui dépasse sa charge lève EReadError, libère le modèle partiel et laisse les enregistrements de graphiques stockés inchangés

Le getter de marqueurs et l'inspection de remplissages préservent le stockage brut des graphiques ; le chemin de capture d'apparence déclarée valide séparément les graphiques principaux pris en charge, tandis que des sommes de contrôle d'extensions de titres riches ou de formes non vérifiées restent non prises en charge

Lecteurs bornés de graphiques, de chaînes et de polices stockés

TXLSChartStoredBytes est un tableau d'octets détaché et TXLSChartStoredRecord contient RecordId et Data ; ces lecteurs inspectent le stockage source retenu sans créer de modèle de graphique décodé ni évaluer de formules

Maintenance de la table de chaînes partagées et émission SST

TXLSStringTable de lxStringTable soutient les chaînes partagées du classeur classique ; les membres ci-dessous couvrent l'enregistrement côté lecteur, la maintenance d'emplacements et l'émission brute de SST pour les enregistrements aller-retour

Pièces jointes PDF, signatures et export HTML

Audit de calcul et contrôles du classeur

Compatibilité de l'habillage hérité des PivotCache

StreamId est écrit comme l'enregistrement SXStreamID ([MS-XLS] §2.4.303) et répété comme le champ SXDB de l'en-tête idstm , qui doit lui être égal ; SourceDataType est écrit comme l'enregistrement SXVS ([MS-XLS] §2.4.317 : $0001 feuille de calcul, $0002 externe, $0004 consolidation, $0010 scénario) et répété comme le champ SXDB de l'en-tête vsType , qui doit lui être égal. Les caches construits à partir d'une plage de feuille de calcul démarrent au type feuille de calcul, tandis que les caches relus depuis un fichier conservent la valeur portée par leur sous-flux, de sorte que l'enregistreur BIFF ne laisse jamais un champ SXDB nommer un enregistrement qu'il n'a pas émis ; RawHasStorageStream marque un cache chargé depuis son propre flux de stockage dont le descripteur global de classeur précède les enregistrements en cache

Intégration du presse-papiers et options de collage

TXLSPasteOption = (xlpoValuesOnly, xlpoInsertRows, xlpoInsertCols);
TXLSPasteOptions = set of TXLSPasteOption;

function XLSGetClipboardText: WideString;
function XLSSetClipboardText(const Text: WideString): Boolean;
function XLSSetClipboardTextAndHtml(const Text: WideString;
  const Html: AnsiString): Boolean;
function XLSBuildHtmlClipboard(const Html: AnsiString): AnsiString;
function XLSEncodeClipboardField(const Text: WideString): WideString;
function XLSClipboardHasText: Boolean;
function XLSParseClipboardGrid(const ClipboardText: WideString;
  Loader: TXLSCSVLoader): Boolean;
function XLSClipboardHasXmlSpreadsheet: Boolean;
function XLSGetClipboardXmlSpreadsheet: WideString;
function XLSParseXmlSpreadsheet(const XmlText: WideString;
  Loader: TXLSCSVLoader): Boolean;
function XLSClipboardHasBiff8: Boolean;
function XLSGetClipboardBiff8: AnsiString;
function XLSReadClipboardPasteData(out Biff8: AnsiString;
  out Text: WideString): Boolean;
function XLSSetClipboardBiff8(const Biff8: AnsiString;
  const Text: WideString; const Html: AnsiString = ''): Boolean;
      

Résolution du texte d'affichage des cellules

TXLSCellDisplayMode = (xcdmFormattedValue, xcdmFormulaText,
  xcdmSuppressedZero);

TXLSCellDisplayOptions = record
  ShowFormulas: Boolean;
  ShowZeros: Boolean;
  SheetProtected: Boolean;
  FormulaWidthFactor: Double;
  DateSerialZero: Double;
end;

TXLSCellDisplayInput = record
  HasFormula: Boolean;
  FormulaHidden: Boolean;
  IsNumericZero: Boolean;
  FormulaText: WideString;
  FormattedText: WideString;
end;

TXLSCellDisplayResult = record
  Mode: TXLSCellDisplayMode;
  Text: WideString;
  TreatAsText: Boolean;
  EffectiveWidthFactor: Double;
end;

function XLSDefaultCellDisplayOptions: TXLSCellDisplayOptions;
function XLSNormalizeFormulaDisplayText(const FormulaText: WideString): WideString;
function XLSResolveCellDisplay(const Options: TXLSCellDisplayOptions;
  const Input: TXLSCellDisplayInput): TXLSCellDisplayResult;
      

Objets de validation de données classiques

TXLSDataValidationType = (xlsDvAny, xlsDvWhole, xlsDvDecimal, xlsDvList,
  xlsDvDate, xlsDvTime, xlsDvTextLength, xlsDvCustom);
TXLSDvErrorStyle = (xlsDvErrStop, xlsDvErrWarning, xlsDvErrInformation);

TDVRange = class;             { one validation rule over one or more ranges }
TDVRangeList = class;         { the per-sheet rule collection }
TDataValidator = class;       { engine that checks edits against the rules }
      

Balayage et résolution des couleurs indexées

TXLSIndexedColorKind = (xickPalette, xickAutomatic, xickSystem, xickInvalid);
TXLSSystemColorRole = (xscrNone, xscrWindowText, xscrWindowBackground,
  xscrChartText, xscrChartBackground, xscrChartNeutral, xscrToolTipText);

TXLSIndexedColorResolution = record
  Kind: TXLSIndexedColorKind;
  RawIndex: Int64;
  PaletteSlot: Integer;
  SystemColorRole: TXLSSystemColorRole;
  ARGB: LongWord;
  HasResolvedColor: Boolean;
end;

TXLSNearestIndexedColorMatch = record
  InputARGB: LongWord;
  ColorIndex: Integer;
  PaletteSlot: Integer;
  ARGB: LongWord;
  DistanceSquared: Double;
  ExactMatch: Boolean;
end;

TXLSIndexedColorUsageKind = (xicukFont, xicukFillForeground,
  xicukFillBackground, xicukGradient, xicukBorder, xicukConditionalFormat,
  xicukChart, xicukShape, xicukComment, xicukWorksheet, xicukOther);
      

Helpers de références A1

function XLSA1CellRef(ARow, ACol: Integer): WideString;
function XLSTryParseA1CellRef(const ARef: WideString;
  out ARow, ACol: Integer): Boolean;
function XLSTryParseA1RangeRef(const ARef: WideString;
  out ARow1, ACol1, ARow2, ACol2: Integer): Boolean;
      

Voir aussi

• Membres API XLS classiques supplémentaires
• Membres avancés de l'API XLSX
• Géométrie de plan clairsemée
• Traçabilité et audit des formules
• Visionneuse de classeur