Office-Inspired Products

Office File & PDF Document Processing APIs — June 2026 Roadmap (v26.1)

Maria Nikulina (DevExpress) — Mon, 23 Feb 2026 04:20:00 Z

We thank you for your continued support and for sharing your document processing needs and requirements with us. In this blog post, I’ll outline our development and release plans for the first half of 2026.

If you’d like to discuss this roadmap in greater detail or share a business use case that our Office File & PDF API library does not currently address, feel free to submit your feedback via the DevExpress Support Center. We’ll be happy to follow up.

The information contained within this blog post details our current/projected development plans. Please note that this information is being shared for INFORMATIONAL PURPOSES ONLY and does not represent a binding commitment on the part of Developer Express Inc. This roadmap and the features/products listed within it are subject to change. You should not rely on or use this information to help make a purchase decision about Developer Express Inc products.

Roadmap Updates

Our roadmap will be updated regularly to reflect development progress. As we get closer to the release, we expect to add additional items and modify the status of planned features. Look for the following labels next to every feature:

Planned — Feature is scheduled but not yet in development.
In Development — Under active development.
Coming in EAP v26.1 — Will be available in our first v26.1 early access preview.
Coming in v26.1 — Will be included in the final v26.1 release.
Released in v26.1 — Fully implemented and available.

Safe Word & Excel Document Processing

In Development

Our Office File API libraries will include new APIs to securely load and sanitize Microsoft Office(r) files (Word, Excel). These APIs will ship with the following capabilities:

Remove potentially harmful or malicious content (macros, embedded objects, links, scripts).
Remove sensitive, hidden, or private data (metadata, comments, tracked changes, optional content, and more).
Limit file size, complexity, or structure depth when uploading or saving files.

These enhancements will help ensure documents are safe to share and compliant with internal data protection policies.

Document Processing Libraries for JAVA

In Development

As part of our cross-platform expansion, we are broadening the footprint of DevExpress Office & PDF APIs (moving to the Java platform).

Important note: Once our Java Document Processing Library is released, it will be available as a separate/independent subscription. Java libraries will not be included in our .NET Office & PDF File API library.

The following libraries are expected to be available as an early beta in our v26.1 release cycle (and enhanced incrementally):

Barcode Generation API — A comprehensive library for generating barcodes (1D and 2D formats) within Java applications. This API will support common symbologies and image output formats making it suitable for labeling and scanning.
PowerPoint Presentation API — A non-visual PowerPoint processing API that parallels our .NET offering and allows Java developers to programmatically create, modify, and export PPTX files. Early support will focus on slide management, text and shape manipulation, and basic chart support.
PDF Document API — Core PDF file processing capabilities will be extended to Java and enable automated workflows for PDF generation, manipulation, data extraction, and export. Planned features include document creation, merging, form filling, annotating, and text management.

PDF Processing

New PDF Processing API

In Development

We will introduce new high-level APIs for PDF document generation and content management. These new APIs aim to significantly reduce the complexity of PDF document creation/editing and enable more fluent and flexible text-processing.

These new capabilities will allow you to:

Work with high-level document objects such as paragraphs, text fragments, images, shapes, interactive forms, and annotations.
Insert, read, search, remove, and format text using semantic PDF elements with full control over font, size, and style properties.
Work with RTL documents.
Automatically reflow content when text fragments are inserted/deleted.
Manually tag document objects.
Сopy and reuse high-level objects across PDF documents.

PDF/UA-2 Export

Planned

To further extend accessibility compliance in automated document workflows, we plan to introduce export options that target the PDF/UA-2 accessibility conformance level. With this capability, developers will be able to create PDFs with appropriate tags, semantics, and structural metadata required for accessibility tools (screen readers, assistive technologies).

PDF/A-4 Export

Planned

In v26.1, we expect to extend our PDF Document API’s export capabilities with PDF/A-4 compliance so that you can generate archival PDFs that meet current retention and regulatory requirements.

Excel Spreadsheet API

Excel to PDF/UA Conversion Enhancements

Planned

We’ll enhance our Excel to PDF/UA conversion engine to address accessibility issues related to graphical object tagging and artifact generation (for decorative content).

New Excel Functions

In Development

We will enhance our Spreadsheet calculation engine by adding support for modern, dynamic array-based Excel functions, including functions like:

XLOOKUP
XMATCH
SORT
FILTER
UNIQUE

Presentation API

Charts

In Development

In v26.1, the DevExpress Presentation API library will natively support Office/PowerPoint charts. New APIs will allow you to create, manipulate, and customize chart objects inside PowerPoint presentations (PPTX) programmatically. This includes support for:

Common MS Office chart types
Chart data initialization and binding
Data series and axis configuration
Visual format settings (titles, legends, colors, and more)

You will also be able to open, edit, and export existing PowerPoint presentations that contain charts without content loss.

Export Slides to Images

Coming in EAP v26.1

v26.1 will add the ability to export individual slides to raster and vector image formats:

BMP
PNG
JPEG
EMF
SVG
And more

This feature will allow you to generate thumbnail previews, create image-based slide wrappers for web or mobile consumption, and integrate slides into non-PPTX workflows in both Windows and Unix-based systems.

Your Feedback Counts

We appreciate your continued support. As I mentioned at the beginning of this post, if you have Office/PDF File API-related suggestions or requests, please submit a support ticket via the DevExpress Support Center — we'll be happy to review your feedback and follow up.

File & Document Processing APIs (Office/PDF File APIs) — Year-End Roadmap (v25.2)

Maria Nikulina (DevExpress) — Thu, 14 Aug 2025 06:30:00 Z

Thank you for your continued support and for sharing your document processing needs and requirements with us. In this blog post, I'll share our development/release plans for the second half of 2025. If you’d like to discuss this roadmap in greater detail or share a business use case that our Office File API product does not currently address, feel free to submit your feedback via the DevExpress Support Center. We’ll be happy to follow up.

Roadmap Updates

Our year-end roadmap will be updated regularly to reflect development progress. As we get closer to the release, we expect to add additional items and modify the status of planned features. Look for the following labels next to every feature:

Planned — Feature is scheduled but not yet in development.
In Development — Under active development.
Coming in EAP v25.2 — Will be available in our first v25.2 early access preview.
Coming in v25.2 — Will be included in the final v25.2 release.
Released in v25.2 — Fully implemented and available.

DevExpress MCP Server for AI-Powered Documentation Access

All Platforms
Available in Preview

We will introduce an MCP server that connects GitHub Copilot Chat, Cursor, and other MCP-compatible AI tools directly to our comprehensive documentation database. The server will provide instant access to over 300,000 help topics through natural language queries within your IDE. This will allow you and AI coding agents such as Claude Code to access current DevExpress documentation directly within the AI assistant's context.

Safe Document Processing (Discuss This Feature)

Postponed to v26.1

Our Office/PDF File API libraries will include new APIs to securely load and sanitize PDF and Office files (Word, Excel, and PowerPoint formats). These APIs will ship with the following capabilities:

Remove potentially harmful or malicious content (macros, embedded objects, links, scripts, etc).
Remove sensitive, hidden, or private data (metadata, comments, tracked changes, optional content, etc).
Limit file size, complexity, or structure depth when uploading or saving files.

These enhancements will help ensure documents are safe to share and compliant with internal data protection policies.

AI-powered Document Processing (Discuss This Feature)

Released in v25.2

