4-Heights® PDF Toolbox SDK - Assembler, modifier et créer des fichiers PDF en C# et Java

Le 4 Heights™ PDF Toolbox SDK est un composant rapide, de haute qualité et compatible PDF/A qui permet de créer des documents PDF par programmation à partir de zéro, d'ajouter tout contenu, tel que du texte et des images, à des PDF existants et d'assembler (fusionner et diviser) des documents PDF. Grâce à diverses interfaces, le SDK peut être utilisée avec Java, C/C++, .NET Core et langages .NET, tels que C# et Visual Basic.

Formulaires et annotations

Créer, remplir et extraire des formulaires de manière programmatique. Ajouter, modifier et extraire des annotations.

Modifier des fichiers PDF

Enrichir des documents PDF avec des informations supplémentaires, comme estampillage

Créer des fichiers PDF

Créer de nouvelles pages avec n’importe quel contenu et assembler avec vos fichiers PDF

Obtenir un essai gratuit de 30 jours

Demandez un offre adaptée

Smallpdf est un grand de la compression

La taille d’un fichier en pièce jointe à un e-mail peut empêcher l’envoi ou la réception de l’e-mail en raison de limitations techniques. Pour résoudre ce problème, les fondateurs de Smallpdf ont cherché un moyen de réduire la taille de ces fichiers.

Gagner du temps grâce à des services PDF basés sur le cloud

L’augmentation constante des volumes exigeait non seulement plus de stabilité et de qualité du logiciel lui-même, mais aussi une évolutivité plus efficace de l’infrastructure serveur existante et future. La principale exigence envers le nouveau logiciel était donc d’accomplir l’ensemble des tâches rapidement et avec une grande qualité.

PDF Toolbox - Fonctions

Assemblage de documents

Copie de pages de documents PDF existants
Copie d’annotations / de commentaires, de champs de formulaire, de liens, d’informations relatives à la structure, de signets, d’étiquettes, de marqueurs de saut
Dissolution d’annotations, de champs de formulaire, de signatures
Optimisation des ressources
Découpe et rotation des pages
Libre composition de contenus, superpositions, sous-couches, cachets, transformations
Cryptage: Mot de passe utilisateur, Mot de passe propriétaire, Permissions
Copier et modifier les métadonnées d'un document
Copier et modifier les métadonnées de page
Ajout de fichiers incorporés et de fichiers associés
Obtenir et configurer OpenAction

Génération de contenu

Niveau du document
- Créer des pages
  - Créer des champs de formulaire
  - Zones de texte générales et zones de texte en peigne
  - Cases à cocher
  - Groupes de boutons d'option
  - Listes de sélection
  - Listes déroulantes
- Créer de nouveaux signets et les insérer n'importe où dans l'arbre des signets
- Sauter des cibles : Destinations nommées et destinations directes dans le document
- Configurer les paramètres de visualisation
Contenu de page
- Création de nouveaux contenus PDF en partant de zéro
- Ajout de contenu à des pages existantes
Coleurs
- Device colors: RGB, CMYK ou nuances de gris
- Profils de couleurs ICC
- Transparence: Mode Alpha et Blend
Paths
- Lignes simples et multi-segments
- Rectangle, Cercle, Courbes de Bézier, Ellipse, Arc, Tarte
- Remplissage, dessin, découpage et combinaisons de ceux-ci
- Largeur de ligne, fin de ligne (capuchon), raccord de ligne (jonction), tableau de bord (tableau de bord, phase du tableau de bord) et limite d'onglet (avec limite)
- Règles interne : Nonzero winding rule, Even/odd rule
Texte
- Taille de police caractères, espacement des caractères, espacement des mots
- Mise à l'échelle horizontale, en tête, leading, en exposant
- Permet une mise en page simple du texte
- Polices caractères PDF standard, polices caractères installées
- Paramètres de police : Italic angle, Ascent, Descent, Cap height, Character width
- Caractères Unicode
- Course du texte: Largeur de ligne, jointure de ligne et tirets
- Remplir et recadrer du texte, texte invisible
- Utiliser le texte comme chemin de détourage
Images
- Bi-level: CCITT G3, G3 2D and G4, Flate, LZW, Packbits, non compressé
- 4 bits et 8 nuances de gris: Flat, LZW, Packbits, JPEG et JPEG-6 (8 bits seulement), non compressé
- RGB: Flate, JPEG et JPEG-6, LZW, Packbits, non compressé
Transformations
- Traduction
- Mise à l'échelle
- Déformer (horizontale, verticale)
- Rotation
Annotations
- Annotations de liens Internet
- Annotations de fichiers joints
- Annotation en texte libre
- Note autocollante d'annotation
- Annotation de timbre de texte
- Annotation de timbres personnalisés
- Annotation circulaire
- Annotation carrée
- Annotation de ligne
- Annotation polyligne
- Annotation polygonale
- Annotation de dessin libre (" ink ")

