Documentation – Work with PDF facades in C++

Cpp: Merge, split, and arrange PDF pages in C++

Fri, 13 Nov 2026 00:00:00 +0000

Use PdfFileEditor to merge, append, insert, delete, extract, split, impose, and resize PDF pages and content.

These functions pass file paths directly to PdfFileEditor rather than binding an input PDF. Supply the page counts referenced in each sample. Some examples inspect Boolean results and report failure or throw an exception.

PdfFileEditor tutorials

Cpp: Edit PDF content and actions in C++

Fri, 13 Nov 2026 00:00:00 +0000

Use PdfContentEditor to replace text and images, manage attachments and stamps, create annotations, and configure document actions and viewer preferences.

Several examples require existing images or stamps on page 1. CreateStampSample produces a PDF with a stamp that can be used by the stamp inspection examples. Viewer action and media activation are separate from creating the PDF objects.

What you can do with PdfContentEditor

Cpp: Manage PDF annotations in C++

Fri, 13 Nov 2026 00:00:00 +0000

Use PdfAnnotationEditor to delete, extract, flatten, modify, and transfer annotations and exchange annotation data through XFDF.

Annotation import examples create blank target pages before importing annotations; they do not copy the original page content. The flattening example enables ApplyRedactions.

The snippets are independent example functions with their SDK includes and example namespaces. Configure the Aspose.PDF for C++ SDK, supply the input resources referenced by the sample, and choose writable output paths. The examples retain the source field names, page indexes, coordinates, and options.

PdfAnnotationEditor workflows

Delete all annotations by type

Delete Text and FreeText annotations from the bound PDF.

Create PdfAnnotationEditor.
Bind the PDF input with Facade::BindPdf().
Delete the selected annotations with PdfAnnotationEditor::DeleteAnnotations().
Save the resulting PDF with PdfAnnotationEditor::Save().

#include <Aspose.PDF.Cpp/Facades/PdfAnnotationEditor.h>
#include <system/string.h>

namespace Facades::Examples::PDF_AnnotationEditor
{
using namespace System;
using namespace Aspose::Pdf;
using Aspose::Pdf::Facades::PdfAnnotationEditor;

void DeleteAllAnnotationsByType(String inputFile, String outputFile)
{
    auto editor = MakeObject<PdfAnnotationEditor>();
    editor->BindPdf(inputFile);

    editor->DeleteAnnotations(u"Text");
    editor->DeleteAnnotations(u"FreeText");

    editor->Save(outputFile);
}
} // namespace Facades::Examples::PDF_AnnotationEditor

Delete all annotations

Delete all annotations from the bound PDF.

Create PdfAnnotationEditor.
Bind the PDF input with Facade::BindPdf().
Delete the selected annotations with PdfAnnotationEditor::DeleteAnnotations().
Save the resulting PDF with PdfAnnotationEditor::Save().

#include <Aspose.PDF.Cpp/Facades/PdfAnnotationEditor.h>
#include <system/string.h>

namespace Facades::Examples::PDF_AnnotationEditor
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;

void DeleteAllAnnotations(String inputFile, String outputFile)
{
    auto editor = MakeObject<PdfAnnotationEditor>();
    editor->BindPdf(inputFile);
    editor->DeleteAnnotations();
    editor->Save(outputFile);
}
} // namespace Facades::Examples::PDF_AnnotationEditor

Delete annotation by name

Delete the annotation named sample-note-1.

Create PdfAnnotationEditor.
Bind the PDF input with Facade::BindPdf().
Delete the named annotation with PdfAnnotationEditor::DeleteAnnotation().
Save the resulting PDF with PdfAnnotationEditor::Save().

#include <Aspose.PDF.Cpp/Facades/PdfAnnotationEditor.h>
#include <system/string.h>

namespace Facades::Examples::PDF_AnnotationEditor
{
using namespace System;
using namespace Aspose::Pdf;
using Aspose::Pdf::Facades::PdfAnnotationEditor;

void DeleteAnnotationByName(String inputFile, String outputFile)
{
    auto editor = MakeObject<PdfAnnotationEditor>();
    editor->BindPdf(inputFile);
    editor->DeleteAnnotation(u"sample-note-1");
    editor->Save(outputFile);
}
} // namespace Facades::Examples::PDF_AnnotationEditor

Extract annotations

Extract Text and FreeText annotation contents across all pages and write them to a text file.

Create PdfAnnotationEditor.
Bind the PDF input with Facade::BindPdf().
Extract the selected annotation types and page range with PdfAnnotationEditor::ExtractAnnotations().
Write the collected values to the output text file.

#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Facades/PdfAnnotationEditor.h>
#include <Aspose.PDF.Cpp/InteractiveFeatures/Annotations/Annotation.h>
#include <Aspose.PDF.Cpp/InteractiveFeatures/Annotations/AnnotationType.h>
#include <Aspose.PDF.Cpp/Page.h>
#include <Aspose.PDF.Cpp/PageCollection.h>
#include <system/array.h>
#include <system/io/file.h>
#include <system/io/file_stream.h>
#include <system/string.h>

namespace Facades::Examples::PDF_AnnotationEditor
{
using namespace System;
using namespace Aspose::Pdf;
using Aspose::Pdf::Facades::PdfAnnotationEditor;

void ExtractAnnotations(String inputFile, String outputFile)
{
    auto types = MakeArray<Annotations::AnnotationType>(
        {Annotations::AnnotationType::FreeText, Annotations::AnnotationType::Text});

    auto editor = MakeObject<PdfAnnotationEditor>();
    editor->BindPdf(inputFile);
    String contents;
    for (auto annotation : editor->ExtractAnnotations(1, editor->get_Document()->get_Pages()->get_Count(), types))
        contents += annotation->get_Contents() + u"\n";
    System::IO::File::WriteAllText(outputFile, contents);
}
} // namespace Facades::Examples::PDF_AnnotationEditor

Flatten annotations

Flatten annotations with redaction application enabled, events disabled, buttons hidden, and appearances updated.

Configure Form::FlattenSettings for redaction, events, buttons, and appearance handling.
Create PdfAnnotationEditor.
Bind the PDF input with Facade::BindPdf().
Apply the flattening settings with PdfAnnotationEditor::FlatteningAnnotations().
Save the resulting PDF with PdfAnnotationEditor::Save().

#include <Aspose.PDF.Cpp/Facades/PdfAnnotationEditor.h>
#include <Aspose.PDF.Cpp/InteractiveFeatures/Forms/Form.h>
#include <system/string.h>

namespace Facades::Examples::PDF_AnnotationEditor
{
using namespace System;
using namespace Aspose::Pdf;
using Aspose::Pdf::Facades::PdfAnnotationEditor;

void FlattenAnnotations(String inputFile, String outputFile)
{
    auto editor = MakeObject<PdfAnnotationEditor>();
    editor->BindPdf(inputFile);

    auto settings = MakeObject<Forms::Form::FlattenSettings>();
    settings->set_ApplyRedactions(true);
    settings->set_CallEvents(false);
    settings->set_HideButtons(true);
    settings->set_UpdateAppearances(true);
    editor->FlatteningAnnotations(settings);

    editor->Save(outputFile);
}
} // namespace Facades::Examples::PDF_AnnotationEditor

Import annotations

Create a blank destination with the same page count as the source and import its annotations.

Create PdfAnnotationEditor.
Create or open the Document and prepare its pages as shown.
Bind the PDF input with Facade::BindPdf().
Import annotations into the target PDF with PdfAnnotationEditor::ImportAnnotations().
Save the resulting PDF with PdfAnnotationEditor::Save().

#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Facades/PdfAnnotationEditor.h>
#include <Aspose.PDF.Cpp/Page.h>
#include <Aspose.PDF.Cpp/PageCollection.h>
#include <system/array.h>
#include <system/string.h>

namespace Facades::Examples::PDF_AnnotationEditor
{
using namespace System;
using namespace Aspose::Pdf;
using Aspose::Pdf::Facades::PdfAnnotationEditor;

void ImportAnnotations(String inputFile, String outputFile)
{
    auto source = MakeObject<Document>(inputFile);
    auto target = MakeObject<Document>();
    for (int i = 0; i < source->get_Pages()->get_Count(); ++i)
        target->get_Pages()->Add();
    auto editor = MakeObject<PdfAnnotationEditor>();
    editor->BindPdf(target);
    editor->ImportAnnotations(MakeArray<String>({inputFile}));
    editor->Save(outputFile);
}
} // namespace Facades::Examples::PDF_AnnotationEditor

Import export all annotations XFDF

Export annotations to outputFile.xfdf, then import that file into a blank document with matching page count.

Create PdfAnnotationEditor.
Create or open the Document and prepare its pages as shown.
Bind the PDF input with Facade::BindPdf().
Export all annotations with PdfAnnotationEditor::ExportAnnotationsToXfdf().
Import the XFDF annotations with PdfAnnotationEditor::ImportAnnotationsFromXfdf().
Save the resulting PDF with PdfAnnotationEditor::Save().

#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Facades/PdfAnnotationEditor.h>
#include <Aspose.PDF.Cpp/Page.h>
#include <Aspose.PDF.Cpp/PageCollection.h>
#include <system/io/file.h>
#include <system/io/file_stream.h>
#include <system/string.h>

namespace Facades::Examples::PDF_AnnotationEditor
{
using namespace System;
using namespace Aspose::Pdf;
using Aspose::Pdf::Facades::PdfAnnotationEditor;

void ImportExportAllAnnotationsXfdf(String inputFile, String outputFile)
{
    String xfdfFile = outputFile + u".xfdf";
    auto editor = MakeObject<PdfAnnotationEditor>();
    editor->BindPdf(inputFile);
    int count = editor->get_Document()->get_Pages()->get_Count();
    auto stream = System::IO::File::Create(xfdfFile);
    editor->ExportAnnotationsToXfdf(stream);
    stream->Close();
    auto target = MakeObject<Document>();
    for (int page = 0; page < count; ++page)
    {
        target->get_Pages()->Add();
    }
    auto importer = MakeObject<PdfAnnotationEditor>();
    importer->BindPdf(target);
    importer->ImportAnnotationsFromXfdf(xfdfFile);
    importer->Save(outputFile);
}
} // namespace Facades::Examples::PDF_AnnotationEditor

Import export selected annotations XFDF

Export only Text and FreeText annotations across the source page range, then import the XFDF into blank target pages.

Create PdfAnnotationEditor.
Create or open the Document and prepare its pages as shown.
Bind the PDF input with Facade::BindPdf().
Export the selected annotation types with PdfAnnotationEditor::ExportAnnotationsXfdf().
Import the XFDF annotations with PdfAnnotationEditor::ImportAnnotationsFromXfdf().
Save the resulting PDF with PdfAnnotationEditor::Save().

#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Facades/PdfAnnotationEditor.h>
#include <Aspose.PDF.Cpp/InteractiveFeatures/Annotations/AnnotationType.h>
#include <Aspose.PDF.Cpp/Page.h>
#include <Aspose.PDF.Cpp/PageCollection.h>
#include <system/array.h>
#include <system/io/file.h>
#include <system/io/file_stream.h>
#include <system/string.h>

