All Classes and Interfaces
Class
Description
Class modelling the abs Number Function.
Abstract base class for document actions, like "go-to" actions with absolute page coordinates.
Base class for the AFP-specific extension elements.
A base abstract AFP raw stream image handler
This is the base class for all data stream objects.
structured field category codes
structured field type codes
A base AFP painter
The base class for nearly all LayoutManagers.
Abstract base class for binary-writing
IFDocumentHandler implementations.Abstract
IFDocumentHandler implementation
for producing bitmap images.This class keeps information about abstract border element, i.e.
Abstract base class for breakers (page breakers, static region handlers etc.).
Helper class, extending the functionality of the
basic
BlockKnuthSequence.A page break position.
Abstract base class for code point mapping classes (1-byte character encodings).
An abstract configurator
Abstract base class used by the ImageObject and GraphicsObject which both
have define an ObjectEnvironmentGroup
Base class for AFP descriptor objects
A base class that encapsulates common features of
ActiveEnvironmentGroup and ResourceEnvironmentGroup
Base class for factory classes which instantiate FOEventHandlers and provide information
about them.
Abstract base class for the PFM and TTF Reader command-line applications.
A FOP base implementation of a Batik BridgeContext.
Bridge class for the <image> element when jpeg images.
A node that holds a Graphics2D image.
Bridge class for the <text> element.
Renders the attributed character iterator of a
TextNode.This is the common base class of all of FOP's transcoders.
Generic XML handler for SVG.
Common base class for the
fo:instream-foreign-object
and
fo:external-graphic flow formatting objects.Abstract base class for Graphics2DAdapter implementations.
A base class encapsulating the structure of coordinate based GOCA objects
A base GOCA drawing order
A base container of prepared structured AFP objects
LayoutManager handling the common tasks for the fo:instream-foreign-object
and fo:external-graphics formatting objects
Abstract base class for
IFDocumentHandler implementations.Base class for factory classes which instantiate
IFDocumentHandlers and provide
information about them.Abstract base class for IFPainter implementations.
Abstract PDFImage implementation for the PDF renderer.
Abstract base class for ImageHandler implementations that process Java2D images through
the Graphics2DImagePainter interface.
The base class for most LayoutManagers.
Common superclass for
fo:list-item-label and
fo:list-item-body.Abstract base class for the XMP and RDF root nodes.
This is the base class for all named data stream objects.
Abstract base class for objects that are processed by the renderer outside
of the actual document.
A font defined as a set of lines and curves as opposed to a bitmap font.
Common base class for the
fo:page-number-citation and
fo:page-number-citation-last objects.LayoutManager for the fo:page-number-citation(-last) formatting object
Pages contain the data objects that comprise a presentation document.
Abstract base class for the
fo:page-sequence formatting object and the
fox:external-document extension object.Abstract base class for a page sequence layout manager.
A base class which holds information about the current painting state.
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 the PDF-specific extension elements.
Base class for PDF font streams.
A partial implementation of a PDF-specific image handler, containing the code that is
common between image flavors.
This is an abstract base class for PDF streams.
Base postscript commment element class
Base class for the PostScript-specific extension elements.
Base class for the PostScript-specific extension elements.
This class enables to transcode an input to a PostScript document.
Abstract base class for all renderers.
Abstract base classes for renderer-related configurator classes.
Base class for factory classes which instantiate Renderers and provide information
about them.
Abstract base class for RenderingContext implementations.
An abstract class which encapsulates the common features of
Document and PageGroup resource containers
An abstract container of resource objects
Abstract base class for the
fo:retrieve-marker and
fo:retrieve-table-marker formatting objects.An abstract class encapsulating an MODCA structured object
Abstract base class for SVG Painter implementations.
Abstract base class for both TextArea and Character.
A simple implementation of a MOD:CA triplet
A MODCA structured object base class providing support for Triplets
Abstract xml renderer base class.
Abstract base class for XML-writing
IFDocumentHandler implementations.Helper class for FOP's accessibility features.
Event producer for accessibility-related events.
Provider class for the event producer.
Utilities for java.text.AttributedCharacterIterator.
This class manages actions and action references.
A cell playing in the construction of steps for a row-group.
Auxiliary class to store all the informations related to a breaking step.
An Active Environment Group (AEG) is associated with each page,
and is contained in the page's begin-end envelope in the data stream.
Enumerates the linkplain http://unicode.org/Public/MAPPINGS/VENDORS/ADOBE/stdenc.txt for
characters found in a Type1 font.
Formats messages based on a template and with a set of named parameters.
Implementations of this interface do some computation based on the message parameters
given to it.
Implementations of this interface format certain objects to strings.
Represents a message template part.
Implementations of this interface parse a field part and return message parts.
Exception thrown when attempting to decode a truetype font file and a format
constraint is violated.
This class parses a sequence of transformations into an array of
AffineTransform
instances.Holds the metrics of a single character from an AFM file.
Represents the contents of a Type 1 AFM font metrics file.
Parses the contents of a Type 1 AFM font metrics file into an object structure (
AFMFile).Represents a writing direction metrics section from an AFM file.
This class extends the org.apache.fop.fo.StringProperty.Maker inner class
in order to provide a static property maker.
Sets up a typical Base 12 font configuration for AFP
Handles the drawing of borders/lines in AFP
An AFP specific implementation of a Batik BridgeContext
Constants used by the AFP renderer.
Interface used to customize the AFP renderer or document handler.
Factory for high level data objects (Image/Graphics etc)
A list of parameters associated with an AFP data objects
A painter of rectangles in AFP
IFDocumentHandler implementation that produces AFP
(MO:DCA).Intermediate format document handler factory for AFP output.
AFPElementMapping object provides the ability to extract information
from the formatted object that reside in the afp namespace.
Event producer interface for AFP-specific events.
Provider class for the event producer.
This is the pass-through value object for the AFP extension.
ContentHandler (parser) for restoring AFPExtension objects from XML.
Factory for the ContentHandler that handles serialized AFPPageSetup instances.
All implementations of AFP fonts should extend this base class,
the object implements the FontMetrics information.
This class encapsulates the font attributes that need to be included
in the AFP data stream.
A base collection of AFP fonts
The config object for AFP fonts, these differ from the the more generic fonts (TTF and Type1).
The parser for AFP font data.
FontInfo contains meta information on fonts
Parses any AFP foreign attributes
This is a concrete implementation of
AbstractGraphics2D (and
therefore of Graphics2D) which is able to generate GOCA byte
codes.Graphics2DAdapter implementation for AFP.
A graphics object info which contains necessary painting objects
An AFP specific implementation of a Batik SVGImageElementBridge
A base abstract AFP image handler
PDFImageHandler implementation which handles Graphics2D images.
AFPImageHandler implementation which handles CCITT encoded images (CCITT fax group 3/4).
ImageHandler implementation which handles ImageRawJPEG instances.AFPImageHandler implementation which handles raw stream images.
PDFImageHandler implementation which handles RenderedImage instances.
Image handler implementation which handles SVG images for AFP output.
A list of parameters associated with an image
This extension allows to include an AFP form map resource.
Represents the "include-form-map" extension in the FO tree.
AFP information structure for drawing the XML document.
This is the pass-through value object for the AFP extension.
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.
Line data information
A common class used to convey locations,
dimensions and resolutions of data objects.
Holds the current page fonts
This extension allows to include an AFP Page Overlay resource.
This class extends the org.apache.fop.render.afp.extensions.AbstractAFPExtensionObject class.
This class extends the org.apache.fop.extensions.ExtensionObj class.
This is the pass-through value object for the AFP extension.
This is the pass-through value object for the AFP extension.
This class extends the org.apache.fop.extensions.ExtensionObj class.
IFPainter implementation that produces AFP (MO:DCA).
This keeps information about the current painting state when writing to an
AFP datastream.
A painter of rectangles in AFP
The AFP renderer config object.
The parser for AFP renderer specific data in the FOP conf.
An enumeration for the various images modes available to the AFP renderer.
AFP Renderer configurator
AFP-specific renderer context class.
Defines a number of standard constants (keys) for use by the RendererContext class.
The AFP image information
An enumeration of the configuration options available for the AFP renderer.
Rendering context for AFP (MO:DCA) production.
Defines an interface through which external resource objects can be accessed.
The level at which a resource is to reside in the AFP output
A resource level
This class holds resource levels defaults for the various resource types.
Manages the creation and storage of document resources
TODO better docs
Utility for AFP resource handling
A utility class to read structured fields from a MO:DCA document.
Enumeration of the AFP shading modes.
Manages the streaming of the AFP output
AFP XML handler for SVG.
Text data information
Bridge class for the <text> element.
Specialized TextHandler implementation that the AFPGraphics2D class delegates to to paint text
using AFP GOCA text operations.
Renders the attributed character iterator of some text.
AFP Unit converter
The alignment context is carried within a LayoutContext and as
part of the Knuth Inline elements to facilitate proper line building.
PDFImage implementation for alpha channel "images".
Anchor area for footnote or float.
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.
Utility class which provides common code for the addAreas stage.
Event producer interface for events related to the area tree.
Provider class for the event producer.
Area tree handler for formatting objects.
InputHandler for the area tree XML (the old intermediate format) as input.
This is the model for the area tree object.
Abstract base class for all area tree objects.
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.
PDF Filter for ASCII85.
ASCII Hex filter for PDF streams.
The attribute qualifier triplet is used to specify a qualifier for a document
attribute.
Encapsulates a font attribute value
The attribute value triplet is used to specify a value for a document
attribute.
The AWTRender outputs the pages generated by the layout engine to a Swing
window.
RendererMaker for the AWT Preview Renderer.
Represents the 4 bytes that specify the axis-area rotation reference coordinate system
Class encapsulating functionality for the
background-position shorthand.Inner class for creating instances of this property
Inner class to provide shorthand parsing capabilities
This is a the breaking algorithm that is responsible for balancing columns in multi-column
layout.
Base class for all Base 14 fonts.
Sets up Base 14 fonts
A base 14 font collection for graphics 2D
Class modelling the
fo:basic-link object.An inline area produced by an fo:basic-link element.
LayoutManager for the fo:basic-link formatting object
This Element Mapping is for Batik SVG Extension elements
of the http://xml.apache.org/batik/ext namespace.
Image flavors used by Batik.
Helper utilities for Apache Batik.
The before-float-reference-area optionally generated by an fo:region-body.
Bidirectional class utilities.
Constants used for bidirectional processing.
Layout manager for fo:bidi-override.
Class modelling the
fo:bidi-override object.A utility class for performing bidirectional resolution processing.
Library of utility useful conversion methods.
Bitmap image.
Utility method for dealing with bitmap images.
The Bitmap renderer config data object.
The parser for the Bitmap renderer configuration data.
Configurator for bitmap output.
Event producer interface for events generated by the bitmap renderers.
Provider class for the event producer.
An enumeration of the Bitmap renderer configuration opetions available to the user via the FOP
conf.
This class holds settings used when rendering to bitmaps.
This is the block area class.
Class modelling the
fo:block object.Class modelling the
fo:block-container object.LayoutManager for a block-container FO.
Represents a list of block level Knuth elements.
LayoutManager for a block FO.
Event producer interface for block-level layout managers.
Provider class for the event producer.
The interface for LayoutManagers which generate block areas
A BlockParent holds block-level areas.
Base LayoutManager class for all areas which stack their child
areas in the block-progression direction, such as Flow, Block, ListBlock.
A mapping position.
A BlockViewport.
This class is a container for the areas that may be generated by
an fo:region-body.
Class corresponding to the body-start Property Value function.
Class modelling the
fo:bookmark object, first introduced in the
XSL 1.1 WD.This class is a bookmark element for use in the intermediate format.
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-title object, first introduced in the
XSL 1.1 WD.Class modelling the
fo:bookmark-tree object, first introduced in the
XSL 1.1 WD.This class is the root of the bookmark tree for use in the intermediate format.
Constants for RTF border attribute names, and a static method for converting
fo attribute strings.
This represents an unresolved border element.
This keeps all information about borders for current processed page.
This class represents an unresolved border or padding element.
This is an abstract base class for handling border painting.
The four corners
SB - Start-Before
BE - Before-End
EA - End-After
AS - After-Start
0 --> x
|
v
y
SB BE
*----*
| |
| |
*----*
AS EA
Border painting information
Border properties.
A class dedicated to the resolution of borders in tables.
Shorthand parser for the "border-spacing" shorthand property.
A border's informations, along with the FO element which declared it.
Enumeration class for border styles.
This subclass of LengthProperty.Maker handles the special treatment of
border width described in 7.7.20.
Shorthand property parser for Box rounded corner properties
Shorthand property parser for Box properties
This class represents an unresolved break possibility.
The set of nodes is sorted into lines indexed into activeLines.
Holder for symbolic literals for the fitness classes
Defines methods to evaluate break opportunities at a particular location in the tree of
layout managers.
Helper implementations of the
BreakOpportunity methods.Defines property access methods for the break-before and break-after properties.
A utility class for manipulating break classes (the break-before and break-after properties).
A BuilderContext holds context information when building an RTF document.
This class implements a simple byte vector with access to the
underlying array.
A simple cached render pages model.
CCF Filter class.
Represents a non-divisible part of a grid unit.
A class to read the CFF data from an OTF CFF font file.
A class containing data for a dictionary entry
Common change bar base class.
Class modelling the
fo:character object.LayoutManager for the fo:character formatting 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
Inner class for creating instances of CharacterProperty
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.
The CharacterSetBuilder is responsible building the a CharacterSet instance that holds
the font metric data.
Double-byte (CID Keyed font (Type 0)) implementation of AFPFontReader.
An abstraction that wraps the encoding mechanism for encoding a Unicode character sequence into a
specified format.
The default encoder is used for encoding IBM format SBCS (single byte character sets), this
the primary format for most Latin character sets.
The EBCDIC double byte encoder is used for encoding IBM format DBCS (double byte character
sets) with an EBCDIC code-page.
A container for encoded character bytes
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.
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.
An enumeration of AFP characterset types.
A structure class encapsulating an interval of characters expressed as an offset and count of
Unicode scalar values (in an IntBuffer).
Abstract base class for iterators that should iterate through a series
of characters.
A handler that parses the various types of character metrics in an AFM file.
Mirror related utilities.
Normalization related utilities.
Script related utilities.
This class provides utilities to distinguish various kinds of Unicode
whitespace and to get character widths in a given FontState.
This class implements a simple char vector with access to the
underlying array.
Defines a "choice" field part that works like
ChoiceFormat.Factory for ChoiceFieldPart.
Abstract base class for CID fonts.
This class enumerates all supported CID font types.
Provides methods to get font information.
Declares methods to retrieve font information (glyph indices, widths, unicode values) from a CID font.
Provides methods to get font information.
Implements the cie-lab-color() function.
This is a decorator to block calls to close() to the underlying stream.
A cmap builder.
A segment in a cmap table of format 4.
Implements the cmyk() function.
This class is a superclass for the two collapsing border models defined
in the XSL 1.0 specification.
Implements the normal "collapse" border model defined in 6.7.10 in XSL 1.0.
A class that implements the border-collapsing model.
Deprecated.
Class modelling the
fo:color-profile object.Deprecated.
use org.apache.xmlgraphics.java2d.color.profile.ColorProfileUtil directly
Class for properties that wrap Color values
Inner class for creating instances of ColorTypeProperty
Map with cached ICC based ColorSpace objects.
Generic Color helper class.
This class is a
Color subclass adding a fallback color that FOP uses to re-serialize
color specifications as textual functions.Helper class maintaining a record of occupied columns and an index to the next
non-occupied column.
Marking interface for table-related classes which contain a ColumnNumberManager
instance (Table, for registering columns, or TableCellContainer, for managing occupied
cells).
Class holding a number of columns making up the column setup of a row.
This class represents UI-commands, which can be used as menu or toolbar
items
.
.
Options parses the commandline arguments
An inline comment triplet.
Store all common absolute position properties.
The "role" and "source-document" properties, see Section 7.5 of the XSL-FO 1.1
Recommendation.
Classes that implement this interface support the common accessibility properties.
Stores all common aural properties.
Stores all common border and padding properties.
Utility class to express border info.
A conditional length of value 0.
Collection of CommonFont properties
Store all common hyphenation properties.
Store all common margin properties for blocks.
Store all common margin properties for inlines.
Store all common relative position properties.
Stores all information concerning text-decoration.
A utility class that provides helper methods for implementing equals and hashCode.
Set and expose the internal completeness of an object.
EventListener implementation forwards events to possibly multiple other EventListeners.
This interface is used as a base for compound datatypes.
This class extends Property.Maker with support for sub-properties.
Represents a PDF object that may appear in an object stream.
A reference to an indirect object stored in an object stream.
A class that holds the three possible values for a border-before/after on a table-cell,
in the collapsing model.
This interface is used to notify layout managers about the situation around spaces, borders
and padding just before the addArea() method is called when a part is being painted.
Class modelling the
fo:conditional-page-master-reference object.Superclass for properties that have conditional lengths
Inner class for creating instances of CondLengthProperty
A java2d configured font collection
Definition of constants used throughout FOP.
Container area for inline container.
Container data descriptor (to maintain compatibility with pre-year 2000 applications)
Factory interface implemented by classes that can instantiate ContentHandler subclasses which
parse a SAX stream into Java objects.
EventListener interface for objects which want to get notified when ContentHandler
implementing the ObjectSource interface has finished parsing.
Interface that ContentHandler implementations that parse Java objects from XML can implement
to return these objects.
This class holds references to various XML handlers used by FOP.
Content Layout Manager.
This class contains utility methods for conversions, like
a java.lang.String to an array of int or double.
Maker class for handling corresponding properties.
A representation of the cross-reference data to be output at the end of a PDF file.
A cross-reference stream, as described in Section 3.4.7 of the PDF 1.5 Reference.
A cross-reference table, as described in Section 3.4.3 of the PDF 1.5 Reference.
Describe a PDF or PostScript style coordinate transformation matrix (CTM).
CTMHelper converts FOP transformation matrices to those
suitable for use by the PDFRenderer.
This class can be used to convert a cubic bezier curve within
a path into multiple quadratic bezier curves which will approximate
the original cubic curve.
Abstract base class for custom fonts loaded from files, for example.
Sets up a set of custom (embedded) fonts
FontMetricsMapper that delegates most methods to an underlying
FontMetrics instance.This class is responsible for managing of dashed border elements.
A data stream is a continuous ordered stream of data elements and objects
conforming to a given format.
Deprecated.
Deprecated.
use org.apache.xmlgraphics.util.uri.DataURLUtil directly
DCT Filter class.
Class modelling the
fo:declarations object.Standard ErrorListener implementation for in-FOP use.
Default implementation of the EventBroadcaster interface.
The font configuration data for the more generic fonts such as TTF and Type1, that are used by
most the renderers.
Parses the morge generic font information.
The directory to find fonts within.
Represents a font object within the FOP conf.
The default configurator for fonts.
Default implementation of the MonochromeBitmapConverter which uses the Java Class Library
to convert grayscale bitmaps to monochrome bitmaps.
This object represents the default renderer configurator and contains the methods for most the
RendererConfigurators.
Default script processor, which enables default glyph composition/decomposition, common ligatures, localized forms
and kerning.
SAX 2 Event Handler which simply delegates all calls to another ContentHandler.
This class delegates all FO events to another FOEventHandler instance.
This class is a
DelegatingContentHandler subclass which swallows the
DelegatingFragmentContentHandler.startDocument() and DelegatingFragmentContentHandler.endDocument() methods.The
DelimitedTextRange class implements the "delimited text range" as described
by XML-FO 1.1 §5.8, which contains a flattened sequence of characters.Associates an ObjectAreaPosition with and ObjectAreaDescriptor structured field
Class for named destinations in PDF.
Comparator class to enable comparing (and
hence sorting) of PDFDestination objects.
An instance of this class is named destination from fox:destination
The
DevanagariScriptProcessor class implements a script processor for
performing glyph substitution and positioning operations on content associated with the Devanagari script.Dimensioned property maker.
Enumeration class for direction traits, namely {inline,block}-progression-direction
and shift-direction.
Exception thrown during when attempting to map glyphs to associated characters
in the case that the associated characters do not represent a compact interval.
Utility methods for dithering.
The document is the highest level of the MO:DCA data-stream document
component hierarchy.
Constants for the IF document-level navigation extension.
ContentHandler that handles the IF document navigation namespace.
Helper class that produces a SAX stream from a DOM Document.
ContentHandlerFactory which constructs ContentHandlers that build DOM Documents.
This class is responsible for managing of dotted border elements.
Implementation of
AbstractOutlineFont that supports double-byte fonts (CID Keyed font (Type 0)).An entity resolver for both DOM and SAX models of the SAX document.
The entity resolver only handles queries for the DTD.
The entity resolver only handles queries for the DTD.
A dummy implementation of PercentBaseContext
This implementation ignores all structure tree events.
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.
This class is used to observe Knuth element lists generated within the layout managers.
Implement this interface to receive notifications on element lists.
Utilities for Knuth 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.
Base class for all Makers.
This class keeps track of all configured ElementMapping implementations which are responsible
for properly handling all kinds of different XML namespaces.
Image handler implementation that embeds SVG images in the target SVG file.
This enumerates the embedding mode of fonts; full; subset; auto (auto defaults to full for
Type 1 fonts and subset for TrueType fonts.
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)
GridUnit subclass for empty grid units.
This class enumerates all supported encoding modes for fonts: auto, single-byte and CID.
Represents a CCSID encoding triplet.
A length quantity in XSL which is specified as an enum, such as "auto"
A number quantity in XSL which is specified as an enum, such as "no-limit".
Superclass for properties that wrap an enumeration value
Inner class for creating EnumProperty instances
Creates an
EnvironmentProfile that sets the environment in which a FOP instance is run.The environment profile represents the system in which FOP is invoked.
This class enables to transcode an input to a EPS document.
Defines an "equals" field part that can compare a field's string value against another string.
Part factory for "equals".
This is the default event class used by this package.
This class is a fluent builder class for building up the parameter map.
The EventBroadcaster is the central relay point for events.
This exception is used to indicate a violation of the conventions for event producers.
This class is responsible for converting events into exceptions.
This interface is implementation by exception factories that can create exceptions from
events.
Converts events into human-readable, localized messages.
PartFactory for lookups.
This interface is implemented by clients who want to listen for events.
Represents an event method.
Represents an event parameter.
Represents a whole event model that supports multiple event producers.
This is a parser for the event model XML.
This is a marker interface which all event producer interfaces need to extend.
Finds EventProducer interfaces and builds the event model for them.
Ant task which inspects a file set for Java interfaces which extend the
EventProducer interface.Represents the model of an event producer with multiple event methods.
A filter that uses the Event Notification System to broadcast IF events.
Enumeration class for event severities.
The Extended Resource Local Identifier triplet specifies a resource type and a
four byte local identifier or LID.
This interface is implemented by objects that are returned by special extension element
through the FONode.getExtensionAttachment() method.
Element mapping for FOP's proprietary extension to XSL-FO.
An enumeration for placement instruction for AFP extensions.
Class for the fox:external-document extension element.
LayoutManager for an external-document extension element.
Class modelling the
fo:external-graphic object.LayoutManager for the fo:external-graphic formatting object
Creator of MO:DCA structured field objects
This class is an extension of Ant, a script utility from
http://ant.apache.org.
A class to generate the File Identifier of a PDF document (the ID entry of the file
trailer dictionary).
Filled area.
A row group builder optimised for a fixed number of columns, known before the parsing
of cells starts (that is, if the fo:table has explicit fo:table-column children).
An absolute length quantity in XSL
A filter to deflate a stream.
Class modelling the
fo:float object.Class modelling the
fo:flow object.LayoutManager for an fo:flow object.
Allows to create the structure tree of an FO document, by converting FO
events into appropriate structure tree events.
Base class for representation of formatting objects and their processing.
Basic
FONode.FONodeIterator implementationAbstract base class for representation of mixed content formatting objects
(= those that can contain both child
FONodes and #PCDATA).This datatype hold a pair of resolved lengths,
specifiying the dimensions in
both inline and block-progression-directions.
Element mapping class for all XSL-FO elements.
Abstract class defining what should be done with SAX events that map to
XSL-FO input.
Base class for nodes in the XML tree
Base iterator interface over a FO's children, offering three methods on top of the base interface
methods.
Function for AdvancedMessageFormat to retrieve context info from an FONode.
This class holds font state information and provides access to the font
metrics.
Adds a list of fonts to a given font info list
Fop cache (currently only used for font info caching)
Fop cache (currently only used for font info caching)
A factory that provides the font caching manager mechanism.
Sets up a set of fonts
An interface for font configuration information.
An interface for parsing font configuration information.
An abstract FontInfo configurator
This interface enhances the font metrics interface with access methods to
value needed to register fonts in various target formats like PDF or
PostScript.
An interface for the font detecting mechanism.
A factory that provides the font detecting machanism.
Detector of operating system and classpath fonts
Implementers provide find method for searching native operating system
for available fonts.
Event listener interface for font-related events.
Event listener interface for font-related events.
Event producer for fonts-related events.
Provider class for the event producer.
Property class for the font-family property.
Inner class for creating instances of ListProperty
Helps to autodetect/locate available operating system fonts.
Reads a TrueType font file into a byte array and
provides file like functions for array access.
Implementers provide find method for searching native operating system
for available fonts.
The FontInfo holds font information for the layout and rendering of a fo document.
Attempts to determine correct FontInfo
Generates a list of available fonts.
Command-line application to list available fonts and to optionally produce sample pages
with those fonts.
Turns the font list into SAX events.
Base class for font loaders.
The manager of fonts.
Configurator of the FontManager
Main interface for access to font metrics.
Adds method to retrieve the actual
Font
for use by Java2DRenderers.This class represents a tool for extracting the Type 1 PFB file from an AFP outline font.
Encapsulates a font substitution qualifier
A cache for font resource objects.
A runtime exception for handling fatal errors in processing fonts.
Helper class for automatic font selection.
Default fonts for FOP application; currently this uses PDF's fonts
by default.
A shorthand parser for the font shorthand property
Property subclass for the font shorthand
Inner class for creating instances of FontShorthandProperty
This subclass of LengthProperty.Maker handles the special treatment of
relative font sizes described in 7.8.4.
Represents a font with information on how it can be used from XSL-FO.
This subclass of EnumProperty.Maker handles the special treatment of
relative font stretch values described in 7.8.5.
Encapsulates a pair of substitution qualifiers
Font substitutions
Configures a font substitution catalog
FontTriplet contains information on name, style and weight of one font
Matcher interface for
FontTriplet.This class enumerates all supported font types.
Font utilities.
Font weight property maker.
Encapsulates a range of font weight values
The footnote-reference-area optionally generated by an fo:region-body.
Class modelling the
fo:footnote object.Class modelling the
fo:footnote-body object.Layout manager for footnote bodies.
Layout manager for fo:footnote.
Primary class that activates the FOP process for embedded usage.
Wrapper for FOP which allows it to be accessed from within an Ant task.
A Character set for a normal FOP font
Parses the FOP configuration file and returns a
FopFactoryBuilder which builds a
FopFactory.EventListener proxy that inspects all events and adjusts severity levels where necessary.
Exception thrown when FOP has a problem.
Factory class which instantiates new Fop and FOUserAgent instances.
This is the builder class for
FopFactory.The configuration data for a
FopFactory instance.Example servlet to generate a fop printout from a servlet.
Proc Set with FOP-specific procs.
This class creates and returns an array of Property.Maker instances
indexed by the PR_* propId from Constants.java.
A RtfAttributes subclass that adds some helper set methods.
This is a special subclass to allow setting a special EntityResolver.
Example servlet to generate a PDF from a servlet.
an fop extension to text handler
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.Foreign object inline area.
Class for reporting back formatting results to the calling application.
A text node (PCDATA) in the formatting object tree.
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.
Context class providing information needed while building the FO tree.
Converts XSL-FO units to RTF units.
This is the user agent for FOP.
Event producer interface for XSL-FO validation messages.
Provider class for the event producer.
Class modelling the from-nearest-specified-value function.
Class modelling the from-parent Property Value function.
Class modelling the from-table-column Property Value function.
A Fully Qualified Name triplet enable the identification and referencing of
objects using Gloabl Identifiers (GIDs).
Interface for managing XSL-FO Functions
Abstract Base class for XSL-FO functions
This class is a delegating SAX ContentHandler which has the purpose to provide a few handy
methods that make life easier when generating SAX events.
BridgeContext which registers the custom bridges for Java2D output.
Image Element Bridge class for the SVG to Java2D converter, used to make Batik load images
through FOP and XGC's image loading framework.
Generic shorthand parser for ListProperties
This "glyf" table in a TrueType font file contains information that describes the glyphs.
The
GlyphClassMapping interface provides glyph identifier to class
index mapping support.Base class implementation of glyph class table.
Interface for testing the originating (source) character context of a glyph sequence.
The
GlyphCoverageMapping interface provides glyph identifier to coverage
index mapping support..Base class implementation of glyph coverage table.
The
GlyphDefinition interface is a marker interface implemented by a glyph definition
subtable.The
GlyphDefinitionSubtable implements an abstract base of a glyph definition subtable,
providing a default implementation of the GlyphDefinition interface.The
GlyphDefinitionTable class is a glyph table that implements
glyph definition functionality according to the OpenType GDEF table.Stores the mapping of a text fragment to glyphs, along with various information.
Base class implementation of glyph mapping table.
empty mapping table base class
mapped mapping table base class
The
MappingRange class encapsulates a glyph [start,end] range and
a mapping index.range mapping table base class
Function formatting a character to a glyph name.
Factory for
GlyphNameFieldPart.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
GlyphPositioningState implements an state object used during glyph positioning
processing.The
GlyphPositioningSubtable implements an abstract base of a glyph subtable,
providing a default implementation of the GlyphPositioning interface.The
GlyphPositioningTable class is a glyph table that implements
GlyphPositioning functionality.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
DeviceTable class implements a positioning device table record, comprising
adjustments to be made to scaled design units according to the scaled size.The
MarkAnchor class is a subclass of the Anchor class, adding a mark
class designation.The
PairValues class implements a pair value record, comprising a glyph id (or zero)
and two optional positioning values.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
GlyphProcessingState implements a common, base state object used during glyph substitution
and positioning processing.combined AND glyph tester
combined OR glyph tester
NOT glyph tester
Deprecated.
Use the Glyphs class from XML Graphics Commons instead!
A GlyphSequence encapsulates a sequence of character codes, a sequence of glyph codes,
and a sequence of character associations, where, for each glyph in the sequence of glyph
codes, there is a corresponding character association.
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
GlyphSubstitutionState implements an state object used during glyph substitution
processing.The
GlyphSubstitutionSubtable implements an abstract base of a glyph substitution subtable,
providing a default implementation of the GlyphSubstitution interface.The
GlyphSubstitutionTable class is a glyph table that implements
GlyphSubstitution functionality.The
Ligature class implements a ligature lookup result in terms of
a ligature glyph (code) and the N+1...The
LigatureSet class implements a set of ligatures.The
GlyphSubtable implements an abstract glyph subtable that
encapsulates identification, type, format, and coverage information.Base class for all advanced typographic glyph tables.
The
ChainedClassSequenceRule class implements a subclass of ClassSequenceRule
that supports matching on a specific glyph class sequence in a specific chained contextual.The
ChainedCoverageSequenceRule class implements a subclass of CoverageSequenceRule
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
ClassSequenceRule class implements a subclass of Rule
that supports matching on a specific glyph class sequence.The
CoverageSequenceRule class implements a subclass of Rule
that supports matching on a specific glyph coverage sequence.The
GlyphSequenceRule class implements a subclass of Rule
that supports matching on a specific glyph sequence.The
HomogenousRuleSet class implements a collection of rules, which
must be the same rule type (i.e., same concrete rule class) or null.A structure class encapsulating a lookup specification as a <script,language,feature> tuple.
The
LookupTable class comprising an identifier and an ordered list
of glyph subtables, each of which employ the same lookup identifier.The
Rule class implements an array of rule lookup records.The
RuleLookup class implements a rule lookup record, comprising
a glyph sequence index and a lookup table index (in an applicable lookup list).The
RuleSet class implements a collection of rules, which
may or may not be the same rule type.The
UseSpec class comprises a lookup table reference
and the feature that selected the lookup table.Interface for testing glyph properties according to glyph identifier.
Go to Page Dialog.
Action class which represents a "go-to" action to an absolute coordinate on a page.
Helper class to draw gradients in PostScript.
This interface represents an optional feature that can be provided by
a renderer.
Deprecated.
use
Graphics2DImagePainter directly!A graphics 2D image painter implementation for painting SVG images using Batik.
The beginning of a filled region (graphics area).
The end of a filled region (graphics area).
A GOCA graphics rectangular box
A GOCA graphics segment
A GOCA graphics string
Adapter to allow subclassing java.awt.GraphicsConfiguration without
compilation errors.
A GOCA graphics data
GOCA Graphics Data Descriptor
The end of a prolog.
A GOCA graphics curved tangential line to a specified set of
straight lines drawn from the given position or current position
A GOCA graphics arc (circle/ellipse)
A GOCA Image
A GOCA graphics straight line drawn from the
given absolute position
Top-level GOCA graphics object.
the internal graphics state
Used primarily by
BorderPainter, implementations are created for rendering
primitive graphical operations.This interface provides access to properties necessary to calculate the size and positioning
of images and graphics inside a viewport.
Sets the arc parameters for a GOCA graphics arc (circle/ellipse)
Sets the current character set (font) to be used for following graphics strings
Sets the current painting position of the graphics object
Sets the line width to use when stroking GOCA shapes (structured fields)
Sets the value of the current line type attribute when stroking GOCA shapes (structured fields)
Sets the line width to use when stroking GOCA shapes (structured fields)
Sets the foreground mix mode.
Sets the pattern symbol to use when filling following GOCA structured fields
Sets the current processing color for the following GOCA structured fields
Converts to grayscale using the standard RED=30%, GREEN=59% and BLUE=11%
weights (see http://en.wikipedia.org/wiki/Grayscale)
This class represents one grid unit inside a table.
The
GujaratiScriptProcessor class implements a script processor for
performing glyph substitution and positioning operations on content associated with the Gujarati script.The
GurmukhiScriptProcessor class implements a script processor for
performing glyph substitution and positioning operations on content associated with the Gurmukhi script.This class hold code for selecting a set of hard-coded fonts available in practically all
PCL implementations.
This class has a few convenient static methods for number quantization.
A helper class to create hex-encoded representations of numbers.
Function formatting a number or character to a hex value.
Factory for
HexFieldPart.This class is used to pass information to the getNextBreakPoss()
method concerning hyphenation.
Represents a hyphen.
This class represents a hyphenated word.
An hyphenation exception.
This tree structure stores the hyphenation patterns in an efficient
way for fast lookup.
This is a cache for HyphenationTree instances.
This class is the main entry point to the hyphenation package.
Constants for RTF border attribute names.
This class represents the IOCA IDE Structure parameter (X'9B').
Used by the AreaTreeHandler to keep track of ID reference usage
on a PageViewport level.
This class allows to concatenate multiple intermediate format files to a single output file
in the final format.
Constants for the intermediate format.
intermediate format content handler
This class provides a context object that is valid for a single processing run to create
an output file using the intermediate format.
Interface used to paint whole documents layouted by Apache FOP.
This interface is implemented by classes that configure an
IFDocumentHandler instance.This class is a simple proxy that delegates all method calls to another
IFDocumentHandler
instance.Interface to handle document navigation features.
Exception thrown by code dealing with FOP's intermediate format.
Defines an "if" field part that checks if field's value is true or false.
Part factory for "if".
Specialized graphic context class for the intermediate format renderer.
a group
a viewport
InputHandler for the intermediate format XML as input.
Interface used to paint whole documents layouted by Apache FOP.
This is a parser for the intermediate format XML which converts the intermediate file into
IFPainter events.This renderer implementation is an adapter to the
IFPainter interface.The Intermediate Format renderer configuration data object.
The Intermediate Format configuration data parser.
IFPainter implementation that serializes the intermediate format to XML.
Intermediate format document handler factory for intermediate format XML output.
a state class for intermediate format data
Saves structure tree events as SAX events in order to replay them when it's
time to stream the structure tree to the output.
A SAX handler that records events to replay them later.
Utility functions for the intermediate format.
Image area for external-graphic.
This interface represents an optional feature that can be provided by
a renderer.
The IM Image Cell Position structured field specifies the placement,
size, and replication of IM image cells.
Here will be defined all supported image formats.
An IOCA Image Content
This ImageConverter converts Java2D images into SVG images.
This ImageConverter converts SVG images to Java2D.
This ImageConverter converts WMF (Windows Metafile) images (represented by Batik's
WMFRecordStore) to Java2D.
ImageDataDescriptor
ImageEncoder implementation for CCITT encoded images.
ImageEncoder implementation for JPEG images.
ImageEncoder implementation for PNG images.
This interface is a service provider interface for image handlers.
This interface is a service provider base interface for image handlers.
This class holds references to various image handlers.
Utility methods for image handling.
The IM Image Input Descriptor structured field contains the
descriptor data for an IM image data object.
InputHandler for the images (for example TIFF) as input.
Helper class which calculates the size and position in the viewport of an image.
Factory class for the ImageLoader for SVG.
Factory class for the ImageLoader for WMF (Windows Metafile).
ImageLoader for SVG (using Apache Batik).
ImageLoader for WMF (Windows Metafile).
An IOCA Image Data Object
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.
Panel used to display a single page of a document.
Contains the image points that define the IM image raster pattern.
Raster data is a grid of cells covering an area of interest.
PDFImage implementation for the PDF renderer which handles raw CCITT fax images.
PDFImage implementation for the PDF renderer which handles raw JPEG images.
PDFImage implementation for the PDF renderer which handles RenderedImages.
An Image Segment is represented by a set of self-defining fields, fields
that describe their own contents.
Describes the measurement characteristics of the image when it is created.
Misc.utilities for images handling
This class belongs to the fo:external-graphic tag processing.
This class is an implementation of the Image interface exposing a RenderedImage.
An IM image data object specifies the contents of a raster image and
its placement on a page, overlay, or page segment.
Encapsulates an included resource object that is loaded from an external file.
An Include Object structured field references an object on a page or overlay.
The Include Page Overlay structured field references an overlay resource
definition that is to be positioned on the page.
The Include Page Segment structured field references a page segment resource
object that is to be presented on the page or overlay presentation space.
Exception thrown during when attempting to map glyphs to associated characters
in the case that the associated characters do not represent a compact interval.
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.
The
IndicScriptProcessor class implements a script processor for
performing glyph substitution and positioning operations on content associated with the Indic script.Default syllabizer.
Syllabic segment.
Abstract syllabizer.
Class modelling the inherited-property-value Property Value function.
Class modelling the
fo:initial-property-set object.Class modelling the
fo:inline formatting object.Inline Area
This area is for all inline areas that can be placed
in a line area.
This is the inline block area class.
Inline block parent area.
This creates a single inline container area after
laying out the child block areas.
Represents a list of inline Knuth elements.
LayoutManager for objects which stack children in the inline direction,
such as Inline or Line
Class modelling the commonalities of several inline-level
formatting objects.
Event producer interface for inline-level layout managers.
Provider class for the event producer.
The interface for LayoutManagers which generate inline areas
Inline parent area.
The
InlineRun class is a utility class, the instances of which are used
to capture a sequence of reordering levels associated with an inline area.Class modelling the commonalities of layoutmanagers for objects
which stack children in the inline direction, such as Inline or
Line.
Inline viewport area.
StreamCache implementation that uses temporary files rather than heap.
Class for handling files input from command line
either with XML and XSLT files (and optionally xsl
parameters) or FO File input alone.
A custom AWT font collection
Class modelling the
fo:instream-foreign-object object.LayoutManager for the fo:instream-foreign-object formatting object
A simple compact data structure to model a sparse array
MO:DCA Interchange Set
Element mapping for FOP's internal extension to XSL-FO.
This object holds the base URI from which to resolve URIs against as well as the resolver for
resource acquisition.
The Invoke Medium Map structured field identifies the Medium Map that is to
become active for the document.
interface for RTF objects that can contain footers
Interface for classes containing headers.
RTF Bookmark container interface.
Interface for classes containing images.
Interface for RtfElements that can contain RtfHyperLinks.
Interface for objects containing Commands
Interface for RtfElements that can contain RtfLists.
Options for configuring the rtf elements.
Interface for RtfElements that can contain RtfPageBreaks.
Interface for RtfElements that can contain RtfText elements.
Interface for classes containing page number citations
Interface for objects containing page numbers
Interface for RtfElements that can contain RtfParagraphs.
Interface for classes containing Paragraphs with Keep Together
Interface for RtfElements that can contain RtfTables.
Interface for classes containing templates.
Interface for RtfElements that can contain RtfText elements.
Interface which enables an implementing class to contain linear text runs.
Constants for RTF table attribute names.
Used to get information about tables, for example when handling nested tables.
IFDocumentHandler implementation that produces
Graphics2D instance.This is a FontMetrics to be used for AWT rendering.
Graphics2DAdapter implementation for Java2D.
Keeps information about the current state of the Graphics2D currentGraphics.
Image handler implementation that paints
Graphics2D image on another Graphics2D
target.Image handler implementation that paints
RenderedImage instances on a Graphics2D
object.IFPainter implementation that paints on a Graphics2D
instance.The
Java2DRenderer class provides the abstract technical
foundation for all rendering with the Java2D API.The Java2D renderer configuration data object.
The Java2D renderer configuration data parser.
Configurerer for Java 2D renderer
Defines a number of standard constants (keys) for use by the RendererContext class.
An enumeration of the renderer configuration options available to the Java2D renderer via the
FOP conf.
Rendering context for Java2D painting.
This class holds settings used when rendering with Java2D.
Java2D XML handler for SVG (uses Apache Batik).
Java2D information structure for drawing the XML document.
Rendering-related utilities for Java2D.
Object representing a keep constraint, corresponding
to the XSL-FO keep properties.
Class for properties that wrap Keep values
Inner class for creating instances of KeepProperty
Keep Value
Stores the different types of keeps in a single convenient format.
UnicodeRender Class.
The
KhmerScriptProcessor class implements a script processor for
performing glyph substitution and positioning operations on content associated with the Khmer script.Knuth box used to represent a line in block-progression-dimension (i.e.
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), ...
This is the super class for KnuthBox, KnuthGlue and KnuthPenalty.
An instance of this class represents a piece of content with adjustable
width: for example a space between words of justified text.
A knuth inline box.
An instance of this class represents information about a feasible
breaking point; it does not represent any piece of content.
A dedicated
PositionIterator that is backed by an iterator
over a list of KnuthElements.Represents a list of
Knuth elements.Class modelling the label-end Property Value function.
Provides utility methods for manipulating language tags compliant with the
RFC 3066 specification available at http://www.ietf.org/rfc/rfc3066.txt.
This class is used to pass information to the getNextKnuthElements()
method.
Exception thrown by FOP if an unrecoverable layout error occurs.
Exception factory for
LayoutException.The interface for all LayoutManagers.
The interface for all LayoutManager makers
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
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
a layout manager maker
a layout manager maker
Class modelling the
fo:layout-master-set object.This class is used to defer the loading of a font until it is really used.
This is a leader inline area.
Class modelling the
fo:leader object.LayoutManager for the fo:leader formatting object
Base LayoutManager for leaf-node FObj, ie: ones which have no children.
A leaf position.
A length quantity in XSL
Models a length which can be used as a factor in a percentage length
calculation
Superclass for properties wrapping a LengthPair value
Inner class for creating instances of LengthPairProperty
Superclass for properties wrapping a Length value.
Inner class for making instances of LengthProperty
Superclass for properties that contain LengthRange values
Inner class for a Maker for LengthProperty objects
The line area.
This class is meant for supporting the Unicode line breaking algorithm.
Line breaking utilities.
PtocaProducer implementation that interprets AFPLineDataInfo objects.A maker which calculates the line-height property.
LayoutManager for lines.
Private class to store information about inline breaks.
Line layout possibilities.
This class is a link element for use in the intermediate format.
Link resolving for resolving internal links.
Provides methods to convert list attributes to RtfAttributes.
Class modelling the list block
fo:list-block object.LayoutManager for a list-block FO.
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 object.Class modelling the list item
fo:list-item-body object.LayoutManager for a list-item-label or list-item-body FO.
Class modelling the list item
fo:list-item-label object.LayoutManager for a list-item FO.
Superclass for properties that are lists of other properties
Inner class for creating instances of
ListPropertyProvides helper functions for
List.An iterator for layout managers.
Object formatter for the SAX Locator object.
EventListener implementation that redirects events to Commons Logging.
Convenience Logging utility methods used in FOP
Mac font directory finder
Main command-line class for Apache FOP.
Wrapper to support dependency injection.
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 Coded Font structured field maps a unique coded font resource local
ID, which may be embedded one or more times within an object's data and
descriptor, to the identifier of a coded font resource object.
Private utility class used as a container for font attributes
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 Data Resource structured field specifies resources that are
required for presentation.
The Map Image Object (MIO) structured field specifies how an image data object is
mapped into its object area.
The Map Page Overlay structured field maps a Resource Local ID to the name of
a Begin Overlay structured field.
The Map Page Segment structured field identifies page segments that are required to present
a page on a physical medium.
Specifies the mapping of data object presentation space to object area
Class modelling the marker
fo:markerobject.Convenience inner class
A class to register and resolve markers.
Class for managing the "max" Number Function.
An exception to handle maximum sizes being exceeded.
The Measurement Units triplet is used to specify the units of measure
for a presentation space
The is the basis for MIF document elements.
The MIF File.
Maker class for MIF support.
The MIF Handler.
Frequently used MIME types for various file formats used when working with Apache FOP.
Class for managing the "min" Number Function.
This class holds the resolved (as mpoints) form of a
LengthRange or
Space type property value.An simple MO:DCA/AFP parser.
Interface for converters that convert images to monochrome (1-bit, bi-level) bitmap images.
Generic MultiByte (CID) font
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-properties object.Class modelling the
fo:multi-property-set object.Class modelling the
fo:multi-switch object.Class modelling the
fo:multi-toggle property.This interface is used to set the values of a font during configuration time.
Represents an named character with character name (from the Adobe glyph list) and a Unicode
sequence that this character represents.
This class is a named destination element for use in the intermediate format.
Native font finder base class
native image handler
Specialized TextHandler implementation that the PSGraphics2D class delegates to to paint text
using PostScript text operations.
Abstract base class for text painters that use specialized text commands native to an output
format to render text.
Class for handling NC Name objects
Handy class for wrapping runtime Exceptions with a root cause.
A non-leaf position.
The No Operation structured field may be used to carry comments
or any other type of unarchitected data.
The normal-flow-reference-area class.
Class providing an iterator for zero characters.
Null Filter class.
Implementation of Number to String Conversion algorithm specified by
XSL Transformations (XSLT) Version 2.0, W3C Recommendation, 23 January 2007.
Isopsephry (Greek) Numerals
Special number formatter.
Class for handling numeric properties
Inner class for making NumberProperty objects
A positive integer property maker.
An interface for classes that can participate in numeric operations.
This class contains static methods to evaluate operations on Numeric
operands.
A numeric property which hold the final absolute result of an expression
calculations.
The Object Area Descriptor structured field specifies the size and attributes
of an object area presentation space.
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 Area Size triplet is used to specify the extent of an object area
in the X and Y directions
The Object Byte Extent triplet is used to specify the number of bytes contained in an object
The Object Classification is used to classify and identify object data.
Object containers are MO:DCA objects that envelop and carry object data.
An Object Environment Group (OEG) may be associated with an object and is contained
within the object's begin-end envelope.
A reference to an indirect object.
An object stream, as described in section 3.4.6 of the PDF 1.5 Reference.
Manages a collection of object streams, creating new streams as necessary to keep the
number of objects in each stream at the recommended value.
OCAColor is a single component color representation that is mostly used
in AFP documents to represent text foreground color.
The OCA color space is a subset of RGB that includes a limited set of colors.
This class represents an entry to a TrueType font's Dir Tab.
This class wraps ExtensionAttachments which cannot be transported inside the area tree but
need to be handled in the AreaTreeHandler.
Interface for objects that are processed by the renderer outside
of the actual document.
Loads a TrueType font into memory directly from the original font file.
This class represents a TrueType Mtx Entry.
Represents table names as found in a TrueType font's Table Directory.
Element mapping for the old FOP extension namespace.
Class providing an iterator for one character.
Version of the PostScript table (post) contained in this font.
Key-value helper class.
Superclass for properties that wrap an optional character value
TODO convert character value to int in order to denote unicode scalar value
instead of a single UTF-16 code element
Inner class for creating instances of OptionalCharacterProperty
OpenType Font (OTF) advanced typographic table reader.
Language system tags defined by OTF specification.
Script tags defined by OTF specification.
Reads an OpenType CFF file and generates a subset
The OpenType specification can be found at the Microsoft
Typography site: http://www.microsoft.com/typography/otspec/
A class used to store the last number operand and also it's size in bytes
Default implementation of AbstractOutlineFont.
An overlay is a MO:DCA-P resource object.
This represents an unresolved padding element.
The page.
This object is used by the layout engine to represent a page.
Renderer that prints through java.awt.PrintJob.
Converts simple-page-master attributes into strings as defined in RtfPage.
This class is used to calculate the effective boundaries of a page including special-purpose
boxes used in prepress.
Handles the breaking of pages in an fo:flow
Interface to notify about layout events during page breaking.
Shorthand parser for page-break-before, page-break-after and page-break-inside.
Swing event fired whenever the current page selection of a
PreviewPanel changes.Swing listener interface for classes which wish to receive
notification of page change events.
The Page Descriptor structured field specifies the size and attributes of
a page or overlay presentation space.
Custom Maker for page-height / page-width
A page group is used in the data stream to define a named, logical grouping
of sequential pages.
Interface to get the page index
Class modelling the
fo:page-number object.Class modelling the
fo:page-number-citation object.Class modelling the
fo:page-number-citation-last object from XSL 1.1.LayoutManager for the fo:page-number-citation-last formatting object.
LayoutManager for the fo:page-number-citation 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.
LayoutManager for the fo:page-number formatting object
Pages contain the data objects that comprise a presentation document.
Exception thrown by FOP if there is a problem while producing new pages.
Exception factory for
PageProductionException.This class delivers Page instances.
This class provides utility methods to parse the 'fox:scale' extension attribute.
A page segment is a MO:DCA-P resource object.
Class holding information on a page segment.
Represents a page sequence in the area tree.
Class modelling the
fo:page-sequence object.LayoutManager for a PageSequence.
Class modelling the
fo:page-sequence-master object.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.Enum class for pages mode (all, even, odd pages).
Page viewport that specifies the viewport area and holds the page contents.
Generic painting information interface
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.
A SAX document handler to read and parse hyphenation patterns
from a XML file.
Character Class used in PCL Character Descriptor See Table 11-51 from PCL 5 Specification
Character Format used in PCL Character Descriptor See Table 11-50 from PCL 5 Specification
Constants used for PCL output.
IFDocumentHandler implementation
that produces PCL 5.Document handler factory for PCL output.
PCL-specific extensions for Apache FOP.
Event producer interface for events generated by the PCL renderer.
Provider class for the event producer.
This class provides methods for generating PCL print files.
Graphics2D implementation implementing PCL and HP GL/2.
Image handler implementation that paints Graphics2D images in PCL.
Image handler implementation that paints
RenderedImage instances in PCL.This class represents a page format with PCL-specific properties.
IFPainter implementation that produces PCL 5.The PCL renderer configuration data object.
The PCL renderer configuration data parser.
PCL Renderer configurator
Wrapper on the RendererContext to access the information structure for drawing
the XML document.
Defines a number of standard constants (keys) for use by the RendererContext class.
Rendering context for PCL production.
Enumeration class for PCL rendering modes.
Utility class for handling all sorts of peripheral tasks around PCL generation.
PCL XML handler for SVG.
Table C-1 from http://www.lprng.com/DISTRIB/RESOURCES/DOCS/pcl5comp.pdf
class representing an action object.
Extension element for pdf:action.
Bridge class for the <a> element.
Enum class for PDF/A modes.
class representing an object which is a list of annotations.
A graphics node that represents an image described as a graphics node.
Class representing an array object.
Extension element for pdf:array.
Element Bridge for Batik's flow text extension, so those texts can be painted using
PDF primitives.
BridgeContext which registers the custom bridges for PDF output.
Extension element for pdf:catalog.
Special PDFStream for embeddable CFF fonts.
PDFStream for embeddable OpenType CFF fonts.
class representing a /CharProcs dictionary for Type3 fonts.
Class representing a "character identifier" font (p 210 and onwards).
Class representing a font descriptor for CID fonts.
class representing system information for "character identifier" fonts.
This class represents a "CIE L*a*b*" color space.
Class representing the CMap encodings.
Extension element for collection entries: pdf:{array,boolean,dictionary,name,number,reference,string}.
PDF Color object.
This class handles the registration of color spaces and the generation of PDF code to select
the right colors given a
Color instance.PDF Color space.
RuntimeException descendant indicating a conformance problem during PDF generation.
Generator class encapsulating all object references and state necessary to generate a
PDF content stream.
Context class which holds state information which should remain in sync over multiple instances
of PDFDocumentGraphics2D.
class representing a named destination
class representing an /Dests dictionary object
Represents a device-specific color space.
Class representing a PDF dictionary object
Extension element for dictionaries: pdf:{catalog,page,dictionary}.
Enumeration type for PDF dictionary extension elements.
Class representing a PDF document.
This class is a wrapper for the
PDFGraphics2D that
is used to create a full document around the PDF rendering from
PDFGraphics2D.Configurator class for PDFDocumentGraphics2D.
IFDocumentHandler implementation that produces PDF.Intermediate format document handler factory for PDF output.
Implementation of the
IFDocumentNavigationHandler interface for PDF output.This class provides the element mapping for the PDF-specific extensions.
This class represents an embedded file stream.
This is the pass-through value object for the PDF extension.
Extension element for pdf:embedded-file.
Class representing an /EmbeddedFiles dictionary object (name tree).
Class representing an /Encoding object.
This interface defines the contract for classes implementing PDF encryption.
An implementation of the Standard Security Handler.
This class acts as a factory for PDF encryption support.
This class holds the parameters for PDF encryption.
Event producer interface for events generated by the PDF renderer.
Provider class for the event producer.
ContentHandler (parser) for restoring PDF extension objects from XML.
Factory for the ContentHandler that handles serialized PDFExtensionAttachment instances.
This class provides method to create and register PDF objects.
Class representing a /FileSpec object.
PDF Filter class.
PDF Filter exception.
This class represents a list of PDF filters to be applied when serializing
the output of a PDF object.
Text Painter for Batik's flow text extension.
Text Painter for SVG 1.2 (flow) text.
Class representing a /Font object.
Class representing a font descriptor (/FontDescriptor object).
A common ancestor for Type1, TrueType, MMType1 and Type3 fonts
(all except base 14 fonts).
Class representing a TrueType font.
Class representing a Type0 font.
Class representing a Type1 or MMType1 font (not necessary for the base 14).
Class representing a Type3 font.
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 PDF Function.
class representing a /GoTo object.
Class representing a /GoToR object.
PDF Graphics 2D.
May be used to give proper feedback to the user when a particular PDF profile is
being used that disallows transparency.
Our implementation of the class that returns information about
roughly what we can handle and want to see (alpha for example).
This implements the GraphicsDevice interface as appropriate for
a PDFGraphics2D.
PDF-specific implementation of the
GraphicsPainter.Class representing a /ExtGState object.
Represents an ICCBased color space in PDF.
Special PDFStream for ICC profiles (color profiles).
Identified Dictionary.
Interface for a PDF image.
PDF Image Element Bridge class for the <image> element when jpeg images.
PDFImageHandler implementation which handles Graphics2D images.
Image handler implementation which handles CCITT encoded images (CCITT fax group 3/4)
for PDF output.
Image handler implementation which handles raw JPEG images for PDF output.
Image handler implementation which handles CCITT encoded images (CCITT fax group 3/4)
for PDF output.
Image handler implementation which handles RenderedImage instances for PDF output.
Image Handler implementation which handles SVG images.
PDF XObject
A derivative of the PDF Object, is a PDF Stream that has not only a
dictionary but a stream of image data.
class representing an /Info object
The standard keys in the Document Information Dictionary
class used to create a PDF internal link
PDF Action which executes some JavaScript code.
This class represents the /Launch action.
Optional Content Group Dictionary, which we will call a 'layer'.
Extension element for pdf:layer.
class representing an /Annot object of /Subtype /Link
Handles the creation of the logical structure in the PDF document.
Class providing the necessary information for bracketing content
associated to a structure element as a marked-content sequence.
Special PDFStream for Metadata.
Class representing a PDF name object.
Class representing a PDF Names object
Class representing a PDF name tree node.
Navigation Node Dictionary, which we call a 'navigator'.
Extension element for pdf:navigator.
Class representing a PDF name object.
This class represents a simple number object.
Class representing a PDF number tree node.
Class representing an "Nums" array object (for Number Trees).
generic PDF object.
Enumeration type for leaf PDF object extension types used as singletons,
dictionary entries, or array entries.
This represents a single Outline object in a PDF, including the root Outlines
object.
Represents the OutputIntent dictionary.
Class representing a /Page object.
Extension element for pdf:page.
Class representing a PDF /PageLabels dictionary.
class representing a /Pages object.
IFPainter implementation that produces PDF.
This keeps information about the current painting state when writing to pdf.
Class representing a PDF /ParentTree.
Base class for PDF painting operations.
class representing a PDF Function.
This class allows tracks the enabled PDF profiles (PDF/A and PDF/X) and provides methods to
the libarary and its users to enable the generation of PDFs conforming to the enabled PDF
profiles.
class representing a rectangle
Rectangles are specified on page 183 of the PDF 1.3 spec.
Class representing a PDF object reference.
Extension element for pdf:reference.
The PDF renderer configuration data object.
The PDF renderer configuration data parser.
PDF renderer configurator.
Defines a number of standard constants (keys) for use by the RendererContext class.
The renderer options configuration data.
Rendering context for PDF production.
Utility class which enables all sorts of features that are not directly connected to the
normal rendering process.
The PDF resource context.
Class representing a /Resources object.
Class representing a Root (/Catalog) object.
This class represents a "Separation" color space.
class representing a PDF Smooth Shading object.
Class representing a PDF stream.
Class representing a PDF Structure Element.
Class representing a placeholder for a PDF Structure Element.
Class representing a PDF /StructTreeRoot dictionary.
Element Bridge for SVG 1.2 flow text, so those texts can be painted using
PDF primitives.
PDF XML handler for SVG (uses Apache Batik).
PDF information structure for drawing the XML document.
Special PDFStream for embedding Type 1 fonts.
This class represents a simple number object.
Bridge class for the <text> element.
Renders the attributed character iterator of a
TextNode.Utility class for generating PDF text objects.
Utility class for generating PDF text objects.
Class representing ToUnicode CMaps.
This class enables to transcode an input to a PDF document.
Special PDFStream for embeddable TrueType fonts.
Enum class for PDF/UA modes.
class used to create a PDF Uri link
Class representing a W array for CID fonts.
Inner class for entries in the form "c [w ...]"
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.
Enum class for PDF/X modes.
Abstract base class of PDF XObjects.
Used for determining initial values for column-numbers in case of row-spanning cells.
Interface for objects that can be used as base objects for percentage
computations
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.
PercentBaseContext implementation to track base widths for percentage calculations.
a percent specified length quantity in XSL
Class that represents the contents of a PFB file.
This class represents a parser for Adobe Type 1 PFB files.
This class represents a PFM file (or parts of it) as a Java object.
This is a helper class for reading PFM files.
A tool which reads PFM files from Adobe Type 1 fonts and creates
XML font metrics file for use in FOP.
Font Catalog element.
IFDocumentHandler implementation
that produces PNG files.Document handler factory for PNG output.
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 codecThe PNG renderer configuration data object.
The PNG renderer configuration parser.
RendererMaker for the PNG Renderer.
A position.
Optional interface which indicates that glyph positioning is supported and, if supported,
can perform positioning.
A shorthand parser for the position shorthand.
Image preloader for SVG images.
Image preloader for WMF images (Windows Metafile).
The Preprocess Presentation Object structured field specifies presentation
parameters for a data object that has been mapped as a resource.
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.
This triplet is used to specify the resulting appearance when data in a new
presentation space is merged with data in an existing presentation space.
Presentation text data contains the graphic characters and the control
sequences necessary to position the characters within the object space.
The Presentation Text 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.
The Presentation Text object is the data object used in document processing
environments for representing text which has been prepared for presentation.
AWT Viewer main window.
AWT Viewer's "About" dialog.
Holds a scrollpane with the rendered page(s) and handles actions performed
to alter the display of the page.
This class represents a primary grid unit of a spanned cell.
Renderer that prints through java.awt.PrintJob.
Abstract base class of "Print" type renderers.
Base Print renderer configurator (mostly handles font configuration)
RendererMaker for the Print Renderer.
Base class for all property objects
Thread-safe cache that minimizes the memory requirements by fetching an instance from the cache
that is equal to the given one.
Class for managing exceptions that are raised in Property processing.
Exception factory for
PropertyException.This class holds context information needed during property expression
evaluation.
Class containing the collection of properties for a given FObj.
A class to handle unknown shorthand property values e.g.
A PropertyListMaker is a factory that creates PropertyLists.
Base class for all property makers
Class to parse XSL-FO property expressions.
Class to tokenize XSL FO property expression.
Class modelling the proportional-column-width function.
Element Bridge for Batik's flow text extension, so those texts can be painted using
PostScript primitives.
BridgeContext which registers the custom bridges for PostScript output.
Custom postscript comment after class
Comment after element
Custom postscript comment before class
Comment before element
IFDocumentHandler implementation
that produces PostScript.Intermediate format document handler factory for PostScript output.
Event producer interface for events generated by the PostScript renderer.
Provider class for the event producer.
This is the pass-through value object for the PostScript extension.
This class provides the element mapping for the PostScript-specific extensions.
ContentHandler (parser) for restoring PSExtension objects from XML.
Factory for the ContentHandler that handles serialized PSSetupCode instances.
A DSC resource corresponding to a font.
Utility code for font handling in PostScript.
Graphics2DAdapter implementation for PostScript.
PostScript-specific implementation of the
BorderPainter.PostScript Resource class representing a FOP form.
Specialized image handler interface for PostScript output.
Image handler implementation which handles EPS images for PostScript output.
Image handler implementation which handles vector graphics (Java2D) for PostScript output.
Image handler implementation which handles CCITT fax images for PostScript output.
Image handler implementation which handles undecoded JPEG images for PostScript output.
Image handler implementation which handles raw (not decoded) PNG images for PostScript output.
Image handler implementation which handles RenderedImage instances for PostScript output.
Image handler implementation which handles SVG images for PostScript output.
Utility code for rendering images in PostScript.
Extension element for fox:ps-page-setup-code.
Comment before element
IFPainter implementation that produces PostScript.
The PostScript renderer configuration data object.
The PostScript renderer configuration data parser.
Postscript renderer config
Defines a number of standard constants (keys) for use by the RendererContext class.
An enumeration of the PostScript renderer configuration options along with their default values.
Rendering context for PostScript production.
Enumeration that specifies the rendering mode for PostScript output.
Utility class which enables all sorts of features that are not directly connected to the
normal rendering process.
Element for postscript setpagedevice instruction
This is a an extension which provides a pass-through value
dictionary object for the postscript setpagedevice instruction.
Extension element for ps:ps-setpagedevice.
This is the pass-through value object for the PostScript extension.
Extension element for fox:ps-setup-code.
Defines the set of supported ImageFlavors for the PostScript renderer.
Element Bridge for SVG 1.2 flow text, so those texts can be painted using
PDF primitives.
PostScript XML handler for SVG.
PostScript information structure for drawing the XML document.
Bridge class for the <text> element.
Renders the attributed character iterator of a
TextNode.This class enables to transcode an input to a PostScript document.
This is a wrapper for
PSGenerator that contains some members specific for streaming
TrueType fonts to a PostScript document.Streams glyphs in accordance with the constraints of the PostScript file format.
Streams a TrueType font according to the PostScript format.
Streams a TrueType table according to the PostScript format.
Generator class for PTOCA data structures.
A collection of PTOCA constants.
Producer interface that is passed to a
PresentationTextObject
to produce PTOCA control sequences using a PtocaBuilder.Deprecated.
Use the XML Graphics Commons variant instead!
A font where each character is stored as an array of pixels (a bitmap).
Represents the top-level "RDF" element used by XMP metadata.
Setup the element mapping for XMP metadata.
Filled rectangle painting information
Kind of a super-iterator that iterates through child nodes of an FONode,
in turn managing character iterators for each of them.
Reference MIF Element.
Custom Maker adding validity check for reference-orientation
This is an abstract base class for pagination regions.
Class modelling the
fo:region-after object.Abstract base class for
fo:region-before and
fo:region-after.Class modelling the
fo:region-before object.Class modelling the
fo:region-body object.Class modelling the
fo:region-end object.This is a region reference area for a page regions.
Abstract base class for
fo:region-start and
fo:region-end.Class modelling the
fo:region-start object.Region Viewport area.
MOD:CA Registry of object types
This class represent a node in a property expression tree.
Enum class for relative sides.
The interface is used by the AWT preview dialog to reload a document.
Interface implemented by all renderers.
Implementations of this interface have all the renderer-specific configuration data found in the
FOP-conf.
Implementations of this interface parse the relevant renderer-specific configuration data
within the FOP-conf and create a
RendererConfig.Implementations of this interface enumerate the various renderer configuration options available
to users in the FOP conf.
The Render Context for external handlers.
Base class for a wrapper around RendererContext to access its properties in a type-safe,
renderer-specific way.
Defines a number of standard constants (keys) for use by the RendererContext class.
Event producer interface for rendering-specific events.
Provider class for the event producer.
Factory for FOEventHandlers and Renderers.
A runtime exception for handling fatal errors in rendering.
Implementations of this interface provide context information needed by supporting classes
during specific tasks (like image 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-alternatives object.Class modelling the
fo:repeatable-page-master-reference object.Resolvable Interface.
Always (pre-) resolved page number area.
A Resource Environment Group contains a set of resources for a document
or for a group of pages in a document.
Event producer interface for resource events (missing images, fonts etc.).
Provider class for the event producer.
A Resource Group contains a set of overlays.
This class is used when two-pass production is used to generate the PostScript file (setting
"optimize-resources").
This resource structured field begins an envelope that is used to carry
resource objects in print-file-level (external) resource groups.
A Resource Object Type Triplet
A factory class for
ResourceResolvers.Implementations of this interface will be builders for
ResourceResolver, they bind
URI schemes to their respective resolver.Class to find the restart layoutmanager for changing IPD
Class modelling the
fo:retrieve-marker formatting object.Class modelling the
fo:retrieve-table-marker formatting object.Implements the rgb() function.
Implements the rgb-icc() function.
Implements the rgb-named-color() function.
Class modeling the
fo:root formatting object.Represents a rotation value
A class that creates groups of rows belonging to a same set of spans.
RtfContainer that encloses footers
Common code for RtfAfter and RtfBefore.
Attributes for RtfText.
The opposite of RtfAfter
RTF Bookmark.
RTF Bookmark container implementation.
Singelton of the RTF color table.
An RtfElement that can contain other elements.
The RTF document area, container for RtfSection objects.
Base class for all elements of an RTF file.
Event producer interface for events generated by the RTF renderer.
Provider class for the event producer.
Base class for rtflib exceptions.
Creates an RTF image from an external graphic file.
Exception thrown when an image file/URL cannot be read
Used to add extra table rows after a row that contains a nested table:
Models the top-level structure of an RTF file.
Maker class for RTF support.
RTF font table.
RTF font table.
Model of an RTF footnote.
Represents a generator element which says who generated the RTF document.
RTF Handler: generates RTF output using the structure events from
the FO Tree sent to this structure handler.
RTF file header, contains style, font and other document-level information.
Creates an hyperlink.
Process "jfor-cmd"
Generates the leader in RTF.
Model of an RTF line break.
Model of an RTF list, which can contain RTF list items.
Model of an RTF list item, which can contain RTF paragraphs.
Class to handle list styles.
Class to handle bullet list style.
Class to handle number list style.
Class to handle text list style.
RtfListTable: used to make the list table in the header section of the RtfFile.
Null container.
Simplistic options definitions for RTF generation.
Specifies rtf control words.
Page area container.
Model of an RTF page break.
Page number container.
Page number citation container.
Model of an RTF paragraph, which can contain RTF text elements.
Class which represents a paragraph break.
Models the keep together attributes of paragraphs
This class creates objects which are missing from the XSL:FO but are required
by the RTF format.
Models a section in an RTF document
This class is responsible for saving space-before/space-after attributes
history and adding spacing to established candidates (i.e.
This class splits block attributes into space-before attribute, space-after
attribute and common attributes.
Plain text in a RTF file, without any formatings.
Converts java Strings according to RTF conventions.
Thrown when a method call would lead to an invalid RTF document structure.
Singelton of the RTF style sheet table.
Container for RtfRow elements.
A cell in an RTF table, container for paragraphs, lists, etc.
Container for RtfTableCell elements.
Singelton of the RTF style template
This class belongs to the jfor:style-template tag processing.
Model of a text run (a piece of text with attributes) in an RTF document.
Class which contains a linear text run.
Enumeration class for rule styles.
a ruling element
Testing ant task.
The FOP specific incarnation of the XSL-FO scaled baseline table.
Interface for providing script specific context testers.
Abstract script processor base class for which an implementation of the substitution and positioning methods
must be supplied.
A resolver for the separate-border model.
Serialize hyphenation patterns.
This class is a URIResolver implementation that provides access to resources in the WEB-INF
directory of a web application using "servlet-content:" URIs.
Interface used to provide parsing capabilities to Properties with shorthand
characteristics (those with multiple components).
Common base class for side regions (before, after, start, end).
Class modelling the
fo:simple-page-master object.Class to implement a simple lookup context for a single percent base value.
A simple implementation of the OneByteEncoding mostly used for encodings that are constructed
on-the-fly.
A simple SVG user agent.
The interface defines a 1-byte character encoding (with 256 characters).
Generic SingleByte font
Class modelling the
fo:single-page-master-reference object.This class is responsible for solid and double border elements managing.
Inline space area.
A space
A block-stacking layout manager for an FO that supports spaces, border and padding.
This class represents an unresolved space element.
Base class used for handling properties of the fo:space-before and
fo:space-after variety.
Inner class used to create new instances of SpaceProperty
Special CorrespondingPropertyMaker that sets the conditionality subproperty
correctly for space-* properties.
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 break possibilities.
Position class for no-break situations.
Accumulate a sequence of space-specifiers (XSL space type) on
areas with a stacking constraint.
Store a single Space property value in simplified form, with all
Length values resolved.
A maker which creates 'letter-spacing' and 'word-spacing' properties.
The span-reference-area.
Standard attributes, as defined in section 10.7.5 of the PDF Reference, Fourth edition (PDF 1.5).
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.
Class modelling the
fo:static-content object.LayoutManager for an fo:flow object.
A very fast implementation of PropertyList that uses arrays to store
the explicit set properties and another array to store cached values.
Listener interface used by the PreviewDialog.
Implementing object is able to write to an OutputStream
Interface used to store the bytes for a PDFStream.
This class is serves as a factory from
A print-file resource group
Class providing an (FO flavored) char iterator for a string.
Exists primarily as a container for its Maker inner class, which is
extended by many string-based FO property classes.
Inner class for making instances of StringProperty
Library of utility methods useful in dealing with strings.
An AFP object which is able to know its own data length prior to writeToStream()
A helper class to read structured fields from a MO:DCA document.
An element in the document's structure tree.
Converts structure tree events to SAX events.
An object that represents the structure of the document in the output format.
Implementations of this interface can return the element in the document's
structure tree that they resulted into.
Receive notifications relating to the structure tree of an FO document.
A bridge between
FOEventHandler and StructureTreeEventHandler.A structure type, as defined in Section 10.6.2 of the PDF Reference, fourth edition (PDF 1.5).
Classes that implement this interface can be added to a
PageSequenceMaster,
and are capable of looking up an appropriate SimplePageMaster.Optional interface which indicates that glyph substitution is supported and, if supported,
can perform substitution.
Constants for the intermediate format.
Image handler implementation that embeds JPEG bitmaps as RFC 2397 data URLs in the target SVG
file.
IFDocumentHandler implementation
that writes SVG 1.1.Document handler factory for SVG output.
ContentHandlerFactory which constructs ContentHandlers that build SVG DOM
Documents.
Class representing the SVG root element
for constructing an SVG document.
This class is the default context for a particular
element.
Setup the SVG element mapping.
Event producer interface for SVG-related events.
Provider class for the event producer.
Class for SVG element objects.
IFPainter implementation that writes SVG.
IFDocumentHandler implementation
that writes SVG Print.Document handler factory for SVG Print output.
This renderer generates SVG (Scalable Vector Graphics) format.
Defines a number of standard constants (keys) for use by the RendererContext class.
RendererMaker for the SVG Renderer.
Rendering context for SVG production.
The svg:svg element handler.
The SVG user agent.
This class provides utility methods for generating SVG.
Some utilities for creating svg DOM documents and elements.
Implements the system-color() function.
This class implements org.apache.fop.layout.FontMetrics and
is added to the hash table in FontInfo.
Class modelling the
fo:table object.Class modelling the
fo:table-and-caption property.LayoutManager for a table-and-caption FO.
Provides methods to convert the attributes to RtfAttributes.
Class modelling the
fo:table-body object.A table border preference property maker.
Class modelling the
fo:table-caption object.LayoutManager for a table-caption FO.
Class modelling the
fo:table-cell object.A common class for fo:table-body and fo:table-row which both can contain fo:table-cell.
LayoutManager for a table-cell FO.
A table-column width specification, possibly including some
number of proportional "column-units".
Class modelling the
fo:table-column object.Layout manager for table contents, particularly managing the creation of combined element lists.
This class represents a Position specific to TableContentLayoutManager.
Used when handling fo:table to hold information to build the table.
Event producer interface for table-specific XSL-FO validation messages.
Provider class for the event producer.
Common base class for table-related FOs
PropertyMaker subclass for the column-number propertyClass modelling the
fo:table-footer object.Class modelling the
fo:table-header object.This class represents a Position specific to TableContentLayoutManager.
This class represents a Position specific to TableContentLayoutManager.
LayoutManager for a table FO.
Temporary holder of column background informations for a table-cell's area.
An abstract base class modelling a TablePart
(i.e.
Class modelling the
fo:table-row object.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).
This class processes row groups to create combined element lists for tables.
A Tag Logical Element structured field assigns an attribute name and an
attribute value to a page or page group.
Holds the attribute state of a TLE
The
TamilScriptProcessor class implements a script processor for
performing glyph substitution and positioning operations on content associated with the Tamil script.StreamCache implementation that uses temporary files rather than heap.
Ternary Search Tree.
TestConverter is used to process a set of tests specified in
a testsuite.
A text inline area.
Converts FO properties to RtfAttributes.
PtocaProducer implementation that interprets AFPTextDataInfo objects.Dedicated
PropertyMaker for handling the
text-decoration
property.Encapsulates a sub-sequence (fragement) of a text iterator (or other text source),
where begin index and end index are indices into larger text iterator that denote
[begin,end) of sub-sequence range.
The
TextInterval class is a utility class, the instances of which are used
to record backpointers to associated nodes over sub-intervals of a delimited text range.LayoutManager for text (a sequence of characters) which generates one
or more inline areas.
Compression constants for TIFF image output.
IFDocumentHandler implementation
that produces TIFF files.Document handler factory for TIFF output.
This class represents renderer to TIFF (Tagged Image File Format) format.
The renderer configuration object for the TIFF renderer.
The TIFF renderer configuration parser.
TIFF Renderer configurator
RendererMaker for the TIFF Renderer.
Class modeling the
fo:title object.A special property for representing an as yet unimplemented property.
A to be implemented property maker instance.
This interface is implemented by top-level layout managers such as the ones for fo:page-sequence
and fox:external-document.
A data class representing entries of the file trailer dictionary.
Area traits used for rendering.
Background trait structure.
External Link trait structure
Class for internal link traits.
Base class for enumeration classes representing traits.
This is a helper class used for setting common traits on areas.
A DefaultHandler implementation that delegates all the method calls to a
TransformerHandler instance.Transition Dictionary
This class is used to build a transition dictionary to
specify the transition between pages.
AWT Viewer's localization class, backed up by
java.util.ResourceBundle.The PDF profile being used does not allow transparency.
This object represents a series of PTOCA TransparentData (TRN) control sequences.
Triplet interface.
Reads a TrueType file or a TrueType Collection.
An interface for writing individual glyphs from the glyf table of a TrueType font to an output stream.
An interface for writing a TrueType font to an output stream.
A tool which reads TTF files and generates
XML font metrics file for use in FOP.
Reads a TrueType file and generates a subset
that can be used to embed a TrueType CID font.
An interface for writing a TrueType table to an output stream.
Renderer that renders areas to plain text.
The Text renderer configuration data object.
The Text renderer configuration data parser.
TXT Renderer configurator
RendererMaker for the Plain Text Renderer.
This keeps information about the current state when writing to txt, i.e.
Helper class for text streams.
This class represents a formatter for CharString commands of a Type1 font.
This class represents a formatter for a given Type1 font.
Loads a Type 1 font into memory directly from the original font file.
A class to encode and decode sections of a type 1 font file.
A class used to store the last number operand and also it's size in bytes
Base class for font classes
Provides an InputStreamFilter which avoids closing the original stream.
A reference to an indirect object that is not stored in an object stream.
The
UnflattenProcessor class is used to reconstruct (by unflattening) a line
area's internal area hierarachy after leaf inline area reordering is completed.The
UnicodeBidiAlgorithm class implements functionality prescribed by
the Unicode Bidirectional Algorithm, Unicode Standard Annex #9.Deprecated.
use org.apache.xmlgraphics.util.UnitConv instead.
Unix font directory finder
Class for handling generic XML from a namespace not recognized by FOP
Inner class for an UnknownXMLObj Maker
Represents an unparsed (generic) AFP structured field.
This class represents an unresolved list element.
This class represents an unresolved list element element with a (conditional) length.
Unresolvable page number area.
Exception factory for
UnsupportedOperationException.Action class which represents a "URI" action, i.e.
Class modeling a property that has a value of type <uri-specification>.
Inner
PropertyMaker subclass responsible
for making instances of this type.This class contains method to deal with the <uri-specification> datatype from XSL-FO.
UTF32 related utilities.
Exception thrown during FO tree validation.
Exception factory for
ValidationException.This base context is used during validation when the actual base values are still unknown
but should still already be checked.
A row group builder accommodating a variable number of columns.
Each event is recorded and will be played once the table is finished, and the final
number of columns known.
A version of PDF.
This class is used to evaluate the version information contained in the Manifest of FOP's JAR.
An abstraction that controls the mutability of the PDF version for a document.
A class representing the version of a PDF document.
A class representing the version of a PDF document.
A shorthand parser for the vertical-align shorthand.
A viewport-area that may clip its content.
Collapses whitespace of an RtfContainer that contains RtfText elements.
A special penalty used to specify content having multiple variants.
Shorthand parser for the white-space property;
Sets the values for white-space-treament, linefeed-treatment,
white-space-collapse and wrap-option
FontFinder for native Windows platforms
A string of characters without spaces
Class modelling the fo wrapper
fo:wrapper object.This is the layout manager for the fo:wrapper formatting object.
Deprecated.
use org.apache.xmlgraphics.util.WriterOutputStream instead
Enumeration class for writing mode trait.
This class provides a reusable implementation of the WritingModeTraitsSetter
interface.
This interface provides read access to FO traits related to writing mode.
This interface provides read and assignment access to FO traits related to writing mode.
A collection of constants for XML handling.
Deprecated.
This interface is implemented by classes that can handle a certain type
of foreign objects.
Configurator for XMLHandler objects.
This class holds references to various XML handlers used by FOP.
A parser for the xml:lang property.
Abstract class modelling generic, non-XSL-FO XML objects.
Renderer that renders areas to XML for debugging purposes.
RendererMaker for the Area Tree XML Renderer.
This class is a ResourceBundle that loads its contents from XML files instead of properties
files (like PropertiesResourceBundle).
A collection of utility method for XML handling.
Class encapsulating the functionality for white-space-handling
during refinement stage.
XML handler for the XML renderer.
ContentHandlerFactory for the XMP root element.
Setup the element mapping for XMP metadata.
This is the pass-through value object for the XMP metadata extension.
Represents the top-level "xmpmeta" element used by XMP metadata.
ColorWithAlternatives