Additional library API members

This page completes the reference for public types that support the primary workbook, worksheet, rendering, import, diagnostics, and viewer APIs but which do not need a separate task-oriented guide

Filtering and conditional formatting

TXLSCfValue, TXLSDataBarSpec, TXLSColorScaleSpec, TXLSIconSetSpec, and TXLSDxfStyle accept AttachWriteGuardOwner, attaching the rule object to its owning workbook so edits acquire a write guard automatically; the owner implements TXLSCondFormatWriteGuardOwner, whose single AcquireWriteGuard method hands the rule the workbook's write guard. TXLSDxfStyle adds FontColorIndex with FontColorIsIndexed plus the FillFgColorIndex / FillFgColorIsIndexed and FillBgColorIndex / FillBgColorIsIndexed pairs for palette-index rule colours, and the differential-font overrides FontName, FontSize, and FontScheme (empty string, a point size, or a theme font slot such as major / minor) alongside the existing bold, italic, underline, and colour members; each assignment acquires the write guard and marks the rule dirty for re-emission

TXLSConnections, TXLSDataTables, and TXLSQueryTables expose OnAcquireWriteGuard (type TXLSConnectionAcquireWriteGuard, TXLSDataTableAcquireWriteGuard, and TXLSQueryTableAcquireWriteGuard), the hook their edit paths use to obtain the owning workbook's IXLSWorkbookWriteGuard before mutating and to advance the workbook generation afterwards; the guard logs StartGeneration, and Complete marks the write finished so dependent caches can rebuild

Preserved data connections carry a typed description: TXLSConnectionKind (xlckUnknown, xlckOdbc, xlckDao, xlckFile, xlckWeb, xlckOleDb, xlckText, xlckAdo) classifies the connection, TXLSConnectionCredentials (xlccIntegrated, xlccNone, xlccStored, xlccPrompt) records its authentication mode, and every connection parameter value is tagged with TXLSConnectionParameterValueKind (xlcpvNone, xlcpvBoolean, xlcpvDouble, xlcpvInteger, xlcpvString, xlcpvCell). What-if data tables report their stored definition kind through TXLSDataTableKind

What-if data tables and pivot grouping

Icon-set thresholds can be rendered or validated programmatically: XLSCfIconSetCount reports how many icons a TXLSIconSetType defines, and XLSBuildCfIconGeometry fills a TXLSCfIconGeometry with the primitives (TXLSCfIconPrimitive, kind TXLSCfIconPrimitiveKind: cfipPolygon, cfipEllipse, cfipRect, cfipLine) and points (TXLSCfIconPoint) that draw one icon, so custom renderers match Excel's built-in icon shapes

Diagnostics, formula tracing, and validation

Import validation schemas

TXLSImportCheck from lxImportCheck validates a TXLSXWorksheet against rules owned by the application; it inspects stored scalar values and stored formula results, with one-based worksheet coordinates and no implicit text-to-number, text-to-date, or text-to-Boolean conversion

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 starts checking at the next row and takes precedence over FirstRow; otherwise FirstRow defaults to 1; LastRow = 0 uses the worksheet's last used row, whilst a positive LastRow can include absent cells without creating them; columns must lie within 1 through 16,384 and active data-row bounds within 1 through 1,048,576

Column rules and explicit types

AddRule(Column) replaces and frees any previous rule for that column; the per-value type, range, length, and pattern predicates skip missing values, nulls, and empty strings, whilst irRequired reports them; uniqueness retains the distinct policies described below; nonempty whitespace still counts as a value; a number does not qualify as a Boolean, a date does not qualify as an ordinary number, and a numeric-looking string stays text

Assigning MinimumValue or MaximumValue enables that bound; either HasMinimum or HasMaximum can disable it again; both inclusivity switches default to True; bounds must be finite typed numbers or dates, and two bounds must be comparable and describe a nonempty interval; reversed, missing, incompatible, or empty bounds raise before any worksheet validation starts