namespace Facades::Examples::PDF_AnnotationEditor
{
using namespace System;
using namespace Aspose::Pdf;
using Aspose::Pdf::Facades::PdfAnnotationEditor;

void ImportExportSelectedAnnotationsXfdf(String inputFile, String outputFile)
{
    String xfdfFile = outputFile + u".xfdf";
    auto editor = MakeObject<PdfAnnotationEditor>();
    editor->BindPdf(inputFile);
    int count = editor->get_Document()->get_Pages()->get_Count();
    auto stream = System::IO::File::Create(xfdfFile);
    auto types = MakeArray<Annotations::AnnotationType>(
        {Annotations::AnnotationType::FreeText, Annotations::AnnotationType::Text});
    editor->ExportAnnotationsXfdf(stream, 1, count, types);
    stream->Close();
    auto target = MakeObject<Document>();
    for (int page = 0; page < count; ++page)
    {
        target->get_Pages()->Add();
    }
    auto importer = MakeObject<PdfAnnotationEditor>();
    importer->BindPdf(target);
    importer->ImportAnnotationsFromXfdf(xfdfFile);
    importer->Save(outputFile);
}
} // namespace Facades::Examples::PDF_AnnotationEditor

Modify annotations author

Replace the author Aspose User with Aspose.PDF user across the document page range.

Create PdfAnnotationEditor.
Bind the PDF input with Facade::BindPdf().
Replace matching annotation authors with PdfAnnotationEditor::ModifyAnnotationsAuthor().
Save the resulting PDF with PdfAnnotationEditor::Save().

#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Facades/PdfAnnotationEditor.h>
#include <Aspose.PDF.Cpp/Page.h>
#include <Aspose.PDF.Cpp/PageCollection.h>
#include <system/string.h>

namespace Facades::Examples::PDF_AnnotationEditor
{
using namespace System;
using namespace Aspose::Pdf;
using Aspose::Pdf::Facades::PdfAnnotationEditor;

void ModifyAnnotationsAuthor(String inputFile, String outputFile)
{
    auto editor = MakeObject<PdfAnnotationEditor>();
    editor->BindPdf(inputFile);

    editor->ModifyAnnotationsAuthor(1, editor->get_Document()->get_Pages()->get_Count(), u"Aspose User",
                                    u"Aspose.PDF user");

    editor->Save(outputFile);
}
} // namespace Facades::Examples::PDF_AnnotationEditor

Modify annotations

Use a TextAnnotation template to update annotation title, subject, and contents on page 1.

Create PdfAnnotationEditor.
Bind the PDF input with Facade::BindPdf().
Apply the annotation template with PdfAnnotationEditor::ModifyAnnotations().
Save the resulting PDF with PdfAnnotationEditor::Save().

#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Facades/PdfAnnotationEditor.h>
#include <Aspose.PDF.Cpp/InteractiveFeatures/Annotations/TextAnnotation.h>
#include <Aspose.PDF.Cpp/Page.h>
#include <Aspose.PDF.Cpp/PageCollection.h>
#include <Aspose.PDF.Cpp/Rectangle.h>
#include <system/string.h>

namespace Facades::Examples::PDF_AnnotationEditor
{
using namespace System;
using namespace Aspose::Pdf;
using Aspose::Pdf::Facades::PdfAnnotationEditor;

void ModifyAnnotations(String inputFile, String outputFile)
{
    auto editor = MakeObject<PdfAnnotationEditor>();
    editor->BindPdf(inputFile);

    auto annotation = MakeObject<Annotations::TextAnnotation>(editor->get_Document()->get_Pages()->idx_get(1),
                                                              MakeObject<Rectangle>(200, 400, 400, 600));
    annotation->set_Title(u"Updated title");
    annotation->set_Subject(u"Updated subject");
    annotation->set_Contents(u"Updated sample contents for the annotation");
    editor->ModifyAnnotations(1, 1, annotation);

    editor->Save(outputFile);
}
} // namespace Facades::Examples::PDF_AnnotationEditor

Cpp: Manage PDF bookmarks in C++

Fri, 13 Nov 2026 00:00:00 +0000

Use PdfBookmarkEditor to create bookmark hierarchies and page bookmarks, inspect and update titles, delete bookmarks, and exchange bookmark XML.

Use input PDFs with the page numbers and bookmark titles referenced by each example. The page-list example demonstrates a single title/page pair even though its function name refers to a range.

PdfBookmarkEditor workflows

Add bookmark in an existing PDF file

Create New Bookmark targeting page 1.

Create PdfBookmarkEditor.
Bind the PDF input with Facade::BindPdf().
Create bookmarks with PdfBookmarkEditor::CreateBookmarks().
Save the resulting PDF with PdfBookmarkEditor::Save().

#include <Aspose.PDF.Cpp/Facades/Bookmark.h>
#include <Aspose.PDF.Cpp/Facades/PdfBookmarkEditor.h>
#include <system/string.h>

namespace Facades::Examples::PDF_BookmarkEditor
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;

void AddBookmarkInAnExistingPdfFile(String inputFile, String outputFile)
{
    auto bookmark = MakeObject<Bookmark>();
    bookmark->set_PageNumber(1);
    bookmark->set_Title(u"New Bookmark");

    auto bookmarkEditor = MakeObject<PdfBookmarkEditor>();

    bookmarkEditor->BindPdf(inputFile);

    bookmarkEditor->CreateBookmarks(bookmark);

    bookmarkEditor->Save(outputFile);
}
} // namespace Facades::Examples::PDF_BookmarkEditor

Add child bookmark in an existing PDF file

Create a Parent bookmark with First Child and Second Child targeting pages 1 and 2.

Create PdfBookmarkEditor.
Bind the PDF input with Facade::BindPdf().
Create bookmarks with PdfBookmarkEditor::CreateBookmarks().
Save the resulting PDF with PdfBookmarkEditor::Save().

#include <Aspose.PDF.Cpp/Facades/Bookmark.h>
#include <Aspose.PDF.Cpp/Facades/Bookmarks.h>
#include <Aspose.PDF.Cpp/Facades/PdfBookmarkEditor.h>
#include <system/string.h>

namespace Facades::Examples::PDF_BookmarkEditor
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;

void AddChildBookmarkInAnExistingPdfFile(String inputFile, String outputFile)
{
    auto bookmarks = MakeObject<Bookmarks>();
    auto childBookmark1 = MakeObject<Bookmark>();
    childBookmark1->set_PageNumber(1);
    childBookmark1->set_Title(u"First Child");
    auto childBookmark2 = MakeObject<Bookmark>();
    childBookmark2->set_PageNumber(2);
    childBookmark2->set_Title(u"Second Child");
    bookmarks->Add(childBookmark1);
    bookmarks->Add(childBookmark2);
    auto bookmark = MakeObject<Bookmark>();
    bookmark->set_Action(u"GoTo");
    bookmark->set_PageNumber(1);
    bookmark->set_Title(u"Parent");
    bookmark->set_ChildItems(bookmarks);

    auto bookmarkEditor = MakeObject<PdfBookmarkEditor>();

    bookmarkEditor->BindPdf(inputFile);

    bookmarkEditor->CreateBookmarks(bookmark);

    bookmarkEditor->Save(outputFile);
}
} // namespace Facades::Examples::PDF_BookmarkEditor

Create bookmark of a particular page

Create Bookmark Name targeting page 2.

Create PdfBookmarkEditor.
Bind the PDF input with Facade::BindPdf().
Create page bookmarks with PdfBookmarkEditor::CreateBookmarkOfPage().
Save the resulting PDF with PdfBookmarkEditor::Save().

#include <Aspose.PDF.Cpp/Facades/PdfBookmarkEditor.h>
#include <system/string.h>

namespace Facades::Examples::PDF_BookmarkEditor
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;

void CreateBookmarkOfAParticularPage(String inputFile, String outputFile)
{
    auto bookmarkEditor = MakeObject<PdfBookmarkEditor>();

    bookmarkEditor->BindPdf(inputFile);

    bookmarkEditor->CreateBookmarkOfPage(u"Bookmark Name", 2);

    bookmarkEditor->Save(outputFile);
}
} // namespace Facades::Examples::PDF_BookmarkEditor

Create bookmarks of a range of pages

Pass an array containing the title First and an array containing page 1 to CreateBookmarkOfPage().

Create PdfBookmarkEditor.
Bind the PDF input with Facade::BindPdf().
Create page bookmarks with PdfBookmarkEditor::CreateBookmarkOfPage().
Save the resulting PDF with PdfBookmarkEditor::Save().

#include <Aspose.PDF.Cpp/Facades/PdfBookmarkEditor.h>
#include <system/array.h>
#include <system/string.h>

namespace Facades::Examples::PDF_BookmarkEditor
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;

void CreateBookmarksOfARangeOfPages(String inputFile, String outputFile)
{
    auto bookmarkEditor = MakeObject<PdfBookmarkEditor>();

    bookmarkEditor->BindPdf(inputFile);

    auto bookmarkList = MakeArray<String>({u"First"});

    auto pageList = MakeArray<int32_t>({1});

    bookmarkEditor->CreateBookmarkOfPage(bookmarkList, pageList);

    bookmarkEditor->Save(outputFile);
}
} // namespace Facades::Examples::PDF_BookmarkEditor

Create bookmarks of all pages with properties

Create page bookmarks with green text and both style flags enabled.

Create PdfBookmarkEditor.
Bind the PDF input with Facade::BindPdf().
Create bookmarks with PdfBookmarkEditor::CreateBookmarks().
Save the resulting PDF with PdfBookmarkEditor::Save().

#include <Aspose.PDF.Cpp/Color.h>
#include <Aspose.PDF.Cpp/Facades/PdfBookmarkEditor.h>
#include <drawing/color.h>
#include <system/string.h>

namespace Facades::Examples::PDF_BookmarkEditor
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;
using DrawingColor = System::Drawing::Color;

void CreateBookmarksOfAllPagesWithProperties(String inputFile, String outputFile)
{
    auto bookmarkEditor = MakeObject<PdfBookmarkEditor>();

    bookmarkEditor->BindPdf(inputFile);

    bookmarkEditor->CreateBookmarks(DrawingColor::get_Green(), true, true);

    bookmarkEditor->Save(outputFile);
}
} // namespace Facades::Examples::PDF_BookmarkEditor

Create bookmarks of all pages

Create bookmarks for all document pages.

Create PdfBookmarkEditor.
Bind the PDF input with Facade::BindPdf().
Create bookmarks with PdfBookmarkEditor::CreateBookmarks().
Save the resulting PDF with PdfBookmarkEditor::Save().

#include <Aspose.PDF.Cpp/Facades/PdfBookmarkEditor.h>
#include <system/string.h>

namespace Facades::Examples::PDF_BookmarkEditor
{
	using namespace System;
	using namespace Aspose::Pdf;
	using namespace Aspose::Pdf::Facades;

	void CreateBookmarksOfAllPages(String inputFile, String outputFile)
	{
		auto bookmarkEditor = MakeObject<PdfBookmarkEditor>();

		bookmarkEditor->BindPdf(inputFile);

		bookmarkEditor->CreateBookmarks();

		bookmarkEditor->Save(outputFile);
	}
} // namespace Facades::Examples::PDF_BookmarkEditor

Delete all bookmarks

Delete every bookmark in the document.

Create PdfBookmarkEditor.
Bind the PDF input with Facade::BindPdf().
Delete bookmarks with PdfBookmarkEditor::DeleteBookmarks().
Save the resulting PDF with PdfBookmarkEditor::Save().

#include <Aspose.PDF.Cpp/Facades/PdfBookmarkEditor.h>
#include <system/string.h>

namespace Facades::Examples::PDF_BookmarkEditor
{
	using namespace System;
	using namespace Aspose::Pdf;
	using namespace Aspose::Pdf::Facades;

