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.

This represents an unresolved padding element.

This object is used by the layout engine to represent a page.

This class is used to calculate the effective boundaries of a page including special-purpose boxes used in prepress.

Shorthand parser for page-break-before, page-break-after and page-break-inside.

Swing listener interface for classes which wish to receive notification of page change events.

Custom Maker for page-height / page-width

Interface to get the page index

Class modelling the fo:page-number-citation object.

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

This class uses the 'format', 'groupingSeparator', 'groupingSize', and 'letterValue' properties on fo:page-sequence to return a String corresponding to the supplied integer page number.

Pages contain the data objects that comprise a presentation document.

Exception factory for PageProductionException.

This class provides utility methods to parse the 'fox:scale' extension attribute.

Represents a page sequence in the area tree.

LayoutManager for a PageSequence.

Class for reporting back formatting results to the calling application.

Class modelling the fo:page-sequence-wrapper object, first introduced in the XSL 1.1 WD.

Page viewport that specifies the viewport area and holds the page contents.

This context is used to manage the "keepn" RTF attribute Used by ParagraphBuilder and JforCmd

This interface is used to connect the XML pattern file parser to the hyphenation tree.

Character Class used in PCL Character Descriptor See Table 11-51 from PCL 5 Specification

Document handler factory for PCL output.

Event producer interface for events generated by the PCL renderer.

This class provides methods for generating PCL print files.

Image handler implementation that paints Graphics2D images in PCL.

This class represents a page format with PCL-specific properties.

The PCL renderer configuration data object.

PCL Renderer configurator

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

Enumeration class for PCL rendering modes.

Table C-1 from http://www.lprng.com/DISTRIB/RESOURCES/DOCS/pcl5comp.pdf

class representing an action object.

Enum class for PDF/A modes.

A graphics node that represents an image described as a graphics node.

Extension element for pdf:array.

Element Bridge for Batik's flow text extension, so those texts can be painted using PDF primitives.

Extension element for pdf:catalog.

Special PDFStream for embeddable CFF fonts.

class representing a /CharProcs dictionary for Type3 fonts.

Class representing a font descriptor for CID fonts.

This class represents a "CIE L*a*b*" color space.

Extension element for collection entries: pdf:{array,boolean,dictionary,name,number,reference,string}.

This class handles the registration of color spaces and the generation of PDF code to select the right colors given a Color instance.

RuntimeException descendant indicating a conformance problem during PDF generation.

Context class which holds state information which should remain in sync over multiple instances of PDFDocumentGraphics2D.

class representing an /Dests dictionary object

Class representing a PDF dictionary object

Extension element for dictionaries: pdf:{catalog,page,dictionary}.

Enumeration type for PDF dictionary extension elements.

This class is a wrapper for the PDFGraphics2D that is used to create a full document around the PDF rendering from PDFGraphics2D.

IFDocumentHandler implementation that produces PDF.

Implementation of the IFDocumentNavigationHandler interface for PDF output.

This class represents an embedded file stream.

Extension element for pdf:embedded-file.

Class representing an /Encoding object.

An implementation of the Standard Security Handler.

Event producer interface for events generated by the PDF renderer.

ContentHandler (parser) for restoring PDF extension objects from XML.

This class provides method to create and register PDF objects.

PDF Filter class.

This class represents a list of PDF filters to be applied when serializing the output of a PDF object.

Text Painter for SVG 1.2 (flow) text.

Class representing a font descriptor (/FontDescriptor object).

Class representing a TrueType font.

Class representing a Type1 or MMType1 font (not necessary for the base 14).

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

class representing a /GoTo object.

PDF Graphics 2D.

PDF-specific implementation of the GraphicsPainter.

Represents an ICCBased color space in PDF.

Identified Dictionary.

PDF Image Element Bridge class for the <image> element when jpeg images.

Image handler implementation which handles CCITT encoded images (CCITT fax group 3/4) for PDF output.

Image handler implementation which handles CCITT encoded images (CCITT fax group 3/4) for PDF output.