Number bounds compare numeric values whilst date bounds compare dates; integer-to-integer comparisons preserve all Int64 and UInt64 bits; values of an incompatible category fail the range check; text length and regex predicates continue to inspect the scalar's text representation, and regex checks retain the existing IsMatch behaviour, so use anchors such as ^...$ when the complete text must match; an invalid regex turns off its pattern check for compatibility

Date-formatted Excel values

A cell imported from Excel can contain a numeric serial even when its number format displays a date; choose a serial mode explicitly when the accepted import schema calls for one; the mode affects validation only and never alters the stored cell value

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 is declared in Variants and EncodeDate in SysUtils; numeric serials must be nonnegative and resolve before January 1, 10000; fractional serials retain their time-of-day; the 1900 system rejects every serial from 60 inclusive through 61 exclusive since that interval denotes the fictitious leap day; the 1904 system maps serial zero to January 1, 1904

Date bounds include the time of day, so a maximum set to midnight on December 31 excludes later times on that day; use an exclusive upper bound at January 1 of the following year when the whole of the final day must be accepted; textual dates such as 10/08/2026 remain text regardless of the configured serial mode

Composite uniqueness and cross-column comparisons

Composite keys retain each member's exact Variant type and text identity; Integer(1), Double(1), the string '1', a Boolean, and a date are distinct members; there is no case folding, Unicode normalisation, locale parsing, or delimiter ambiguity; combinations such as ('ab', 'c') and ('a', 'bc') remain different; each validation pass starts a fresh tuple index

When SkipIncompleteRows = True, a missing, null, or empty-string member leaves that row out of tuple uniqueness; setting it to False includes those members with their original Variant identities; a duplicate reports the first tuple column as its cell address together with the first matching row via FirstDuplicateRow

The existing single-column irUnique retains its text-based, case-insensitive matching behaviour and skips missing or null values; use AddUniqueRule([Column]) when strict typed identity is required for one column

Cross-column comparisons never coerce strings to numbers, numbers to Booleans, or ordinary numbers to dates; mismatched incompatible categories fail even for icNotEqual; string comparisons distinguish composed and decomposed Unicode, preserve embedded null characters, and order shorter prefixes first; when SkipBlankValues = False, either blank operand produces a cross-column violation

Structured results and correction workbooks

Check(Sheet) returns the number of violations, and ViolationCount plus zero-based Violation(Index) enumerate the report; one column rule reports its first failing predicate, whilst independently configured tuple and comparison rules can add further violations for the same cell; assign meaningful Name values when callers need stable application rule identifiers

Formula cells are validated from their stored cached values; a formula lacking a stored cached result reports ivFormulaCacheMissing, and an error result reports ivCellError; explicitly recalculate before checking when fresh formula results are required; validation never reaches external sources, alters formula definitions, or evaluates uncached formulas

OnVerifyCell retains the TlxImportVerifyCell callback signature and runs after successful applicable column predicates and uniqueness checks; it returns a Boolean and can set an application error message; callbacks must keep the workbook and validation schema unchanged, and workbook writes are refused by the read lease; callback exceptions propagate and the lease is freed again for subsequent operations

Check never annotates, deletes rows, or materialises packed values; use Annotate after checking to apply red fonts and append error text to existing comments, or else explicitly call KeepOnlyViolations to remove nonviolating rows and create a correction workbook; these methods alter the supplied worksheet, so call them on the intended workbook after studying the report

Validation borrows the worksheet and workbook for the synchronous call; it does not take over the caller's object ownership or require an interface-owned workbook; a read lease shields the relevant stored-cell snapshots and stored formula-cache access throughout the check

External link save policies

TXLSExternalLinkUpdateMode = (xluPromptUser, xluNever, xluAlways);

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

Calculation audit and workbook hints

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;
      

Table formula and IME state

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

Web Add-in task pane inspection and removal

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

Workbook object display policy

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;
      

Render calibration values and snapshots

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;
      

Render geometry and font measurement

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;
      

Import, code generation, comparison, and monitoring

Workbook comparison

TXLSXWorkbookCompare in lxCompare compares two TXLSXWorkbook instances without recalculating formulas or modifying either workbook; sheets are paired by case-insensitive name, and sheet order changes on their own do not produce a difference