	void DeleteAllBookmarks(String inputFile, String outputFile)
	{
		auto bookmarkEditor = MakeObject<PdfBookmarkEditor>();

		bookmarkEditor->BindPdf(inputFile);

		bookmarkEditor->DeleteBookmarks();

		bookmarkEditor->Save(outputFile);
	}
} // namespace Facades::Examples::PDF_BookmarkEditor

Delete particular bookmark

Delete bookmarks matching the title Page2.

Create PdfBookmarkEditor.
Bind the PDF input with Facade::BindPdf().
Delete bookmarks with PdfBookmarkEditor::DeleteBookmarks().
Save the resulting PDF with PdfBookmarkEditor::Save().

#include <Aspose.PDF.Cpp/Facades/PdfBookmarkEditor.h>
#include <system/string.h>

namespace Facades::Examples::PDF_BookmarkEditor
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;

void DeleteParticularBookmark(String inputFile, String outputFile)
{
    auto bookmarkEditor = MakeObject<PdfBookmarkEditor>();

    bookmarkEditor->BindPdf(inputFile);

    bookmarkEditor->DeleteBookmarks(u"Page2");

    bookmarkEditor->Save(outputFile);
}
} // namespace Facades::Examples::PDF_BookmarkEditor

Export bookmarks to XML

Export bookmarks to an XML output file.

Create PdfBookmarkEditor.
Bind the PDF input with Facade::BindPdf().
Export the bookmark XML with PdfBookmarkEditor::ExportBookmarksToXML().

#include <Aspose.PDF.Cpp/Facades/PdfBookmarkEditor.h>
#include <system/string.h>

namespace Facades::Examples::PDF_BookmarkEditor
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;

void ExportBookmarksToXML(String inputFile, String outputFile)
{
    auto bookmarkEditor = MakeObject<PdfBookmarkEditor>();

    bookmarkEditor->BindPdf(inputFile);

    bookmarkEditor->ExportBookmarksToXML(outputFile);
}
} // namespace Facades::Examples::PDF_BookmarkEditor

Get bookmarks from document

Extract bookmarks and write each title, page number, and action to a text report.

Create PdfBookmarkEditor.
Bind the PDF input with Facade::BindPdf().
Read bookmarks with PdfBookmarkEditor::ExtractBookmarks().
Write the collected values to the output text file.

#include <Aspose.PDF.Cpp/Facades/Bookmark.h>
#include <Aspose.PDF.Cpp/Facades/Bookmarks.h>
#include <Aspose.PDF.Cpp/Facades/PdfBookmarkEditor.h>
#include <string>
#include <system/io/file.h>
#include <system/io/file_stream.h>
#include <system/string.h>

namespace Facades::Examples::PDF_BookmarkEditor
{
	using namespace System;
	using namespace Aspose::Pdf;
	using namespace Aspose::Pdf::Facades;

	void GetBookmarksFromDocument(String inputFile, String outputFile)
	{
		auto editor = MakeObject<PdfBookmarkEditor>();
		editor->BindPdf(inputFile);
		String report;
		for (auto bookmark : editor->ExtractBookmarks())
		{
			report += u"Title: " + bookmark->get_Title() + u"\nPage Number: " +
				String::FromUtf8(std::to_string(bookmark->get_PageNumber())) + u"\nBookmark Action: " +
				bookmark->get_Action() + u"\n";
		}
		System::IO::File::WriteAllText(outputFile, report);
	}
} // namespace Facades::Examples::PDF_BookmarkEditor

Import bookmarks from XML

Import bookmark data from the supplied XML file and save the PDF.

Create PdfBookmarkEditor.
Bind the PDF input with Facade::BindPdf().
Import bookmark XML with PdfBookmarkEditor::ImportBookmarksWithXML().
Save the resulting PDF with PdfBookmarkEditor::Save().

#include <Aspose.PDF.Cpp/Facades/PdfBookmarkEditor.h>
#include <system/string.h>

namespace Facades::Examples::PDF_BookmarkEditor
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;

void ImportBookmarksFromXML(String inputFile, String outputFile)
{
    auto bookmarkEditor = MakeObject<PdfBookmarkEditor>();

    bookmarkEditor->BindPdf(inputFile);

    auto xmlFile = inputFile.Replace(u".pdf", u".xml");

    bookmarkEditor->ImportBookmarksWithXML(xmlFile);

    bookmarkEditor->Save(outputFile);
}
} // namespace Facades::Examples::PDF_BookmarkEditor

Update existing bookmark

Update an existing bookmark title using ModifyBookmarks().

Create PdfBookmarkEditor.
Bind the PDF input with Facade::BindPdf().
Change the bookmark title with PdfBookmarkEditor::ModifyBookmarks().
Save the resulting PDF with PdfBookmarkEditor::Save().

#include <Aspose.PDF.Cpp/Facades/PdfBookmarkEditor.h>
#include <system/string.h>

namespace Facades::Examples::PDF_BookmarkEditor
{
	using namespace System;
	using namespace Aspose::Pdf;
	using namespace Aspose::Pdf::Facades;

	void UpdateExistingBookmark(String inputFile, String outputFile)
	{
		auto bookmarkEditor = MakeObject<PdfBookmarkEditor>();

		bookmarkEditor->BindPdf(inputFile);

		bookmarkEditor->ModifyBookmarks(u"New Bookmark", u"New Title");

		bookmarkEditor->Save(outputFile);
	}
} // namespace Facades::Examples::PDF_BookmarkEditor

Cpp: Sign and inspect PDF signatures in C++

Fri, 13 Nov 2026 00:00:00 +0000

Use PdfFileSignature to sign or certify PDF documents, inspect and verify signatures, extract certificates, and remove a signature.

Signing examples require a certificate file using the sample password Aspose2021. Inspection, extraction, verification, and removal examples select the first existing signature, so a signed input PDF is required. Use the appropriate certificate and password for your documents.

PdfFileSignature tutorials

Cpp: Render PDFs and merge images in C++

Fri, 13 Nov 2026 00:00:00 +0000

Use PdfConverter to render PDF pages as JPEG images and combine input images into JPEG, TIFF, or PDF output.

Conversion functions write numbered JPEG files to outputFolder. Image-merging functions sort files matching MergeImages*.jpg in inputDirectory and fail if none exist. The TIFF variant uses Document and TiffDevice rather than MergeImagesAsTiff, matching the supplied compatibility workaround.

PdfConverter workflows

Render PDF pages as JPEG images

Render the PDF and write each page image to a numbered JPEG file.

Create PdfConverter.
Bind the PDF input with Facade::BindPdf().
Prepare page rendering with PdfConverter::DoConvert().
Check for another image with PdfConverter::HasNextImage().
Write each image with PdfConverter::GetNextImage().

#include <Aspose.PDF.Cpp/Facades/PdfConverter.h>
#include <Aspose.PDF.Cpp/Presentation/IndependentImpl/ImageFormat.h>
#include <drawing/imaging/image_format.h>
#include <system/io/directory.h>
#include <system/io/file.h>
#include <system/io/file_stream.h>
#include <system/string.h>

namespace Facades::Examples::PDF_Converter
{
	using namespace System;
	using namespace Aspose::Pdf;
	using Aspose::Pdf::Facades::PdfConverter;

	void ConvertPdfPagesToImages01(String inputFile, String outputFolder)
	{
		auto converter = MakeObject<PdfConverter>();
		converter->BindPdf(inputFile);

		converter->DoConvert();
		System::IO::Directory::CreateDirectory_(outputFolder);
		int imageNumber = 1;
		while (converter->HasNextImage())
		{
			String outputFile = outputFolder + u"/" + String::Format(u"{0}_out.jpg", imageNumber);
			converter->GetNextImage(outputFile, System::Drawing::Imaging::ImageFormat::get_Jpeg());
			++imageNumber;
		}
	}
} // namespace Facades::Examples::PDF_Converter

Render pages with resolution and CropBox settings

Render from page 2 at 600 DPI using CropBox coordinates and Production form presentation.

Create PdfConverter.
Bind the PDF input with Facade::BindPdf().
Set coordinate type through PdfConverter using the example values.
Set resolution through PdfConverter using the example values.
Set form presentation mode through PdfConverter using the example values.
Set start page through PdfConverter using the example values.
Prepare page rendering with PdfConverter::DoConvert().
Check for another image with PdfConverter::HasNextImage().
Write each image with PdfConverter::GetNextImage().

#include <Aspose.PDF.Cpp/Devices/FormPresentationMode.h>
#include <Aspose.PDF.Cpp/Devices/Resolution.h>
#include <Aspose.PDF.Cpp/Facades/PdfConverter.h>
#include <Aspose.PDF.Cpp/PageCoordinateType.h>
#include <Aspose.PDF.Cpp/Presentation/IndependentImpl/ImageFormat.h>
#include <drawing/imaging/image_format.h>
#include <system/io/directory.h>
#include <system/io/file.h>
#include <system/io/file_stream.h>
#include <system/string.h>

namespace Facades::Examples::PDF_Converter
{
using namespace System;
using namespace Aspose::Pdf;
using Aspose::Pdf::Facades::PdfConverter;

void ConvertPdfPagesToImages02(String inputFile, String outputFolder)
{
    auto converter = MakeObject<PdfConverter>();
    converter->BindPdf(inputFile);
    converter->set_CoordinateType(PageCoordinateType::CropBox);
    converter->set_Resolution(MakeObject<Devices::Resolution>(600));
    converter->set_FormPresentationMode(Devices::FormPresentationMode::Production);
    converter->set_StartPage(2);
    converter->DoConvert();
    System::IO::Directory::CreateDirectory_(outputFolder);
    int imageNumber = 1;
    while (converter->HasNextImage())
    {
        String outputFile = outputFolder + u"/" + String::Format(u"{0}_out.jpg", imageNumber);
        converter->GetNextImage(outputFile, System::Drawing::Imaging::ImageFormat::get_Jpeg());
        ++imageNumber;
    }
}
} // namespace Facades::Examples::PDF_Converter

Convert with font substitution

Temporarily substitute Helvetica with Arial during rendering. Remove the substitution after conversion and in the exception path.

Create PdfConverter.
Bind the PDF input with Facade::BindPdf().
Prepare page rendering with PdfConverter::DoConvert().
Check for another image with PdfConverter::HasNextImage().
Write each image with PdfConverter::GetNextImage().

#include <Aspose.PDF.Cpp/CommonData/Text/Fonts/FontSubstitutions/FontSubstitutionCollection.h>
#include <Aspose.PDF.Cpp/CommonData/Text/Fonts/FontSubstitutions/SimpleFontSubstitution.h>
#include <Aspose.PDF.Cpp/Facades/PdfConverter.h>
#include <Aspose.PDF.Cpp/Presentation/IndependentImpl/ImageFormat.h>
#include <Aspose.PDF.Cpp/Text/FontRepository.h>
#include <drawing/imaging/image_format.h>
#include <system/io/directory.h>
#include <system/io/file.h>
#include <system/io/file_stream.h>
#include <system/string.h>

