What's New in Document Solutions v9.2

We’re excited to introduce the v9.2 release of Document Solutions, bringing major updates across the  .NET, Java, and JavaScript product families. This release significantly expands the new Document Solutions for PDF JS (DsPdfJS) API with digital signatures, standards-focused PDF generation, output intents, font inspection, reusable Form XObjects, custom annotation appearances, linearized PDF output, and additional PDF object-model support.

Document Solutions for PDF .NET (DsPdf .NET) and DsPdfJS also add support for creating PDF/A-4, PDF/A-4e, PDF/A-4f, and PDF/UA-2 documents, along with new 3D annotation capabilities. Document Solutions for Word .NET (DsWord .NET) expands field updating with REF, NOTEREF, and STYLEREF support. The Document Solutions PDF Viewer (DsPdfViewer) improves pinch-and-zoom behavior on mobile and touchscreen devices.

The release also includes a broad set of improvements for Document Solutions for Excel .NET (DsExcel .NET), Document Solutions for Excel Java (DsExcel Java), and Document Solutions DataViewer (DsDataViewer). These include PivotTable grouping, additional chart and cell-type export support, improved formula handling, stronger SpreadJS interoperability, workbook I/O enhancements, and XLTX loading in DsDataViewer.

Explore What’s New Across Document Solutions v9.2

Download the Latest Document Solutions Releases Today!

Document Solutions for PDF JS (DsPdfJS)

Document Solutions for PDF JS (DsPdfJS) v9.2 is a major expansion of the JavaScript PDF API introduced in v9.1. The release adds advanced document-security workflows, richer standards-oriented PDF generation, reusable PDF graphics objects, deeper font inspection, and new APIs for controlling output intent and annotation appearance.

Together, these updates make DsPdfJS better suited for document signing, accessible and archival PDF creation, externally managed signing services, advanced PDF inspection, and production-oriented browser or Node.js workflows.

Digital Signatures

DsPdfJS v9.2 adds support for creating, parsing, and verifying PDF digital signatures in JavaScript workflows. Developers can sign documents using an X.509 certificate and its corresponding private key in PEM format, or integrate an external signing provider without exposing private keys to DsPdfJS.

The signing architecture separates PDF structure management from cryptographic and network operations. The DsPdfJS WebAssembly core prepares the PDF, calculates the byte ranges, and reserves the signature container. JavaScript then performs asynchronous cryptographic operations and returns the completed signature data to the WebAssembly layer for final PDF generation.

This approach enables integrations with browser-native and externally hosted signing infrastructure, including Web Crypto, Azure Key Vault, hardware-backed signing services, and custom server-side signing APIs.

DsPdfJS v9.2 supports:

  • Certificate-based PDF signing
  • Visible and invisible signatures
  • Sequential signing through incremental updates
  • Asynchronous external signer implementations
  • Document timestamp signatures
  • Signature parsing and inspection
  • Signature-value verification
  • Certificate chains, OCSP responses, CRLs, and timestamp evidence
  • Document Security Store data for long-term validation scenarios
  • PAdES B-B, B-T, B-LT, and B-LTA signature levels

The main API includes PdfDocument.sign(), PdfDocument.timestamp(), Pkcs7Signer, Pkcs7SignerBase, TimeStampProvider, TimeStamper, PdfSignature, and the document security store.

Sign a PDF Using an X.509 Certificate

/**
 * This sample demonstrates how to create and sign a PDF with a certificate .crt and private key .pem files,
 * using a SignatureField.
 * The sample then loads the signed file back into another PdfDocument instance
 * and verifies the signature.
 */
const doc = new PdfDocument();
const page = doc.newPage();
const tf = new Format({ font: Font.getPdfFont(StandardPdfFont.Times), fontSize: 14 });
page.context.drawText("Hello, World!\n" +
                "Signed by DsPdfWeb SignDoc sample.",
                tf, 72, 72);
// load certificate and private key
const certificatePem = await loadFileAsString("sign_cert.crt");
const privatePem = await loadFileAsString("sign_privatekey.pem");
const pkcs7Signer = new Pkcs7Signer();
pkcs7Signer.location = "DsPdfJS Demo Browser";
pkcs7Signer.signerName = "DsPdfJS";
pkcs7Signer.signingDateTime = new Date();
pkcs7Signer.certificateChainPem = [certificatePem];
pkcs7Signer.privateKeyPem = privatePem;

