All Classes

Abstract base class for document actions, like "go-to" actions with absolute page coordinates.

A base abstract AFP raw stream image handler

structured field category codes

A base AFP painter

Abstract base class for binary-writing IFDocumentHandler implementations.

This class keeps information about abstract border element, i.e.

Helper class, extending the functionality of the basic BlockKnuthSequence.

A page break position.

An abstract configurator

Base class for AFP descriptor objects

Base class for factory classes which instantiate FOEventHandlers and provide information about them.

A FOP base implementation of a Batik BridgeContext.

A node that holds a Graphics2D image.

Renders the attributed character iterator of a TextNode.

Generic XML handler for SVG.

Abstract base class for Graphics2DAdapter implementations.

A base GOCA drawing order

LayoutManager handling the common tasks for the fo:instream-foreign-object and fo:external-graphics formatting objects

Base class for factory classes which instantiate IFDocumentHandlers and provide information about them.

Abstract PDFImage implementation for the PDF renderer.

The base class for most LayoutManagers.

Abstract base class for the XMP and RDF root nodes.

Abstract base class for objects that are processed by the renderer outside of the actual document.

Common base class for the fo:page-number-citation and fo:page-number-citation-last objects.

Pages contain the data objects that comprise a presentation document.

Abstract base class for a page sequence layout manager.

Abstract base class for renderers like PDF and PostScript where many painting operations follow similar patterns which makes it possible to share some code.

Base class for PDF font streams.

Base postscript commment element class

Base class for the PostScript-specific extension elements.

Abstract base class for all renderers.

Base class for factory classes which instantiate Renderers and provide information about them.

An abstract class which encapsulates the common features of Document and PageGroup resource containers

Abstract base class for the fo:retrieve-marker and fo:retrieve-table-marker formatting objects.

Abstract base class for both TextArea and Character.

A MODCA structured object base class providing support for Triplets

Abstract base class for XML-writing IFDocumentHandler implementations.

Event producer for accessibility-related events.

Utilities for java.text.AttributedCharacterIterator.

An Active Environment Group (AEG) is associated with each page, and is contained in the page's begin-end envelope in the data stream.

Exception thrown when attempting to decode a truetype font file and a format constraint is violated.

Holds the metrics of a single character from an AFM file.

Parses the contents of a Type 1 AFM font metrics file into an object structure (AFMFile).

This class extends the org.apache.fop.fo.StringProperty.Maker inner class in order to provide a static property maker.

Handles the drawing of borders/lines in AFP

Constants used by the AFP renderer.

Factory for high level data objects (Image/Graphics etc)

A painter of rectangles in AFP

Intermediate format document handler factory for AFP output.

Event producer interface for AFP-specific events.

This is the pass-through value object for the AFP extension.

Factory for the ContentHandler that handles serialized AFPPageSetup instances.

This class encapsulates the font attributes that need to be included in the AFP data stream.

The config object for AFP fonts, these differ from the the more generic fonts (TTF and Type1).

Parses any AFP foreign attributes

Graphics2DAdapter implementation for AFP.

An AFP specific implementation of a Batik SVGImageElementBridge

PDFImageHandler implementation which handles Graphics2D images.

ImageHandler implementation which handles ImageRawJPEG instances.

PDFImageHandler implementation which handles RenderedImage instances.

A list of parameters associated with an image

Represents the "include-form-map" extension in the FO tree.

This is the pass-through value object for the AFP extension.

Line data information

Holds the current page fonts

This class extends the org.apache.fop.render.afp.extensions.AbstractAFPExtensionObject class.

This is the pass-through value object for the AFP extension.

This class extends the org.apache.fop.extensions.ExtensionObj class.

This keeps information about the current painting state when writing to an AFP datastream.

The AFP renderer config object.

An enumeration for the various images modes available to the AFP renderer.

AFP-specific renderer context class.

The AFP image information

Rendering context for AFP (MO:DCA) production.

The level at which a resource is to reside in the AFP output

Manages the creation and storage of document resources

Enumeration of the AFP shading modes.

AFP XML handler for SVG.

Bridge class for the <text> element.

Renders the attributed character iterator of some text.

PDFImage implementation for alpha channel "images".

The ArabicScriptProcessor class implements a script processor for performing glyph substitution and positioning operations on content associated with the Arabic script.

Base object for all areas.

Event producer interface for events related to the area tree.

Area tree handler for formatting objects.

This is the model for the area tree object.

This is a parser for the area tree XML (intermediate format) which is used to reread an area tree (or part of it) into memory again for rendering to the final output format.

ASCII Hex filter for PDF streams.

Encapsulates a font attribute value

The AWTRender outputs the pages generated by the layout engine to a Swing window.

Represents the 4 bytes that specify the axis-area rotation reference coordinate system

Inner class for creating instances of this property