The default Options value is empty and both tolerances default to zero; default comparison reports added or removed sheets, added or removed stored cells, changed typed literal values, changed formula text, and merged ranges that were added or removed

Literal comparison tells numbers, text, Boolean values, dates, errors, and blanks apart: the number 1 differs from the text '1', a Boolean differs from its text spelling, dates retain their own type, and errors compare by their stored error code; numeric storage types with equal values compare equally, whilst distinct Int64 values remain distinct during exact comparison

Options has type TlxCompareOptions, a set of TlxCompareOption; enabling an option adds its differences to the default comparison

SetFeatureLimits(MaxBytes, MaxItems) validates both positive limits before changing either setting; MaxFeatureBytes defaults to 64 MiB and MaxFeatureItems defaults to 1,000,000, and the individual setters keep the same atomic validation

Feature budgets cover the aggregate detached canonical bytes and counted entries from both workbooks, including rich-text runs, filter XML nodes, Pivot fields, domain members and record values, and slicer or timeline connections; readers check counts and large text inputs before building native XML, enforce bounded output streams, and raise EXLSXSemanticBudget when a limit is exceeded

SetNumericTolerance(AbsoluteTolerance, RelativeTolerance) validates both arguments before changing either setting; both must be finite and nonnegative, and the separate AbsoluteTolerance and RelativeTolerance setters apply the same validation

Numeric literal and numeric cache values compare equally when their absolute difference is within AbsoluteTolerance or their difference relative to the larger absolute value is at most RelativeTolerance; a threshold of zero keeps exact equality, the relative calculation avoids overflow for extreme opposite values, and tolerance never coerces text or applies to dates, styles, or geometry

LeftName and RightName set optional display names used by Report lines, defaulting to left and right; the names affect reporting only, not sheet pairing or comparison

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 returns the difference count, Count reads that count afterward, and Diff(Index) uses zero-based indexing to return a comparer-owned TlxCompareDiff; retain the comparer whilst reading its entries, and reacquire entries after another successful comparison

Each entry provides Kind, Sheet, one-based Row and Col where applicable, Ref, LeftText, RightText, and typed LeftKind / RightKind values; TlxCompareValueKind contains lcvNone, lcvBlank, lcvNumber, lcvText, lcvBoolean, lcvDateTime, lcvError, and lcvFormula, with lcvNone used for an absent side or a non-value difference

TlxCompareKind retains lckSheetAdded, lckSheetRemoved, lckCellAdded, lckCellRemoved, lckValueChanged, lckFormulaChanged, lckMergeAdded, and lckMergeRemoved, and adds lckFormulaCacheChanged, lckStyleChanged, lckRowGeometryChanged, and lckColumnGeometryChanged

Style differences carry stable canonical style fingerprints in LeftText and RightText; geometry differences hold the compared size, hidden, outline, and collapsed state, with Ref naming the affected contiguous axis interval, Row set to its first row and Col to zero for rows, or Col set to its first column and Row to zero for columns

Feature differences use lckDefinedNameChanged, lckDataValidationChanged, lckConditionalFormatChanged, lckTableChanged, lckDrawingChanged, lckPivotTableChanged, lckPivotCacheChanged, lckSlicerChanged, or lckTimelineChanged; Change is lccChanged, lccAdded, or lccRemoved, and each present side carries its canonical definition fingerprint whilst an absent side carries an empty string

lckRichTextChanged identifies a changed run definition at its cell coordinate and takes canonical run fingerprints in LeftText and RightText; numeric tolerance applies to cell literals and formula caches, whilst typed feature definitions compare exactly

Feature references identify scoped names or table names, or use one-based sequence positions for validation, conditional-format, and drawing definitions; inserting or moving an ordered feature can change several positions, whilst workbook-level name entries have an empty Sheet

lckBlankStyleRegionChanged identifies a changed blank rectangle through Row, Col, inclusive LastRow and LastCol, and its A1 Ref; stored coordinates are covered by ordinary cell comparison and lcoCellStyles, so switch on both style options to inspect stored cells and blank areas together

