How do I create an unordered list in iText 8?

By Wayan in iText PDF 0 Comment

Creating an unordered list in iText 8 involves creating a List object and adding ListItem objects to it.

Here is an example of how you can do this:

package org.kodejava.itext;

import com.itextpdf.layout.Document;
import com.itextpdf.layout.element.List;
import com.itextpdf.layout.element.ListItem;
import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.kernel.pdf.PdfWriter;

public class UnorderedListExample {
    public static void main(String[] args) throws Exception {
        PdfDocument pdfDoc = new PdfDocument(new PdfWriter("output.pdf"));
        try (Document doc = new Document(pdfDoc)) {
            // Create a List object
            List list = new List();
            list.setListSymbol("\u2022 ");

            // Add ListItems
            list.add(new ListItem("First item"));
            list.add(new ListItem("Second item"));
            list.add(new ListItem("Third item"));
            list.add(new ListItem("Fourth item"));

            // Add the list to our document
            doc.add(list);
        }
    }
}

In this code:

  • A PdfDocument object is created to write to a PDF file named “output.pdf”.
  • A Document object is created, which represents an actual PDF document.
  • A List object is created, representing the unordered list.
  • ListItem objects representing individual list items are added to the List.
  • Finally, the List is added to the Document, and the Document is automatically closed by the try-with-resource block, and flush any remaining content to the PDF.

You may put different things in your ListItem objects, and nest other List objects within them, if you wish.

Maven Dependencies

<dependency>
    <groupId>com.itextpdf</groupId>
    <artifactId>itext-core</artifactId>
    <version>8.0.2</version>
    <type>pom</type>
</dependency>

Maven Central

How do I set the indentation of a Paragraph object in iText 8?

By Wayan in iText PDF 0 Comment

In iText 8, indentation of a Paragraph can be controlled using the setMarginLeft() and setMarginRight() method of the BlockElement class which is the super class of Paragraph.

Here is an example of how to indent a paragraph:

package org.kodejava.itext;

import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.kernel.pdf.PdfWriter;
import com.itextpdf.layout.Document;
import com.itextpdf.layout.element.Paragraph;