Modification

Contenu de page
- Suppression sélective d'éléments de contenu (sans markup)
- Transformation géométrique des éléments de contenu (sans markup)
Annotations
- URI cibles des annotations de liens web
- Emplacement des annotations de markup, date de création/modification, sujet, auteur, contenu
Champs du formulaire
- Suppression de champs et modification des valeurs de champs pour
  - les champs de texte communs et les champs de texte combo
  - Cases à cocher
  - Groupes de boutons d'option
  - Listes de sélection
  - Listes déroulantes

Extraction

Document et pages
- Saisie d'information de pièce : Titre, Auteur, Auteur, Sujet, Mots-clés, Créateur, Producteur, Date de création, Date de modification
- Métadonnées du document XMP
- Paramètres de cryptage des documents
- Fichiers intégrés
- Boîtes de délimitation des pages : Media box, Crop box, Bleed box, Trim box, Art box
- Page Métadonnées XMP
- Arbre des signets : structure arborescente, titre du signet, ouverture/fermeture
- Sauter des cibles : Destinations nommées et destinations directes dans le document
- Paramètres de visualisation
Contentu
- Éléments de contenu des pages et éléments de groupe, y compris les attributs suivants
  - Boîte de délimitation (Bounding box)
  - Transformation affine
- Types d'éléments extraits :
  - Élément de groupe
  - Élément figuratif
    - Largeur et hauteur en pixels
    - Bits par composante de couleur
    - Espace des couleurs
- Elément de masque d'image
  - Largeur et hauteur en pixels
  - Couleur pour remplir le masque
- Élément de chemin
  - Boîte d'alignement
  - Paramètres de remplissage, y compris peinture et règle de remplissage
  - Paramètres de ligne, y compris la couleur et le style de la ligne
- Élément d'ombrage
- Élément de texte
  - Fragments de texte
    - Boîte de délimitation (Bounding box)
    - Transformation affine
    - Unicode String
    - Paramètres de remplissage, y compris peinture et règle de remplissage
    - Paramètres de ligne, y compris la couleur et le style de la ligne
Annotations
- Annotations : localisation
- Annotation markup : type, lieu, date de création/modification, sujet, auteur, contenu
- Annotations de timbres personnalisés : apparence
- Annotations de liens : lieu, destination cible ou URI
- Champs de signature: nom, lieu, motif, coordonnées, date, visibilité
Champs du formulaire AcroForm
- Identificateur de zone de formulaire, nom d'exportation et nom d'affichage, y compris la hiérarchie des zones de formulaire
- Valeurs d'exportation de zone de formulaire et valeurs d'affichage pour :
  - Boutons poussoirs
  - Cases à cocher
  - Groupes de boutons d'option
  - Zones de texte générales et zones de texte en peigne
  - Listes de sélection
  - Listes déroulantes

Conformance

ISO 32000-1 (PDF 1.7)
ISO 32000-2 (PDF 2.0)
ISO 19005-1 (PDF/A-1)
ISO 19005-2 (PDF/A-2)
ISO 19005-3 (PDF/A-3)