Describe formats one entry, whilst Report(List) appends the formatted entries to a caller-owned TStrings; a typed value change includes type labels when the types differ, and results are sorted by sheet name, row, column, difference kind, and reference rather than cell insertion order

Comparison holds read leases, walks stored cells through detached cursor snapshots, and retains packed storage; geometry partitions stored metadata boundaries and compact repeated-row spans, whilst blank-style comparison sweeps active rectangle and stored-cell boundaries without scanning a rectangular million-row grid; work grows with stored features, region intersections, and reported differences

A failed comparison preserves the previous successful result; invalid tolerance assignment also preserves the existing settings and result, whilst passing a nil workbook clears the result and returns zero

This comparison covers the XLSX facade's stored cell content and selected typed feature definitions; name, validation, conditional-format, table, and chart formula spelling normalises through the semantic formula parser, whilst Pivot calculated formulas retain their stored definition text

Table filters accept supported custom, value-list, date-group, colour, icon, dynamic, and top-count shapes and sort conditions; independent filter columns and value-set entries normalise their order, Boolean defaults and numeric spellings normalise, and sort-condition order remains significant

Typed Pivot, slicer, and timeline comparison resolves supported local worksheet sources and non-OLAP bindings without refreshing or evaluating availability; native slicer availability hints are derived display metadata, whilst member selections and recognised native sort metadata are compared

Opaque native drawing properties, incomplete binary Pivot models, external or OLAP Pivot sources, raw PivotTable supplemental records and extension XML, unknown filter XML, and unmodelled slicer or timeline extension attributes or children raise EXLSSemanticSnapshot; preservation of such data does not imply semantic equivalence

Selected imported PivotTable and PivotCache features also validate preserved native XML before comparing the typed projection, including nested field metadata and cache records; unknown namespaces, attributes, children, and extension payloads fail explicitly within the same cooperative feature limits, whilst modelled slicer cache bindings remain supported

TSimpleDomNode.RawName exposes the original element QName alongside the reader-normalised Name, permitting namespace-sensitive inspection without changing existing parser name matching

Workbook settings and opaque package metadata remain outside comparison; base style comparison does not evaluate conditional-format or table-style appearance, and drawing comparison keeps the semantic snapshot's supported image, text-box, chart, and ordered-group boundaries

Effective rich-text properties

TMsoFbtOpt.StoredPids returns stored OfficeArt property identifiers in sorted order, whilst TMsoFbtSp.PersistentFlags exposes native shape flags without allocating properties or anchors

TMsoShapeContainer.HasPreservedObjectData identifies retained OBJ tail bytes; HasOrdinaryEmbeddedPictureObjectData checks that picture tails contain only recognised clipboard-format and zero picture-flag records, and rejects linked or unknown records without copying the payload

TMSOShapeTextBox.HasValidTextRuns checks stored TXO run boundaries and reserved fields without creating runs; TMsoDrawing.HasUnmodeledAppearance identifies native drawing data skipped by the typed parser, letting capture reject unresolved appearance explicitly

TXLSXRichTextRun.BoldSet, ItalicSet, StrikethroughSet, UnderlineSet, VertAlignSet and ColorSet distinguish inherited font properties from explicit overrides, including false flags, none, baseline and automatic colours; setters mark the property explicit even when its value equals the new run's initial default

TXLSXRichText.HasUnsupportedAppearance reports native rich properties that the typed run model cannot represent; portable capture and effective rich-text comparison reject such runs explicitly, whilst supported shared/inline run properties and whitespace retain their imported semantics

Effective rich-text comparison applies explicit false overrides before coalescing adjacent equal runs; inherited and explicitly cleared properties stay distinct during shared-string deduplication and supported XML roundtrips

TXMLReader.ResolveNamespaceUri(Prefix, Uri) resolves the current in-scope namespace binding without altering reader position, returning false when no binding exists; an empty prefix requests the default namespace, and raw QNames stay available for namespace-sensitive inspection

The immutable rich/scene records, capture-source extension and HXRSNP02 transfer contract are described in Portable headless output