// Init a signature field to hold the signature:
var sf = new SignatureField();
sf.widget.rect = { x: 72, y: 72 * 2, width: 72 * 4, height: 36};
sf.widget.page = page;
sf.widget.backColor = "LightSeaGreen";
sf.widget.defaultAppearance.font = Font.getPdfFont(StandardPdfFont.Helvetica);
sf.widget.buttonAppearance.caption =
        `Signer: ${pkcs7Signer.signerName}\r\nLocation: ${pkcs7Signer.location}`;
// Add the signature field to the document:
doc.acroForm.fields.add(sf);
// Connect the signature field and signer:
pkcs7Signer.signatureField = sf;
// Sign and save the document:
const docData = await doc.sign(pkcs7Signer);
// Verify signature
const doc2 = PdfDocument.load(docData);
const sf2 = doc2.acroForm.fields.getAt(0) as SignatureField;
const parsedSignature = sf2.signature?.parseContent();
if (!parsedSignature?.valueValid)
        throw new Error("Failed to verify the signature");
saveFile("digitallySignPdf.pdf", docData as any);

External signing providers can be implemented by deriving from Pkcs7SignerBase. This allows DsPdfJS to supply the data that must be signed while the caller controls where and how the private-key operation occurs.

JS PDF API | Sign a PDF Using an X.509 Certificate Example

DsPdfJS verifies that the embedded signature value corresponds to the signed PDF data. Certificate trust, expiration, and revocation-policy validation may require additional application-level processing.

Help | Demo

Output Intents and ICC Profiles

DsPdfJS v9.2 adds support for PDF output intents, allowing developers to describe the intended output device or production condition for a document. Output intents are especially important in standards-oriented workflows such as PDF/A and PDF/X, where color reproduction must be described consistently.

The new IccProfile API creates an ICC profile from raw profile data, while OutputIntent defines information such as the output-intent subtype, condition identifier, registry name, human-readable information, and destination output profile. The document’s output-intent collection is available through PdfDocument.outputIntents.

const profile = IccProfile.create(iccProfileBytes);
const outputIntent = new OutputIntent();
outputIntent.subtype = OutputIntent.GTS_PDFA1;
outputIntent.outputConditionIdentifier = "sRGB IEC61966-2.1";
outputIntent.info = "sRGB color profile";
outputIntent.destOutputProfile = profile;

doc.outputIntents.add(outputIntent);
Before setting the 'Use Overprint Preview' option After setting the 'Use Overprint Preview' option
Before Setting the 'Use Overprint Preview' option After Setting the 'Use Overprint Preview' option

For common PDF/A scenarios, developers can also use OutputIntent.createDefaultForPdfA() to create a default sRGB-based output intent.

Help | Demo

Tagged PDFs, Structure Trees, and PDF Conformance

DsPdfJS v9.2 introduces a broad set of APIs for generating and modifying tagged PDFs. These APIs help developers build the logical document structure required for accessible and archival PDF workflows, including PDF/A and PDF/UA documents.

Visible PDF content can now be wrapped in marked-content sequences using beginMarkedContent() and endMarkedContent(). Developers can associate that marked content with logical elements such as documents, parts, paragraphs, figures, forms, and other structural objects through the document’s structure tree.

The feature group includes:

  • Tagged PDF content streams
  • PDF structure trees
  • Structure elements and content-item links
  • PDF 2.0 namespaces
  • Structure attributes, role maps, and class maps
  • Associated files
  • Structure-based annotation tab order
  • Form XObjects
  • Custom annotation appearance streams
  • PDF/A and PDF/UA conformance metadata

Create Tagged Content