We will introduce a new set of AI-powered file and document APIs designed to enhance productivity/streamline document workflows across the entire DevExpress Office/PDF File API suite.

These intelligent services will allow you to integrate advanced language models directly into document processing scenarios and leverage capabilities such as:

Summarization – Automatically generate concise summaries of Word, PDF, Excel, or PowerPoint documents.
Translation – Translate content between languages and preserve original document formatting and structure.
Proofreading – Detect and correct grammar, spelling, and style issues across document content.
Contextual Q&A – Ask questions about the content of a document and receive targeted responses.
And more.

Key capabilities:

Supports Word (DOCX), Excel (XLSX), PowerPoint (PPTX), and PDF file formats.
Seamless integration with the document object model (DOM) and structured document elements (paragraphs, shapes, cells, etc).
Real-time document editing and updates based on AI-generated suggestions.

Document Accessibility & Compliance

PDF/A Processing Enhancements (Discuss This Feature)

Released in v25.2

With v25.2, we will enhance PDF/A file processing capabilities (import, edit, and save) when using our PDF Document API. These improvements will help ensure that files remain PDF/A-compliant after modifications. We will also introduce APIs to read a document’s PDF/A conformance level and reset compliance status as needed.

Word to PDF/UA Conversion — Form Field Tagging

Released in v25.2

With our next release, DevExpress Word-processing tools will automatically add accessible tags for PDF form fields when users export Word documents with Content Controls to PDF/UA.

Excel to PDF/UA Conversion Enhancements (Discuss This Feature)

Postponed

We’ll enhance our Excel to PDF/UA conversion engine to address accessibility issues related to graphical object tagging and artifact generation (for decorative content).

PDF 2.0 & PDF/UA-2 Support (Research Phase)

Research Complete

During our v25.2 release cycle, we will begin work to support PDF 2.0 and PDF/UA-2 formats across the entire DevExpress Office File API product line.

Once our research phase is complete, we'll prioritize implementation steps to align our document processing libraries with modern standards and regulatory requirements.

Presentation API

Document Rendering Enhancements

Released in v25.2

We will refine our internal document layout engine to offer precise rendering of PowerPoint presentation content. This includes enhancements in how text, shapes, and layout elements are measured and drawn when you print or export presentations to PDF.

Tables (Discuss This Feature)

Released in v25.2

We plan to support PowerPoint table elements and introduce APIs to programmatically create and format structured tables inside slides.

This feature will include the following capabilities:

Insert tables with a specified number of rows and columns.
Manage table, row, column, and cell operations (insert, delete, resize, format).
Fill, modify, and clear table data.
Merge and split table cells.
Apply table styles and format individual cells (borders, shading, text alignment, background fills and more).

Themes (Discuss This Feature)

Released in v25.2

To improve presentation design consistency, we will support PowerPoint themes. This will include the ability to:

Apply and manipulate built-in or custom themes programmatically.
Modify a theme's color scheme.
Reset theme formatting.

OpenXml-based File Formats (Discuss This Feature)

Released in v25.2

We'll expand the range of supported PowerPoint file formats with the following OpenXml-based extensions:

POTX — PowerPoint Template
POTM — PowerPoint Macro-Enabled Template
PPTM — PowerPoint Macro-Enabled Presentation

PDF Document API

PDF Compression & Optimization

Image Compression Enhancements (Discuss This Feature)

Released in v25.2

We'll introduce support for additional image compression options. This will include settings for grayscale conversion to reduce file size when color fidelity is not required.

Combine & Compress PDF Object Streams (Discuss This Feature)

Released in v25.2

With v25.2, our PDF Processing API will include functionality to merge and compress PDF object streams to remove redundancy in internal data structures and reduce file overhead.

This capability will optimize both output file size and PDF load performance. Additionally, this will address file size growth issues when you merge multiple PDFs with pre-compressed streams into a single file.

Use Custom Fonts for PDF AcroForm Fields (Discuss This Feature)

Released in v25.2

We'll introduce the ability to use custom fonts (not registered in the system) for PDF fields (text boxes, signatures, etc) when using the DevExpress PDF Document API library for document generation or modification. Custom fonts registered in the DXFontRepository will be embeddable at runtime and applied to newly created or existing fields via the document model.

Word Document API

Enhanced Master-Detail Mail Merge (Discuss This Feature)

Released in v25.2

We will extend our Word Processing APIs and support mail merge operations based on hierarchical (master-detail) data sources. This feature will allow developers to bind nested collections directly to Word templates using standard merge field syntax. With this enhancement, you will be able to:

Define repeatable detail sections using region-based merge fields.
Use a single template to generate multi-level reports, invoices, or personalized documents.
Perform complex document generation from hierarchical business objects (for example, Customer → Orders, Order → Items).
Integrate with custom data sources.

Spreadsheet Document API

OLE Object Support Enhancements (Discuss This Feature)

Released in v25.2

In our end-of-year release, we will give you the capability to manage OLE Objects (load, modify, and save) in binary file formats:

XLS
XLSB

New Excel Functions (Discuss This Feature)

Postponed to v26.1

We will enhance our Spreadsheet calculation engine by adding support for modern, dynamic array-based Excel functions, including functions like:

XLOOKUP
XMATCH
FILTER
UNIQUE
And more

Your Feedback Counts

v25.1 - What’s New

If you have yet to review the features/capabilities introduced in our most recent major update, please visit the following webpage and let us know what you think of this release by responding to our online survey: Explore Our Newest Features (v25.1).

File & Document Processing APIs — New PowerPoint Presentation API Library

Maria Nikulina (DevExpress) — Wed, 13 Aug 2025 00:30:00 Z

We are happy to announce the CTP release of our new .NET PowerPoint Presentation API library (available with v25.1.4+). This library was designed to help you create, read, edit, convert, merge, split, and print Microsoft PowerPoint files within .NET apps.

In this blog post, I’ll describe the key features available in this Community Tech Preview, share product architecture insights, and demonstrate how you can create an application to manage presentation files in code.

Note: The DevExpress Presentation API Library is currently available as a Community Technology Preview (CTP).

Presentation API Overview

Cross-platform PowerPoint File Processing

The DevExpress Presentation API is built atop .NET and supports a broad range of platforms and operating systems out of the box. Whether you’re developing a traditional desktop application, a web backend, or a cross-platform solution, you can seamlessly integrate PowerPoint file processing without any dependency on Microsoft Office or PowerPoint installations.

Supported frameworks, operating systems, and environments include:

NET 8/9, .NET Framework 4.6.2+
Windows, Linux, macOS
Azure, AWS, Docker

Supported Formats and Document Elements

The current version (v25.1.x) of our PowerPoint Presentation API library allows you to import and save presentation files using the PPTX file format (and of course to print/export files to PDF).

The DevExpress Presentation library includes a comprehensive set of APIs and settings to create/manage presentation elements programmatically. You can add, access, modify, or remove the following PowerPoint document elements and customize associated settings:

Slides, Slide Layouts, Slide Master
Slide Notes, Note Master
Shapes, Connectors, Text Boxes, Images
Shape Text, Paragraphs, and Placeholders
Bullet and Numbered Lists
Presentation Header and Footer
Built-in and Custom Document Properties
Presentation View Properties

Code Example — Convert a Presentation to PDF

using DevExpress.Docs.Presentation;
//...
// Load a presentation
Presentation presentation = new Presentation(File.ReadAllBytes("mypresentation.pptx"));
// Export to PDF
presentation.ExportToPdf(new FileStream(@"D:\exported-document.pdf", FileMode.Create));

