All Classes and Interfaces
Class
Description
Base class for device-specific (uncalibrated) color spaces.
Abstract base class for DSC comments.
Abstract base class for DSC events.
This extension of the java.awt.Graphics2D abstract class
is still abstract, but it implements a lot of the Graphics2D
method in a way that concrete implementations can reuse.
Adapter to allow subclassing java.awt.GraphicsConfiguration without
compilation errors.
Abstract base class for Image implementations.
Abstract base class for ImageConverter implementations.
Simple abstract base class for ImageLoaders.
Abstract base class for ImageLoaderFactory implementations.
Abstract base class for image preloaders.
Abstract base class for classes implementing ImageSessionContext.
Implementations of this interface will be used as the mechanism for creating the
Source that wraps resources.This fallback resolver is to be used in environments where controlling file access is of
critical importance.
An unrestricted resolver that has various contingency mechanisms that access the file-system.
Abstract base class for ImageWriter implementations.
This class is a wrapper for the PSGraphics2D that
is used to create a full document around the PostScript rendering from
PSGraphics2D.
This is an abstract base class that takes care of most of the
normal issues surrounding the implementation of the CachableRed
(RenderedImage) interface.
Abstract base class for resource comments.
Abstract base class for Resource DSC comments (DocumentNeededResources,
DocumentSuppliedResources and PageResources).
Schema adapter implementation for the Adobe PDF schema.
Adobe PDF XMP schema.
This function will tranform an image from any colorspace into a
luminance image.
This function will tranform an image from any colorspace into a
luminance image.
Merges properties by adding up all items from both ends into one SEQ array.
This interface defines constants used by the ASCII85 filters.
This class applies a ASCII85 decoding to the stream.
This class applies a ASCII85 encoding to the stream.
This class applies a ASCII Hex encoding to the stream.
This class implements a Base64 Character decoder as specified in RFC1113.
This class implements a Base64 Character encoder as specified in RFC1113.
This implements CachableRed based on a BufferedImage.
This provides a number of extra methods that enable a system to
better analyse the dependencies between nodes in a render graph.
This class defines the CIE L*a*b* (CIE 1976) color space.
A class to find resources in the classpath by their mime-type specified in
the MANIFEST.
Deprecated.
This class has been moved to the "color" subpackage.
Utility for implementing a color conversion scheme.
Helper methods for handling color profiles.
Interface used to decorate java.awt.color.ColorSpaces subclasses
to report the origin of the associated color profile.
Provides access to various color spaces.
Generic Color helper class.
Extended
Color class allowing to specify a prioritized list of alternative colors.A URI Resolver which supports pluggable entities via the
Service
mechanism.Composite ImageLoader implementation in order to provide fallbacks when one ImageLoader
fails due to some limitation.
Enumerates the possible compression values for TIFF images.
Resolves data URLs (described in RFC 2397) returning its data as a StreamSource.
Utility classes for generating RFC 2397 data URLs.
A default implementation that does not apply any conversion
Default implementation of a DSCHandler which simply passes through the PostScript content
unchanged.
Default implementation of an edge directory for the
DijkstraAlgorithm.Implements the default expiration policy for the image cache.
This concrete implementation of AbstractGraphics2D is a
simple help to programmers to get started with their own
implementation of Graphics2D.
Very simple ImageContext implementation that uses the
Toolkit's screen resolution.Very simple implementation of the ImageSessionContext interface.
DSCListener implementation which automatically skips data
between Begin/EndDocument and Begin/EndData.This class represents an uncalibrated CMYK color space.
This is an implementation of Dijkstra's algorithm to find the shortest path for a directed
graph with non-negative edge weights.
Subclass of Dimension2D which takes double values.
This class implements fast, thread-safe format of a double value
with a given number of decimal digits.
This class represents a DSC comment with an "(ATEND)" value.
Base interface for all DSC comments.
Represents a %BeginDocument DSC comment.
Represents a %BeginResource DSC comment.
Represents a %%BoundingBox DSC comment.
Represents a %%DocumentNeededResources DSC comment.
Represents a %%DocumentSuppliedResources DSC comment.
Respresents a %%EndComments DSC comment.
Represents a %%EOF DSC comment.
Factory for DSCComment subclasses.
Represents a %%HiResBoundingBox DSC comment.
Represents a %IncludeResource DSC comment.
Represents a %%LanguageLevel DSC comment
Represents a %%Page DSC comment.
Represents a %%PageBoundingBox DSC comment.
Represents a %%PageHiResBoundingBox DSC comment.
Represents a %%PageResources DSC comment.
Represents the %%Pages DSC comment.
Represents a %%Title DSC comment.
This class defines constants with Strings for the DSC specification.
Interface representing a DSC event.
Exception to signal problems while parsing a supposedly DSC-conformant file.
Filter interface for DSC events used by the DSC parser.
Interface containing events generated by the DSCParser.
Represents a DSC header comment (beginning with "%!).
Listener interface for the DSC parser.
Parser for DSC-compliant PostScript files (DSC = Document Structuring Conventions).
Constants the DSC parser uses.
Helper methods commonly used when dealing with DSC-compliant PostScript files.
Schema adapter implementation for the Dublin Core schema.
Schema class for Dublin Core.
Represents an edge (or direct route between two points) for the
DijkstraAlgorithm.Represents a directory of edges for use by the
DijkstraAlgorithm.Enumeration for specifying the endianness of the image.
This class is a wrapper for the AbstractPSDocumentGraphics2D that
is used to create EPS (Encapsulated PostScript) files instead of PS file.
DSCHandler implementation that records DSC events.
Represents an expiration policy for cache entries that have a creation time stamp.
This interface provides much more control over internationalization
than the Localizable interface.
A subclass of
SeekableStream that may be used to wrap
a regular InputStream.DSCListener implementation that filters certain DSC events.This interface is used for special FilteredOutputStream classes that won't
be closed (since this causes the target OutputStream to be closed, too) but
where flush() is not enough, for example because a final marker has to be
written to the target stream.
This class applies a FlateEncode filter to the stream.
This allows you to specify the ColorModel, Alpha premult and/or
SampleModel to be used for output.
Abstract helper class for generating PostScript forms.
A subclass of
SeekableStream that may be used
to wrap a regular InputStream efficiently.This implements the
GraphicsDevice interface as appropriate for the various output
configurations.This class provides a number of constants for glyph management.
Handles the attributes in a graphic context:
+ Composite
+ Font
+ Paint
+ Stroke
+ Clip
+ RenderingHints
+ AffineTransform
+ Composite
+ Font
+ Paint
+ Stroke
+ Clip
+ RenderingHints
+ AffineTransform
This interface is used to paint vector graphic images.
An implementation of
GraphicsConfiguration that does not support transparencies
(alpha channels).An implementation of
GraphicsConfiguration that supports transparencies (alpha
channels).Set of utility methods for Graphics.
Converts to grayscale using the standard RED=30%, GREEN=59% and BLUE=11%
weights (see http://en.wikipedia.org/wiki/Grayscale)
This class extends the ICCColorSpace class by providing
convenience methods to convert to sRGB using various
methods, forcing a given intent, such as perceptual or
relative colorimetric.
Represents an instance of an image (bitmap or vector graphic).
This class is an implementation of the Image interface exposing a BufferedImage.
This class provides a cache for images.
This interface can be implemented by classes which want to know what's going on inside the
image cache.
Convenience class that gathers statistical information about the image cache.
The ImageContext interface provides session-independent information (mainly configuration
values).
Defines an image converter that can convert one image representation into another.
This ImageConverter wraps a bitmap image in a Graphics2D image.
This ImageConverter converts BufferedImages to RenderedImages (well, it's basically just a
class cast).
This ImageConverter converts Graphics2D images to a BufferedImage.
This ImageConverter converts Rendered to PNG images.
An empty (marker) interface to be implemented by all image decoder
parameter classes.
An interface describing objects that transform an InputStream into a
BufferedImage or Raster.
A partial implementation of the
ImageDecoder interface
useful for subclassing.An empty (marker) interface to be implemented by all image encoder
parameter classes.
An interface describing objects that transform a BufferedImage or
Raster into an OutputStream.
The interface is implemented by classes that can generate the raw bitmap field for an image
that might be further encoded/compressed by the image handler class.
A partial implementation of the ImageEncoder interface useful for
subclassing.
Helper class for encoding bitmap images.
Base class for all image-related exceptions.
The flavor of an image indicates in which form it is available.
Abstract helper class for generating PostScript forms.
This class is an implementation of the Image interface exposing a Graphics2DImagePainter.
This class is the registry for all implementations of the various service provider interfaces
for the image package.
Represents an image that may not have been fully loaded.
Decorates an ImageInputStream with an InputStream interface.
A subclass of
SeekableStream that may be used to wrap
a regular ImageInputStream.Helper class for debugging stuff in Image I/O.
ImageWriter implementation that uses Image I/O to write images.
ImageWriter that encodes JPEG images using Image I/O.
ImageWriter that encodes PNG images using Image I/O.
ImageWriter that encodes TIFF images using Image I/O.
Helper and convenience methods for ImageIO.
Key class for Image instances in the cache.
This interface is implemented by classes which load images from a source.
ImageLoader for EPS (Encapsulated PostScript) images.
This interface is implemented to provide information about an ImageLoader and to create new
instances.
Factory class for the ImageLoader for EPS (Encapsulated PostScript) images.
Factory class for the ImageLoader based on ImageIO.
Factory class for the ImageLoader for TIFF (based on Commons' internal TIFF codec).
Factory class for the ImageLoader for raw/undecoded images.
Factory class for the ImageLoader for raw/undecoded CCITT encoded images.
An ImageLoader implementation based on ImageIO for loading bitmap images.
An ImageLoader implementation based on Commons' internal TIFF codec.
ImageLoader for formats consumed "raw" (undecoded).
ImageLoader for CCITT group 3 and 4 images consumed "raw" (undecoded).
ImageLoader for JPEG images consumed "raw" (undecoded).
ImageManager is the central starting point for image access.
This interface provides two functions: determining whether an image format is supported and if
that's the case, some minimal information (mostly the image's intrinsic size) is extracted
and returned.
This interface defines some standard hints to be used for image processing in this package.
Represents a pipeline of ImageConverters with an ImageLoader at the beginning of the
pipeline.
This class is an implementation of the Image interface exposing a 1-bit bitmap image stream
that can be decoded by the PostScript or PDF CCITTFaxDecode filter.
This class is an implementation of the Image interface exposing EPS file.
This class is an implementation of the Image interface exposing a JPEG file.
This class is an implementation of the Image interface exposing an InputStream for loading the
raw/undecoded image.
InputStream factory that wraps a byte array.
Represents a factory for InputStream objects.
This class is an implementation of the Image interface exposing a RenderedImage.
This class represents a combination of MIME type and an image flavor.
This interface is used to tell the cache which images are used by a session (in FOP that would
be a rendering run).
Encapsulates the size of an image.
Acts as a holder for the input to image loading operations.
Helper and convenience methods for working with the image package.
Interface which allows image library independent image writing.
Parameters for the encoder which is accessed through the
ImageWriter interface.
Registry for
ImageWriter implementations.Convenience methods around ImageWriter for the most important tasks.
This class is an implementation of the Image interface exposing an XML DOM (W3C).
Constants for JPEG images
Provides methods useful for processing JPEG files.
This class represents a group of ExtendedLocalizable objects which
have a shared default locale.
This interface must be implemented by the classes which must provide a
way to override the default locale.
This class provides a default implementation of the Localizable interface.
A subclass of
SeekableStream that may be used to wrap
a regular InputStream.Represents a set of rules used to merge to XMP properties.
This class represents the root of an XMP metadata tree.
Frequently used MIME types for various file formats used by the XML Graphics project.
Special image flavor subclass which enables the restriction to a particular MIME type.
Interface which allows writing multiple images into one image file if the output format
supports this feature.
Simplified in-memory representation of an ICC named color profile.
This class is a parser for ICC named color profiles.
Implements a pseudo color space for a named color which is defined in the CIE XYZ color space.
Interface that is used to delegate the handling of nested documents (EPS files, data sections)
in a PostScript document.
A basic PropertyMerger which only sets a value in the target metadata if there's not already
another value.
This class can extract a certain range of pages from a DSC-compliant PostScript file.
Schema adapter implementation for both the old (deprecated) and the current PDF/A schema.
XMP Schema for PDF/A (ISO 19005-1).
Schema adapter implementation for both the old (deprecated) and the current PDF/UA schema.
XMP Schema for PDF/UA
Immutable class representing a penalty value.
Factory class for image processing pipelines.
See http://en.wikipedia.org/wiki/Portable_Network_Graphics for a light explanation;
See http://www.libpng.org/pub/png/spec/1.2/PNG-Chunks.html for the spec.
An instance of
ImageDecodeParam for decoding images in
the PNG format.An instance of
ImageEncodeParam for encoding images in
the PNG format.An ImageEncoder for the PNG file format.
ImageWriter implementation that uses the internal PNG codec to
write PNG files.
A class representing the fields of a PNG suggested palette entry.
Represents a PostScript comment
Represents a line of PostScript code.
Image preloader for BMP images.
Image preloader for EMF images.
Image preloader for EPS images (Encapsulated PostScript).
Holder class for various pointers to the contents of the EPS file.
Image preloader for GIF images.
Image preloader for images supported by ImageIO.
Image preloader for JPEG images.
Image preloader for TIFF images.
This interface is implemented by the top-level Metadata class and stuctured properties.
Defines an interface the classes can implement to provide special property merging behaviour.
Interface to map standard PostScript commands to other commands or macros, for example
shorthands for compact PostScript code.
This class is used to encapsulate postscript dictionary objects.
Thrown to indicate that a formatting error has occurred when
trying to parse a PostScript dictionary object
This class is a wrapper for the PSGraphics2D that
is used to create a full document around the PostScript rendering from
PSGraphics2D.
Utility code for font handling in PostScript.
This class is used to output PostScript code to an OutputStream.
This is a concrete implementation of AbstractGraphics2D (and
therefore of Graphics2D) which is able to generate PostScript
code.
Utility code for rendering images in PostScript.
Postscript page device dictionary object
This object is used by the postscript renderer to hold postscript page device
values.
PSResource subclass that represents a ProcSet resource.
This class defines the basic resources (procsets) used by the Apache XML Graphics project.
Represents a PostScript resource (file, font, procset etc.).
This class holds the current state of the PostScript interpreter.
Interface which the Graphics2D class delegates text painting to for Postscript.
This class is implementation of PostScript tiling pattern.
Represents a qualified name of an XML element or an XML attribute.
Special image flavor subclass which enables the refinement to specific (sub-)flavors but
maintaining compatibility to a parent (i.e.
This implements CachableRed around a RenderedImage.
Enumeration for rendering intents.
The most basic PropertyMerger which simply overwrites any existing value in the target metadata.
Enumeration for resolution units used by images; 1 for None, 2 for Inch and 3 for Centimeter.
This class represents a resolved resource.
Implementations of this resource resolver allow XGC users to control the URI resolution
mechanism.
This class is used to track resources in a DSC-compliant PostScript file.
This class applies a RunLengthEncode filter to the stream.
An
OutputStream which can seek to an arbitrary offset.An abstract subclass of
java.io.InputStream that allows seeking
within the input, similar to the RandomAccessFile class.Adapter which provides a SeekableStream interface over an ImageInputStream.
This class handles looking up service providers on the class path.
Simple refined image flavor implementation that just differs flavors by name but allows to
specify a parent flavor.
A simple class implemented the
RenderedImage
interface.A simple class that provides RenderedImage functionality
given a Raster and a ColorModel.
Provides a simple cache using soft references and storing the values in a Map.
Special SoftReference subclass that holds an additional key object that can be used to remove
a reference from a Map once the referenced object is collected, for example.
Default TextHandler implementation which paints text using graphics primitives (shapes).
Exception which indicates that a particular (sub-)image could not be found.
This class is a FilterInputStream descendant that reads from an underlying InputStream
up to a defined number of bytes or the end of the underlying stream.
Implementations of this interface resolve URIs for temporary files used by XGC.
Creates a URI for any temporary resource used within XGC.
Interface which the Graphics2D class delegates text painting to.
An instance of
ImageDecodeParam for decoding images in
the TIFF format.A class representing an Image File Directory (IFD) from a TIFF 6.0
stream.
An instance of
ImageEncodeParam for encoding images in
the TIFF format.A class representing a field in a TIFF 6.0 Image File Directory.
A baseline TIFF reader.
A baseline TIFF writer.
ImageWriter implementation that uses the internal TIFF codec to
write TIFF files.
A class for performing LZW decoding.
Contains a description of an elementary transform stack element,
such as a rotate or translate.
Enumeration for transformation types.
Utility class for unit conversions.
Represents a DSC comment that is not parsed into one of the concrete DSCComment subclasses.
An adapter between
URIResolver to ResourceResolver.Represents a vertex to be used by
DijkstraAlgorithm.An OutputStream wrapper for a Writer.
This interface can be implemented by classes willing to provide an XML representation
of their current state as SAX events.
Special image flavor subclass which enables the restriction to a particular XML namespace.
Represents an XMP array as defined by the XMP specification.
Enum class for XMP array types.
Schema adapter implementation for the XMP Basic schema.
XMP schema for XMP Basic.
Base class for complex data types in XMP.
Constants used in XMP metadata.
Passive XMP parser implemented as a SAX DefaultHandler.
This class is a parser for XMP packets.
The XMP parser.
This class is the base class for all XMP properties.
Base class for schema implementations that provide user-friendly access to XMP values.
Base class for schema-specific adapters that provide user-friendly access to XMP values.
This class is a registry of XMP schemas.
Serializes an XMP tree to XML or to an XMP packet.
Represents an XMP structure as defined by the XMP specification.