// PDF structure tree basics: StructTreeRoot, StructElement, McidContentItemLink.
// Content is drawn inside marked-content brackets, and for each marked-content
// sequence a structure element is created and linked to the content via its MCID.
const doc = new PdfDocument();
const font = Font.getPdfFont(StandardPdfFont.Helvetica);
// Create a Part element under the structure tree root;
// it will contain P (paragraph) elements:
const sePart = new StructElement('Part');
doc.structTreeRoot.children.add(sePart);
const page = doc.pages.addNew();
const g = page.context;
let y = 20;
for (let i = 0; i < 3; i++) {
    // create a paragraph element and add it to the Part element
    const seParagraph = new StructElement('P');
    seParagraph.title = `Paragraph ${i + 1}`;
    // defaultPage is the page MCID-based content items of this element refer to
    seParagraph.defaultPage = page;
    sePart.children.add(seParagraph);
    const tl = new Layout({
        defaultFormat: new Format({ font: font, fontSize: 12 }),
        maxWidth: page.width - 40
    });
    tl.append(`Paragraph ${i + 1}: this text is drawn inside a marked-content bracket with MCID ${i} ` +
        'and referenced from a P structure element via McidContentItemLink.');
    tl.performLayout();
    // draw the paragraph within tagged content (BDC ... EMC with MCID i)
    g.beginMarkedContent({ name: 'P', mcid: i });
    g.drawLayout(tl, 20, y);
    g.endMarkedContent();
    y += tl.contentHeight + 20;
    // link the marked-content sequence to the structure element
    seParagraph.contentItems.add(new McidContentItemLink(i));
}
// the mark information dictionary of a tagged document must have marked = true
doc.markInfo.marked = true;
const outputFile = path.join(__dirname, 'StructureTreeBasics.pdf');
await writeFile(outputFile, doc.savePdf());

The above code produces the following structure tree of tagged content:

Create Tagged Content | JavaScript PDF API Library | SDK

DsPdfJS provides the APIs required to produce conforming documents, but it does not automatically validate that every requirement of a selected PDF standard has been satisfied. The calling application remains responsible for requirements such as embedding fonts, tagging all meaningful content, providing alternative text, and supplying the required metadata.

Help | Demo

Form XObjects

DsPdfJS v9.2 adds support for Form XObjects, reusable self-contained pieces of PDF content that can be drawn multiple times without duplicating the underlying content stream.

A FormXObject can be created from an explicit rectangle or from an existing PDF page, including a page from another document. Developers draw into the Form XObject through its context property and render it with drawForm().

This is useful for reusable graphics, page imposition, repeated headers or stamps, annotation appearance streams, and structure-tree scenarios. The below code shows how to create a Form XObject and render it multiple times with different bounds.

// Form XObjects: create a FormXObject, build its content, draw it with drawForm().
// A FormXObject is a reusable self-contained piece of content: it is stored once
// in the PDF and can be drawn any number of times on any page.
const doc = new PdfDocument();
const page = doc.pages.addNew();
const font = Font.getPdfFont(StandardPdfFont.Helvetica);
// Create a FormXObject with explicit bounds:
const bounds = { x: 0, y: 0, width: 144, height: 72 };
const fxo = new FormXObject(doc, bounds);
// Generate the form's content through its context property
// (all drawing APIs available for page content work here as well):
const g = fxo.context;
g.drawRect(bounds, { fillBrush: new LinearGradientBrush({ startColor: "LightCyan", endColor: "Cyan" }) });
g.drawRect(bounds, { lineColor: "DarkCyan", lineWidth: 2 });
const tl = new Layout({
    maxWidth: bounds.width,
    maxHeight: bounds.height,
    textAlignment: TextAlignment.Center,
    paragraphAlignment: ParagraphAlignment.Center,
    defaultFormat: new Format({ font: font, fontSize: 16 })
});
tl.append("Form XObject");
tl.performLayout();
g.drawLayout(tl, 0, 0);
// Draw the same FormXObject instance three times with different bounds;
// the content is scaled to the destination rectangle:
const pg = page.context;
pg.drawText("The same FormXObject drawn three times with different bounds:", new Format({ font: font, fontSize: 12 }), 20, 20);
// original size
pg.drawForm(fxo, 20, 50, 144, 72);
// stretched horizontally
pg.drawForm(fxo, 200, 50, 288, 72);
// bounds overload; keepAspectRatio fits the content proportionally
pg.drawForm(fxo, { x: 20, y: 150, width: 288, height: 144 }, { keepAspectRatio: true });
const outputFile = path.join(__dirname, 'FormXObjects.pdf');
await writeFile(outputFile, doc.savePdf());
console.log(`Created ${outputFile}`);

The above code generates the following Form XObjects:

JavaScript PDF API Library Support for PDF Form XObjects

The same Form XObject can be placed on multiple pages, transformed, scaled, rotated, or reused as part of an annotation appearance.

Help

Associated Files