Detached style and axis inspection

TXLSXWorksheet.ReadSemanticCellStyle(Row, Col) returns a detached TXLSSemanticCellStyle for valid one-based coordinates, resolving stored and packed styles, worksheet defaults, applicable style overlays, implicit date formats, indexed colours, and theme colours without materialising cells or changing style pools; the public call acquires a read lease and excludes conditional-format and table-style rules

TXLSXWorksheet.GetStoredAxisSpans(IsRow) returns TXLSXAxisSpans, an array of TXLSXAxisSpan records with inclusive one-based FirstIndex and LastIndex; it reports size, hidden, outline, and collapsed metadata footprints, keeps compact repeated-row height spans, and leaves the worksheet's effective default reachable through its ordinary properties

The returned spans describe stored metadata footprints rather than a disjoint normalised partition; applications comparing two axes can combine their first and last boundaries, then inspect the effective state once per resulting interval

TXLSXWorksheet.GetStoredStyleRegions returns detached TXLSXStyleRegions containing inclusive FirstRow, FirstCol, LastRow, and LastCol boundaries for compact virtual-formatting footprints; such footprints can overlap, and callers read their effective appearance with ReadSemanticCellStyle

TXLSXWorkbook.ReadSemanticFeatures(Kind, Sheet, MaxBytes, MaxItems) returns detached TXLSXSemanticFeatures entries with a stable Key, canonical Definition bytes, and counted ItemCount; optional positive limits default to 64 MiB and 1,000,000 entries

TXLSXSemanticFeatureKind contains xlsxSemanticDefinedNames, xlsxSemanticDataValidations, xlsxSemanticConditionalFormats, xlsxSemanticTables, xlsxSemanticDrawings, xlsxSemanticPivotTables, xlsxSemanticPivotCaches, xlsxSemanticSlicers, xlsxSemanticSlicerCaches, xlsxSemanticTimelines, and xlsxSemanticTimelineCaches

Defined names and the three cache kinds use workbook-wide scope and permit a nil sheet; the other kinds require a worksheet belonging to the workbook, rules and drawings retain their stored sequence, and returned arrays and buffers are caller-owned copies; these readers acquire read leases and inherit the typed coverage and explicit unsupported-data behaviour described above

TXLSXWorksheet.ReadSemanticRichText(Row, Col, IncludePlainText, MaxBytes, MaxItems, ConsumedItems) returns detached canonical run bytes for one-based coordinates, or an empty buffer when no rich text is present and IncludePlainText is false; optional ConsumedItems: PInteger receives the captured run count, and plain-text capture retains packed storage

TXLSPivotCacheField.GroupItemTypes[Index] exposes the typed kind corresponding to GroupItemLabels[Index] and rejects an index outside the stored grouped-label domain

Formula metadata and Pivot query callbacks

TXLSGetCellFormulaText and TXLSCalculator.OnGetCellFormulaText read stored expression text using a one-based SheetIndex and zero-based Row/Col, returning lxOk or a typed error code and honouring formula-hidden protection; TXLSGetPivotTable and OnGetPivotTable locate a borrowed table through one-based SheetIndex and zero-based range coordinates

The workbook engines wire these optional callbacks in normal, read-only and isolated calculation contexts; callbacks never recalculate targets, refresh Pivot sources or take over ownership

TXLSPivotDataConstraint stores a FieldName and typed Item, with TXLSPivotDataConstraints collecting field/item pairs; TXLSPivotTable.GetDataValue queries one visible supported aggregate from a detached local table or cache snapshot and IntersectsQueryRange uses one-based worksheet bounds including modelled report-filter cells

TlxPivotQueryBudget receives work and memory estimates synchronously and reports whether evaluation can continue; EXLSPivotQueryBudget and EXLSPivotQueryUnsupported distinguish exhausted limits from unsupported cache or aggregate models

TXLSPivotCache.QueryModelIsComplete records decoded query readiness separately from BIFF raw replay completeness; QueryRecordsValid exposes imported record validity and SetQueryRecordValidity applies format-reader precedence without refreshing records