namespace Facades::Examples::PDF_Converter
{
using namespace System;
using namespace Aspose::Pdf;
using Aspose::Pdf::Facades::PdfConverter;

void ConvertWithFontSubstitution(String inputFile, String outputFolder)
{
    auto substitutions = Aspose::Pdf::Text::FontRepository::get_Substitutions();
    auto substitution = MakeObject<Aspose::Pdf::Text::SimpleFontSubstitution>(u"Helvetica", u"Arial");
    substitutions->Add(substitution);
    try
    {
        auto converter = MakeObject<PdfConverter>();
        converter->BindPdf(inputFile);

        converter->DoConvert();
        System::IO::Directory::CreateDirectory_(outputFolder);
        int imageNumber = 1;
        while (converter->HasNextImage())
        {
            String outputFile = outputFolder + u"/" + String::Format(u"{0}_out.jpg", imageNumber);
            converter->GetNextImage(outputFile, System::Drawing::Imaging::ImageFormat::get_Jpeg());
            ++imageNumber;
        }
    }
    catch (...)
    {
        substitutions->Remove(substitution);
        throw;
    }
    substitutions->Remove(substitution);
}
} // namespace Facades::Examples::PDF_Converter

Merge images vertically

Sort matching JPEG inputs and combine them vertically into a JPEG output.

Combine the prepared image streams with PdfConverter::MergeImages().

#include <Aspose.PDF.Cpp/Facades/ImageMergeMode.h>
#include <Aspose.PDF.Cpp/Facades/PdfConverter.h>
#include <Aspose.PDF.Cpp/Presentation/IndependentImpl/ImageFormat.h>
#include <algorithm>
#include <stdexcept>
#include <system/collections/list.h>
#include <system/io/directory.h>
#include <system/io/file.h>
#include <system/io/file_stream.h>
#include <system/io/memory_stream.h>
#include <system/string.h>

namespace Facades::Examples::PDF_Converter
{
using namespace System;
using namespace Aspose::Pdf;
using Aspose::Pdf::Facades::PdfConverter;

void MergeImages01(String inputDirectory, String outputFile)
{
    auto imageFiles = System::IO::Directory::GetFiles(inputDirectory, u"MergeImages*.jpg");
    std::sort(imageFiles->begin(), imageFiles->end());
    if (imageFiles->get_Length() == 0)
    {
        throw std::runtime_error("No images matching MergeImages*.jpg");
    }
    auto streams = MakeObject<System::Collections::Generic::List<SharedPtr<System::IO::Stream>>>();
    for (const auto &imageFile : imageFiles)
    {
        auto bytes = System::IO::File::ReadAllBytes(imageFile);
        streams->Add(MakeObject<System::IO::MemoryStream>(bytes));
    }
    auto mergedImage = PdfConverter::MergeImages(streams, Aspose::Pdf::Drawing::ImageFormat::Jpeg,
                                                 Aspose::Pdf::Facades::ImageMergeMode::Vertical, 1, 1);
    auto output = System::IO::File::Create(outputFile);
    mergedImage->CopyTo(output);
    output->Close();
}
} // namespace Facades::Examples::PDF_Converter

Merge images horizontally

Sort matching JPEG inputs and combine them horizontally into a JPEG output.

Combine the prepared image streams with PdfConverter::MergeImages().

#include <Aspose.PDF.Cpp/Facades/ImageMergeMode.h>
#include <Aspose.PDF.Cpp/Facades/PdfConverter.h>
#include <Aspose.PDF.Cpp/Presentation/IndependentImpl/ImageFormat.h>
#include <algorithm>
#include <stdexcept>
#include <system/collections/list.h>
#include <system/io/directory.h>
#include <system/io/file.h>
#include <system/io/file_stream.h>
#include <system/io/memory_stream.h>
#include <system/string.h>

namespace Facades::Examples::PDF_Converter
{
using namespace System;
using namespace Aspose::Pdf;
using Aspose::Pdf::Facades::PdfConverter;

void MergeImages02(String inputDirectory, String outputFile)
{
    auto imageFiles = System::IO::Directory::GetFiles(inputDirectory, u"MergeImages*.jpg");
    std::sort(imageFiles->begin(), imageFiles->end());
    if (imageFiles->get_Length() == 0)
    {
        throw std::runtime_error("No images matching MergeImages*.jpg");
    }
    auto streams = MakeObject<System::Collections::Generic::List<SharedPtr<System::IO::Stream>>>();
    for (const auto &imageFile : imageFiles)
    {
        auto bytes = System::IO::File::ReadAllBytes(imageFile);
        streams->Add(MakeObject<System::IO::MemoryStream>(bytes));
    }
    auto mergedImage = PdfConverter::MergeImages(streams, Aspose::Pdf::Drawing::ImageFormat::Jpeg,
                                                 Aspose::Pdf::Facades::ImageMergeMode::Horizontal, 1, 1);
    auto output = System::IO::File::Create(outputFile);
    mergedImage->CopyTo(output);
    output->Close();
}
} // namespace Facades::Examples::PDF_Converter

Merge images with Center mode

Combine matching JPEG inputs using Center mode and the supplied 2 by 2 spacing arguments.

Combine the prepared image streams with PdfConverter::MergeImages().

#include <Aspose.PDF.Cpp/Facades/ImageMergeMode.h>
#include <Aspose.PDF.Cpp/Facades/PdfConverter.h>
#include <Aspose.PDF.Cpp/Presentation/IndependentImpl/ImageFormat.h>
#include <algorithm>
#include <stdexcept>
#include <system/collections/list.h>
#include <system/io/directory.h>
#include <system/io/file.h>
#include <system/io/file_stream.h>
#include <system/io/memory_stream.h>
#include <system/string.h>

namespace Facades::Examples::PDF_Converter
{
using namespace System;
using namespace Aspose::Pdf;
using Aspose::Pdf::Facades::PdfConverter;

void MergeImages03(String inputDirectory, String outputFile)
{
    auto imageFiles = System::IO::Directory::GetFiles(inputDirectory, u"MergeImages*.jpg");
    std::sort(imageFiles->begin(), imageFiles->end());
    if (imageFiles->get_Length() == 0)
    {
        throw std::runtime_error("No images matching MergeImages*.jpg");
    }
    auto streams = MakeObject<System::Collections::Generic::List<SharedPtr<System::IO::Stream>>>();
    for (const auto &imageFile : imageFiles)
    {
        auto bytes = System::IO::File::ReadAllBytes(imageFile);
        streams->Add(MakeObject<System::IO::MemoryStream>(bytes));
    }
    auto mergedImage = PdfConverter::MergeImages(streams, Aspose::Pdf::Drawing::ImageFormat::Jpeg,
                                                 Aspose::Pdf::Facades::ImageMergeMode::Center, 2, 2);
    auto output = System::IO::File::Create(outputFile);
    mergedImage->CopyTo(output);
    output->Close();
}
} // namespace Facades::Examples::PDF_Converter

Create a multipage TIFF from images

Create one PDF page for each input image and render the temporary document to a 24-bit multipage TIFF at 72 DPI.

Collect and sort the matching input images.
Create a Document and add one page containing each input image.
Configure TiffSettings for 24-bit output and a resolution of 72 DPI.
Write the multipage TIFF with TiffDevice::Process() and close the output stream.

#include <Aspose.PDF.Cpp/Devices/ColorDepth.h>
#include <Aspose.PDF.Cpp/Devices/Resolution.h>
#include <Aspose.PDF.Cpp/Devices/TiffDevice.h>
#include <Aspose.PDF.Cpp/Devices/TiffSettings.h>
#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Facades/PdfConverter.h>
#include <Aspose.PDF.Cpp/Page.h>
#include <Aspose.PDF.Cpp/PageCollection.h>
#include <Aspose.PDF.Cpp/Rectangle.h>
#include <algorithm>
#include <drawing/bitmap.h>
#include <stdexcept>
#include <system/collections/list.h>
#include <system/io/directory.h>
#include <system/io/file.h>
#include <system/io/file_stream.h>
#include <system/io/memory_stream.h>
#include <system/string.h>

namespace Facades::Examples::PDF_Converter
{
using namespace System;
using namespace Aspose::Pdf;
using Aspose::Pdf::Facades::PdfConverter;

void MergeImages04(String inputDirectory, String outputFile)
{
    auto imageFiles = System::IO::Directory::GetFiles(inputDirectory, u"MergeImages*.jpg");
    std::sort(imageFiles->begin(), imageFiles->end());
    if (imageFiles->get_Length() == 0)
    {
        throw std::runtime_error("No images matching MergeImages*.jpg");
    }
    auto streams = MakeObject<System::Collections::Generic::List<SharedPtr<System::IO::Stream>>>();
    for (const auto &imageFile : imageFiles)
    {
        auto bytes = System::IO::File::ReadAllBytes(imageFile);
        streams->Add(MakeObject<System::IO::MemoryStream>(bytes));
    }
    // C++ 26.9 cannot use MergeImagesAsTiff because its drawing runtime
    // lacks frame enumeration. Render one image per TIFF frame instead.
    auto document = MakeObject<Document>();
    for (auto stream : streams)
    {
        auto bitmap = MakeObject<System::Drawing::Bitmap>(stream);
        int width = bitmap->get_Width();
        int height = bitmap->get_Height();
        stream->set_Position(0);
        auto page = document->get_Pages()->Add();
        page->SetPageSize(width, height);
        page->AddImage(stream, MakeObject<Rectangle>(0, 0, width, height));
    }
    auto settings = MakeObject<Devices::TiffSettings>();
    settings->set_Depth(Devices::ColorDepth::Format24bpp);
    auto device = MakeObject<Devices::TiffDevice>(MakeObject<Devices::Resolution>(72), settings);
    auto output = System::IO::File::Create(outputFile);
    device->Process(document, 1, document->get_Pages()->get_Count(), output);
    output->Close();
}
} // namespace Facades::Examples::PDF_Converter

Place merged images in a PDF

Merge input images vertically, place the merged image on a new PDF page, and save the PDF.

Create or open the Document and prepare its pages as shown.
Combine the prepared image streams with PdfConverter::MergeImages().

#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Facades/ImageMergeMode.h>
#include <Aspose.PDF.Cpp/Facades/PdfConverter.h>
#include <Aspose.PDF.Cpp/Page.h>
#include <Aspose.PDF.Cpp/PageCollection.h>
#include <Aspose.PDF.Cpp/Presentation/IndependentImpl/ImageFormat.h>
#include <Aspose.PDF.Cpp/Rectangle.h>
#include <algorithm>
#include <stdexcept>
#include <system/collections/list.h>
#include <system/io/directory.h>
#include <system/io/file.h>
#include <system/io/file_stream.h>
#include <system/io/memory_stream.h>
#include <system/string.h>

namespace Facades::Examples::PDF_Converter
{
using namespace System;
using namespace Aspose::Pdf;
using Aspose::Pdf::Facades::PdfConverter;

void MergeImages05(String inputDirectory, String outputFile)
{
    auto imageFiles = System::IO::Directory::GetFiles(inputDirectory, u"MergeImages*.jpg");
    std::sort(imageFiles->begin(), imageFiles->end());
    if (imageFiles->get_Length() == 0)
    {
        throw std::runtime_error("No images matching MergeImages*.jpg");
    }
    auto streams = MakeObject<System::Collections::Generic::List<SharedPtr<System::IO::Stream>>>();
    for (const auto &imageFile : imageFiles)
    {
        auto bytes = System::IO::File::ReadAllBytes(imageFile);
        streams->Add(MakeObject<System::IO::MemoryStream>(bytes));
    }
    auto mergedImage = PdfConverter::MergeImages(streams, Aspose::Pdf::Drawing::ImageFormat::Jpeg,
                                                 Aspose::Pdf::Facades::ImageMergeMode::Vertical, 1, 1);
    auto document = MakeObject<Document>();
    auto page = document->get_Pages()->Add();
    page->AddImage(mergedImage, MakeObject<Rectangle>(10, 120, 400, 720));
    document->Save(outputFile);
}
} // namespace Facades::Examples::PDF_Converter