DsPdfJS v9.2 adds support for PDF associated files. Unlike a general embedded attachment, an associated file is explicitly related to a document object such as the document itself, a page, an annotation, a Form XObject, or a structure element.

Associated files are important for workflows such as PDF/A-3 and PDF/A-4, where an attachment may need to be connected to the document content it describes. Developers can access associated-file collections through:

  • PdfDocument.associatedFiles
  • PdfPage.associatedFiles
  • AnnotationBase.associatedFiles
  • FormXObject.associatedFiles
  • StructElement.associatedFiles

Applications can specify the file relationship, file name, MIME type, and modification date as required by the target workflow.

Custom Annotation Appearance Streams

DsPdfJS v9.2 gives developers direct control over the normal, rollover, and down appearance streams used by PDF annotations.

Each appearance stream can reference a FormXObject, giving developers access to the full drawing API when defining how an annotation or form widget should look. Named streams are also supported for annotations with multiple visual states, such as checked and unchecked form controls.

const annotation = new StampAnnotation();
annotation.rect = { x: 50, y: 50, width: 180, height: 60 };
page.annotations.add(annotation);
const appearance = annotation.createAppearanceContentStream();
appearance.context.drawRect(0, 0, 180, 60, {
  fillColor: "LightGreen",
  lineColor: "DarkGreen"
});
appearance.context.drawText("APPROVED", new Format({font, fontSize: 12}), 45, 22);
annotation.appearanceStreams.normal.default = appearance;

Because appearance streams are Form XObjects, they can also contain tagged content and participate in accessible PDF workflows. Below is an example of how a custom annotation appearance stream would appear in a real PDF:

Custom Annotation Appearance Streams ExampleHelp

PDF Font Inspection and Embedded Font Data

DsPdfJS v9.2 adds PdfDocument.getFonts(), allowing applications to inspect the fonts referenced by an existing PDF document.

The returned font collection is de-duplicated and includes fonts referenced from page resources, nested Form XObjects, and annotation appearance streams. Developers can inspect font properties such as:

  • PostScript and family names
  • Font weight, stretch, and italic state
  • PDF font subtype
  • Font descriptor metrics
  • Embedded-font status
  • Character-code and Unicode mappings
  • Descendant CID fonts for Type 0 fonts

Applications can also extract embedded font data or remove it when appropriate. Removing embedded font data can reduce file size, but it may change rendering when a matching font is unavailable on the viewing system.

Get Embedded Font Data

const doc = PdfDocument.load(existingPdfBytes);

for (const font of doc.getFonts()) {
  const attributes = font.getFontAttributes();

  console.log({
    baseFont: font.baseFont,
    family: attributes.fontFamily,
    weight: attributes.fontWeight,
    italic: attributes.fontItalic,
    embedded: font.isEmbedded
  });
}

Remove Embedded Font Data

for (const font of doc.getFonts()) {
  if (font.isEmbedded) {
    font.removeEmbeddedData(doc);
  }
}

const optimizedPdf = doc.savePdf();

Below is an image of a generated PDF that showcases the enumerated font information gathered via this new API implementation:

Enumerated font information sample

Help | Demo

Linearized PDF Output

DsPdfJS v9.2 adds support for saving linearized PDFs, commonly known as Fast Web View PDFs. Linearization organizes a PDF so that the first page and required document structures can be loaded before the entire file has been downloaded.

Developers can save a linearized PDF with SaveMode.Linearized and check the current state through PdfDocument.linearized.

const output = doc.savePdf({
  saveMode: SaveMode.Linearized
});

console.log(`Linearized: ${doc.linearized}`);

Linearization and incremental-update save modes are separate workflows and cannot be applied to the same save operation.

Help

Document Solutions for PDF .NET and Shared PDF Improvements

Document Solutions for PDF .NET (DsPdf .NET) v9.2 expands its standards-focused and interactive PDF capabilities with new support for PDF/A-4 variants, PDF/UA-2 generation, PDF 2.0 structure enhancements, structure-based destinations, and a new 3D annotation object model. DsPdfJS v9.2 also introduces many of these capabilities while bringing additional established DsPdf .NET features, such as tagged content, output intents, associated files, and Form XObjects, to JavaScript developers.

Support for PDF/A-4, PDF/A-4e, PDF/A-4f, and PDF/UA-2

DsPdf .NET and DsPdfJS v9.2 add APIs for creating documents that target PDF/A-4, PDF/A-4e, PDF/A-4f, and PDF/UA-2.