Explicit code-page bytes

Pass the returned RawByteString directly to AddRawString or a byte-oriented stream operation; converting it to a default AnsiString can recode its bytes on native FPC systems

Classic defined names and array-formula blocks

Classic font, format, and style pools

Package and binary storage helpers

Drawing and workbook viewer additions

Pagination, image output, and printing

Classic chart models and worksheet chart objects

Typed chart decode model

The decoded chart state is exposed as plain records and enums so inspection code never needs to walk raw BIFF records: TXLSChartInfo carries the decoded chart summary with TXLSChartTypeFamily (cfBar, cfLine, cfPie, cfArea, cfScatter, cfRadar, cfDoughnut, cfSurface, cfBubble), each series reports TXLSChartSeriesType, and TXLSChart3DState plus TXLSChart3DInfo describe three-dimensional views. TXLSChartAxisType (catCategory, catValue, catSeries, catDate) and TXLSChartLegendPosition classify axes and legends, whilst the date-axis model uses TXLSChartDateUnit (xcduDays, xcduMonths, xcduYears) and TXLSChartDateValues. TXLSCustomChart exposes the decoded model through TXLSChartInfo; trendline and error-bar annotations are typed objects (TXLSChartTrendline, TXLSChartErrorBars) reachable from each series

Chart authoring records

Chart-sheet and builder authoring takes plain records instead of object graphs: TXLSChartTrendlineInfo, TXLSChartErrorBarsInfo, TXLSChartDataLabelsInfo, and TXLSChartSeriesStyleInfo fill the series entries passed to TXLSWorksheets.AddChartSheet and the shared chart builder, and TXLSPivotChartInfo describes the pivot-chart framing applied when a chart is attached to a pivot table

Classic chart fill inspection

TXLSCustomChart.GetChartModel decodes supported native OfficeArt property tables plus tertiary property tables in GelFrame records, including properties following complex payload entries; the existing builder representation stays supported, and malformed table bounds leave the prior typed fill unchanged and report the unsupported record

Chart inspection validates the complete stored text and annotation payload before adding typed state: truncated trendline names or data-label separators report their record ID via _UnsupportedSemanticRecordID, whilst nil or undersized SeriesText headers report that record as unsupported under both BIFF5 and BIFF8; a declared series-text extent that exceeds its payload raises EReadError, frees the partial model and leaves the stored chart records unchanged

The marker getter and fill inspection preserve raw chart storage; the declared appearance capture path separately validates supported core charts, whilst unverified rich title or shape extension checksums remain unsupported

Bounded stored chart, string and font readers

TXLSChartStoredBytes is a detached byte array and TXLSChartStoredRecord contains RecordId and Data; these readers inspect retained source storage without building a decoded chart model or evaluating formulas

Shared string table maintenance and SST emission

TXLSStringTable in lxStringTable underpins the classic workbook's shared strings; the members below cover reader-side registration, slot maintenance, and raw SST emission for round-trip saves

PDF attachments, signatures, and HTML export

Calculation audit and workbook controls

Legacy PivotCache framing compatibility

StreamId is written as the SXStreamID record ([MS-XLS] §2.4.303) and repeated as the SXDB header idstm field, which must equal it; SourceDataType is written as the SXVS record ([MS-XLS] §2.4.317: $0001 worksheet, $0002 external, $0004 consolidation, $0010 scenario) and repeated as the SXDB header vsType field, which must equal it. Caches built from a worksheet range start at the worksheet type, whilst caches read back from a file keep the value their substream carried, so the BIFF writer never leaves an SXDB field naming a record it did not emit; RawHasStorageStream marks a cache loaded from its own storage stream whose workbook-global descriptor comes before the cached records

Clipboard integration and paste options

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;
      

Cell display text resolution

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;
      

Classic data validation objects

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 }
      

Indexed colour scanning and resolution

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);
      

A1 reference helpers

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;
      

See also

• Additional classic XLS API members
• Advanced XLSX API members
• Sparse outline geometry
• Formula trace and audit
• Workbook viewer