Cpp: Extract PDF text, images, and attachments in C++

Fri, 13 Nov 2026 00:00:00 +0000

Use PdfExtractor to inspect content availability and extract page text, images, and file attachments using facade APIs.

Create a writable outputDir before running examples that write into it. Page-specific samples require pages 2 or 2 through 3. Extraction retrieves existing content; text extraction does not perform OCR.

PdfExtractor workflows

Check if PDF contains text or images

Start text and image extraction and print whether the PDF contains either type of content.

Create PdfExtractor.
Bind the PDF input with Facade::BindPdf().
Prepare text extraction with PdfExtractor::ExtractText().
Check for another page of text with PdfExtractor::HasNextPageText().
Prepare image extraction with PdfExtractor::ExtractImage().
Check for another image with PdfExtractor::HasNextImage().
Print the results or diagnostic messages shown in the example.

#include <Aspose.PDF.Cpp/Facades/PdfExtractor.h>
#include <iostream>
#include <system/string.h>

namespace  Facades::Examples::PDF_Extractor
{
	using namespace System;
	using namespace Aspose::Pdf;
	using namespace Aspose::Pdf::Facades;

	void CheckIfPdfContainsTextOrImages(String inputFile)
	{
		auto pdfExtractor = MakeObject<PdfExtractor>();

		pdfExtractor->BindPdf(inputFile);

		pdfExtractor->ExtractText();
		auto containsText = pdfExtractor->HasNextPageText();

		pdfExtractor->ExtractImage();

		auto containsImage = pdfExtractor->HasNextImage();

		String content = containsText ? (containsImage ? u"both text and image" : u"text only")
			: (containsImage ? u"image only" : u"neither text nor image");
		std::cout << "PDF contains " << content << std::endl;
	}
} // namespace  Facades::Examples::PDF_Extractor

Extract attachments

Extract attachments and write them to outputDir when attachment names are present.

Create PdfExtractor.
Bind the PDF input with Facade::BindPdf().
Prepare attachment extraction with PdfExtractor::ExtractAttachment().
Read attachment names with PdfExtractor::GetAttachNames().
Write attachments with PdfExtractor::GetAttachment().

#include <Aspose.PDF.Cpp/Facades/PdfExtractor.h>
#include <system/string.h>

namespace  Facades::Examples::PDF_Extractor
{
	using namespace System;
	using namespace Aspose::Pdf;
	using namespace Aspose::Pdf::Facades;

	void ExtractAttachments(String inputFile, String outputDir)
	{
		auto pdfExtractor = MakeObject<PdfExtractor>();

		pdfExtractor->BindPdf(inputFile);

		pdfExtractor->ExtractAttachment();

		if (pdfExtractor->GetAttachNames()->get_Count() > 0)
		{
			pdfExtractor->GetAttachment(outputDir);
		}
	}
} // namespace  Facades::Examples::PDF_Extractor

Extract images image extraction mode

Select DefinedInResources mode and write extracted images as numbered PNG files.

Create PdfExtractor.
Bind the PDF input with Facade::BindPdf().
Set extract image mode through PdfExtractor using the example values.
Prepare image extraction with PdfExtractor::ExtractImage().
Check for another image with PdfExtractor::HasNextImage().
Write each image with PdfExtractor::GetNextImage().

#include <Aspose.PDF.Cpp/ExtractImageMode.h>
#include <Aspose.PDF.Cpp/Facades/PdfExtractor.h>
#include <Aspose.PDF.Cpp/Presentation/IndependentImpl/ImageFormat.h>
#include <drawing/imaging/image_format.h>
#include <system/io/file.h>
#include <system/io/file_stream.h>
#include <system/string.h>

namespace  Facades::Examples::PDF_Extractor
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;

void ExtractImagesImageExtractionMode(String inputFile, String outputDir)
{
    auto pdfExtractor = MakeObject<PdfExtractor>();

    pdfExtractor->BindPdf(inputFile);

    pdfExtractor->set_ExtractImageMode(ExtractImageMode::DefinedInResources);
    pdfExtractor->ExtractImage();

    int index = 0;

    while (pdfExtractor->HasNextImage())
    {
        index++;

        auto outputFile = (outputDir + u"/" + String::Format(u"{0}", index) + u"_out.png");
        auto outputImage = System::IO::File::Create(outputFile);

        pdfExtractor->GetNextImage(outputImage, System::Drawing::Imaging::ImageFormat::get_Png());
    }
}
} // namespace  Facades::Examples::PDF_Extractor

Extract images particular page

Extract images from page 2 and write numbered JPEG files.

Create PdfExtractor.
Bind the PDF input with Facade::BindPdf().
Set start page through PdfExtractor using the example values.
Set end page through PdfExtractor using the example values.
Prepare image extraction with PdfExtractor::ExtractImage().
Check for another image with PdfExtractor::HasNextImage().
Write each image with PdfExtractor::GetNextImage().

#include <Aspose.PDF.Cpp/Facades/PdfExtractor.h>
#include <Aspose.PDF.Cpp/Presentation/IndependentImpl/ImageFormat.h>
#include <drawing/imaging/image_format.h>
#include <system/io/file.h>
#include <system/io/file_stream.h>
#include <system/string.h>

namespace  Facades::Examples::PDF_Extractor
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;

void ExtractImagesParticularPage(String inputFile, String outputDir)
{
    auto pdfExtractor = MakeObject<PdfExtractor>();

    pdfExtractor->BindPdf(inputFile);

    pdfExtractor->set_StartPage(2);
    pdfExtractor->set_EndPage(2);

    pdfExtractor->ExtractImage();
    int index = 0;

    while (pdfExtractor->HasNextImage())
    {
        index++;

        auto outputFile = (outputDir + u"/" + String::Format(u"{0}", index) + u"_out.jpg");
        auto outputImage = System::IO::File::Create(outputFile);

        pdfExtractor->GetNextImage(outputImage, System::Drawing::Imaging::ImageFormat::get_Jpeg());
    }
}
} // namespace  Facades::Examples::PDF_Extractor

Extract images range pages

Extract images from pages 2 through 3 and write numbered JPEG files.

Create PdfExtractor.
Bind the PDF input with Facade::BindPdf().
Set start page through PdfExtractor using the example values.
Set end page through PdfExtractor using the example values.
Prepare image extraction with PdfExtractor::ExtractImage().
Check for another image with PdfExtractor::HasNextImage().
Write each image with PdfExtractor::GetNextImage().

#include <Aspose.PDF.Cpp/Facades/PdfExtractor.h>
#include <Aspose.PDF.Cpp/Presentation/IndependentImpl/ImageFormat.h>
#include <drawing/imaging/image_format.h>
#include <system/io/file.h>
#include <system/io/file_stream.h>
#include <system/string.h>

namespace  Facades::Examples::PDF_Extractor
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;

void ExtractImagesRangePages(String inputFile, String outputDir)
{
    auto pdfExtractor = MakeObject<PdfExtractor>();

    pdfExtractor->BindPdf(inputFile);

    pdfExtractor->set_StartPage(2);
    pdfExtractor->set_EndPage(3);

    pdfExtractor->ExtractImage();
    int index = 0;

    while (pdfExtractor->HasNextImage())
    {
        index++;

        auto outputFile = (outputDir + u"/" + String::Format(u"{0}", index) + u"_out.jpg");
        auto outputImage = System::IO::File::Create(outputFile);

        pdfExtractor->GetNextImage(outputImage, System::Drawing::Imaging::ImageFormat::get_Jpeg());
    }
}
} // namespace  Facades::Examples::PDF_Extractor

Extract images whole PDF streams

Extract images from the PDF and write each JPEG through a file stream.

Create PdfExtractor.
Bind the PDF input with Facade::BindPdf().
Prepare image extraction with PdfExtractor::ExtractImage().
Check for another image with PdfExtractor::HasNextImage().
Write each image with PdfExtractor::GetNextImage().

#include <Aspose.PDF.Cpp/Facades/PdfExtractor.h>
#include <Aspose.PDF.Cpp/Presentation/IndependentImpl/ImageFormat.h>
#include <drawing/imaging/image_format.h>
#include <system/io/file.h>
#include <system/io/file_stream.h>
#include <system/string.h>

namespace  Facades::Examples::PDF_Extractor
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;

void ExtractImagesWholePDFStreams(String inputFile, String outputDir)
{
    auto pdfExtractor = MakeObject<PdfExtractor>();

    pdfExtractor->BindPdf(inputFile);

    pdfExtractor->ExtractImage();
    int index = 0;

    while (pdfExtractor->HasNextImage())
    {
        index++;

        auto outputFile = (outputDir + u"/" + String::Format(u"{0}", index) + u"_out.jpg");
        auto outputImage = System::IO::File::Create(outputFile);

        pdfExtractor->GetNextImage(outputImage, System::Drawing::Imaging::ImageFormat::get_Jpeg());
    }
}
} // namespace  Facades::Examples::PDF_Extractor

Extract images whole PDF

Extract images from the PDF directly to numbered JPEG paths.

Create PdfExtractor.
Bind the PDF input with Facade::BindPdf().
Prepare image extraction with PdfExtractor::ExtractImage().
Check for another image with PdfExtractor::HasNextImage().
Write each image with PdfExtractor::GetNextImage().

#include <Aspose.PDF.Cpp/Facades/PdfExtractor.h>
#include <system/string.h>

namespace  Facades::Examples::PDF_Extractor
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;

void ExtractImagesWholePDF(String inputFile, String outputDir)
{
    auto pdfExtractor = MakeObject<PdfExtractor>();

    pdfExtractor->BindPdf(inputFile);

    pdfExtractor->ExtractImage();
    int index = 0;

    while (pdfExtractor->HasNextImage())
    {
        ++index;
        pdfExtractor->GetNextImage((outputDir + u"/" + String::Format(u"{0}", index) + u"_out.jpg"));
    }
}
} // namespace  Facades::Examples::PDF_Extractor

Extract text extraction mode

Set extraction mode to the numeric value 1 and write text from each extracted page to a separate file.

Create PdfExtractor.
Bind the PDF input with Facade::BindPdf().
Set extract text mode through PdfExtractor using the example values.
Prepare text extraction with PdfExtractor::ExtractText().
Check for another page of text with PdfExtractor::HasNextPageText().
Write each page of text with PdfExtractor::GetNextPageText().

#include <Aspose.PDF.Cpp/Facades/PdfExtractor.h>
#include <system/string.h>

namespace  Facades::Examples::PDF_Extractor
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;

void ExtractTextExtractionMode(String inputFile, String outputDir)
{
    auto pdfExtractor = MakeObject<PdfExtractor>();

    pdfExtractor->BindPdf(inputFile);

    pdfExtractor->set_ExtractTextMode(1);
    pdfExtractor->ExtractText();

    int pageNumber = 1;
    while (pdfExtractor->HasNextPageText())
    {
        pdfExtractor->GetNextPageText(
            (outputDir + u"/" + String(u"sample") + String::Format(u"{0}", pageNumber) + u".txt"));
        pageNumber++;
    }
}
} // namespace  Facades::Examples::PDF_Extractor

Extract text

Write extracted page text to numbered text files.