PDF/A-4 is based on PDF 2.0 and is designed for long-term preservation. Its specialized variants extend the format for engineering content and embedded-file workflows:

  • PDF/A-4 supports the core PDF/A-4 archival profile.
  • PDF/A-4e supports engineering-oriented content and may include formats such as CAD, STEP, XML, and rich media.
  • PDF/A-4f supports arbitrary embedded-file attachments when the required association rules are followed.

PDF/UA-2 is the second generation of the PDF Universal Accessibility standard. It builds on PDF 2.0 and defines the document structure and metadata needed for reliable use with assistive technologies such as screen readers and braille displays.

For DsPdf .NET, v9.2 introduces new PDF/A-4 conformance levels and PDF/UA-2 generation support, along with APIs for PDF 2.0 namespaces, structure-tree relationships, revision metadata, and structure destinations. New APIs include PdfAConformanceLevel.PdfA4, PdfA4e, and PdfA4f; Namespace and NamespaceCollection; StructTreeRoot.Namespaces; StructElement.NS; ContentItem.StructElement; Metadata.PdfRev and Metadata.PdfUaRev; and new structure-destination overloads for DestinationXYZ, DestinationFit, DestinationFitH, DestinationFitV, DestinationFitR, DestinationFitB, DestinationFitBH, and DestinationFitBV that accept a StructElement.

DsPdfJS v9.2 provides corresponding standards-focused functionality while also making several capabilities already established in DsPdf .NET available to JavaScript developers, including tagged and marked content, output intents, associated files, and other PDF structure features.

The following example configures a document for PDF/UA-2 and initializes its PDF 2.0 structure tree. Additional tagging, alternative text, embedded fonts, and other required content-level details must be supplied for full conformance.

var doc = new GcPdfDocument();
doc.PdfVersion = "2.0";
doc.Lang = "en";
doc.Metadata.PdfUa = 2;
doc.Metadata.PdfUaRev = "2024";
doc.MarkInfo.Marked = true;
var ns = new Namespace("http://iso.org/pdf2/ssn");
doc.StructTreeRoot.Namespaces.Add(ns);
var documentElement = new StructElement("Document") { NS = ns };
doc.StructTreeRoot.Children.Add(documentElement);

As with existing PDF/A and PDF/UA support, these APIs enable applications to create documents that meet the standards. They do not automatically convert an arbitrary PDF into a conforming document or perform complete standards validation.

Help .NET | Help JS | PDF/UA-2 Demo .NET | PDF/UA-2 Demo JS | PDF/A-4 Demo .NET | PDF/A-4 Demo JS

3D Annotation Support

DsPdf .NET and DsPdfJS v9.2 add support for representing 3D artwork through PDF 3D annotations.

3D Annotation Support | Included in Document Solutions for PDF .NET and JS Libraries

The new object model includes 3D annotations, 3D streams, views, activation and deactivation settings, presentation styles, toolbar visibility, transparency, animation behavior, lighting, rendering modes, and camera transformations.

These APIs support common embedded and windowed 3D viewing scenarios without requiring developers to manually construct the lower-level PDF dictionaries. Refer to the following code to create a 3D model annotation:

public class Annotation3D
{
    public int CreatePDF(Stream stream)
    {
        var doc = new GcPdfDocument();
        var page = doc.NewPage();
        // Load the 3D model (U3D format).
        var modelPath = Path.Combine(
            "Resources",
            "3DModels",
            "plane64x64_base.u3d");
        using var modelStream = File.OpenRead(modelPath);
        // Add a 3D annotation showing the model.
        var annotation = new Model3DAnnotation
        {
            Stream = new Model3DStream(
                modelStream,
                Model3DStreamFormat.U3D),
            ActivationCondition =
                Model3DActivationCondition.PageBecomesVisible,
            DeactivationCondition =
                Model3DDeactivationCondition.PageBecomesInvisible,
            Page = page,
            Rect = new RectangleF(
                rc.X,
                rc.Bottom + 18,
                72 * 5,
                72 * 4)
        };

        doc.Save(stream);
        return doc.Pages.Count;
    }
}

Help .NET | Demo .NET | Help JS | Demo JS

Document Solutions PDF Viewer (DsPdfViewer)

Document Solutions PDF Viewer (DsPdfViewer) v9.2 improves touch interaction for PDF viewing on mobile devices and touch-enabled screens.

Improved Pinch-and-Zoom Behavior

Previously, pinch-to-zoom operations used the top-left corner of the document as the zoom focal point, regardless of where the user placed their fingers.

DsPdfViewer v9.2 corrects this behavior so that zooming remains centered around the user’s actual pinch location. This provides a more natural mobile experience, particularly when viewing large documents, technical drawings, maps, or detailed page content.

The improvement does not require a new public API and applies automatically when users pinch to zoom on supported touchscreen devices.

Demo

Document Solutions for Word .NET (DsWord .NET)

Document Solutions for Word .NET (DsWord .NET) v9.2 expands field updating with support for three commonly used Word reference fields: REF, NOTEREF, and STYLEREF. These fields allow for greater control over document content, such as utilizing the NOTEREF to resolve references to footnote and endnote marks, including determining the page number on which the referenced note appears during document layout, and maintaining that information during document export to PDF or image file formats.

These additions improve automation for cross-references, legal and technical documents, footnotes and endnotes, numbered clauses, and documents that use styles to display nearby section or chapter information.

Reference Field Updates

REF Fields

DsWord .NET v9.2 adds support for updating REF fields. A REF field inserts content associated with a bookmark and can also display the bookmarked paragraph’s list number or its relative position.

The new RefFieldOptions API supports bookmark references, hyperlinks, relative-position text, list-number display modes, reference-number inclusion, text formatting, and result formatting.

// REF fields can display bookmarked content, paragraph numbering,
// or the bookmark's relative position.
GcWordDocument doc = new GcWordDocument();

// Create numbered list items
Paragraph item1 = doc.Body.AddParagraph("License Grant");
item1.Style = doc.Styles[BuiltInStyleId.ListNumber];
item1.GetRange().Bookmarks.Add("LicenseGrant");
doc.Body.AddParagraph("The Licensor grants to the Licensee a worldwide License.");
Paragraph item2 = doc.Body.AddParagraph("Termination");
item2.Style = doc.Styles[BuiltInStyleId.ListNumber];

// REF field that copies the bookmarked text
Paragraph refPara = doc.Body.AddParagraph("As described in ");
RefFieldOptions textRef = new RefFieldOptions(doc, "LicenseGrant");
textRef.Hyperlink = true;
refPara.GetRange().ComplexFields.Add(textRef);
refPara.GetRange().Runs.Add(", the license is granted worldwide.");

// REF field that shows the paragraph number
Paragraph numPara = doc.Body.AddParagraph("See item ");
RefFieldOptions numRef = new RefFieldOptions(doc, "LicenseGrant");
numRef.DisplayListNumber = DisplayListNumber.AllLevels;
numPara.GetRange().ComplexFields.Add(numRef);
numPara.GetRange().Runs.Add(" for details.");

// REF field with relative position
Paragraph relPara = doc.Body.AddParagraph("The License Grant item is ");
RefFieldOptions relRef = new RefFieldOptions(doc, "LicenseGrant");
relRef.DisplayRelative = true;
relPara.GetRange().ComplexFields.Add(relRef);
relPara.GetRange().Runs.Add(".");

doc.UpdateFields();
doc.Save(@"ref-field.docx");

Help | Demo

NOTEREF Fields

DsWord .NET v9.2 adds support for updating NOTEREF fields, which display the reference number of a bookmarked footnote or endnote.

The new NoteRefFieldOptions class lets developers create hyperlinks to the referenced note, display relative-position text, preserve reference-mark formatting, and apply field-result formatting.

// NOTEREF fields display the reference number of a footnote or endnote.
GcWordDocument doc = new GcWordDocument();

// Add body text with a footnote
Paragraph p1 = doc.Body.AddParagraph("The experiment produced significant results");
p1.GetRange().Footnotes.Add("See Johnson et al., 2024 for methodology details.");
p1.GetRange().Bookmarks.Add("fnMethodology");

// Add more body text with another footnote
Paragraph p2 = doc.Body.AddParagraph("The control group showed no variation");
p2.GetRange().Footnotes.Add("P-value < 0.001 across all trials.");
p2.GetRange().Bookmarks.Add("fnPValue");

// Cross-reference the first footnote by number
Paragraph refPara = doc.Body.AddParagraph("As noted in footnote ");
NoteRefFieldOptions noteRef = new NoteRefFieldOptions(doc, "fnMethodology");
refPara.GetRange().ComplexFields.Add(noteRef);
refPara.GetRange().Runs.Add(", the methodology was validated.");

// Cross-reference with formatted reference mark (\f switch)
Paragraph refPara2 = doc.Body.AddParagraph("Statistical significance was confirmed");
NoteRefFieldOptions noteRefMark = new NoteRefFieldOptions(doc, "fnPValue");
noteRefMark.FormatAsReferenceMark = true;
refPara2.GetRange().ComplexFields.Add(noteRefMark);
refPara2.GetRange().Runs.Add(".");

// Cross-reference with relative position (\p switch)
Paragraph refPara3 = doc.Body.AddParagraph("The methodology (see footnote ");
NoteRefFieldOptions noteRefPos = new NoteRefFieldOptions(doc, "fnMethodology");
noteRefPos.DisplayRelative = true;
refPara3.GetRange().ComplexFields.Add(noteRefPos);
refPara3.GetRange().Runs.Add(") was peer-reviewed.");

doc.UpdateFields();
doc.Save(@"noteref-field.docx");

Help | Demo

STYLEREF Fields

DsWord .NET v9.2 adds support for updating STYLEREF fields. STYLEREF fields display text from the nearest preceding paragraph with a specified style. This example uses STYLEREF fields in the document body to create a breadcrumb that dynamically displays the current chapter and section.

var doc = new GcWordDocument();

var heading1 = doc.Styles[BuiltInStyleId.Heading1];
var heading2 = doc.Styles[BuiltInStyleId.Heading2];

doc.Body.AddParagraph("Chapter 1", heading1);
doc.Body.AddParagraph("Section 1.1", heading2);
doc.Body.AddParagraph("Lorem ipsum dolor sit amet, consectetur adipiscing elit.");

// Add STYLEREF fields in the document body.
var breadcrumb = doc.Body.AddParagraph();
breadcrumb.GetRange().Runs.Add("You are reading: ");
breadcrumb.AddComplexField(new StyleRefFieldOptions(doc, heading1.Name));
breadcrumb.GetRange().Runs.Add(" → ");
breadcrumb.AddComplexField(new StyleRefFieldOptions(doc, heading2.Name));

// Update the fields.
doc.UpdateFields(new GrapeCity.Documents.Word.Layout.WordLayoutSettings()
{
    FontCollection = FontCollection,
    Culture = CultureInfo.GetCultureInfo("en-US")
});

doc.Save(@"styleref-field.docx");

In v9.2, STYLEREF updating is not supported in page headers or footers.

Help | Demo

Document Solutions for Excel .NET (DsExcel .NET), Java (DsExcel Java), and Document Solutions Data Viewer (DsDataViewer)

Document Solutions for Excel .NET (DsExcel .NET) and Document Solutions for Excel Java (DsExcel Java) v9.2 add new workbook, PivotTable, export, security, formula-handling, and SpreadJS interoperability features. Document Solutions Data Viewer (DsDataViewer) v9.2 also adds support for loading XLTX Excel template files directly in browser-based viewing workflows.

The main v9.2 improvements include:

Read the full description of these updates in the full What’s New in Document Solutions for Excel blog.

Ready to Try Document Solutions v9.2?

Document Solutions v9.2 expands advanced document processing across JavaScript and .NET. DsPdfJS now supports digital signatures, PAdES workflows, tagged content, PDF structure trees, output intents, Form XObjects, associated files, custom annotation appearances, font inspection, and linearized PDF output. DsPdf .NET and DsPdfJS add new PDF/A-4 and PDF/UA-2 capabilities, along with 3D annotation support. The release also delivers more natural touchscreen zooming in DsPdfViewer, adds REF, NOTEREF, and STYLEREF field updating in DsWord .NET. Across DsExcel .NET, DsExcel Java, and DsDataViewer, v9.2 adds new PivotTable, workbook, export, formula-handling, interoperability, benchmark, and XLTX viewing capabilities.

Ready to check out the release? Download Document Solutions Today!

Tags:

Related Content

Try Our Document APIs

Document Solutions APIs Resources

Learn More About Document Solutions
Pricing
Licensing
Product Documentation
ComponentOne Technical Engagement Engineer Hunter Haaf

Hunter Haaf

Product Manager
comments powered by Disqus