DEV Community: Jeremy K.

Change Fonts in a Word Document with Python

Jeremy K. — Tue, 11 Aug 2026 08:50:20 +0000

Standardizing fonts across multiple Word documents is a common yet tedious task in daily office work. Whether you are preparing corporate reports, cleaning up inconsistent user submissions, or replacing missing fonts to prevent layout shifts, doing this manually—page by page—is inefficient and prone to missing text inside tables, headers, or text boxes.

By programmatically controlling document fonts with Python, you can automate this entire workflow. This guide explores how to use the Free Spire.Doc for Python library to modify font styles efficiently.

Setting Up the Environment

Start by installing the library via pip:

pip install spire.doc.free

Once installed, import the necessary modules into your script:

from spire.doc import *
from spire.doc.common import *

Core Concepts: CharacterFormat and ParagraphStyle

In the Free Spire.Doc object model, all font-related attributes—such as typeface, size, color, bold, and italic—are managed through the CharacterFormat property. Whether you are styling an entire paragraph or tweaking a specific word, your changes ultimately target this CharacterFormat object.

The ParagraphStyle class lets you define reusable custom styles. It includes a CharacterFormat property to control the visual appearance of text. Once you define a style, you add it to the document using Styles.Add() and apply it to any paragraph with ApplyStyle().

Scenario 1: Changing the Font of an Entire Paragraph

When you need to uniformly reformat all the text within a specific paragraph, creating and applying a paragraph style is the cleanest approach.

Code Example

from spire.doc import *
from spire.doc.common import *

# Load the document
doc = Document()
doc.LoadFromFile('Sample.docx')

# Target a specific paragraph (index starts at 0)
section = doc.Sections[0]
paragraph = section.Paragraphs[2]

# Define a new paragraph style
style = ParagraphStyle(doc)
style.Name = 'ParaFont'
style.CharacterFormat.FontName = 'Arial'
style.CharacterFormat.FontSize = 12
style.CharacterFormat.Bold = True
style.CharacterFormat.Italic = True
style.CharacterFormat.TextColor = Color.get_Red()

# Register and apply the style
doc.Styles.Add(style)
paragraph.ApplyStyle(style.Name)

# Save the updated document
doc.SaveToFile('output/ChangeParaFont.docx', FileFormat.Docx)
doc.Dispose()

How It Works

ParagraphStyle(doc) initializes a new style container.
The CharacterFormat properties define the exact font appearance (name, size, weight, color).
ApplyStyle() attaches your custom style to the target paragraph in one go.

This method is ideal for bulk formatting of headings, subheadings, or standard body text.

Scenario 2: Finding and Modifying Specific Text

If you only want to change the font for certain keywords or phrases, use the FindAllString method for precise text targeting.

Code Example

from spire.doc import Document, Color

doc = Document()
doc.LoadFromFile('Sample.docx')

# Locate all occurrences of the target text (case-sensitive)
selections = doc.FindAllString('target text', False, True)

# Update the font for each match
for selection in selections:
    text_range = selection.GetAsOneRange()
    text_range.CharacterFormat.FontName = 'Cambria'
    text_range.CharacterFormat.FontSize = 14
    text_range.CharacterFormat.TextColor = Color.get_Red()
    text_range.CharacterFormat.Bold = True

doc.SaveToFile('output/ChangeTextFont.docx', FileFormat.Docx)
doc.Dispose()

How It Works

FindAllString() scans the document and returns a list of TextSelection objects representing the found instances.
GetAsOneRange() converts a selection into a TextRange object, allowing direct manipulation of its CharacterFormat.

This approach is perfect for highlighting keywords, updating product names, or correcting specific terminology.

Important Considerations

Free Version Limits: The free edition of Spire.Doc is capped at processing 500 paragraphs per document. This is sufficient for most small-to-medium projects and evaluation purposes.
Resource Management: Always call Dispose() (or Close()) after saving to properly release system resources and avoid memory leaks.
Full Document Overhaul: To change the font of every piece of text in a document, you can iterate through Sections, then Paragraphs, then inspect each ChildObject. Whenever you encounter a TextRange, apply your font changes directly.

Summary

This article demonstrated two practical techniques for modifying fonts in Word documents using Python:

Paragraph-wide changes – using ParagraphStyle for consistent, reusable formatting.
Targeted text changes – using FindAllString to locate and update specific words or phrases.

Both methods operate entirely within Python and do not require Microsoft Office to be installed, making them highly suitable for server-side or automated batch-processing tasks.

How to Batch Extract PDF Form Data Using C#

Jeremy K. — Wed, 05 Aug 2026 01:46:00 +0000

In enterprise workflows, PDF forms are widely used for data collection. After users fill out a form, systems typically need to automatically extract the field values for storage, validation, or downstream processing. This article demonstrates how to read interactive PDF form fields—including text boxes, checkboxes, radio buttons, list boxes, and combo boxes—using C#.

1. Approach Overview

Every form field in a PDF has a unique name, a type indicator, and a current value. The overall process is straightforward:

Load the PDF document.
Access the form collection.
Iterate through all fields.
Extract the value according to each field’s type.

We’ll use the Free Spire.PDF for .NET library, which offers the PdfFormWidget class for form manipulation and supports field lookup by index or name.

2. Prerequisites

2.1 Install the NuGet Package

Install FreeSpire.PDF via the Visual Studio NuGet Package Manager, or run the following command in the Package Manager Console:

Install-Package FreeSpire.PDF

Once installed, the Spire.Pdf.dll reference is added automatically. Note that the free version limits processing to the first 10 pages per document, which is typically sufficient for form extraction.

2.2 Import Required Namespaces

using Spire.Pdf;
using Spire.Pdf.Widget;
using System;
using System.Text;

3. Basic Workflow for Reading Form Fields

3.1 Load the Document and Retrieve the Form

PdfDocument doc = new PdfDocument();
doc.LoadFromFile("YourForm.pdf");

// Cast to PdfFormWidget to access the full field collection
PdfFormWidget formWidget = doc.Form as PdfFormWidget;

The doc.Form property returns a generic form object; casting to PdfFormWidget gives you the complete field list.

3.2 Iterate Over All Fields

for (int i = 0; i < formWidget.FieldsWidget.List.Count; i++)
{
    PdfField field = formWidget.FieldsWidget.List[i] as PdfField;
    Console.WriteLine($"Field Name: {field.Name}");
}

4. Extracting Values by Field Type

Different field types store their values in different properties. Use type checking and casting to retrieve the correct data.

4.1 Text Box (`PdfTextBoxFieldWidget`)

if (field is PdfTextBoxFieldWidget textBoxField)
{
    Console.WriteLine($"TextBox - Name: {textBoxField.Name}, Value: {textBoxField.Text}");
}

4.2 Checkbox (`PdfCheckBoxWidgetFieldWidget`)

if (field is PdfCheckBoxWidgetFieldWidget checkBoxField)
{
    Console.WriteLine($"CheckBox - Name: {checkBoxField.Name}, Checked: {checkBoxField.Checked}");
}

4.3 Radio Button Group (`PdfRadioButtonListFieldWidget`)

if (field is PdfRadioButtonListFieldWidget radioBtnField)
{
    Console.WriteLine($"RadioButton - Name: {radioBtnField.Name}, SelectedValue: {radioBtnField.SelectedValue}");
}

4.4 List Box (`PdfListBoxWidgetFieldWidget`)

if (field is PdfListBoxWidgetFieldWidget listBoxField)
{
    Console.WriteLine($"ListBox - Name: {listBoxField.Name}, SelectedValue: {listBoxField.SelectedValue}");

    // List all available options
    foreach (PdfListWidgetItem item in listBoxField.Values)
    {
        Console.WriteLine($"  Option: {item.Value}");
    }
}

4.5 Combo Box (Drop‑down) (`PdfComboBoxWidgetFieldWidget`)

if (field is PdfComboBoxWidgetFieldWidget comboField)
{
    Console.WriteLine($"ComboBox - Name: {comboField.Name}, SelectedValue: {comboField.SelectedValue}");
}

5. Important Notes and Troubleshooting

5.1 Check for Empty Forms

Not all PDFs contain interactive forms. If doc.Form cannot be cast to PdfFormWidget, or if formWidget.FieldsWidget.Count is zero, the document has no form fields. In such cases, fall back to plain text extraction.

5.2 AcroForm vs. XFA Forms

PDF forms come in two standards:

AcroForm – Adobe’s native format, which is what this article covers (handled by PdfFormWidget).
XFA Forms – XML‑based forms, often created with Adobe LiveCycle. These require separate handling via formWidget.XFAForm, as their field structure and value access are entirely different.

5.3 Release Resources

Always close the document to free up resources:

doc.Close();

6. Summary

Successfully reading PDF form fields hinges on correctly identifying each field’s type and using the appropriate property to retrieve its value. The PdfFormWidget class provides a unified interface, and pattern matching with as makes type conversion clean and safe, covering most AcroForm scenarios.

In practice, it’s wise to first explore the field structure and naming conventions of your target PDF by iterating all fields. Then encapsulate the extracted data into a strongly typed model for business logic. This approach ensures accuracy, maintainability, and ease of future extension.

Pure Frontend RTF-to-PDF Conversion with JavaScript

Jeremy K. — Tue, 28 Jul 2026 03:06:09 +0000

Introduction

Converting document formats within a web application is a perennial challenge for frontend developers. Traditional approaches lean on server‑side APIs, but they introduce extra infrastructure costs, network latency, and privacy concerns. With WebAssembly (WASM) reaching broad browser support, it is now feasible to perform RTF‑to‑PDF conversion entirely on the client side. This article walks through a WASM‑based implementation that runs in the browser with no external service dependencies.

Setup and Installation

Before writing any code, complete the following preparatory steps.

1. Install the package

Use npm to add the document‑processing library:

npm i spire.office

This package supports multiple file formats; we will use only its RTF‑to‑PDF capability.

2. Deploy WASM assets

After installation, copy the required runtime files into your project's static directory (e.g., public/). The essential files are:

spire.doc.js
spire.common.js
Spire.Doc.Wasm.zip
Spire.Common.Wasm.zip
_framework/ (entire folder)

After placing them in public/, your directory structure should resemble:

public/
├── spire.doc.js
├── spire.common.js
├── Spire.Doc.Wasm.zip
├── Spire.Common.Wasm.zip
├── _framework/
│   └── ...
└── static/
    ├── font/          # TrueType fonts (e.g., times.ttf)
    └── data/          # Sample RTF input files (optional)

3. Prepare font files

To ensure correct text rendering in the output PDF, place the necessary TrueType font files in the static font directory (e.g., public/static/font/). This example uses Times New Roman; you can substitute any fonts licensed for your use case.

Important: Verify that you have the legal right to distribute and use these fonts within your application.

Once these assets are in place, you are ready to implement the conversion logic.

Architecture Overview

Our solution leverages WebAssembly to compile a robust document‑processing library into a WASM module that executes directly in the browser. The architecture consists of four layers:

Loader – dynamically imports the WASM module using import().
Virtual File System (VFS) – emulates a file system inside the WASM memory, enabling the module to read/write files without touching the host OS.
Conversion Engine – the WASM core that parses RTF and generates PDF data.
Output Handler – extracts the PDF from the VFS and triggers a browser download.

Core Implementation

1. Loading the WASM Module

We use a React useEffect hook to manage the module lifecycle, loading it asynchronously on demand:

useEffect(() => {
  (async () => {
    try {
      const publicUrl = process.env.PUBLIC_URL || '';
      // Dynamic import – webpackIgnore prevents bundling interference
      const spireModule = await import(
        /* webpackIgnore: true */ `${publicUrl}/spire.doc.js`
      );
      const rawModule = spireModule.default || spireModule;
      // Initialize the WASM instance; locateFile tells it where to fetch .wasm binaries
      window.wasmModule = typeof rawModule === 'function'
        ? await rawModule({ 
            locateFile: p => p.endsWith('.wasm') 
              ? `${publicUrl}/${p}` 
              : p 
          })
        : rawModule;
      setWasmModule(window.wasmModule);
    } catch (error) {
      console.error('Failed to load WASM module:', error);
    }
  })();
}, []);

The locateFile callback is critical—it guides the runtime to the correct URL for the .wasm files. The /* webpackIgnore: true */ comment prevents Webpack from attempting to resolve the dynamic path at build time.

2. Virtual File System (VFS) Setup

Because the WASM module runs in a sandbox, it cannot access the host file system directly. We populate an in‑memory VFS with all required resources (fonts and input documents) using the provided FetchFileToVFS helper:

// Load fonts into the VFS under the expected path
await window.spire.FetchFileToVFS(
  'times.ttf',
  '/Library/Fonts/',
  `${publicUrl}/static/font/`
);
await window.spire.FetchFileToVFS('timesbd.ttf', '/Library/Fonts/', `${publicUrl}/static/font/`);
await window.spire.FetchFileToVFS('timesbi.ttf', '/Library/Fonts/', `${publicUrl}/static/font/`);
await window.spire.FetchFileToVFS('timesi.ttf', '/Library/Fonts/', `${publicUrl}/static/font/`);

Fonts are essential for accurate PDF output—without them, characters may render as missing glyphs.

3. Conversion Workflow

The core conversion function performs these steps:

Writes the input RTF file into the VFS.
Instantiates a Document object.
Loads the RTF from the VFS.
Saves it as a PDF (also into the VFS).
Reads the generated PDF data from the VFS.
Creates a downloadable Blob and triggers the download.
Cleans up resources.

const convertRtfToPdf = async () => {
  const wasmModule = window.wasmModule.spiredoc;
  if (!wasmModule) return;

  // Place the input file into the VFS
  await window.spire.FetchFileToVFS(
    'input.rtf',
    '',
    `${process.env.PUBLIC_URL}/static/data/`
  );

  const doc = new wasmModule.Document();
  doc.LoadFromFile('input.rtf');

  const outputFileName = 'RtfToPdf.pdf';
  doc.SaveToFile({
    fileName: outputFileName,
    fileFormat: wasmModule.FileFormat.PDF
  });

  // Read the PDF from the VFS
  const pdfData = window.dotnetRuntime.Module.FS.readFile(outputFileName);

  // Trigger download
  const blob = new Blob([pdfData], { type: 'application/pdf' });
  const url = URL.createObjectURL(blob);
  const a = document.createElement('a');
  a.href = url;
  a.download = outputFileName;
  a.click();

  // Release object URL and dispose document
  URL.revokeObjectURL(url);
  doc.Dispose();
};

4. Cleanup

WASM memory is not garbage‑collected automatically; you must explicitly release files and objects to avoid leaks:

// Remove temporary files from the VFS
window.dotnetRuntime.Module.FS.unlink('input.rtf');
window.dotnetRuntime.Module.FS.unlink('RtfToPdf.pdf');

// Dispose the Document instance
doc.Dispose();

Browser support: This approach relies on WebAssembly and Blob URLs, which are supported in all modern browsers (Chrome, Firefox, Safari, Edge). No fallback is provided for legacy browsers.

Conclusion

By harnessing WebAssembly, we have built a client‑side RTF‑to‑PDF converter that eliminates server dependencies and reduces both cost and complexity. The key benefits are:

Low latency – all processing occurs locally, with zero network round‑trips.
Reduced infrastructure – no need to maintain or scale conversion servers.
Enhanced privacy – user documents never leave the browser, avoiding third‑party exposure.

That said, this approach has its limits. Very large files or extremely complex layouts may still benefit from a server‑side fallback. Evaluate your specific performance requirements and document complexity to decide whether a pure frontend solution suffices, or whether a hybrid client‑server model is more appropriate.

Writing Data to Excel Documents Using C++

Jeremy K. — Wed, 22 Jul 2026 02:07:47 +0000

I. Overview

In C++ development, programmatically generating and writing data to Excel documents is a common enterprise requirement, spanning report exports, data archiving, and automated report generation. Compared to solutions that depend on Microsoft Office automation components, dedicated Excel processing libraries offer distinct advantages, including independent deployment, stable performance, and no need for an installed Office environment.

This article provides a systematic guide to implementing Excel data writing with the Spire.XLS for C++ library—covering everything from environment setup to various data-writing techniques, including single-cell updates, batch data population, and style formatting.

II. Environment Setup

2.1 Obtaining and Integrating the Library

Spire.XLS for C++ can be integrated via NuGet: right-click the project in Solution Explorer, select Manage NuGet Packages, search for Spire.XLS.Cpp, and install it.

2.2 Including Header Files

After installation, include the main header file in your source code:

#include "Spire.Xls.o.h"
using namespace Spire::Xls;

III. Core Object Model

Spire.XLS for C++ uses an object model that mirrors the hierarchical structure of an Excel document:

Workbook – Represents the entire Excel workbook and serves as the top-level entry point for operations.
Worksheet – Represents a single worksheet within the workbook.
CellRange – Represents a cell or a range of cells, used for reading/writing data and applying styles.

The following code demonstrates how to create a new workbook and retrieve its first worksheet:

// Create a Workbook object
intrusive_ptr<Workbook> workbook = new Workbook();
// Get the first worksheet (index starts from 0)
intrusive_ptr<Worksheet> sheet = 
    dynamic_pointer_cast<Worksheet>(workbook->GetWorksheets()->Get(0));

IV. Writing Data to Cells

4.1 Writing Text Values

Use Worksheet->GetRange(int row, int column) to target a specific cell (both row and column indices start at 1), then call CellRange->SetText() to write text:

// Target row 1, columns 1–3 and write headers
sheet->GetRange(1, 1)->SetText(L"Name");
sheet->GetRange(1, 2)->SetText(L"Age");
sheet->GetRange(1, 3)->SetText(L"Department");

4.2 Writing Numeric Values

For numeric data, use CellRange->SetNumberValue():

sheet->GetRange(2, 2)->SetNumberValue(29);
sheet->GetRange(3, 2)->SetNumberValue(27);

4.3 Writing Date and Time Values

Date/time values can be written as text and combined with a custom number format:

sheet->GetRange(2, 4)->SetText(L"2021-02-26");
// Apply a date format
sheet->GetRange(2, 4)->SetNumberFormat(L"yyyy-mm-dd");

4.4 Complete Example: Employee Information Table

The following example creates a worksheet containing employee records with name, age, department, and hire date:

#include "Spire.Xls.o.h"
using namespace Spire::Xls;

int main() {
    // Specify the output file path
    std::wstring outputPath = L"Output\\";
    std::wstring outputFile = outputPath + L"EmployeeData.xlsx";

    // Create a Workbook object
    intrusive_ptr<Workbook> workbook = new Workbook();

    // Get the first worksheet
    intrusive_ptr<Worksheet> sheet = 
        dynamic_pointer_cast<Worksheet>(workbook->GetWorksheets()->Get(0));

    // Write header row
    sheet->GetRange(1, 1)->SetText(L"Name");
    sheet->GetRange(1, 2)->SetText(L"Age");
    sheet->GetRange(1, 3)->SetText(L"Department");
    sheet->GetRange(1, 4)->SetText(L"Hire Date");

    // Write data rows
    sheet->GetRange(2, 1)->SetText(L"Hazel");
    sheet->GetRange(2, 2)->SetNumberValue(29);
    sheet->GetRange(2, 3)->SetText(L"Marketing");
    sheet->GetRange(2, 4)->SetText(L"2021-02-26");

    sheet->GetRange(3, 1)->SetText(L"Tina");
    sheet->GetRange(3, 2)->SetNumberValue(27);
    sheet->GetRange(3, 3)->SetText(L"Human Resource");
    sheet->GetRange(3, 4)->SetText(L"2020-07-13");

    sheet->GetRange(4, 1)->SetText(L"Amy");
    sheet->GetRange(4, 2)->SetNumberValue(35);
    sheet->GetRange(4, 3)->SetText(L"Development");
    sheet->GetRange(4, 4)->SetText(L"2019-04-01");

    // Save the workbook
    workbook->SaveToFile(outputFile.c_str(), ExcelVersion::Version2013);
    workbook->Dispose();

    return 0;
}

V. Batch Writing

Writing data cell by cell is inefficient for large datasets. Spire.XLS for C++ provides the Worksheet->InsertArray() method, which allows you to write a std::vector of data into a specified cell range in a single operation.

Basic usage example:

// Prepare a 2D data array
wstring twoDimensionalArray[4][3] = {
    { L"Region", L"Q1 Sales", L"Q2 Sales" },
    { L"East China", L"125000", L"138000" },
    { L"North China", L"98000", L"105000" },
    { L"South China", L"112000", L"120000" }
};

// Determine row and column counts
int rowNum = sizeof(twoDimensionalArray) / sizeof(twoDimensionalArray[0]);
int columnNum = sizeof(twoDimensionalArray[0]) / sizeof(twoDimensionalArray[0][0]);

// Convert each row of the 2D array into a vector and insert it
for (size_t i = 0; i < rowNum; i++)
{
    vector<LPCWSTR> vec_temp;
    for (size_t j = 0; j < columnNum; j++)
    {
        vec_temp.push_back(twoDimensionalArray[i][j].c_str());
    }
    // Insert the row vector starting at column 1 of the target row
    sheet->InsertArray(vec_temp, 4 + i, 1, false);
}

VI. Important Considerations

Indexing convention – Row and column indices are 1-based, matching the Excel interface.
Memory management – Always call Dispose() on Workbook and Worksheet objects after use to properly release resources.
Wide strings – All text parameters must be wide strings (L"..." or std::wstring), as the library uses Unicode encoding internally.
File format – When saving, use the ExcelVersion enumeration to specify the output format. Supported versions include Version97to2003 (.xls) and Version2013 (.xlsx), among others.
Exception handling – In production code, wrap file I/O and data operations in try-catch blocks to gracefully handle potential exceptions.

VII. Summary

Through the three core classes—Workbook, Worksheet, and CellRange—developers can seamlessly handle everything from individual cell updates to large-scale batch imports. The library's vector-based bulk insertion mechanism, combined with its rich styling capabilities, makes generating professionally formatted Excel reports in C++ applications both highly efficient and fully controllable.

Compare Two Word Documents Using Python

Jeremy K. — Wed, 15 Jul 2026 02:52:32 +0000

In everyday office workflows—whether reviewing contracts, iterating on technical documentation, or editing official correspondence—comparing different versions of a Word document is a frequent and critical task. While Microsoft Word provides a built-in "Compare" feature, manual processing falls short when you need to handle batch operations or integrate document diffing into automated CI/CD and business pipelines.

This article demonstrates how to automate Word document comparison using Python and the Free Spire.Doc for Python library.

Note: Free Spire.Doc for Python is a free-to-use library (with certain page limitations). It runs independently of Microsoft Office and works seamlessly in any standard Python environment.

1. Environment Setup

1.1 Installing the Library

Install the free Python library directly via pip:

pip install Spire.Doc.Free

1.2 Core API Overview

The Document class provides the Compare() method, which compares the current document against another. Its signature is:

document.Compare(Document document, string author)

document: The other Document object to compare against.
author: The reviewer name that will appear in the revision markers.

After comparison, all differences are recorded as Track Changes in the original document object. Saving it produces a standard Word file with visible revision marks.

2. Basic Document Comparison

2.1 Minimal Code Example

The following minimal script loads two documents, compares them, and outputs a result file with all revisions:

from spire.doc import *
from spire.doc.common import *

# Load the original document (baseline version)
firstDoc = Document("Original.docx")

# Load the revised document (target version)
secondDoc = Document("Revised.docx")

# Compare: identify all changes in secondDoc relative to firstDoc
# The second argument specifies the reviewer name shown in the revision marks
firstDoc.Compare(secondDoc, "System Auditor")

# Save the result as a new document
firstDoc.SaveToFile("Comparison_Result.docx", FileFormat.Docx2016)

# Release resources
firstDoc.Dispose()
secondDoc.Dispose()

The logic is concise: instantiate two Document objects, call Compare(), and save. The library handles all the heavy lifting.

2.2 Output Result

The generated Comparison_Result.docx contains full revision marks:

Additions are shown with underlines or in a distinct color.
Deletions are shown with strikethrough.
Each change includes the reviewer's name and timestamp metadata.

3. Customizing Comparison Behavior

In many real‑world cases, you may want to ignore stylistic changes (e.g., font, size, color) and focus solely on content modifications. The CompareOptions class gives you fine‑grained control over what differences are flagged.

3.1 Ignoring Formatting Differences

from spire.doc import *
from spire.doc.common import *

firstDoc = Document("Original.docx")
secondDoc = Document("Revised.docx")

# Configure comparison options
compareOptions = CompareOptions()
compareOptions.IgnoreFormatting = True

# Pass the options into the comparison
firstDoc.Compare(secondDoc, "System Auditor", compareOptions)

firstDoc.SaveToFile("Comparison_Result_ContentOnly.docx", FileFormat.Docx2016)

firstDoc.Dispose()
secondDoc.Dispose()

With IgnoreFormatting = True, only text insertions, deletions, and rewording are marked; all formatting changes are silently ignored.

3.2 Additional Options

Depending on your library version, CompareOptions may offer further controls:

Property	Description
`IgnoreFormatting`	Ignore font, size, color, and paragraph styling.
`IgnoreHeadersAndFooters`	Ignore differences in headers and footers.
`TextCompareLevel`	Controls comparison granularity; defaults to word-level (`Word`).

4. Summary

With just a few lines of Python, the Free Spire.Doc library turns Word document comparison into a fast, reliable, and automated process. Key benefits include:

Automation-ready: Easily scale to batch processing hundreds of documents.
Environment‑independent: No Microsoft Office installation required.
Highly customizable: Fine‑tune which differences to flag (formatting, headers, granularity).
Standard output: Generates native Word documents with familiar Track Changes markup.

Whether you're streamlining document auditing, version control, or regulatory compliance workflows, this approach eliminates tedious manual checks—saving time, reducing human error, and empowering teams to focus on higher‑value decisions.

Java: Word to TXT Conversion

Jeremy K. — Wed, 08 Jul 2026 06:29:17 +0000

In routine software development, converting Word documents to plain text is a frequently encountered requirement, commonly seen in use cases such as content retrieval, text analysis, data ingestion, and batch document preprocessing. Rather than parsing Word's binary format directly, leveraging a mature document-processing library can significantly reduce development effort. This article demonstrates how to quickly convert Word (DOC/DOCX) files to TXT using the Free Spire.Doc for Java library, complete with code examples and key considerations.

1. Common Approaches

Word documents are essentially structured files containing rich content—styles, formatting, images, tables, and more. The core objective of plain-text extraction is to strip away formatting while preserving the readable textual content.

There are generally several technical paths to achieve Word-to-TXT conversion:

Parsing with Apache POI: Offers high flexibility but requires handling format differences across various Word versions and involves a larger code footprint.
Calling Office automation interfaces: Depends on a local Office installation, which incurs high server deployment and maintenance costs.
Using third-party document libraries: Provides well-designed, high-level APIs, operates without Office dependencies, and significantly boosts development productivity.

Free Spire.Doc for Java falls into the third category. It runs independently without requiring Microsoft Office, offers solid support for both DOC and DOCX formats, and features an intuitive API design—making it a practical choice for quickly implementing conversion functionality.

2. Maven Dependency Configuration

Add the official repository and the free-version dependency to your pom.xml:

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>
<dependency>
    <groupId>e-iceblue</groupId>
    <artifactId>spire.doc.free</artifactId>
    <version>14.3.1</version>
</dependency>

3. Core Implementation for Word-to-TXT Conversion

The conversion process is straightforward and concise, boiling down to just three core steps: Load → Save → Release.

import com.spire.doc.Document;
import com.spire.doc.FileFormat;

public class WordToTxtConverter {
    public static void main(String[] args) {
        // 1. Create a Document instance
        Document doc = new Document();

        // 2. Load the Word document (supports .doc and .docx)
        doc.loadFromFile("C:\\input\\sample.docx");

        // 3. Save as TXT format
        doc.saveToFile("C:\\output\\converted.txt", FileFormat.Txt);

        // 4. Release resources
        doc.dispose();
    }
}

The saveToFile method preserves paragraph breaks, and the overall output structure corresponds faithfully to the original paragraph order.

4. Advanced Usage and Batch Processing

Batch Conversion

To convert multiple Word documents in batch, combine the conversion logic with directory traversal:

import java.io.File;
import com.spire.doc.Document;
import com.spire.doc.FileFormat;

public class BatchWordToTxt {
    public static void main(String[] args) {
        String inputDir = "C:\\word_files\\";
        String outputDir = "C:\\txt_output\\";

        File folder = new File(inputDir);
        File[] files = folder.listFiles((dir, name) -> 
            name.endsWith(".doc") || name.endsWith(".docx"));

        if (files != null) {
            for (File wordFile : files) {
                Document doc = new Document();
                doc.loadFromFile(wordFile.getAbsolutePath());

                String outputPath = outputDir + 
                    wordFile.getName().replaceAll("\\.docx?$", ".txt");
                doc.saveToFile(outputPath, FileFormat.Txt);
                doc.dispose();

                System.out.println("Converted: " + wordFile.getName());
            }
        }
    }
}

Extracting Text Without Saving to a File

If you only need the text content for in‑memory processing—for example, to store it in a database—use the getText() method:

Document doc = new Document();
doc.loadFromFile("sample.docx");
String textContent = doc.getText();  // Retrieve plain text content
doc.dispose();
// Proceed with further processing on textContent

5. Common Issues and Considerations

5.1 Free Version Limitations

The free edition imposes upper limits on the number of paragraphs and tables. It is well-suited for personal learning, small utility tools, and feature validation, but may not be appropriate for large-scale production use.

5.2 Encoding Issues

When using saveToFile to output TXT directly, the default encoding is UTF-8.
If your target system requires GBK encoding, you can switch the encoding format during the file-writing stage.

5.3 Resource Management

The Document object consumes memory resources. Always call dispose() after use to release them. In batch-processing scenarios, it is advisable to release resources immediately after each file to prevent OutOfMemoryError.

5.4 Handling of Non-Text Content

Since TXT does not support images, table borders, font styling, or other rich formatting, the following behavior applies after conversion:

Images are omitted and will not appear in the output.
Table content is converted to plain text in cell order, losing its original row/column structure.
Hyperlinks retain only the visible display text, not the underlying URLs.

If you need to preserve more formatting details, consider converting to intermediate formats such as HTML or Markdown.

The examples above show how to accomplish the core conversion logic with just a few lines of code. For scenarios that do not require deep customization of formatting, this approach offers low development costs and rapid integration, satisfying most text-extraction needs.

In real-world projects, it is recommended to perform a balanced evaluation based on document volume, concurrency, and formatting requirements. For small-scale batch processing, the free version is sufficient for a quick start. For production environments with high concurrency and large documents, further performance benchmarking and exploration of alternative solutions are strongly advised.

Reorder Excel Columns with C#

Jeremy K. — Wed, 01 Jul 2026 02:36:53 +0000

When processing data or generating reports in .NET applications, reordering Excel columns is a common requirement—whether to match downstream system schemas, improve data readability, or standardize layouts across multiple files. While drag-and-drop works fine for one-off tasks with small files, batch processing and automated workflows demand a code-based solution.

This article walks through how to rearrange Excel column positions using a free, lightweight .NET library—without requiring Microsoft Office to be installed.

You can install the free library via NuGet Package Manager by searching for Free Spire.XLS.

After installation, add the following using directive to your code file:

using Spire.Xls;

Core Strategy

Free Spire.XLS doesn’t expose a dedicated Reorder() API. Instead, we implement column reordering with a simple three-step approach:

Create a temporary worksheet and clone the full data from the target worksheet.
Copy columns from the temporary sheet back to the original sheet, following the new desired order.
Delete the temporary worksheet.

This "backup, overwrite, clean up" pattern ensures that all data, formatting, and column widths are fully preserved.

Complete Code Example

using System.Linq;
using Spire.Xls;

namespace ReorderExcelColumns
{
    class Program
    {
        static void Main(string[] args)
        {
            // 1. Load the source Excel file
            Workbook workbook = new Workbook();
            workbook.LoadFromFile(@"C:\sample.xlsx");

            // 2. Reference the first worksheet
            Worksheet worksheet = workbook.Worksheets[0];

            // 3. Define the target column order (0‑based indices)
            // Example: Move the original 4th column (index 3) to the front,
            // shifting columns 1–3 to the right.
            int[] newColumnOrder = new int[] { 3, 0, 1, 2, 4, 5 };

            // 4. Create a temporary sheet and clone all data from the original
            Worksheet tempSheet = workbook.Worksheets.Add("temp");
            tempSheet.CopyFrom(worksheet);

            // 5. Reorder columns by copying from the temporary sheet
            for (int i = 0; i < newColumnOrder.Length; i++)
            {
                tempSheet.Columns[newColumnOrder[i]].Copy(
                    worksheet.Columns[i],
                    true,   // Copy cell values
                    true    // Copy formatting
                );

                // 6. Preserve column width for consistency
                worksheet.Columns[i].ColumnWidth =
                    tempSheet.Columns[newColumnOrder[i]].ColumnWidth;
            }

            // 7. Remove the temporary sheet
            workbook.Worksheets.Remove(tempSheet);

            // 8. Save the reordered workbook
            workbook.SaveToFile("Reordered.xlsx", FileFormat.Version2016);
        }
    }
}

Key API Reference

API	Description
`Workbook.LoadFromFile()`	Loads an existing Excel workbook
`Workbook.Worksheets.Add()`	Creates a new blank worksheet
`Worksheet.CopyFrom()`	Copies all data and formatting from one sheet to another
`Worksheet.Columns[index].Copy()`	Copies a specific column (values + optional formatting) to a target column
`Worksheet.Columns[index].ColumnWidth`	Gets or sets the width of a column
`Workbook.SaveToFile()`	Saves the workbook to disk

Typical Use Cases

Batch restructuring – Apply the same column order to hundreds of Excel files in a single run.
UX-focused presentation – Promote key identifiers (like order IDs or dates) to the leftmost positions for better readability.
Automated reporting pipelines – Standardize column sequences during ETL or report generation flows.
Data consolidation – Align Excel imports from disparate sources into a uniform column structure before merging.

How to Read Hyperlinks from Word in C# (Free .NET Library)

Jeremy K. — Mon, 22 Jun 2026 07:37:01 +0000

Are you looking for a lightweight way to extract hyperlinks from Word documents in your .NET application? Whether you are performing a large-scale content audit, migrating website data, or automating document processing workflows, programmatically reading hyperlinks is a common developer requirement.

This tutorial provides a complete, low-code solution using the Free Spire.Doc for .NET component. We will cover how to read URL addresses, anchor text (display text), and even screen tips from .doc and .docx files—without requiring Microsoft Office to be installed on your machine.

Understanding Word Hyperlink Fields (Technical Background)

Before diving into the code, it helps to understand how Word stores links. In Microsoft Word, hyperlinks are not plain text; they are stored as Field objects within the document structure.

Each hyperlink field consists of two critical components:

Component	Description
Anchor Text (Display Text)	The visible, clickable text the user sees in the document.
URL / Link Address	The hidden target destination stored in the field code.

By iterating through the document's hierarchical object model (Document → Sections → Paragraphs → Fields), we can capture these elements precisely.

Setting Up Your C# Environment

To get started, you need to install the required library and include the necessary namespaces.

1. Install the Free Spire.Doc Package

The easiest way to integrate the library is via the NuGet Package Manager. Run the following command in the Package Manager Console:

Install-Package FreeSpire.Doc

⚠️ Note: This free edition has page restrictions, making it ideal for small to medium-sized document processing tasks.

2. Import Required Namespaces

Add the following using statements at the top of your code file to access the document parsing methods:

using Spire.Doc;
using Spire.Doc.Documents;
using Spire.Doc.Fields;
using System.Collections.Generic;
using System.IO;
using System.Text;

Step-by-Step: C# Code to Extract Hyperlinks

Let's break down the core extraction logic into manageable steps. We will traverse the document, filter for hyperlink fields, and output the results.

Step 1: Load the Word Document

Create a Document object and load your target file (supports both .doc and .docx).

Step 2: Traverse Sections and Paragraphs

Since Word uses a nested structure, we must iterate through all Sections and their Paragraphs.

Step 3: Filter Hyperlink Fields

Within each paragraph, check if a child object is of type Field. If so, verify that its Type equals FieldType.FieldHyperlink.

Step 4: Extract and Export Data

For every identified hyperlink, read the FieldText (Anchor Text) and Code (URL) properties, then save them to a text file.

Full Source Code Example

Here is the complete, ready-to-run C# program for extracting hyperlinks:

using Spire.Doc;
using Spire.Doc.Documents;
using Spire.Doc.Fields;
using System.Collections.Generic;
using System.IO;
using System.Text;

namespace ExtractHyperlinks
{
    class Program
    {
        static void Main(string[] args)
        {
            // 1. Initialize and load the Word document
            Document doc = new Document();
            doc.LoadFromFile(@"sample.docx");

            // 2. Storage list for hyperlink fields
            List<Field> hyperlinks = new List<Field>();

            // 3. Traverse the document hierarchy
            foreach (Section section in doc.Sections)
            {
                foreach (DocumentObject secObj in section.Body.ChildObjects)
                {
                    if (secObj.DocumentObjectType == DocumentObjectType.Paragraph)
                    {
                        Paragraph paragraph = secObj as Paragraph;

                        foreach (DocumentObject paraObj in paragraph.ChildObjects)
                        {
                            // Identify Field objects
                            if (paraObj.DocumentObjectType == DocumentObjectType.Field)
                            {
                                Field field = paraObj as Field;

                                // Filter specifically for hyperlinks
                                if (field.Type == FieldType.FieldHyperlink)
                                {
                                    hyperlinks.Add(field);
                                }
                            }
                        }
                    }
                }
            }

            // 4. Build and write the output
            StringBuilder sb = new StringBuilder();
            foreach (Field hyperlink in hyperlinks)
            {
                sb.AppendLine("Display Text: " + hyperlink.FieldText);
                sb.AppendLine("URL Address: " + hyperlink.Code);
                sb.AppendLine();
            }

            File.WriteAllText("Hyperlinks.txt", sb.ToString());
            doc.Close();

        }
    }
}

Going Further: Extracting Screen Tips

Many hyperlinks contain a ScreenTip—the descriptive text that appears when a user hovers over the link. While the basic extraction above gets the URL and text, you can parse the Field Code to capture the tip.

The field code typically looks like this:

Standard: HYPERLINK "https://example.com"
With ScreenTip: HYPERLINK "https://example.com" \o "Visit our homepage"

Add this logic to extract the hover text:

// Get the display text
string anchorText = field.FieldText;

// Get the raw field code string
string fieldCode = field.GetFieldCode();

// Extract the URL (between the first pair of quotes)
string url = fieldCode.Split('"')[1];

// Extract the screen tip if the \o switch exists
string screenTip = string.Empty;
if (fieldCode.Contains("\\o"))
{
    // The screen tip is usually in the third pair of quotes
    screenTip = fieldCode.Split('"')[3].Trim();
}

Summary

Extracting hyperlinks from Word documents in C# is a straightforward process once you understand the Field structure. By using the Free Spire.Doc for .NET library, you can reliably read display text, URLs, and screen tips with just a few dozen lines of code.

Key Benefits of this Approach:

✅ No Microsoft Office interop required.
✅ Ideal for server-side and automated batch scripts.
✅ Easy to extend—you can update URLs by modifying the Code property.

Try this solution today to supercharge your document data extraction workflows. If you need to process hyperlinks in bulk, simply loop through multiple files and aggregate the results into a database or JSON file.

Applying Multiple Font Styles in Excel Using C#

Jeremy K. — Wed, 17 Jun 2026 08:39:05 +0000

In Excel report generation and data templating, distinguishing titles, headers, data rows, and key metrics via font styles is essential for readability. Varying font names, sizes, colors, and typefaces helps guide the reader’s eye and emphasizes critical information. This article demonstrates how to programmatically apply rich font formatting to Excel cells using C# and the Spire.XLS for .NET library.

1. Setting Up the Development Environment

Before writing any code, add the Spire.XLS library to your project. You can install it via the NuGet Package Manager (search for Spire.XLS) or run the following command in the Package Manager Console:

Install-Package Spire.XLS

The library supports .NET Framework, .NET 5+, and other modern .NET platforms. Once installed, reference the Spire.Xls namespace to get started.

2. Key Font Properties

The ExcelFont object provides the following configurable properties for styling cell text:

Property	Description
`FontName`	Font family name (e.g., Microsoft YaHei, Arial).
`Size`	Font size in points.
`Color`	RGB color value.
`IsBold` / `IsItalic`	Toggle bold or italic emphasis.
`Underline`	Underline style.
`IsStrikethrough`	Toggle strikethrough.
`IsSuperscript` / `IsSubscript`	Toggle superscript or subscript.

3. Common Font Application Scenarios

3.1 Styling a Single Cell

The most basic usage—ideal for setting a title or emphasizing a single data point—is achieved via the CellRange.Style.Font property.

using Spire.Xls;

class Program
{
    static void Main(string[] args)
    {
        Workbook workbook = new Workbook();
        Worksheet sheet = workbook.Worksheets[0];

        sheet.Range["A1"].Text = "Sales Data Summary";

        CellStyle style = sheet.Range["A1"].Style;
        style.Font.FontName = "Microsoft YaHei";
        style.Font.Size = 16;
        style.Font.IsBold = true;
        style.Font.Color = System.Drawing.Color.DarkBlue;

        workbook.SaveToFile("BasicFontSettings.xlsx", ExcelVersion.Version2016);
    }
}

3.2 Applying Different Fonts Across Cell Ranges

In practical reports, headers, data bodies, and summary rows usually follow distinct style guidelines. You can apply fonts to entire ranges in bulk.

// Header range (A2:D2)
CellRange headerRange = sheet.Range["A2:D2"];
headerRange.Style.Font.FontName = "Arial";
headerRange.Style.Font.Size = 12;
headerRange.Style.Font.IsBold = true;
headerRange.Style.Font.Color = System.Drawing.Color.White;
headerRange.Style.Color = System.Drawing.Color.SteelBlue; // Background for contrast

// Data range (A3:D6)
CellRange dataRange = sheet.Range["A3:D6"];
dataRange.Style.Font.FontName = "Arial";
dataRange.Style.Font.Size = 11;

// Summary row (A7:D7)
CellRange totalRange = sheet.Range["A7:D7"];
totalRange.Style.Font.FontName = "Arial";
totalRange.Style.Font.Size = 12;
totalRange.Style.Font.IsBold = true;
totalRange.Style.Font.Color = System.Drawing.Color.DarkRed;

3.3 Mixing Multiple Fonts Inside a Single Cell

To emphasize specific words or numbers within a cell (e.g., "Amount: 1200 RMB"), use the RichText feature. It allows you to assign independent font styles to different character segments.

sheet.Range["A9"].Text = "Note: Monthly sales increased by 15% year-on-year, achieving quarterly target";

RichText richText = sheet.Range["A9"].RichText;

// Create reusable font objects via the workbook
ExcelFont fontNormal = workbook.CreateFont();
fontNormal.FontName = "Arial";
fontNormal.Size = 11;
fontNormal.Color = Color.Black;

ExcelFont fontRed = workbook.CreateFont();
fontRed.FontName = "Arial";
fontRed.Size = 11;
fontRed.IsBold = true;
fontRed.Color = Color.Red;

ExcelFont fontItalic = workbook.CreateFont();
fontItalic.FontName = "Arial";
fontItalic.Size = 11;
fontItalic.IsItalic = true;
fontItalic.Color = Color.Green;

// Apply a default style to the entire text first
richText.SetFont(0, 22, fontNormal);

// Override specific segments (startIndex, length)
richText.SetFont(0, 3, fontNormal);          // "Note:" (indices 0–2)
richText.SetFont(12, 3, fontRed);            // "15%" (indices 12–14)
richText.SetFont(16, 6, fontItalic);         // "achieving quarterly target" (indices 16–21)

Note: The SetFont method takes a zero-based start index and a character length.

3.4 Bulk Styling for Entire Rows or Columns

To apply a uniform style across a full row or column without iterating through individual cells, target the Rows or Columns collection directly.

// Style the entire first row
sheet.Rows[0].Style.Font.FontName = "Microsoft YaHei";
sheet.Rows[0].Style.Font.Size = 14;

// Style the entire third column
sheet.Columns[2].Style.Font.FontName = "Arial Narrow";
sheet.Columns[2].Style.Font.Size = 10;

4. Complete Code Example

The following comprehensive example combines all the techniques above into a fully runnable demo:

using Spire.Xls;
using System.Drawing;

namespace ExcelFontDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            using (Workbook workbook = new Workbook())
            {
                Worksheet sheet = workbook.Worksheets[0];
                sheet.Name = "Sales Report";

                // 1. Title
                sheet.Range["A1"].Text = "Product Sales Summary - Q2 2024";
                sheet.Range["A1:D1"].Merge();
                sheet.Range["A1"].Style.Font.FontName = "Microsoft YaHei";
                sheet.Range["A1"].Style.Font.Size = 18;
                sheet.Range["A1"].Style.Font.IsBold = true;
                sheet.Range["A1"].Style.Font.Color = Color.DarkSlateGray;
                sheet.Range["A1"].HorizontalAlignment = HorizontalAlignType.Center;
                sheet.SetRowHeight(1, 25);

                // 2. Headers
                string[] headers = { "Product Name", "Quantity Sold", "Unit Price (RMB)", "Sales Amount (RMB)" };
                for (int i = 0; i < headers.Length; i++)
                {
                    sheet.Range[2, i + 1].Text = headers[i];
                }
                sheet.Range["A2:D2"].Style.Font.FontName = "Arial";
                sheet.Range["A2:D2"].Style.Font.Size = 12;
                sheet.Range["A2:D2"].Style.Font.IsBold = true;
                sheet.Range["A2:D2"].Style.Font.Color = Color.White;
                sheet.Range["A2:D2"].Style.Color = Color.Teal;

                // 3. Data rows (using InsertArray)
                object[,] data = {
                    { "Product A", 120, 89.9, 10788 },
                    { "Product B", 256, 45.5, 11648 },
                    { "Product C", 89, 199.0, 17711 }
                };
                sheet.InsertArray(data, 3, 1);
                sheet.Range["A3:D5"].Style.Font.FontName = "Arial";
                sheet.Range["A3:D5"].Style.Font.Size = 11;

                // 4. Summary row
                sheet.Range["A6"].Text = "Total";
                sheet.Range["D6"].Formula = "=SUM(D3:D5)";
                sheet.Range["A6:D6"].Style.Font.FontName = "Arial";
                sheet.Range["A6:D6"].Style.Font.Size = 12;
                sheet.Range["A6:D6"].Style.Font.IsBold = true;
                sheet.Range["A6:D6"].Style.Font.Color = Color.DarkRed;

                // 5. Remarks with RichText
                string remark = "Note: Red-highlighted data indicates over-achievement; quarterly target completion rate is 112%";
                sheet.Range["A8"].Text = remark;
                RichText richText = sheet.Range["A8"].RichText;

                ExcelFont fontGray = workbook.CreateFont();
                fontGray.FontName = "Arial";
                fontGray.Size = 10;
                fontGray.Color = Color.Gray;

                ExcelFont fontRed = workbook.CreateFont();
                fontRed.FontName = "Arial";
                fontRed.Size = 10;
                fontRed.Color = Color.Red;
                fontRed.IsBold = true;

                ExcelFont fontGreen = workbook.CreateFont();
                fontGreen.FontName = "Arial";
                fontGreen.Size = 10;
                fontGreen.Color = Color.Green;
                fontGreen.IsBold = true;

                richText.SetFont(0, remark.Length, fontGray);
                richText.SetFont(2, 3, fontRed);      
                richText.SetFont(17, 5, fontGreen);   

                // Auto-fit columns for a clean look
                sheet.AllocatedRange.AutoFitColumns();

                workbook.SaveToFile("ExcelMultiFontExample.xlsx", ExcelVersion.Version2016);
            }
        }
    }
}

