com.itextpdf.text.pdf.PdfDictionary Java Examples

public byte[] buildSignedPDF(String digestOID, byte[] signature, byte[] hash) throws Exception {
    byte[] hashTmp = null;
    if (dateTime != null)
        hashTmp = hash;

    byte[] pkcs7enc = PKCS7Manager.buildPDFPKCS7(digestOID, x509Certificate, signature, hashTmp, dateTime);

    PdfDictionary dic = new PdfDictionary();
    PdfString contents = new PdfString(pkcs7enc).setHexWriting(true);

    contentsSize = contents.length();

    dic.put(PdfName.CONTENTS, contents);
    sap.close(dic);

    return bout.toByteArray();
}
 

/**
 * @see #testExtractImageLikeSteveB()
 */
private static List<BufferedImage> FindImages(PdfReader reader, PdfDictionary pdfPage) throws IOException
{
    List<BufferedImage> result = new ArrayList<>(); 
    Iterable<PdfObject> imgPdfObject = FindImageInPDFDictionary(pdfPage);
    for (PdfObject image : imgPdfObject)
    {
        int xrefIndex = ((PRIndirectReference)image).getNumber();
        PdfObject stream = reader.getPdfObject(xrefIndex);
        // Exception occurs here :
        PdfImageObject pdfImage = new PdfImageObject((PRStream)stream);
        BufferedImage img = pdfImage.getBufferedImage();

        // Do something with the image
        result.add(img);
    }
    return result;
}
 

static Map<Integer, File> retrieveFolders(PdfReader reader, File baseDir) throws DocumentException
{
    Map<Integer, File> result = new HashMap<Integer, File>();

    PdfDictionary root = reader.getCatalog();
    PdfDictionary collection = root.getAsDict(PdfName.COLLECTION);
    if (collection == null)
        throw new DocumentException("Document has no Collection dictionary");
    PdfDictionary folders = collection.getAsDict(FOLDERS);
    if (folders == null)
        throw new DocumentException("Document collection has no folders dictionary");
    
    collectFolders(result, folders, baseDir);

    return result;
}
 

/**
 * <a href="http://stackoverflow.com/questions/34394199/i-cant-rotate-my-page-from-existing-pdf">
 * I can't rotate my page from existing PDF
 * </a>
 * <p>
 * Switching between portrait and landscape like this obviously will cut off some parts of the page.
 * </p>
 */
@Test
public void testSwitchOrientation() throws DocumentException, IOException
{
    try (InputStream resourceStream = getClass().getResourceAsStream("/mkl/testarea/itext5/extract/n2013.00849449.pdf"))
    {
        PdfReader reader = new PdfReader(resourceStream);
        int n = reader.getNumberOfPages();
        PdfDictionary pageDict;
        for (int i = 1; i <= n; i++) {
            Rectangle rect = reader.getPageSize(i);
            Rectangle crop = reader.getCropBox(i);
            pageDict = reader.getPageN(i);
            pageDict.put(PdfName.MEDIABOX, new PdfArray(new float[] {rect.getBottom(), rect.getLeft(), rect.getTop(), rect.getRight()}));
            pageDict.put(PdfName.CROPBOX, new PdfArray(new float[] {crop.getBottom(), crop.getLeft(), crop.getTop(), crop.getRight()}));
        }
        PdfStamper stamper = new PdfStamper(reader, new FileOutputStream(new File(RESULT_FOLDER, "n2013.00849449-switch.pdf")));
        stamper.close();
        reader.close();
    }
}
 

/**
 * <p>
 * These two methods ({@link #extractAttachmentsWithFolders(PdfReader, String)} and
 * {@link #extractAttachment(PdfReader, Map, PdfString, PdfDictionary)}) extend the
 * functionality of the OP's original code posted in his question. They extract files
 * with the folder structure.
 * </p>
 * <p>
 * The information concerning the portfolio folder structure is retrieved using
 * the method {@link #retrieveFolders(PdfReader, File)} and its helper method
 * {@link #collectFolders(Map, PdfDictionary, File)}.
 * </p>
 */
public static void extractAttachmentsWithFolders(PdfReader reader, String dir) throws IOException, DocumentException
{
    File folder = new File(dir);
    folder.mkdirs();

    Map<Integer, File> folders = retrieveFolders(reader, folder);

    PdfDictionary root = reader.getCatalog();

    PdfDictionary names = root.getAsDict(PdfName.NAMES);
    System.out.println("" + names.getKeys().toString());
    PdfDictionary embedded = names.getAsDict(PdfName.EMBEDDEDFILES);
    System.out.println("" + embedded.toString());

    PdfArray filespecs = embedded.getAsArray(PdfName.NAMES);

    for (int i = 0; i < filespecs.size();)
    {
        extractAttachment(reader, folders, folder, filespecs.getAsString(i++), filespecs.getAsDict(i++));
    }
}
 

/**
 * These two methods ({@link #extractAttachments(PdfReader, String)} and
 * {@link #extractAttachment(PdfReader, File, PdfString, PdfDictionary)})
 * essentially are the OP's original code posted in his question. They
 * extract files without the folder structure.
 */
