Read, write, style, and export Excel workbooks without Office automation

Native workbook I/O

Create, open, modify, and save Excel workbooks directly from Delphi or C++Builder code. No Microsoft Excel installation, COM automation, or external spreadsheet process is required

Save macro-free XLTX templates with SaveAs(FileName, xlsxOpenXMLTemplate) or the matching stream overload, including streaming output; the default save format remains unchanged

Classic XLS facade

A mature API for Excel 97-2003 (.xls) workbooks, covering the full classic object model with high-fidelity BIFF8 round-trip, and reading legacy Excel 2.0/3.0/4.0 (BIFF2-4) files for their values

• Indexed formula-output intervals avoid repeated scans of preceding rows when rebuilding large dependency graphs, including references to array outputs and dependencies spanning worksheets
• Classic XLS saving preserves loaded or calculated formula caches, including shared and array formula roots; missing caches retain the calculation fallback, while explicit Recalculate refreshes existing values
• Scalar defined-name references intersect single-row or single-column ranges at the formula cell, while aggregate and lookup range arguments retain full ranges; recalculation avoids false range cycles, prioritizes finalized lookup caches, and preserves floating-point precision in mixed integer and floating-point arithmetic
• XLSX round trips retain dynamic print-area formulas, qualified range unions, and the required zero-valued phonetic font index; generated and preserved parts share unique content-type declarations, while custom properties and opaque root relationships retain distinct relationship IDs
• Classic XLS retains absent imported margin records until the corresponding margin is explicitly set, without changing default margin output for new workbooks
• AGGREGATE handles uncached errors and nested selection independently, with separate reference and computed-array semantics for options 0 through 7
• XLSX round trips retain unmodified chart XML and chart anchor offsets, conditional-format font names, sizes, schemes, explicit style flags and RGB colors, and an unspecified page orientation when only margins are set
• Full object model: workbook, worksheet, range, formula, formatting, image, hyperlink, defined name, protection, page setup, and report export
• Classic column metadata exposes outline collapse markers independently of hidden state and grouping level, preserving them through raw XLS round trips, column-format copies, and worksheet copies
• Classic page setup exposes HasSetupRecord and PrinterSettingsInitialized, preserves an untouched BIFF Setup record byte for byte, keeps an absent record absent, and initializes printer-dependent fields only when their setters require it
• XLS-to-XLSX and XLSX-to-XLS conversion carries typed page setup and opaque printer-driver bytes independently, keeps standard fields authoritative over duplicate private defaults, and rejects unrepresentable BIFF8 settings before writing the destination
• Classic XLS and XLSX workbooks expose matching SaveExternalLinkValues and UpdateLinks policies; cached external-workbook values can be omitted without deleting link definitions or in-memory caches, invalid untouched source declarations remain lossless, cross-format conversion keeps legal policy values, and update preferences never initiate file or network access
• XLSX workbooks expose exact Web Add-in task pane detection, counting, and atomic removal; the removal validates bounded internal relationship closures before mutation, preserves any part shared by another relationship, deletes owned relationship parts and stale content-type entries, prevents compressed source-copy resurrection, and remains idempotent, while Classic XLS and ODS report the operation as unsupported without package scanning
• Classic XLS and XLSX worksheets expose matching pane-aware selection and 1-based scroll methods through TXLSPanePosition; TryGetWindowScroll and ScrollWindow map the shared upper, lower, left, and right axes to each format's native two-level view state, preserve them through save, open, and worksheet copy, and reject missing panes or invalid coordinates atomically; selection snapshots remain ordered, overlapping, and caller-owned, whole-row or whole-column structural edits remap every pane while preserving active-area identity with deterministic survivor and boundary-cell fallbacks, and large area operations remain amortized linear; Classic XLS additionally aggregates consecutive selection records, preserves untouched or invalid record bodies, reports malformed groups through xlsDiagnosticSelectionRecordInvalid, and chunks selections larger than 1369 areas
• The engine-neutral lxOutline unit builds row or column outline geometry from sorted sparse spans, discovers summary-before or summary-after nodes in O(log n + k) time, and creates compressed idempotent plans for node collapse, display-level changes, nested-child preservation, and recursive child-state updates without scanning unused worksheet coordinates; both worksheet engines expose the same node query and control methods, while OpenDocument groups retain native display state and convert to XLSX summary-node markers
• Classic XLS and XLSX workbooks expose the same side-effect-free ResolveIndexedColor contract for public color indexes, BIFF icv values, and OOXML indexed colors; palette, automatic, system, and invalid tokens remain distinct, border index zero keeps its unspecified meaning, ARGB output is normalized, and operating-system colors are resolved only through an explicit caller callback
• Both workbook engines expose a side-effect-free NearestIndexedColor query backed by a mutation-aware OKLab cache; it searches only the 56 physical BIFF palette entries, returns public and physical indexes with distance and exact-match metadata, rejects partial alpha, and resolves equal-distance ties to the lowest public index
• Both workbook engines expose a deterministic, side-effect-free ScanIndexedColorUsage inventory for all 56 physical palette slots, including normalized ARGB values, definition and reference counts, consumer kinds, and preservation locks across styles, sparse cells, worksheet objects, charts, comments, and conditional formats without materializing unused cells
• Both workbook engines expose a mutation-free BuildBiffPalettePlan preview that protects indexed consumers, aggregates direct and resolved theme colors by rendered frequency, preserves existing exact matches, maps colors deterministically through OKLab, and reports source identity, slot changes, exact coverage, weighted error, and overflow quantization without changing the workbook or save behavior
• Both workbook engines can validate and atomically apply a current 56-slot plan through ApplyBiffPalettePlan, rejecting stale or tampered input before any mutation and rebuilding the perceptual matcher once; Classic workbooks additionally provide an explicit BiffPaletteSavePolicy whose default preserves historical output, whose optimization mode applies only to BIFF8, and whose failed or cancelled saves restore the original palette
• Both workbook engines expose a validated TXLSRenderCalibration value with width, height, multi-line spacing, cell-margin, screen-scaling, and measurement-DPI controls; assignment is atomic, capture returns an independent operation snapshot, defaults are deterministic, and the runtime setting is never serialized or used to resize worksheet geometry by itself
• Both workbook engines create operation-owned IXLSRenderGeometry services whose immutable calibration, workbook generation, backend, full font signature, wrap width, and text form a bounded local metric-cache identity; shared GDI measurement and pixel, point, column-width, MDW, and usable-cell-width conversions eliminate AutoFit process-global DPI and base-width caches while keeping screen scaling out of output-coordinate scaling
• Classic XLS and XLSX AutoFit capture one render-geometry snapshot per operation and apply calibrated font measurement, wrapping, line spacing, and cell margins; pagination captures the same workbook-local geometry per build, so default page sizes stay stable, later calibration changes require an explicit rebuild, and page calculation never writes stored row heights or column widths
• PDF, SVG, bitmap, print-preview, and workbook-viewer pagination identify their own render backend and retain an immutable workbook calibration for the complete operation; shared page text fitting and SVG wrapping use the operation-local bounded metric cache with complete font styles and charset identity instead of process-global measurement objects
• TDataToXLS dataset exports can include only selected fields or exclude sensitive fields while keeping headers, data rows, callbacks, and column widths aligned
• Automatic XLSX dynamic arrays resize and own their spill cells, preserve user obstructions with #SPILL!, support A1# and unary @, and recover ownership after reopening; fixed CSE formulas evaluate raw range arithmetic element by element
• Multiple-array MAP and computed-array FILTER preserve per-element errors, while XLSX rich-value metadata retains typed #SPILL! and #CALC! errors
• GetConversionReport inventories known target-format losses without mutation, and opt-in SaveAsChecked can reject them before writing; explicit xlsxOpenXMLMacroEnabledTemplate output creates XLTM packages and preserves existing VBA
• Caller-supplied TXLSQueryTableProvider implementations refresh fixed-schema query-table data transactionally, resizing table and filter ranges with bounded results, progress, cancellation, and rollback
• Automatic database queries bind bounded positional parameters from explicitly typed literals or stored worksheet cells, including Unicode, empty text, dates, nulls and available formula caches; Jet and ACE preserve typed dates without locale-dependent timestamp conversion, and refresh applies results transactionally
• Automatic Text queries refresh delimited or fixed-width files with explicit decoding, typed fields, skipped columns, configured header and starting rows, and bounded transactional updates; fixed-width positions use decoded UTF-16 code units, trim padding and retain declared columns on short records
• Import validation checks strict scalar types, numeric and date bounds, composite uniqueness and cross-column relationships against stored values and formula caches, with structured cell-addressed violations and explicit annotation or correction-workbook operations
• CELL reads actual referenced file identity, supported base number formats, alignment, locked state and column width across XLS and XLSX; INFO("recalc") reads workbook calculation mode, while unavailable Excel application environment information returns an explicit error
• Repeated report bands clone complete threaded conversations with remapped identities, and shared native pagination renders merged cell spans while chart caches refresh from supported local ranges after edits and recalculation
• Built-in formula calculation with process-wide and workbook-local user-function registries, local-name override semantics, lock-free handler invocation, OnUserFunction and OnUserFunctionEx callbacks, plus common Excel text, date, workday, engineering/base-conversion, bitwise, statistical, aggregate, math, and dynamic-array functions including broadcast array operators with per-cell errors, complete multivariable LINEST / LOGEST matrices, shaped TREND / GROWTH predictions, stable row or column SORT, stable multi-key row or column SORTBY with independent directions and array keys, array-aware CEILING.MATH / FLOOR.MATH rounding with singleton broadcasting and local errors, stable array-aware COT / ACOT / COTH / ACOTH / CSC / CSCH / SEC / SECH evaluation with local errors and overflow-safe large-input branches, overflow-checked COMBINA / PERMUTATIONA repetition calculations, memory-bounded MUNIT identity matrices, Unicode-scalar UNICHAR conversion, Thai currency text through BAHTTEXT, reference-preserving ISFORMULA inspection without target recalculation, hash-indexed row or column UNIQUE, spilled FREQUENCY results, logarithmic binary XMATCH / XLOOKUP, ISOMITTED optional-argument detection, ARRAYTOTEXT / VALUETOTEXT array conversion, validated XIRR / XNPV calculations, PDURATION / RRI investment timing and growth rates, and fractional-period VDB depreciation, plus complete LET bindings and LAMBDA closures callable through defined names and lexically captured inside LET
• Engine-neutral EvaluateFormulaAt evaluates A1 or R1C1 formula text in an explicit worksheet cell context without mutating the cell model, cache, dirty state, active sheet, or dependency graph; typed results preserve formula errors, arrays, empty values, volatility, cancellation, external-reference authorization, and stable failure categories, while IXLSFormulaEvaluationTemplate reuses an immutable compiled anchor across target cells under configurable formula-length, step, recursion, and array-memory budgets
• Classic XLS and XLSX expose matching mutation-free ValidateFormulaEntry methods, workbook-level FormulaEntryPolicy, and parsed AuditFormulaSymbols scans across cells and defined names, with faster sparse Classic XLS scans and a single symbol traversal that preserves independent function and name findings, scope, deduplication and finding order; exact empty input, formulas returning an empty string, unknown functions, unknown names, syntax failures, invalid targets, and target-format limitations remain distinct, normal formula assignment applies strict rejection or preservation atomically, preserved unknown symbols evaluate and propagate as #NAME?, UDF or defined-name changes invalidate stale dependencies, Classic BIFF stores preserved unknown calls as add-in user functions, validation recognizes registered or callback user functions, lexical and defined-name lambdas, report placeholders, registered external links, and valid structured references without invoking handlers, and dangerous external or macro-style function callbacks remain blocked before argument evaluation unless explicitly authorized
• Lossless formula-token inspection and guarded mutation for both workbook engines through TXLSFormulaTokenStream, ParseFormulaTokens, GetFormulaTokens, FormulaTokensToText, and SetFormulaTokens, with caller-owned streams, read-only token projections, raw BIFF payloads, independent reference flags, cloning, atomic reference replacement, context provenance, and validation before writeback
• One-variable row, one-variable column, and two-variable What-If data tables with isolated dependency recalculation, deleted-input errors, structural edits, worksheet copies, and BIFF8 round-trip support
• Cell scanning, template find & replace, callback range filling, direct typed array writes through ForEachCell, FindText, ReplaceText, WriteCells, and the numeric, string, and variant row and column writer methods, plus whole-sheet or single-cell ConvertFormulasToValues that freezes formulas into their calculated results while keeping the cached value
• Engine-neutral formula-cache inspection through IXLSFormulaCacheReader and each workbook engine's CreateFormulaCacheReader reports presence, loaded or calculated provenance, and blank, number, date-time, string, Boolean, or error kind without evaluating formulas, invoking user functions, decompiling tokens, or changing workbook state; lifetime leases invalidate readers safely after workbook destruction, shared-formula members retain independent caches, and XLSX and ODS preserve typed errors and explicit blank caches across reopen
• Classic IXLSWorkbook.CreateReadOnlyView and XLSX IXLSXWorkbookOwner.CreateReadOnlyView create constant-time shared-model IXLSReadOnlyWorkbookView instances with view-local active sheets, by-value stored-cell snapshots, no writable object exposure, cached formula results by default, and opt-in formula text or isolated formula evaluation; concurrent views keep recursion state, scalar and array caches, and XLSX compiled formulas private, XLSX external evaluation reads only file-local link caches, packed cells remain unmaterialized, and every view holds a read lease that rejects model writes before mutation
• From 2.384.51, TXLSReadOnlyCellSnapshot.SheetName is a readable and writable WideString property backed by shared UnicodeString storage, reducing per-cell name allocation; ordinary read and assignment syntax is unchanged, but the raw field address and previous record layout are unsupported and callers must recompile
• TXLSWorkbookWorkspace accepts revocable Classic XLS, XLSX, or ODS adapters from each engine's CreateWorkspaceWorkbook, preserves complete path or IRI identities, resolves external worksheets by name before position, and evaluates external formulas through explicit live registrations, an optional caller-controlled once-per-identity loader, typed file caches, and #REF!; concurrent load requests share one result, typed diagnostics expose failures and resource limits, compatibility registration methods remain available on both workbook facades, destroyed targets disconnect safely, and recalculation never opens a file or network resource implicitly
• TXLSWorkbookWorkspace.BuildDependencyGraph extracts one cross-workbook formula graph from registered Classic XLS, XLSX, and ODS models, keeps full workbook and worksheet identities, preserves symbolic local and external defined names, resolves local names to their concrete dependencies when possible, and stores large rectangular ranges as compact intervals; row-interval trees accelerate edge construction and dependent lookup, and graph construction reads packed XLSX storage without materializing it
• TXLSWorkbookWorkspace.Recalculate retains and incrementally dirties the shared dependency graph, schedules acyclic formula nodes in cross-workbook topological order, rejects true strongly connected formula cycles without rejecting harmless bidirectional workbook links, and shares a pass-local external-cell cache with explicit hit, miss, invalidation, and blocked-node diagnostics; same-workspace calls are serialized, removal during a pass returns a workspace-changed status through safe adapter snapshots, destruction waits for active calculation, and failed nodes remain dirty for explicit retry
• CalculateAndVerify compares stored formula results with fresh non-volatile calculations and reports worksheet, cell, formula, expected-value, and actual-value diagnostics without replacing the cache; RecalcAndVerifyEx adds the deep audit with an isolated dependency-graph result overlay, typed failure categories with bounded call stacks, progress cancellation, and an opt-in atomic apply of the recomputed values
• Deep-audit tolerances filter mismatch reports without suppressing fresh intermediate results: dependent formulas use the audited values, and explicit apply refreshes changed caches even when no mismatch is reported; absolute and relative tolerances both apply to double-precision results
• Classic XLS deep formula audits reserve traversal capacity and copy consecutive plain-double cached snapshots efficiently while preserving other Variant types and the isolated evaluation overlay
• Classic recalculation uses a lazily built dependency graph, propagates dirty inputs only to transitive dependants, recomputes volatile formulas on every pass, evaluates acyclic formulas in dependency order, and applies strongly connected component iteration for circular references; disabling full precision rounds formula and What-If data-table caches to their effective displayed numeric precision before dependants consume them
• AutoFilter, list data validation, Excel tables with header-less layouts and per-table comments plus structured-reference formula evaluation (Table[Col], column spans, [#Data] / [#All] / [#Headers] / [#Totals]), conditional-format extensions (data bar with negative-value fill and border colours, color scale, icon set) with sheet-unique priorities on save and PivotTable-scoped rules routed to the Excel 2010+ extension bucket, and chart sheets
• Text boxes, OfficeArt drawings, relationship-driven typed pivot import, filtered and grouped multi-value materialization, calculated fields, items and members, subtotals, grand totals, stable sorting, classic and extended ShowDataAs calculations, plus rich-text comments
• Transactional local Pivot cache refresh resolves rectangular, worksheet-scoped defined-name, and table sources at their current geometry, excludes physical table totals, retains source identity through worksheet moves and renames, preserves existing field and member identities across source reorder, removal, and reintroduction, keeps shared-view selections stable, handles typed error values, and rejects unsupported schemas or new unmapped discrete-group members before changing the cache
• Safe Pivot worksheet materialization evaluates an isolated cache, rejects unsafe overlaps, preserves cell objects and formatting, and tracks exact owned values across resizing, movement, and XLSX reopening
• Typed non-OLAP Pivot Slicer selection inspects and changes imported shared-member selections, intersects connected-view filters, preserves independent restrictions on other fields, and rejects ambiguous or unsupported bindings before mutation
• High-fidelity BIFF8 round-trip that preserves Excel-authored records, exact RGB and theme colors, custom views, and sharing / revision metadata
• Password-protected workbooks via BIFF8 RC4 encryption, plus Agile-encrypted XLSX save and load with a verified data-integrity HMAC over the encrypted package, and classic write reservations (SetModifyPassword) carrying the recommend read-only flag, password hash, and reserving user name
• Merged-cell AutoFit overloads can assign required row or column growth to the first member, the last member, or distribute it evenly across the merged span while preserving hidden state and honoring per-member bounds
• Cross-workbook worksheet copy (TXLSWorksheets.AddCopy) that clones cell values, formulas (recompiled against the destination's sheet names), formats with exact RGB / theme colors, merged cells, comments, hyperlinks, row and column layout, frozen panes, protection, page setup, tab color, conditional formats, data validations, AutoFilter criteria, tables, embedded pictures, rich-text runs (with their fonts migrated by value), and chart sheets (with series references recompiled against the destination) into another workbook; formulas whose sheets are missing in the destination re-point at the source workbook as an external link when it has a file identity
• Shared-cache Pivot views, local Pivot Slicer creation and explicit selection-aware removal, fixed grouped-cache refresh and native compact layout metadata previews
• Transactional native Pivot worksheet output supports grouped layouts and custom row subtotals; local SUM calculated fields and cache-owned items preserve context sums, solve order, supported display calculations and filtering, while unsupported states reject before mutation
• Pivot Timelines and Slicer data states provide guarded local date filtering, shared-view lifecycle and explicit native no-data item refresh
• Automatic query providers refresh supported Text, ADO, ODBC and Web queries explicitly, with bounded results and registered custom providers
• Classic chart inspection decodes supported native OfficeArt fill tables, exposes marker diameters in points and validates stored text and annotation extents before applying typed state; raw chart storage is retained and portable Classic chart appearance remains separately validated
• Portable headless output captures supported Classic XLS or XLSX rectangles into immutable snapshots and renders PDF, SVG and PNG on Linux and macOS with explicit font geometry, rich text, modeled drawing objects, in-cell images, Boolean checkboxes, supported cached XLSX charts and bounded core BIFF8 cached charts with caller-declared layout and effective legend size
• Text and statistical calculated-array arguments preserve function-specific coercion and errors, pair covariance by original positions, and honor calculation budgets
• Defined names in aggregate calculations preserve scalar, array and reference coercion, typed errors, dependencies and resource limits

Modern XLSX facade

A dedicated OOXML engine built around TXLSXWorkbook for Excel 2007+ (.xlsx) workbooks

• Shared strings, styles, drawings, sheet features, ZIP/XML packaging, and round-trip metadata, including field-aware SpreadsheetML Xstring handling that preserves control characters and literal _xHHHH_ tokens without rewriting formula syntax
• Worksheet page setup retains byte-exact binary printer settings through the pageSetup relationship and per-sheet printerSettingsN.bin part, accepts nonstandard source part locations, writes deterministic canonical targets, deep-copies the payload across same-workbook and cross-workbook worksheet copies, and reports missing, mistyped, or dangling printer relationships without binding an unrelated binary part
• Typed numeric, string, and variant row and column writers grow cell capacity geometrically across repeated batches, append forward row batches directly into pre-sized sparse row vectors, clip safely at worksheet limits, preserve stable handles on overlap, and avoid callback dispatch
• OpenDocument (.ods) read and write: import existing spreadsheets through Open / OpenODS, export via SaveAsODS or SaveAs(xlsxOpenDocumentSpreadsheet), tune output with TODSExportOptions, and round-trip styles, rich text, images, charts, validations, conditional formats, page setup, print ranges, outline groups, sheet structure, and workbook metadata; export options retain the normal recalculation, progress cancellation, diagnostics and write protection, and file output preserves the existing destination on serialization failure or cancellation
• ODS cell comparison and expression rules preserve differential font styling, solid or transparent backgrounds, and supported number formats across complete whole-row, whole-column and wide targets using compact repeated blank carriers; explicit cleared attributes survive, unrelated base formatting stays on each cell, and theme or indexed colors export as resolved colors
• Multi-format import: OpenDocument (.ods) and CSV / TSV with separator sniffing, BOM detection, and optional value type inference
• Content-signature detection: DetectExcelContentFormat inspects a file's or stream's leading bytes to tell BIFF compound files, OOXML packages, OpenDocument packages, and plain delimited text apart regardless of file extension, and both workbook engines reject mismatched containers with a clear message naming the right loader
• Formatted display text: the read-only FormattedText property (on IXLSRange and TXLSXCell) renders a cell's value through its number format — separators, percentages, date/time masks, multi-section masks, boolean formats — matching what Excel shows in the grid
• File change monitoring: TXLSFileMonitor watches a workbook on disk and fires OnFileChanged when another process saves over it, with a configurable poll interval and main-thread or watcher-thread event delivery; handlers may stop or destroy the monitor, or switch the watched file
• Password prompting: the classic XLS engine's OnPassword event asks the application for a password when Open meets an encrypted workbook with a missing or wrong password, and retries the open
• Format brush: TXLSXCellFormat describes font, fill, border, alignment, number format, and protection once, then stamps cells, ranges, rows, columns, or whole sheets — only touched aspects apply, and pool indices are resolved once per apply for fast bulk formatting
• Unified streaming rows: TXLSRowCursor walks .xls, .xlsx, .xlsm, .ods, CSV, or TSV sources row by row (FindFirst / FindNext) holding only the current projected row or ODS repeat template in memory, pushing row bounds and column selection before value allocation, preserving cached formula results and stored styled blanks, distinguishing formula presence from formula-text availability, optionally suppressing formula text, skipping ODF covered cells, jumping directly between selected columns in repeated ODS spans, decoding UTF-8 or UTF-16 BOMs and multiline quoted text records, sniffing comma, semicolon, tab, or pipe delimiters, and providing constant-time ValueByCol lookup; explicit lifecycle states, idempotent cancellation, borrowed or transferred stream ownership, generation-checked zero-copy row views, PeakRowBufferedBytes, and SheetPassesStarted make long-running scans observable and safe, while TXLSForwardReader adapts the same backends to one-based sheet and cell callbacks without opening skipped worksheet parts
• Progress and diagnostics: classic XLS and XLSX workbooks provide work callbacks plus begin/work/end callbacks with cancellation, while IXLSWorkbookProgress and TXLSXWorkbook.Diagnostics expose stable codes, severity, operation, sheet or package context, native return values, and exception details
• Failure-safe saves: classic worksheet, chart, style-extension, VBA, control-stream, storage, and output commit failures propagate to the caller, while XLS, XLSX, and ODS disk output is staged before the destination is atomically replaced
• Windows destination replacement tolerates metadata and reader handles that allow deletion on filesystems supporting POSIX rename, while existing readers retain the original bytes; delete access, non-delete-sharing locks and readonly protection are checked before a single commit, with no save retry, and older or unsupported filesystems retain the legacy commit path
• Actionable file-save diagnostics: TXLSXWorkbook.SaveAs(FileName) and its explicit-format overload preserve the native Windows error when destination replacement fails, with diagnostic code 1005 and the original destination left intact
• Compact cell and style storage: XLSX cells live in 256-row blocks with stable public handles and row-major cache-friendly serialization; row entries carry no redundant payload tag, and value, formula, and rich-text changes avoid index reclassification; imported cell styles resolve through one immutable direct-index cellXf array; and automatic style-pool compaction drops unreferenced fonts, fills, borders, number formats, alignments, and protections before every save
• Interval style overlays: row, column, and rectangle formatting stays compact without materializing empty cell objects, resolves lazily on cell access, survives structural edits, and round-trips as compact column, row, and style-only cell entries
• Row-streamed normal save: StreamingWrite (the default) writes each worksheet row directly into the package deflate stream so peak memory follows the largest single row, while shared strings and auxiliary XML parts stream one entry at a time through a single reusable UTF-8 serializer
• Metadata-only open: TXLSXWorkbook.MetadataOnly parses workbook properties, defined names, sheet names and visibility states, styles, theme, connections, and external links, but skips worksheet cell XML plus shared strings, comment and person data, worksheet relationships, drawings, charts, tables, query tables, pivots, and worksheet-reachable opaque payloads for fast low-memory property and name discovery from large workbooks
• XLSX external-workbook slots follow workbook.xml declaration order and retain empty placeholders for broken relationships, keeping later [N] formula references stable across load and save
• Selective worksheet loading: TXLSXWorkbook.SelectedSheets lets Open parse cell XML only for named sheets, while other sheets keep their names and visibility but no cells; call LoadSheet(Index) to materialize a skipped sheet on demand from the original archive
• Incremental compressed-part copy: TXLSXWorkbook.PreserveRawParts opens one private validated source archive per SaveAs operation and copies unchanged theme, VBA project, connection, external-link, image, chart, pivot-table, pivot-cache, and relationship-reachable opaque entries with their original compressed payloads; successful file saves become the next clean baseline, while stream-backed workbooks, changed source files, modified payloads, unsupported compression methods, and compressed-size mismatches use transactional serialization fallback or rejection paths
• Workbook extension preservation: XLSX open and save retain foreign workbook-root namespace declarations, markup-compatibility attributes, complete workbook-level <extLst> payloads, and their unknown relationships while typed sheets, names, views, calculation properties, and pivot caches remain editable; relationship references are remapped when generated IDs conflict
• Slicers: Worksheet.Slicers.Add(Table, ColumnName) creates table slicers (Excel 2013+) end to end — slicer cache, reserved defined name, worksheet extension and drawing anchor included — with positioning, caption, column-count, style and row-height control; workbooks carrying Excel-authored slicers (table or pivot) round-trip them intact through open and save, replaying unmodified parts and anchors byte-for-byte while the surrounding workbook stays fully editable
• Multiple workbook windows: TXLSXWorkbook.WorkbookViews exposes an ordered collection with add, insert, delete, move, and clear operations, typed visibility and geometry state, editable unknown attributes and extensions, and worksheet workbookViewId remapping; the established single-window properties remain compatible projections of the first view
• External defined names and refresh failures: TXLSXExternalLink parses, stores, and round-trips <definedNames> entries from linked workbooks, while each TXLSXExternalSheetData tracks a RefreshError flag for refresh-failure state without requiring a live data source
• Multi-format clipboard import: XLSPasteFromClipboardRich prefers the XML Spreadsheet clipboard format (formulas, styles, merges) over plain Unicode text, with dedicated format detection, extraction, and SpreadsheetML 2003 parsing functions
• Native Biff8 clipboard exchange: CopyToClipboard on both engines publishes Excel's own "Biff8" compound-document payload next to text and HTML, and PasteFromClipboard consumes it first — values arrive free of locale-dependent re-parsing, relative formula references re-anchor to the paste target, and number formats, fonts, fills, borders, alignment, and merged cells round-trip both between HotXLS workbooks and from Excel copies
• XLS and XLSX PasteFromClipboard capture BIFF8 and fallback text together under one clipboard lock, retaining the existing retry policy and using readable captured text without reopening the clipboard when BIFF8 is unavailable or cannot be parsed; readable BIFF8 remains usable if its text companion cannot be retrieved, and unavailable text alone inserts no cells
• Required text and BIFF8 clipboard publication failures preserve the original Win32 GetLastError diagnostic across cleanup for immediate caller inspection
• Rich-text markup: the TaggedText cell property converts between rich-text runs and lightweight tags (<b>, <i>, <u>, <s>, <sub>, <sup>, <color=#RRGGBB>, <font=Name>, <size=N>) in both directions
• 64-bit-safe clipboard readers with contention retry, cached conditional-format and data-validation target matching for absolute, reversed, whole-row, whole-column and whitespace-separated areas, consistent rule lookup, deletion, conditional evaluation and validation checks, and a binary-searched PDF hyperlink index
• Calculation extensibility: by-name user-function registration, an unknown-function audit API, recovery-mode opens that skip damaged parts, native Biff8 clipboard exchange, and cached data-validation range matching
• PDF images: worksheet pictures embed as Flate RGB XObjects with JPEG passthrough and PNG stream reuse (no re-encode, alpha channel preserved through soft masks), byte-identical images are embedded once, keep-together blocks and XlsxAutoPageBreaks align pagination, and ZipCompressionLevel and DeterministicOutput control save output
• PDF output pipeline: page content streams are Flate-compressed, consecutive text operations share batched text blocks with deduplicated font and colour selection, equal adjacent fills merge into single rectangles, and collinear border segments stroke as merged runs — smaller files and faster generation; OnProgress and abort-capable OnProgressEx report begin, page, and end states, while Cancel stops long exports without committing a partial PDF to the destination stream
• PDF cell text fidelity: real word wrapping with vertical block alignment and justified or distributed lines, rotated and vertical stacked text, shrink-to-fit, Excel-like overflow into empty neighbouring cells with clipping, number right-alignment under general alignment, indentation, rich-text runs with per-run style, size, colour, underline, strike, super- and subscript, diagonal and double borders, and text spanning merged cells — all positioned through GDI-calibrated Helvetica advance widths
• PDF print fidelity: styled headers and footers with Excel's font-size, colour, bold/italic/underline/strike and super/subscript codes, black-and-white print mode, printed row and column headings, horizontal and vertical print centering, comment indicators plus an at-end comment listing page through PrintCommentsAtEnd, in-document GoTo links for internal hyperlinks, a viewer PageLayout preference with XMP metadata, Excel-accurate MDW column widths, and TrueType-collection embedding with synthesized bold/italic cuts of the Unicode face
• PDF charts: worksheet charts draw as native vectors — clustered, stacked and percent-stacked column/bar, line with markers, area, pie and doughnut with percentage labels, scatter, and radar — with titled frames, auto-scaled axes and tick labels, gridlines, legends, data labels, per-series fills, and Excel's default accent palette; charts anchored beyond the last data cell extend the printed surface
• Interactive PDF: worksheet hyperlinks become clickable link annotations and every exported sheet gets a document-outline bookmark
• Package-level extensibility: typed custom document properties, custom XML data parts, SVG image companions, per-series chart data labels sourced from cells with indexed caches and point visibility overrides, user-defined table styles with per-section colors, and a data-validation audit API that lists every violating cell
• Format fidelity upgrades: elapsed-time [h]:mm:ss and fraction # ??/?? number formats render everywhere, [Red] brackets recolor PDF text, cell gradient fills round-trip and render in HTML/PDF/viewer, frozen panes and pane scroll read back, DispBlanksAs/PlotVisibleOnly are chart properties, comment boxes size through WidthPt/HeightPt/AutoSizeFromText, and ValidateNumberFormat vets custom format strings
• Excel-semantics search: FindText / ReplaceText support wildcards (*, ?, ~ escape), entire-cell matching, case sensitivity, formula-text search, backward scanning, column-major scan order, windowed FindTextIn / ReplaceTextIn that confine the search to a rectangular range, and a per-match replace callback, Excel-semantics grouping via AddSubtotals (labeled SUBTOTAL rows, grand total, outline levels, page breaks, and replace mode), A1ToR1C1 and R1C1ToA1 converting formulas between A1 and R1C1 reference styles in both directions, plus WriteAutoValue for Excel-like text type sniffing (ISO, US m/d/yyyy, and European d.m.yyyy dates with optional AM/PM times), GetRangeStatistics range aggregation, case-insensitive SortRange that preserves formulas with Excel reference semantics ($ parts stay, relative refs re-anchor), GetHtmlFromCell single-cell HTML fragments, and SetCellFromHtml HTML fragments as rich runs
• Sheet backgrounds: SetBackgroundImage authors tiled pictures in both workbook engines; XLSX preserves package media ownership across worksheet copies, while Classic reads and writes typed BIFF8 background records with continuous payload splitting, exact unknown-format preservation, copy isolation, and known-format conversion between engines; the workbook viewer displays valid backgrounds behind unfilled cells, while print, PDF, SVG, bitmap, metafile, and both HTML exporters keep backgrounds disabled by default and expose ExportSheetBackgroundImages for explicit output with cross-page phase continuity and per-session resource reuse
• Format engine depth: conditional number-format sections ([>=100]) select by value, text sections (@) template strings, TaggedText accepts <br>, <strong>/<em>, and <font color=...> attribute forms, ConvertFormulasToValues offers an only-external mode on both facades, column keep-together blocks complement row blocks, classic Spinner/ScrollBar form controls author into XLS, and row auto-fit handles merged cells
• Clipboard exchange: PasteFromClipboard reads tab-delimited text into cells with number/date/boolean type promotion and formula recognition, while range-level CopyToClipboard publishes both Unicode tabular text and styled HTML with formulas, merged cells, links, display formatting, and embedded-delimiter preservation
• Editable workbook viewer: TXLSWorkbookViewer binds directly to either workbook engine, loads XLS, XLSX, XLSM, XLTX, XLTM, or ODS files, renders styles and conditional formats without materializing sparse XLSX cells, and adds protected-cell-aware in-place editing, formula-bar input, automatic recalculation, rectangular selection, formula-reference events, and O(1) bounded undo and redo
• Classic XLS PivotTable caches use independent storage streams with unique identifiers, worksheet or named source references, Unicode sheet names, and encrypted cache read/write; existing cache extensions retain their original bytes when saved
• Reusable pivot layout designer: TXLSPivotDesigner exposes available, row, column, filter, and value zones, deterministic field reordering, type-aware default aggregation, explicit aggregation changes, layout validation, and result application for either XLS or XLSX pivot models
• Classic form controls: worksheets and shape collections can create, enumerate, edit, delete, and round-trip button, radio-button, checkbox, combo-box, and list-box controls with typed labels, check states, flat or 3D rendering, macro bindings, linked cells, source ranges, control kinds, and cell anchors
• Classic XLS chart inspection through GetChartModel decodes chart family, 3-D state, chart and axis titles, legend, axes with their primary or secondary axis group, series names, categories, value formulas, and series data-label show flags with separators, the per-series primary or secondary chart-group binding, named or external category and value references, per-series line, fill, and marker styling with theme-colored fills carried by the GelFrame OfficeArt theme color extension (theme color index plus tint), the full 3-D scene parameters from the chart stream, and pivot-chart links (source PivotTable view name plus the hide-field-captions flag through the SXViewLink / PivotChartBits records), and embedded chart objects anchored on ordinary worksheets through AddChartObject, along with per-series trendlines (regression kind, order or period, automatic or fixed intercept, equation and R-squared display, forecast and backcast, display name) and error bars (direction side, value type, end caps, magnitude)
• Typed XLSX header and footer images through TXLSXWorksheet.HeaderFooterImages, covering all left, centre, and right slots on odd, even, and first pages with image bytes, formats, titles, point dimensions, point margins, automatic picture field codes, worksheet copies, and relationship-safe open/save round trips alongside comments
• Editable XLSX picture effects through TXLSXImage, including percentage crop edges, transparency, brightness, contrast, stretch or tile fill, degree-based rotation, and structural preservation of unrelated imported DrawingML
• Advanced XLSX chart construction and round trips with ordered column, bar, line, pie, area, scatter, bubble, radar, stock, surface, and 3D plot groups, true combination charts with explicit plot-group draw order, primary and secondary axis pairs, typed date and series axes, configurable 3D views, Excel gallery styles, title, legend, axis text styles, manual plot, title, legend and axis-title layouts, sparse string or numeric series caches, sparse multi-level category caches with live two-dimensional range resolution, and editable preservation of unknown ChartML extensions and formatting
• Selective format patches: TXLSXRange.ApplyFormatPatch copies only requested font, fill, border, number-format, alignment, or protection components, tiles smaller source patterns across larger destinations, and leaves cell values untouched
• Master-detail data export: TDataToXLS.ReadDetailTables recursively exports active linked detail datasets beneath each master record, while IndentDetailTables adds one column of indentation per relationship level and inherited export settings keep the hierarchy visually consistent; write-ahead record and value events can filter records and transform field values without disturbing dataset cursors
• WordArt creation: TXLSXWorksheet.AddWordArt creates cell-anchored DrawingML text with a configurable preset warp, text fill color, and outline color, while subsequent open/save cycles preserve the complete shape anchor
• Unsupported OOXML package preservation: custom parts reachable from unknown package-root, workbook, worksheet, or drawing relationships retain collision-safe relationship IDs, content types, child relationships, compression choice, and exact payload bytes across open/save round trips, with opt-out and retained-part diagnostics on TXLSXWorkbook
• Excel-style tables with styles, filter range and criteria, sort state, stable column identifiers, totals-row labels and functions, calculated-column formulas, totals-row formulas, structure-aware row and column edits, and round-trip collection helpers
• Typed worksheet ignored-error rules through TXLSXWorksheet.IgnoredErrors, covering every standard error category, multi-area cell references, worksheet copies, row and column edits, and open/save round trips
• Typed What-If Scenario Manager authoring through TXLSXWorksheet.Scenarios, including active and shown scenarios, changing-cell ranges, locked and hidden states, user comments, input values and number formats, worksheet copies, structural edits, and repair-free open/save round trips
• Typed What-If data tables through TXLSXWorksheet.AddDataTable and DataTables, covering row-input, column-input, two-variable, deleted-input, calculation-order, worksheet-copy, structural-edit, and SpreadsheetML round-trip semantics
• Typed external data connections through TXLSXWorkbook.Connections and worksheet query results through TXLSXWorksheet.QueryTables, including refresh policy, credentials, database, web, and text settings, exact typed parameter values, table and field bindings, structural edits, worksheet copies, and extension-safe OOXML round trips
• Complete workbook calculation policy through CalcMode, RefMode, iteration settings, recalculation flags, full-precision control, and concurrent-calculation settings, with schema defaults and independent non-default persistence, plus opt-in RecalcLookupCache and RecalcAggregateCache memos that let repeated XLOOKUP/XMATCH, VLOOKUP/HLOOKUP/MATCH, and SUMIF/COUNTIF/AVERAGEIF scans plus unconditional SUM/AVERAGE/MIN/MAX/COUNT over one plain range reuse the first result during a recalculation pass, engaging only when the dependency graph is provably reference-stable so results never differ
• Save-time recalculation policy through RecalcBeforeSave (manual, if-dirty, always) plus RecalcNeeded dirty-state inspection and single-cell RecalcCell value retrieval after a full recalculation
• Report value placeholders with {{name;default}} fallbacks, dbvalue/dbcount/tonumber/ref expressions over a registered DataContext and an isolated per-run data session, bare {{=formula(...)}} cells written as live formulas, and {{#imgsize}}, {{#comment}}, {{#html}}, {{#sheetvisible}}, {{#deletesheet}} structural directives
• Typed lazy user tables through exact {{#usertable(alias, logicalName, providerKey, name=expression)}} cells, with compile-time syntax checks, resolver-free static preflight, dynamic typed parameters, registered-provider enforcement, case-insensitive conflict diagnostics, declaration limits, and first-use loading through dbvalue or dbcount; TXLSReportGenerator.DataContext and TXLSReportTemplateChecker.DataContext carry the same registry into generation and validation
• Report data shaping through lazy Filter, stable multi-key Sort, and Distinct combinators; FromDataSet and FromObjects adapters bind open datasets and published-property object lists as report tables; RunBidirectional bands give each master row its own child-driven columns; PreprocessAndRun lets templates self-modify against the data before the final fill
• Clipboard paste options (values-only, insert rows/columns) on both workbook engines, and OnSkippedRecord diagnostics on the direct reader, row cursor, and forward reader exposing skipped malformed cell references and aborted BIFF sheet scans
• Classic XLS shared-revision protection round-trips through SharedRevisionProtected and SharedRevisionPasswordHash, and reports handle encryption end to end: encrypted templates open by password and RunToEncryptedFile emits an encrypted result in one step
• Cross-workbook CopyRangeTo/CloneRangeTo remap cell styles by value across pools, and classic XLS CreatedDate, LastSavedDate, RevisionNumber and EditTimeMinutes round-trip through the OLE summary stream
• Chart rendering consumes the bar plot group's GapWidth, Overlap and stacked / percent-stacked grouping, so rendered bar and column charts match the model's layout semantics
• Charts round-trip chart-space formatting (rounded corners, background/border/plot-area colours) and the five chart protection switches, with the renderer consuming the colours; series-level Smooth and marker fill/border colours round-trip and render as curved segments; axes carry the crossing mode and tick-mark styles, and AutoTitleDeleted suppresses derived titles
• TXLSPDFWriter builds PDFs without any spreadsheet: explicit page size, multi-page flow, rectangles/lines/ellipses, measured text, transforms, clipping and graphics-state control
• AutoFit offers a two-phase MarkSheet/ApplyMarked flow with inspectable pending measurements, fit-region bounds, IgnoreStrings, KeepHeightAutomatic, a DefaultRowHeightVisual floor and one-call FitWorkbook
• PDF Unicode fonts support automatic, required-subset, complete-program, and map-only embedding policies, standalone OpenType CFF programs, shared GPOS/kern positioning for measurement and drawing, a pre-resolution OnFontEmbed callback, and a recursively cached OnGetFontDirectories family/style resolver; PDF/A output continues to require embedded font programs
• Collection helpers to look up, delete, and reorder sheets, tables, charts, images, merged ranges, and external links by name or position
• One-call chart creation from a data range: AddChartFromRange and the AddColumnChart / AddBarChart / AddLineChart / AddPieChart / AddAreaChart shortcuts derive series and categories from a data block automatically, like Excel's insert-chart-from-selection
• Row and column insertion and deletion that adjusts formulas, table columns and their filter or sort metadata, invalidates deleted table-column structured references across formula consumers, partitions cell-value and expression conditional formats plus data validations when edited areas require different formula anchors, keeps aggregate conditional-format domains intact, and moves defined names, hyperlinks, chart series including bubble sizes, and image, chart, text box, and WordArt anchors automatically
• Formula calculation sharing the classic XLS evaluator with process-wide and workbook-local user-function registries, workbook-local override semantics, parallel-safe lock-free handler invocation, broadcast array operators and per-cell errors, complete multivariable LINEST / LOGEST matrices, shaped TREND / GROWTH predictions, text, date, workday, engineering/base-conversion, bitwise, statistical, aggregate, and math function coverage, reference-preserving ISFORMULA inspection without target recalculation, logarithmic binary XMATCH / XLOOKUP, ISOMITTED optional-argument detection, ARRAYTOTEXT / VALUETOTEXT array conversion, validated XIRR / XNPV calculations, PDURATION / RRI investment timing and growth rates, fractional-period VDB depreciation, and OnUserFunction custom-function callbacks; AnalyzeFormulaIssues provides a structured preflight for missing functions, external references, and exact circular dependency components
• Structured references in current-row form (Table[@Col]) evaluate against the formula cell’s own row in serial and parallel recalculation
• Dependency analysis expands scoped and nested formula-defined names, including multi-area references, and uses cycle guards only when static dependency resolution is impossible
• Excel-authored shared formulas open with every follower expanded to its correct cell-relative expression in full-workbook, streaming direct-reader, and row-cursor paths, while CSE array anchors and followers survive safe whole-array structural edits, complete-range copies, worksheet duplication, and cross-workbook sheet copies
• Dynamic arrays can be authored with TXLSXRange.SetDynamicArrayFormula, retain formula ranges and XLDAPR metadata through open and save cycles, share one deduplicated metadata record across roots, remap that record during cross-workbook copies, and remove it after the final root is cleared
• Calculated-array composition includes typed TRANSPOSE, computed matrix multiplication, determinants and inversion, negative and vector selectors for CHOOSECOLS / CHOOSEROWS, computed lookup vectors and array requests for XLOOKUP / XMATCH / MATCH, and stack and reshape operations with evaluation-step and array-memory limits
• Form-control authoring on XLSX worksheets (AddFormButton / AddFormCheckBox / AddFormRadioButton / AddFormComboBox / AddFormListBox) with VML shapes, ctrlProps parts, and verbatim round-trip of control-bearing files
• Live XLSX cross-workbook evaluation through the path-preserving ExternalWorkspace and compatible RegisterExternalWorkbook facade: full relationship targets and extensions remain distinct, ambiguous aliases fail explicitly, target destruction revokes the live adapter safely, and file-local typed caches remain the fallback without implicit file or network access
• Workbook comparison through TXLSXWorkbookCompare reporting sheet, cell, formula, and merge differences as a structured list or a line-per-difference report
• Workbook-to-code generation through TXLSCodeGen (Delphi and C++Builder dialects) and column-rule import validation through TXLSImportCheck with red-font and comment annotation plus keep-only-violations compaction
• Unrecognized XLS worksheet records round-trip verbatim — vendor-specific or newer-spec records captured at read and replayed on save
• Preset-geometry shapes through AddPresetShape — any OOXML ST_ShapeType token rides the drawing verbatim and round-trips
• Template processing: ApplyTemplate substitutes {{key}} placeholders sheet-wide and FillTemplateBand clones template blocks per record with formula translation, dependent conditional formats, validations, links, comments, pictures, charts, merge cloning, and row-level #skip conditionals; CloneRangeTo exposes the same dependency-aware copy path with selectable payloads; TXLSCompiledReportTemplate compiles placeholder locations and text fragments once for repeated runs across cells, rich text, comments, hyperlinks, drawing text, headers and footers, sheet names, defined names, and document properties without rescanning the workbook, supports addressed preflight diagnostics, strict validation before mutation, and diagnostic worksheets; TXLSCompiledReportRunner adds target-level progress, cancellation, deterministic applied counts, reusable completion or failure state, paired workbook and worksheet lifecycle events, recoverable issue snapshots, and atomic stream, file, or encrypted-file output; TXLSReportGenerator adds template-read events, workbook, file, stream, and encrypted-file sources plus in-place or atomic-clone modification; IXLSReportTable, IXLSReportCursor, per-run lazy providers and resolvers, and compound-key relation indexes supply reusable virtual or in-memory data sources without forcing unreferenced tables to load, while TXLSReportTableFactory composes top, projected, counted, minimum, aggregate, unioned, split, and hash-joined views without copying complete intermediate row payloads; runnable Delphi and C++Builder galleries demonstrate the same data context, compiled runner, diagnostics worksheet, LastResult, and RunToFile path
• Named structural report bands: TXLSCompiledReportBand resolves an exact workbook- or worksheet-scoped rectangular defined name and expands it down, right, or across both axes from one-pass bounded row and column snapshots, preserving value types, mixed-reference formulas, merges, rules, validations, hyperlinks, comments, drawings, and explicit row or column layout metadata while rejecting unsupported partial structures before mutation
• Repeated range and report-band copies reuse scoped defined-name suffix searches while retaining first-available naming after deletion, renaming, or scope changes
• Expandable Excel-table report bands through TXLSCompiledTableReportBand use one bounded cursor snapshot to expand a single data-template row while retaining headers, totals, table and AutoFilter ranges, filter and sort state, column metadata, calculated and totals formulas, styles, structured references, and dependent worksheet objects; representable empty results remove the data-template row, while query-backed tables and unsafe layouts are rejected before structural writes
• Range and Excel-table report bands share ErrorMode, StrictDataAccess, RuntimeLimits, and immutable LastResult diagnostics; WriteAndContinue stores an explicitly recoverable row failure as literal text with its input row and actual output address, then continues the remaining targets and rows, while fatal structural and resource failures roll back the expansion
• Cell and row scanning with raw-value or display-text callbacks, template find & replace, and bulk writing
• Central scratch-file management (registered temp files swept on finalize), opt-in VerifyEncryptedSave post-write decryption check, and per-format grid-limit constants with an OnExportLimit event on the dataset exporter
• Data-validation helpers with one-call list dropdowns from a string array, shared typed IME modes across Classic XLS and XLSX, table formulas that retain independent array attributes, conditional-format extensions, configurable HTML export with centralized CSS style classes, and AES-encrypted save and load — ECMA-376 Standard Encryption (AES-128) with AES-NI acceleration, plus reading Excel's default Agile Encryption (SHA-512 key derivation, AES-128/192/256)
• Classic and XLSX HTML exporters use operation-owned xlsrgbHtml geometry snapshots to convert character widths through Normal-font maximum-digit-width metrics into fixed CSS lengths, reuse one bounded cache per multi-sheet operation, expose the active snapshot for diagnostics, and preserve stored worksheet dimensions
• Prepared XLSX conditional-format evaluation with priority and StopIfTrue layering, relative formulas, shared multi-area statistics, Top/Bottom and average rules, duplicate and unique values, relative date periods, theme-aware differential styles, color scales, directional data bars, and all built-in icon-set families
• Tolerant XLSX opening: namespace prefixes are normalized while parsing, so worksheets, charts, drawings, and document properties bound to non-canonical or ISO 29500 strict namespaces load like ordinary files, and worksheets whose rows or cells omit position attributes infer each cell after its predecessor in scan order
• Strict Open XML output through StrictOOXML: the whole XLSX package — worksheets, shared strings, styles, theme, drawings, charts, comments, document properties, and preserved parts — is saved in ISO/IEC 29500 strict conformance with the purl.oclc.org vocabularies, and strict relationship types resolve on open just like transitional ones
• Full-workbook XLSX opening streams worksheet ZIP entries directly into worker-local inflaters and XML readers, retaining no inflated worksheet XML staging copies and limiting transient worksheet input memory to the active parse workers
• Streaming direct reader (TXLSDirectReader) that scans .xlsx / .xlsm cell by cell with per-cell and per-sheet events and a near-constant memory footprint for very large workbooks, reporting each cell's value, kind, formula text, and style index with optional date detection, early abort that propagates into ZIP input and decompression, row-range pushdown, and constant-time column projection before value decoding; opt-in layout events expose worksheet dimensions, default sizes, column spans, row metadata, frozen or split panes, and merged ranges before dependent cells; bounded parallel parsing streams worker-local worksheet inflaters into independently budgeted producer-consumer queues while preserving callback order on the calling thread, rich-string preservation exposes formatted runs, phonetic ranges, and phonetic properties, and the bounded shared-string store keeps small tables in memory while migrating larger tables and rich payloads to indexed delete-on-close temporary storage
• Streaming direct writer (TXLSDirectWriter) that produces .xlsx workbooks cell by cell, emitting each worksheet straight into the package as rows arrive so very large files are generated with a near-constant memory footprint, covering inline or deduplicated shared strings, rich strings with formatted and phonetic runs, numbers, booleans, dates, formulas, reusable package-level cell styles with cloned handles, deduplicated fonts/fills/borders/number formats, font emphasis, underline, outline and shadow, 19 fill patterns, 14 border styles across five edges, horizontal and vertical alignment, wrapping, shrinking, indentation, rotation, quote prefixes, locked/hidden protection, built-in and custom number formats, column widths, row heights, hidden rows and columns, merged ranges, worksheet and table AutoFilter ranges with value, blank, date-group, custom, dynamic, top/bottom filters and sort states, worksheet protection with fine-grained permissions, legacy or modern password metadata and editable protected ranges, workbook structure and window protection, frozen panes, sheet tab colors, right-to-left sheet views, sheet-view display toggles, page margins, header/footer text, print options, page setup, fit-to-page settings, manual page breaks, worksheet hyperlinks across multiple sheets, workbook and sheet-local defined names, generated defined ranges, print areas, print title rows or columns, data validations with prompts and error alerts, conditional formatting with eight cell-value operators, expressions, text matching, top/bottom ranking, average, duplicate/unique, blank/error predicates, data bars, two- and three-color scales, 17 icon-set families, differential font/fill styles, priorities and stop-if-true control, Excel table parts with column names, header/totals row flags, table comments, totals-row column labels and functions, calculated-column formulas, totals-row formulas, and table style display options, plus current-sheet side channels for classic comments, streamed image sources, anchored DrawingML, typed formula-backed charts, and caller-supplied ChartML
• Opt-in overflow continuation (AutoSplitRows) splits exports across <name>_2 sheets when a row past the worksheet limit arrives, and FillTableCalculatedColumn pushes a table column formula into every data row the way Excel’s authoring does
• In-place worksheet patching through BeginPatch: the streaming writer rewrites one worksheet of an existing package while every untouched part is copied across with its compressed bytes verbatim — replace a data sheet or append a new one without re-authoring the template; failed initialization and finalization release source handles, callers retain responsibility for temporary source registrations, and the writer can be reused after initialization failure
• Camera objects through AddCamera: live snapshot pictures bound to a cell range, following the documented camera-tool drawing extension; the binding round-trips through save and reopen
• PDF attachments through AddAttachment — files ride the export as /EmbeddedFiles entries with a name tree, and IXLSPDFAttachmentSource can provide each payload lazily once per save through a bounded spool; final assembly streams objects sequentially to the destination, so attachment payloads copy in fixed chunks with an indirect length object and peak memory stays flat
• Explicit PDF/A-1a, 1b, 2a, 2b, 3a, and 3b output through PDFAProfile, including profile-specific identification, color management, tagging, attachment, and atomic validation rules; UsePDFA remains a compatibility switch for PDF/A-2b
• PDF export runs in a classic layout or an opt-in PDF 1.5 layout with compressed object streams and a binary cross-reference stream (UseXRefStream) for smaller files
• PDF export supports reusable begin, page, and end progress callbacks with cancellation and no partial stream commit, plus optional cell-positioned Unicode comment annotations that can coexist with comments-at-end pages
• PDF gradients and transparency use native axial or radial shadings with stitched multi-stop functions, per-stop alpha masks, cell fill patterns, image shadows, page-level clipping, and document-level resource caches; selected PDF/A profiles apply their graphics restrictions before output commit
• Style-aware PDF font fallback chains through SetFontFallbackChain, AddFontFallback, and ClearFontFallbackChains select embedded faces by source family, style tier, and glyph coverage, cache loaded faces and selections, preserve supplementary scalars and cross-run grapheme clusters, keep shared-glyph Unicode sequences distinct through CID mappings, and reject PDF/A output atomically rather than using an unembedded font
• TXLSPageImageExporter builds pagination once and exports selected XLS or XLSX pages incrementally as PNG or JPEG with configurable DPI, scale, quality, progress, cancellation, and per-page bitmap lifetime; ExportRange writes one tight cell rectangle and before or after paint events expose the actual page canvas through a read-only context with pixel bounds, page size, resolution, scale, page numbers, and the originating worksheet, firing exactly once per rendered frame including multipage TIFF frames
• TXLSCellImageExporter measures, renders, and saves any classic or XLSX cell rectangle as one compact image without pagination artifacts, with configurable resolution, scale, format, and JPEG quality, transparent PNG or colored backgrounds, independent object, gridline, and cell-border switches, pixel and byte budgets validated before allocation, and file saving through an atomic same-folder replacement that never damages an existing target on failure
• ODS export translates supported scalar formulas, qualified A1 references, custom Boolean validation, formula-valued bounds, and list sources to OpenFormula; unsupported cell formula dialects retain the compatibility fallback, while unsupported validation definitions and references are omitted together
• Repeated ODS row heights and blank-cell styles use compact ranges; ODS output retains row heights and repeated styled tails, while single-row edits, clearing, worksheet copying, row shifts, tiling, and XLSX export preserve the effective heights
• Pull-mode row supply (OnNeedRow + RunRows) drives the streaming writer from a data pipeline one row at a time
• Right-to-left worksheets mirror in PDF export and flip through dir="rtl" in HTML, completing the display-flag round trip
• Worksheet zero-display mode hides actual numeric zero, including formula results, currency values, and date-base zero, across viewers and visual exports before number formatting or text measurement; formula-display mode takes precedence, conditional-format visuals and hyperlinks remain active, and stored values, public formatted text, CSV, and ODS output retain their existing contracts
• Opt-in tracked-width streaming mode (TrackColumnWidths) stages the worksheet in memory so the finished file carries the used-range <dimension> hint and column widths sized to the longest value seen per column, approximating autofit for data that is only known while it streams
• Reference-safe XLSX row and column structural edits that update formulas, defined names, rules, links, drawings, print settings, protected ranges, classic and threaded comment anchors, sparklines, typed pivot sources and views, and recognizable preserved extension references in one guarded transaction, with an ordered participant API for application-owned metadata
• Compact random-access XML tree (TSimpleDomReader) that builds from the same pull reader in one pass for querying workbook metadata, relationships, themes, and other package parts by case-sensitive QName or local-name path
• Step-by-step formula evaluation through TXLSFormulaTracer with exact operand-stack transitions, plus interactive diagnosis through TXLSFormulaDebugger exposing parsed nodes, operand values, evaluation order, cell and range dependencies, lazy branch choices, skipped expressions, and propagated error origins