Key Features Designed to Manage Presentations

The DevExpress Presentation API gives you the power to programmatically create and organize presentation content. It supports the following usage-scenarios:

Add, clone, rearrange, resize, hide, or delete presentation slides.
Create, customize, and apply different slide layouts.
Access and update slide master content.
Merge multiple presentations or copy slides from one presentation to another.
Split one presentation to multiple presentations (slide-by-slide).
Extract or assign text to a specific paragraph, shape, slide, speaker note, or entire presentation.
Format text, paragraphs, shapes, and slide backgrounds.
Manage presentation metadata.

Code Example — Merge Two Presentations

using DevExpress.Docs.Presentation;
//...
// Load presentations
Presentation presentation1 = new Presentation(File.ReadAllBytes("presentation1.pptx"));
Presentation presentation2 = new Presentation(File.ReadAllBytes("presentation2.pptx"));
// Merge presentation slides
foreach (Slide slide in presentation2.Slides) { 
    presentation1.Slides.Add(slide);
}
// Save the merged document to the PPTX file
FileStream outputStream = new FileStream(@"D:\merged_presentation.pptx", FileMode.Create);
presentation.SaveDocument(outputStream);

Object-based Document Model

Unlike other PowerPoint-processing libraries that rely on interface-based document model, the DevExpress Presentation API library uses the concrete Object-oriented model. This architectural choice is designed to offer a cleaner, more flexible, and developer-friendly experience.

Using our Presentation API library, you can work directly with intuitive classes — Slide, Shape, TextParagraph, and so on. You can initialize document objects and configure all necessary settings prior to adding new elements to a presentation. This offers a natural and structured approach to flow-based document generation.

Additionally, you can reuse document elements and configuration settings across multiple slides and presentations. For example, you can add the same slide to multiple presentations or apply the same formatting to multiple slides or shapes (as illustrated in the example below).

// Create and apply the custom background to multiple slides in two different presentations
SolidFill fill = new SolidFill(Color.LightCyan);
CustomSlideBackground background = new CustomSlideBackground(fill);
presentation1.Slides[0].Background = background;
presentation1.Slides[1].Background = background;
presentation2.Slides[0].Background = background;

Our approach allows you to make changes in presentation documents with minimal code. At the same time, if you need unique instances to prevent unintentional changes, you can create independent clones of document elements and settings.

We’d appreciate your feedback on the object model we’ve chosen for this new library. Please feel free to share your thoughts via the survey at the end of this page.

Get Started with PowerPoint Presentation API

To start using the DevExpress Presentation API in your project, you need to:

1. Install the DevExpress.Docs.Presentation NuGet package (v25.1.4+) from Nuget.org.

dotnet add package DevExpress.Docs.Presentation --version 25.1.4

Alternatively, use the Local/Personal DevExpress NuGet feed: Use NuGet Packages to Install Office File API Components.

2. Add the DevExpress.Docs.Presentation namespace to your project file.

3. Create a Presentation instance.

Use the parameterless constructor to create a new presentation with one blank slide.
Use the constructor with a byte array or stream parameter to load an existing PPTX file.

4. Use APIs to build or modify the presentation (generate presentation content, apply formatting, update metadata, or reorganize slides).

5. Generate output.

Use Presentation.SaveDocument to save the presentation to PPTX .
Use Presentations.ExportToPdf to generate a PDF file.
Use Presentation.Print to print the presentation.

Code Example — Create a New Presentation from Scratch

using DevExpress.Docs.Presentation;
//...
// Create a presentation with a single empty slide
Presentation presentation = new Presentation();
        
// Configure Slide Master
SlideMaster slideMaster = presentation.SlideMasters[0];
slideMaster.Background = new CustomSlideBackground(new SolidFill(Color.FromArgb(194, 228, 249)));
        
// Add a new slide with content
presentation.Slides.Clear();
Slide slide1 = new Slide(slideMaster.Layouts.Get(SlideLayoutType.Title));
foreach (Shape shape in slide1.Shapes) {
    if (shape.PlaceholderSettings.Type is PlaceholderType.CenteredTitle) {
        shape.TextArea = new TextArea("Daily Testing Status Report");
    }
    if (shape.PlaceholderSettings.Type is PlaceholderType.Subtitle) {
        shape.TextArea = new TextArea($"{DateTime.Now: dddd, MMMM d, yyyy}");
    }
}
presentation.Slides.Add(slide1);
    
// Save Presentation to PPTX
FileStream outputStream = new FileStream(@"D:\mypresentation.pptx", FileMode.Create);
presentation.SaveDocument(outputStream);

Learn More

Documentation:

Demos & Examples:

Licensing

The PowerPoint Presentation API library is included in the DevExpress Office File API and DevExpress Universal subscriptions. A valid license is required to use this library in production code. For additional information, please visit our Buy page.

Your Feedback Matters

Since this is a CTP version, features are still in development. We’d love your input on what to prioritize next. Please take a moment to complete the short survey below.

You’re also welcome to share your thoughts and questions via the DevExpress Support Center.

Document Processing (Office File API) — Early Access Preview (v25.1) — Redaction API, Export Enhancements and More

Polina Fedorova (DevExpress) — Fri, 25 Apr 2025 01:40:00 Z

This post outlines what’s inside our current Early Access Preview build (v25.1), which is available for download for our Universal and DXperience subscribers.

Early Access and CTP builds are provided solely for early testing purposes and are not ready for production use. This build can be installed side by side with other major versions of DevExpress products. Please back up your project and other important data before installing Early Access and CTP builds. This EAP may not include all features/products we expect to ship in our v25.1 release cycle. As its name implies, the EAP offers an early preview of what we expect to ship in two months.

For additional information on new Document Processing/Office File API capabilities we expect to ship in June, please refer to our v25.1 roadmap.

PDF Redaction API (Discuss This Feature)

v25.1 will include new APIs to create and manage redaction annotations in PDF documents. This new capability makes it possible to completely remove sensitive or private content from your documents and add a colored overlay with text over the redacted area.

The redaction process includes two steps: create a redaction annotation with the required appearance in the PDF page area, and apply the redaction annotations by clearing the content in the redacted area and applying the overlay from the appearance settings. These steps are independent so you can implement the following usage scenarios:

Review workflow: Create redaction annotations, save the document, and send it for review. The recipient can approve or comment on the redactions before applying them.
On-demand redaction: Load a document with redaction annotations, inspect redacted areas and comments, and apply redactions if necessary.
Direct redaction: Create and apply all redaction annotations in your PDF document at once.

Below I'll describe how you can implement these usage scenarios in code.

Create a Redaction Annotation

The Redaction functionality is available via the PDF Facade API. To create a redaction annotation, obtain the PdfDocumentFacade instance, retrieve the required PDF page from the PdfDocumentFacade.Pages collection and call the PdfPageFacade.AddRedactAnnotation method. The AddRedactAnnotation method returns the PdfRedactAnnotationFacade object, which you can use to adjust the appearance settings for the redaction annotation. The appearance includes the overlay text, text font settings (font name, color, size, and style) and additional settings like text repeating, alignment and background color.

PdfDocumentProcessor pdfProcessor = new PdfDocumentProcessor();
pdfProcessor.LoadDocument("Demo.pdf");