public static void extractAttachments(PdfReader reader, String dir) throws IOException
{
    File folder = new File(dir);
    folder.mkdirs();

    PdfDictionary root = reader.getCatalog();

    PdfDictionary names = root.getAsDict(PdfName.NAMES);
    System.out.println("" + names.getKeys().toString());
    PdfDictionary embedded = names.getAsDict(PdfName.EMBEDDEDFILES);
    System.out.println("" + embedded.toString());

    PdfArray filespecs = embedded.getAsArray(PdfName.NAMES);

    //System.out.println(filespecs.getAsString(root1));
    for (int i = 0; i < filespecs.size();)
    {
        extractAttachment(reader, folder, filespecs.getAsString(i++), filespecs.getAsDict(i++));
    }
}
 

/**
 * <a href="http://stackoverflow.com/questions/43870545/filling-a-pdf-with-itextsharp-and-then-hiding-the-base-layer">
 * Filling a PDF with iTextsharp and then hiding the base layer
 * </a>
 * <p>
 * This test shows how to remove all content.
 * </p>
 */
@Test
public void testRemoveContent() throws IOException, DocumentException
{
    try (   InputStream resource = getClass().getResourceAsStream("document.pdf");
            OutputStream result = new FileOutputStream(new File(RESULT_FOLDER, "document-removedContent.pdf")))
    {
        PdfReader pdfReader = new PdfReader(resource);
        for (int page = 1; page <= pdfReader.getNumberOfPages(); page++)
        {
            PdfDictionary pageDictionary = pdfReader.getPageN(page);
            pageDictionary.remove(PdfName.CONTENTS);
        }
        new PdfStamper(pdfReader, result).close();
    }
}
 

void updateTransparencyFrom(PdfName gsName) {
    PdfDictionary extGState = getGraphicsStateDictionary(gsName);
    if (extGState != null) {
        PdfNumber number = extGState.getAsNumber(PdfName.ca);
        if (number != null)
            nonStrokingAlpha = number.floatValue();
        number = extGState.getAsNumber(PdfName.CA);
        if (number != null)
            strokingAlpha = number.floatValue();
    }
}
 

/**
 * This method checks the signatures referenced from the AcroForm Fields.  
 */
void verify(PdfReader reader) throws GeneralSecurityException
{
    PdfDictionary top = (PdfDictionary)PdfReader.getPdfObjectRelease(reader.getCatalog().get(PdfName.ACROFORM));
    if (top == null)
    {
        System.out.println("No AcroForm, so nothing to verify");
        return;
    }

    PdfArray arrfds = (PdfArray)PdfReader.getPdfObjectRelease(top.get(PdfName.FIELDS));
    if (arrfds == null || arrfds.isEmpty())
    {
        System.out.println("No AcroForm Fields, so nothing to verify");
        return;
    }

    for (PdfObject object : arrfds)
    {
        object = PdfReader.getPdfObject(object);
        if (object == null)
        {
            System.out.println("* A null entry.");
        }
        else if (!object.isDictionary())
        {
            System.out.println("* A non-dictionary entry.");
        }
        else
        {
            verify(reader, (PdfDictionary) object, null, null, null, false);
        }
    }
}
 

/**
 * <a href="http://stackoverflow.com/questions/37027579/how-to-associate-a-previous-signature-in-a-new-signature-field">
 * How to associate a previous signature in a new signature field
 * </a>
 * <br/>
 * <span>BLANK-signed.pdf, <em>a blank file from elsewhere with an invisible signature.</em></span>
 * <p>
 * Quite surprisingly it turns out that changing the signature appearance is possible without
 * breaking the signature, merely a warning appears which can be hidden by simply signing again.
 * </p>
 */
@Test
public void testChangeAppearances() throws IOException, DocumentException
{
    try (   InputStream resource = getClass().getResourceAsStream("BLANK-signed.pdf");
            OutputStream result = new FileOutputStream(new File(RESULT_FOLDER, "BLANK-signed-app.pdf")))
    {
        PdfReader pdfReader = new PdfReader(resource);
        PdfStamper pdfStamper = new PdfStamper(pdfReader, result, '\0', true);

        AcroFields acroFields = pdfStamper.getAcroFields();
        for (String signatureName : acroFields.getSignatureNames())
        {
            Item field = acroFields.getFieldItem(signatureName);
            field.writeToAll(PdfName.RECT, new PdfArray(new int[]{100,100,200,200}), Item.WRITE_WIDGET);
            field.markUsed(acroFields, Item.WRITE_WIDGET);
            
            PdfAppearance appearance = PdfAppearance.createAppearance(pdfStamper.getWriter(), 100, 100);
            appearance.setColorStroke(BaseColor.RED);
            appearance.moveTo(0, 0);
            appearance.lineTo(99, 99);
            appearance.moveTo(0, 99);
            appearance.lineTo(99, 0);
            appearance.stroke();
            
            PdfDictionary appDict = new PdfDictionary();
            appDict.put(PdfName.N, appearance.getIndirectReference());
            field.writeToAll(PdfName.AP, appDict, Item.WRITE_WIDGET);
        }

        pdfStamper.close();
    }
}
 

/**
 * Copied from {@link AcroFields#verifySignature(String, String)} and changed to work on the
 * given signature dictionary.
 */
public PdfPKCS7 verifySignature(PdfReader reader, PdfDictionary v, String provider) {
    if (v == null)
        return null;
    try {
        PdfName sub = v.getAsName(PdfName.SUBFILTER);
        PdfString contents = v.getAsString(PdfName.CONTENTS);
        PdfPKCS7 pk = null;
        if (sub.equals(PdfName.ADBE_X509_RSA_SHA1)) {
            PdfString cert = v.getAsString(PdfName.CERT);
            if (cert == null)
                cert = v.getAsArray(PdfName.CERT).getAsString(0);
            pk = new PdfPKCS7(contents.getOriginalBytes(), cert.getBytes(), provider);
        }
        else
            pk = new PdfPKCS7(contents.getOriginalBytes(), sub, provider);
        updateByteRange(reader, pk, v);
        PdfString str = v.getAsString(PdfName.M);
        if (str != null)
            pk.setSignDate(PdfDate.decode(str.toString()));
        PdfObject obj = PdfReader.getPdfObject(v.get(PdfName.NAME));
        if (obj != null) {
          if (obj.isString())
            pk.setSignName(((PdfString)obj).toUnicodeString());
          else if(obj.isName())
            pk.setSignName(PdfName.decodeName(obj.toString()));
        }
        str = v.getAsString(PdfName.REASON);
        if (str != null)
            pk.setReason(str.toUnicodeString());
        str = v.getAsString(PdfName.LOCATION);
        if (str != null)
            pk.setLocation(str.toUnicodeString());
        return pk;
    }
    catch (Exception e) {
        throw new ExceptionConverter(e);
    }
}
 

/**
 * This methods creates a copy of the source document containing each page twice,
 * once with the cropbox limited to the left half page, once to the right one.
 */
void splitIntoHalfPages(InputStream source, File target) throws IOException, DocumentException
{
    final PdfReader reader = new PdfReader(source);
    
    try (   OutputStream targetStream = new FileOutputStream(target)    )
    {
        Document document = new Document();
        PdfCopy copy = new PdfCopy(document, targetStream);
        document.open();

        for (int page = 1; page <= reader.getNumberOfPages(); page++)
        {
            PdfDictionary pageN = reader.getPageN(page);
            Rectangle cropBox = reader.getCropBox(page);
            PdfArray leftBox = new PdfArray(new float[]{cropBox.getLeft(), cropBox.getBottom(), (cropBox.getLeft() + cropBox.getRight()) / 2.0f, cropBox.getTop()});
            PdfArray rightBox = new PdfArray(new float[]{(cropBox.getLeft() + cropBox.getRight()) / 2.0f, cropBox.getBottom(), cropBox.getRight(), cropBox.getTop()});

            PdfImportedPage importedPage = copy.getImportedPage(reader, page);
            pageN.put(PdfName.CROPBOX, leftBox);
            copy.addPage(importedPage);
            pageN.put(PdfName.CROPBOX, rightBox);
            copy.addPage(importedPage);
        }
        
        document.close();
    }
    finally
    {
        reader.close();
    }
}
 

@Test
public void testWithStamperExtFinder() throws DocumentException, IOException
{
    InputStream resourceStream = getClass().getResourceAsStream("test.pdf");
    try
    {
        PdfReader reader = new PdfReader(resourceStream);
        PdfStamper stamper = new PdfStamper(reader, new FileOutputStream(new File(RESULT_FOLDER, "test-trimmed-stamper-ext.pdf")));
        
        // Go through all pages
        int n = reader.getNumberOfPages();
        for (int i = 1; i <= n; i++)
        {
            Rectangle pageSize = reader.getPageSize(i);
            Rectangle rect = getOutputPageSize4(pageSize, reader, i);

            PdfDictionary page = reader.getPageN(i);
            page.put(PdfName.CROPBOX, new PdfArray(new float[]{rect.getLeft(), rect.getBottom(), rect.getRight(), rect.getTop()}));
            stamper.markUsed(page);
        }
        stamper.close();
    }
    finally
    {
        if (resourceStream != null)
            resourceStream.close();
    }
}
 

@Test
public void testWithStamperCentered() throws DocumentException, IOException
{
    InputStream resourceStream = getClass().getResourceAsStream("test.pdf");
    try
    {
        PdfReader reader = new PdfReader(resourceStream);
        PdfStamper stamper = new PdfStamper(reader, new FileOutputStream(new File(RESULT_FOLDER, "test-trimmed-stamper-centered.pdf")));
        
        // Go through all pages
        int n = reader.getNumberOfPages();
        for (int i = 1; i <= n; i++)
        {
            Rectangle pageSize = reader.getPageSize(i);
            Rectangle rect = getOutputPageSize3(pageSize, reader, i);

            PdfDictionary page = reader.getPageN(i);
            page.put(PdfName.CROPBOX, new PdfArray(new float[]{rect.getLeft(), rect.getBottom(), rect.getRight(), rect.getTop()}));
            stamper.markUsed(page);
        }
        stamper.close();
    }
    finally
    {
        if (resourceStream != null)
            resourceStream.close();
    }
}
 

@Test
public void testWithStamperTopBottom() throws DocumentException, IOException
{
    InputStream resourceStream = getClass().getResourceAsStream("test.pdf");
    try
    {
        PdfReader reader = new PdfReader(resourceStream);
        PdfStamper stamper = new PdfStamper(reader, new FileOutputStream(new File(RESULT_FOLDER, "test-trimmed-stamper-top-bottom.pdf")));
        
        // Go through all pages
        int n = reader.getNumberOfPages();
        for (int i = 1; i <= n; i++)
        {
            Rectangle pageSize = reader.getPageSize(i);
            Rectangle rect = getOutputPageSize2(pageSize, reader, i);

            PdfDictionary page = reader.getPageN(i);
            page.put(PdfName.CROPBOX, new PdfArray(new float[]{rect.getLeft(), rect.getBottom(), rect.getRight(), rect.getTop()}));
            stamper.markUsed(page);
        }
        stamper.close();
    }
    finally
    {
        if (resourceStream != null)
            resourceStream.close();
    }
}
 

@Test
public void testWithStamper() throws DocumentException, IOException
{
    InputStream resourceStream = getClass().getResourceAsStream("test.pdf");
    try
    {
        PdfReader reader = new PdfReader(resourceStream);
        PdfStamper stamper = new PdfStamper(reader, new FileOutputStream(new File(RESULT_FOLDER, "test-trimmed-stamper.pdf")));
        
        // Go through all pages
        int n = reader.getNumberOfPages();
        for (int i = 1; i <= n; i++)
        {
            Rectangle pageSize = reader.getPageSize(i);
            Rectangle rect = getOutputPageSize(pageSize, reader, i);

            PdfDictionary page = reader.getPageN(i);
            page.put(PdfName.CROPBOX, new PdfArray(new float[]{rect.getLeft(), rect.getBottom(), rect.getRight(), rect.getTop()}));
            stamper.markUsed(page);
        }
        stamper.close();
    }
    finally
    {
        if (resourceStream != null)
            resourceStream.close();
    }
}
 

/**
 * <a href="http://stackoverflow.com/questions/37748346/extract-text-with-itext-not-works-encoding-or-crypted-text">
 * Extract text with iText not works: encoding or crypted text?
 * </a>
 * <br/>
 * <a href="https://dl.dropboxusercontent.com/u/6413030/pb.pdf">
 * pb.pdf
 * </a>
 * <p>
 * The document has not been provided by the OP but by
 * <a href="http://stackoverflow.com/users/1127485/sschuberth">sschuberth</a>
 * in a comment.
 * </p>
 * <p>
 * In contrast to {@link #testPb()}, we here first remove the <b>ToUnicode</b>
 * tables of the fonts. And indeed, now extraction succeeds.
 * </p>
 */
@Test
public void testPbNoToUnicode() throws Exception
{
    InputStream resourceStream = getClass().getResourceAsStream("pb.pdf");
    try
    {
        PdfReader reader = new PdfReader(resourceStream);
        for (int i = 1; i <= reader.getNumberOfPages(); i++)
        {
            PdfDictionary pageResources = reader.getPageResources(i);
            if (pageResources == null)
                continue;
            PdfDictionary pageFonts = pageResources.getAsDict(PdfName.FONT); 
            if (pageFonts == null)
                continue;
            for (PdfName key : pageFonts.getKeys())
            {
                PdfDictionary fontDictionary = pageFonts.getAsDict(key);
                fontDictionary.put(PdfName.TOUNICODE, null);
            }
        }

        String content = extractAndStore(reader, new File(RESULT_FOLDER, "pb-noToUnicode.%s.txt").toString());

        System.out.println("\nText pb.pdf without ToUnicode\n************************");
        System.out.println(content);
        System.out.println("************************");
    }
    finally
    {
        if (resourceStream != null)
            resourceStream.close();
    }
}
 

/**
 * <a href="http://stackoverflow.com/questions/37275267/how-to-make-pdf-annotation-as-read-only-using-itext">
 * how to make pdf annotation as read only using itext?
 * </a>
 * <br/>
 * test-annotated.pdf <i>simple PDF with sticky note</i>
 * 
 * <p>
 * This test shows how to set the read-only flags of all annotations of a document.
 * </p>
 */
@Test
public void testMarkAnnotationsReadOnly() throws IOException, DocumentException
{
    try (   InputStream resourceStream = getClass().getResourceAsStream("test-annotated.pdf");
            OutputStream outputStream = new FileOutputStream(new File(RESULT_FOLDER, "test-annotated-ro.pdf"))    )
    {
        PdfReader reader = new PdfReader(resourceStream);
        PdfStamper stamper = new PdfStamper(reader, outputStream);

        for (int page = 1; page <= reader.getNumberOfPages(); page++)
        {
            PdfDictionary pageDictionary = reader.getPageN(page);
            PdfArray annotationArray = pageDictionary.getAsArray(PdfName.ANNOTS);
            if (annotationArray == null)
                continue;
            for (PdfObject object : annotationArray)
            {
                PdfObject directObject = PdfReader.getPdfObject(object);
                if (directObject instanceof PdfDictionary)
                {
                    PdfDictionary annotationDictionary = (PdfDictionary) directObject;
                    PdfNumber flagsNumber = annotationDictionary.getAsNumber(PdfName.F);
                    int flags = flagsNumber != null ? flagsNumber.intValue() : 0;
                    flags |= PdfAnnotation.FLAGS_READONLY;
                    annotationDictionary.put(PdfName.F, new PdfNumber(flags));
                }
            }
        }

        stamper.close();
    }
}
 

/**
 * <a href="http://stackoverflow.com/questions/31402602/how-to-rename-only-the-first-found-duplicate-acrofield-in-pdf">
 * How to rename only the first found duplicate acrofield in pdf?
 * </a>
 * <br>
 * <a href="http://s000.tinyupload.com/index.php?file_id=34970992934525199618">
 * test_duplicate_field2.pdf
 * </a>
 * <p>
 * Demonstration of how to transform generate a new field for a widget.
 * </p> 
 */
@Test
public void testWidgetToField() throws IOException, DocumentException
{
    try (   InputStream resource = getClass().getResourceAsStream("test_duplicate_field2.pdf");
            OutputStream result = new FileOutputStream(new File(RESULT_FOLDER, "test_duplicate_field2-widgetToField.pdf"))   )
    {
        PdfReader reader = new PdfReader(resource);

        PdfDictionary form = reader.getCatalog().getAsDict(PdfName.ACROFORM);
        PdfArray fields = form.getAsArray(PdfName.FIELDS);
        for (PdfObject object: fields)
        {
            PdfDictionary field = (PdfDictionary) PdfReader.getPdfObject(object);
            if ("Text1".equals(field.getAsString(PdfName.T).toString()))
            {
                PdfDictionary newField = new PdfDictionary();
                PRIndirectReference newFieldRef = reader.addPdfObject(newField);
                fields.add(newFieldRef);
                newField.putAll(field);
                newField.put(PdfName.T, new PdfString("foobar"));
                PdfArray newKids = new PdfArray();
                newField.put(PdfName.KIDS, newKids);
                PdfArray kids = field.getAsArray(PdfName.KIDS);
                PdfObject widget = kids.remove(0);
                newKids.add(widget);
                PdfDictionary widgetDict = (PdfDictionary) PdfReader.getPdfObject(widget);
                widgetDict.put(PdfName.PARENT, newFieldRef);
                break;
            }
        }

        PdfStamper stamper = new PdfStamper(reader, result);
        stamper.close();
    }
}
 

void show(FdfReader fdfReader)
{
    PdfDictionary catalog = fdfReader.getCatalog();
    catalog = catalog.getAsDict(PdfName.FDF);
    Assert.assertNotNull("FDF catalogue is null", catalog);
    PdfArray annots = catalog.getAsArray(PdfName.ANNOTS);
    Assert.assertNotNull("FDF annotations are null", annots);
    System.out.println(annots);
}
 

/**
 * <p>
 * A primitive attempt at copying links from page <code>sourcePage</code>
 * of <code>PdfReader reader</code> to page <code>targetPage</code> of
 * <code>PdfStamper stamper</code>.
 * </p>
 * <p>
 * This method is meant only for the use case at hand, i.e. copying a link
 * to an external URI without expecting any advanced features.
 * </p>
 */
void copyLinks(PdfStamper stamper, int targetPage, PdfReader reader, int sourcePage)
{
    PdfDictionary sourcePageDict = reader.getPageNRelease(sourcePage);
    PdfArray annotations = sourcePageDict.getAsArray(PdfName.ANNOTS);
    if (annotations != null && annotations.size() > 0)
    {
        for (PdfObject annotationObject : annotations)
        {
            annotationObject = PdfReader.getPdfObject(annotationObject);
            if (!annotationObject.isDictionary())
                continue;
            PdfDictionary annotation = (PdfDictionary) annotationObject;
            if (!PdfName.LINK.equals(annotation.getAsName(PdfName.SUBTYPE)))
                continue;

            PdfArray rectArray = annotation.getAsArray(PdfName.RECT);
            if (rectArray == null || rectArray.size() < 4)
                continue;
            Rectangle rectangle = PdfReader.getNormalizedRectangle(rectArray);

            PdfName hightLight = annotation.getAsName(PdfName.H);
            if (hightLight == null)
                hightLight = PdfAnnotation.HIGHLIGHT_INVERT;

            PdfDictionary actionDict = annotation.getAsDict(PdfName.A);
            if (actionDict == null || !PdfName.URI.equals(actionDict.getAsName(PdfName.S)))
                continue;
            PdfString urlPdfString = actionDict.getAsString(PdfName.URI);
            if (urlPdfString == null)
                continue;
            PdfAction action = new PdfAction(urlPdfString.toString());

            PdfAnnotation link = PdfAnnotation.createLink(stamper.getWriter(), rectangle, hightLight, action);
            stamper.addAnnotation(link, targetPage);
        }
    }
}
 

@Override
public void renderText(TextRenderInfo renderInfo)
{
    DocumentFont font =renderInfo.getFont();
    PdfDictionary dict = font.getFontDictionary();
    PdfDictionary encoding = dict.getAsDict(PdfName.ENCODING);
    PdfArray diffs = encoding.getAsArray(PdfName.DIFFERENCES);

    ;
    StringBuilder builder = new StringBuilder();
    for (byte b : renderInfo.getPdfString().getBytes())
    {
        PdfName name = diffs.getAsName((char)b);
        String s = name.toString().substring(2);
        int i = Integer.parseUnsignedInt(s, 16);
        builder.append((char)i);
    }

    try
    {
        stringField.set(renderInfo, builder.toString());
    }
    catch (IllegalArgumentException | IllegalAccessException e)
    {
        e.printStackTrace();
    }
    strategy.renderText(renderInfo);
}
 

static void collectFolders(Map<Integer, File> collection, PdfDictionary folder, File baseDir)
{
    PdfString name = folder.getAsString(PdfName.NAME);
    File folderDir = new File(baseDir, name.toString());
    folderDir.mkdirs();
    PdfNumber id = folder.getAsNumber(PdfName.ID);
    collection.put(id.intValue(), folderDir);

    PdfDictionary next = folder.getAsDict(PdfName.NEXT);
    if (next != null)
        collectFolders(collection, next, baseDir);
    PdfDictionary child = folder.getAsDict(CHILD);
    if (child != null)
        collectFolders(collection, child, folderDir);
}
 

/**
 * This method edits the immediate contents of a page, i.e. its content stream.
 * It explicitly does not descent into form xobjects, patterns, or annotations.
 */
public void editPage(PdfStamper pdfStamper, int pageNum) throws IOException {
    PdfReader pdfReader = pdfStamper.getReader();
    PdfDictionary page = pdfReader.getPageN(pageNum);
    byte[] pageContentInput = ContentByteUtils.getContentBytesForPage(pdfReader, pageNum);
    page.remove(PdfName.CONTENTS);
    editContent(pageContentInput, page.getAsDict(PdfName.RESOURCES), pdfStamper.getUnderContent(pageNum));
}
 

private static void cropMultipliedFile(File source, CropJob cropJob) throws DocumentException,
    IOException {

    PdfReader reader = new PdfReader(source.getAbsolutePath());
    PdfStamper stamper = new PdfStamper(reader, new FileOutputStream(cropJob.getDestinationFile()));
    stamper.setMoreInfo(cropJob.getSourceMetaInfo());

    PdfDictionary pageDict;
    int newPageNumber = 1;
    for (int origPageNumber = 1; origPageNumber <= cropJob.getSourcePageCount(); origPageNumber++) {
        SingleCluster cluster = cropJob.getClusterCollection().getSingleCluster(origPageNumber);

        // if no crop was selected do nothing
        if (cluster.getRatiosList().size() == 0) {
            newPageNumber++;
            continue;
        }

        for (Float[] ratios : cluster.getRatiosList()) {

            pageDict = reader.getPageN(newPageNumber);

            List<Rectangle> boxes = new ArrayList<Rectangle>();
            boxes.add(reader.getBoxSize(newPageNumber, "media"));
            boxes.add(reader.getBoxSize(newPageNumber, "crop"));
            int rotation = reader.getPageRotation(newPageNumber);

            Rectangle scaledBox = calculateScaledRectangle(boxes, ratios, rotation);

            PdfArray scaleBoxArray = new PdfArray();
            scaleBoxArray.add(new PdfNumber(scaledBox.getLeft()));
            scaleBoxArray.add(new PdfNumber(scaledBox.getBottom()));
            scaleBoxArray.add(new PdfNumber(scaledBox.getRight()));
            scaleBoxArray.add(new PdfNumber(scaledBox.getTop()));

            pageDict.put(PdfName.CROPBOX, scaleBoxArray);
            pageDict.put(PdfName.MEDIABOX, scaleBoxArray);
            // increment the pagenumber
            newPageNumber++;
        }
        int[] range = new int[2];
        range[0] = newPageNumber - 1;
        range[1] = cropJob.getSourcePageCount() + (newPageNumber - origPageNumber);
        SimpleBookmark.shiftPageNumbers(cropJob.getSourceBookmarks(), cluster.getRatiosList().size() - 1, range);
    }
    stamper.setOutlines(cropJob.getSourceBookmarks());
    stamper.close();
    reader.close();
}
 

private static void cropMultipliedFile(final CropDefinition cropDefinition, final File multipliedDocument,
                                       final PdfMetaInformation pdfMetaInformation) throws DocumentException, IOException {

    PdfReader reader = new PdfReader(multipliedDocument.getAbsolutePath());

    PdfStamper stamper = new PdfStamper(reader, new FileOutputStream(cropDefinition.getDestinationFile()));
    stamper.setMoreInfo(pdfMetaInformation.getSourceMetaInfo());

    PdfDictionary pageDict;
    int newPageNumber = 1;

    for (int sourcePageNumber = 1; sourcePageNumber <= pdfMetaInformation.getSourcePageCount(); sourcePageNumber++) {

        List<Float[]> rectangleList = cropDefinition.getRectanglesForPage(sourcePageNumber);

        // if no crop was selected do nothing
        if (rectangleList.isEmpty()) {
            newPageNumber++;
            continue;
        }

        for (Float[] ratios : rectangleList) {

            pageDict = reader.getPageN(newPageNumber);

            List<Rectangle> boxes = new ArrayList<Rectangle>();
            boxes.add(reader.getBoxSize(newPageNumber, "media"));
            boxes.add(reader.getBoxSize(newPageNumber, "crop"));
            int rotation = reader.getPageRotation(newPageNumber);

            Rectangle scaledBox = RectangleHandler.calculateScaledRectangle(boxes, ratios, rotation);

            PdfArray scaleBoxArray = createScaledBoxArray(scaledBox);

            pageDict.put(PdfName.CROPBOX, scaleBoxArray);
            pageDict.put(PdfName.MEDIABOX, scaleBoxArray);
            // increment the pagenumber
            newPageNumber++;
        }
        int[] range = new int[2];
        range[0] = newPageNumber - 1;
        range[1] = pdfMetaInformation.getSourcePageCount() + (newPageNumber - sourcePageNumber);
        SimpleBookmark.shiftPageNumbers(pdfMetaInformation.getSourceBookmarks(), rectangleList.size() - 1, range);
    }
    stamper.setOutlines(pdfMetaInformation.getSourceBookmarks());
    stamper.close();
    reader.close();
}
 

boolean verify(PdfReader reader, PdfDictionary value) throws GeneralSecurityException
{
    PdfArray byteRange = value.getAsArray(PdfName.BYTERANGE);
    if (byteRange == null || byteRange.isEmpty())
    {
        System.out.printf("  Signed range: missing\n");
    }
    else
    {
        StringBuilder builder = new StringBuilder();
        builder.append("  Signed range:");
        for (PdfObject arrObj: byteRange)
        {
            builder.append(' ').append(arrObj);
        }
        int byteRangeSize = byteRange.size();
        if (byteRangeSize % 2 == 1)
        {
            builder.append(" (Invalid: odd number of entries)");
        }
        else
        {
            StringBuilder interoperability = new StringBuilder();
            if (byteRangeSize != 4)
            {
                interoperability.append(", not exactly one gap");
            }
            int rangeStart = byteRange.getAsNumber(0).intValue();
            if (rangeStart != 0)
            {
                interoperability.append(", first range does not start at 0");
            }
            for (int i = 2; i < byteRangeSize; i+=2)
            {
                int lastRangeEnd = rangeStart + byteRange.getAsNumber(i-1).intValue();
                rangeStart = byteRange.getAsNumber(i).intValue();
                if (lastRangeEnd > rangeStart)
                {
                    interoperability.append(", unordered or overlapping ranges");
                    break;
                }
            }
            if (interoperability.length() > 0)
            {
                builder.append(" (Interoperability issues").append(interoperability).append(')');
            }
            int finalRangeEnd = byteRange.getAsNumber(byteRangeSize-2).intValue() + byteRange.getAsNumber(byteRangeSize-1).intValue();
            if (finalRangeEnd == reader.getFileLength())
            {
                builder.append(" (covers whole file)");
            }
            else
            {
                builder.append(" (covers partial file up to ").append(finalRangeEnd).append(")");
            }
        }
        System.out.println(builder);
    }

    PdfPKCS7 pkcs7 = verifySignature(reader, value, null);
    System.out.printf("  Validity: %s\n", pkcs7.verify());
    return pkcs7 != null;
}
 

void verify(PdfReader reader, PdfObject object, String baseName, PdfName baseType, PdfObject baseValue, boolean processed) throws GeneralSecurityException
{
    if (object == null)
    {
        System.out.println("* A null entry.");
    }
    else if (!object.isDictionary())
    {
        System.out.println("* A non-dictionary entry.");
    }
    else
    {
        PdfDictionary field = (PdfDictionary) object;
        
        String name;
        PdfName type;
        PdfObject value;

        PdfString partialObject = field.getAsString(PdfName.T);
        if (partialObject == null)
        {
            System.out.println("* An anonymous entry.");
            name = baseName;
        }
        else
        {
            String partial = partialObject.toString();
            System.out.printf("* A named entry: %s\n", partial);
            name = baseName == null ? partial : String.format("%s:%s", baseName, partial);
        }
        System.out.printf("  FQP: %s\n", name == null ? "" : name);

        PdfName typeHere = field.getAsName(PdfName.FT);
        if (typeHere != null)
        {
            type = typeHere;
            System.out.printf("  Type: %s\n", type);
        }
        else
        {
            type = baseType;
            if (type == null)
            {
                System.out.printf("  Type: -\n");
            }
            else
            {
                System.out.printf("  Type: %s (inherited)\n", type);
            }
        }

        PdfObject valueHere = field.getDirectObject(PdfName.V);
        if (valueHere != null)
        {
            value = valueHere;
            processed = false;
            System.out.printf("  Value: present\n");
        }
        else
        {
            value = baseValue;
            if (value == null)
            {
                System.out.printf("  Value: -\n");
            }
            else
            {
                System.out.printf("  Value: inherited\n");
            }
        }

        if (PdfName.SIG.equals(type) && value instanceof PdfDictionary && !processed)
        {
            processed = verify(reader, (PdfDictionary) value);
        }

        PdfArray kids = field.getAsArray(PdfName.KIDS);
        if (kids != null)
        {
            for (PdfObject kid : kids)
            {
                verify(reader, kid, name, type, value, processed);
            }
        }
    }
}
 

@Test
public void testComplex() throws FileNotFoundException, DocumentException
{
    Document document = new Document();
    PdfWriter writer = PdfWriter.getInstance(document, new FileOutputStream(new File(RESULT_FOLDER, "transparencyComplex.pdf")));
    writer.setCompressionLevel(0);
    document.open();
    PdfContentByte content = writer.getDirectContent();

    content.setRGBColorStroke(0, 255, 0);
    for (int y = 0; y <= 400; y+= 10)
    {
        content.moveTo(0, y);
        content.lineTo(500, y);
    }
    for (int x = 0; x <= 500; x+= 10)
    {
        content.moveTo(x, 0);
        content.lineTo(x, 400);
    }
    content.stroke();

    PdfTemplate template = content.createTemplate(500, 400);
    PdfTransparencyGroup group = new PdfTransparencyGroup();
    group.put(PdfName.CS, PdfName.DEVICEGRAY);
    group.setIsolated(false);
    group.setKnockout(false);
    template.setGroup(group);
    PdfShading radial = PdfShading.simpleRadial(writer, 262, 186, 10, 262, 186, 190, BaseColor.WHITE, BaseColor.BLACK, true, true);
    template.paintShading(radial);

    PdfDictionary mask = new PdfDictionary();
    mask.put(PdfName.TYPE, PdfName.MASK);
    mask.put(PdfName.S, new PdfName("Luminosity"));
    mask.put(new PdfName("G"), template.getIndirectReference());

    content.saveState();
    PdfGState state = new PdfGState();
    state.put(PdfName.SMASK, mask);
    content.setGState(state);
    content.setRGBColorFill(255, 0, 0);
    content.moveTo(162, 86);
    content.lineTo(162, 286);
    content.lineTo(362, 286);
    content.lineTo(362, 86);
    content.closePath();
    //content.fillStroke();
    content.fill();
    
    content.restoreState();

    document.close();
}
 

/**
 * <a href="https://stackoverflow.com/questions/49370352/how-do-i-get-a-get-destination-page-of-a-link-in-pdf-file">
 * How do I get a get destination page of a link in PDF file?
 * </a>
 * <br/>
 * local-link.pdf - output of the test {@link CreateLink}.
 * <p>
 * This test shows how to access data of the target page, once by
 * directly reading from the page dictionary referenced from the
 * link destination, once by first determining the page number and
 * then using {@link PdfReader} helper methods.
 * </p>
 */
@Test
public void testDetermineTargetPage() throws IOException {
    try (   InputStream src = getClass().getResourceAsStream("local-link.pdf")  ) {
        PdfReader reader = new PdfReader(src);
        PdfDictionary page = reader.getPageN(1);
        PdfArray annots = page.getAsArray(PdfName.ANNOTS); 
        for (int i = 0; i < annots.size(); i++) {
            PdfDictionary annotation = annots.getAsDict(i);
            if (PdfName.LINK.equals(annotation.getAsName(PdfName.SUBTYPE))) {
                PdfArray d = annotation.getAsArray(PdfName.DEST);
                if (d == null) {
                    PdfDictionary action = annotation.getAsDict(PdfName.A);
                    if (action != null)
                        d = action.getAsArray(PdfName.D);
                }
                    
                if (d != null && d.size() > 0) {
                    System.out.println("Next destination -");
                    PdfIndirectReference pageReference = d.getAsIndirectObject(0);

                    // Work with target dictionary directly
                    PdfDictionary pageDict = d.getAsDict(0);
                    PdfArray boxArray = pageDict.getAsArray(PdfName.CROPBOX);
                    if (boxArray == null) {
                        boxArray = pageDict.getAsArray(PdfName.MEDIABOX);
                    }
                    Rectangle box = PdfReader.getNormalizedRectangle(boxArray);
                    System.out.printf("* Target page object %s has cropbox %s\n", pageReference, box);

                    // Work via page number
                    for (int pageNr = 1; pageNr <= reader.getNumberOfPages(); pageNr++) {
                        PRIndirectReference pp = reader.getPageOrigRef(pageNr);
                        if (pp.getGeneration() == pageReference.getGeneration() && pp.getNumber() == pageReference.getNumber()) {
                            System.out.printf("* Target page %s has cropbox %s\n", pageNr, reader.getCropBox(pageNr));
                            break;
                        }
                    }
                }
            }
        }
    }
}