Formats supportée

Supported PDF Formats

PDF 1.0 to 1.7
PDF 2.0
PDF/A-1, PDF/A-2, PDF/A-3

Supported image formats

BMP
DIB
JPEG
JPEG2000
JBIG2
PNG
GIF
TIFF

Supported Font Formats

Type1
TrueType
OpenType
OpenType (CFF)

Exemple de code

MANUELS

.NET Core | Java | C/C++

RÉFÉRENCE

Java

Domaines d’application - éditer et composer des documents PDF

Création d’un PDF

Création programmatique de n’importe quels documents PDF/A, dont les contenus peuvent provenir de sources quelconques, comme par exemple une banque de données ou un formulaire de site Web.

Personnalisation

Les documents PDF sont utilisés pour la distribution de livres numériques, pour la réalisation de factures, contrats et conditions notamment dans les propositions d’assurance. Ils présentent tous point commun: le destinataire doit compléter le document avec des informations spécifiques.

Etablissement automatisé de rapports

De grandes quantités d’informations sont stockées dans les banques de données et systèmes DMS. Moyennant la PDF Prep Tool Suite, il est possible de recevoir ces informations et d’en faire des documents PDF distribuables et standardisés, ce qui permet leur distribution dans des infrastructures dotées de technologies et de systèmes d’exploitation les plus divers.

Autres domaines d’application

Création de documents personnalisés tels que citations, politiques, publipostage, etc.
Production de masse des factures, rapports, etc.
Création de fichiers PDF « on-the-fly » dans les applications de serveur Web
"Enregistrer au format PDF/A" fonction dans les programmes d'application
Importer des images et du texte dans documents PDF/A

Contactez-nous

Add stamp to PDF

Add a semi-transparent stamp text onto each page of a PDF document. Optionally specify the color and the opacity of the stamp.

Plus d'exemples

C# sample:

// Open input document
using (Stream inStream = new FileStream(inPath, FileMode.Open, FileAccess.Read))
using (Document inDoc = Document.Open(inStream, null))

// Create output document
using (Stream outStream = new FileStream(outPath, FileMode.Create, FileAccess.ReadWrite))
using (Document outDoc = Document.Create(outStream, inDoc.Conformance, null))
{
    // Copy document-wide data
    CopyDocumentData(inDoc, outDoc);

    font = Font.CreateFromSystem(outDoc, "Arial", "Italic", true);

    // Get the color space
    ColorSpace colorSpace = ColorSpace.CreateProcessColorSpace(outDoc, ProcessColorSpaceType.Rgb);

    // Choose the RGB color value
    double[] color = { 1.0, 0.0, 0.0 };
    Transparency transparency = new Transparency(alpha);

    // Create paint object with the choosen RGB color
    paint = Paint.Create(outDoc, colorSpace, color, transparency);

    // Define copy options
    PageCopyOptions copyOptions = new PageCopyOptions();

    // Copy all pages from input document
    foreach (Page inPage in inDoc.Pages)
    {
        // Copy page from input to output
        Page outPage = Page.Copy(outDoc, inPage, copyOptions);

        // Add text to page
        AddStamp(outDoc, outPage, stampString);

        // Add page to document
        outDoc.Pages.Add(outPage);
    }
}

private static void CopyDocumentData(Document inDoc, Document outDoc)
{
    // Copy document-wide data

    // Output intent
    if (inDoc.OutputIntent != null)
        outDoc.OutputIntent = IccBasedColorSpace.Copy(outDoc, inDoc.OutputIntent);

    // Metadata
    outDoc.Metadata = Metadata.Copy(outDoc, inDoc.Metadata);

    // Viewer settings
    outDoc.ViewerSettings = ViewerSettings.Copy(outDoc, inDoc.ViewerSettings);

    // Associated files (for PDF/A-3 and PDF 2.0 only)
    FileReferenceList outAssociatedFiles = outDoc.AssociatedFiles;
    foreach (FileReference inFileRef in inDoc.AssociatedFiles)
        outAssociatedFiles.Add(FileReference.Copy(outDoc, inFileRef));

    // Plain embedded files
    FileReferenceList outEmbeddedFiles = outDoc.PlainEmbeddedFiles;
    foreach (FileReference inFileRef in inDoc.PlainEmbeddedFiles)
        outEmbeddedFiles.Add(FileReference.Copy(outDoc, inFileRef));
}