PdfDocumentFacade documentFacade = pdfProcessor.DocumentFacade;
PdfRectangle pageCropBox = pdfProcessor.Document.Pages[0].CropBox;
PdfRectangle redactBounds =
	new PdfRectangle(0, pageCropBox.Height-50, 200, pageCropBox.Height);

// Add a redaction annotation at the top left corner of the first document page
PdfRedactAnnotationFacade redactAnnotation =
	documentFacade.Pages[0].AddRedactAnnotation(redactBounds);
redactAnnotation.Author = "Jane Doe";
// Setup the redaction annotation appearance
redactAnnotation.FillColor = new PdfRGBColor(0, 0, 0);
redactAnnotation.FontColor = new PdfRGBColor(1, 1, 1);
redactAnnotation.FontName = "Calibri";
redactAnnotation.FontSize = 0; // enables font auto-size
redactAnnotation.OverlayText = "Classified";
redactAnnotation.TextJustification = PdfTextJustification.Centered;
redactAnnotation.RepeatText = false;

// Save the document with the redaction annotation and send it for review
pdfProcessor.SaveDocument("output_to_review.pdf");

Apply Redaction Annotations

The new API allows you to apply a single redaction annotation, all annotations for a specific page, or all redaction annotations in the entire document. To complete, use the PdfRedactAnnotationFacade.Apply, PdfPageFacade.ApplyRedactAnnotations or PdfDocumentFacade.ApplyRedactAnnotations method respectively.

Additionally, it is possible to use PdfClearContentOptions to specify the type of the content that should be removed (text, graphics, images, or annotations) when you apply the redaction.

PdfDocumentProcessor pdfProcessor = new PdfDocumentProcessor();
pdfProcessor.LoadDocument("Demo.pdf");

PdfDocumentFacade documentFacade = pdfProcessor.DocumentFacade;
// Review redaction annotations and apply
foreach (var page in documentFacade.Pages)
{
    var redactionAnnotations =
    	page.Annotations.Where(annotation => annotation is PdfRedactAnnotationFacade).ToList();
    foreach(PdfRedactAnnotationFacade annotation in redactionAnnotations)
    {
        if (annotation.Author == "Jane Doe")
            annotation.Apply();
    }
}
// Apply redaction annotations for a page
documentFacade.Pages[0].ApplyRedactAnnotations();
// Apply redaction annotations for the whole document
documentFacade.ApplyRedactAnnotations();
// Specify the clear content settings and apply redaction annotations
documentFacade.ApplyRedactAnnotations(new PdfClearContentOptions()
{
     ClearAnnotations = true,
     ClearImages = true,
     ClearText = true,
     ClearGraphics = false
});

Usage in WinForms and WPF PDF Viewer Controls

Of course, it is also possible to enhance your WinForms or WPF PDF Viewer application with the new redaction functionality. Once you obtain the PdfDocumentFacade instance using the PdfViewer.GetDocumentFacade extension method, you will be able to create and apply redaction annotation using the APIs I described above.

Note: The PdfDocumentFacade class is defined in the DevExpress.Docs.v25.1.dll assembly. Add this assembly to your project or install the DevExpress.Document.Processor Nuget Package from the Offline Package source to use PdfDocumentFacade members. You need a license for the DevExpress Office File API Subscription or DevExpress Universal Subscription to use this class in production code.

We prepared the code example that illustrates how to select an area in a PDF document opened in a PDF Viewer application and apply the redaction annotation to this area. Here is the link for your reference: PDF Viewer for WinForms - Add Redaction Annotations Using Viewer Coordinates

AI-powered Behaviors in WinForms PDF Viewer (Discuss This Feature)

You can now integrate AI-powered Summarize, Translate and Ask AI features into our WinForms PDF Viewer. These functionalities allow you to summarize, translate to chosen languages and ask custom questions about the PDF content from the whole PDF document, active page or document selection. The target mode can be selected from the AI dialogs available via the PDF Viewer context menu.

AI MainDemo — Pdf Viewer

AI-powered behaviors for WinForms PDF Viewer use the same prerequisites and integration mechanisms as other AI extensions in our WinForms product line. You can learn more about the AI usage and integration in our documentation: DevExpress AI-powered Extensions for WinForms

Word Processing Document API and Rich Text Editors for WinForms and WPF

DOC Format Export Enhancements

During the last release cycle, we received feedback related to the DOC format export in our word processing components. After a particular update, Microsoft Word started to interpret DOC files generated from other documents with complex structures as invalid. Considering the popularity and importance of the DOC file format in word-processing usage scenarios, we made it our primary goal to address this limitation in the upcoming release.

Good news—in v25.1, we redesigned our DOC format export engine and successfully addressed these limitations. Now, all of the documents and usage scenarios with DOC format conversion you shared with us are working as expected and provide valid DOC output.

We would appreciate your feedback on this matter. If you have experienced issues with DOC format conversion and subsequently opening documents in Microsoft Word, please take a moment to evaluate our update (these changes are also available for v24.2) and leave your feedback here: Ticket Discussion

Right-to-Left (RTL) Engine Enhancements

We enhanced our Right-to-Left text rendering engine in the Word Processing Document API library and WinForms and WPF Rich Text components. This functionality enables correct text order in paragraphs, numbering lists, tables and shapes with bi-directional text (mixed Right-to-Left and Left-to-Right text blocks). The enhanced behavior applies when you preview or edit bi-directional text in visual Rich Text controls, or when you generate a PDF or image output (in the User Interface or code).

Convert Word Content Controls to PDF AcroForms Fields (Discuss This Feature)

We enhanced the Word Document to PDF export engine and supported the built-in conversion of Word content controls to PDF AcroForm fields. With this functionality, you can now create fillable PDF forms from your Word documents with ease.

Our Word-processing tools automatically convert the following content control types:

Plain Text;
Rich Text;
Picture;
Check Box;
Combo Box;
Drop-Down List;
Date Picker.

Note: Building Block and Repeating Section content controls are exported as regular text.
Due to PDF format specifics, PDF text fields generated from Rich Text content controls use formatting from the first word of the original Rich Text content control. Rich Text content controls that split between pages or contain complex objects (like tables) are exported as regular text.

To enable this feature, load your Word file with content controls or generate content controls in your document using the Word Processing Document API library or WinForms/WPF Rich Text Editor. Then, create a PdfExportOptions instance, enable the PdfExportOptions.ExportEditingFieldsToAcroForms property and call the ExportToPdf method with this PdfExportOptions object as a parameter. For visual controls, you can also enable this functionality from the User Interface using the Print Preview -> PDF Export Options dialog.

using DevExpress.XtraPrinting;
using DevExpress.XtraRichEdit;

using(RichEditDocumentServer wordProcessor = new RichEditDocumentServer())
{
    wordProcessor.LoadDocument("input_content_controls.docx");
    PdfExportOptions options = new PdfExportOptions();
    options.ExportEditingFieldsToAcroForms = true;
    wordProcessor.ExportToPdf("output_with_acroform.pdf", options);
}

Your Feedback Matters

As always, we value your feedback. Please take a moment to respond to the feature discussion tickets linked above and let us know how we can best serve your needs. Should you encounter an issue while using this Early Access Preview build (v25.1), please submit a support ticket via the DevExpress Support Center.

Document Processing Libraries (Office File API) — June 2025 Roadmap (v25.1)

Maria Nikulina (DevExpress) — Thu, 20 Feb 2025 21:00:00 Z

We thank you for your continued support and for sharing your document processing needs and requirements with us. In this blog post, I'll share our development/release plans for the first half of 2025.