By mastering the CellRange.Style.Font property and the RichText functionality, you can address a wide variety of business requirements—from basic report formatting to advanced, visually layered data presentations. This flexible approach enables you to consistently produce clean, professional Excel outputs while keeping your C# code concise and maintainable.

Adding Text Watermarks to PDF Documents with C#

Jeremy K. — Thu, 11 Jun 2026 07:09:01 +0000

In C# development, adding text watermarks to PDFs is a common requirement for copyright protection, document status labeling and content misuse prevention. Automating watermarking via code is far more efficient and manageable than manual operation with desktop PDF tools, especially for batch processing.

This guide demonstrates how to use the free library Free Spire.PDF for .NET to implement two typical text watermark types in C#: full-page tiled background watermarks and single localized watermarks. We also cover common customizations including transparency and rotation angle configuration.

1. Environment Preparation

1.1 Install Free Spire.PDF

You can install the library via Visual Studio’s NuGet Package Manager:

Right-click your project → Manage NuGet Packages
Search for FreeSpire.PDF and install the latest stable release.

Alternatively, run the command below in the Package Manager Console:

Install-Package FreeSpire.PDF

Note: This is a free community edition. It has a usage limit: it only processes the first 10 pages of a PDF. Extra pages will be silently truncated without throwing exceptions. This library is ideal for small PDF files, development and testing scenarios.

1.2 Import Required Namespaces

Add the following references at the top of your code file:

using Spire.Pdf;
using Spire.Pdf.Graphics;
using System.Drawing;

2. Create Tiled Background Watermarks

PdfTilingBrush is a built-in tiling brush from Free Spire.PDF. By defining tile width and height, you can generate repeating grid-style watermarks across the entire page. This approach works perfectly for background labels such as Internal Use Only or Draft.

Below is the complete implementation code:

using Spire.Pdf;
using Spire.Pdf.Graphics;
using System.Drawing;

namespace TextWatermarkDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // Use using statement to auto-release PDF resources (C# best practice)
            using (PdfDocument pdf = new PdfDocument())
            {
                pdf.LoadFromFile("sample.pdf");

                // Set tile size to control watermark spacing
                float tileWidth = 260f;
                float tileHeight = 260f;

                // Initialize tiling brush
                PdfTilingBrush brush = new PdfTilingBrush(new SizeF(tileWidth, tileHeight));

                // Set watermark transparency (0.0 = fully transparent, 1.0 = fully opaque)
                brush.Graphics.SetTransparency(0.3f);
                brush.Graphics.Save();

                // Move drawing origin to tile center + rotate canvas
                brush.Graphics.TranslateTransform(brush.Size.Width / 2, brush.Size.Height / 2);
                brush.Graphics.RotateTransform(-45); // Rotate 45 degrees counterclockwise

                // Define font (Microsoft YaHei, size 24, embedded)
                PdfTrueTypeFont font = new PdfTrueTypeFont("Microsoft YaHei", 24f, PdfFontStyle.Regular, true);
                string watermarkText = "Internal Document";

                // Draw centered watermark text inside each tile
                brush.Graphics.DrawString(
                    watermarkText,
                    font,
                    PdfBrushes.Gray,
                    0,
                    0,
                    new PdfStringFormat(PdfTextAlignment.Center, PdfVerticalAlignment.Middle));

                brush.Graphics.Restore();
                brush.Graphics.SetTransparency(1f);

                // Apply tiled watermark to every page
                foreach (PdfPageBase page in pdf.Pages)
                {
                    page.Canvas.DrawRectangle(
                        brush,
                        new RectangleF(0, 0, page.Canvas.ClientSize.Width, page.Canvas.ClientSize.Height)
                    );
                }

                // Export the final PDF
                pdf.SaveToFile("output.pdf");
            }
        }
    }
}

Code Explanation

Tile Size: tileWidth and tileHeight control the gap between repeated watermarks. The page will be fully filled with tiles of this dimension.
PdfTilingBrush: When used to draw a full-page rectangle, it automatically tiles the predefined graphic across the entire area.
Transparency: SetTransparency() adjusts watermark opacity with a range from 0.0 to 1.0.
Coordinate Transformation: TranslateTransform shifts the drawing point to the tile center; RotateTransform tilts the watermark for a better visual effect.
Font Setting: PdfTrueTypeFont supports custom system fonts and font embedding.
Page Rendering: Loop through all pages and draw the tiling brush over the full page canvas.

3. Add a Single Localized Text Watermark

If you only need a standalone watermark at a specific position (header, footer, corner, etc.), draw text directly on the page canvas with specified coordinates. This lightweight method is suitable for copyright statements, company names and page markers.

using Spire.Pdf;
using Spire.Pdf.Graphics;
using System.Drawing;

namespace TextWatermarkDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            using (PdfDocument pdf = new PdfDocument())
            {
                pdf.LoadFromFile("sample.pdf");

                foreach (PdfPageBase page in pdf.Pages)
                {
                    // Semi-transparent solid color brush
                    PdfBrush brush = new PdfSolidBrush(Color.FromArgb(60, Color.DarkBlue));
                    // Use built-in PDF standard font (no embedding, smaller file size)
                    PdfFont font = new PdfFont(PdfFontFamily.TimesRoman, 22f);
                    string waterText = "© 2026 Copyright";

                    // Calculate coordinates for bottom-right placement
                    float x = page.ActualSize.Width - 220;
                    float y = page.ActualSize.Height - 40;

                    // Draw watermark at target position
                    page.Canvas.DrawString(waterText, font, brush, x, y);
                }

                pdf.SaveToFile("simple_watermark.pdf");
            }
        }
    }
}

Key Parameter Explanation

Alpha Transparency: Color.FromArgb(Alpha, Color) — the alpha value ranges from 0 to 255; a smaller value means higher transparency.
Standard PDF Font: PdfFontFamily.TimesRoman is a native PDF font. It requires no font embedding and reduces file size, but only supports Latin characters.
Page Dimension: page.ActualSize retrieves the real width and height of the page for relative positioning.

Positioning Guide

Use the formulas below to place watermarks accurately (add custom margins as needed):

Bottom-right: x = Page Width - Text Width - Margin, y = Page Height - Margin
Bottom-left: x = Margin, y = Page Height - Margin
Page center: x = (Page Width - Text Width) / 2, y = (Page Height - Text Height) / 2

Tip: Use font.MeasureString() to get the exact text size for precise layout and avoid text overflow.

4. Best Practices & Usage Notes

4.1 Watermark Type Selection

Choose the solution based on your business scenario:

Scenario	Recommended Solution
Full-page background labels (document classification, internal files, draft marks)	Tiled background watermark
Copyright notices, company names, page numbers	Single localized watermark
Repeating tilted watermarks that do not obscure main content	Tiled watermark + low transparency

4.2 Optimize Tiled Watermarks

Tile Size: Set tileWidth and tileHeight between 200–400pt. Too small causes text overlap; too large results in sparse watermarks.
Font Size: 18–28pt is recommended. Keep the font size noticeably smaller than the tile size.
Rotation Angle: -30° or -45° are the most common choices for balanced visuals.

5. Conclusion

This article introduces two mainstream approaches to adding text watermarks to PDFs with C#: tiled background watermarks and single localized watermarks. Both solutions include runnable code samples and detailed parameter explanations. Remember the 10-page limit of the free Spire.PDF edition.

In real-world projects, select the appropriate method according to your requirements. Pay attention to coordinate rules, transparency adjustment and resource release. This guide will help you quickly integrate reliable PDF watermark functionality into your C# applications.

Generate Word Documents with Python | Automate DOCX Creation

Jeremy K. — Wed, 03 Jun 2026 06:24:03 +0000

Introduction

Batch generation of contracts, analytical reports and project specification files is one of the most frequent demands for office automation development. Manual copy-and-paste leads to low productivity and inconsistent document formatting standards across batches of Word files.

This practical tutorial focuses on how to generate Word documents with Python via the free edition of Spire.Doc for Python. We deliver complete runnable code examples, ranging from blank DOCX initialization to embedding formatted data tables, local images, headers, footers and full automated project reports.

1. Set Up

1.1 Overview

Free Spire.Doc for Python is a standalone free Python library built for full-cycle Word document processing. It supports creating, reading, modifying and converting legacy .doc and modern .docx formats entirely without MS Word.

1.2 Install via PIP Command

Execute the below pip command inside your Python terminal to install the DOCX generation dependency:

pip install Spire.Doc.Free

1.3 Import Core Modules

Add these import statements at the top of every Python script for generating Word documents with Free Spire.Doc:

from spire.doc import *
from spire.doc.common import *

2. Basic: Create DOCX File From Scratch in Python

All Word files built with this Python SDK follow a fixed nested object structure:
Document → Section → Paragraph → TextRange

Document: Top root instance representing a complete Word DOCX file
Section: Independent page layout container to customize margins, headers, footers and page orientation separately
Paragraph: Core block container for all visible text content
TextRange: Fragment for continuous formatted text inside a single paragraph

2.1 Build Basic Word Document With Built-in Styles

Below sample code creates a complete formatted DOCX file with title, H1 heading and normal body text, a foundational operation when you generate Word documents with Python:

# Initialize blank document instance
doc = Document()
# Create new document section
section = doc.AddSection()

# Customize page margin (unit: point)
section.PageSetup.Margins.Top = 60
section.PageSetup.Margins.Bottom = 60
section.PageSetup.Margins.Left = 70
section.PageSetup.Margins.Right = 70

# Add formatted title with built-in Title style
title = section.AddParagraph()
title.AppendText("2026 Annual Technical Report")
title.ApplyStyle(BuiltinStyle.Title)

# Add H1 heading
heading1 = section.AddParagraph()
heading1.AppendText("I. Project Overview")
heading1.ApplyStyle(BuiltinStyle.Heading1)

# Add normal body text
para = section.AddParagraph()
para.AppendText("This report summarizes the work achievements of the technical team in 2026 in core product development, performance optimization, and user experience enhancement.")
para.ApplyStyle(BuiltinStyle.Normal)

# Export DOCX and release system resource
doc.SaveToFile("demo.docx")
doc.Dispose()

2.2 Define Custom Font & Paragraph Styles

Apart from default built-in Word styles, developers can register reusable custom paragraph formats to unify typography across auto-generated Word content:

# Register user-defined paragraph style
custom_style = ParagraphStyle(doc)
custom_style.Name = "CustomStyle"
# Configure custom font attributes
custom_style.CharacterFormat.FontName = "Times New Roman"
custom_style.CharacterFormat.FontSize = 12
custom_style.CharacterFormat.Bold = False
custom_style.CharacterFormat.TextColor = Color.get_Gray()
doc.Styles.Add(custom_style)

# Bind custom style to target paragraph
para.ApplyStyle("CustomStyle")

# Set paragraph horizontal alignment
title.Format.HorizontalAlignment = HorizontalAlignment.Center
para.Format.HorizontalAlignment = HorizontalAlignment.Left

3. Advanced: Generate Rich Word Content in Python

These three practical scenarios cover top searched requirements: insert data tables, embed local images and add custom header/footer with auto page numbers in DOCX via Python code.

3.1 Insert Dynamic Data Tables Into Word DOCX

Populating structured business datasets into auto-adaptive Word tables is the most widely used function for automated report generation. The following example writes quarterly sales ledger into formatted DOCX tables:

from spire.doc import *
from spire.doc.common import *

doc = Document()
section = doc.AddSection()
section.PageSetup.Margins.All = 40

# Define table header and source business data
header = ["Month", "Product Line", "Revenue", "YoY Growth"]
data_list = [
    ["Jan", "Software Services", "23500", "6.2%"],
    ["Feb", "Hardware Products", "18900", "-2.1%"],
    ["Mar", "Outsourced O&M", "32100", "12.5%"]
]

# Initialize table: row count = header row + data rows, column count matches header
table = section.AddTable()
table.ResetCells(len(data_list)+1, len(header))
# Auto stretch table width to fit full page width
table.AutoFit(AutoFitBehaviorType.AutoFitToWindow)
# Apply built-in lightweight table theme
table.ApplyStyle(DefaultTableStyle.GridTable1LightAccent6)

# Fill bold-formatted table header cells
for col_idx, val in enumerate(header):
    cell = table.Rows[0].Cells[col_idx]
    cell.AddParagraph().AppendText(val).CharacterFormat.Bold = True

# Iteratively fill business detail rows
for row_idx, row_data in enumerate(data_list, start=1):
    for col_idx, val in enumerate(row_data):
        table.Rows[row_idx].Cells[col_idx].AddParagraph().AppendText(val)

doc.SaveToFile("business_data_table.docx", FileFormat.Docx)
doc.Dispose()

3.2 Embed Images Into Word Documents

Use Paragraph.AppendPicture() to insert local image assets into DOCX, with customizable dimension, center alignment and descriptive captions.

from spire.doc import *
from spire.doc.common import *

doc = Document()
section = doc.AddSection()

# Section heading
title = section.AddParagraph()
title.AppendText("Product Diagram")
title.ApplyStyle(BuiltinStyle.Heading1)

# Pre-image explanatory text
caption = section.AddParagraph()
caption.AppendText("The diagram below illustrates the product structure:")

# Insert and configure embedded image
image_para = section.AddParagraph()
picture = image_para.AppendPicture("product_diagram.png")
# Fix image dimension (unit: point)
picture.Width = 400
picture.Height = 300
# Center align the image container paragraph
image_para.Format.HorizontalAlignment = HorizontalAlignment.Center

# Bottom figure caption
caption_below = section.AddParagraph()
caption_below.AppendText("Figure 1 Product Structure Diagram")
caption_below.Format.HorizontalAlignment = HorizontalAlignment.Center

doc.SaveToFile("report_with_image.docx")
doc.Dispose()

3.3 Configure Header, Footer & Dynamic Page Numbers in DOCX

Headers and footers belong to section-level attributes bound to Section.HeadersFooters, supporting fixed header text and auto-calculated page/total-page fields for Python-generated Word files:

from spire.doc import *
from spire.doc.common import *

doc = Document()
section = doc.AddSection()

# Set page layout direction
section.PageSetup.Orientation = PageOrientation.Portrait

# Build right-aligned document header
header = section.HeadersFooters.Header.AddParagraph()
header.AppendText("Internal Company Document - Technical Report")
header.Format.HorizontalAlignment = HorizontalAlignment.Right

# Build centered footer with dynamic page / total page fields
footer = section.HeadersFooters.Footer.AddParagraph()
footer.AppendField("Page", FieldType.FieldPage)
footer.AppendText(" / ")
footer.AppendField("NumPages", FieldType.FieldNumPages)
footer.Format.HorizontalAlignment = HorizontalAlignment.Center

# Sample body content
content = section.AddParagraph()
content.AppendText("Report body content...")

doc.SaveToFile("with_header_footer.docx")
doc.Dispose()

4. Integrated End-to-End Demo: Auto-Generate Full Project Closing Report

This encapsulated function integrates all preceding features (header/footer, styled text, info tables, metric sheets) to produce a standardized project closing report via parameter input.

from spire.doc import *
from spire.doc.common import *

def generate_project_report(project_name, start_date, end_date, budget, metrics, summary):
    """
    Generate standardized project closing Word report via Python
    :param project_name: Target project full name
    :param start_date: Project kickoff date
    :param end_date: Project final delivery date
    :param budget: Total project budget (unit: ten thousand CNY)
    :param metrics: List of KPI tuples: (Metric Name, Actual Value, Target Value)
    :param summary: Post-project overall summary text
    """
    doc = Document()
    section = doc.AddSection()

    # Global page margin setup
    section.PageSetup.Margins.Top = 70
    section.PageSetup.Margins.Bottom = 70
    section.PageSetup.Margins.Left = 60
    section.PageSetup.Margins.Right = 60

    # Centered document header
    header = section.HeadersFooters.Header.AddParagraph()
    header.AppendText("Project Closing Report - Internal Use")
    header.Format.HorizontalAlignment = HorizontalAlignment.Center

    # Auto page-number footer
    footer = section.HeadersFooters.Footer.AddParagraph()
    footer.AppendField("Page", FieldType.FieldPage)
    footer.AppendText(" / ")
    footer.AppendField("NumPages", FieldType.FieldNumPages)
    footer.Format.HorizontalAlignment = HorizontalAlignment.Center

    # Document main title
    title = section.AddParagraph()
    title.AppendText(f"{project_name} - Closing Report")
    title.ApplyStyle(BuiltinStyle.Title)
    title.Format.HorizontalAlignment = HorizontalAlignment.Center
    title.Format.AfterSpacing = 20

    # Part I: Basic project information table
    heading_basic = section.AddParagraph()
    heading_basic.AppendText("I. Basic Project Information")
    heading_basic.ApplyStyle(BuiltinStyle.Heading1)

    info_table = section.AddTable(True)
    info_table.ResetCells(4, 2)
    info_table.TableFormat.Borders.BorderType = BorderStyle.Single
    info_data = [
        ("Project Name", project_name),
        ("Execution Period", f"{start_date} to {end_date}"),
        ("Budget Amount", f"{budget} ten thousand CNY"),
        ("Report Date", "June 2026")
    ]
    for i, (key, value) in enumerate(info_data):
        info_table.Rows[i].Cells[0].AddParagraph().AppendText(key).CharacterFormat.Bold = True
        info_table.Rows[i].Cells[1].AddParagraph().AppendText(value)

    # Part II: KPI completion statistics table
    heading_metrics = section.AddParagraph()
    heading_metrics.AppendText("II. Key Metrics Achievement")
    heading_metrics.ApplyStyle(BuiltinStyle.Heading1)

    metrics_table = section.AddTable(True)
    metrics_table.ResetCells(len(metrics) + 1, 3)
    metrics_table.TableFormat.Borders.BorderType = BorderStyle.Single
    metric_headers = ["Metric Name", "Actual Value", "Target Value"]

    # Fill table header with bold text
    for idx, header in enumerate(metric_headers):
        metrics_table.Rows[0].Cells[idx].AddParagraph().AppendText(header).CharacterFormat.Bold = True
    # Fill KPI row content
    for i, (name, actual, target) in enumerate(metrics):
        metrics_table.Rows[i + 1].Cells[0].AddParagraph().AppendText(name)
        metrics_table.Rows[i + 1].Cells[1].AddParagraph().AppendText(str(actual))
        metrics_table.Rows[i + 1].Cells[2].AddParagraph().AppendText(str(target))

    # Part III: Project summary paragraph
    heading_summary = section.AddParagraph()
    heading_summary.AppendText("III. Project Summary")
    heading_summary.ApplyStyle(BuiltinStyle.Heading1)

    summary_para = section.AddParagraph()
    summary_para.AppendText(summary)
    summary_para.ApplyStyle(BuiltinStyle.Normal)

    # Export generated file and release resource
    output_file = f"{project_name}_Closing_Report.docx"
    doc.SaveToFile(output_file)
    doc.Dispose()
    print(f"Report generated successfully: {output_file}")


