When used in a Servlet to generate a PDF that is returned to the client (e.g. a browser) PDFreactor can write directly to the ServletOutputStream:

ServletOutputStream out = response.getOutputStream();
response.setContentType("application/pdf");
pdfReactor.renderDocument(inputSource, out);
out.close();

PDFreactor uses the Java Logging API to output information about it's progress. A simple console logger can be created like this:

pdfReactorLogger = Logger.getAnonymousLogger();
pdfReactorLogger.setLevel(Level.INFO);
pdfReactorLogger.addHandler(new DefaultHandler());
pdfReactor.setLogger(pdfReactorLogger);

Additionally, you can append the log to the generated PDF by using the method setAppendLog like this:

pdfReactor.setAppendLog(true);

pdfReactor.setLogLevel(PDFreactor.LOG_LEVEL_WARN);

To use the PDFreactor PHP API simply copy the PDFreactor.class.php to a directory of your webserver where PHP is enabled.

Then include the PDFreactor.class.php with:

include("/path/to/PDFreactor.class.php");

With just a few lines you can create and directly show PDFs inside your PHP webapplication:

<?php
include("../PDFreactor.class.php");
$pdfReactor = new PDFreactor();
$result = $pdfReactor->renderDocumentFromURL("http://www.pdfreactor.com");

// Check if successful
if (is_null($result)) {
    // Not successful, print error and log
    echo "<h1>Error During Rendering</h1>";
    echo "<h2>".$pdfReactor->getError()."</h2>";
    echo "<pre>".$pdfReactor->getLog()."</pre>";
} else {
    // Set the correct header for PDF output and echo PDF content
    header("Content-Type: application/pdf");
    echo $result;
}
?>

PHP API specific issues. PHP Script timeout: Generally the timeout of PHP scripts is set to 30s within the php.ini. When rendering large documents this limit may be exceeded.

You can easily access the PDFreactor service from any .NET language. The library assembly PDFreactor.dll offers you a large subset of the Java-API and takes care of all communication with the service.

A simple usage in C# would be:

PDFreactor pdfReactor = new PDFreactor();
byte[] result = pdfReactor.RenderDocumentFromURL("http://www.pdfreactor.com/");

A class reference and an XML documentation file is included.

Using ASP.NET. To use the .NET API from ASP.NET copy PDFreactor.dll from wrappers\dotnet\bin in your PDFreactor installation directory to bin in the root of your IIS-Application or to the global assembly cache.

An ASP.NET example would be:

<%@ Page Language="C#" Debug="false" %>
<%
PDFreactor pdfReactor = new PDFreactor();
byte[] result = pdfReactor.RenderDocumentFromURL("http://www.pdfreactor.com/");

// Check if successful
if (result == null)
{
    // Not successful, print error and log
    Response.Write("<h1>Error During Rendering</h1>>");
    Response.Write("<h2>"+pdfReactor.GetError()+"</h2>");
    Response.Write("<pre>"+pdfReactor.GetLog()+"</pre>");
}
else
{
    // Set the correct header for PDF output and echo PDF content
    Response.ContentType = "application/pdf";
    Response.BinaryWrite(result);
}
%>

To use the PDFreactor Python API simply copy the PDFreactor.py to a directory of your webserver where Python is enabled (by e.g. CGI or mod-python).

Then include the PDFreactor.py with:

import sys
sys.path.append("path/to/PDFreactor.py/")
from PDFreactor import *

With just a few lines you can create and directly show PDFs inside your Python webapplication:

pdfReactor = PDFreactor()
result = pdfReactor.renderDocumentFromURL("http://www.pdfreactor.com")

# Check if successful
if result == None:
    # Not successful, print error and log
    print "Content-Type: text/html\n"
    print "<h1>Error During Rendering</h1>"
    print "<h2>"+pdfReactor.getError()+"</h2>"
    print "<pre>"+pdfReactor.getLog()+"</pre>"
else:
    # Used to prevent newlines are converted to Windows newlines (\n --> \r\n) 
    # when using Python on Windows systems 
    if sys.platform == "win32":
        import os, msvcrt
        msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
    # Set the correct header for PDF output and echo PDF content
    print "Content-Type: application/pdf\n"
    sys.stdout.write(result)

if sys.platform == "win32":
    import os, msvcrt
    msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
    print "Content-Type: application/pdf\n"
    sys.stdout.write(result)

To use the PDFreactor Perl API simply copy the PDFreactor.pm to a directory of your webserver where Perl is enabled (by e.g. CGI or mod-perl).

Then include the PDFreactor.pm with:

require "PDFreactor.pm";

With just a few lines you can create and directly show PDFs inside your Perl webapplication:

my $pdfReactor = PDFreactor -> new();
$result = $pdfReactor -> renderDocumentFromURL("http://www.pdfreactor.com");

# Check if successful
if (!defined $result) {
    # Not successful, print error and log
    print "Content-type: text/html\n\n";
    print "<h1>Error During Rendering</h1>";
    print "<h2>".$pdfReactor -> getError() ."</h2>";
    print "<pre>".$pdfReactor -> getLog() ."</pre>";
} else {
    # Set the correct header for PDF output and echo PDF content
    print "Content-type: application/pdf\n\n";
    binmode(STDOUT);
    print $result;
}

binmode(STDOUT);

To use the PDFreactor Ruby API simply copy the PDFreactor.rb to a directory of your webserver where Ruby is enabled (by e.g. CGI or mod-ruby).

Then include the PDFreactor.rb with:

require 'PDFreactor.rb'

With just a few lines you can create and directly show PDFs inside your Ruby web application:

pdfReactor = PDFreactor.new()
result = pdfReactor.renderDocumentFromURL("http://www.pdfreactor.com")

# Check if successful
if result == nil
  # Not successful, print error and log
  print "Content-type: text/html\n\n"
  puts "<h1>Error During Rendering</h1>"
  puts "<h2>"+pdfReactor.getError()+"</h2>"
  puts "<pre>"+pdfReactor.getLog()+"</pre>"
else
  # Set the correct header for PDF output and echo PDF content
  print "Content-type: application/pdf\n\n"
  $stdout.binmode
  print result
end

$stdout.binmode

The Jetty application server can be configured in several ways. Most commonly, as described in the chapter Memory, you may want to increase the amount of memory available.

…
<Set name="maxThreads">16</Set>
…

…
<Set name="port">9423</Set>
…

$pdfReactor = new PDFreactor("localhost", 9424);