Create PdfExtractor.
Bind the PDF input with Facade::BindPdf().
Prepare text extraction with PdfExtractor::ExtractText().
Check for another page of text with PdfExtractor::HasNextPageText().
Write each page of text with PdfExtractor::GetNextPageText().

#include <Aspose.PDF.Cpp/Facades/PdfExtractor.h>
#include <system/string.h>

namespace  Facades::Examples::PDF_Extractor
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;

void ExtractText(String inputFile, String outputDir)
{
    auto pdfExtractor = MakeObject<PdfExtractor>();

    pdfExtractor->BindPdf(inputFile);

    pdfExtractor->ExtractText();

    int pageNumber = 1;
    while (pdfExtractor->HasNextPageText())
    {
        pdfExtractor->GetNextPageText((outputDir + u"/" + String::Format(u"{0}", pageNumber) + u".txt"));
        pageNumber++;
    }
}
} // namespace  Facades::Examples::PDF_Extractor

Cpp: Add text and images to PDF pages in C++

Fri, 13 Nov 2026 00:00:00 +0000

Use PdfFileMend to place images and formatted text on PDF pages and configure compositing or word wrapping.

In AddImage01 through AddImage04, inputFile is an image path and the function creates a new PDF page. Text examples accept a PDF path. AddText03 appends three pages before adding text to pages 1 and 3.

PdfFileMend workflows

Add an image to a new PDF

Create a new one-page PDF and add inputFile as an image in the rectangle (10, 650, 110, 750).

Create PdfFileMend.
Create or open the Document and prepare its pages as shown.
Bind the PDF input with Facade::BindPdf().
Place the image with PdfFileMend::AddImage().
Save the resulting PDF with PdfFileMend::Save().

#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Facades/PdfFileMend.h>
#include <Aspose.PDF.Cpp/Page.h>
#include <Aspose.PDF.Cpp/PageCollection.h>
#include <system/string.h>

namespace Facades::Examples::PDF_FileMend
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;

void AddImage01(String inputFile, String outputFile)
{
    auto document = MakeObject<Document>();
    document->get_Pages()->Add();

    auto mender = MakeObject<PdfFileMend>();

    mender->BindPdf(document);

    mender->AddImage(inputFile, 1, 10, 650, 110, 750);

    mender->Save(outputFile);
}
} // namespace Facades::Examples::PDF_FileMend

Add an image with Multiply blending

Place an image on a new page with Multiply compositing.

Configure image blending and filtering with CompositingParameters.
Create PdfFileMend.
Create or open the Document and prepare its pages as shown.
Bind the PDF input with Facade::BindPdf().
Place the image with PdfFileMend::AddImage().
Save the resulting PDF with PdfFileMend::Save().

#include <Aspose.PDF.Cpp/BlendMode.h>
#include <Aspose.PDF.Cpp/CompositingParameters.h>
#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Facades/PdfFileMend.h>
#include <Aspose.PDF.Cpp/Page.h>
#include <Aspose.PDF.Cpp/PageCollection.h>
#include <system/string.h>

namespace Facades::Examples::PDF_FileMend
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;

void AddImage02(String inputFile, String outputFile)
{
    auto document = MakeObject<Document>();
    document->get_Pages()->Add();

    auto mender = MakeObject<PdfFileMend>();

    mender->BindPdf(document);

    int pageNum = 1;
    int lowerLeftX = 10;
    int lowerLeftY = 650;
    int upperRightX = 110;
    int upperRightY = 750;

    auto compositingParameters = MakeObject<CompositingParameters>(BlendMode::Multiply);

    mender->AddImage(inputFile, pageNum, lowerLeftX, lowerLeftY, upperRightX, upperRightY, compositingParameters);

    mender->Save(outputFile);
}
} // namespace Facades::Examples::PDF_FileMend

Add an image with Exclusion blending and Flate filtering

Place an image on a new page with Exclusion blending and Flate filtering.

Configure image blending and filtering with CompositingParameters.
Create PdfFileMend.
Create or open the Document and prepare its pages as shown.
Bind the PDF input with Facade::BindPdf().
Place the image with PdfFileMend::AddImage().
Save the resulting PDF with PdfFileMend::Save().

#include <Aspose.PDF.Cpp/BlendMode.h>
#include <Aspose.PDF.Cpp/CompositingParameters.h>
#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Facades/PdfFileMend.h>
#include <Aspose.PDF.Cpp/ImageFilterType.h>
#include <Aspose.PDF.Cpp/Page.h>
#include <Aspose.PDF.Cpp/PageCollection.h>
#include <system/string.h>

namespace Facades::Examples::PDF_FileMend
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;

void AddImage03(String inputFile, String outputFile)
{
    auto document = MakeObject<Document>();
    document->get_Pages()->Add();

    auto mender = MakeObject<PdfFileMend>();

    mender->BindPdf(document);

    int pageNum = 1;
    int lowerLeftX = 10;
    int lowerLeftY = 650;
    int upperRightX = 110;
    int upperRightY = 750;

    auto compositingParameters = MakeObject<CompositingParameters>(BlendMode::Exclusion, ImageFilterType::Flate);

    mender->AddImage(inputFile, pageNum, lowerLeftX, lowerLeftY, upperRightX, upperRightY, compositingParameters);

    mender->Save(outputFile);
}
} // namespace Facades::Examples::PDF_FileMend

Add an image with explicit compositing options

Place an image with Multiply blending, Flate filtering, and the third compositing option set to false.

Configure image blending and filtering with CompositingParameters.
Create PdfFileMend.
Create or open the Document and prepare its pages as shown.
Bind the PDF input with Facade::BindPdf().
Place the image with PdfFileMend::AddImage().
Save the resulting PDF with PdfFileMend::Save().

#include <Aspose.PDF.Cpp/BlendMode.h>
#include <Aspose.PDF.Cpp/CompositingParameters.h>
#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Facades/PdfFileMend.h>
#include <Aspose.PDF.Cpp/ImageFilterType.h>
#include <Aspose.PDF.Cpp/Page.h>
#include <Aspose.PDF.Cpp/PageCollection.h>
#include <system/string.h>

namespace Facades::Examples::PDF_FileMend
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;

void AddImage04(String inputFile, String outputFile)
{
    auto document = MakeObject<Document>();
    document->get_Pages()->Add();

    auto mender = MakeObject<PdfFileMend>();

    mender->BindPdf(document);

    int pageNum = 1;
    int lowerLeftX = 10;
    int lowerLeftY = 650;
    int upperRightX = 110;
    int upperRightY = 750;

    auto compositingParameters = MakeObject<CompositingParameters>(BlendMode::Multiply, ImageFilterType::Flate, false);

    mender->AddImage(inputFile, pageNum, lowerLeftX, lowerLeftY, upperRightX, upperRightY, compositingParameters);

    mender->Save(outputFile);
}
} // namespace Facades::Examples::PDF_FileMend

Add formatted text to a page

Add Welcome to Aspose! to page 1 at (10, 750).

Create the text content and formatting with FormattedText.
Create PdfFileMend.
Bind the PDF input with Facade::BindPdf().
Place formatted text with PdfFileMend::AddText().
Save the resulting PDF with PdfFileMend::Save().

#include <Aspose.PDF.Cpp/Facades/FormattedText.h>
#include <Aspose.PDF.Cpp/Facades/PdfFileMend.h>
#include <system/string.h>

namespace Facades::Examples::PDF_FileMend
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;

void AddText01(String inputFile, String outputFile)
{
    auto mender = MakeObject<PdfFileMend>();

    mender->BindPdf(inputFile);

    auto message = MakeObject<FormattedText>(u"Welcome to Aspose!");

    mender->AddText(message, 1, 10, 750);

    mender->Save(outputFile);
}
} // namespace Facades::Examples::PDF_FileMend

Set word wrapping for formatted text

Add formatted text to page 1 and set WrapMode to ByWords before saving.

Create the text content and formatting with FormattedText.
Create PdfFileMend.
Bind the PDF input with Facade::BindPdf().
Place formatted text with PdfFileMend::AddText().
Set wrap mode through PdfFileMend using the example values.
Save the resulting PDF with PdfFileMend::Save().

#include <Aspose.PDF.Cpp/Facades/FormattedText.h>
#include <Aspose.PDF.Cpp/Facades/PdfFileMend.h>
#include <Aspose.PDF.Cpp/Facades/WordWrapMode.h>
#include <system/string.h>

namespace Facades::Examples::PDF_FileMend
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;

void AddText02(String inputFile, String outputFile)
{
    auto mender = MakeObject<PdfFileMend>();

    mender->BindPdf(inputFile);

    auto message = MakeObject<FormattedText>(u"Welcome to Aspose!");

    mender->AddText(message, 1, 10, 750);
    mender->set_WrapMode(WordWrapMode::ByWords);

    mender->Save(outputFile);
}
} // namespace Facades::Examples::PDF_FileMend

Add text to multiple pages

Append three pages to the input PDF and add formatted text to pages 1 and 3 within the specified rectangle.

Create the text content and formatting with FormattedText.
Create PdfFileMend.
Create or open the Document and prepare its pages as shown.
Bind the PDF input with Facade::BindPdf().
Place formatted text with PdfFileMend::AddText().
Save the resulting PDF with PdfFileMend::Save().

#include <Aspose.PDF.Cpp/Document.h>
#include <Aspose.PDF.Cpp/Facades/FormattedText.h>
#include <Aspose.PDF.Cpp/Facades/PdfFileMend.h>
#include <Aspose.PDF.Cpp/Page.h>
#include <Aspose.PDF.Cpp/PageCollection.h>
#include <system/array.h>
#include <system/string.h>

namespace Facades::Examples::PDF_FileMend
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;

void AddText03(String inputFile, String outputFile)
{
    auto document = MakeObject<Document>(inputFile);

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

    auto mender = MakeObject<PdfFileMend>();

    mender->BindPdf(document);

    auto message = MakeObject<FormattedText>(u"Welcome to Aspose!");

    auto pageNums = MakeArray<int32_t>({1, 3});

    float llx = 10;
    float lly = 750;
    float urx = 310;
    float ury = 760;
    mender->AddText(message, pageNums, llx, lly, urx, ury);

    mender->Save(outputFile);
}
} // namespace Facades::Examples::PDF_FileMend

Cpp: Create and edit PDF form fields in C++

Fri, 13 Nov 2026 00:00:00 +0000

Use FormEditor to create, copy, move, decorate, rename, and remove form fields and configure lists, scripts, and submission actions.

Most examples edit existing named fields. CopyInnerField uses page 2, so its input must contain at least two pages. JavaScript and submit actions depend on viewer support when the output is opened.

Common FormEditor tasks

Cpp: Inspect PDF file information in C++

Fri, 13 Nov 2026 00:00:00 +0000

Use PdfFileInfo to read and update metadata, inspect page dimensions, offsets, privileges, encryption flags, and PDF version.

PdfFileInfo opens the PDF through its constructor. Page information examples inspect page 1; offset examples convert points to inches by dividing by 72.

What you can do with PdfFileInfo

Cpp: Edit PDF page properties in C++

Fri, 13 Nov 2026 00:00:00 +0000

Use PdfPageEditor to change page sizes, rotation, alignment, transitions, position, and zoom and inspect page boxes.

ProcessPages limits selected edits to specific pages. The per-page rotation sample requires at least three pages. Presentation transitions depend on the viewer displaying the output.

PdfPageEditor workflows

Change PDF page size

Select page 1 and change its size to Letter.

