All Classes

Class modelling the abs Number Function.

Base class for the AFP-specific extension elements.

This is the base class for all data stream objects.

structured field type codes

The base class for nearly all LayoutManagers.

Abstract IFDocumentHandler implementation for producing bitmap images.

Abstract base class for breakers (page breakers, static region handlers etc.).

Abstract base class for code point mapping classes (1-byte character encodings).

Abstract base class used by the ImageObject and GraphicsObject which both have define an ObjectEnvironmentGroup

A base class that encapsulates common features of ActiveEnvironmentGroup and ResourceEnvironmentGroup

Abstract base class for the PFM and TTF Reader command-line applications.

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

Bridge class for the <text> element.

This is the common base class of all of FOP's transcoders.

Common base class for the fo:instream-foreign-object and fo:external-graphic flow formatting objects.

A base class encapsulating the structure of coordinate based GOCA objects

A base container of prepared structured AFP objects

Abstract base class for IFDocumentHandler implementations.

Abstract base class for IFPainter implementations.

Abstract base class for ImageHandler implementations that process Java2D images through the Graphics2DImagePainter interface.

Common superclass for fo:list-item-label and fo:list-item-body.

This is the base class for all named data stream objects.

A font defined as a set of lines and curves as opposed to a bitmap font.

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

Abstract base class for the fo:page-sequence formatting object and the fox:external-document extension object.

A base class which holds information about the current painting state.

Base class for the PDF-specific extension elements.

This is an abstract base class for PDF streams.

Base class for the PostScript-specific extension elements.

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

Abstract base classes for renderer-related configurator classes.

Abstract base class for RenderingContext implementations.

An abstract container of resource objects

An abstract class encapsulating an MODCA structured object

A simple implementation of a MOD:CA triplet

Abstract xml renderer base class.

Helper class for FOP's accessibility features.

Provider class for the event producer.

This class manages actions and action references.

Enumerates the linkplain http://unicode.org/Public/MAPPINGS/VENDORS/ADOBE/stdenc.txt for characters found in a Type1 font.

This class parses a sequence of transformations into an array of AffineTransform instances.

Represents the contents of a Type 1 AFM font metrics file.

Represents a writing direction metrics section from an AFM file.

Sets up a typical Base 12 font configuration for AFP

An AFP specific implementation of a Batik BridgeContext

Interface used to customize the AFP renderer or document handler.

A list of parameters associated with an AFP data objects

IFDocumentHandler implementation that produces AFP (MO:DCA).

AFPElementMapping object provides the ability to extract information from the formatted object that reside in the afp namespace.

Provider class for the event producer.

ContentHandler (parser) for restoring AFPExtension objects from XML.

All implementations of AFP fonts should extend this base class, the object implements the FontMetrics information.

A base collection of AFP fonts

FontInfo contains meta information on fonts

This is a concrete implementation of AbstractGraphics2D (and therefore of Graphics2D) which is able to generate GOCA byte codes.

A graphics object info which contains necessary painting objects

A base abstract AFP image handler

AFPImageHandler implementation which handles CCITT encoded images (CCITT fax group 3/4).

AFPImageHandler implementation which handles raw stream images.

Image handler implementation which handles SVG images for AFP output.

This extension allows to include an AFP form map resource.

AFP information structure for drawing the XML document.

This class represents an AFP-specific extension element to embed Invoke Medium Map (IMM) fields at the beginning of a page group or just prior to a Page.

A common class used to convey locations, dimensions and resolutions of data objects.

This extension allows to include an AFP Page Overlay resource.

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

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

IFPainter implementation that produces AFP (MO:DCA).

A painter of rectangles in AFP

The parser for AFP renderer specific data in the FOP conf.

AFP Renderer configurator

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

An enumeration of the configuration options available for the AFP renderer.

Defines an interface through which external resource objects can be accessed.

A resource level

This class holds resource levels defaults for the various resource types.

TODO better docs Utility for AFP resource handling A utility class to read structured fields from a MO:DCA document.

Manages the streaming of the AFP output

Text data information

Specialized TextHandler implementation that the AFPGraphics2D class delegates to to paint text using AFP GOCA text operations.

AFP Unit converter

The alignment context is carried within a LayoutContext and as part of the Knuth Inline elements to facilitate proper line building.

Anchor area for footnote or float.

Utility class which provides common code for the addAreas stage.

Provider class for the event producer.

InputHandler for the area tree XML (the old intermediate format) as input.

Abstract base class for all area tree objects.

PDF Filter for ASCII85.

The attribute qualifier triplet is used to specify a qualifier for a document attribute.

The attribute value triplet is used to specify a value for a document attribute.

RendererMaker for the AWT Preview Renderer.

Class encapsulating functionality for the background-position shorthand.

Inner class to provide shorthand parsing capabilities

Sets up Base 14 fonts

Class modelling the fo:basic-link object.

LayoutManager for the fo:basic-link formatting object

Image flavors used by Batik.

The before-float-reference-area optionally generated by an fo:region-body.

Constants used for bidirectional processing.

Class modelling the fo:bidi-override object.

Library of utility useful conversion methods.

Utility method for dealing with bitmap images.

The parser for the Bitmap renderer configuration data.

Event producer interface for events generated by the bitmap renderers.

An enumeration of the Bitmap renderer configuration opetions available to the user via the FOP conf.

This is the block area class.

Class modelling the fo:block-container object.

Represents a list of block level Knuth elements.

Event producer interface for block-level layout managers.

The interface for LayoutManagers which generate block areas

Base LayoutManager class for all areas which stack their child areas in the block-progression direction, such as Flow, Block, ListBlock.

A BlockViewport.

Class corresponding to the body-start Property Value function.

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

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

This class is the root of the bookmark tree for use in the intermediate format.

This represents an unresolved border element.

This class represents an unresolved border or padding element.

Border painting information

A border's informations, along with the FO element which declared it.

This subclass of LengthProperty.Maker handles the special treatment of border width described in 7.7.20.

Shorthand property parser for Box properties

The set of nodes is sorted into lines indexed into activeLines.

Helper implementations of the BreakOpportunity methods.

A utility class for manipulating break classes (the break-before and break-after properties).

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

CCF Filter class.

A class containing data for a dictionary entry

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

Definition of constants used throughout FOP.

Container data descriptor (to maintain compatibility with pre-year 2000 applications)

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:initial-property-set object.

Inline Area This area is for all inline areas that can be placed in a line area.

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.

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.

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-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.

The SVG user agent.

Class modelling the fo:table object.

LayoutManager for a table-and-caption FO.

Class modelling the fo:table-body object.

Class modelling the fo:table-caption object.

Class modelling the fo:table-cell object.

LayoutManager for a table-cell FO.

Class modelling the fo:table-column object.

Used when handling fo:table to hold information to build the table.

Provider class for the event producer.

PropertyMaker subclass for the column-number property

Class modelling the fo:table-header object.

An abstract base class modelling a TablePart (i.e.

Iterator that lets the table layout manager step over all the rows of a part of the table (table-header, table-footer or table-body).

A Tag Logical Element structured field assigns an attribute name and an attribute value to a page or page group.

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

Ternary Search Tree.