PDFreactor pdfReactor = new PDFreactor("localhost", 9424);

pdfReactor = PDFreactor("localhost", 9424);

my $pdfReactor = PDFreactor -> new("localhost", 9424);

pdfReactor = PDFreactor.new("localhost", 9424);

…
<Set name="host">localhost</Set>
…

$pdfReactor = new PDFreactor("my-server.com");

PDFreactor pdfReactor = new PDFreactor("my-server.com");

pdfReactor = PDFreactor("my-server.com");

my $pdfReactor = PDFreactor -> new("my-server.com");

pdfReactor = PDFreactor.new("my-server.com");

The logging mechanism for the APIs that use the web service is different from the logging mechanism of the Java API. Here, the PDFreactor instance has two additional methods getLog and getError which can be called after the conversion process to retrieve the log or any errors which may have occurred during the conversion, respectively.

Another way of retrieving the log is using the method setAppendLog. This will append the log to the generated PDF you have both the generated PDF and the log in one document.

Additionally, the entire log output of the Jetty application server is written into the output.log file located in the PDFreactor/bin directory.

$pdfReactor->setLogLevel(LOG_LEVEL_DEBUG);
$pdfReactor->setAppendLog(true);

pdfReactor.SetLogLevel(PDFreactor.LOG_LEVEL_DEBUG);
pdfReactor.SetAppendLog(true);

pdfReactor.setLogLevel(PDFreactor.LOG_LEVEL_DEBUG)
pdfReactor.setAppendLog(True)

$pdfReactor -> setLogLevel($pdfReactor -> LOG_LEVEL_DEBUG);
$pdfReactor -> setAppendLog('true');

pdfReactor.setLogLevel(PDFreactor::LOG_LEVEL_DEBUG)
pdfReactor.setAppendLog(true)

In order to run PDFreactor from the command line, please make sure that a JRE is installed (you can find the minimum requirements in the readme file). To verify that the JRE is installed properly and see the current version just type the following command in your shell:

java -version

This should result in an output similar to the following:

C:\>java -version
    java version "1.6.0_17"
    Java(TM) SE Runtime Environment, Standard Edition (build 1.6.0_17-b04)
    Java HotSpot(TM) Client VM (build 14.3-b01, mixed mode, sharing)

In order to run PDFreactor, you must use java with the jar option:

java -jar pdfreactor.jar

The -h option of PDFreactor will display an overview of all available command line options:

java -jar pdfreactor.jar -h

All of these sample instructions assume that you are currently in the same directory as pdfreactor.jar file.

Generating PDF documents.  In the simplest case, PDFreactor only needs two parameters to generate a PDF file: the input and the output file:

java -jar pdfreactor.jar <input file> <output file>

For example:

java -jar pdfreactor.jar c:\test\test.html c:\test\test.pdf

Instead of an input file you can also specify a URL:

java -jar pdfreactor.jar http://www.myserver.com/mytestfile.xml myfile.pdf

java -jar pdfreactor.jar /user/home/testuser/test.xml test.pdf

java -jar pdfreactor.jar "c:\documents and settings\user\test.html" test.pdf

This section covers the most important command line calls.

java -jar pdfreactor.jar -v debug c:\test\test.html test.pdf

java -jar pdfreactor.jar -v fatal c:\test\test.html test.pdf

java -jar pdfreactor.jar
         --style "* {font-weight:bold}" c:\test\test.html test.pdf

java -jar pdfreactor.jar
         --styleurl http://myserver/style.css c:\test\test.html test.pdf

To increase the amount of memory available to to PDFreactor, you need start the Java VM with the -Xmx parameter which specifies the amount of memory.

To increase the memory to e.g. 2GB, start the VM with the parameter -Xmx2048m like this:

java -Xmx2048m -jar pdfreactor.jar

Without a license key PDFreactor runs in evaluation mode. In evaluation mode it is possible to integrate and test PDFreactor just like the full version but the resulting PDF document will include watermarks and additional evaluation pages.

To obtain a license key, please visit the PDFreactor website (http://www.pdfreactor.com). It provides information about all available licenses and how to receive license keys.

RealObjects provides you a license key file in XML format.

The license key can be set as a string using the setLicenseKey method of the PDFreactor class.

Example:

String licensekey = "<license>... your license ...</license>";
pdfReactor.setLicenseKey(licensekey);

pdfReactor.setThrowLicenseExceptions(true)

PDFreactor supports the img element per default in HTML. For other XML languages, you can use proprietary CSS extensions to define an image element. For example, in an XML vocabulary where an image element is <image source='test.jpg'>, the corresponding CSS definition would be:

image {
    -ro-replacedelement: image;
    -ro-source: ro-attr(source);
}

To define an element as image element, you must specify the replaced element formatter for images for this element, as displayed in the example above. Using the -ro-source property, you can select an attribute of this element. The value of this attribute must always be of the type URI and is used to load the image.

PDFreactor automatically embeds and renders SVG documents referenced via the img element. Example:

<img src="diagram.svg" />

Alternatively, you can embed SVG directly into your documents:

a circle:<br/>
<svg width="100" height="100">
    <circle cx="50" cy="50" r="45" fill="yellow" stroke="black" />
</svg>
<br/>sometext.......

<svg:svg xmlns:svg="http://www.w3.org/2000/svg" width="100" height="100">
    <svg:circle cx="50" cy="50" r="45" fill="yellow" stroke="black" />
</svg:svg>

Rasterization. SVGs are embedded into the PDF as vector graphics, keeping them resolution independent. However SVGs containing masks, filters or non-default composites have to be rasterized. This behavior can be configured using CSS:

The style -ro-rasterization: avoid disables the aforementioned SVG features to avoid having to rasterize the image.

The property -ro-rasterization-supersampling configures the resolution of the rasterization. The default value is 2, meaning twice the default CSS resolution of 96dpi. Accepted values are all positive integers. Higher resolution factors increase the quality of the image, but also increase the conversion time and the size of the output documents.

CMYK Colors in SVG. PDFreactor supports CMYK colors in SVGs. Those are passed to the PDF as-is, as long as the SVG is not rasterized.

stroke="cmyk(0.0, 0.0, 0.0, 1.0)"

PDFreactor supports displaying barcodes in documents using the Barcode XML format from Barcode4J:

<p><b>EAN-13:</b></p>
<barcode:barcode xmlns:barcode="http://barcode4j.krysalis.org/ns"
    message="123456789012">
    <barcode:ean-13/>
</barcode:barcode>
<br>sometext.......

PDFreactor supports displaying MathML in documents using the MathML XML format.

<math:math mode="display" xmlns:math="http://www.w3.org/1998/Math/MathML">
  <math:mrow>
    <math:munderover>
      <math:mo>&#x222B;</math:mo>
      <math:mn>1</math:mn>
      <math:mi>x</math:mi>
    </math:munderover>
    <math:mfrac>
      <math:mi>dt</math:mi>
      <math:mi>t</math:mi>
    </math:mfrac>
  </math:mrow>
</math:math>
        

PDFreactor supports displaying QR codes in documents using the following style:

.qrcode {
-ro-replacedelement: qrcode;
}

If the replaced element is applied to an HTML link, the reference URL (resolved against the base URI) is used as the content of the QR code, e.g.:

<a href="http://www.pdfreactor.com" class="qrcode"></a>

In any other case the text content of the element is used, e.g.:

<span class="qrcode">
BEGIN:VCARD
VERSION:2.1
N:Doe
FN:John
TEL:+1-555-123-456
TEL;FAX:+1-555-123-457
EMAIL:johndoe@johndoe.com
URL:http://www.johndoe.com
END:VCARD
</span>

QR Codes can be tweaked using the following CSS properties:

PDFreactor supports the object and embed elements of HTML. You can use either element or a combination of both to embed any type of data such as for example a flash animation. The most simple code to do so is:

<embed src="myflash.swf" width="256" height="256"
       type="application/x-shockwave-flash"/>

An iframe allows another document, for example content from other pages, to be embeded inside an existing one.

The source document. There are two ways to define the inner document of an iframe. The first option is to use the src attribute and specifying the URL from which the document should be loaded. The URL might be absolute or relative and should refer to an HTML document.

The second option is useful if the inner document is very short and simple. When using the srcdoc attribute, its value is set to be the inner document's source code.

<iframe src="http://www.pdfreactor.com" width="600" height="400">
</iframe>

<iframe srcdoc="<p>Hello World</p>">
    <b>This is fallback text in case the user-agent does not support
        iframes.</b>
</iframe>
        

Seamless. If the seamless attribute has been set, the iframe's document behaves as it would be in the document that contains the iframe. That means that the width and height of the iframe are ignored and the inner document is shown completely if possible.

Furthermore, the borders of the iframe are removed and most importantly all styles from the outer document are inherited by the inner document.

When generating the PDF, the headings and other bookmark styles inside the iframe are passed through, so they can be found in the bookmark list.

The seamless attribute is a boolean attribute, which means that if it exists it is set to true and if it does not exist, it is set to false. The only valid values of seamless are an empty string "" or "seamless". The attribute can also be used without any value:

<iframe src="http://www.pdfreactor.com" width="600" height="400" 
            seamless>
</iframe>

Customization. Using CSS styles, it is possible to customize the look and functionality of iframes.

The border, padding and margin can be set or removed with the appropriate styles.

iframe {
    border: none;
    padding: 0px;
    margin: 0px;
}

By default, if seamless is false neither style sheets nor inline styles are passed down to the iframe's document. However, by using the property -ro-passdown-styles, this behavior can be customized.

When generating a PDF with the bookmarks feature enabled, the headings in the document are added as bookmarks to quickly navigate the document.

Using the property -ro-bookmarks-enabled it is possible to enable or disable this feature for iframes, thus allowing the headings of the inner document to be added to the bookmarks list or not. The property can be either set to true or false. If the iframe is seamless, it is set to true by default.

<iframe src="http://www.pdfreactor.com" width="600" height="400"
    seamless="seamless" style="-ro-passdown-styles:stylesheets-only; 
    -ro-bookmarks-enabled:false;">
</iframe>

PDFreactor has built-in support for the canvas element of HTML5. The canvas element is a dynamic image for rendering graphics primitives on the fly. In contrast to other replaced elements the content of the canvas element must be generated dynamically via JavaScript, instead of referencing an external resource that contains the content to be displayed (as is the case for example for images).

Below is a simple code fragment which renders shadowed text into a canvas element:

<head>
    <script type="text/javascript">
function draw() {
    var ctx = document.getElementById("canvas").getContext('2d');
    ctx.font = "50px 'sans-serif'";
    ctx.shadowBlur = 5;
    ctx.shadowColor = "#aaa";
    ctx.shadowOffsetX = 2;
    ctx.shadowOffsetY = 2;
    ctx.fillStyle = "black";
    ctx.fillText("PDFreactor",0,50);
}
    </script>
</head>
...
<body onload="draw();">
    <canvas id="canvas" width="400" height="300">
        Canvas element is not supported.
    </canvas>
</body>

Resolution Independence. PDFreactor by default does not use a resolution-dependent bitmap as the core of the canvas. Instead it converts the graphics commands from JavaScript to resolution-independet PDF objects. This avoids resolution-related issues like blurriness or pixelation.

Shadows can not be convert to PDF objects. So those are added as images. This does not affect other objects in the canvas.

Accessing ImageData of a canvas or setting a non-default composite causes that canvas to be rasterized entirely.

This behavior can be configured using CSS:

The style -ro-rasterization: avoid disables functionality that causes the rasterization of the canvas.

The style -ro-rasterization: always forces the canvas to be rasterized in any case.

The property -ro-rasterization-supersampling configures the resolution at which the canvas or shadows are rasterized. The default value is 2, meaning twice the default CSS resolution of 96dpi. Accepted values are 1 to 4. Higher resolution factors increase the quality of the image, but also increase the conversion time and the size of the output documents. This does not affect canvas objects that are not rasterized.

PDFreactor allows JavaScript access to some layout information while rendering a document. To get the information use the following methods and objects:

The JavaScript library awesomizr.js is a collection of helpful functions for the use with PDFreactor. You have to import the JavaScript and in same cases the corresponding CSS.

You can add the library by using the PDFreactor API method addUserScript(). To add the respective CSS, use the method addUserStyleSheet():

pdfReactor.addUserStyleSheet("", "", "", "awesomizr.css");
pdfReactor.addUserScript(null, "awesomizr.js", false);
pdfReactor.addUserScript("Awesomizr.createTableOfContents();", null, false);

The capabilities of awesomizr.js include:

[D]

PDFreactor adds bookmarks to your document by using the following API method:

pdfReactor.setAddBookmarks(true);

When the default HTML mode is enabled, the following bookmark levels are applied by default:

h1 { -ro-pdf-bookmark-level: 1;}
h2 { -ro-pdf-bookmark-level: 2;}
h3 { -ro-pdf-bookmark-level: 3;}
h4 { -ro-pdf-bookmark-level: 4;}
h5 { -ro-pdf-bookmark-level: 5;}
h6 { -ro-pdf-bookmark-level: 6;}

Using the -ro-pdf-bookmark-level style you can create bookmarks which link to arbitrary XML elements in your PDF files.

element { -ro-pdf-bookmark-level: 1 }

Using this property, one can structure the specified elements within the bookmark view of the PDF viewer. The elements are ordered in ascending order. The element with the lowest bookmark level is on top of the bookmark hierarchy (similar to HTML headlines). Several bookmark levels can be set using the -ro-pdf-bookmark-level style.

PDFreactor can add links to your documents when using the following API method:

pdfReactor.setAddLinks(true);

When the default HTML mode is enabled, the following link styles are applied by default:

a[href] { -ro-link: ro-attr(href); }
a[name] { -ro-anchor: ro-attr(name ro-ident); }

Using the styles -ro-link and -ro-anchor arbitrary elements can be defined to be links or anchors.

linkElement[linkAttribute] { -ro-link: ro-attr(linkAttribute); }
anchorElement[anchorAttribute] { -ro-anchor: ro-attr(anchorAttribute ro-ident); }

Please also see Attachments.

The clickable areas of links. The style -ro-link-area can be used to specify how the 'clickable' areas of a link are determined:

This style is not inherited. It has to be set on the same element as -ro-link.

It is possible to add PDF comments to the document using the following API method:

pdfReactor.setAddComments(true);

Depending on how the comment information is stored in your HTML source document, there are several style rules that can be applied. The most common use-cases are to either create a comment from an empty element (where any information is stored in its attributes) or to create a comment from a non-empty element (where the content is the text encompassed by the element):

<span class="comment" text="My Comment."></span>

span.comment {
    -ro-comment-content: ro-attr(text);
}

<span class="comment">This text is commented</span>

span.comment {
    -ro-comment-content: content();
}

There are different styles to visualize a comment in the PDF:

The comment styles highlight, underline, strikeout and squiggly are only applicable to comments that encompass a section of text.

The following example demonstrates how to style a simple comment.

<span class="comment">This is a styled comment</span>

span.comment {
    -ro-comment-content: content();
    -ro-comment-style: underline;
}

Comments can be customized further by using a variety of style rules. Besides content and style, you can also customize the following properties:

The following sample shows how to customize all of the aforementioned properties.

.comment {
    /* Content: get the content of the comment from the text content of the element */
    -ro-comment-content: content();
    /* Title: get the title from the "author" attribute of the element */
    -ro-comment-title: ro-attr(author);
    /* Style: set the comment style to "note" */
    -ro-comment-style: note;
    /* Color: specify a color for the comment */
    -ro-comment-color: steelblue;
    /* Date: get the date from the "date" attribute of the element */
    -ro-comment-date: ro-attr(date);
    /* Date Format: specify a custom date format */
    -ro-comment-dateformat: "yyyy/dd/MM HH:mm:ss";
    /* Position: shift the comment icon to the right side of the page */
    -ro-comment-position: page-right;
    /* Initial state: open comment bubbles when the PDF is opened */
    -ro-comment-state: open;
    /* additional styles */
}

Please see the documentation of the individual CSS properties for more information.

Advanced Comments. In some cases, comments have a separate start and end tag. In this case the additional style rules -ro-comment-start or -ro-comment-end have to be set to match the comment's start and end elements.

commentstart {
    /* some customizations */
    -ro-comment-content: ro-attr(text);
    -ro-comment-title: ro-attr(author);
    -ro-comment-style: highlight;
    
    /* define the comment start element */
    -ro-comment-start: ro-attr(uid)
}

commentend {
    /* define the comment end element */
    -ro-comment-end: ro-attr(uid);
}

The title of a generated PDF documnet, as well as the additional metadata author, subject and keywords, can be specified in multiple ways:

By default the <title> tag as well as various <meta> tags are read.

The metadata can also be read from other elements using the properties -ro-title, -ro-author, -ro-subject and -ro-keywords.

/* Disable setting title from title or meta tags */
head * {
    -ro-title: none;
}
/* Set title from first heading */
body > h1:first-of-type {
    -ro-title: content();
}

The metadata of the document can be overridden from the API:

pdfReactor.setAuthor("John Doe");
pdfReactor.setTitle("Architecture of the World Wide Web, Volume One");
pdfReactor.setSubject("Architecture of the world wide web");
pdfReactor.setKeywords("w3c, www");

The code above creates metadata as shown in the screenshot below:

[D]

Custom Properties. You can also add custom properties to the documents, for which you can define the name and value, e.g.

pdfReactor.addCustomDocumentProperty("feedback address", "peter@miller.com");

HTML forms are automatically rendered by PDFreactor. In addition, you can also convert HTML forms to fully functional interactive PDF forms (sometimes refered to as AcroForms) using the proprietary CSS property -ro-pdf-format. This property must be specified for the forms you wish to convert to an interactive PDF form.

Example form:

<form id="credentials">
    First Name: <input type="text" value="firstname" />
    Last Name: <input type="text" value="lastname" />
    <input type="submit" />
</form>

To convert the form with the ID "credentials" to an AcroForm, you can use this style declaration:

#credentials, #credentials > input { -ro-pdf-format: pdf; }

Using this style declaration, only the form with the ID "credentials" and the input fields contained in this form are converted to an AcroForm when the PDF is rendered. Only the forms and form elements having this CSS style are converted. You can convert all forms and input fields using this CSS code:

form, form input { -ro-pdf-format: pdf; }

Tagged PDF files contain information about the structure of the document. The information about the structure is transported via so-called "PDF tags". Tagging a PDF usually makes it more accessible to screen readers, handhelds an similar devices.

Using the setAddTags API method, you can add PDF tags to the PDF documents generated with PDFreactor. If you are generating a PDF from HTML documents, the HTML elements are automatically mapped to the corresponding PDF tags, so all you have to do is setting this property to enable this feature:

pdfReactor.setAddTags(true);

If you are generating a PDF from another XML language (e.g. DocBook), the elements of this XML language are not mapped to PDF tag types. Instead, they are translated to PDF tags using the XML element name. Thus, the element "para" would be mapped to the PDF tag "para", while the PDF tag type "P" may be more appropriate for this element.

However you can manually map XML elements to PDF tag types using style properties. These style properties are "-ro-pdf-tag-type" and "-ro-alt-text". "-ro-pdf-tag-type" is used to map an element of the XML language you are using to a PDF tag, for example:

para { -ro-pdf-tag-type: "P"; }

If you were using DocBook, this would map the DocBook element "para" to the PDF tag "P".

The property -ro-alt-text is used to specify an alternative description for an XML element. Example:

img {
    -ro-pdf-tag-type: "Figure";
}
img[alt] {
    -ro-alt-text: ro-attr(alt);
}

The example above maps the HTML element <img> to the PDF tag "Figure", and the content of its alt attribute to an alternative description for this tag.

If you want to define from which element or attribute in the document the names of the form elements are adopted to a generated PDF, you can use the property -ro-formelement-name. By default, the names are adopted from the value attribute of the form element.

Using the -ro-radiobuttonelement-group, the name for radio button groups can be adopted in the same way. By default, it will be adopted from the name attribute of the radio button element.

PDFreactor supports the creation of PDF/A-1a or PDF/A-3a conformant files.

PDF/A is a family of ISO standards for long-term archiving of documents. The goal of these standards is to ensure the reproduction of the visual appearance as well as the inclusion of the document's structure. All information necessary for displaying the document in the same way every time is embedded in the file. Dependencies on external resources is not permitted.

Many companies and government organizations worldwide require PDF/A conformant documents.

PDF/A-1a is the most strict PDF/A standard while the newer PDF/A-3a is more leniant, e.g. allowing transparency and attachements.

To create a PDF/A conformant document, the method setConformance can be used in the PDFreactor integration:

pdfReactor.setConformance(PDFreactor.CONFORMANCE_PDFA1A);

or

pdfReactor.setConformance(PDFreactor.CONFORMANCE_PDFA3A);

If CMYK colors are used in a document to be converted into a PDF/A-conformant file, an Output Intent has to be set. It is possible to use the following API methods:

pdfReactor.setOutputIntentFromURL(String identifier, String profileUrl);

or

pdfReactor.setOutputIntentFromByteArray(String identifier, byte[] profileData);

The first parameter is a string identifying the intended output device or production condition in human- or machine-readable form. The second parameter points to an ICC profile file or contains data of such a profile.

PDFreactor can be configured to immediately display a print dialog when a PDF file created with PDFreactor is opened. To do so, the setPrintDialogPrompt method of the PDFreactor class must be used. Example:

pdfReactor.setPrintDialogPrompt(true);

Using the API method setFullCompression, PDF files can be generated with full compression, thus reducing the file size of the resulting PDF document.

Example usage:

pdfReactor.setFullCompression(true);

PDFreactor can protect generated PDF documents via 40 or 128 bit encryption.

To encrypt the output PDF, set the encryption strength to a value other than ENCRYPTION_NONE:

pdfReactor.setEncryption(PDFreactor.ENCRYPTION_128);

When the PDF document is opened, the user has to supply the user password in order to view the content. When no user password is set, the PDF can be viewed by any user. In either case, certain restrictions are imposed. These can be suspended by supplying the owner password. You can set the passwords as follows:

pdfReactor.setUserPassword("upasswd");
pdfReactor.setOwnerPassword("opasswd");

Both passwords are optional, but recommended for security reasons.

By default, all restrictions are imposed on the PDF document. You can however exclude selected ones by using the following methods:

Using the setAddPreviewImages API method, you can use PDFreactor to add page preview images to your PDF file. This is recommended if the PDF reader you are using does not offer an automatic preview of pages or if you are rendering highly complex documents containing many graphical elements.

Example usage:

pdfReactor.setAddPreviewImages(true);

You can configure the initial presentation of the document in the viewer by setting viewer preferences. Setting viewer preferences will activate / deactivate certain options of the viewer, for example it allows to hide the viewer's toolbar when the document is opened.

Note that these preferences are not enforced, i.e. if you decide to set the HIDE_TOOLBAR preference, the user can still display the toolbar again when viewing this PDF if he decides to do so. Setting this preference only affects the default state of the toolbar when the document is opened, but does not enforce this state.

Some viewer preferences also influence the default settings of the print dialog of the viewer.

You can set viewer preferences by using the method setViewerPreferences. Multiple preferences can be combined using the OR operator, e.g.:

pdfReactor.setViewerPreferences(
        PDFreactor.VIEWER_PREFERENCES_PAGE_LAYOUT_SINGLE_PAGE | 
        PDFreactor.VIEWER_PREFERENCES_DISPLAY_DOC_TITLE);

PDFreactor supports the following viewer preferences:

A generated PDF can easily be merged with existing ones. To merge with a single PDF use the setMergeURL(String) method that declares the path to the PDF file.

pdfReactor.setMergeURL("http://www.myserver.com/overlaid.pdf");

To merge multiple PDFs use the methods setMergeURLs or setMergeByteArrays.

String[] urls = {"http://www.myserver.com/overlaid1.pdf",
        "http://www.myserver.com/overlaid2.pdf"};
pdfReactor.setMergeURLs(urls);

Whether the existing PDFs are appended to the generated PDF or whether the generated PDF is laid over them depends on the general type of merge:

Concatenation merges append PDFs before or after the generated PDF. The following sample shows how to append an existing PDF after the generated one:

pdfReactor.setMergeURL("http://www.myserver.com/appendDoc.pdf");
pdfReactor.setMergeMode(PDFreactor.MERGE_MODE_APPEND);

Overlay merges add the generated PDF above or below existing PDFs. The following sample shows how to overlay an existing PDF:

pdfReactor.setMergeURL("http://www.myserver.com/overlaid.pdf");
pdfReactor.setMergeMode(PDFreactor.MERGE_MODE_OVERLAY);

PDFreactor allows to repeat the pages of PDFs with less pages than other PDFs involved in the merger. The API method setOverlayRepeat offers different options to do this:

In the following example, all pages are repeated:

pdfReactor.setOverlayRepeat(PDFreactor.OVERLAY_REPEAT_ALL_PAGES);

The default merge behavior of PDFreactor is a Concatenation after the pages of the generated PDF.

PDFreactor is able to sign the PDFs it creates. This allows to validate the identity of the creator of the document. A self-signed certificate may be used. A keystore file in which the certificate is included, is required.

The keystore type is required to be one of the following formats:

PDFreactor supports the following three modes to sign a PDF:

To sign a PDF digitally use the API method setSignPDF.

By default, PDFreactor automatically embeds the required subsets of all fonts used in the document. This can be disable using the method setDisableFontEmbedding.

pdfReactor.setDisableFontEmbedding(true)

Doing so reduces the file size of the resulting PDF documents. However, these documents are likely to not look the same on all systems. Therefore this method should only be used when necessary.

Overprinting means that one color is printed on top of another color. As this is a feature for printing it should be used with CMYK colors.

PDFreactor can set the values of the PDF graphics state parameters overprint and overprint mode via CSS. This can be enabled usign the API method setAddOverprint:

pdfReactor.setAddOverprint(true)

Using the styles -ro-pdf-overprint and -ro-pdf-overprint-content you can specify the overprint properties of elements and their content to either none (default), mode0 or mode1 (nonzero overprint mode).

-ro-pdf-overprint affects the entire element, while -ro-pdf-overprint-content only affects the content of the element (not its borders and backgrounds). In both cases the children of the element are affected entirely, unless overprint styles are applied to them as well.

The following example sets small text on solid background to overprint, without enabling overprinting for the background of either the paragraphs or the highlighting spans:

p.infobox {
    border: 1pt solid black;
    background-color: lightgrey;
    color: black;
    font-size: 8pt;
    -ro-pdf-overprint-content: mode1;
}
p.infobox span.marked {
    background-color: yellow;
    -ro-pdf-overprint: none;
    -ro-pdf-overprint-content: mode1;
}

Alternatively to linking to external URLs (see Links) PDFreactor also allows embedding their content into the PDF.

Attachments can be defined via CSS, which can be enabled by the API method setAddAttachments:

pdfReactor.setAddAttachments(true)

The following styles can be used to specify attachments:

Attachments can be specified for specific elements as follows:

#downloadReport {
    -ro-pdf-attachment-url: "../resources/0412/report.doc";
    -ro-pdf-attachment-name: "report-2012-04.doc";
    -ro-pdf-attachment-description: "Report for April of 2012";
}

Strings can be dynamicly read from the document using the CSS functions ro-attr and content, that read specified attributes or the text content of the element respectively. Using those, certain a-tags can be changed from links to attachments:

.downloadReports a[href] {
    -ro-link: none;
    -ro-pdf-attachment-url: ro-attr(href);
    -ro-pdf-attachment-description: content() " (" ro-attr(href) ")"; 
}

Attachments can also be set via the API method addAttachment. This method also allows specifying the content of the attachment as a byte array instead of an URL, so dynamicly created data can be attached:

pr.addAttachment("sample attachment text".getBytes(), null,
        "sample.txt", "a dynamically created attachment containing text");
pr.addAttachment(null, "../resources/0412/report.doc",
        "report-2012-04.doc", "Report for April of 2012");

All image output formats, except for the TIFF formats, create an image of a single page. By default, this is the first page. A different page can be selected using the method setPageOrder, e.g.:

pdfReactor.setPageOrder("5");

The methods renderDocumentFromURLAsArray, renderDocumentFromContentAsArray and renderDocumentFromByteArrayAsArray convert a document, returning an array of byte-arrays each containing an image representing one page of the document.

The method setContinuousOutput sets PDFreactor to continuous mode. In this mode each document is converted into one image. Also screen styles will be used and print styles will be ignored, resulting in a very browser-like look for the output image.

pdfReactor.setContinuousOutput(1024, 768);

The first parameter sets the width of the layout. This has the same effect as the width of a browser window. This only changes the layout. The result will still be scaled to the width specified by setOutputFormat

The second parameter sets the height. This has the same effect as the height of a browser window, i.e. it will cut off the image or increase its height. Values of less than 1 cause the full height of the laid out document to be used.

To create an individual page layout pages need to be selected with CSS. In principle it works the same way as selecting an element, but the selector is different.

To select all pages of the document, the @page rule is used instead of the usual element selector.

@page {
    margin: 1in
}

Using the pseudo-classes :first, :left and :right makes it possible to select the first, all left or all right pages. This allows to define different style for certain pages, e.g. for a title page.

@page{
    margin-top: 2in;
    margin-bottom: 6in
}
@page:left{
    margin-left: 4in;
    margin-right: 3in
}
@page:right{
    margin-left: 3in;
    margin-right: 4in
}

The size and orientation of a page can be set with the size property. PDFreactor supports many different page sizes, see Appendix Supported Page Size Formats.

@page{
    size: letter portrait
}

To set a page to landscape orientation, "portrait" is replaced by "landscape":

@page{
    size: letter landscape
}

Instead of setting fixed page formats with a specified orientation it is also possible to set two length values. These then define page size and orientation.

@page{
    size: 4.25in 6.75in
}

With Named Pages an element is able to create and appear on a special page that has a name. This name can be used as part of a Page Selector to attach additional style properties to all pages of that name.

To create a Named Page, an element receives the page property with a page name as identifier.

table{
    page: pageName
}

A page break will be inserted before an element that has the page property set. Another page break will be inserted for the next element that defines a different page name (or none) to ensure the Named Page only contains elements that specify its name.

To attach style to a named page, the page name is added to the @page rule. The page name is not a pseudo-class as :first is. There is a space between @page and the page name, not a colon.

@page pageName{
    size: letter landscape
}

Automatic Hyphenation allows breaking words in a way appropriate for the language of the word.

To use Automatic Hyphenation two requirements must be met:

The lang attribute in HTML or the xml:lang attribute in XML allow defining a language for the document and on individual elements, in case they deviate from the document language.

<html lang="en">
    ...
</html>

Hyphenation is enabled or disabled via CSS with the hyphens property:

html {
    hyphens: auto
}
p.noHyphenation { 
    hyphens: none
}

In addition it is possible to specify the number of minimum letters before or after which text can be broken within a word. This is done with the hyphenate-before and hyphenate-after properties.

By default, PDFreactor avoids widows and orphans by adding a page break before the paragraph. This behaviour can be changed with the CSS properties widows and orphans.

p {
    orphans: 2;
    widows: 2
}

Changing the value to 1 will allow widows and orphans. Changing it to higher integer values will prevent even multiple line widows and orphans. (e.g.: orphans: 5 means that if the first 4 lines of a paragraph are the last 4 lines of a page these lines are considered an orphan.)

To create generated text, set a String as value of the content property.

<div>This is a note.</div>

div::before{
    /* Adds the text "Note:" at the start of the element. */
    content: "Note:";
    
    padding-right: 0.1in;
    font-weight: bold
}
div{
    border: 1px solid black; 
    background-color: palegoldenrod;
    padding: 0.1in
}

As a result, the <div> would look like this:

This is a note.

Sometimes it is necessary to add an explicit line break to generated text. To create such a line break, a "\A" needs to be added to the String and the white-space property needs to be set to either pre, pre-wrap or pre-line.

div::before{
    content: "RealObjects\APDFreactor";
    white-space: pre
}

The result would look like this:

If the first character after the line break is an HTML entity, add an additional space between the "\A" and the entity.

A generated image can be created with the image's URL set as value of the content property.

h1::before{
    content: url(http://mydomain/pictures/image.svg)
}

Counters can be used to count elements or pages and then add the value of the Counter to generated text.

A Counter needs to be defined either with the counter-reset or the counter-increment property. Its value is read with the counter() function as value of the content property.

A common use-case for Counters are numbered headings. The chapter heading of a document is intended to display a number in front of its text that increases with each chapter.

h1{ 
    /* increases the counter "heading1" by 1 on each <h1> element */
    counter-increment: heading1 1
}
h1::before{
    /* Adds the current value of "heading1" before the <h1> element's 
       text as decimal number */
    content: counter(heading1, decimal)
}

Subchapter headings, work the same way, with a simple addition. The number of each subchapter is intended to be reset whenever a new chapter begins. To restart numbering, the counter-reset property is used.

h1{ 
    /* resets the value of counter "heading2" to 0 on every  <h1> element */
    counter-reset: heading2 0
}
h2{
    counter-increment: heading2 1
}

h2::before{
    /* Shows the current value of "heading1" and "heading2", separated by a 
       generated text ".", the value of "heading2" is shown as lower-case 
       letter */
    content: counter(heading1, decimal) "." counter(heading2, lower-alpha)
}

It is possible to add Generated Content to a page within the page margin. The page margin is the space between the document content and the edges of a sheet. It is defined on a page using Page Selectors and the margin property.

Each page provides sixteen Page Margin Boxes that can display Generated Content much like a pseudo-element. To add Generated Content to a page, add a Page Margin Box declaration to an existing @page rule and set the Generated Content to the content property as usual.

A Page Margin Box declaration consists of an "@" character followed by the name of the Page Margin Box.

@top-left{
    content: ""RealObjects PDFreactor(R)"";
}
@top-right{
    content: "copyright 2015 by RealObjects";
}

Running Elements are elements inside the document that are not rendered inside the document content but inside Page Margin Boxes.

They are useful whenever the content of a Page Margin Box needs to be more complex than Generated Content (e.g. a table) or parts of it need to be styled individually.

To create a Running Element, an element needs to be positioned as "running", using the running() function with an identifier for the element as argument. The function is set as value of the position property. This removes the element from the document content.

To display a Running Element inside a Page Margin Box, set the element() function as value of the content property. The argument of the function is the same identifier used to in the running() function of the Running Element.

<body>
    <footer>...</footer>
    ...
</body>

footer{
    position: running(footerIdentifier)
}
@page{
    @bottom-center{
        content: element(footerIdentifier)
    }
}

The <footer> needs to be at the beginning of the HTML document to guarantee, that it will appear on every page of the document.

The reason for that is, that running elements stay anchored to the location they would appear in if they were not Running Elements.

The original position of the running element inside the document plays a key role when designing a document, it provides document designers with additional options.

First of all it is possible to have running elements of the same name, which makes it possible to change the content of a Page Margin Box over the course of the document.

<body>
    <header id="titlePageHeader">...</header>
    <header id="pageHeader">...</header>
    <!-- first page content -->
    ...
    <!-- second page content -->
    ...
</body>

#titlePageHeader, #pageHeader{
    position: running(headerIdentifier)
}
@page{
    @top-center{
        content: element(headerIdentifier)
    }
}

Second of all it is possible to have running elements appear for the first time later in the document than on the first page.

<body>
    ...
    <footer>...</footer>
</body>

footer{
    position: running(footerIdentifier)
}
@page{
    @bottom-center{
        content: element(footerIdentifier)
    }
}

It is possible that more than one Running Element of the same name would anchor on the same page. Sometimes, it may not be the first Running Element on a page that should be used for that page. For that case it is possible to add one of these identifiers as second argument to the element() function:

In case Generated Content does not suffice and Running Elements are not an option, it is possible to use Running Documents inside Page Margin Boxes.

A Running Document is a String containing an HTML document or document fragment or a URL that references a document as argument of the xhtml() function.

/* document fragment */
content: xhtml("<table>…</table>");
/* complete document */
content: xhtml("<html><head>...</head><body>...</body></html>");
/* external document */
content: xhtml(url("header.html"));

The document is loaded independantly inside the Page Margin Box but styles from the document are passed down to it. This can be an advantage as the same style is used throughout all documents. In some cases though this behavior is not desired as this style may break the layout of the document inside the Page Margin Box. To prevent passing down style the –ro-passdown-styles property is used.

<!--
@page {
    @top-center{
        content: xhtml("<table>...</table>");
    }
}
-->

To add page numbers to a document, Page Counters are used. Page Counters work like Counters, but are defined on the Page and accessed in Page Margin Boxes.

The following example creates a Page Counter and a simple page footer that shows the page number on the bottom right of the page.

@page{
    counter-increment: page 1
    @bottom-right{
        content: counter(page)
    }
}

To retrieve the total number of pages PDFreactor provides the Total Pages Counter. The Total Pages Counter is a counter provided on application level, meaning it can be accessed without defining it first by the name pages.

content: "Page " counter(page) " of " counter(pages)

@media print{
    @page:first {
        counter-reset: page 
            applicationValue("com/realobjects/pdfreactor/start-page-number");
    }
    @page{
        counter-increment: page;
    }
}

h1 {
    -ro-counter-set: page 1;
}

Named Strings allow to store the text of an element and its Generated Content as String for use in Page Margin Boxes.

A Named String is defined very similar to a Counter and is used in a similar way. To create a Named String the property string-set is used, which requires an identifier and a definition of the contents of the String. To read a Named String the string() function is used as value of the content property.

h1 {
    string-set: headingString self;
}
@page{
    @top-left{
        content: string(headingString);
    }
}

The content of a named String is very flexible and can take a combination of Strings, counter() functions and Named String keywords.

/* Creates a Named String in the form of "Chapter [chapter number]: [chapter title]". */
h1{
    string-set: headingString "Chapter " before ": " self
}
/* Retrieves the first letter of an address element, useful as part of a page header 
    for a sorted list of addresses */
address{
    string-set: addressEntry first-letter;
}

Named Strings are similar to Running Elements in that they can occur multiple times on the same page and are accessed from Page Margin Boxes. Similar to the element() function, the string() function allows to add a second argument to specify which Named String inside a page should be used:

A Cross-reference is a piece of text that references another location in the document in order to establish a thematic relationship to that location.

Although it is perfectly possible to add such references by hand, this approach is prone to error when creating and modifying the document. After a change the numbering and page numbers might not match the numbering from when the cross-reference was first defined. The same could happen to the reference text if it includes the chapter title.

To automatically keep the reference up-to-date with the referenced location, CSS provides the target-counter() and target-text() functions to automatically retrieve the exact numbering, title or page number of the referenced location.

...
<p>For more information <a href="#chapter">see</a>.
...
<h1 id="chapter">Cross-references</h1>
...

@page{
    counter-increment: pageCounter;
    @bottom-right{
        content: counter(pageCounter);
    }
}
h1{
    counter-increment: chapterCounter;
}
h1::before{
    content: counter(chapterCounter, upper-roman);
}
a[href]::after{
    content: "Chapter " target-counter(ro-attr(href url), chapterCounter, upper-roman) 
                " on page " target-counter(ro-attr(href url), pageCounter);
}

a[href]{
    content: target-text(ro-attr(href url), before) " " 
        target-text(ro-attr(href url), content);
}

A footnote is a text note placed on the bottom of a page. It references a specific part of the main content of the document, giving further explanations or information about a citation. A footnote is marked by a defined symbol both in the main content of the page and in the footnote area at the bottom of the page, to show which parts belong together.

For content that is required to have a footnote, the following style can be applied:

float: footnote

The text content of the element that the style applied to, will appear in the footnote area at the bottom of the page. Content in the footnote area can be styled via CSS using the footnote rule.

.footnote {
    float: footnote;
}
@page {
    @footnote {
        border-top: solid black 1px;
    }
}

By defining a footnote, a footnote call is left behind in the main content. Its content and style can be influenced by the footnote-call pseudo-element.

For every footnote element, there is also a footnote-marker pseudo-element added. Usually this contains the same number or symbol as the footnote-call it belongs to.

.footnote::footnote-call {
    content: counter(footnote, decimal)
}
.footnote::footnote-marker {
    content: counter(footnote, decimal);
}

By default, the footnote counter is available and is automatically incremented for every element with the style:

float: footnote

By default, this counter numbers the footnotes sequentially for the entire document. To number footnotes on a per-page basis, the counter has to be reset on every page, using the following style:

@page {
    counter-reset: footnote;
}

PDFreactor is capable of transforming elements with the transform property, which makes moving, rotating and scaling document content possible.

Most block elements can be defined as a region. They are not required to be of the same size nor are they required to be the same node name.

To create a region from a block element, the -ro-flow-from property is used. It receives an identifier. A region chain contains all regions of the same identifier in document order. The identifier is also the name of the named flow these regions will display.

#region1, #region2{
    -ro-flow-from: regionChainName;
}

PDFreactor automatically lays out content inside regions and breaks text and boxes where no space is left. The number of regions inside a region chain is limited by the number of associated Region elements though and it is possible that the content of a named flow occupies more space than is available inside the regions of a region chain. In that case content from the named flow overflows the last region inside the region chain.

The –ro-flow-into property adds document content to a named flow. The content may consist of content from one or more elements. Content assigned to a named flow is not rendered at its position inside the document but inside one of the regions inside the region chain.

The property receives an identifier which is the name of the named flow the content belongs to. An optional keyword defines what part of the styled element should be taken into the named flow:

<article>...</article>
<article>
    ...
    <section id="info">...</section>
</article>

article{
    -ro-flow-into: articleNamedFlowName;
}
section#info{
    -ro-flow-into: infoNamedFlowName;
}

A region element can have before and after Generated Content just like any other element. This generated content is rendered above or below the region's content and is not moved to the next region due to lack of space. Instead the available space inside a region is reduced. If there is still not enough space left, the region's content flows over.

To manipulate the break behavior before and after boxes, the break-before and break-after properties are used. They provide keywords to force or avoid page, column and region breaks.

h1{
    break-before: always;
}

h1{
    break-before: right;
}

This style creates a page break before the h1 and moves it to the next page. In case this is a left page another page break is performed, to move it to a right page again.

h1, h2, h3, h4, h5, h6{
    break-after: avoid;
}

To manipulate the break behavior inside a box, the property break-inside is used. It specifies whether breaking should be avoided inside the box or not.

div{
    break-inside: avoid;
}

awesomizr.js is able to automatically add page breaks depending on the amount of space left below an element with the help of the applyAdaptivePageBreaks() function.

A possible use case is to prevent a new section from beginning at the bottom of a page.

The function also prevents large whitespaces that occur when in situations where only a couple of sentences from a previous section are followed by a page break as the next section begins.

The function takes two parameters:

Page boxes are used to specify the page geometry. PDFreactor supports the TrimBox, MediaBox, BleedBox, CropBox and ArtBox.

size: A4 portrait;

-ro-media-size: SRA4;

-ro-bleed-width: 3mm;

-ro-crop-size: media;

Printer Marks are special pieces of information located outside of the actual print result. They are used to prove the correctness of the result in prepress printing and are placed outside the TrimBox.

Cutting out the print result of the print sheet is done inside the bleed area. Trim and bleed marks indicate where this area starts and ends. Both types of marks are displayed as hairlines in the corner of the print sheet.

Registration marks show whether the printer's colors are aligned properly. They are printed as crosshair-shaped objects located on each side of the print sheet.

Color bars show if the colors of the print result meet the expected result. They consist of a variety of colors that can be checked individually.

The property -ro-marks is used to add trim, bleed and registration marks. The property -ro-marks-width sets the width of the mark lines, -ro-marks-color sets their color.

-ro-marks: trim bleed registration;
-ro-marks-width: 1pt;
-ro-marks-color: red;

Setting one of the -ro-colorbar-* properties defines where a color bar is added to the document.

-ro-colorbar-bottom-left: gradient-tint;
-ro-colorbar-bottom-right: progressive-color;

This method adapts the "pixels per inch" value used for laying out the document, i.e. it only scales lengths set as px including such set via HTML attributes. It does not cause gaps at the bottom of pages.

pdfReactor.setPixelsPerInchShrinkToFit(true)

The pixels per inch can also be specified manually.

This property must be part of the @page rule and allows the following values:

@page {
    -ro-scale-content: auto;
}