Create PdfPageEditor.
Bind the PDF input with Facade::BindPdf().
Set process pages through PdfPageEditor using the example values.
Set page size through PdfPageEditor using the example values.
Save the resulting PDF with PdfPageEditor::Save().

#include <Aspose.PDF.Cpp/Facades/PdfPageEditor.h>
#include <Aspose.PDF.Cpp/PageSize.h>
#include <system/array.h>
#include <system/string.h>

namespace Facades::Examples::PDF_PageEditor
{
	using namespace System;
	using namespace Aspose::Pdf;
	using Aspose::Pdf::Facades::PdfPageEditor;

	void ChangePdfPageSize(String inputFile, String outputFile)
	{
		auto editor = MakeObject<PdfPageEditor>();
		editor->BindPdf(inputFile);

		editor->set_ProcessPages(MakeArray<int>({ 1 }));
		editor->set_PageSize(PageSize::get_PageLetter());

		editor->Save(outputFile);
	}
} // namespace Facades::Examples::PDF_PageEditor

Edit PDF pages

Configure page 1 with Ledger size, right alignment, 90-degree rotation, zoom 1, and presentation timing settings.

Create PdfPageEditor.
Bind the PDF input with Facade::BindPdf().
Set process pages through PdfPageEditor using the example values.
Set horizontal alignment through PdfPageEditor using the example values.
Set transition type through PdfPageEditor using the example values.
Set transition duration through PdfPageEditor using the example values.
Set display duration through PdfPageEditor using the example values.
Set page size through PdfPageEditor using the example values.
Set rotation through PdfPageEditor using the example values.
Set zoom through PdfPageEditor using the example values.
Read the page rotation with PdfPageEditor::GetPageRotation().
Read the page count with PdfPageEditor::GetPages().
Save the resulting PDF with PdfPageEditor::Save().
Print the results or diagnostic messages shown in the example.

#include <Aspose.PDF.Cpp/Facades/PdfPageEditor.h>
#include <Aspose.PDF.Cpp/HorizontalAlignment.h>
#include <Aspose.PDF.Cpp/PageSize.h>
#include <iostream>
#include <system/array.h>
#include <system/string.h>

namespace Facades::Examples::PDF_PageEditor
{
using namespace System;
using namespace Aspose::Pdf;
using Aspose::Pdf::Facades::PdfPageEditor;

void EditPdfPages(String inputFile, String outputFile)
{
    auto editor = MakeObject<PdfPageEditor>();
    editor->BindPdf(inputFile);

    editor->set_ProcessPages(MakeArray<int>({1}));
    editor->set_HorizontalAlignment(HorizontalAlignment::Right);
    editor->set_TransitionType(2);
    editor->set_TransitionDuration(5);
    editor->set_DisplayDuration(5);
    editor->set_PageSize(PageSize::get_PageLedger());
    editor->set_Rotation(90);
    editor->set_Zoom(1.0f);
    std::cout << editor->GetPageRotation(1) << std::endl;
    std::cout << editor->GetPages() << std::endl;

    editor->Save(outputFile);
}
} // namespace Facades::Examples::PDF_PageEditor

Get PDF page properties

Write page 1 rotation, total pages, and trim, art, bleed, crop, and media boxes to a text report.

Create PdfPageEditor.
Bind the PDF input with Facade::BindPdf().
Read the page rotation with PdfPageEditor::GetPageRotation().
Read the page count with PdfPageEditor::GetPages().
Read page boxes with PdfPageEditor::GetPageBoxSize().
Write the collected values to the output text file.

#include <Aspose.PDF.Cpp/Facades/PdfPageEditor.h>
#include <drawing/rectangle.h>
#include <iostream>
#include <string>
#include <system/io/file.h>
#include <system/io/file_stream.h>
#include <system/string.h>

namespace Facades::Examples::PDF_PageEditor
{
using namespace System;
using namespace Aspose::Pdf;
using Aspose::Pdf::Facades::PdfPageEditor;

void GetPdfPageProperties(String inputFile, String outputFile)
{
    auto editor = MakeObject<PdfPageEditor>();
    editor->BindPdf(inputFile);
    String report =
        String::Format(u"Page 1 Rotation: {0}\nTotal Pages: {1}\n", editor->GetPageRotation(1), editor->GetPages());
    for (const auto &box : {u"trim", u"art", u"bleed", u"crop", u"media"})
        report += String(box) + u": " + editor->GetPageBoxSize(1, box).ToString() + u"\n";
    std::cout << report << std::endl;
    System::IO::File::WriteAllText(outputFile, report);
}
} // namespace Facades::Examples::PDF_PageEditor

Set individual page rotations

Assign rotations of 90, 180, and 270 degrees to pages 1, 2, and 3.

Create PdfPageEditor.
Bind the PDF input with Facade::BindPdf().
Set page rotations through PdfPageEditor using the example values.
Save the resulting PDF with PdfPageEditor::Save().

#include <Aspose.PDF.Cpp/Facades/PdfPageEditor.h>
#include <system/collections/dictionary.h>
#include <system/string.h>

namespace Facades::Examples::PDF_PageEditor
{
using namespace System;
using namespace Aspose::Pdf;
using Aspose::Pdf::Facades::PdfPageEditor;

void RotatePages1(String inputFile, String outputFile)
{
    auto editor = MakeObject<PdfPageEditor>();
    editor->BindPdf(inputFile);

    auto rotations = MakeObject<System::Collections::Generic::Dictionary<int, int>>();
    rotations->Add(1, 90);
    rotations->Add(2, 180);
    rotations->Add(3, 270);
    editor->set_PageRotations(rotations);

    editor->Save(outputFile);
}
} // namespace Facades::Examples::PDF_PageEditor

Rotate selected pages

Rotate pages 1 and 3 by 90 degrees.

Create PdfPageEditor.
Bind the PDF input with Facade::BindPdf().
Set process pages through PdfPageEditor using the example values.
Set rotation through PdfPageEditor using the example values.
Save the resulting PDF with PdfPageEditor::Save().

#include <Aspose.PDF.Cpp/Facades/PdfPageEditor.h>
#include <system/array.h>
#include <system/string.h>

namespace Facades::Examples::PDF_PageEditor
{
using namespace System;
using namespace Aspose::Pdf;
using Aspose::Pdf::Facades::PdfPageEditor;

void RotatePages2(String inputFile, String outputFile)
{
    auto editor = MakeObject<PdfPageEditor>();
    editor->BindPdf(inputFile);

    editor->set_ProcessPages(MakeArray<int>({1, 3}));
    editor->set_Rotation(90);

    editor->Save(outputFile);
}
} // namespace Facades::Examples::PDF_PageEditor

Set PDF page properties

Move page content by (100, 100) and set zoom to 2.

Create PdfPageEditor.
Bind the PDF input with Facade::BindPdf().
Move page content with PdfPageEditor::MovePosition().
Set zoom through PdfPageEditor using the example values.
Save the resulting PDF with PdfPageEditor::Save().

#include <Aspose.PDF.Cpp/Facades/PdfPageEditor.h>
#include <system/string.h>

namespace Facades::Examples::PDF_PageEditor
{
using namespace System;
using namespace Aspose::Pdf;
using Aspose::Pdf::Facades::PdfPageEditor;

void SetPdfPageProperties(String inputFile, String outputFile)
{
    auto editor = MakeObject<PdfPageEditor>();
    editor->BindPdf(inputFile);

    editor->MovePosition(100, 100);
    editor->set_Zoom(2.0f);

    editor->Save(outputFile);
}
} // namespace Facades::Examples::PDF_PageEditor

Cpp: Manage PDF passwords and permissions in C++

Fri, 13 Nov 2026 00:00:00 +0000

Use PdfFileSecurity to encrypt and decrypt PDF files, change passwords, and apply document privileges with direct or Try methods.

The passwords in these examples are fixture values. Substitute the passwords for your own input and output documents. Permission examples configure DocumentPrivilege; Try methods save only when the operation succeeds.

Common PdfFileSecurity tasks

Cpp: Manage PDF XMP metadata in C++

Fri, 13 Nov 2026 00:00:00 +0000

Use PdfXmpMetadata to add, update, remove, and read XMP properties and register a custom metadata namespace.

The read example expects the standard and custom keys written by AddXmpMetadata. Its outputFile is a text report rather than a modified PDF.

PdfXmpMetadata workflows

Add XMP metadata

Set standard timestamps and creator tool, remove ModifyDate, and register and update a custom property.

Create PdfXmpMetadata.
Bind the PDF input with Facade::BindPdf().
Add the XMP property with PdfXmpMetadata::Add().
Remove the XMP property with PdfXmpMetadata::Remove().
Register the custom namespace with PdfXmpMetadata::RegisterNamespaceURI().
Update the metadata value with PdfXmpMetadata::idx_set().
Save the resulting PDF with PdfXmpMetadata::Save().

#include <Aspose.PDF.Cpp/Data/XMP/XmpValue.h>
#include <Aspose.PDF.Cpp/Facades/DefaultMetadataProperties.h>
#include <Aspose.PDF.Cpp/Facades/PdfXmpMetadata.h>
#include <system/date_time_offset.h>
#include <system/string.h>

namespace Facades::Examples::PDF_XmpMetaData
{
	using namespace System;
	using namespace Aspose::Pdf;
	using namespace Aspose::Pdf::Facades;

	void AddXmpMetadata(String inputFile, String outputFile)
	{
		auto xmp = MakeObject<PdfXmpMetadata>();
		xmp->BindPdf(inputFile);
		auto timestamp = MakeObject<XmpValue>(DateTimeOffset::get_UtcNow().ToString(u"o"));
		xmp->Add(DefaultMetadataProperties::CreateDate, timestamp);
		xmp->Add(DefaultMetadataProperties::MetadataDate, timestamp);
		xmp->Add(DefaultMetadataProperties::CreatorTool, MakeObject<XmpValue>(u"Creator tool name"));
		xmp->Remove(DefaultMetadataProperties::ModifyDate);
		xmp->RegisterNamespaceURI(u"customNamespace", u"http://www.customNameSpaces.com/ns/");
		xmp->Add(u"customNamespace:UserPropertyName", MakeObject<XmpValue>(u"UserPropertyValue"));
		xmp->idx_set(u"customNamespace:UserPropertyName", MakeObject<XmpValue>(u"UserPropertyValue2"));
		xmp->Save(outputFile);
	}
} // namespace Facades::Examples::PDF_XmpMetaData

Get XMP metadata

Read expected standard and custom XMP keys, print them, and write a text report.

Create PdfXmpMetadata.
Bind the PDF input with Facade::BindPdf().
Read the metadata value with PdfXmpMetadata::idx_get().
Write the collected values to the output text file.

#include <Aspose.PDF.Cpp/Data/XMP/XmpValue.h>
#include <Aspose.PDF.Cpp/Facades/DefaultMetadataProperties.h>
#include <Aspose.PDF.Cpp/Facades/PdfXmpMetadata.h>
#include <iostream>
#include <system/io/file.h>
#include <system/io/file_stream.h>
#include <system/string.h>

namespace Facades::Examples::PDF_XmpMetaData
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;

void GetXmpMetadata(String inputFile, String outputFile)
{
    auto xmp = MakeObject<PdfXmpMetadata>();
    xmp->BindPdf(inputFile);
    String report;
    for (auto key : {DefaultMetadataProperties::CreateDate, DefaultMetadataProperties::MetadataDate,
                     DefaultMetadataProperties::CreatorTool})
        report += xmp->idx_get(key)->ToString() + u"\n";
    report += xmp->idx_get(u"customNamespace:UserPropertyName")->ToString() + u"\n";
    std::cout << report << std::endl;
    System::IO::File::WriteAllText(outputFile, report);
}
} // namespace Facades::Examples::PDF_XmpMetaData

