Tags: JavaScript, PHP, PDF Generation, PDFMake, ApacheBox, Java, Ruby, Prawn, FPDF
This article demonstrates how to start a simple, single-purpose project and utilize PDF libraries available in different programming languages. One library is chosen for each language, and the development process is described.
For this article, four programming languages have been selected, with a single library chosen for each:
Following this article, you can start a simple command-line project in the respective programming language, install the selected PDF library as a dependency, and write code that utilizes the library to generate a custom PDF document.
Stay updated with the latest articles from our blog! Choose the tags and topics you're interested in, and we'll send you relevant content directly to your inbox.
The implementations from this article are shared in the following GitHub repositories:
To start a new project in JavaScript, it is good practice to use a package manager. Node.js comes with the "npm" package manager by default. However, Yarn can be considered a more practical alternative (subjective opinion), so in this article Yarn is used. To install Yarn globally, run the following command:
npm install -g yarnTo initialize a new Node.js project, run the following command in the directory created for this project and answer the prompted questions about the project:
yarn init
question name (create-pdf-using-javascript-and-pdfmake):
question version (1.0.0):
question description:
question entry point (index.js):
question repository url:
question author: Gradient s.p.
question license (MIT):
question private:
success Saved package.json
Done in 36.14s.At this point package.json file is generated.
package.json
{
"name": "create-pdf-using-javascript-and-pdfmake",
"version": "1.0.0",
"main": "index.js",
"author": "Gradient s.p.",
"license": "MIT"
}
The "main" field in "package.json" is used when a project is intended to be used as an npm dependency in other projects. Since we are not building a library, but final program, we can remove "main" field. Additionally, we configure a run script for our project and create a simple 'Hello World' JavaScript program.
package.json
{
"name": "create-pdf-using-javascript-and-pdfmake",
"version": "1.0.0",
"scripts": {
"start": "node src/index.js"
},
"author": "Gradient s.p.",
"license": "MIT"
}src/index.js
console.log("Hello World!");We then run it from the root of our project.
yarn start
yarn run v1.22.22
$ node src/index.js
Hello World!
Done in 0.07s.The next step is to install the PDFMake library and create a simple 'Hello World' PDF file.
Important: PDFMake requires font files to function. For this tutorial, you can download the necessary fonts here and save them in the fonts/ directory. Refer to the following source code to see which font variants are needed for this example.
yarn add pdfmake
yarn add v1.22.22
[1/4] Resolving packages...
[2/4] Fetching packages...
[3/4] Linking dependencies...
[4/4] Building fresh packages...
success Saved 1 new dependency.
info Direct dependencies
└─ pdfmake@0.2.18
info All dependencies
└─ pdfmake@0.2.18
Done in 0.47s.
src/index.js
import PdfPrinter from "pdfmake";
import * as fs from "fs";
const fonts = {
Roboto: {
normal: 'fonts/Roboto-Regular.ttf',
bold: 'fonts/Roboto-Medium.ttf',
italics: 'fonts/Roboto-Italic.ttf',
bolditalics: 'fonts/Roboto-MediumItalic.ttf'
}
};
const printer = new PdfPrinter(fonts);
const docDefinition = {
content: [
// Content goes here
{
text: "Hello World"
},
],
};
const options = {
// General Options to be configured
}
const pdfDoc = printer.createPdfKitDocument(docDefinition, options);
pdfDoc.pipe(fs.createWriteStream('document.pdf'));
pdfDoc.end();
After executing the program, we obtain a basic 'Hello World' PDF.
In PDFMake, content is defined in the docDefinition section as an array of elements that will be included in the PDF. Since the document definition is a single large JavaScript object, it is highly practical for dynamically generating the final PDF document.
One key advantage of PDFMake is its built-in handling of page breaks, which simplifies development when working with dynamically generated content, especially when the final document length is determined at runtime.
The following code demonstrates some of PDFMake’s features and builds a more complex PDF document:
src/index.js
import PdfPrinter from "pdfmake";
import * as fs from "fs";
const fonts = {
Roboto: {
normal: 'fonts/Roboto-Regular.ttf',
bold: 'fonts/Roboto-Medium.ttf',
italics: 'fonts/Roboto-Italic.ttf',
bolditalics: 'fonts/Roboto-MediumItalic.ttf'
}
};
const printer = new PdfPrinter(fonts);
const docDefinition = {
styles: {
heading: {
fontSize: 18,
bold: true,
marginBottom: 20,
marginTop: 20,
alignment: 'center'
},
content: {
margin: [20, 0, 20, 5], // [left, top, right, bottom]
alignment: 'justify',
leadingIndent: 20
}
},
content: [
// Content goes here
{
text: 'Example document created using pdfmake',
style: 'heading'
},
{
toc: {
title: {text: 'INDEX', style: 'heading'}
}
},
{
text: 'Topic 1',
style: 'heading',
tocItem: true
},
{
text: "Content of Topic 1. ".repeat(40),
style: 'content'
},
{
text: "Content of Topic 1. ".repeat(60),
style: 'content'
},
{
text: 'Topic 2',
style: 'heading',
tocItem: true
},
{
columns: [
{
text: "Content in Columns. ".repeat(25),
style: 'content'
},
{
text: "Content in Columns. ".repeat(25),
style: 'content'
}
]
},
{
text: 'Topic 3',
style: 'heading',
tocItem: true
},
{
text: 'Some Shapes',
style: 'content'
},
{
canvas:
[
{
type: 'line',
x1: 0, y1: 0,
x2: 260, y2: 60,
lineWidth: 3
},
{
type: 'polyline',
lineWidth: 3,
closePath: true,
lineColor: 'blue',
color: 'red',
points: [{ x: 310, y: 10}, { x: 335, y: 40 }, { x: 400, y: 40 }, { x: 425, y:10 }]
}
]
}
],
};
const options = {
// General Options to be configured
}
const pdfDoc = printer.createPdfKitDocument(docDefinition, options);
pdfDoc.pipe(fs.createWriteStream('document.pdf'));
pdfDoc.end();
This implementation produces following PDF document:
For more details on using and configuring PDFMake, visit their official website.
In this section, we will build a Java example project using Gradle, a Java build tool.
To initialize a new Java project, run the following command in the directory created for this project and answer the prompted questions about the project:
gradle init --type java-application
Select build script DSL:
1: Groovy
2: Kotlin
Enter selection (default: Groovy) [1..2]
Select test framework:
1: JUnit 4
2: TestNG
3: Spock
4: JUnit Jupiter
Enter selection (default: JUnit Jupiter) [1..4]
Project name (default: create-pdf-using-java-and-pdfbox):
Source package (default: create.pdf.using.java.and.pdfbox):
> Task :init
Get more help with your project: https://docs.gradle.org/7.2/samples/sample_building_java_applications.html
BUILD SUCCESSFUL in 10s
2 actionable tasks: 2 executedAs a result of the initialization, a basic 'Hello World' application is created.
App.java
/*
* This Java source file was generated by the Gradle 'init' task.
*/
package create.pdf.using.java.and.pdfbox;
public class App {
public String getGreeting() {
return "Hello World!";
}
public static void main(String[] args) {
System.out.println(new App().getGreeting());
}
}
To build the test project and run all checks, execute the Gradle build task:
./gradlew buildTo run the project (including compilation):
./gradlew run
> Task :app:run
Hello World!
BUILD SUCCESSFUL in 619ms
2 actionable tasks: 1 executed, 1 up-to-date
To ensure the same Gradle version is configured as used in this article, make sure the 'distributionUrl' parameter matches.
gradle/wrapper/gradle-wrapper.properties
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/distsAfter the correct configuration, adding the Apache PDFBox dependency is required.
app/build.gradle
... other build settings
dependencies {
... other dependencies
// https://mvnrepository.com/artifact/org.apache.pdfbox/pdfbox
implementation group: 'org.apache.pdfbox', name: 'pdfbox', version: '3.0.4'
}The build should succeed after this step (./gradlew build), and then the PDF creation implementation can be added.
App.java
package create.pdf.using.java.and.pdfbox;
import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.pdmodel.PDPage;
import org.apache.pdfbox.pdmodel.PDPageContentStream;
import org.apache.pdfbox.pdmodel.font.PDType1Font;
import org.apache.pdfbox.pdmodel.font.Standard14Fonts;
import java.io.IOException;
public class App {
public static void main(String[] args) throws IOException {
App app = new App();
final int fontSize = 12;
final int margin = 50;
final int leading = fontSize + 2;
PDDocument document = new PDDocument();
PDPage page = new PDPage();
PDPageContentStream contentStream = new PDPageContentStream(document, page);
app.drawCircle(contentStream, margin, page.getBBox().getHeight() - margin, margin, 0.8f, 0, 0);
app.drawCircle(contentStream, page.getBBox().getWidth() - margin, page.getBBox().getHeight() - margin, margin, 0, 0, 0.8f);
contentStream.beginText();
contentStream.setFont(new PDType1Font(Standard14Fonts.FontName.HELVETICA), fontSize);
contentStream.newLineAtOffset(margin, page.getBBox().getHeight() - margin);
contentStream.setLeading(leading);
contentStream.setNonStrokingColor(0, 0, 0);
for (int j = 1; j < 5; j++) {
for (int i = 1; i < 6; i++) {
StringBuilder sb = new StringBuilder();
app.drawLineOfText(contentStream, sb.append("Example Text ")
.append(i)
.append(" ")
.toString()
.repeat(i)
);
}
app.drawLineOfText(contentStream, "");
}
document.addPage(page);
contentStream.close();
document.save("my_doc.pdf");
System.out.println("PDF Created");
document.close();
}
private void drawLineOfText(PDPageContentStream contentStream, String text) throws IOException {
contentStream.showText(text);
contentStream.newLine();
}
private void drawCircle(PDPageContentStream contentStream, float cx, float cy, float r, float red, float green, float blue) throws IOException {
final float k = 0.552284749831f;
contentStream.setJavaNonStrokingColor(red, green, blue);
contentStream.moveTo(cx - r, cy);
contentStream.curveTo(cx - r, cy + k * r, cx - k * r, cy + r, cx, cy + r);
contentStream.curveTo(cx + k * r, cy + r, cx + r, cy + k * r, cx + r, cy);
contentStream.curveTo(cx + r, cy - k * r, cx + k * r, cy - r, cx, cy - r);
contentStream.curveTo(cx - k * r, cy - r, cx - r, cy - k * r, cx - r, cy);
contentStream.fill();
}
}
This implementation produces following PDF document:
In this section, we will create a Ruby example project using Bundler as a package manager.
To initialize a new Ruby project, run the following commands in the directory created for this project:
> bundle init
> bundle add prawn
> bundle install
As a result, the Gemfile should be created with content similar to the following:
Gemfile
# frozen_string_literal: true
source "https://rubygems.org"
# gem "rails"
gem "prawn", "~> 2.5"Now, create a directory named src, and inside it, create the following file for a Hello World example:
src/main.rb
# frozen_string_literal: true
require "prawn"
Prawn::Document.generate("hello.pdf") do
text "Hello World!"
endRun this program with the following command:
ruby src/main.rbAfter execution, a PDF named hello.pdf is created in the root directory. It looks as follows:
When everything is ready, we can build our PDF example using Ruby and Prawn. Here is the source code that generates it:
src/main.rb
# frozen_string_literal: true
require "prawn"
Prawn::Document.generate("document.pdf") do
text "Hello World!"
text 'Section 1',
size: 24,
align: :center
text 'Content for first section. ' * 10
text 'Section 2',
size: 24,
align: :center
column_box([0, cursor], columns: 2, width: bounds.width) do
text("#{<<~TEXT.gsub(/\s+/, ' ')}\n\n" * 4)
All the States and Governments by which men are or ever have been ruled,
have been and are either Republics or Princedoms. Princedoms are either
hereditary, in which the sovereignty is derived through an ancient line
of ancestors, or they are new. New Princedoms are either wholly new, as
that of Milan to Francesco Sforza; or they are like limbs joined on to
the hereditary possessions of the Prince who acquires them, as the
Kingdom of Naples to the dominions of the King of Spain. The States thus
acquired have either been used to live under a Prince or have been free;
and he who acquires them does so either by his own arms or by the arms of
others, and either by good fortune or by merit.
TEXT
end
text 'Section 3 - Drawing',
size: 24,
align: :center
bounding_box([100, cursor], width: 300, height: 100) do
stroke_bounds
stroke_circle [0, 0], 10
end
stroke_axis
stroke do
move_to 0, 0
line_to 100, 100
line_to 0, 100
curve_to [150, 200], bounds: [[20, 150], [120, 150]]
curve_to [200, 0], bounds: [[150, 200], [450, 10]]
end
fill_ellipse [200, 500], 100, 50
endThis example results in the following PDF document:
In this section, we will build a PHP example project using Composer, a PHP build tool.
To initialize a new PHP project, run the following command in the directory created for this project, and answer the prompted questions about the project.
> composer init
# or alternatively
> php composer.phar initAfter this, for simplicity, open composer.json and remove the default PSR-4 namespaces so that the resulting file looks as follows:
composer.json
{
"name": "gradient/create-pdf-using-php-and-fpdf"
}It is time to add the FPDF dependency and create a Hello World PDF. The command is:
composer require fpdf/fpdf
# or alternatively
php composer.phar require fpdf/fpdfsrc/main.php
<?php
require __DIR__ . '/../vendor/autoload.php';
use Fpdf\Fpdf;
$fpdf = new Fpdf();
$fpdf->AddPage();
$fpdf->SetFont('Arial', '', 16);
$fpdf->Write(0, 'Hello World!');
$fpdf->Output('F', getcwd() . DIRECTORY_SEPARATOR . 'document.pdf');Run this program with the following command:
php src/main.phpAs a result, the file document.pdf should be created, and it looks as follows:
If everything works correctly, the next step is to build the resulting example PDF document. The code example we will use is:
src/main.php
<?php
require __DIR__ . '/../vendor/autoload.php';
use Fpdf\Fpdf;
$regularTextSize = 16;
$titleTextSize = 32;
$fpdf = new Fpdf();
$fpdf->AddPage();
$fpdf->SetFont('Arial', '', $regularTextSize);
$fpdf->Write($regularTextSize, "Hello World!\n");
$fpdf->SetFont('Arial', 'b', $titleTextSize);
$fpdf->Cell(0, $titleTextSize / 2, "Section 1", null, null, 'C');
$fpdf->Ln();
$fpdf->SetFont('Arial', '', $regularTextSize);
$fpdf->Write($regularTextSize / 2, str_repeat('Section 1 Content. ', 10));
$fpdf->Ln();
$fpdf->Ln();
$fpdf->Write($regularTextSize / 2, 'Some additional Text');
$fpdf->Ln();
$triangleHeight = 20;
$point1 = [0, $fpdf->GetY()];
$point2 = [$fpdf->GetPageWidth() / 2, $fpdf->GetY() + $triangleHeight];
$point3 = [$fpdf->GetPageWidth(), $fpdf->GetY()];
$fpdf->Line(...$point1, ...$point2);
$fpdf->Line(...$point2, ...$point3);
$fpdf->Line(...$point3, ...$point1);
$fpdf->Output('F', getcwd() . DIRECTORY_SEPARATOR . 'document.pdf');This code results in the following PDF:
Contact Us or Schedule a Meeting with us to get an offer for our development & consulting services regarding your current or next development project.