If you’d like to discuss this roadmap in greater detail or share a business use case that our Office File API product does not currently address, feel free to submit your feedback via the DevExpress Support Center. We’ll be happy to follow up.

New PowerPoint API Presentation Library (Discuss This Feature)

Office File API
Coming in v25.1.4+

We expect to extend the capabilities of the DevExpress Office File API library with a new Presentation library for .NET.

This non-visual library will allow developers to generate, modify, print, and export PowerPoint presentations to different formats in code. We expect to support the following PowerPoint-related usage scenarios programmatically:

Create new presentations from scratch.
Save presentations using the PPTX (OpenXml) document format.
Merge multiple presentations into a single file.
Add, remove, and extract presentation slides; modify slide settings.
Add, remove, and customize slide elements (shapes, texts, tables and more).
Apply formatting to slide elements.
Print and export presentations to PDF.

Note: The CTP (Community Technology Preview) version of our PowerPoint Presentation Library is expected mid-year. As in any CTP, functional limitations will apply.

PDF Document API

PDF Document Compression (Discuss This Feature)

Office File API
Coming in v25.1

To reduce file size when saving PDF documents using DevExpress PDF Document APIs, we will introduce a compression engine for the PDF object streams. This engine will optimize PDFs for more efficient storage/sharing options. New compression mechanisms will apply to various document structures, including PDF forms, fonts, and graphics.

Redaction API (Discuss This Feature)

Office File API
Coming in v25.1

We’ll introduce a new Redaction API that allows users to secure PDF documents and permanently remove sensitive information. This feature will allow you to:

Erase personal or confidential data from a PDF document and prevent end-users from accessing, viewing or copying it.
Apply overlays with custom text or graphics over redacted areas.

WinForms and WPF PDF Viewers

AI-powered Behaviors (Discuss This Feature)

WinForms WPF
Coming in v25.1

We will integrate AI-powered features into our WinForms and WPF PDF Viewer components. These enhancements will allow users to quickly understand the underlying essence of individual documents via Generative AI summaries and translate documents to a preferred language using AI-powered translations.
Additionally, users will be able to interact with an AI-powered assistant directly within their applications and ask questions about PDF documents.

Note: Our implementation is based on the functionality provided by the Microsoft.Extensions.AI library. To access these features, you will need to register the IChatClient implementation in your app (based on the desired AI services provider: OpenAI, Azure Open AI, Google Gemini or local open-source models powered by Ollama).

Spreadsheet Document API and Spreadsheet Controls for Winforms & WPF

OLE Objects (Discuss This Feature)

Office File API WinForms WPF
Coming in v25.1

Spreadsheet components will support embedded and linked objects (OLE objects) within Excel documents. You will be able to import and save documents with OLE Objects to supported Excel formats without content loss. OLE Object icons will be properly displayed when you preview the document, print, or export it to PDF.
Additionally, we’ll introduce APIs to create, remove, and manage OLE objects in code.

New Excel Functions Support (Discuss This Feature)

Office File API WinForms WPF
Postponed to v25.2

We will enhance our Spreadsheet calculation engine by adding support for modern, dynamic array-based Excel functions. In v25.1, we will introduce functions like:

XLOOKUP
XMATCH
UNIQUE
And more

These functions will improve data lookup, filtering, and transformation capabilities across our Spreadsheet components.

Word Processing Document API and Rich Text Editors for Winforms & WPF

CJK (Chinese, Japanese and Korean) Text Wrapping (Discuss This Feature)

Office File API WinForms WPF
Coming in v25.1

To enhance document rendering and readability, our Word Processing library and Rich Text Editors will support CJK text wrapping and line breaking rules. This feature applies correct line breaks between characters for Chinese, Japanese, and Korean (CJK) text. Documents using these wrapping rules will be displayed, printed, and exported to PDF with appropriate formatting.

RTL (Right-to-Left) Engine Enhancements

Office File API WinForms WPF
Coming in v25.1

In our mid-year release v25.1, we will extend our RTL rendering engine for Rich Text components. This functionality will ensure correct rendering and PDF export for document paragraphs, tables and shapes containing bi-directional text (mixed Right-to-Left and Left-to-Right text blocks).

Export Word Content Controls to PDF AcroForm Fields (Discuss This Feature)

Office File API WinForms WPF
Coming in v25.1

We will enhance our Word-to-PDF export engine and support the conversion of Word content controls into PDF AcroForm fields. With this capability, you'll be able to import or generate Word documents with content controls in our Rich Text document editing tools, export these documents to PDF, and automatically generate corresponding AcroForm fields in PDF output. This feature will apply to the following content control types:

Plain Text Boxes
Check Boxes
Popups

Compare Word Documents (Discuss This Feature)

Office File API
Coming in v25.1

We will introduce new APIs to compare Word documents. This capability will allow you to:

Identify changes between two document versions.
Generate revision-based output highlighting.

Note: These new APIs will focus on detecting changes and making revisions for the visible document content only.

Your Feedback Counts

v24.2 - What’s New

Spreadsheet Control for WinForms and WPF – Sort and Filter by Color via the User Interface

Polina Fedorova (DevExpress) — Mon, 14 Oct 2024 00:20:00 Z

In a recent minor update (v24.1.4), we introduced new UI elements for both our WinForms and WPF Spreadsheet component libraries. These enhancements allow users to sort and filter spreadsheet data by color.

The following video showcases this new capability:

Should you encounter an issue while using these new user interface elements, please submit a support ticket via the DevExpress Support Center. We'll be happy to follow up.

PDF Document API — Using Layers (Optional Content Groups) to Control Visibility of PDF Graphics Objects (v24.1)

Margarita (DevExpress) — Wed, 28 Aug 2024 02:05:00 Z

Complex PDF documents such as CAD drawings, technical construction plans, layered artwork, maps, or multi-language documents are full of visual information. PDF layers are often used to simplify these documents and improve overall readability (layers allow you to selectively view/hide sections).

In this blog post, I'll introduce a couple of straightforward layer-related usage scenarios and show you how to use the DevExpress PDF Viewer and PdfDocumentProcessor (PDF Document APIs) to control layer visibility in your DevExpress-powered app (layer visibility support was introduced in v24.1).

Control Layer Visibility

You can set PDF layer visibility by using the PdfOptionalContentGroupVisibility.Visible property for the appropriate layer or within the Layers panel of the DevExpress PDF Viewer. To display a layer, click its associated check box (visible layers are signified with an "eye" icon).

You can also manage layer visibility through the Document Facade API. When a layer is added to a document, a user must specify the default configuration (layer settings based on state). For example, your configuration can specify that a given layer is hidden when viewed, but visible when printed. When you load a document, you can obtain the default layer configuration (PdfOptionalContentProperties.DefaultConfiguration property value) and specify the category used to enable layer settings:

View - settings applied to the layer in a view state (when you display a document in a viewer).
Print - settings applied to the layer in print preview mode or when you print the document.
Export - settings applied to the layer when you export a document.
Zoom - settings applied to the layer based on zoom level.
Language - language culture settings applied to the layer.

For example, if you set ActiveUsages to PdfOptionalContentUsageCategories.Print, only print settings from the default configuration are applied to layers when you print the document. Other default settings are automatically disabled. You can set ActiveUsages to none to disable all default settings and only apply current settings.

IMPORTANT NOTE: A PDF document only stores default content configuration. This means that layer visibility is not preserved when you save the document. Visibility settings are applicable when you preview the document in a PDF Viewer component, print the document, or export it to an image.