Image Handler implementation which handles SVG images.

class representing an /Info object

class used to create a PDF internal link

This class represents the /Launch action.

class representing an /Annot object of /Subtype /Link

Special PDFStream for Metadata.

Class representing a PDF Names object

Navigation Node Dictionary, which we call a 'navigator'.

This class represents a simple number object.

Class representing an "Nums" array object (for Number Trees).

Enumeration type for leaf PDF object extension types used as singletons, dictionary entries, or array entries.

Represents the OutputIntent dictionary.

Extension element for pdf:page.

Class representing a PDF /PageLabels dictionary.

IFPainter implementation that produces PDF.

Class representing a PDF /ParentTree.

class representing a PDF Function.

class representing a rectangle Rectangles are specified on page 183 of the PDF 1.3 spec.

Extension element for pdf:reference.

The PDF renderer configuration data object.

PDF renderer configurator.

Rendering context for PDF production.

Class representing a /Resources object.

This class represents a "Separation" color space.

Class representing a PDF stream.

Class representing a placeholder for a PDF Structure Element.

PDF XML handler for SVG (uses Apache Batik).

Special PDFStream for embedding Type 1 fonts.

Bridge class for the <text> element.

Utility class for generating PDF text objects.

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

Enum class for PDF/UA modes.

This interface is implemented by classes that can be serialized to a PDF file either by serializing the object or by writing a indirect reference to the actual object.

Abstract base class of PDF XObjects.

This interface is used by the layout managers to provide relevant information back to the property percentage resolution logic, that is the percentages based property getValue() functions expect an object implementing this interface as an argument.

a percent specified length quantity in XSL

This class represents a parser for Adobe Type 1 PFB files.

This is a helper class for reading PFM files.

IFDocumentHandler implementation that produces PNG files.

PNG Renderer This class actually does not render itself, instead it extends org.apache.fop.render.java2D.Java2DRenderer and just encode rendering results into PNG format using Batik's image codec

The PNG renderer configuration parser.

A position.

An iterator over Position instances, that is wrapped around another 'parent' Iterator.

Image preloader for WMF images (Windows Metafile).

The Presentation Environment Control structured field specifies parameters that affect the rendering of presentation data and the appearance that is to be assumed by the presentation device.

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.

The Presentation Text Descriptor specifies the units of measure for the Presentation Text object space, the size of the Presentation Text object space, and the initial values for modal parameters, called initial text conditions.

AWT Viewer main window.

Holds a scrollpane with the rendered page(s) and handles actions performed to alter the display of the page.

Renderer that prints through java.awt.PrintJob.

Base Print renderer configurator (mostly handles font configuration)

Base class for all property objects

Class for managing exceptions that are raised in Property processing.

This class holds context information needed during property expression evaluation.

A PropertyListMaker is a factory that creates PropertyLists.

Class to parse XSL-FO property expressions.

Element Bridge for Batik's flow text extension, so those texts can be painted using PostScript primitives.

Custom postscript comment after class

Custom postscript comment before class

IFDocumentHandler implementation that produces PostScript.

Intermediate format document handler factory for PostScript output.

Provider class for the event producer.

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

Factory for the ContentHandler that handles serialized PSSetupCode instances.

Graphics2DAdapter implementation for PostScript.

PostScript Resource class representing a FOP form.

Image handler implementation which handles EPS images for PostScript output.

Image handler implementation which handles CCITT fax images for PostScript output.

Image handler implementation which handles raw (not decoded) PNG images for PostScript output.

Image handler implementation which handles SVG images for PostScript output.

Extension element for fox:ps-page-setup-code.

Comment before element

The PostScript renderer configuration data object.

Postscript renderer config

An enumeration of the PostScript renderer configuration options along with their default values.

Utility class which enables all sorts of features that are not directly connected to the normal rendering process.

Extension element for ps:ps-setpagedevice.

Extension element for fox:ps-setup-code.

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

PostScript XML handler for SVG.