This is a the breaking algorithm that is responsible for balancing columns in multi-column layout.

Base class for all Base 14 fonts.

A base 14 font collection for graphics 2D

An inline area produced by an fo:basic-link element.

This Element Mapping is for Batik SVG Extension elements of the http://xml.apache.org/batik/ext namespace.

Helper utilities for Apache Batik.

Bidirectional class utilities.

Layout manager for fo:bidi-override.

A utility class for performing bidirectional resolution processing.

Bitmap image.

The Bitmap renderer config data object.

Configurator for bitmap output.

Provider class for the event producer.

This class holds settings used when rendering to bitmaps.

Class modelling the fo:block object.

LayoutManager for a block-container FO.

LayoutManager for a block FO.

Provider class for the event producer.

A BlockParent holds block-level areas.

A mapping position.

This class is a container for the areas that may be generated by an fo:region-body.

Class modelling the fo:bookmark object, first introduced in the XSL 1.1 WD.

An instance of this class is either a PDF bookmark-tree and its child bookmark-items, or a bookmark-item and the child child bookmark-items under it.

Class modelling the fo:bookmark-tree object, first introduced in the XSL 1.1 WD.

Constants for RTF border attribute names, and a static method for converting fo attribute strings.

This keeps all information about borders for current processed page.

This is an abstract base class for handling border painting.

Border properties.

Shorthand parser for the "border-spacing" shorthand property.

Enumeration class for border styles.

Shorthand property parser for Box rounded corner properties

This class represents an unresolved break possibility.

Defines methods to evaluate break opportunities at a particular location in the tree of layout managers.

Defines property access methods for the break-before and break-after properties.

A BuilderContext holds context information when building an RTF document.

A simple cached render pages model.

A class to read the CFF data from an OTF CFF font file.

Class modelling the fo:character object.

Superclass for properties that wrap a character value TODO convert character value to int in order to denote unicode scalar value instead of a single UTF-16 code element

The IBM Font Object Content Architecture (FOCA) supports presentation of character shapes by defining their characteristics, which include font description information for identifying the characters, font metric information for positioning the characters, and character shape information for presenting the character images.

An abstraction that wraps the encoding mechanism for encoding a Unicode character sequence into a specified format.

The IBM Font Object Content Architecture (FOCA) supports presentation of character shapes by defining their characteristics, which include Font-Description information for identifying the characters, Font-Metric information for positioning the characters, and Character-Shape information for presenting the character images.
Presenting a graphic character on a presentation surface requires that you communicate this information clearly to rotate and position characters correctly on the physical or logical page.
This class provides font metric information for a particular font as by the orientation.
This information is obtained directly from the AFP font files which must be installed in the classpath under in the location specified by the path attribute in the afp-font.xml file.

A structure class encapsulating an interval of characters expressed as an offset and count of Unicode scalar values (in an IntBuffer).

Mirror related utilities.

Script related utilities.

This class implements a simple char vector with access to the underlying array.

Factory for ChoiceFieldPart.

This class enumerates all supported CID font types.

Declares methods to retrieve font information (glyph indices, widths, unicode values) from a CID font.

This is a decorator to block calls to close() to the underlying stream.

A segment in a cmap table of format 4.

This class is a superclass for the two collapsing border models defined in the XSL 1.0 specification.

Inner class for creating instances of ColorTypeProperty

Generic Color helper class.

Helper class maintaining a record of occupied columns and an index to the next non-occupied column.

Class holding a number of columns making up the column setup of a row.

Options parses the commandline arguments

Store all common absolute position properties.

Classes that implement this interface support the common accessibility properties.

Stores all common border and padding properties.

Collection of CommonFont properties

Store all common margin properties for blocks.

Store all common relative position properties.

A utility class that provides helper methods for implementing equals and hashCode.

This class extends Property.Maker with support for sub-properties.

A class that holds the three possible values for a border-before/after on a table-cell, in the collapsing model.

Class modelling the fo:conditional-page-master-reference object.

Inner class for creating instances of CondLengthProperty

A java2d configured font collection

Container area for inline container.

EventListener interface for objects which want to get notified when ContentHandler implementing the ObjectSource interface has finished parsing.

This class holds references to various XML handlers used by FOP.

This class contains utility methods for conversions, like a java.lang.String to an array of int or double.

A representation of the cross-reference data to be output at the end of a PDF file.

A cross-reference table, as described in Section 3.4.3 of the PDF 1.5 Reference.

CTMHelper converts FOP transformation matrices to those suitable for use by the PDFRenderer.

Abstract base class for custom fonts loaded from files, for example.

FontMetricsMapper that delegates most methods to an underlying FontMetrics instance.

A data stream is a continuous ordered stream of data elements and objects conforming to a given format.

Class modelling the fo:declarations object.