Use Case 1: Analyze Report Data from Different Perspectives

In this example, a PDF report with sales metrics includes multiple layers with comments for different people. You can control layer visibility within the PDF viewer when viewing the document. This allows you to display appropriate comments without increasing the number of report pages.

Use Case 2: Display Details when Zooming

In this instance, a PDF file with a map uses a different layer at 200% zoom (displays additional data).

Use Case 3: Label Documents when Printing

In this instance, the DevExpress logo is added to the printed document. The logo is placed on a separate layer and includes the following configuration settings:

it is hidden when you view the document but rendered when you print/export this document.

For this scenario, we enabled print usage for the configured layer:


using DevExpress.Pdf;
using System;
using System.Linq;
using DevExpress.Drawing;

static void Main(string[] args) {
    using (PdfDocumentProcessor processor = new PdfDocumentProcessor()) {
        processor.LoadDocument("PdfLayers.pdf");
        // Specify which settings from the default configuration will be applied for each layer contained in a document.
        processor.DocumentFacade.OptionalContentVisibility.ActiveUsages = PdfOptionalContentUsageCategories.Print;
        // Print the document.
        DXBitmap bitmap = processor.CreateDXBitmap(1, 1000);
        PdfPrinterSettings pdfPrinterSettings = new PdfPrinterSettings();
        processor.Print(pdfPrinterSettings);
    }
}

Output is as follows:

As I mentioned earlier, layer support was introduced in our v24.1 release cycle. Should you have any questions about this post or our PDF APIs/PDF Viewer components, please submit a support ticket via the DevExpress Support Center at your convenience.

Extending Excel Calculations with AI: Implementing User-Defined Formulas using the DevExpress WinForms Spreadsheet

Maria Nikulina (DevExpress) — Tue, 20 Aug 2024 04:10:00 Z

Overview

Standard Excel formulas address a variety of business requirements. Of course, like anything else in life, there are times when your enterprise will require additional capabilities to address a specific use case.

When it comes to spreadsheet calculations, user-defined formulas offer a variety of options for those who wish to introduce custom, task-specific calculations within Excel documents. User-defined formulas allow you to automate repetitive tasks, analyze data more efficiently, and execute advanced calculations not possible with built-in functions.

By integrating AI services, we can take Excel formula calculations to a whole new level. We can analyze large datasets more efficiently, incorporate pattern recognition, make predictions, and so much more.

In this blog post, I will incorporate a user-defined formula using the DevExpress WinForms Spreadsheet Control and illustrate how to utilize AI for advanced calculations.

Implementing User-Defined Formulas within the DevExpress WinForms Spreadsheet Control

In the following sections, I'll create a user-defined formula that uses AI services for spreadsheet calculations. Feel free to use my example as a starting point and if you encounter issues, please submit a ticket via the DevExpress Support Center. We'll be happy to follow up.

Note: I will be using the OpenAI service in the example below. Before you incorporate this solution in your app, please be sure to read and understand OpenAI’s license agreement and terms of use.

Step 1: Setting Up the DevExpress WinForms Spreadsheet Control

First, I'll need to add the DevExpress WinForms Spreadsheet Control to my project. If you are new to our WinForms product line (or the Spreadsheet Control), please follow our Spreadsheet: Getting Started guide.

Step 2: Setting Up the OpenAI Client

Once I've added the Spreadsheet Control to my project, I can install the Azure.AI.OpenAI NuGet package and create a class to register OpenAIClient. This client will be used in the custom formula class (to send requests to the AI service).

public static class AIFormulaClient
{
    public static OpenAIClient Client;
    static AIFormulaClient() => Client = new OpenAIClient("your OpenAI key");
}

Step 3: Creating a User-Defined Function

Next, I'll create a user-defined function (UDF) within my sample WinForms application. For purposes of this example, I'll define a function called AISummary. This function uses the AI service to generate a summary for a selected cell range.

The AISummaryFunction class implements the custom function and provides two parameters:

the first is a required parameter (specifies source cell range for the summary)
the second is an optional parameter used to set summary length in words.

The IFunction.Evaluate method retrieves parameter values and sends cell data (in CSV format) and the word count to the GetSummary method. This method generates a request using OpenAIClient and returns the response. The returned value (AI-generated summary) is used as the result of the formula evaluation.

public class AISummaryFunction : ICustomFunction
{
    const string functionName = "AISummary";
    readonly ParameterInfo[] functionParameters;

    public AISummaryFunction()
    {
        this.functionParameters = new ParameterInfo[] { 
                new ParameterInfo(ParameterType.Reference, ParameterAttributes.Required), 
                new ParameterInfo(ParameterType.Value, ParameterAttributes.Optional) };
    }

    public string Name { get { return functionName; } }
    ParameterInfo[] IFunction.Parameters { get { return functionParameters; } }
    ParameterType IFunction.ReturnType { get { return ParameterType.Value; } }
    bool IFunction.Volatile { get { return false; } }

    ParameterValue IFunction.Evaluate(IList<ParameterValue> parameters, EvaluationContext context)
    {
        int wordCount = 40;
        if (parameters.Count > 1)
            wordCount = (int)parameters[1].NumericValue;
        IWorkbook workbook = context.Sheet.Workbook;
        workbook.Options.Export.Csv.Range = parameters[0].RangeValue.GetReferenceA1();
        byte[] cellDataBytes = workbook.SaveDocument(DocumentFormat.Csv);
        string value = GetSummary(Encoding.UTF8.GetString(cellDataBytes), wordCount);
        return value;
    }
    string GetSummary(string cellRangeData, int wordCount)
    {              
        ChatCompletionsOptions chatCompletionsOptions = new ChatCompletionsOptions()
        {
            DeploymentName = "gpt-4-vision-preview",
            Messages =
        {
            new ChatRequestSystemMessage("You are a helpful assistant."),
            new ChatRequestUserMessage(
                new ChatMessageTextContentItem(string.Format("Please create summary in {0} words for the following excel data", wordCount)),
                new ChatMessageTextContentItem(cellRangeData))
        },
            MaxTokens = 300
        };

        Response<ChatCompletions> chatResponse = AIFormulaClient.Client.GetChatCompletions(chatCompletionsOptions);
        ChatChoice choice = chatResponse.Value.Choices[0];
        return choice.Message.Content;

    }
    string IFunction.GetName(CultureInfo culture)
    {
        return functionName;
    }
}

Step 4: Registering the Custom Function

In this step, I'll register the custom function.

public Form1()
{
    InitializeComponent();

    AISummaryFunction aiSummaryFunction = new AISummaryFunction();
    var globalFunctions = spreadsheetControl.Document.Functions.GlobalCustomFunctions;
    if (!globalFunctions.Contains(aiSummaryFunction.Name))
        globalFunctions.Add(aiSummaryFunction);
}

Step 5: Using the Custom Function within the Spreadsheet

I can now use the AISummary function in my spreadsheet (just like any other formula). I'll load my Excel file in the WinForms Spreadsheet Control or I can enter data for the summary into a cell range then apply the AISummary function to obtain my AI-generated summary.

Worksheet worksheet = spreadsheetControl.ActiveWorksheet;
worksheet["E2"].Formula = "AISummary(A2:D10, 50)";

Step 6: Testing

Of course, we can't forget testing...I'll test my new user-defined formula and ensure my AI integration/custom formulas work as expected.