Bridge class for the <text> element.

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

Streams glyphs in accordance with the constraints of the PostScript file format.

Streams a TrueType table according to the PostScript format.

A collection of PTOCA constants.

Represents the top-level "RDF" element used by XMP metadata.

Filled rectangle painting information

Custom Maker adding validity check for reference-orientation

This is an abstract base class for pagination regions.

Abstract base class for fo:region-before and fo:region-after.

Class modelling the fo:region-body object.

This is a region reference area for a page regions.

Class modelling the fo:region-start object.

MOD:CA Registry of object types

Enum class for relative sides.

Interface implemented by all renderers.

Implementations of this interface parse the relevant renderer-specific configuration data within the FOP-conf and create a RendererConfig.

The Render Context for external handlers.

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

Provider class for the event producer.

A runtime exception for handling fatal errors in rendering.

This uses the AreaTreeModel to store the pages Each page is either rendered if ready or prepared for later rendering.

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

Always (pre-) resolved page number area.

Event producer interface for resource events (missing images, fonts etc.).

A Resource Group contains a set of overlays.

This resource structured field begins an envelope that is used to carry resource objects in print-file-level (external) resource groups.

A factory class for ResourceResolvers.

Class modelling the fo:retrieve-marker formatting object.

Represents a rotation value

Attributes for RtfText.

RTF Bookmark.

Singelton of the RTF color table.

The RTF document area, container for RtfSection objects.

Event producer interface for events generated by the RTF renderer.

Base class for rtflib exceptions.

Exception thrown when an image file/URL cannot be read

Models the top-level structure of an RTF file.

RTF font table.

Represents a generator element which says who generated the RTF document.

Creates an hyperlink.

Generates the leader in RTF.

Model of an RTF list, which can contain RTF list items.

Class to handle list styles.

Class to handle number list style.

RtfListTable: used to make the list table in the header section of the RtfFile.

Simplistic options definitions for RTF generation.

Page area container.

Page number container.

Model of an RTF paragraph, which can contain RTF text elements.

Models the keep together attributes of paragraphs

Models a section in an RTF document

This class splits block attributes into space-before attribute, space-after attribute and common attributes.

Converts java Strings according to RTF conventions.

Singelton of the RTF style sheet table.

A cell in an RTF table, container for paragraphs, lists, etc.

Singelton of the RTF style template This class belongs to the jfor:style-template tag processing.

Class which contains a linear text run.

Testing ant task.

Abstract script processor base class for which an implementation of the substitution and positioning methods must be supplied.

This class is a URIResolver implementation that provides access to resources in the WEB-INF directory of a web application using "servlet-content:" URIs.

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

A simple implementation of the OneByteEncoding mostly used for encodings that are constructed on-the-fly.

The interface defines a 1-byte character encoding (with 256 characters).

This class is responsible for solid and double border elements managing.

A space

This class represents an unresolved space element.

Inner class used to create new instances of SpaceProperty

This class resolves spaces and conditional borders and paddings by replacing the UnresolvedListElements descendants by the right combination of KnuthElements on an element list.

Position class for no-break situations.

Store a single Space property value in simplified form, with all Length values resolved.

The span-reference-area.

Standard structure types, as defined in section 10.7.4 of the PDF Reference, Fourth Edition (PDF 1.5).

Set and expose whether an object has started or not.

LayoutManager for an fo:flow object.

Listener interface used by the PreviewDialog.

Interface used to store the bytes for a PDFStream.

A print-file resource group

Exists primarily as a container for its Maker inner class, which is extended by many string-based FO property classes.

Library of utility methods useful in dealing with strings.

A helper class to read structured fields from a MO:DCA document.

Converts structure tree events to SAX events.

Implementations of this interface can return the element in the document's structure tree that they resulted into.

A structure type, as defined in Section 10.6.2 of the PDF Reference, fourth edition (PDF 1.5).

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

Class representing the SVG root element for constructing an SVG document.

Setup the SVG element mapping.

Provider class for the event producer.

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