Parses the morge generic font information.

Represents a font object within the FOP conf.

Default implementation of the MonochromeBitmapConverter which uses the Java Class Library to convert grayscale bitmaps to monochrome bitmaps.

Default script processor, which enables default glyph composition/decomposition, common ligatures, localized forms and kerning.

This class delegates all FO events to another FOEventHandler instance.

The DelimitedTextRange class implements the "delimited text range" as described by XML-FO 1.1 §5.8, which contains a flattened sequence of characters.

Class for named destinations in PDF.

An instance of this class is named destination from fox:destination

Dimensioned property maker.

Exception thrown during when attempting to map glyphs to associated characters in the case that the associated characters do not represent a compact interval.

The document is the highest level of the MO:DCA data-stream document component hierarchy.

ContentHandler that handles the IF document navigation namespace.

ContentHandlerFactory which constructs ContentHandlers that build DOM Documents.

Implementation of AbstractOutlineFont that supports double-byte fonts (CID Keyed font (Type 0)).

A dummy implementation of PercentBaseContext

This class represents an effective row in a table and holds a list of grid units occupying the row as well as some additional values.

Implement this interface to receive notifications on element lists.

Abstract base class for Element Mappings (including FO Element Mappings) which provide the framework of valid elements and attributes for a given namespace.

This class keeps track of all configured ElementMapping implementations which are responsible for properly handling all kinds of different XML namespaces.

FontInfo contains meta information on fonts (where is the metrics file etc.) TODO: We need to remove this class and think about more intelligent design patterns (Data classes => Procedural code)

This class enumerates all supported encoding modes for fonts: auto, single-byte and CID.

A length quantity in XSL which is specified as an enum, such as "auto"

Superclass for properties that wrap an enumeration value

Creates an EnvironmentProfile that sets the environment in which a FOP instance is run.

This class enables to transcode an input to a EPS document.

Part factory for "equals".

The Extended Resource Local Identifier triplet specifies a resource type and a four byte local identifier or LID.

Element mapping for FOP's proprietary extension to XSL-FO.

Class for the fox:external-document extension element.

Class modelling the fo:external-graphic object.

Creator of MO:DCA structured field objects

Filled area.

An absolute length quantity in XSL

Class modelling the fo:float object.

LayoutManager for an fo:flow object.

Base class for representation of formatting objects and their processing.

Abstract base class for representation of mixed content formatting objects (= those that can contain both child FONodes and #PCDATA).

Element mapping class for all XSL-FO elements.

Base class for nodes in the XML tree

Function for AdvancedMessageFormat to retrieve context info from an FONode.

Adds a list of fonts to a given font info list

Fop cache (currently only used for font info caching)

Sets up a set of fonts

An interface for parsing font configuration information.

This interface enhances the font metrics interface with access methods to value needed to register fonts in various target formats like PDF or PostScript.

A factory that provides the font detecting machanism.

Event listener interface for font-related events.

Event producer for fonts-related events.

Property class for the font-family property.

Helps to autodetect/locate available operating system fonts.

Implementers provide find method for searching native operating system for available fonts.

Attempts to determine correct FontInfo

Command-line application to list available fonts and to optionally produce sample pages with those fonts.

Base class for font loaders.

Configurator of the FontManager

Adds method to retrieve the actual Font for use by Java2DRenderers.

Encapsulates a font substitution qualifier

Helper class for automatic font selection.

A shorthand parser for the font shorthand property

Inner class for creating instances of FontShorthandProperty

Represents a font with information on how it can be used from XSL-FO.

Encapsulates a pair of substitution qualifiers

Configures a font substitution catalog

Matcher interface for FontTriplet.

Font weight property maker.

Class modelling the fo:footnote object.

Layout manager for footnote bodies.

Primary class that activates the FOP process for embedded usage.

A Character set for a normal FOP font

EventListener proxy that inspects all events and adjusts severity levels where necessary.

Factory class which instantiates new Fop and FOUserAgent instances.

Proc Set with FOP-specific procs.

A RtfAttributes subclass that adds some helper set methods.

Example servlet to generate a PDF from a servlet.

The FOPTextHandlerAdapter class is an adapter class to permit use of FOPTextHandler without incurring deprecation warnings caused by the underlying org.apache.xmlgraphics.java2d.TextHandler.drawString(String...) method.

Class for reporting back formatting results to the calling application.

SAX Handler that passes parsed data to the various FO objects, where they can be used either to build an FO Tree, or used by Structure Renderers to build other data structures.

This is the user agent for FOP.

Provider class for the event producer.

Class modelling the from-parent Property Value function.

A Fully Qualified Name triplet enable the identification and referencing of objects using Gloabl Identifiers (GIDs).

Abstract Base class for XSL-FO functions

Generic shorthand parser for ListProperties

The GlyphClassMapping interface provides glyph identifier to class index mapping support.

Interface for testing the originating (source) character context of a glyph sequence.

.Base class implementation of glyph coverage table.

The GlyphDefinitionSubtable implements an abstract base of a glyph definition subtable, providing a default implementation of the GlyphDefinition interface.

Stores the mapping of a text fragment to glyphs, along with various information.

empty mapping table base class

The MappingRange class encapsulates a glyph [start,end] range and a mapping index.

Function formatting a character to a glyph name.

The GlyphPositioning interface is implemented by a glyph positioning subtable that supports the determination of glyph positioning information based on script and language of the corresponding character content.

The GlyphPositioningSubtable implements an abstract base of a glyph subtable, providing a default implementation of the GlyphPositioning interface.

The Anchor class implements a anchor record, comprising an X,Y coordinate pair, an optional anchor point index (or -1), and optional X or Y device tables (or null if absent).

The MarkAnchor class is a subclass of the Anchor class, adding a mark class designation.

The Value class implements a positioning value record, comprising placement and advancement information in X and Y axes, and optionally including device data used to perform device (grid-fitted) specific fine grain adjustments.

The GlyphSubstitution interface is implemented by a glyph substitution subtable that supports the determination of glyph substitution information based on script and language of the corresponding character content.

The GlyphSubstitutionSubtable implements an abstract base of a glyph substitution subtable, providing a default implementation of the GlyphSubstitution interface.

The Ligature class implements a ligature lookup result in terms of a ligature glyph (code) and the N+1...

The GlyphSubtable implements an abstract glyph subtable that encapsulates identification, type, format, and coverage information.

The ChainedClassSequenceRule class implements a subclass of ClassSequenceRule that supports matching on a specific glyph class sequence in a specific chained contextual.

The ChainedGlyphSequenceRule class implements a subclass of GlyphSequenceRule that supports matching on a specific glyph sequence in a specific chained contextual.

The CoverageSequenceRule class implements a subclass of Rule that supports matching on a specific glyph coverage sequence.

The HomogenousRuleSet class implements a collection of rules, which must be the same rule type (i.e., same concrete rule class) or null.

The LookupTable class comprising an identifier and an ordered list of glyph subtables, each of which employ the same lookup identifier.

The RuleLookup class implements a rule lookup record, comprising a glyph sequence index and a lookup table index (in an applicable lookup list).

The UseSpec class comprises a lookup table reference and the feature that selected the lookup table.

Go to Page Dialog.

Helper class to draw gradients in PostScript.

The beginning of a filled region (graphics area).

A GOCA graphics rectangular box

A GOCA graphics string

A GOCA graphics data

The end of a prolog.

A GOCA graphics arc (circle/ellipse)

A GOCA graphics straight line drawn from the given absolute position

Used primarily by BorderPainter, implementations are created for rendering primitive graphical operations.

Sets the arc parameters for a GOCA graphics arc (circle/ellipse)

Sets the current painting position of the graphics object

Sets the value of the current line type attribute when stroking GOCA shapes (structured fields)

Sets the foreground mix mode.

Sets the current processing color for the following GOCA structured fields

The GujaratiScriptProcessor class implements a script processor for performing glyph substitution and positioning operations on content associated with the Gujarati script.

This class has a few convenient static methods for number quantization.

Function formatting a number or character to a hex value.

This class is used to pass information to the getNextBreakPoss() method concerning hyphenation.

This class represents a hyphenated word.

This tree structure stores the hyphenation patterns in an efficient way for fast lookup.

This class is the main entry point to the hyphenation package.

This class represents the IOCA IDE Structure parameter (X'9B').

This class allows to concatenate multiple intermediate format files to a single output file in the final format.

intermediate format content handler

Interface used to paint whole documents layouted by Apache FOP.

This class is a simple proxy that delegates all method calls to another IFDocumentHandler instance.

Exception thrown by code dealing with FOP's intermediate format.

Part factory for "if".

a group

InputHandler for the intermediate format XML as input.

This is a parser for the intermediate format XML which converts the intermediate file into IFPainter events.

The Intermediate Format renderer configuration data object.

IFPainter implementation that serializes the intermediate format to XML.

a state class for intermediate format data

Image area for external-graphic.

The IM Image Cell Position structured field specifies the placement, size, and replication of IM image cells.

An IOCA Image Content

This ImageConverter converts SVG images to Java2D.

ImageDataDescriptor

ImageEncoder implementation for JPEG images.

This interface is a service provider interface for image handlers.

This class holds references to various image handlers.

The IM Image Input Descriptor structured field contains the descriptor data for an IM image data object.

Helper class which calculates the size and position in the viewport of an image.

Factory class for the ImageLoader for WMF (Windows Metafile).

ImageLoader for WMF (Windows Metafile).

The IM Image Output Control structured field specifies the position and orientation of the IM image object area and the mapping of the image points to presentation device pels.

Contains the image points that define the IM image raster pattern.

PDFImage implementation for the PDF renderer which handles raw CCITT fax images.

An Image Segment is represented by a set of self-defining fields, fields that describe their own contents.

Misc.utilities for images handling This class belongs to the fo:external-graphic tag processing.

An IM image data object specifies the contents of a raster image and its placement on a page, overlay, or page segment.

An Include Object structured field references an object on a page or overlay.

The Include Page Segment structured field references a page segment resource object that is to be presented on the page or overlay presentation space.

This property maker handles the calculations described in 5.3.2 which involves the sizes of the corresponding margin-* properties and the padding-* and border-*-width properties.

Default syllabizer.

Abstract syllabizer.

Class modelling the fo:inline formatting object.

This is the inline block area class.

Represents a list of inline Knuth elements.

Class modelling the commonalities of several inline-level formatting objects.

Provider class for the event producer.

Inline parent area.

Class modelling the commonalities of layoutmanagers for objects which stack children in the inline direction, such as Inline or Line.

StreamCache implementation that uses temporary files rather than heap.

A custom AWT font collection

LayoutManager for the fo:instream-foreign-object formatting object

Element mapping for FOP's internal extension to XSL-FO.

The Invoke Medium Map structured field identifies the Medium Map that is to become active for the document.

Interface for classes containing headers.

Interface for classes containing images.

Interface for objects containing Commands

Options for configuring the rtf elements.

Interface for RtfElements that can contain RtfText elements.

Interface for objects containing page numbers

Interface for classes containing Paragraphs with Keep Together

Interface for classes containing templates.

Interface which enables an implementing class to contain linear text runs.

Used to get information about tables, for example when handling nested tables.

IFDocumentHandler implementation that produces Graphics2D instance.

Graphics2DAdapter implementation for Java2D.

Image handler implementation that paints Graphics2D image on another Graphics2D target.

IFPainter implementation that paints on a Graphics2D instance.

The Java2D renderer configuration data object.

Configurerer for Java 2D renderer

Rendering context for Java2D painting.

Java2D XML handler for SVG (uses Apache Batik).

Rendering-related utilities for Java2D.

Class for properties that wrap Keep values

Keep Value Stores the different types of keeps in a single convenient format.

The KhmerScriptProcessor class implements a script processor for performing glyph substitution and positioning operations on content associated with the Khmer script.

An instance of this class represents an unbreakable piece of content with fixed width: for example an image, a syllable (but only if letter spacing is constant), ...

An instance of this class represents a piece of content with adjustable width: for example a space between words of justified text.

An instance of this class represents information about a feasible breaking point; it does not represent any piece of content.

Represents a list of Knuth elements.

Provides utility methods for manipulating language tags compliant with the RFC 3066 specification available at http://www.ietf.org/rfc/rfc3066.txt.

Exception thrown by FOP if an unrecoverable layout error occurs.

The interface for all LayoutManagers.

The default LayoutManager maker class

a layout manager maker

a layout manager maker

a layout manager maker

a layout manager maker

a layout manager maker

a layout manager maker

a layout manager maker

a layout manager maker base class

a layout manager maker

a layout manager maker

This class is used to defer the loading of a font until it is really used.

Class modelling the fo:leader object.

Base LayoutManager for leaf-node FObj, ie: ones which have no children.

A length quantity in XSL

Superclass for properties wrapping a LengthPair value

Superclass for properties wrapping a Length value.

Superclass for properties that contain LengthRange values

The line area.

Line breaking utilities.

A maker which calculates the line-height property.

Line layout possibilities.

Link resolving for resolving internal links.

Class modelling the list block fo:list-block object.

This class is the base class for all kinds of elements that are added to element lists.

Class modelling the list item fo:list-item-body object.

Class modelling the list item fo:list-item-label object.

Superclass for properties that are lists of other properties

Provides helper functions for List.

EventListener implementation that redirects events to Commons Logging.

Mac font directory finder

The main-reference-area generated by an fo:region-body This object holds one or more span-reference-areas (block-areas stacked in the block progression direction) See fo:region-body definition in the XSL Rec for more information.

The Map Container Data structured field specifies how a presentation data object that is carried in an Object Container is mapped into its object area.

The Map Image Object (MIO) structured field specifies how an image data object is mapped into its object area.

The Map Page Segment structured field identifies page segments that are required to present a page on a physical medium.

Class modelling the marker fo:markerobject.

A class to register and resolve markers.

An exception to handle maximum sizes being exceeded.

Frequently used MIME types for various file formats used when working with Apache FOP.

This class holds the resolved (as mpoints) form of a LengthRange or Space type property value.

Interface for converters that convert images to monochrome (1-bit, bi-level) bitmap images.

Class modelling the fo:multi-case object.

This utility class helps renderers who generate one file per page, like the PNG renderer.

Class modelling the fo:multi-property-set object.

This interface is used to set the values of a font during configuration time.

This class is a named destination element for use in the intermediate format.

native image handler

Abstract base class for text painters that use specialized text commands native to an output format to render text.

Handy class for wrapping runtime Exceptions with a root cause.

The No Operation structured field may be used to carry comments or any other type of unarchitected data.

Class providing an iterator for zero characters.

Implementation of Number to String Conversion algorithm specified by XSL Transformations (XSLT) Version 2.0, W3C Recommendation, 23 January 2007.

Inner class for making NumberProperty objects

An interface for classes that can participate in numeric operations.

A numeric property which hold the final absolute result of an expression calculations.

The Object Area Position structured field specifies the origin and orientation of the object area, and the origin and orientation of the object content within the object area.

The Object Byte Extent triplet is used to specify the number of bytes contained in an object

Object containers are MO:DCA objects that envelop and carry object data.

An object stream, as described in section 3.4.6 of the PDF 1.5 Reference.

The OCA color space is a subset of RGB that includes a limited set of colors.

This class wraps ExtensionAttachments which cannot be transported inside the area tree but need to be handled in the AreaTreeHandler.

Loads a TrueType font into memory directly from the original font file.

Represents table names as found in a TrueType font's Table Directory.

Class providing an iterator for one character.

Version of the PostScript table (post) contained in this font.

Inner class for creating instances of OptionalCharacterProperty

Script tags defined by OTF specification.

An overlay is a MO:DCA-P resource object.

The page.

Renderer that prints through java.awt.PrintJob.

Handles the breaking of pages in an fo:flow

Swing event fired whenever the current page selection of a PreviewPanel changes.

The Page Descriptor structured field specifies the size and attributes of a page or overlay presentation space.

A page group is used in the data stream to define a named, logical grouping of sequential pages.

Class modelling the fo:page-number object.

Class modelling the fo:page-number-citation-last object from XSL 1.1.

LayoutManager for the fo:page-number-citation formatting object.

LayoutManager for the fo:page-number formatting object

Exception thrown by FOP if there is a problem while producing new pages.

This class delivers Page instances.

A page segment is a MO:DCA-P resource object.

Class modelling the fo:page-sequence object.

Class modelling the fo:page-sequence-master object.

Enum class for pages mode (all, even, odd pages).

Generic painting information interface

A SAX document handler to read and parse hyphenation patterns from a XML file.

Character Format used in PCL Character Descriptor See Table 11-50 from PCL 5 Specification

IFDocumentHandler implementation that produces PCL 5.

PCL-specific extensions for Apache FOP.

Provider class for the event producer.

Graphics2D implementation implementing PCL and HP GL/2.

Image handler implementation that paints RenderedImage instances in PCL.

IFPainter implementation that produces PCL 5.

The PCL renderer configuration data parser.

Wrapper on the RendererContext to access the information structure for drawing the XML document.

Rendering context for PCL production.

Utility class for handling all sorts of peripheral tasks around PCL generation.

PCL XML handler for SVG.

Extension element for pdf:action.

Bridge class for the <a> element.

class representing an object which is a list of annotations.

Class representing an array object.

BridgeContext which registers the custom bridges for PDF output.

PDFStream for embeddable OpenType CFF fonts.

Class representing a "character identifier" font (p 210 and onwards).

class representing system information for "character identifier" fonts.

Class representing the CMap encodings.

PDF Color object.

PDF Color space.

Generator class encapsulating all object references and state necessary to generate a PDF content stream.

class representing a named destination

Represents a device-specific color space.

Class representing a PDF document.

Configurator class for PDFDocumentGraphics2D.

Intermediate format document handler factory for PDF output.

This class provides the element mapping for the PDF-specific extensions.

This is the pass-through value object for the PDF extension.

Class representing an /EmbeddedFiles dictionary object (name tree).

This interface defines the contract for classes implementing PDF encryption.

This class acts as a factory for PDF encryption support.

This class holds the parameters for PDF encryption.

Provider class for the event producer.

Factory for the ContentHandler that handles serialized PDFExtensionAttachment instances.

Class representing a /FileSpec object.

PDF Filter exception.

Text Painter for Batik's flow text extension.

Class representing a /Font object.

A common ancestor for Type1, TrueType, MMType1 and Type3 fonts (all except base 14 fonts).

Class representing a Type0 font.

Class representing a Type3 font.

class representing a PDF Function.

Class representing a /GoToR object.

May be used to give proper feedback to the user when a particular PDF profile is being used that disallows transparency.

Class representing a /ExtGState object.

Special PDFStream for ICC profiles (color profiles).

Interface for a PDF image.

PDFImageHandler implementation which handles Graphics2D images.

Image handler implementation which handles raw JPEG images for PDF output.

Image handler implementation which handles RenderedImage instances for PDF output.

PDF XObject A derivative of the PDF Object, is a PDF Stream that has not only a dictionary but a stream of image data.

The standard keys in the Document Information Dictionary

PDF Action which executes some JavaScript code.

Optional Content Group Dictionary, which we will call a 'layer'.

Extension element for pdf:layer.

Handles the creation of the logical structure in the PDF document.

Class representing a PDF name object.

Class representing a PDF name tree node.

Extension element for pdf:navigator.

Class representing a PDF name object.

Class representing a PDF number tree node.

generic PDF object.

This represents a single Outline object in a PDF, including the root Outlines object.

Class representing a /Page object.

class representing a /Pages object.

This keeps information about the current painting state when writing to pdf.

Base class for PDF painting operations.

This class allows tracks the enabled PDF profiles (PDF/A and PDF/X) and provides methods to the libarary and its users to enable the generation of PDFs conforming to the enabled PDF profiles.

Class representing a PDF object reference.

The PDF renderer configuration data parser.

Defines a number of standard constants (keys) for use by the RendererContext class.

The renderer options configuration data.

The PDF resource context.

Class representing a Root (/Catalog) object.

class representing a PDF Smooth Shading object.

Class representing a PDF Structure Element.

Class representing a PDF /StructTreeRoot dictionary.

Element Bridge for SVG 1.2 flow text, so those texts can be painted using PDF primitives.

PDF information structure for drawing the XML document.

This class represents a simple number object.

Utility class for generating PDF text objects.

Class representing ToUnicode CMaps.

Special PDFStream for embeddable TrueType fonts.

class used to create a PDF Uri link

Class representing a W array for CID fonts.

Enum class for PDF/X modes.

Interface for objects that can be used as base objects for percentage computations

PercentBaseContext implementation to track base widths for percentage calculations.

Class that represents the contents of a PFB file.

This class represents a PFM file (or parts of it) as a Java object.

A tool which reads PFM files from Adobe Type 1 fonts and creates XML font metrics file for use in FOP.

Document handler factory for PNG output.

The PNG renderer configuration data object.

RendererMaker for the PNG Renderer.

Optional interface which indicates that glyph positioning is supported and, if supported, can perform positioning.

A shorthand parser for the position shorthand.

Image preloader for SVG images.

The Preprocess Presentation Object structured field specifies presentation parameters for a data object that has been mapped as a resource.

This triplet is used to specify the resulting appearance when data in a new presentation space is merged with data in an existing presentation space.

Presentation text data contains the graphic characters and the control sequences necessary to position the characters within the object space.

The Presentation Text object is the data object used in document processing environments for representing text which has been prepared for presentation.

AWT Viewer's "About" dialog.

This class represents a primary grid unit of a spanned cell.

Abstract base class of "Print" type renderers.

RendererMaker for the Print Renderer.

Thread-safe cache that minimizes the memory requirements by fetching an instance from the cache that is equal to the given one.

Exception factory for PropertyException.

Class containing the collection of properties for a given FObj.

Base class for all property makers

Class modelling the proportional-column-width function.

BridgeContext which registers the custom bridges for PostScript output.

Comment after element

Comment before element

Event producer interface for events generated by the PostScript renderer.

This is the pass-through value object for the PostScript extension.

ContentHandler (parser) for restoring PSExtension objects from XML.

Utility code for font handling in PostScript.

PostScript-specific implementation of the BorderPainter.

Specialized image handler interface for PostScript output.

Image handler implementation which handles vector graphics (Java2D) for PostScript output.

Image handler implementation which handles undecoded JPEG images for PostScript output.

Image handler implementation which handles RenderedImage instances for PostScript output.

Utility code for rendering images in PostScript.

IFPainter implementation that produces PostScript.

The PostScript renderer configuration data parser.

Defines a number of standard constants (keys) for use by the RendererContext class.

Rendering context for PostScript production.

Element for postscript setpagedevice instruction This is a an extension which provides a pass-through value dictionary object for the postscript setpagedevice instruction.

This is the pass-through value object for the PostScript extension.

Defines the set of supported ImageFlavors for the PostScript renderer.

PostScript information structure for drawing the XML document.

Renders the attributed character iterator of a TextNode.

This is a wrapper for PSGenerator that contains some members specific for streaming TrueType fonts to a PostScript document.

Streams a TrueType font according to the PostScript format.

Generator class for PTOCA data structures.

Producer interface that is passed to a PresentationTextObject to produce PTOCA control sequences using a PtocaBuilder.

A font where each character is stored as an array of pixels (a bitmap).

Setup the element mapping for XMP metadata.

Kind of a super-iterator that iterates through child nodes of an FONode, in turn managing character iterators for each of them.

Class modelling the fo:region-after object.

Class modelling the fo:region-before object.

Class modelling the fo:region-end object.

Abstract base class for fo:region-start and fo:region-end.

Region Viewport area.

This class represent a node in a property expression tree.

The interface is used by the AWT preview dialog to reload a document.

Implementations of this interface have all the renderer-specific configuration data found in the FOP-conf.

Implementations of this interface enumerate the various renderer configuration options available to users in the FOP conf.

Base class for a wrapper around RendererContext to access its properties in a type-safe, renderer-specific way.

Event producer interface for rendering-specific events.

Factory for FOEventHandlers and Renderers.

Implementations of this interface provide context information needed by supporting classes during specific tasks (like image rendering).

Class modelling the fo:repeatable-page-master-alternatives object.

Resolvable Interface.

A Resource Environment Group contains a set of resources for a document or for a group of pages in a document.

Provider class for the event producer.

This class is used when two-pass production is used to generate the PostScript file (setting "optimize-resources").

A Resource Object Type Triplet

Implementations of this interface will be builders for ResourceResolver, they bind URI schemes to their respective resolver.

Class modelling the fo:retrieve-table-marker formatting object.

Class modeling the fo:root formatting object.

RtfContainer that encloses footers

The opposite of RtfAfter

RTF Bookmark container implementation.

An RtfElement that can contain other elements.

Base class for all elements of an RTF file.

Provider class for the event producer.

Creates an RTF image from an external graphic file.

Used to add extra table rows after a row that contains a nested table:

Maker class for RTF support.

Model of an RTF footnote.

RTF Handler: generates RTF output using the structure events from the FO Tree sent to this structure handler.

Process "jfor-cmd"

Model of an RTF line break.

Model of an RTF list item, which can contain RTF paragraphs.

Class to handle bullet list style.

Class to handle text list style.

Null container.

Specifies rtf control words.

Model of an RTF page break.

Page number citation container.

Class which represents a paragraph break.

This class creates objects which are missing from the XSL:FO but are required by the RTF format.

This class is responsible for saving space-before/space-after attributes history and adding spacing to established candidates (i.e.

Plain text in a RTF file, without any formatings.

Thrown when a method call would lead to an invalid RTF document structure.

Container for RtfRow elements.

Container for RtfTableCell elements.

Model of a text run (a piece of text with attributes) in an RTF document.

Enumeration class for rule styles.

Interface for providing script specific context testers.

Serialize hyphenation patterns.

Interface used to provide parsing capabilities to Properties with shorthand characteristics (those with multiple components).

Common base class for side regions (before, after, start, end).

Class to implement a simple lookup context for a single percent base value.

A simple SVG user agent.

Generic SingleByte font

Class modelling the fo:single-page-master-reference object.

Inline space area.

A block-stacking layout manager for an FO that supports spaces, border and padding.

Base class used for handling properties of the fo:space-before and fo:space-after variety.

Special CorrespondingPropertyMaker that sets the conditionality subproperty correctly for space-* properties.

Position class for break possibilities.

Accumulate a sequence of space-specifiers (XSL space type) on areas with a stacking constraint.

A maker which creates 'letter-spacing' and 'word-spacing' properties.

Standard attributes, as defined in section 10.7.5 of the PDF Reference, Fourth edition (PDF 1.5).

Class modelling the fo:static-content object.

A very fast implementation of PropertyList that uses arrays to store the explicit set properties and another array to store cached values.

Implementing object is able to write to an OutputStream

This class is serves as a factory from

Class providing an (FO flavored) char iterator for a string.

Inner class for making instances of StringProperty

An AFP object which is able to know its own data length prior to writeToStream()

An element in the document's structure tree.

An object that represents the structure of the document in the output format.

Receive notifications relating to the structure tree of an FO document.

Classes that implement this interface can be added to a PageSequenceMaster, and are capable of looking up an appropriate SimplePageMaster.

ContentHandlerFactory which constructs ContentHandlers that build SVG DOM Documents.

This class is the default context for a particular element.

Event producer interface for SVG-related events.

Class for SVG element objects.

Some utilities for creating svg DOM documents and elements.

This class implements org.apache.fop.layout.FontMetrics and is added to the hash table in FontInfo.

Class modelling the fo:table-and-caption property.

Provides methods to convert the attributes to RtfAttributes.

A table border preference property maker.

LayoutManager for a table-caption FO.

A common class for fo:table-body and fo:table-row which both can contain fo:table-cell.

A table-column width specification, possibly including some number of proportional "column-units".

Layout manager for table contents, particularly managing the creation of combined element lists.

Event producer interface for table-specific XSL-FO validation messages.

Common base class for table-related FOs