Cpp: Fill and inspect PDF forms in C++

Fri, 13 Nov 2026 00:00:00 +0000

Use Form to fill fields, exchange FDF, XFDF, and XML data, add button images, inspect values, rename fields, and flatten forms.

The samples use named fields from the supplied form fixtures. Use a PDF with matching field names and appropriate field types; importing data also requires a compatible FDF, XFDF, or XML file.

Form tutorials

Cpp: Configure PDF image and text stamps in C++

Fri, 13 Nov 2026 00:00:00 +0000

Use Stamp to create image, PDF-page, and text stamps with placement, rotation, transparency, and page selection.

These examples use Aspose::Pdf::Facades::Stamp. Supply the required image or stamp PDF file; the PDF-page sample uses page 1 of the stamp source.

Stamp workflows

Add background image stamp

Apply an image stamp behind page content with opacity 0.35, rotation 45 degrees, size 160 by 80, and origin (200, 300).

Create PdfFileStamp and Stamp.
Bind the PDF input with Facade::BindPdf().
Bind the stamp image with Stamp::BindImage().
Set is background through Stamp using the example values.
Set opacity through Stamp using the example values.
Set quality through Stamp using the example values.
Set rotation through Stamp using the example values.
Set the image stamp dimensions with Stamp::SetImageSize().
Set stamp placement with Stamp::SetOrigin().
Apply the configured stamp with PdfFileStamp::AddStamp().
Save the resulting PDF with PdfFileStamp::Save().

#include <Aspose.PDF.Cpp/Facades/PdfFileStamp.h>
#include <Aspose.PDF.Cpp/Facades/Stamp.h>
#include <system/string.h>

namespace Facades::Examples::PDF_Stamp
{
	using namespace System;
	using namespace Aspose::Pdf::Facades;

	void AddBackgroundImageStamp(String inputFile, String imageFile, String outputFile)
	{
		auto pdfStamper = MakeObject<PdfFileStamp>();
		pdfStamper->BindPdf(inputFile);
		auto stamp = MakeObject<Stamp>();
		stamp->BindImage(imageFile);
		stamp->set_IsBackground(true);
		stamp->set_Opacity(0.35f);
		stamp->set_Quality(90);
		stamp->set_Rotation(45.0f);
		stamp->SetImageSize(160, 80);
		stamp->SetOrigin(200, 300);
		pdfStamper->AddStamp(stamp);
		pdfStamper->Save(outputFile);
	}
} // namespace Facades::Examples::PDF_Stamp

Add image stamp

Apply an image stamp with ID 1 at (36, 520).

Create PdfFileStamp and Stamp.
Bind the PDF input with Facade::BindPdf().
Bind the stamp image with Stamp::BindImage().
Set stamp id through Stamp using the example values.
Set stamp placement with Stamp::SetOrigin().
Apply the configured stamp with PdfFileStamp::AddStamp().
Save the resulting PDF with PdfFileStamp::Save().

#include <Aspose.PDF.Cpp/Facades/PdfFileStamp.h>
#include <Aspose.PDF.Cpp/Facades/Stamp.h>
#include <system/string.h>

namespace Facades::Examples::PDF_Stamp
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;
using Stamp = Aspose::Pdf::Facades::Stamp;

void AddImageStamp(String inputFile, String imageFile, String outputFile)
{
    auto pdfStamper = MakeObject<PdfFileStamp>();
    pdfStamper->BindPdf(inputFile);
    auto stamp = MakeObject<Stamp>();
    stamp->BindImage(imageFile);
    stamp->set_StampId(1);
    stamp->SetOrigin(36, 520);
    pdfStamper->AddStamp(stamp);
    pdfStamper->Save(outputFile);
}
} // namespace Facades::Examples::PDF_Stamp

Add PDF page as stamp

Use page 1 from stampPdf as a stamp on page 1 of the target PDF at (36, 250).

Create PdfFileStamp and Stamp.
Bind the PDF input with Facade::BindPdf().
Bind the source PDF page with Stamp::BindPdf().
Set page number through Stamp using the example values.
Set stamp placement with Stamp::SetOrigin().
Apply the configured stamp with PdfFileStamp::AddStamp().
Save the resulting PDF with PdfFileStamp::Save().

#include <Aspose.PDF.Cpp/Facades/PdfFileStamp.h>
#include <Aspose.PDF.Cpp/Facades/Stamp.h>
#include <system/string.h>

namespace Facades::Examples::PDF_Stamp
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;
using Stamp = Aspose::Pdf::Facades::Stamp;

void AddPdfPageAsStamp(String inputFile, String stampPdf, String outputFile)
{
    auto pdfStamper = MakeObject<PdfFileStamp>();
    pdfStamper->BindPdf(inputFile);
    auto stamp = MakeObject<Stamp>();
    stamp->BindPdf(stampPdf, 1);
    stamp->set_PageNumber(1);
    stamp->SetOrigin(36, 250);
    pdfStamper->AddStamp(stamp);
    pdfStamper->Save(outputFile);
}
} // namespace Facades::Examples::PDF_Stamp

Add rotating stamp to PDF

Place a 100 by 100 image stamp on page 1 at half the page width and height and rotate it 90 degrees.

Create PdfFileInfo and Stamp and PdfFileStamp.
Bind the stamp image with Stamp::BindImage().
Set is background through Stamp using the example values.
Set pages through Stamp using the example values.
Set rotation through Stamp using the example values.
Set stamp placement with Stamp::SetOrigin().
Read the page width with PdfFileInfo::GetPageWidth().
Read the page height with PdfFileInfo::GetPageHeight().
Set the image stamp dimensions with Stamp::SetImageSize().
Bind the PDF input with Facade::BindPdf().
Apply the configured stamp with PdfFileStamp::AddStamp().
Save the resulting PDF with PdfFileStamp::Save().

#include <Aspose.PDF.Cpp/Facades/PdfFileInfo.h>
#include <Aspose.PDF.Cpp/Facades/PdfFileStamp.h>
#include <Aspose.PDF.Cpp/Facades/Stamp.h>
#include <system/array.h>
#include <system/string.h>

namespace Facades::Examples::PDF_Stamp
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;
using Stamp = Aspose::Pdf::Facades::Stamp;

void AddRotatingStampToPdf(String inputFile, String imageFile, String outputFile)
{
    auto fileInfo = MakeObject<PdfFileInfo>(inputFile);

    auto stamp = MakeObject<Stamp>();

    stamp->BindImage(imageFile);

    stamp->set_IsBackground(false);

    stamp->set_Pages(MakeArray<int32_t>({1}));

    stamp->set_Rotation(90);

    stamp->SetOrigin(fileInfo->GetPageWidth(1) / 2, fileInfo->GetPageHeight(1) / 2);

    stamp->SetImageSize(100, 100);

    auto stamper = MakeObject<PdfFileStamp>();

    stamper->BindPdf(inputFile);

    stamper->AddStamp(stamp);
    stamper->Save(outputFile);
}
} // namespace Facades::Examples::PDF_Stamp

Add stamp to specific pages

Limit the image stamp to page 1 with size 120 by 60 and origin (400, 40).

Create PdfFileStamp and Stamp.
Bind the PDF input with Facade::BindPdf().
Bind the stamp image with Stamp::BindImage().
Set pages through Stamp using the example values.
Set stamp placement with Stamp::SetOrigin().
Set the image stamp dimensions with Stamp::SetImageSize().
Apply the configured stamp with PdfFileStamp::AddStamp().
Save the resulting PDF with PdfFileStamp::Save().

#include <Aspose.PDF.Cpp/Facades/PdfFileStamp.h>
#include <Aspose.PDF.Cpp/Facades/Stamp.h>
#include <system/array.h>
#include <system/string.h>

namespace Facades::Examples::PDF_Stamp
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;
using Stamp = Aspose::Pdf::Facades::Stamp;

void AddStampToSpecificPages(String inputFile, String imageFile, String outputFile)
{
    auto pdfStamper = MakeObject<PdfFileStamp>();
    pdfStamper->BindPdf(inputFile);
    auto stamp = MakeObject<Stamp>();
    stamp->BindImage(imageFile);
    stamp->set_Pages(MakeArray<int32_t>({1}));
    stamp->SetOrigin(400, 40);
    stamp->SetImageSize(120, 60);
    pdfStamper->AddStamp(stamp);
    pdfStamper->Save(outputFile);
}
} // namespace Facades::Examples::PDF_Stamp

Add text stamp with text state

Bind formatted approval text and a TextState to a stamp and apply it at (36, 700) with 15-degree rotation.

Create the text content and formatting with FormattedText.
Configure text appearance through TextState.
Create PdfFileStamp and Stamp.
Bind the PDF input with Facade::BindPdf().
Bind the formatted stamp text with Stamp::BindLogo().
Set stamp text styling with Stamp::BindTextState().
Set stamp placement with Stamp::SetOrigin().
Set rotation through Stamp using the example values.
Apply the configured stamp with PdfFileStamp::AddStamp().
Save the resulting PDF with PdfFileStamp::Save().

#include <Aspose.PDF.Cpp/Color.h>
#include <Aspose.PDF.Cpp/Facades/EncodingType.h>
#include <Aspose.PDF.Cpp/Facades/FontStyle.h>
#include <Aspose.PDF.Cpp/Facades/FormattedText.h>
#include <Aspose.PDF.Cpp/Facades/PdfFileStamp.h>
#include <Aspose.PDF.Cpp/Facades/Stamp.h>
#include <Aspose.PDF.Cpp/Text/FontStyles.h>
#include <Aspose.PDF.Cpp/Text/TextState.h>
#include <drawing/color.h>
#include <system/string.h>

namespace Facades::Examples::PDF_Stamp
{
using namespace System;
using namespace Aspose::Pdf;
using namespace Aspose::Pdf::Facades;
using namespace Aspose::Pdf::Text;
using Stamp = Aspose::Pdf::Facades::Stamp;

void AddTextStampWithTextState(String inputFile, String outputFile)
{
    auto text = MakeObject<FormattedText>(u"Approved by signing workflow", System::Drawing::Color::get_Blue(),
                                          System::Drawing::Color::get_LightGray(), FontStyle::HelveticaBold,
                                          EncodingType::Winansi, true, 14);
    auto textState = MakeObject<TextState>();
    textState->set_ForegroundColor(Aspose::Pdf::Color::get_DarkBlue());
    textState->set_FontSize(16);
    textState->set_FontStyle(FontStyles::Bold);

    auto pdfStamper = MakeObject<PdfFileStamp>();
    pdfStamper->BindPdf(inputFile);
    auto stamp = MakeObject<Stamp>();
    stamp->BindLogo(text);
    stamp->BindTextState(textState);
    stamp->SetOrigin(36, 700);
    stamp->set_Rotation(15.0f);
    pdfStamper->AddStamp(stamp);
    pdfStamper->Save(outputFile);
}
} // namespace Facades::Examples::PDF_Stamp

Cpp: Add PDF headers, footers, and page numbers in C++

Fri, 13 Nov 2026 00:00:00 +0000

Use PdfFileStamp to add text and image headers or footers, image stamps, and page numbers with configurable position and style.

The examples bind an existing PDF and save the stamped result. Image variants require imageFile. The # placeholder in page-number text is replaced by the generated page number.