Your Feedback Matters

As always, your feedback is very important. Please let us know whether additional AI-related samples/solutions are of interest to you and how you expect AI to change your development strategies in the next 12-months.

Office File API & Office-Inspired Desktop UI Controls — Year-End Roadmap (v24.2)

Maria Nikulina (DevExpress) — Mon, 15 Jul 2024 00:30:00 Z

We thank you for your continued support and for sharing your document processing needs and requirements with us. If you’d like to discuss this roadmap in greater detail or share a business use case that our Office File API product does not address, feel free to send your feedback using the survey below or submit a Support Center ticket. We’ll be happy to follow up.

Important Changes

.NET Framework 4.6.2 and .NET 8 Support

Our development plans are aligned with Microsoft's .NET Life Cycle and as such, we'll be ending .NET 7 (ended in May 2024) and .NET 6 support (will end November 2024) with our next major update (v24.2).

The minimal .NET Framework supported target will be v4.6.2, as it is the lowest framework version supported by Microsoft.

And finally, the oldest supported version of the Visual Studio IDE will be 2019 (our surveys indicate that 2019 and 2022 are used by the vast majority of our customers).

Please refer to the following announcement to learn more about this global change .NET — .NET 8 and .NET Framework 4.6.2 Are Minimally Supported Target Frameworks for DevExpress Libraries in v24.2..

.NET 9 Support

We will support .NET 9 across our product line for v24.2 and v24.1 after November 2024.

GDI+ (Libgdiplus) — End Of Support on Non-Windows systems

Office File API non-Windows
Completed

As you may already know, GDI+ (System.Drawing library) APIs are now marked for use in Windows-only environments (beginning with .NET 7).

Based on plans to shift to .NET 8 this year and the release of our cross-platform SkiaSharp-based engine last year, we will refactor our source code to remove all method calls related to GDI+ for non Windows-based environments (libgdiplus).

Support Skia for Windows Environment and Prepare to Deprecate the AzureCompatibility Property

Office File API Microsoft Azure
Completed

Multiple DevExpress products (specifically Reporting, Dashboards, and Office File API) ship with printing and export functionality for restricted environments such as Microsoft Azure, wherein certain GDI/GDI+ calls related to metafiles and font objects are unavailable. The AzureCompatibility.Enable property managed this capability.

With v23.2, we ended support for functionality offered by this property toggle for non-Windows environments and in our next major update (v24.2) we will continue in this direction. To achieve this, we will support Skia for non-visual Office File API libraries in Windows-based environments as well. Once complete we'll be ready to phase out the AzureCompatibility toggle.

This decision will help us focus development and maintenance efforts in a single direction and allow customers to use the DevExpress Office File API in cloud/restricted environments (for more information in this regard, refer to the following: Skia-based Cross-Platform Graphics Engine).

New AI-Powered Enhancements

WinForms WPF
Completed

We will integrate AI-Powered features into our WinForms and WPF Rich Text and Spreadsheet components. These enhancements will allow users to quickly understand the underlying essence of individual documents via Generative AI summaries and translate documents to a preferred language using AI-powered translations. In addition, we plan to give you the ability to describe images used within Office documents using AI-powered APIs.

To access these features, you will need to use your own Microsoft Azure Open AI API key or use local open-source models powered by Ollama and Onnx Runtime.

Spreadsheet Document API and Spreadsheet UI Controls for WinForms and WPF

Dynamic Array Formulas

WinForms WPF Office File API
Completed

Dynamic arrays are a modern and powerful way to work with Excel document formulas. Unlike standard array formulas, which return a single value for each cell with a formula, dynamic array functions return a dynamic array of values (this array of values automatically spills into neighboring cells). Dynamic arrays offer many advantages, including new functions (XLOOKUP, XMATCH, Sort, etc.).

We expect to enhance our formula calculation engine and integrate dynamic arrays into relevant DevExpress Spreadsheet-processing tools. Core functionality will include the following:

Dynamic array calculations (formulas) and Spill Range support.
New formula error type (#SPILL!).
Spill range reference (# symbol).
Implicit intersection operator (@ symbol) to return a single formula value instead of an array.

Embed Images in Cells

WinForms WPF Office File API
Completed

Modern versions of Microsoft Excel support a new locate image feature - "Place in Cell" (available from the Insert->Picture menu). This option gives you the ability to embed an image directly into a cell instead of placing it over worksheet content.

With v24.2, our Spreadsheet Document API library and desktop Spreadsheet UI controls (WinForms & WPF) will ship with "Place in Cell" image placement support. As you would expect, this new feature will allow you to import documents with images embedded in worksheet cells and save these documents to supported Excel formats without the content loss. Embedded cell images will be correctly displayed when you preview workbooks using our desktop Spreadsheet editors (WinForms & WPF) and when you print/export documents to PDF (and of course, we'll offer new APIs to manage embedded images in code).

PDF Document API and PDF Viewer for WinForms

Accessibility Enhancements

WinForms
Completed

We will continue to enhance accessibility support for our desktop document viewers. In our next release cycle, we will introduce screen reader support for the DevExpress WinForms PDF Viewer. With this enhancement, you will be able to read contents in Accessible PDF documents (based on tagged structure).

Signature Validation Enhancements

Office File API
Completed

v24.2 will ship with enhanced PDF Signature Validation APIs. New capabilities will include:

APIs to verify certificate revocation based on Online Certificate Status Protocol (OCSP) responses.
APIs to verify certificate revocation based on Certificate Revocation List (CRL).
APIs to validate Long Term Validation (LTV) signatures.
APIs to validate Document Level Timestamps.

Export PDF Documents to SVG

Cross-Platform Office File API
Completed

We will finalize "SVG Export" options for our Office File API libraries and extend existing image export APIs for the PDF Document Processor library (to convert PDF file pages to SVG images). This enhancement will allow you to generate vector document previews from PDF files in both Windows and non-Windows environments.

Image Extraction API

Office File API
Completed

To improve user experiences when extracting PDF content and analyzing document structure, we plan to enhance our image extraction APIs for the PDF Document API library. With our new APIs, you will be able to obtain additional information about PDF page images and determine image size and location on a page.

Word Processing Document API and Rich Text Editors for WinForms and WPF

Page Borders

WinForms WPF Office File API
Completed

Our Word-processing components will support Page Borders within Word documents. You will be able to import and save documents with page borders to supported Word formats without content loss. Page borders will be properly displayed when you preview the document, print it, or export it to the PDF. APIs to manage page borders in code will be also available.

Small Caps Formatting Support

WinForms WPF Office File API
Completed

With v24.2, our Word processing tools will support Small Caps character formatting. Small Caps formatting will be applied when you preview the document inside the UI control and when you print/export to PDF. We will also introduce API settings to manage Small Caps formatting in code (and enhance the Font dialog for our desktop Rich Text Editors (WinForms & WPF) to apply formatting via the UI).

Barcode Generation API

New Barcode Types — Aztec & Micro QR Code

Cross-Platform Office File API
Completed

v24.2 will allow you to generate two new barcode types: Aztec and Micro QR Code.

Aztec barcodes provide a compact and efficient way to encode large amounts of data without requiring a quiet zone, making them ideal for space-constrained documents.
Micro QR Codes offer a smaller alternative to traditional QR Codes, suitable for scenarios where space is limited and only small amounts of data need encoding.

Libraries - Resolve Missing Fonts

Cross-Platform Office File API
Completed

We plan to introduce a new API that will detect fonts used in documents but are missing in your application’s hosting environment (such as various Docker images, Azure App Service, etc.). This feature will allow you to identify and resolve missing fonts by adding them to the DXFontRepository before document generation begins. With this enhancement, you will be able to identify and address document appearance issues, ensuring that your documents appear as designed, regardless of the hosting platform.

Your Feedback Matters

We thank you for taking the time to review our year-end Roadmap. Please take a moment to answer the following survey question and let us know your thoughts on our plans for v24.2.

v24.1 - What's New

Word Processing Document API, Rich Text Editors (WinForms and WPF) — Reducing Document File Size (Best Practices)

Polina Fedorova (DevExpress) — Mon, 01 Jul 2024 01:05:00 Z

Reducing document file size can improve document import/processing related operations. It can also help minimize file storage requirements in databases and cloud servers. In this blog post, I will describe different strategies to reduce Microsoft Word document file size using our Word Processing APIs.

IMPORTANT NOTE: The strategies outlined below involve the removal of document content. Deleted content cannot be restored.

Simplify Your Documents

While obvious, document simplification is the best way to reduce/optimize file size. Simplification strategies include:

Where possible, use a limited set of styles to format document content.
Convert the document from DOCM to DOCX format to eliminate macros. You can also use our RichEditDocumentServer.Options.DocumentCapabilities.Macros option to disable macros.
Disable Track Changes before saving the document. RichEditDocumentServer includes a RichEditDocumentServer.Options.DocumentCapabilities.TrackChanges property designed to disable tracking.
Reduce graphics content.
Use linked OLE objects instead of embedded OLE objects. If you are unable to use linked OLE objects, you can reduce embedded OLE object size or remove it before saving. Refer to the following article for additional information on OLE object support: OLE Objects in Word Documents
Reduce the use of fields and content controls. Unlink or remove fields before saving (see Replace Fields with Field Values to learn more).
Replace charts with compressed images.
Remove additional metadata (XML data, document properties, comments, RTF theme data).
Divide long tables into multiple short tables. In most instances, long tables do not affect file size but slow document rendering and layout calculation.

Use the OpenXML Format Instead of Legacy Formats

The OpenXML format (DOCX) is modern, open, and compatible across multiple platforms. While more efficient in certain scenarios, legacy formats (such as DOC, RTF) are proprietary and less flexible. OpenXML files are essentially ZIP archives with XML files and additional resources (like images and styles). As such, DOCX files are easier to store in a database. You can use our RichEditDocumentServer.Save method to convert documents into the desired file format.

Do Not Embed Fonts

The DevExpress Word Processing Document API allows you to embed fonts into your document. While documents with embedded fonts maintain appearance characteristics across different computing devices, these documents are much larger in size. If your solution displays documents in a controlled/managed environment, we recommend the use of the DevExpress DXFontRepository class. Please refer to the following help topic for additional information: Load and Use Custom Fonts Without Installation on the System

Reduce Image Size

You can use a third-party app to compress document images. Once compressed, simply call the PictureFormat.SetPicture method to replace the original image(s) with its compressed equivalent(s).

The following code snippet replaces the original image with its compressed equivalent:

using (RichEditDocumentServer wordProcessor = new RichEditDocumentServer()) {
    wordProcessor.LoadDocument("doc_with_images.docx");
    Document document = wordProcessor.Document;
    Shape shape = document.Shapes[0];
    DXImage sourceImage = shape.PictureFormat.Picture.DXImage;
    MemoryStream imageStream  = new MemoryStream();
    sourceImage.Save(stream);
    //Compress the image saved in the stream
    //...
    DXImage compressedImage = DXImage.FromStream(updatedImageStream);
    shape.PictureFormat.SetPicture(compressedImage);
}

Another tip is not to crop images. Use a saved pre-cropped version instead. You can use the PictureFormat.SourceRect property to crop the image in code and then save the output. The PictureFormat.SetPicture method allows you to replace the image with its cropped version.

The following code snippet crops an image, saves it, and then replaces the original image with its cropped equivalent:

using (RichEditDocumentServer wordProcessor = new RichEditDocumentServer()) {
  wordProcessor.LoadDocument("CroppedImages.docx");
  Document document = wordProcessor.Document;
  Shape shape = document.Shapes[0];
      if (shape.PictureFormat != null) { 
        DXBitmap image = shape.PictureFormat.Picture.DXImage as DXBitmap;
        var rectOffset = shape.PictureFormat.SourceRect;
        RectangleF imageRect = new RectangleF(image.Width * rectOffset.LeftOffset, 
            image.Height * rectOffset.TopOffset, 
              image.Width - image.Width * rectOffset.LeftOffset - image.Width * rectOffset.RightOffset, 
                image.Height - image.Height * rectOffset.TopOffset - image.Height * rectOffset.BottomOffset);
        MemoryStream imageStream = new MemoryStream();
        image.Crop(imageRect).Save(imageStream, image.ImageFormat);
        DocumentImageSource source = DocumentImageSource.FromStream(imageStream);
        shape.PictureFormat.SetPicture(source);
        shape.PictureFormat.SourceRect = new RectangleOffset();
    }
}

If large image use is necessary and app architecture allows you to store images separately, you can employ the following workaround. Iterate the document's shape collection and save all images to a database with unique identifiers. Once complete, replace original document images with empty images, or DOCVARIABLE fields (for dynamic image replacement), or remove images and mark their position in the document with bookmarks. By using this strategy, you will be able to save a lightweight version of the document and restore original document images when necessary:

Document document = wordProcessor.Document;
// iterate through document images, save them to the database 
// and replace original images with an empty image
int imageID = 1; // generate an image ID as you require
DocumentImageSource emptyImageSource = DocumentImageSource.FromImage(new DXBitmap(1, 1));
for (int i = document.Shapes.Count - 1; i >= 0; i--)
{
    Shape shape = document.Shapes[i];
    if (shape.PictureFormat != null)
    {
        DXBitmap image = shape.PictureFormat.Picture.DXImage as DXBitmap;
        using (MemoryStream imageStream = new MemoryStream()) {
            image.Save(imageStream, image.ImageFormat);
            byte[] imageBytes = imageStream.ToArray();
            // save image bytes to the database with the specified image ID
            // ...
            // change the image name (if required) to identify it later
            shape.Name = "Image " + imageID.ToString();
            // replace the current image with the empty image
            shape.PictureFormat.SetPicture(emptyImageSource);
        }
        imageID++;
    }
}
// save the document with dummy images
using (MemoryStream documentStream = new MemoryStream())
    document.SaveDocument(documentStream, DocumentFormat.OpenXml);
 
//...
// restore document images
richEditControl.LoadDocument(documentStream, DocumentFormat.OpenXml);
Document document = richEditControl.Document;
for (int i = document.Shapes.Count - 1; i >= 0; i--)
{
    Shape shape = document.Shapes[i];
    if (shape.PictureFormat != null)
    {
        string imageName = shape.Name;
        // extract the required image from the database by name
        byte[] imageBytes = ...;
        using(MemoryStream imageStream = new MemoryStream(imageBytes))
        {
            // replace the empty image with the original image
            DocumentImageSource imageSource = DocumentImageSource.FromStream(imageStream);
            shape.PictureFormat.SetPicture(imageSource);
        }
    }
}

Your Feedback Counts

Help us shape the future of our Office/PDF File API libraries. Please take a moment to respond to the following survey questions: