Documentation – Accessibility and tagged PDFs in C++

Cpp: Create tagged PDF documents in C++

Mon, 12 Oct 2026 00:00:00 +0000

Use Aspose.PDF for C++ to build a logical structure tree for PDF content, set language and title metadata, and associate visible content with structure elements. This page covers tagged document creation, text styling, images, form fields, tables of contents, automatic tagging, and validation.

Create a simple tagged PDF

Build a document with a heading and paragraph in the logical structure tree.

Create a Document and get its ITaggedContent with get_TaggedContent().
Set the document title and language with SetTitle() and SetLanguage().
Create a heading and paragraph with CreateHeaderElement() and CreateParagraphElement().
Set their text and attach them to get_RootElement() with AppendChild().
Save the document with Save().


#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/BLSElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;

void CreateTaggedPdfDocumentSimple(System::String outputFile)
{
    auto document = MakeObject<Document>();
    auto taggedContent = document->get_TaggedContent();
    auto rootElement = taggedContent->get_RootElement();

    taggedContent->SetTitle(u"Tagged Pdf Document");
    taggedContent->SetLanguage(u"en-US");

    auto mainHeader = taggedContent->CreateHeaderElement();
    mainHeader->SetText(u"Main Header");

    auto paragraphElement = taggedContent->CreateParagraphElement();
    paragraphElement->SetText(u"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean nec lectus ac sem faucibus imperdiet. Sed ut erat ac magna ullamcorper hendrerit. Cras pellentesque libero semper, gravida magna sed, luctus leo.");

    rootElement->AppendChild(mainHeader, true);
    rootElement->AppendChild(paragraphElement, true);
    document->Save(outputFile);
}

Create a tagged PDF with inline quotes

Combine spans and an emphasized quotation inside a paragraph.

Create a Document and get its ITaggedContent with get_TaggedContent().
Set the document title and language with SetTitle() and SetLanguage().
Create a level-one heading and a paragraph.
Set the paragraph font and margins.
Create inline spans and a quotation with CreateSpanElement() and CreateQuoteElement().
Apply bold and italic formatting to the quote through StructureTextState.
Append the inline elements to the paragraph, then append the heading and paragraph to the root.
Save the document with Save().


#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Generator/MarginInfo.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/BLSElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/ILSElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureTextState.h>
#include <Aspose.PDF.Cpp/Tagged/PositionSettings.h>
#include <Aspose.PDF.Cpp/Text/Font.h>
#include <Aspose.PDF.Cpp/Text/FontRepository.h>
#include <Aspose.PDF.Cpp/Text/FontStyles.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;
using namespace Aspose::Pdf::Text;

void CreateTaggedPdfDocumentAdv(System::String outputFile)
{
    auto document = MakeObject<Document>();
    auto taggedContent = document->get_TaggedContent();
    auto rootElement = taggedContent->get_RootElement();

    taggedContent->SetTitle(u"Tagged Pdf Document");
    taggedContent->SetLanguage(u"en-US");

    auto header1 = taggedContent->CreateHeaderElement(1);
    header1->SetText(u"Header Level 1");

    auto paragraphWithQuotes = taggedContent->CreateParagraphElement();
    paragraphWithQuotes->get_StructureTextState()->set_Font(FontRepository::FindFont(u"Arial"));

    auto positionSettings = MakeObject<PositionSettings>();
    positionSettings->set_Margin(MakeObject<MarginInfo>(10, 5, 10, 5));
    paragraphWithQuotes->AdjustPosition(positionSettings);

    auto spanElement1 = taggedContent->CreateSpanElement();
    spanElement1->SetText(u"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean nec lectus ac sem faucibus imperdiet. Sed ut erat ac magna ullamcorper hendrerit. ");

    auto quoteElement = taggedContent->CreateQuoteElement();
    quoteElement->SetText(u"Sed vulputate, quam sed lacinia luctus, ipsum nibh fringilla purus.");
    quoteElement->get_StructureTextState()->set_FontStyle(FontStyles::Bold | FontStyles::Italic);

    auto spanElement2 = taggedContent->CreateSpanElement();
    spanElement2->SetText(u" Sed non consectetur elit.");

    paragraphWithQuotes->AppendChild(spanElement1, true);
    paragraphWithQuotes->AppendChild(quoteElement, true);
    paragraphWithQuotes->AppendChild(spanElement2, true);

    rootElement->AppendChild(header1, true);
    rootElement->AppendChild(paragraphWithQuotes, true);
    document->Save(outputFile);
}

Set document and element languages

Define document metadata and identify the language of each multilingual paragraph.

Create a Document and get its ITaggedContent with get_TaggedContent().
Set the document title and language with SetTitle() and SetLanguage().
Create a level-one heading.
Create paragraphs containing English, German, French, and Spanish text.
Set the language on each StructureElement and append it to the root.
Save the document with Save().


#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/BLSElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;

void SetLanguageAndTitle(System::String outputFile)
{
    auto document = MakeObject<Document>();
    auto taggedContent = document->get_TaggedContent();
    taggedContent->SetTitle(u"Example Tagged Document");
    taggedContent->SetLanguage(u"en-US");

    auto header = taggedContent->CreateHeaderElement(1);
    header->SetText(u"Phrase on different languages");
    taggedContent->get_RootElement()->AppendChild(header, true);

    {
        auto paragraph = taggedContent->CreateParagraphElement();
        paragraph->SetText(u"Hello, World!");
        paragraph->set_Language(u"en-US");
        taggedContent->get_RootElement()->AppendChild(paragraph, true);
    }
    {
        auto paragraph = taggedContent->CreateParagraphElement();
        paragraph->SetText(u"Hallo Welt!");
        paragraph->set_Language(u"de-DE");
        taggedContent->get_RootElement()->AppendChild(paragraph, true);
    }
    {
        auto paragraph = taggedContent->CreateParagraphElement();
        paragraph->SetText(u"Bonjour le monde!");
        paragraph->set_Language(u"fr-FR");
        taggedContent->get_RootElement()->AppendChild(paragraph, true);
    }
    {
        auto paragraph = taggedContent->CreateParagraphElement();
        paragraph->SetText(u"Hola Mundo!");
        paragraph->set_Language(u"es-ES");
        taggedContent->get_RootElement()->AppendChild(paragraph, true);
    }

    document->Save(outputFile);
}

Style tagged text

Apply font size, color, and font style to a tagged paragraph.

Create a Document and get its ITaggedContent with get_TaggedContent().
Set the document title and language with SetTitle() and SetLanguage().
Create a paragraph and append it to the root.
Set its StructureTextState to 18-point red italic text.
Set the paragraph text.
Save the document with Save().


#include <Aspose.PDF.Cpp/Color.h>
#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/BLSElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureTextState.h>
#include <Aspose.PDF.Cpp/Text/FontStyles.h>

using namespace Aspose::Pdf::Text;
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;

void AddStyle(System::String outputFile)
{
    auto document = MakeObject<Document>();
    auto taggedContent = document->get_TaggedContent();

    taggedContent->SetTitle(u"Tagged Pdf Document");
    taggedContent->SetLanguage(u"en-US");

    auto paragraphElement = taggedContent->CreateParagraphElement();
    taggedContent->get_RootElement()->AppendChild(paragraphElement, true);

    paragraphElement->get_StructureTextState()->set_FontSize(18.0f);
    paragraphElement->get_StructureTextState()->set_ForegroundColor(Color::get_Red());
    paragraphElement->get_StructureTextState()->set_FontStyle(FontStyles::Italic);
    paragraphElement->SetText(u"Red italic text.");

    document->Save(outputFile);
}

Position a tagged paragraph

Adjust paragraph margins and layout flags through PositionSettings.

Create a Document and get its ITaggedContent with get_TaggedContent().
Set the document title and language with SetTitle() and SetLanguage().
Create a paragraph, set its text, and append it to the root.
Create PositionSettings and configure margins, alignment, and pagination flags.
Apply the position settings with AdjustPosition().
Save the document with Save().


#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Generator/MarginInfo.h>
#include <Aspose.PDF.Cpp/HorizontalAlignment.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/BLSElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>
#include <Aspose.PDF.Cpp/Tagged/PositionSettings.h>
#include <Aspose.PDF.Cpp/VerticalAlignment.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;

void AdjustPosition(System::String outputFile)
{
    auto document = MakeObject<Document>();
    auto taggedContent = document->get_TaggedContent();

    taggedContent->SetTitle(u"Tagged Pdf Document");
    taggedContent->SetLanguage(u"en-US");

    auto paragraph = taggedContent->CreateParagraphElement();
    taggedContent->get_RootElement()->AppendChild(paragraph, true);
    paragraph->SetText(u"Text.");

    auto positionSettings = MakeObject<PositionSettings>();
    auto marginInfo = MakeObject<MarginInfo>();
    marginInfo->set_Left(300);
    marginInfo->set_Top(20);
    marginInfo->set_Right(0);
    marginInfo->set_Bottom(0);
    positionSettings->set_Margin(marginInfo);
    positionSettings->set_HorizontalAlignment(HorizontalAlignment::None);
    positionSettings->set_VerticalAlignment(VerticalAlignment::None);
    positionSettings->set_IsFirstParagraphInColumn(false);
    positionSettings->set_IsKeptWithNext(false);
    positionSettings->set_IsInNewPage(false);
    positionSettings->set_IsInLineParagraph(false);
    paragraph->AdjustPosition(positionSettings);

    document->Save(outputFile);
}

Add a tagged figure

Insert an image with an alternative description, title, and custom tag.

Supply an existing image file. The sample descriptions are placeholders; replace them with descriptions of your image.

Create a Document and get its ITaggedContent with get_TaggedContent().
Set the document title and language with SetTitle() and SetLanguage().
Create a FigureElement with CreateFigureElement() and append it to the root.
Set the alternative text, title, and custom tag.
Load the image from imageFile with SetImage().
Configure the image margins and apply AdjustPosition().
Save the document with Save().


#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Generator/Image.h>
#include <Aspose.PDF.Cpp/Generator/MarginInfo.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/IllustrationElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>
#include <Aspose.PDF.Cpp/Tagged/PositionSettings.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;

void IllustrateStructureElements(System::String imageFile, System::String outputFile)
{
    auto document = MakeObject<Document>();
    auto taggedContent = document->get_TaggedContent();

    taggedContent->SetTitle(u"Tagged Pdf Document");
    taggedContent->SetLanguage(u"en-US");

    auto figure1 = taggedContent->CreateFigureElement();
    taggedContent->get_RootElement()->AppendChild(figure1, true);
    figure1->set_AlternativeText(u"Figure One");
    figure1->set_Title(u"Image 1");
    figure1->SetTag(u"Fig1");
    figure1->SetImage(imageFile, 300);

    auto positionSettings = MakeObject<PositionSettings>();
    auto marginInfo = MakeObject<MarginInfo>();
    marginInfo->set_Left(50);
    marginInfo->set_Top(20);
    positionSettings->set_Margin(marginInfo);
    figure1->AdjustPosition(positionSettings);

    document->Save(outputFile);
}

Tag a signature form field

Associate a signature field with a form element in the structure tree.

This example creates a signature field; it does not sign the document.

Create a Document and get its ITaggedContent with get_TaggedContent().
Add a page and create a SignatureField within a rectangle.
Set its partial name and alternate name.
Add the field to the document form.
Create a form structure element with CreateFormElement() and set its alternative text.
Associate the field with the element using Tag() and append the element to the root.
Save the document with Save().


#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Facades/Form.h>
#include <Aspose.PDF.Cpp/InteractiveFeatures/Forms/SignatureField.h>
#include <Aspose.PDF.Cpp/Page.h>
#include <Aspose.PDF.Cpp/PageCollection.h>
#include <Aspose.PDF.Cpp/Rectangle.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/IllustrationElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;
using namespace Aspose::Pdf::Forms;

void CreatePdfWithTaggedFormField(System::String outputFile)
{
    auto document = MakeObject<Document>();
    auto page = document->get_Pages()->Add();
    auto taggedContent = document->get_TaggedContent();
    auto rootElement = taggedContent->get_RootElement();

    auto signatureField = MakeObject<SignatureField>(page, MakeObject<Rectangle>(50, 50, 100, 100, true));
    signatureField->set_PartialName(u"Signature1");
    signatureField->set_AlternateName(u"signature 1");

    auto formFields = document->get_Form();
    formFields->Add(System::StaticCast<Field>(signatureField));

    auto form = taggedContent->CreateFormElement();
    form->set_AlternativeText(u"form 1");
    form->Tag(signatureField);
    rootElement->AppendChild(form, true);

    document->Save(outputFile);
}

Create a tagged table of contents

Connect a table-of-contents entry to a heading in the document structure.

Create a Document and get its ITaggedContent with get_TaggedContent().
Set the document language with SetLanguage().
Add a TOC page and assign TocInfo.
Create a TOC structure element with CreateTOCElement() and append it to the root.
Add a content page and a level-one heading.
Create a TOC item with CreateTOCIElement(), add the heading entry to the TOC page, and reference the heading with AddRef().
Save the document with Save().


#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Generator/TOCInfo.h>
#include <Aspose.PDF.Cpp/Page.h>
#include <Aspose.PDF.Cpp/PageCollection.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/BLSElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/GroupingElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;

void CreatePdfWithTocPage(System::String outputFile)
{
    auto document = MakeObject<Document>();
    auto content = document->get_TaggedContent();
    auto rootElement = content->get_RootElement();
    content->SetLanguage(u"en-US");

    auto tocPage = document->get_Pages()->Add();
    tocPage->set_TocInfo(MakeObject<TocInfo>());

    auto tocElement = content->CreateTOCElement();
    rootElement->AppendChild(tocElement, true);

    document->get_Pages()->Add();

    auto header = content->CreateHeaderElement(1);
    header->SetText(u"1. Header");
    rootElement->AppendChild(header, true);

    auto toci = content->CreateTOCIElement();
    tocElement->AppendChild(toci, true);
    header->AddEntryToTocPage(tocPage, toci);
    toci->AddRef(header);

    document->Save(outputFile);
}

Create a table of contents with nested entries

Link a TOC title to a heading and include subheadings as nested list entries.

Create a Document and get its ITaggedContent with get_TaggedContent().
Set the document language and create a TOC page with a visible title.
Create a TOC element and associate the page title with a header using LinkTocPageTitleToHeaderElement().
Add the first heading and its TOC item.
Create a list of subheading entries with CreateListElement() and CreateListLIElement().
Add each subheading to the TOC page and link its entry with AddRef().
Append the list to the first TOC item and add a second heading and TOC item.
Save the document with Save().


#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Generator/TOCInfo.h>
#include <Aspose.PDF.Cpp/Page.h>
#include <Aspose.PDF.Cpp/PageCollection.h>
#include <Aspose.PDF.Cpp/Table/Table.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/BLSElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/GroupingElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureTextState.h>
#include <Aspose.PDF.Cpp/Text/TextFragment.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;
using namespace Aspose::Pdf::Text;

void CreatePdfWithTocPageAdvanced(System::String outputFile)
{
    auto document = MakeObject<Document>();
    auto content = document->get_TaggedContent();
    auto rootElement = content->get_RootElement();
    content->SetLanguage(u"en-US");

    auto tocPage = document->get_Pages()->Add();
    tocPage->set_TocInfo(MakeObject<TocInfo>());
    tocPage->get_TocInfo()->set_Title(MakeObject<TextFragment>(u"Table of Contents"));

    auto tocElement = content->CreateTOCElement();
    auto headerForTocPageTitle = content->CreateHeaderElement(1);
    tocElement->LinkTocPageTitleToHeaderElement(tocPage, headerForTocPageTitle);

    rootElement->AppendChild(headerForTocPageTitle, true);
    rootElement->AppendChild(tocElement, true);

    document->get_Pages()->Add();

    auto header = content->CreateHeaderElement(1);
    header->SetText(u"1. Header");
    rootElement->AppendChild(header, true);

    auto toci = content->CreateTOCIElement();
    tocElement->AppendChild(toci, true);
    header->AddEntryToTocPage(tocPage, toci);
    toci->AddRef(header);

    auto listElement = content->CreateListElement();
    for (int i = 1; i < 4; i++) {
        auto li = content->CreateListLIElement();
        listElement->AppendChild(li, true);

        auto subHeader = content->CreateHeaderElement(2);
        subHeader->get_StructureTextState()->set_FontSize(14.0f);
        subHeader->set_Language(u"en-US");
        subHeader->SetText(String::Format(u"1.{0} subheader ", i));
        subHeader->AddEntryToTocPage(tocPage, li);
        li->AddRef(subHeader);

        auto p = content->CreateParagraphElement();
        p->SetText(u"Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
        p->set_Language(u"en-US");

        rootElement->AppendChild(subHeader, true);
        rootElement->AppendChild(p, true);
    }
    toci->AppendChild(listElement, true);

    auto header2 = content->CreateHeaderElement(1);
    header2->SetText(u"2. Header");
    rootElement->AppendChild(header2, true);

    auto toci2 = content->CreateTOCIElement();
    tocElement->AppendChild(toci2, true);
    header2->AddEntryToTocPage(tocPage, toci2);
    toci2->AddRef(header2);

    document->Save(outputFile);
}

Convert to PDF/UA with automatic tagging

Enable automatic tagging when converting an existing PDF to PDF/UA-1.

The example uses ConvertErrorAction::Delete, which can remove objects that cannot be converted. Review the conversion log and validate the output; completion of the function does not establish PDF/UA conformance.

Open the input PDF as a Document.
Create PdfFormatConversionOptions with logFile, PDF_UA_1, and ConvertErrorAction::Delete.
Create AutoTaggingSettings, enable automatic tagging, and select automatic heading recognition.
Assign the tagging settings to the conversion options.
Call Convert() and save the result with Save().


#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/IO/ConvertStrategies/AutoTaggingSettings.h>
#include <Aspose.PDF.Cpp/IO/ConvertStrategies/ConvertErrorAction.h>
#include <Aspose.PDF.Cpp/IO/ConvertStrategies/PdfFormat.h>
#include <Aspose.PDF.Cpp/PdfFormatConversionOptions.h>
#include <Aspose.PDF.Cpp/PdfToMarkdown/MarkdownOptions/HeadingRecognitionStrategy.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;

void ConvertToPdfUaWithAutomaticTagging(System::String inputFile, System::String outputFile, System::String logFile)
{
    auto document = MakeObject<Document>(inputFile);
    auto options = MakeObject<PdfFormatConversionOptions>(
    logFile, PdfFormat::PDF_UA_1, ConvertErrorAction::Delete);

    auto autoTaggingSettings = MakeObject<AutoTaggingSettings>();
    autoTaggingSettings->set_EnableAutoTagging(true);
    autoTaggingSettings->set_HeadingRecognitionStrategy(HeadingRecognitionStrategy::Auto);
    options->set_AutoTaggingSettings(autoTaggingSettings);

    document->Convert(options);
    document->Save(outputFile);
}

Validate a tagged PDF against PDF/UA-1

Check an input document and write the validation report to a log file.

A false result indicates that the document did not pass validation. Writing a report or completing the function does not mean the input is compliant.

Open the input PDF as a Document.
Call Validate() with logFile and PdfFormat::PDF_UA_1.
Print the returned Boolean result.
Review the validation report for any reported failures.


#include <iostream>
#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/IO/ConvertStrategies/PdfFormat.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;

void ValidateTaggedPdf(System::String inputFile, System::String logFile)
{
    auto document = MakeObject<Document>(inputFile);
    bool isValid = document->Validate(logFile, PdfFormat::PDF_UA_1);
    std::cout << "Is Valid: " << isValid << std::endl;
}

Cpp: Inspect tagged PDF content in C++

Mon, 12 Oct 2026 00:00:00 +0000

Access the tagged content container and inspect the logical structure of PDF documents with Aspose.PDF for C++. The examples show metadata initialization, structure root access, and inspection and modification of child elements.

Get the tagged content container

Access tagged content and define the document metadata.

This example creates a new document; it does not extract text from an existing PDF.

Create a Document and get its ITaggedContent with get_TaggedContent().
Set the document title and language with SetTitle() and SetLanguage().
Save the document with Save().


#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;

void GetTaggedContent(System::String outputFile)
{
    auto document = MakeObject<Document>();
    auto taggedContent = document->get_TaggedContent();
    taggedContent->SetTitle(u"Simple Tagged Pdf Document");
    taggedContent->SetLanguage(u"en-US");
    document->Save(outputFile);
}

Access the structure roots

Retrieve the structure-tree root and the document root element.

Create a Document and get its ITaggedContent with get_TaggedContent().
Set the document title and language with SetTitle() and SetLanguage().
Get the structure-tree root with get_StructTreeRootElement().
Get the document root with get_RootElement().
Print the string representations of both roots.
Save the document with Save().


#include <iostream>
#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/Element.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/ElementList.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructTreeRootElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;

void GetRootStructure(System::String outputFile)
{
    auto document = MakeObject<Document>();
    auto taggedContent = document->get_TaggedContent();
    taggedContent->SetTitle(u"Tagged Pdf Document");
    taggedContent->SetLanguage(u"en-US");

    std::cout << "StructTreeRootElement: " << taggedContent->get_StructTreeRootElement()->ToString() << std::endl;
    std::cout << "RootElement: " << taggedContent->get_RootElement()->ToString() << std::endl;

    document->Save(outputFile);
}

Inspect and update child elements

Read accessibility properties from an existing structure tree and update nested elements.

The sample assumes that the root contains a child at index 1. Inspect the input structure before applying the same indexing to another document.

Open the tagged input PDF as a Document and get its ITaggedContent.
Read the structure-tree root children with get_ChildElements().
Cast each applicable child to StructureElement and print its title, language, actual text, expansion text, and alternative text.
Select the root child at index 1 and iterate through its children.
Update the metadata of each applicable child.
Save the document with Save().


#include <iostream>
#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/Element.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/ElementList.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructTreeRootElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;

void AccessChildElements(System::String inputFile, System::String outputFile)
{
    auto document = MakeObject<Document>(inputFile);
    auto taggedContent = document->get_TaggedContent();

    auto elementList = taggedContent->get_StructTreeRootElement()->get_ChildElements();
    for (const auto& element : elementList) {
        if (auto structureElement = System::DynamicCast_noexcept<StructureElement>(element)) {
            std::cout << "StructureElement properties - "
            << "title: " << structureElement->get_Title()
            << ", language: " << structureElement->get_Language()
            << ", actual_text: " << structureElement->get_ActualText()
            << ", expansion_text: " << structureElement->get_ExpansionText()
            << ", alternative_text: " << structureElement->get_AlternativeText() << std::endl;
        }
    }

    auto firstChild = taggedContent->get_RootElement()->get_ChildElements()->idx_get(1);
    for (const auto& element : firstChild->get_ChildElements()) {
        if (auto structureElement = System::DynamicCast_noexcept<StructureElement>(element)) {
            structureElement->set_Title(u"title");
            structureElement->set_Language(u"fr-FR");
            structureElement->set_ActualText(u"actual text");
            structureElement->set_ExpansionText(u"exp");
            structureElement->set_AlternativeText(u"alt");
        }
    }

    document->Save(outputFile);
}

Cpp: Set tagged PDF structure element properties in C++

Mon, 12 Oct 2026 00:00:00 +0000

Configure the content and accessibility metadata of tagged PDF structure elements with Aspose.PDF for C++. This page covers headings, paragraphs, inline spans, links, notes, and custom tags.

Set common structure element properties

Add accessibility metadata to a heading nested inside a section.

Create a Document and get its ITaggedContent with get_TaggedContent().
Set the document title and language with SetTitle() and SetLanguage().
Create a section with CreateSectElement() and append it to the root.
Create a level-one heading and append it to the section.
Set the heading text.
Set the title, language, alternative text, expansion text, and actual text on the StructureElement.
Save the document with Save().


#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/BLSElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/GroupingElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;

void SetProperties(System::String outputFile)
{
    auto document = MakeObject<Document>();
    auto taggedContent = document->get_TaggedContent();
    taggedContent->SetTitle(u"Tagged Pdf Document");
    taggedContent->SetLanguage(u"en-US");

    auto rootElement = taggedContent->get_RootElement();
    auto sectionElement = taggedContent->CreateSectElement();
    rootElement->AppendChild(sectionElement, true);

    auto headerElement = taggedContent->CreateHeaderElement(1);
    sectionElement->AppendChild(headerElement, true);
    headerElement->SetText(u"The Header");

    headerElement->set_Title(u"Title");
    headerElement->set_Language(u"en-US");
    headerElement->set_AlternativeText(u"Alternative Text");
    headerElement->set_ExpansionText(u"Expansion Text");
    headerElement->set_ActualText(u"Actual Text");

    document->Save(outputFile);
}

Create a text paragraph

Add a tagged paragraph with text to the document root.

Create a Document and get its ITaggedContent with get_TaggedContent().
Set the document title and language with SetTitle() and SetLanguage().
Create a paragraph with CreateParagraphElement().
Set the paragraph text and append it to the root.
Save the document with Save().


#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/BLSElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;

void SetTextElements(System::String outputFile)
{
    auto document = MakeObject<Document>();
    auto taggedContent = document->get_TaggedContent();
    taggedContent->SetTitle(u"Tagged Pdf Document");
    taggedContent->SetLanguage(u"en-US");

    auto paragraphElement = taggedContent->CreateParagraphElement();
    paragraphElement->SetText(u"Paragraph.");
    taggedContent->get_RootElement()->AppendChild(paragraphElement, true);

    document->Save(outputFile);
}

Create headings and block text

Build headings at levels one through six followed by a paragraph.

Create a Document and get its ITaggedContent with get_TaggedContent().
Set the document title and language with SetTitle() and SetLanguage().
Create headings for levels 1 through 6 with CreateHeaderElement().
Set each heading text and append it to the root.
Create a paragraph, set its text, and append it to the root.
Save the document with Save().


#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/BLSElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;

void SetTextBlockElements(System::String outputFile)
{
    auto document = MakeObject<Document>();
    auto taggedContent = document->get_TaggedContent();
    taggedContent->SetTitle(u"Tagged Pdf Document");
    taggedContent->SetLanguage(u"en-US");

    for (int level = 1; level <= 6; level++) {
        auto header = taggedContent->CreateHeaderElement(level);
        header->SetText(String::Format(u"H{0}. Header of Level {1}", level, level));
        taggedContent->get_RootElement()->AppendChild(header, true);
    }

    auto p = taggedContent->CreateParagraphElement();
    p->SetText(u"P. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean nec lectus ac sem faucibus imperdiet.");
    taggedContent->get_RootElement()->AppendChild(p, true);

    document->Save(outputFile);
}

Create inline spans

Compose headings and paragraphs from inline span elements.

Create a Document and get its ITaggedContent with get_TaggedContent().
Set the document title and language with SetTitle() and SetLanguage().
Create headings at levels 1 through 6.
Create two spans for each heading with CreateSpanElement() and append them to the heading.
Create a paragraph and append it to the root.
Create ten spans, set their text, and append them to the paragraph.
Save the document with Save().


#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/BLSElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/ILSElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;

void SetInlineElements(System::String outputFile)
{
    auto document = MakeObject<Document>();
    auto taggedContent = document->get_TaggedContent();
    taggedContent->SetTitle(u"Tagged Pdf Document");
    taggedContent->SetLanguage(u"en-US");

    for (int level = 1; level <= 6; level++) {
        auto header = taggedContent->CreateHeaderElement(level);
        taggedContent->get_RootElement()->AppendChild(header, true);

        auto span1 = taggedContent->CreateSpanElement();
        span1->SetText(String::Format(u"H{0}. ", level));
        header->AppendChild(span1, true);

        auto span2 = taggedContent->CreateSpanElement();
        span2->SetText(String::Format(u"Level {0} Header", level));
        header->AppendChild(span2, true);
    }

    auto paragraphElement = taggedContent->CreateParagraphElement();
    paragraphElement->SetText(u"P. ");
    taggedContent->get_RootElement()->AppendChild(paragraphElement, true);

    for (int index = 1; index <= 10; index++) {
        auto span = taggedContent->CreateSpanElement();
        span->SetText(String::Format(u"Span {0}. ", index));
        paragraphElement->AppendChild(span, true);
    }

    document->Save(outputFile);
}

Create text and image links

Add links with alternate descriptions and an image link with a layout attribute.

Supply an existing image file. The example includes a multiline text link.

Create a Document and get its ITaggedContent with get_TaggedContent().
Set the document title and language with SetTitle() and SetLanguage().
Create paragraphs and add LinkElement objects with CreateLinkElement().
Assign each link a WebHyperlink, link text, and alternate description.
Create another link and load an image into a FigureElement.
Set the figure alternative text.
Create a StructureAttribute for block placement and assign it to the link layout attributes.
Append the figure to the link and set the link alternate description.
Save the document with Save().


#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Generator/WebHyperlink.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/AttributeName.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/BLSElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/ILSElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/IllustrationElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureAttribute.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureAttributeCollection.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureAttributes.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;

void SetElements(System::String imageFile, System::String outputFile)
{
    auto document = MakeObject<Document>();
    auto taggedContent = document->get_TaggedContent();
    taggedContent->SetTitle(u"Link Elements Example");
    taggedContent->SetLanguage(u"en-US");

    for (int index = 1; index <= 4; index++) {
        auto paragraph = taggedContent->CreateParagraphElement();
        taggedContent->get_RootElement()->AppendChild(paragraph, true);

        auto link = taggedContent->CreateLinkElement();
        paragraph->AppendChild(link, true);
        link->set_Hyperlink(MakeObject<WebHyperlink>(u"http://google.com"));
        link->SetText(index == 4 ? u"The multiline link: Google Google Google Google" : u"Google");
        link->set_AlternateDescriptions(u"Link to Google");
    }

    auto paragraph = taggedContent->CreateParagraphElement();
    taggedContent->get_RootElement()->AppendChild(paragraph, true);

    auto link = taggedContent->CreateLinkElement();
    paragraph->AppendChild(link, true);
    link->set_Hyperlink(MakeObject<WebHyperlink>(u"http://google.com"));

    auto figure = taggedContent->CreateFigureElement();
    figure->SetImage(imageFile, 1200);
    figure->set_AlternativeText(u"Google icon");

    auto linkLayoutAttributes = link->get_Attributes()->GetAttributes(AttributeOwnerStandard::Layout());
    auto placementAttribute = MakeObject<StructureAttribute>(AttributeKey::Placement);
    placementAttribute->SetNameValue(AttributeName::Placement_Block);
    linkLayoutAttributes->SetAttribute(placementAttribute);

    link->AppendChild(figure, true);
    link->set_AlternateDescriptions(u"Link to Google");

    document->Save(outputFile);
}

Compose paragraphs from spans

Append inline spans to paragraphs to build their text content.

Despite its function name AddLinkElement, this example creates spans. It does not create hyperlinks; see the preceding link example.

Create a Document and get its ITaggedContent with get_TaggedContent().
Set the document title and language with SetTitle() and SetLanguage().
Create four paragraphs with CreateParagraphElement().
Create two spans for each paragraph with CreateSpanElement().
Set the paragraph prefix and the span text.
Append both spans to the paragraph.
Save the document with Save().


#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/BLSElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/ILSElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;

void AddLinkElement(System::String outputFile)
{
    auto document = MakeObject<Document>();
    auto taggedContent = document->get_TaggedContent();
    taggedContent->SetTitle(u"Text Elements Example");
    taggedContent->SetLanguage(u"en-US");

    for (int paragraphIndex = 1; paragraphIndex <= 4; paragraphIndex++) {
        auto paragraph = taggedContent->CreateParagraphElement();
        taggedContent->get_RootElement()->AppendChild(paragraph, true);

        auto span1 = taggedContent->CreateSpanElement();
        span1->SetText(String::Format(u"Span_{0}1", paragraphIndex));
        auto span2 = taggedContent->CreateSpanElement();
        span2->SetText(String::Format(u" and Span_{0}2.", paragraphIndex));

        paragraph->SetText(u"Paragraph with ");
        paragraph->AppendChild(span1, true);
        paragraph->AppendChild(span2, true);
    }

    document->Save(outputFile);
}

Add notes with identifiers

Create note elements with automatically generated and explicit IDs.

Create a Document and get its ITaggedContent with get_TaggedContent().
Set the document title and language with SetTitle() and SetLanguage().
Create a paragraph and append it to the root.
Create three notes with CreateNoteElement() and append them to the paragraph.
Set the note text.
Keep the generated ID for the first note and assign explicit IDs to the other notes with SetId().
Save the document with Save().


#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Generator/Note.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/BLSElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/ILSElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;

void SetNoteElement(System::String outputFile)
{
    auto document = MakeObject<Document>();
    auto taggedContent = document->get_TaggedContent();
    taggedContent->SetTitle(u"Sample of Note Elements");
    taggedContent->SetLanguage(u"en-US");

    auto paragraph = taggedContent->CreateParagraphElement();
    taggedContent->get_RootElement()->AppendChild(paragraph, true);

    auto note1 = taggedContent->CreateNoteElement();
    paragraph->AppendChild(note1, true);
    note1->SetText(u"Note with auto generate ID. ");

    auto note2 = taggedContent->CreateNoteElement();
    paragraph->AppendChild(note2, true);
    note2->SetText(u"Note with ID = 'note_002'. ");
    note2->SetId(u"note_002");

    auto note3 = taggedContent->CreateNoteElement();
    paragraph->AppendChild(note3, true);
    note3->SetText(u"Note with ID = 'note_003'. ");
    note3->SetId(u"note_003");

    document->Save(outputFile);
}

Set custom tag names

Assign custom tags to paragraphs and spans within a section.

Create a Document and get its ITaggedContent with get_TaggedContent().
Set the document title and language with SetTitle() and SetLanguage().
Create a section with CreateSectElement() and append it to the root.
Create paragraph and span elements and set their text.
Assign the sample custom names with SetTag().
Append each span to its paragraph and each paragraph to the section.
Save the document with Save().


#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/BLSElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/GroupingElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/ILSElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;

void SetTagName(System::String outputFile)
{
    auto document = MakeObject<Document>();
    auto taggedContent = document->get_TaggedContent();
    taggedContent->SetTitle(u"Tagged Pdf Document");
    taggedContent->SetLanguage(u"en-US");

    auto sectionElement = taggedContent->CreateSectElement();
    taggedContent->get_RootElement()->AppendChild(sectionElement, true);

    const String paragraphTags[] = {u"P1", u"Para", u"Para", u"Paragraph"};
    const String spanTags[] = {u"SPAN", u"Sp", u"Sp", u"TheSpan"};

    for (int index = 0; index < 4; index++) {
        auto paragraph = taggedContent->CreateParagraphElement();
        paragraph->SetText(String::Format(u"P{0}. ", index + 1));
        paragraph->SetTag(paragraphTags[index]);

        auto span = taggedContent->CreateSpanElement();
        span->SetText(String::Format(u"Span {0}.", index + 1));
        span->SetTag(spanTags[index]);

        paragraph->AppendChild(span, true);
        sectionElement->AppendChild(paragraph, true);
    }

    document->Save(outputFile);
}

Cpp: Work with tables in tagged PDFs in C++

Mon, 12 Oct 2026 00:00:00 +0000

Create tagged tables with explicit header, body, and footer elements using Aspose.PDF for C++. The examples show how to describe a table, merge cells, style tables and rows, and adjust their position.

Create a tagged table

Build a table with a header, body, footer, merged cells, and summary metadata.

The example creates 50 body rows and uses Arial for cell text. Make sure the font is available.

Create a Document and get its ITaggedContent with get_TaggedContent().
Set the document title and language with SetTitle() and SetLanguage().
Create a table with CreateTableElement() and append it to the root.
Configure the border and create the table header, body, and footer.
Create a header row with TH cells.
Create body rows with TD cells and configure text, borders, padding, and alignment.
Set row and column spans for the merged cell and skip the positions it covers.
Create the footer row.
Set the table summary with a StructureAttribute.
Save the document with Save().


#include <Aspose.PDF.Cpp/Color.h>
#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Generator/BorderInfo.h>
#include <Aspose.PDF.Cpp/Generator/BorderSide.h>
#include <Aspose.PDF.Cpp/Generator/MarginInfo.h>
#include <Aspose.PDF.Cpp/HorizontalAlignment.h>
#include <Aspose.PDF.Cpp/Table/Cell.h>
#include <Aspose.PDF.Cpp/Table/Row.h>
#include <Aspose.PDF.Cpp/Table/Table.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/AttributeName.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/BLSTableElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureAttribute.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureAttributeCollection.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureAttributes.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureTextState.h>
#include <Aspose.PDF.Cpp/Text/Font.h>
#include <Aspose.PDF.Cpp/Text/FontRepository.h>
#include <Aspose.PDF.Cpp/Text/FontStyles.h>
#include <Aspose.PDF.Cpp/Text/TextState.h>
#include <Aspose.PDF.Cpp/VerticalAlignment.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;
using namespace Aspose::Pdf::Text;

void CreateTable(System::String outputFile)
{
    auto document = MakeObject<Document>();
    auto taggedContent = document->get_TaggedContent();
    taggedContent->SetTitle(u"Example table");
    taggedContent->SetLanguage(u"en-US");

    auto tableElement = taggedContent->CreateTableElement();
    taggedContent->get_RootElement()->AppendChild(tableElement, true);
    tableElement->set_Border(MakeObject<BorderInfo>(BorderSide::All, 1.2f, Color::get_DarkBlue()));


    auto tableTHeadElement = tableElement->CreateTHead();
    auto tableTBodyElement = tableElement->CreateTBody();
    auto tableTFootElement = tableElement->CreateTFoot();

    auto headTrElement = tableTHeadElement->CreateTR();
    headTrElement->set_AlternativeText(u"Head Row");
    headTrElement->set_BackgroundColor(Color::get_LightGray());

    for (int columnIndex = 0; columnIndex < 4; columnIndex++) {
        auto thElement = headTrElement->CreateTH();
        thElement->SetText(String::Format(u"Head {0}", columnIndex));
        thElement->set_BackgroundColor(Color::get_GreenYellow());
        thElement->set_Border(MakeObject<BorderInfo>(BorderSide::All, 4.0f, Color::get_Gray()));
        thElement->set_IsNoBorder(true);
        thElement->set_Margin(MakeObject<MarginInfo>(16.0, 2.0, 8.0, 2.0));
        thElement->set_Alignment(HorizontalAlignment::Right);
    }

    for (int rowIndex = 0; rowIndex < 50; rowIndex++) {
        auto trElement = tableTBodyElement->CreateTR();
        trElement->set_AlternativeText(String::Format(u"Row {0}", rowIndex));

        for (int columnIndex = 0; columnIndex < 4; columnIndex++) {
            int colSpan = 1;
            int rowSpan = 1;

            if (true && columnIndex == 1 && rowIndex == 1) {
                colSpan = 2;
                rowSpan = 2;
            } else if (true && ((rowIndex == 1 && columnIndex == 2)
            || (rowIndex == 2 && (columnIndex == 1 || columnIndex == 2)))) {
                continue;
            }

            auto tdElement = trElement->CreateTD();
            tdElement->SetText(String::Format(u"Cell [{0}, {1}]", rowIndex, columnIndex));
            tdElement->set_BackgroundColor(Color::get_Yellow());
            tdElement->set_Border(MakeObject<BorderInfo>(BorderSide::All, 4.0f, Color::get_Gray()));
            tdElement->set_IsNoBorder(false);
            tdElement->set_Margin(MakeObject<MarginInfo>(8.0, 2.0, 8.0, 2.0));
            tdElement->set_Alignment(HorizontalAlignment::Center);

            auto cellTextState = MakeObject<TextState>();
            cellTextState->set_ForegroundColor(Color::get_DarkBlue());
            cellTextState->set_FontSize(7.5f);
            cellTextState->set_FontStyle(FontStyles::Bold);
            cellTextState->set_Font(FontRepository::FindFont(u"Arial"));
            tdElement->set_DefaultCellTextState(cellTextState);

            tdElement->set_IsWordWrapped(true);
            tdElement->set_VerticalAlignment(VerticalAlignment::Center);
            tdElement->set_ColSpan(colSpan);
            tdElement->set_RowSpan(rowSpan);
        }
    }

    auto footTrElement = tableTFootElement->CreateTR();
    footTrElement->set_AlternativeText(u"Foot Row");
    footTrElement->set_BackgroundColor(Color::get_LightSeaGreen());

    for (int columnIndex = 0; columnIndex < 4; columnIndex++) {
        auto tdElement = footTrElement->CreateTD();
        tdElement->SetText(String::Format(u"Foot {0}", columnIndex));
        tdElement->set_Alignment(HorizontalAlignment::Center);
        tdElement->get_StructureTextState()->set_FontSize(7.0f);
        tdElement->get_StructureTextState()->set_FontStyle(FontStyles::Bold);
    }


    auto tableAttributes = tableElement->get_Attributes()->GetAttributes(AttributeOwnerStandard::Table());
    auto summaryAttribute = MakeObject<StructureAttribute>(AttributeKey::Summary);
    summaryAttribute->SetStringValue(u"The summary text for table");
    tableAttributes->SetAttribute(summaryAttribute);

    document->Save(outputFile);
}

Style a tagged table

Configure table layout, borders, cell defaults, and repeating rows and columns.

The merged-cell branch is disabled in this example. For active row and column spans, see the cell styling example.

Create a Document and get its ITaggedContent with get_TaggedContent().
Set the document title and language with SetTitle() and SetLanguage().
Create a table with CreateTableElement() and append it to the root.
Set the background, border, alignment, column widths, and column adjustment.
Configure default cell borders, padding, and text formatting.
Set the table position and repeating row and column settings.
Create header, body, and footer rows.
Apply per-cell styles and fill the cells with text.
Save the document with Save().


#include <Aspose.PDF.Cpp/Color.h>
#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Table/VerticalBroken.h>
#include <Aspose.PDF.Cpp/Generator/BorderInfo.h>
#include <Aspose.PDF.Cpp/Generator/BorderSide.h>
#include <Aspose.PDF.Cpp/Generator/ColumnAdjustment.h>
#include <Aspose.PDF.Cpp/Generator/MarginInfo.h>
#include <Aspose.PDF.Cpp/HorizontalAlignment.h>
#include <Aspose.PDF.Cpp/Table/Cell.h>
#include <Aspose.PDF.Cpp/Table/Row.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/BLSTableElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureTextState.h>
#include <Aspose.PDF.Cpp/Text/Font.h>
#include <Aspose.PDF.Cpp/Text/FontRepository.h>
#include <Aspose.PDF.Cpp/Text/FontStyles.h>
#include <Aspose.PDF.Cpp/Text/TextState.h>
#include <Aspose.PDF.Cpp/VerticalAlignment.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;
using namespace Aspose::Pdf::Text;

void StyleTable(System::String outputFile)
{
    auto document = MakeObject<Document>();
    auto taggedContent = document->get_TaggedContent();
    taggedContent->SetTitle(u"Example table style");
    taggedContent->SetLanguage(u"en-US");

    auto tableElement = taggedContent->CreateTableElement();
    taggedContent->get_RootElement()->AppendChild(tableElement, true);

    tableElement->set_BackgroundColor(Color::get_Beige());
    tableElement->set_Border(MakeObject<BorderInfo>(BorderSide::All, 0.80f, Color::get_Gray()));
    tableElement->set_Alignment(HorizontalAlignment::Center);
    tableElement->set_Broken(TableBroken::Vertical);
    tableElement->set_ColumnAdjustment(ColumnAdjustment::AutoFitToWindow);
    tableElement->set_ColumnWidths(u"80 80 80 80 80");
    tableElement->set_DefaultCellBorder(MakeObject<BorderInfo>(BorderSide::All, 0.50f, Color::get_DarkBlue()));
    tableElement->set_DefaultCellPadding(MakeObject<MarginInfo>(16.0, 2.0, 8.0, 2.0));
    tableElement->get_DefaultCellTextState()->set_ForegroundColor(Color::get_DarkCyan());
    tableElement->get_DefaultCellTextState()->set_FontSize(8.0f);
    tableElement->set_DefaultColumnWidth(u"70");
    tableElement->set_IsBordersIncluded(true);
    tableElement->set_Left(0.0f);
    tableElement->set_Top(40.0f);
    tableElement->set_RepeatingColumnsCount(2);
    tableElement->set_RepeatingRowsCount(3);

    auto rowStyle = MakeObject<TextState>();
    rowStyle->set_BackgroundColor(Color::get_LightCoral());
    tableElement->set_RepeatingRowsStyle(rowStyle);


    auto tableTHeadElement = tableElement->CreateTHead();
    auto tableTBodyElement = tableElement->CreateTBody();
    auto tableTFootElement = tableElement->CreateTFoot();

    auto headTrElement = tableTHeadElement->CreateTR();
    headTrElement->set_AlternativeText(u"Head Row");
    headTrElement->set_BackgroundColor(Color::get_LightGray());

    for (int columnIndex = 0; columnIndex < 5; columnIndex++) {
        auto thElement = headTrElement->CreateTH();
        thElement->SetText(String::Format(u"Head {0}", columnIndex));
        thElement->set_BackgroundColor(Color::get_GreenYellow());
        thElement->set_Border(MakeObject<BorderInfo>(BorderSide::All, 4.0f, Color::get_Gray()));
        thElement->set_IsNoBorder(true);
        thElement->set_Margin(MakeObject<MarginInfo>(16.0, 2.0, 8.0, 2.0));
        thElement->set_Alignment(HorizontalAlignment::Right);
    }

    for (int rowIndex = 0; rowIndex < 10; rowIndex++) {
        auto trElement = tableTBodyElement->CreateTR();
        trElement->set_AlternativeText(u"Row " + rowIndex);

        for (int columnIndex = 0; columnIndex < 5; columnIndex++) {
            int colSpan = 1;
            int rowSpan = 1;

            if (false && columnIndex == 1 && rowIndex == 1) {
                colSpan = 2;
                rowSpan = 2;
            } else if (false && ((rowIndex == 1 && columnIndex == 2)
            || (rowIndex == 2 && (columnIndex == 1 || columnIndex == 2)))) {
                continue;
            }

            auto tdElement = trElement->CreateTD();
            tdElement->SetText(String::Format(u"Cell [{0}, {1}]", rowIndex, columnIndex));
            tdElement->set_BackgroundColor(Color::get_Yellow());
            tdElement->set_Border(MakeObject<BorderInfo>(BorderSide::All, 4.0f, Color::get_Gray()));
            tdElement->set_IsNoBorder(false);
            tdElement->set_Margin(MakeObject<MarginInfo>(8.0, 2.0, 8.0, 2.0));
            tdElement->set_Alignment(HorizontalAlignment::Center);

            auto cellTextState = MakeObject<TextState>();
            cellTextState->set_ForegroundColor(Color::get_DarkBlue());
            cellTextState->set_FontSize(7.5f);
            cellTextState->set_FontStyle(FontStyles::Bold);
            cellTextState->set_Font(FontRepository::FindFont(u"Arial"));
            tdElement->set_DefaultCellTextState(cellTextState);

            tdElement->set_IsWordWrapped(true);
            tdElement->set_VerticalAlignment(VerticalAlignment::Center);
            tdElement->set_ColSpan(colSpan);
            tdElement->set_RowSpan(rowSpan);
        }
    }

    auto footTrElement = tableTFootElement->CreateTR();
    footTrElement->set_AlternativeText(u"Foot Row");
    footTrElement->set_BackgroundColor(Color::get_LightSeaGreen());

    for (int columnIndex = 0; columnIndex < 5; columnIndex++) {
        auto tdElement = footTrElement->CreateTD();
        tdElement->SetText(String::Format(u"Foot {0}", columnIndex));
        tdElement->set_Alignment(HorizontalAlignment::Center);
        tdElement->get_StructureTextState()->set_FontSize(7.0f);
        tdElement->get_StructureTextState()->set_FontStyle(FontStyles::Bold);
    }

    document->Save(outputFile);
}

Style table rows

Apply row height, pagination, borders, padding, and default cell text settings.

Create a Document and get its ITaggedContent with get_TaggedContent().
Set the document title and language with SetTitle() and SetLanguage().
Create a table with CreateTableElement() and append it to the root.
Create the table header, body, and footer.
Populate the header row.
Create seven body rows and set their background, borders, minimum height, and fixed height.
Configure row page breaks, row splitting, default cell formatting, padding, and vertical alignment.
Populate the body and footer cells.
Save the document with Save().


#include <Aspose.PDF.Cpp/Color.h>
#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Generator/BorderInfo.h>
#include <Aspose.PDF.Cpp/Generator/BorderSide.h>
#include <Aspose.PDF.Cpp/Generator/MarginInfo.h>
#include <Aspose.PDF.Cpp/Table/Cell.h>
#include <Aspose.PDF.Cpp/Table/Row.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/BLSTableElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>
#include <Aspose.PDF.Cpp/Text/TextState.h>
#include <Aspose.PDF.Cpp/VerticalAlignment.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;
using namespace Aspose::Pdf::Text;

void StyleTableRow(System::String outputFile)
{
    auto document = MakeObject<Document>();
    auto taggedContent = document->get_TaggedContent();
    taggedContent->SetTitle(u"Example table style");
    taggedContent->SetLanguage(u"en-US");

    auto tableElement = taggedContent->CreateTableElement();
    taggedContent->get_RootElement()->AppendChild(tableElement, true);
    auto tableTHeadElement = tableElement->CreateTHead();
    auto tableTBodyElement = tableElement->CreateTBody();
    auto tableTFootElement = tableElement->CreateTFoot();

    auto headTrElement = tableTHeadElement->CreateTR();
    headTrElement->set_AlternativeText(u"Head Row");
    for (int colIndex = 0; colIndex < 3; colIndex++) {
        headTrElement->CreateTH()->SetText(String::Format(u"Head {0}", colIndex));
    }

    for (int rowIndex = 0; rowIndex < 7; rowIndex++) {
        auto trElement = tableTBodyElement->CreateTR();
        trElement->set_AlternativeText(u"Row " + rowIndex);
        trElement->set_BackgroundColor(Color::get_LightGoldenrodYellow());
        trElement->set_Border(MakeObject<BorderInfo>(BorderSide::All, 0.75f, Color::get_DarkGray()));
        trElement->set_DefaultCellBorder(MakeObject<BorderInfo>(BorderSide::All, 0.50f, Color::get_Blue()));
        trElement->set_MinRowHeight(100.0);
        trElement->set_FixedRowHeight(120.0);
        trElement->set_IsInNewPage(rowIndex % 3 == 1);
        trElement->set_IsRowBroken(true);

        auto cellTextState = MakeObject<TextState>();
        cellTextState->set_ForegroundColor(Color::get_Red());
        trElement->set_DefaultCellTextState(cellTextState);
        trElement->set_DefaultCellPadding(MakeObject<MarginInfo>(16.0, 2.0, 8.0, 2.0));
        trElement->set_VerticalAlignment(VerticalAlignment::Bottom);

        for (int colIndex = 0; colIndex < 3; colIndex++) {
            trElement->CreateTD()->SetText(String::Format(u"Cell [{0}, {1}]", rowIndex, colIndex));
        }
    }

    auto footTrElement = tableTFootElement->CreateTR();
    footTrElement->set_AlternativeText(u"Foot Row");
    for (int colIndex = 0; colIndex < 3; colIndex++) {
        footTrElement->CreateTD()->SetText(String::Format(u"Foot {0}", colIndex));
    }

    document->Save(outputFile);
}

Style table cells and spans

Set cell appearance and merge a cell across two rows and two columns.

Create a Document and get its ITaggedContent with get_TaggedContent().
Set the document title and language with SetTitle() and SetLanguage().
Create a table with CreateTableElement() and append it to the root.
Create the table header, body, and footer.
Create header cells and set their formatting.
Create body cells and set text, background, border, margins, alignment, and text state.
Configure word wrapping and vertical alignment.
Set ColSpan and RowSpan for the merged cell, skipping the covered cell positions.
Populate and style the footer.
Save the document with Save().


#include <Aspose.PDF.Cpp/Color.h>
#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Generator/BorderInfo.h>
#include <Aspose.PDF.Cpp/Generator/BorderSide.h>
#include <Aspose.PDF.Cpp/Generator/MarginInfo.h>
#include <Aspose.PDF.Cpp/HorizontalAlignment.h>
#include <Aspose.PDF.Cpp/Table/Cell.h>
#include <Aspose.PDF.Cpp/Table/Row.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/BLSTableElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureTextState.h>
#include <Aspose.PDF.Cpp/Text/Font.h>
#include <Aspose.PDF.Cpp/Text/FontRepository.h>
#include <Aspose.PDF.Cpp/Text/FontStyles.h>
#include <Aspose.PDF.Cpp/Text/TextState.h>
#include <Aspose.PDF.Cpp/VerticalAlignment.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;
using namespace Aspose::Pdf::Text;

void StyleTableCell(System::String outputFile)
{
    auto document = MakeObject<Document>();
    auto taggedContent = document->get_TaggedContent();
    taggedContent->SetTitle(u"Example table cell style");
    taggedContent->SetLanguage(u"en-US");

    auto tableElement = taggedContent->CreateTableElement();
    taggedContent->get_RootElement()->AppendChild(tableElement, true);

    auto tableTHeadElement = tableElement->CreateTHead();
    auto tableTBodyElement = tableElement->CreateTBody();
    auto tableTFootElement = tableElement->CreateTFoot();

    auto headTrElement = tableTHeadElement->CreateTR();
    headTrElement->set_AlternativeText(u"Head Row");
    headTrElement->set_BackgroundColor(Color::get_LightGray());

    for (int columnIndex = 0; columnIndex < 4; columnIndex++) {
        auto thElement = headTrElement->CreateTH();
        thElement->SetText(String::Format(u"Head {0}", columnIndex));
        thElement->set_BackgroundColor(Color::get_GreenYellow());
        thElement->set_Border(MakeObject<BorderInfo>(BorderSide::All, 4.0f, Color::get_Gray()));
        thElement->set_IsNoBorder(true);
        thElement->set_Margin(MakeObject<MarginInfo>(16.0, 2.0, 8.0, 2.0));
        thElement->set_Alignment(HorizontalAlignment::Right);
    }

    for (int rowIndex = 0; rowIndex < 4; rowIndex++) {
        auto trElement = tableTBodyElement->CreateTR();
        trElement->set_AlternativeText(u"Row " + rowIndex);

        for (int columnIndex = 0; columnIndex < 4; columnIndex++) {
            int colSpan = 1;
            int rowSpan = 1;

            if (true && columnIndex == 1 && rowIndex == 1) {
                colSpan = 2;
                rowSpan = 2;
            } else if (true && ((rowIndex == 1 && columnIndex == 2)
            || (rowIndex == 2 && (columnIndex == 1 || columnIndex == 2)))) {
                continue;
            }

            auto tdElement = trElement->CreateTD();
            tdElement->SetText(String::Format(u"Cell [{0}, {1}]", rowIndex, columnIndex));
            tdElement->set_BackgroundColor(Color::get_Yellow());
            tdElement->set_Border(MakeObject<BorderInfo>(BorderSide::All, 4.0f, Color::get_Gray()));
            tdElement->set_IsNoBorder(false);
            tdElement->set_Margin(MakeObject<MarginInfo>(8.0, 2.0, 8.0, 2.0));
            tdElement->set_Alignment(HorizontalAlignment::Center);

            auto cellTextState = MakeObject<TextState>();
            cellTextState->set_ForegroundColor(Color::get_DarkBlue());
            cellTextState->set_FontSize(7.5f);
            cellTextState->set_FontStyle(FontStyles::Bold);
            cellTextState->set_Font(FontRepository::FindFont(u"Arial"));
            tdElement->set_DefaultCellTextState(cellTextState);

            tdElement->set_IsWordWrapped(true);
            tdElement->set_VerticalAlignment(VerticalAlignment::Center);
            tdElement->set_ColSpan(colSpan);
            tdElement->set_RowSpan(rowSpan);
        }
    }

    auto footTrElement = tableTFootElement->CreateTR();
    footTrElement->set_AlternativeText(u"Foot Row");
    footTrElement->set_BackgroundColor(Color::get_LightSeaGreen());

    for (int columnIndex = 0; columnIndex < 4; columnIndex++) {
        auto tdElement = footTrElement->CreateTD();
        tdElement->SetText(String::Format(u"Foot {0}", columnIndex));
        tdElement->set_Alignment(HorizontalAlignment::Center);
        tdElement->get_StructureTextState()->set_FontSize(7.0f);
        tdElement->get_StructureTextState()->set_FontStyle(FontStyles::Bold);
    }


    document->Save(outputFile);
}

Adjust table position

Apply PositionSettings to a tagged table before adding its rows and cells.

Create a Document and get its ITaggedContent with get_TaggedContent().
Set the document title and language with SetTitle() and SetLanguage().
Create a table with CreateTableElement() and append it to the root.
Create PositionSettings with a left margin and explicit alignment and pagination flags.
Apply the settings to the table with AdjustPosition().
Create header, body, and footer rows.
Populate and style the cells, including the merged cell.
Save the document with Save().


#include <Aspose.PDF.Cpp/Color.h>
#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Generator/BorderInfo.h>
#include <Aspose.PDF.Cpp/Generator/BorderSide.h>
#include <Aspose.PDF.Cpp/Generator/MarginInfo.h>
#include <Aspose.PDF.Cpp/HorizontalAlignment.h>
#include <Aspose.PDF.Cpp/Table/Cell.h>
#include <Aspose.PDF.Cpp/Table/Row.h>
#include <Aspose.PDF.Cpp/Tagged/ITaggedContent.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/BLSTableElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureElement.h>
#include <Aspose.PDF.Cpp/Tagged/LogicalStructure/StructureTextState.h>
#include <Aspose.PDF.Cpp/Tagged/PositionSettings.h>
#include <Aspose.PDF.Cpp/Text/Font.h>
#include <Aspose.PDF.Cpp/Text/FontRepository.h>
#include <Aspose.PDF.Cpp/Text/FontStyles.h>
#include <Aspose.PDF.Cpp/Text/TextState.h>
#include <Aspose.PDF.Cpp/VerticalAlignment.h>

using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Tagged;
using namespace Aspose::Pdf::LogicalStructure;
using namespace Aspose::Pdf::Text;

void AdjustTablePosition(System::String outputFile)
{
    auto document = MakeObject<Document>();
    auto taggedContent = document->get_TaggedContent();
    taggedContent->SetTitle(u"Example table position");
    taggedContent->SetLanguage(u"en-US");

    auto tableElement = taggedContent->CreateTableElement();
    taggedContent->get_RootElement()->AppendChild(tableElement, true);

    auto positionSettings = MakeObject<PositionSettings>();
    positionSettings->set_HorizontalAlignment(HorizontalAlignment::None);
    positionSettings->set_Margin(MakeObject<MarginInfo>(20, 0, 0, 0));
    positionSettings->set_VerticalAlignment(VerticalAlignment::None);
    positionSettings->set_IsFirstParagraphInColumn(false);
    positionSettings->set_IsKeptWithNext(false);
    positionSettings->set_IsInNewPage(false);
    positionSettings->set_IsInLineParagraph(false);
    tableElement->AdjustPosition(positionSettings);


    auto tableTHeadElement = tableElement->CreateTHead();
    auto tableTBodyElement = tableElement->CreateTBody();
    auto tableTFootElement = tableElement->CreateTFoot();

    auto headTrElement = tableTHeadElement->CreateTR();
    headTrElement->set_AlternativeText(u"Head Row");
    headTrElement->set_BackgroundColor(Color::get_LightGray());

    for (int columnIndex = 0; columnIndex < 4; columnIndex++) {
        auto thElement = headTrElement->CreateTH();
        thElement->SetText(String::Format(u"Head {0}", columnIndex));
        thElement->set_BackgroundColor(Color::get_GreenYellow());
        thElement->set_Border(MakeObject<BorderInfo>(BorderSide::All, 4.0f, Color::get_Gray()));
        thElement->set_IsNoBorder(true);
        thElement->set_Margin(MakeObject<MarginInfo>(16.0, 2.0, 8.0, 2.0));
        thElement->set_Alignment(HorizontalAlignment::Right);
    }

    for (int rowIndex = 0; rowIndex < 4; rowIndex++) {
        auto trElement = tableTBodyElement->CreateTR();
        trElement->set_AlternativeText(u"Row " + rowIndex);

        for (int columnIndex = 0; columnIndex < 4; columnIndex++) {
            int colSpan = 1;
            int rowSpan = 1;

            if (true && columnIndex == 1 && rowIndex == 1) {
                colSpan = 2;
                rowSpan = 2;
            } else if (true && ((rowIndex == 1 && columnIndex == 2)
            || (rowIndex == 2 && (columnIndex == 1 || columnIndex == 2)))) {
                continue;
            }

            auto tdElement = trElement->CreateTD();
            tdElement->SetText(String::Format(u"Cell [{0}, {1}]", rowIndex, columnIndex));
            tdElement->set_BackgroundColor(Color::get_Yellow());
            tdElement->set_Border(MakeObject<BorderInfo>(BorderSide::All, 4.0f, Color::get_Gray()));
            tdElement->set_IsNoBorder(false);
            tdElement->set_Margin(MakeObject<MarginInfo>(8.0, 2.0, 8.0, 2.0));
            tdElement->set_Alignment(HorizontalAlignment::Center);

            auto cellTextState = MakeObject<TextState>();
            cellTextState->set_ForegroundColor(Color::get_DarkBlue());
            cellTextState->set_FontSize(7.5f);
            cellTextState->set_FontStyle(FontStyles::Bold);
            cellTextState->set_Font(FontRepository::FindFont(u"Arial"));
            tdElement->set_DefaultCellTextState(cellTextState);

            tdElement->set_IsWordWrapped(true);
            tdElement->set_VerticalAlignment(VerticalAlignment::Center);
            tdElement->set_ColSpan(colSpan);
            tdElement->set_RowSpan(rowSpan);
        }
    }

    auto footTrElement = tableTFootElement->CreateTR();
    footTrElement->set_AlternativeText(u"Foot Row");
    footTrElement->set_BackgroundColor(Color::get_LightSeaGreen());

    for (int columnIndex = 0; columnIndex < 4; columnIndex++) {
        auto tdElement = footTrElement->CreateTD();
        tdElement->SetText(String::Format(u"Foot {0}", columnIndex));
        tdElement->set_Alignment(HorizontalAlignment::Center);
        tdElement->get_StructureTextState()->set_FontSize(7.0f);
        tdElement->get_StructureTextState()->set_FontStyle(FontStyles::Bold);
    }

    document->Save(outputFile);
}