public class ParagraphIndentation {
    public static void main(String[] args) throws Exception {
        PdfWriter writer = new PdfWriter("indentation.pdf");
        PdfDocument pdf = new PdfDocument(writer);

        try (Document document = new Document(pdf)) {
            String first = """
                    Lorem ipsum dolor sit amet, consectetur adipisicing elit, \
                    sed do eiusmod tempor incididunt ut labore et dolore magna \
                    aliqua. Ut enim ad minim veniam, quis nostrud exercitation \
                    ullamco laboris nisi ut aliquip ex ea commodo consequat. \
                    """;
            String second = """
                    Duis aute irure dolor in  reprehenderit in voluptate velit \
                    esse cillum dolore eu fugiat nulla pariatur. Excepteur sint \
                    occaecat cupidatat non proident, sunt in culpa qui officia \
                    deserunt mollit anim id est laborum.
                    """;

            Paragraph firstParagraph = new Paragraph(first);
            firstParagraph.setFirstLineIndent(60);
            firstParagraph.setMarginLeft(50);
            firstParagraph.setMarginRight(50);
            document.add(firstParagraph);

            Paragraph secondParagraph = new Paragraph(second);
            secondParagraph.setFirstLineIndent(60);
            secondParagraph.setMarginLeft(50);
            secondParagraph.setMarginRight(50);
            document.add(secondParagraph);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

In this example, setMarginLeft() and setMarginRight() methods are used to set the left and right indentation of the paragraph. These methods accept a float value as the parameter for setting the left and right indentation respectively.

The setFirstLineIndent() method in the Paragraph class sets the indentation of the first line of a Paragraph in points. This option is commonly used in document formatting where the first line of a paragraph is typically indented more than the rest of the text in the paragraph.

For example, if you set paragraph.setFirstLineIndent(60);, the first line of the text in that paragraph would be indented 60 points from the left margin.

The generated PDF document looks like this:

Paragraph Indentation

Maven Dependencies

<dependency>
    <groupId>com.itextpdf</groupId>
    <artifactId>itext-core</artifactId>
    <version>8.0.2</version>
    <type>pom</type>
</dependency>

Maven Central

How do I add a new page to a Document with iText 8?

By Wayan in iText PDF 0 Comment

In iText 8, you can use the AreaBreak class to add a new page to a Document. An AreaBreak is used to start a new area in the document. This can be compared to a page break in word processing software, but in iText, it’s a bit more flexible.

You can use AreaBreak to create different layout areas in the same page. For example, it can be used to separate a chapter or section in your document into two columns. You can also use an AreaBreak to create a new page, too.

Here’s an example of how to do it:

package org.kodejava.itext;

import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.kernel.pdf.PdfWriter;
import com.itextpdf.layout.Document;
import com.itextpdf.layout.element.AreaBreak;
import com.itextpdf.layout.element.Paragraph;

public class AreaBreakExample {
    public static void main(String[] args) throws Exception {
        PdfWriter writer = new PdfWriter("output.pdf");
        PdfDocument pdf = new PdfDocument(writer);

        // Create a document object
        try (Document document = new Document(pdf)) {
            // Add a new paragraph to the document
            document.add(new Paragraph("This is some content on Page 1"));

            // Add an area break (the new page starts here)
            document.add(new AreaBreak());

            // Add another paragraph to the document (on a new page)
            document.add(new Paragraph("This is some content on Page 2"));
        }
    }
}

In this example, the AreaBreak creates a new page before adding the second paragraph. As a result, “This is some content on Page 1” appears on the first page, while “This is some content on Page 2” appears on the second page.

While both AreaBreak and PdfDocument‘s addNewPage() method can be used to add a new page in a PDF document, they work in slightly different ways.

  • AreaBreak: This is typically used in the context of the iText Document abstraction. When you insert an AreaBreak, it tells the layout mechanism that you want to start laying out new elements in a new region (which could be a new page, or a new column, for example). This is particularly useful when adding elements like texts, images, tables, etc. sequentially to a document, and you want control over page breaks.
  • addNewPage(): This is a lower-level operation that allows you to directly interact with the PdfDocument object. This method is used when you’re not using the Document abstraction and are working directly with the PdfDocument. It provides more control over creating and customizing pages, but requires a more detailed understanding of the PDF structure.

In short, AreaBreak is generally more high-level and is useful when laying out elements via the Document abstraction, while addNewPage() is a lower-level method that offers more control but requires more detailed knowledge about the structure of PDF files.

It’s important to note that the use of one over the other depends on the specific requirements and context of your project.

Maven Dependencies

<dependency>
    <groupId>com.itextpdf</groupId>
    <artifactId>itext-core</artifactId>
    <version>8.0.2</version>
    <type>pom</type>
</dependency>

Maven Central

How to Get Started with iText 8: A Beginner’s Guide to Library and API Usage

By Wayan in iText PDF 0 Comment

iText is a highly versatile and robust library used for creating and manipulating PDF files in Java. It is capable of generating high-quality documents with complex layouts and rich multimedia content.

The ease of embedding text, images, tables, and interactive forms in PDFs make it a go-to library for developers dealing with document-intensive applications. It is programmatically accessible, providing developers with complete control over the PDF creation and manipulation process.

Another significant feature of iText is its ability to handle advanced PDF features such as watermarks, encryption, and Digital Rights Management (DRM), which make it a great tool for more complex and advanced projects. It also provides a mechanism to create bookmarks, annotations, and comments, making it easier to navigate through voluminous PDFs.

iText is a powerful library that allows developers to generate and manipulate PDF files in Java. To get started with iText 8 in your Java project, follow these steps:

In your Maven pom.xml file, add the following dependency:

<dependency>
    <groupId>com.itextpdf</groupId>
    <artifactId>itext-core</artifactId>
    <version>8.0.2</version>
    <type>pom</type>
</dependency>

Maven Central

Once you have added the iText dependency to your project, you can start using it to create PDFs. Here’s a simple example code that creates a PDF file and adds a paragraph to it:

package org.kodejava.itext;

import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.kernel.pdf.PdfWriter;
import com.itextpdf.layout.Document;
import com.itextpdf.layout.element.Paragraph;

import java.io.FileNotFoundException;

public class CreatePDFIntro {
    public static void main(String[] args) {
        try {
            PdfWriter writer = new PdfWriter("HelloWorld.pdf");
            PdfDocument pdf = new PdfDocument(writer);
            Document document = new Document(pdf);
            document.add(new Paragraph("Hello World!"));
            document.close();
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}

This code will create a file named HelloWorld.pdf in the root folder of your project, containing a single paragraph with the text “Hello, World!”.

iText offers a multitude of features, from basic ones such as adding text and images to a PDF, to more complex ones like adding bookmarks, watermarks, and securing the PDF. The official iText 8 documentation is a comprehensive resource that covers these features in great detail; it also has several examples that show how to use the library.

In addition, iText provides strong international language support. This includes various fonts and writing systems, including every Western, Middle Eastern, and Asian language.

It’s worth noting that iText prioritizes performance and memory management, which is especially advantageous when dealing with large quantities of data or high-demand environments.

Given its wide range of features and powerful capabilities, iText is a time-tested choice for generating and manipulating PDFs in Java-centric software development. However, careful attention must be given to its licensing. The open-source version of iText is offered under AGPL, which can be restrictive for some projects. Therefore, for commercial use, a commercial license is recommended.

How do I create a PDF document using iText 8?

By Wayan in iText PDF 0 Comment

iText 8 is an open source library for creating and manipulating PDF files in Java. It’s a successor to iText 7, providing more advanced features and capabilities for transforming documents into PDF format.

iText 8 supports the creation and manipulation of PDF documents, and offers various functionalities to enhance your PDF generation requirements. With iText 8 you can generate documents from scratch, or manipulate existing documents, customize the content with font styling, add tables, lists and images, generate barcodes or even forms.

Here are the steps to create a simple PDF document using iText 8 in Java:

  1. Creating a new PdfWriter object, passing the output dest (file path) as an argument.
  2. Then create a PdfDocument with the writer object as argument.
  3. Create the root Document object.
  4. Instantiate a new Paragraph object with some text and add it to the document object.
  5. Finally, close the document object which effectively creates your PDF.

The code snippet:

package org.kodejava.itext;

import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.kernel.pdf.PdfWriter;
import com.itextpdf.layout.Document;
import com.itextpdf.layout.element.Paragraph;

public class CreatePDF {
    public static void main(String[] args) {
        try {
            String dest = "./First-PDF.pdf";
            PdfWriter writer = new PdfWriter(dest);

            // Creating PDF document
            PdfDocument pdfDoc = new PdfDocument(writer);

            // Document is the default root element
            Document document = new Document(pdfDoc);
            String text = "This is the first paragraph of the PDF document created using iText 8.";

            // Creating paragraph
            Paragraph paragraph = new Paragraph(text);

            // Adding paragraph to document 
            document.add(paragraph);

            // Closing the document 
            document.close();
            System.out.println("PDF Created Successfully");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Running this code will give you the First-PDF.pdf file as a result in our current working directory. We can replace the path to an absolute file path to where ever we want to write the output file.

iText version 8 is a powerful tool that, when used correctly, can help automate document generation tasks in your applications, saving a lot of manual effort and ensuring consistency and accuracy. However, it’s important to note that while iText 8 is open-source and free to use under the AGPL license, commercial implementations require purchasing a license.

Maven Dependencies

<dependency>
    <groupId>com.itextpdf</groupId>
    <artifactId>itext-core</artifactId>
    <version>8.0.2</version>
    <type>pom</type>
</dependency>

Maven Central