# Execute report generation entry
if __name__ == "__main__":
    generate_project_report(
        project_name="Next-Generation Data Analytics Platform",
        start_date="2025-07-01",
        end_date="2026-06-30",
        budget=280,
        metrics=[
            ("Data Processing Throughput (TPS)", 12500, 10000),
            ("Query Response Time (ms)", 85, 100),
            ("User Satisfaction Score", 4.8, 4.5),
            ("Feature Completion (%)", 98, 95)
        ],
        summary="This project successfully completed the development and deployment of the next-generation data analytics platform. All key metrics met or exceeded expectations. The system has been running stably since launch and has received positive feedback from users. Subsequent phases will continue to advance AI analytics features and mobile support."
    )

5. Summary

This complete tutorial covers the full end-to-end workflow to generate Word documents with Python. Developers can build DOCX files from scratch, add formatted text, business tables, embedded local images and customized header/footer with auto page numbers without installing Microsoft Word locally.

FAQ

Q1: Can I generate DOCX with Python without installing Microsoft Word?

A: Yes. Free Spire.Doc for Python is a standalone SDK with zero MS Word dependency; all DOCX creation runs purely via Python code.

Q2: What’s the limitation of Free Spire.Doc for Python free edition?

A: Free version caps at 500 paragraphs and 25 tables per single DOCX file; extra content gets automatically truncated after exceeding limits.

Q3: How to insert images and tables into Word document using Python?

A: Use AppendPicture() for image embedding and AddTable() + ResetCells() to initialize data tables, refer to Section 3.1 & 3.2 for ready-to-run code samples.

Q4: Is it possible to auto-generate full project report DOCX via Python?

A: Yes. Check the integrated function in Section 4; pass project basic info, budget and KPI data to generate formatted closing reports in one click.

Q5: Can Python edit existing finished Word DOCX files with Spire.Doc?

A: Supported via extended SDK features; load target DOCX and execute text replacement or content appending operations.

Automate PowerPoint Slides with C#: Add & Remove Without Microsoft Office

Jeremy K. — Tue, 26 May 2026 06:02:32 +0000

When building dynamic presentations, generating reports in bulk, or automating branded PowerPoint templates, the ability to programmatically add and remove slides is essential. This tutorial provides a ready-to-use C# solution using the free library Free Spire.Presentation for .NET.

✅ No Microsoft Office dependency – pure managed code that works in server-side automation environments.

1. Quick Setup: NuGet Installation

To start automating PowerPoint with C#, install the Free Spire.Presentation library via NuGet:

PM> Install-Package FreeSpire.Presentation

Or search for FreeSpire.Presentation in the NuGet Package Manager.

Then add the namespace:

using Spire.Presentation;

2. Core API Overview

The Presentation class and SlideCollection control all slide operations. Below are the essential methods for C# PowerPoint automation:

Method	Description
`Slides.Append()`	Adds a blank slide at the end
`Slides.Insert(index)`	Inserts a blank slide at a specific position
`Slides.Insert(index, ISlide)`	Copies an existing slide into the presentation
`Slides.RemoveAt(index)`	Deletes a slide by index
`Slides.Remove(ISlide)`	Deletes a slide by object reference

3. How to Add Slides in C

3.1 Create a New PPT and Remove Default Slide

When you instantiate Presentation, it automatically contains one blank slide. To start from scratch:

Presentation ppt = new Presentation();
ppt.Slides.RemoveAt(0);  // Remove the default slide

3.2 Append a Slide to the End

Presentation ppt = new Presentation();
ppt.LoadFromFile("template.pptx");
ppt.Slides.Append();  // Adds blank slide at the end
ppt.SaveToFile("output.pptx", FileFormat.Pptx2019);

3.3 Insert a Slide at a Specific Index

Use zero-based indexing (Slides[0] is the first slide). This example inserts a blank slide as the second slide:

ppt.Slides.Insert(1);

3.4 Copy an Existing Slide (Same or Different PPT)

Copying preserves layout, images, and formatting.

Within the same document:

ISlide source = ppt.Slides[0];
ppt.Slides.Append(source);
ppt.Slides.Insert(2, source);

Across documents:

Presentation sourcePpt = new Presentation();
sourcePpt.LoadFromFile("source.pptx");

Presentation targetPpt = new Presentation();
targetPpt.LoadFromFile("target.pptx");

ISlide toCopy = sourcePpt.Slides[0];
targetPpt.Slides.Insert(0, toCopy);  // Insert at beginning
targetPpt.SaveToFile("merged.pptx", FileFormat.Pptx2019);

4. How to Delete Slides in C

4.1 Delete by Index

ppt.Slides.RemoveAt(0);  // Removes the first slide

⚠️ Always validate ppt.Slides.Count > index to avoid ArgumentOutOfRangeException.

4.2 Delete by Object Reference

ISlide target = ppt.Slides[2];
ppt.Slides.Remove(target);

4.3 Delete Multiple Slides Safely (Reverse Iteration)

When looping and deleting, iterate backwards to avoid index shifting:

for (int i = ppt.Slides.Count - 1; i >= 0; i--)
{
    ppt.Slides.RemoveAt(i);
}

5. Best Practices & Limitations

Practice	Reason
Use `using` statements for `Presentation`	Ensures proper disposal of resources, critical for web apps and backend services
Wrap file I/O in `try-catch`	Handles missing files, permission errors, or corrupted PPTs
Validate slide count before deletion	Prevents runtime exceptions
Use `FileFormat.Pptx2019` for saving	Broad compatibility with modern PowerPoint versions
Be aware of free edition limitation	Maximum 10 slides per document

6. Summary

With fewer than 10 lines of C# code, you can fully automate the addition and removal of PowerPoint slides. The Free Spire.Presentation API is intuitive and mirrors PowerPoint's native object model, making it easy for developers to integrate into batch reporting systems, dynamic presentation builders, or server-side document automation pipelines.

For advanced scenarios – such as copying slides across documents while preserving all formatting, batch operations by section, or merging multiple PPTs – extend the examples above with additional API calls.

Looking for more C# PowerPoint automation guides? Check out the official Free Spire.Presentation documentation or leave a comment below.

SEO improvements made:

✅ Keyword-rich title (C#, PowerPoint, add & remove, automate, without Microsoft Office)
✅ Meta description with primary keywords and value proposition
✅ Clear H1, H2, H3 hierarchy for search engine crawling
✅ Bolded key phrases like "programmatically add and remove slides", "C# PowerPoint automation"
✅ Table for API methods and best practices (enhances readability and featured snippet potential)
✅ Table of contents for internal anchor links
✅ Short paragraphs and bullet points for scannability
✅ Semantic related terms: "dynamic presentations", "batch automation", "server-side", "merge PPTs"
✅ Call to action at the end

DEV Community: Jeremy K.

Change Fonts in a Word Document with Python

Setting Up the Environment

Core Concepts: CharacterFormat and ParagraphStyle

Scenario 1: Changing the Font of an Entire Paragraph

Code Example

How It Works

Scenario 2: Finding and Modifying Specific Text

Code Example

How It Works

Important Considerations

Summary

How to Batch Extract PDF Form Data Using C#

1. Approach Overview

2. Prerequisites

2.1 Install the NuGet Package

2.2 Import Required Namespaces

3. Basic Workflow for Reading Form Fields

3.1 Load the Document and Retrieve the Form

3.2 Iterate Over All Fields

4. Extracting Values by Field Type

4.1 Text Box (PdfTextBoxFieldWidget)

4.2 Checkbox (PdfCheckBoxWidgetFieldWidget)

4.3 Radio Button Group (PdfRadioButtonListFieldWidget)

4.4 List Box (PdfListBoxWidgetFieldWidget)

4.5 Combo Box (Drop‑down) (PdfComboBoxWidgetFieldWidget)

5. Important Notes and Troubleshooting

5.1 Check for Empty Forms

5.2 AcroForm vs. XFA Forms

5.3 Release Resources

6. Summary

Pure Frontend RTF-to-PDF Conversion with JavaScript

Introduction

Setup and Installation

Architecture Overview

Core Implementation

1. Loading the WASM Module

2. Virtual File System (VFS) Setup

3. Conversion Workflow

4. Cleanup

Conclusion

Writing Data to Excel Documents Using C++

I. Overview

II. Environment Setup

2.1 Obtaining and Integrating the Library

2.2 Including Header Files

III. Core Object Model

IV. Writing Data to Cells

4.1 Writing Text Values

4.2 Writing Numeric Values

4.3 Writing Date and Time Values

4.4 Complete Example: Employee Information Table

V. Batch Writing

VI. Important Considerations

VII. Summary

Compare Two Word Documents Using Python

1. Environment Setup

1.1 Installing the Library

1.2 Core API Overview

2. Basic Document Comparison

2.1 Minimal Code Example

2.2 Output Result

3. Customizing Comparison Behavior

3.1 Ignoring Formatting Differences

3.2 Additional Options

4. Summary

Java: Word to TXT Conversion

1. Common Approaches

2. Maven Dependency Configuration

3. Core Implementation for Word-to-TXT Conversion

4. Advanced Usage and Batch Processing

Batch Conversion

Extracting Text Without Saving to a File

5. Common Issues and Considerations

5.1 Free Version Limitations

5.2 Encoding Issues

5.3 Resource Management

5.4 Handling of Non-Text Content

Reorder Excel Columns with C#

Core Strategy

4.1 Text Box (`PdfTextBoxFieldWidget`)

4.2 Checkbox (`PdfCheckBoxWidgetFieldWidget`)

4.3 Radio Button Group (`PdfRadioButtonListFieldWidget`)

4.4 List Box (`PdfListBoxWidgetFieldWidget`)

4.5 Combo Box (Drop‑down) (`PdfComboBoxWidgetFieldWidget`)