private static void AddStamp(Document outputDoc, Page outPage, string stampString)
{
    // Create content generator and text object
    using ContentGenerator gen = new ContentGenerator(outPage.Content, false);
    Text text = Text.Create(outputDoc);

    // Create text generator
    using (TextGenerator textgenerator = new TextGenerator(text, font, fontSize, null))
    {
        // Calculate point and angle of rotation
        Point rotationCenter = new Point
        {
            X = outPage.Size.Width / 2.0,
            Y = outPage.Size.Height / 2.0
        };
        double rotationAngle = Math.Atan2(outPage.Size.Height,
            outPage.Size.Width) / Math.PI * 180.0;

        // Rotate textinput around the calculated position
        AffineTransform trans = AffineTransform.Identity;
        trans.Rotate(rotationAngle, rotationCenter);
        gen.Transform(trans);

        // Calculate position
        Point position = new Point
        {
            X = (outPage.Size.Width - textgenerator.GetWidth(stampString)) / 2.0,
            Y = (outPage.Size.Height - font.Ascent * fontSize) / 2.0
        };

        // Move to position
        textgenerator.MoveTo(position);

        // Set text paint
        textgenerator.Fill = paint;

        // Add given stamp string
        textgenerator.ShowLine(stampString);
    }
    // Paint the positioned text
    gen.PaintText(text);
}

C# sample:

Java sample:

try (// Open input document
    FileStream inStream = new FileStream(inPath, "r");
    Document inDoc = Document.open(inStream, null);
    FileStream outStream = new FileStream(outPath, "rw")) {
    outStream.setLength(0);
    try (// Create output document
        Document outDoc = Document.create(outStream, inDoc.getConformance(), null)) {
        // Copy document-wide data
        copyDocumentData(inDoc, outDoc);

        // Create embedded font in output document
        font = Font.createFromSystem(outDoc, "Arial", "Italic", true);

        // Get the color space
        ColorSpace colorSpace = ColorSpace.createProcessColorSpace(outDoc, ProcessColorSpaceType.RGB);

        // Choose the RGB color value
        double[] color = { 1.0, 0.0, 0.0 };
        Transparency transparency = new Transparency(alpha);

        // Create paint object
        paint = Paint.create(outDoc, colorSpace, color, transparency);

        // Define page copy options
        PageCopyOptions copyOptions = new PageCopyOptions();

        // Loop throw all pages of input
        for (Page inPage : inDoc.getPages()) {
            // Copy page from input to output
            Page outPage = Page.copy(outDoc, inPage, copyOptions);

            // Add text to page
            addStamp(outDoc, outPage, stampString);

            // Add page to document
            outDoc.getPages().add(outPage);
        }
    }
}

private static void copyDocumentData(Document inDoc, Document outDoc) throws PdfToolboxException, IOException {
    // Copy document-wide data

    // Output intent
    if (inDoc.getOutputIntent() != null)
        outDoc.setOutputIntent(IccBasedColorSpace.copy(outDoc, inDoc.getOutputIntent()));

    // Metadata
    outDoc.setMetadata(Metadata.copy(outDoc, inDoc.getMetadata()));

    // Viewer settings
    outDoc.setViewerSettings(ViewerSettings.copy(outDoc, inDoc.getViewerSettings()));

    // Associated files (for PDF/A-3 and PDF 2.0 only)
    FileReferenceList outAssociatedFiles = outDoc.getAssociatedFiles();
    for (FileReference inFileRef : inDoc.getAssociatedFiles())
        outAssociatedFiles.add(FileReference.copy(outDoc, inFileRef));

    // Plain embedded files
    FileReferenceList outEmbeddedFiles = outDoc.getPlainEmbeddedFiles();
    for (FileReference inFileRef : inDoc.getPlainEmbeddedFiles())
        outEmbeddedFiles.add(FileReference.copy(outDoc, inFileRef));
}

private static void addStamp(Document outputDoc, Page outPage, String stampString)
        throws PdfToolboxException, IOException {
    try (// Create content generator
        ContentGenerator generator = new ContentGenerator(outPage.getContent(), false)) {
        // Create text object
        Text text = Text.create(outputDoc);
        try (// Create text generator
            TextGenerator textgenerator = new TextGenerator(text, font, fontSize, null)) {
            // Calculate point and angle of rotation
            Point rotationCenter = new Point(outPage.getSize().width / 2.0, outPage.getSize().height / 2.0);

            // Calculate rotation angle
            double rotationAngle = Math.atan2(outPage.getSize().height, outPage.getSize().width) / Math.PI * 180.0;

            // Rotate text input around the calculated position
            AffineTransform trans = AffineTransform.getIdentity();
            trans.rotate(rotationAngle, rotationCenter);
            generator.transform(trans);

            // Calculate position
            Point position = new Point((outPage.getSize().width - textgenerator.getWidth(stampString)) / 2.0,
                    (outPage.getSize().height - font.getAscent() * fontSize) / 2.0);

            // Move to position
            textgenerator.moveTo(position);

            // Set text paint
            textgenerator.setFill(paint);

            // Add given stamp string
            textgenerator.showLine(stampString);
        }

        // Paint the positioned text
        generator.paintText(text);
    }
}

Java sample:

C sample:

// Open input document
pInStream = _tfopen(szInPath, _T("rb"));
GOTO_CLEANUP_IF_NULL(pInStream, _T("Failed to open input file \"%s\".\n"), szInPath);
PtxSysCreateFILEStreamDescriptor(&inDescriptor, pInStream, FALSE);
pInDoc = PtxPdf_Document_Open(&inDescriptor, _T(""));
GOTO_CLEANUP_IF_NULL_PRINT_ERROR(pInDoc, _T("Input file \"%s\" cannot be opened. %s (ErrorCode: 0x%08x).\n"), szInPath, szErrorBuff, Ptx_GetLastError());

// Create output document
pOutStream = _tfopen(szOutPath, _T("wb+"));
GOTO_CLEANUP_IF_NULL(pOutStream, _T("Failed to open output file %s.\n"), szOutPath);
PtxSysCreateFILEStreamDescriptor(&outDescriptor, pOutStream, 0);
iConformance = PtxPdf_Document_GetConformance(pInDoc);
pOutDoc = PtxPdf_Document_Create(&outDescriptor, &iConformance, NULL);
GOTO_CLEANUP_IF_NULL_PRINT_ERROR(pOutDoc, _T("Output file %s cannot be closed. %s (ErrorCode: 0x%08x).\n"), szOutPath, szErrorBuff, Ptx_GetLastError());

// Create embedded font in output document
pFont = PtxPdfContent_Font_CreateFromSystem(pOutDoc, _T("Arial"), _T("Italic"), TRUE);
GOTO_CLEANUP_IF_NULL_PRINT_ERROR(pFont, _T("Embedded font cannot be created. %s (ErrorCode: 0x%08x).\n"), szErrorBuff, Ptx_GetLastError());

// Copy document-wide data
GOTO_CLEANUP_IF_FALSE_PRINT_ERROR(copyDocumentData(pInDoc, pOutDoc), _T("Failed to copy document-wide data. %s (ErrorCode: 0x%08x).\n"), szErrorBuff, Ptx_GetLastError());

// Get the color space
TPtxPdfContent_ColorSpace* pColorSpace = PtxPdfContent_ColorSpace_CreateProcessColorSpace(pOutDoc, ePtxPdfContent_ProcessColorSpaceType_Rgb);
GOTO_CLEANUP_IF_NULL_PRINT_ERROR(pColorSpace, _T("Failed to get the color space. %s (ErrorCode: 0x%08x).\n"), szErrorBuff, Ptx_GetLastError());

// Chose the RGB color values
double color[] = { 1.0, 0.0, 0.0 };
size_t nColor = sizeof(color) / sizeof(double);
pTransparency = PtxPdfContent_Transparency_New(dAlpha);

// Create paint object
pPaint = PtxPdfContent_Paint_Create(pOutDoc, pColorSpace, color, nColor, pTransparency);
GOTO_CLEANUP_IF_NULL_PRINT_ERROR(pPaint, _T("Failed to create a transparent paint. %s (ErrorCode: 0x%08x).\n"), szErrorBuff, Ptx_GetLastError());

// Configure copy options
pCopyOptions = PtxPdf_PageCopyOptions_New();

// Loop through all pages of input
pInPageList = PtxPdf_Document_GetPages(pInDoc);
GOTO_CLEANUP_IF_NULL_PRINT_ERROR(pInPageList, _T("Failed to get the pages of the input document. %s (ErrorCode: 0x%08x).\n"), szErrorBuff, Ptx_GetLastError());
pOutPageList = PtxPdf_Document_GetPages(pOutDoc);
GOTO_CLEANUP_IF_NULL_PRINT_ERROR(pOutPageList, _T("Failed to get the pages of the output document. %s (ErrorCode: 0x%08x).\n"), szErrorBuff, Ptx_GetLastError());
for (int i = 0; i < PtxPdf_PageList_GetCount(pInPageList); i++)
{
    // Get a list of pages
    pInPage = PtxPdf_PageList_Get(pInPageList, i);

    // Copy page from input to output
    pOutPage = PtxPdf_Page_Copy(pOutDoc, pInPage, pCopyOptions);
    GOTO_CLEANUP_IF_NULL_PRINT_ERROR(pOutPage, _T("Failed to copy pages from input to output. %s (ErrorCode: 0x%08x).\n"), szErrorBuff, Ptx_GetLastError());

    // Add stamp to page
    if (addStamp(pOutDoc, pOutPage, szStampString, pFont, 50) == 1)
    {
        goto cleanup;
    }

    // Add page to output document
    GOTO_CLEANUP_IF_FALSE_PRINT_ERROR(PtxPdf_PageList_Add(pOutPageList, pOutPage), _T("Failed to add page to output document. %s (ErrorCode: 0x%08x).\n"), szErrorBuff, Ptx_GetLastError());

    if (pOutPage != NULL)
    {
        Ptx_Release(pOutPage);
        pOutPage = NULL;
    }

    if (pInPage != NULL)
    {
        Ptx_Release(pInPage);
        pInPage = NULL;
    }
}

int copyDocumentData(TPtxPdf_Document * pInDoc, TPtxPdf_Document * pOutDoc)
{
    TPtxPdf_FileReferenceList* pInFileRefList;
    TPtxPdf_FileReferenceList* pOutFileRefList;

    // Output intent
    if (PtxPdf_Document_GetOutputIntent(pInDoc) != NULL)
        if (PtxPdf_Document_SetOutputIntent(pOutDoc, PtxPdfContent_IccBasedColorSpace_Copy(pOutDoc, PtxPdf_Document_GetOutputIntent(pInDoc))) == FALSE)
            return FALSE;

    // Metadata
    if (PtxPdf_Document_SetMetadata(pOutDoc, PtxPdf_Metadata_Copy(pOutDoc, PtxPdf_Document_GetMetadata(pInDoc))) == FALSE)
        return FALSE;

    // Viewer settings
    if (PtxPdf_Document_SetViewerSettings(pOutDoc, PtxPdfNav_ViewerSettings_Copy(pOutDoc, PtxPdf_Document_GetViewerSettings(pInDoc))) == FALSE)
        return FALSE;

    // Associated files (for PDF/A-3 and PDF 2.0 only)
    pInFileRefList = PtxPdf_Document_GetAssociatedFiles(pInDoc);
    pOutFileRefList = PtxPdf_Document_GetAssociatedFiles(pOutDoc);
    if (pInFileRefList == NULL || pOutFileRefList == NULL)
        return FALSE;
    for (int iFileRef = 0; iFileRef < PtxPdf_FileReferenceList_GetCount(pInFileRefList); iFileRef++)
        if (PtxPdf_FileReferenceList_Add(pOutFileRefList, PtxPdf_FileReference_Copy(pOutDoc, PtxPdf_FileReferenceList_Get(pInFileRefList, iFileRef))) == FALSE)
            return FALSE;

    // Plain embedded files
    pInFileRefList = PtxPdf_Document_GetPlainEmbeddedFiles(pInDoc);
    pOutFileRefList = PtxPdf_Document_GetPlainEmbeddedFiles(pOutDoc);
    if (pInFileRefList == NULL || pOutFileRefList == NULL)
        return FALSE;
    for (int iFileRef = 0; iFileRef < PtxPdf_FileReferenceList_GetCount(pInFileRefList); iFileRef++)
        if (PtxPdf_FileReferenceList_Add(pOutFileRefList, PtxPdf_FileReference_Copy(pOutDoc, PtxPdf_FileReferenceList_Get(pInFileRefList, iFileRef))) == FALSE)
            return FALSE;

    return TRUE;
}

int addStamp(TPtxPdf_Document* pOutDoc, TPtxPdf_Page* pOutPage, TCHAR* szStampString, TPtxPdfContent_Font* pFont, double dFontSize)
{
    TPtxPdfContent_ContentGenerator* pGenerator = NULL;
    TPtxPdfContent_Text* pText = NULL;
    TPtxPdfContent_TextGenerator* pTextGenerator = NULL;
    TPtxGeomReal_AffineTransform trans;
    TPtxGeomReal_Point rotationCenter;
    double dTextWidth;
    double dFontAscent;

    TPtxPdfContent_Content* pContent = PtxPdf_Page_GetContent(pOutPage);

    // Create content generator
    pGenerator = PtxPdfContent_ContentGenerator_New(pContent, FALSE);
    GOTO_CLEANUP_IF_NULL_PRINT_ERROR(pGenerator, _T("Failed to create a content generator. %s (ErrorCode: 0x%08x).\n"), szErrorBuff, Ptx_GetLastError());

    // Create text object
    pText = PtxPdfContent_Text_Create(pOutDoc);
    GOTO_CLEANUP_IF_NULL_PRINT_ERROR(pText, _T("Failed to create a text object. %s (ErrorCode: 0x%08x).\n"), szErrorBuff, Ptx_GetLastError());

    // Create a text generator 
    pTextGenerator = PtxPdfContent_TextGenerator_New(pText, pFont, dFontSize, NULL);
    GOTO_CLEANUP_IF_NULL_PRINT_ERROR(pTextGenerator, _T("Failed to create a text generator. %s (ErrorCode: 0x%08x).\n"), szErrorBuff, Ptx_GetLastError());

    // Get output page size
    TPtxGeomReal_Size size;
    GOTO_CLEANUP_IF_FALSE_PRINT_ERROR(PtxPdf_Page_GetSize(pOutPage, &size), _T("Failed to read page size. %s (ErrorCode: 0x%08x).\n"), szErrorBuff, Ptx_GetLastError());

    // Calculate point and angle of rotation
    rotationCenter.dX = size.dWidth / 2.0;
    rotationCenter.dY = size.dHeight / 2.0;
    double dRotationAngle = atan2(size.dHeight, size.dWidth) / M_PI * 180.0;

    // Rotate textinput around the calculated position
    PtxGeomReal_AffineTransform_GetIdentity(&trans);
    GOTO_CLEANUP_IF_FALSE_PRINT_ERROR(PtxGeomReal_AffineTransform_Rotate(&trans, dRotationAngle, &rotationCenter), _T("Failed to rotate textinput around the calculated position. %s (ErrorCode: 0x%08x).\n"), szErrorBuff, Ptx_GetLastError());
    GOTO_CLEANUP_IF_FALSE_PRINT_ERROR(PtxPdfContent_ContentGenerator_Transform(pGenerator, &trans), _T("Failed to modify the current transformation. %s (ErrorCode: 0x%08x).\n"), szErrorBuff, Ptx_GetLastError());

    // Calculate position
    TPtxGeomReal_Point position;
    dTextWidth = PtxPdfContent_TextGenerator_GetWidth(pTextGenerator, szStampString);
    GOTO_CLEANUP_IF_ZERO_PRINT_ERROR(dTextWidth, _T("%s (ErrorCode: 0x%08x).\n"), szErrorBuff, Ptx_GetLastError());
    dFontAscent = PtxPdfContent_Font_GetAscent(pFont);
    GOTO_CLEANUP_IF_ZERO_PRINT_ERROR(dFontAscent, _T("%s (ErrorCode: 0x%08x).\n"), szErrorBuff, Ptx_GetLastError());
    position.dX = (size.dWidth - dTextWidth) / 2.0;
    position.dY = (size.dHeight - dFontAscent * dFontSize) / 2.0;

    // Move to position
    GOTO_CLEANUP_IF_FALSE_PRINT_ERROR(PtxPdfContent_TextGenerator_MoveTo(pTextGenerator, &position), _T("Failed to move to position. %s (ErrorCode: 0x%08x).\n"), szErrorBuff, Ptx_GetLastError());
    // Set text rendering
    GOTO_CLEANUP_IF_FALSE_PRINT_ERROR(PtxPdfContent_TextGenerator_SetFill(pTextGenerator, pPaint), _T("Failed to set fill paint. %s (ErrorCode: 0x%08x).\n"), szErrorBuff, Ptx_GetLastError());
    // Add given stamp string
    GOTO_CLEANUP_IF_FALSE_PRINT_ERROR(PtxPdfContent_TextGenerator_ShowLine(pTextGenerator, szStampString), _T("Failed to add stamp. %s (ErrorCode: 0x%08x).\n"), szErrorBuff, Ptx_GetLastError());

    // Close text generator
    if (pTextGenerator != NULL)
    {
        PtxPdfContent_TextGenerator_Close(pTextGenerator);
        pTextGenerator = NULL;
    }

    // Paint the positioned text
    GOTO_CLEANUP_IF_FALSE_PRINT_ERROR(PtxPdfContent_ContentGenerator_PaintText(pGenerator, pText), _T("Failed to paint the positioned text. %s (ErrorCode: 0x%08x).\n"), szErrorBuff, Ptx_GetLastError());

cleanup:
    if (pTextGenerator != NULL)
        PtxPdfContent_TextGenerator_Close(pTextGenerator);
    if (pText != NULL)
        Ptx_Release(pText);
    if (pGenerator != NULL)
        PtxPdfContent_ContentGenerator_Close(pGenerator);
    if (pContent != NULL)
        Ptx_Release(pContent);

    return iReturnValue;
}

C sample:

The caveats of assembling PDF/A documents

Assembling PDF documents from various sources is a crucial part of an output management system. And, as the document needs to be archived in most cases, it should conform to the PDF/A standard. Is there a way to assemble a document and accomplish PDF/A conformance in one step?

The problem with embedded fonts in PDF mass printing applications

PDF is more and more finding its way into mass printing applications. However, PDF spool files often ask too much from a print engine resulting in aborts or, even worse, incomplete prints which may not be noticed. What is special about PDF mass printing...