All Classes and Interfaces
Class
Description
A dialog showing the revision of the Batik viewer as well
as the list of contributors.
An abstract base class for the different types of animation.
This class implements the
Attr interface.Inner class to hold type information about this attribute.
This class provides an abstract implementation of the
AttributeCondition interface.This class provides an abstract implementation of the
AttributeCondition interface.This class implements the
Attr interface with
support for namespaces.This class implements the
CharacterData interface.This class is the superclass of all the char decoders.
This class implements the
Node interface with support
for parent and siblings.This is a base class for CIE Lab/LCH color values.
This is an abstract base class that adds the ability to specify the
Color Space that the operation should take place in (linear sRGB or
gamma corrected sRBG).
This class provides a manager for the property with support for
CSS color values.
This class provides an abstract implementation of the
CombinatorCondition interface.This class provides an abstract implementation of the
CombinatorCondition interface.This class implements the
Comment interface.Abstract compound command.
A base class for handlers of different XBL content element includes
attribute syntaxes.
An interface for content selector factories.
A factory for XPathPatternContentSelector objects.
A factory for XPathSubsetContentSelector objects.
This class provides an abstract implementation of the
DescendantSelector interface.This class provides an abstract implementation of the
DescendantSelector interface.This class implements the
Document interface.DOMError implementation.
The DOMLocator implementation.
An XPathNSResolver that uses Node.lookupNamespaceURI.
This class implements
DocumentFragment interface.This class implements the
DOMImplementation,
DOMImplementationCSS interfaces.This class provides a superclass to implement an SVG element, or
an element interoperable with the SVG elements.
This class implements the
Element interface.Inner class to hold type information about this element.
To manage collisions in the attributes map.
This class implements the
Element interface.This class provides an abstract implementation of the ElementSelector
interface.
This class provides an abstract implementation of the
ElementSelector interface.This class implements the
Entity interface.This class implements the
EntityReference interface.The abstract
Event root class.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.A partial implementation of the
GraphicsNode interface.The base bridge class for SVG graphics node.
This abstract implementation of the ImageHandler interface
is intended to be the base class for ImageHandlers that generate
image files for all the images they handle.
This is the base class for all ImageIO-based RegistryEntry implementations.
This class represents a zoom interactor.
An abstract implementation of the Light interface.
This class implements the
Node interface.This class implements the
Notation interface.This class represents a pan interactor.
This class implements the
Node interface with support
for children, parent and siblings.This class implements the Node interface with support for children.
Very simple abstract base class for ParsedURLProtocolHandlers.
This class is the superclass of all parsers.
This class implements the
ProcessingInstruction
interface.This is an abstract base class that takes care of most of the
normal issues surrounding the implementation of the RenderableImage
interface.
This is an abstract base class that takes care of most of the
normal issues surrounding the implementation of the CachableRed
(RenderedImage) interface.
This class represents an interactor which reset the rendering transform
of the associated document.
This class represents a rotate interactor.
An abstract scanner class to be extended.
An abstract class for path segments.
This class provides an abstract implementation of the
SiblingSelector interface.This class provides an abstract implementation of the
SiblingSelector interface.A Document that supports CSS styling.
This class provides an implementation of the
SVGAnimatedLength interface.An abstract base class for the
SVGAnimated* classes, that
implements an AnimatedAttributeListener list.The base bridge class for SVG elements.
Abstract class with common utility methods used by subclasses
for specific convertion operations.
Abstract class with common utility methods used by subclasses
for specific convertion operations.
The base bridge class for SVG filter primitives.
Bridge class for vending gradients.
This class represents a gradient <stop> element.
Bridge class for the gradient <stop> element.
Adapter for the SVGItem interface.
Default implementation for SVGLength.
This class is the implementation of
SVGLengthList.Bridge class for the <feDiffuseLighting> element.
The base bridge class for light element.
Bridge class for the <feDistantLight> element.
Bridge class for the <fePointLight> element.
Bridge class for the <feSpotLight> element.
This class is a base implementation for a live
list representation of SVG attributes.
This class provides an abstract implementation of the
SVGMatrix
interface.This class is the implementation of the normalized
SVGPathSegList.Implementation of
SVGNumber.This class is the implementation of
SVGNumberList.Helper class to interface the
NumberListParser and the
NumberListHandler.This class is the implementation of
SVGPathSegList.Abstract implementation of
SVGPointList.Helper class to interface the
PointsParser and the
PointsHandler.Abstract implementation for SVGPreservAspectRatio
This is the base implementation for SVGPreservAspectRatio
Abstract implementation of
SVGTransform.This class is the implementation of
SVGTransformList.An
SVGTransform in the list.Helper class to interface the
TransformListParser and the
ListHandler.This class implements the
Text interface.This is an abstract base class that takes care of most of the
normal issues surrounding the implementation of the CachableRed
(RenderedImage) interface.
This class can be the base class of a transcoder which may support
transcoding hints and/or error handler.
Represents abstract undoable/redoable command.
This class provides an abstract implementation of the Value interface.
This class provides a base implementation for the value factories.
This class provides an abstract implementation of the ValueManager
interface.
This class provides generic methods that must be used by a particular WMFPainter.
This class provides a general framework to read WMF Metafiles.
This class represents a zoom interactor.
A class to handle SMIL access key timing specifiers.
This interface represents an object which maps actions to strings
Adjusts the input images coordinate system by a general Affine transform
Concrete implementation of the AffineRable interface.
This is an implementation of an affine operation as a RenderedImage.
This class provides a manager for the 'alignment-baseline' property values.
An interface for handling altGlyphs.
This interface must be implemented and then registred as the
handler of a
AngleParser instance in order to be
notified of parsing events.This class implements an event-based parser for the SVG angle
values.
An SVG angle-or-identifier value in the animation system.
An SVG angle value in the animation system.
A boolean value in the animation system.
An SVG color value in the animation system.
An interface for animatable elements to expose their underlying values
to the compositing functions in
AbstractAnimation.Abstract bridge class for animatable elements that do not produce
a GraphicsNode.
An integer in the animation engine.
An SVG length list value in the animation system.
An SVG length-or-identifier value in the animation system.
An SVG length value in the animation system.
A point value in the animation system from a motion animation.
A number list in the animation system.
A number-optional-number value in the animation system.
A number-or-identifier value in the animation system.
A number-or-percentage value in the animation system.
A number value in the animation system.
An SVG paint value in the animation system.
An SVG path value in the animation system.
A percentage value in the animation system.
An SVG point list value in the animation system.
An SVG preserveAspectRatio value in the animation system.
An SVG rect value in the animation system.
A string value in the animation system.
Abstract bridge class for those elements that can be animated.
An SVG transform list value in the animation system.
An abstract class for values in the animation engine.
An interface to listen for changes on any animatable XML attribute in
an
SVGOMDocument.An interface for
LiveAttributeValues that have an animated value
component.An abstract base class for managing animation in a document.
Class to hold target information of an animation.
Class to hold an animation sandwich for a particular attribute.
Class to hold XML and CSS animations for a target element.
An exception class for SMIL animation exceptions.
Class that provides utilities for animation support.
An interface for targets of animation to provide context information.
A listener class for animation targets.
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.
This function will tranform an image from any colorspace into a
luminance image.
This interface represents a SVG viewer application.
This is a helper class which helps applications enforce secure
script execution.
Handles the processing of arabic text.
Enumerated type for an ARGB Channel selector.
This class represents an object which decodes ASCII characters from
a stream of bytes.
AttributedCharacterSpanIterator
Used to provide ACI functionality to a "substring" of an AttributedString.
This class is used by elements to initialize and reset their attributes.
A transcoding Key represented as a boolean to indicate whether tiling of
bitmaps is undesired by the destination.
An EventDispatcher implementation based on AWT events.
A font family class for AWT fonts.
This class represents a doubly indexed hash table, which holds
soft references to the contained glyph geometry informations.
The object that holds glyph geometry.
This is a wrapper class for a java.awt.Font instance.
This is a wrapper class for a java.awt.font.GlyphVector instance.
This class provides an implementation of the PathHandler that initializes
a Shape from the value of a path's 'd' attribute.
This class produces a polygon shape from a reader.
This class produces a polyline shape from a reader.
This class provides an implementation of the PathHandler that initializes
an AffineTransform from the value of a 'transform' attribute.
This implementation of RenderableImage will render its input
GraphicsNode into a BufferedImage upon invokation of one of its
createRendering methods.
This class implements a Base64 Character decoder as specified in RFC1113.
This class implements a Base64 Character encoder as specified in RFC1113.
This class provides a manager for the 'baseline-shift' property values.
This class is the base class for SVG scripting.
Basic implementation of TextPainter which
renders the attributed character iterator of a
TextNode.This TextPainter's implementation of the Mark interface.
This is a Service interface for classes that want to extend the
functionality of the Bridge, to support new tags in the rendering tree.
This is a Service interface for classes that want to extend the
functionality of the Dom, to support new tags in the rendering tree.
To create a 'histogramNormalization' element.
To create a 'regularPolygon' element.
To create a 'star' element.
To create a 'colorSwitch' element.
To create a 'flowDiv' element.
To create a 'flowLine' element.
To create a 'flowPara' element.
To create a 'flowRegionBreak' element.
To create a 'flowRegion' element.
To create a 'flowSpan' element.
To create a 'flowText' element.
Batik extension constants.
Bridge class for the <flowText> element.
This class implements a histogram normalization extension to SVG.
Bridge class for a histogram normalization element.
This class implements a regular polygon extension to SVG
Bridge class for a regular polygon element.
This implementation of the Rhino
SecurityController interface is
meant for use within the context of Batik only.This
SecurityManager extension exposes the getClassContext
method so that it can be used by the BatikSecuritySupport or other
security related class.This class implements a star shape extension to sVG
Bridge class for a star element.
An attributed character iterator that does the reordering of the characters
for bidirectional text.
This class implements foreign namespace elements that can be
bound with XBL.
Bridge class for foreign namespace elements that can be bound with sXBL.
The interface for listening to binding changes on bindable elements.
A transcoding Key represented as a boolean.
A tagging interface that all bridges must implement.
This class represents a context used by the various bridges and the
builder.
A class used to store an EventListener added to the DOM.
This class is responsible of tracking GraphicsNodeMouseEvent and
fowarding them to the DOM as regular DOM MouseEvent.
A GraphicsNodeMouseListener that dispatch DOM events accordingly.
Thrown when the bridge has detected an error.
This is a Service interface for classes that want to extend the
functionality of the Bridge, to support new tags in the rendering tree.
Interface for objects interested in being notified of updates.
This interface is to be used to provide alternate ways of
generating a placeholder image when the ImageTagRegistry
fails to handle a given reference.
This implements CachableRed based on a BufferedImage.
Default BumpMap implementation.
This class represents a button factory which builds
buttons from the content of a resource bundle.
This provides a number of extra methods that enable a system to
better analyse the dependencies between nodes in a render graph.
Extends the default ImageHandler interface with calls to
allow caching of raster images in generated SVG content.
This subclass of
ImageHandlerBase64Encoder implements
functionality specific to the cached version of the image
encoder.GenericImageHandler which caches JPEG images.
GenericImageHandler which caches PNG images.
The graphics node container with a background color.
This interface represents an object which decodes characters from a
stream of bytes.
This class represents an CIE L*a*b* color value.
This class represents an CIE LCH color value.
This class contains utility methods to manipulate Java classes.
One line Class Desc
Complete Class Desc
A PhantomReference subclass that automatically registers with
the cleaner ReferenceQueue.
If objects registered with the reference queue associated with
this class implement this interface then the 'cleared' method
will be called when the reference is queued.
A SoftReference subclass that automatically registers with
the cleaner ReferenceQueue.
A WeakReference subclass that automatically registers with
the cleaner ReferenceQueue.
Factory class for vending
Shape objects that represents a
clipping area.This class provides a manager for the 'clip' property values.
This class provides a manager for the 'clip-path' property values.
Implements a clip operation.
ClipRable implementation
This class provides a manager for the 'clip-rule' property values.
This interface must be implemented and then registered as the
handler of a
ClockParser instance in order
to be notified of parsing events.A parser for clock values.
Simple Macintosh cmap table, mapping only the ASCII character set to glyphs.
An animation class for 'animateColor' animations.
This class provides a manager for the 'color-interpolation' property values.
This class provides a manager for the 'color-interpolation' property values.
This class provides a manager for the 'color' property values.
Defines the interface expected from a color matrix
operation
Implements the interface expected from a color matrix
operation
This class provides a manager for the 'color-interpolation' property values.
This class provides a manager for the 'color-rendering' property values.
TranscodingHint as to what the destination of the drawing is.
Bridge class for the "color switch" extension element.
This class implements a "color switch" extension to SVG.
Defines the interface expected from a component
transfer function.
Defines the interface expected from a component
transfer operation.
This class implements the interface expected from a component
transfer operation.
A CompositeGraphicsNode is a graphics node that can contain graphics nodes.
Composites a list of images according to a single composite rule.
Composites a list of images according to a single composite rule.
This is an implementation of an affine operation as a RenderedImage.
This is a typesafe enumeration of the standard Composite rules for
the CompositeRable operation.
A shape painter which consists of multiple shape painters.
This class represents a computed property value.
This class implements the interface expected from a component
transfer function.
This interface lets
GraphicsNode create instances of
GraphicsNodeRable appropriate for the filter module
implementation.This class provides a factory for renderers.
Factory instance that returns TextSpanLayouts appropriate to
AttributedCharacterIterator instances.
Renders the attributed character iterator of a
TextNode.A simple implementation of GraphicsNodeMouseListener for text selection.
A class to manage all XBL content elements in a shadow tree.
An event to signify a change to the list of selected nodes for an
xbl;content element.
The interface for listening to changes in selected nodes on an
xbl:content element.
Convolves an image with a convolution matrix.
Convolves an image with a convolution matrix.
This class provides an implementation of the
CombinatorCondition interface.This class provides an implementation of the
AttributeCondition interface.This class provides an implementation of the
AttributeCondition interface.This class provides an implementation of the
DescendantSelector interface.This class provides an implementation of the
AttributeCondition interface.This class provides an implementation of the
ConditionalSelector interface.This class provides an implementation of the
ConditionFactory interface.This interface defines constants for CSS.
This interface allows the user of a CSSEngine to provide contextual
informations.
This class provides an implementation for the
DescendantSelector interface.This class provides an implementation for the
DescendantSelector interface.This class implements the
ElementSelector interface.This is the base class for all the CSS engines.
Provides an (empty) adapter for the DocumentHandler interface.
Interface for people interesting in having 'primary' properties
set.
This class represents a CSS event fired by a CSSEngine.
This class must be implemented in order to be notified of CSS events.
One line Class Desc
Complete Class Desc
This class represents a <font-face> element or @font-face rule
This class provides an implementation of the
AttributeCondition interface.This class provides an implementation of the
LangCondition interface.This class implements the
LexicalUnit interface.This class represents a dimension unit.
This class represents a float unit.
This class represents a function unit.
This class represents an integer unit.
This class represents a function unit.
This class represents a simple unit.
This class represents a string unit.
This class represents a panel to edit/add/remove CSS media.
A dialog to add a new CSS medium.
A dialog to edit/add/remove CSS media.
An interface for documents that have CSSNavigableNodes.
An interface for listeners of CSSNavigableDocument events.
An interface for DOM classes that can be navigated for CSS selector
matching and cascade computation.
This class represents the computed style of an element.
A class for SVG style declarations that store their properties in a
StyleDeclaration.This class represents a style declaration.
To manage the modifications on a CSS value.
To provides the values.
This class implements the
SVGColor interface.To manage the modifications on a CSS value.
To provide the actual value.
This class represents the computed style of an SVG element.
This class implements the
SVGPaint interface.To manage the modifications on a SVGPaint value.
This class represents a SVG style declaration.
This class represents an object which provides the computed styles
of the elements of a SVG document.
This class provides an abstract implementation of a ModificationHandler.
To manage the modifications on a CSS value.
To provides the actual value.
This class represents an object which provides the computed styles
of the elements of a document.
This class provides an implementation of the
AttributeCondition interface.This class provides an implementation of the
AttributeCondition interface.This class implements the
ElementSelector interface.This class implements the
SACMediaList interface.This class implements the
SelectorFactory interface.This class implements the
SelectorList interface.This interface must be implemented by the DOM elements which needs
CSS support.
This interface represents CSSStyleDeclaration factories.
This interface must be implemented by the DOM nodes which represent
CSS style-sheets.
A collection of utility method involving CSS property.
A class representing a cubic path segment.
The CursorManager class is a helper class which preloads the cursors
corresponding to the SVG built in cursors.
This class provides a manager for the 'cursor' property values.
The CustomEvent interface is the recommended interface for
application-specific event types.
This class provides an implementation of the
CombinatorCondition interface.This class provides an adapter for AngleHandler
This class provides an implementation of the
AttributeCondition interface.This class provides an implementation of the
AttributeCondition interface.This class is a default implementation of the GenericImageHandler
for handlers implementing a caching strategy.
This class provides an implementation of the
DescendantSelector interface.This class provides an implementation of the
AttributeCondition interface.This class provides an implementation of the
ConditionalSelector interface.This class provides an implementation of the
ConditionFactory interface.A class to handle content selection when the includes attribute is not
present.
This class provides an implementation for the
DescendantSelector interface.This class provides an implementation for the
DescendantSelector interface.This class provides a default implementation of the SAC DocumentHandler.
This class implements the
ElementSelector interface.This class provides a default implementation of the
ErrorHandler interface.This class provides a default implementation of ErrorHandler.
The
ErrorHandler interface allows you to specialize
how the error will be set on an SVG Element.A default
ErrorHandler that throws a
TranscoderException when a fatal error occured and display
a message when a warning or an error occured.This implementation of the ExtensionHandler interface always
returns null Nodes.
Default implementation for the
ExternalResourceSecurity interface.The is a utility class that is used for resolving UnresolvedFontFamilies.
This class provides an adapter for FragmentIdentifierHandler.
This concrete implementation of
AbstractGraphics2D is a
simple help to programmers to get started with their own
implementation of Graphics2D.This class provides an implementation of the
AttributeCondition interface.This class provides a default implementation of the ImageHandler
interface simply puts a place holder in the xlink:href
attribute and sets the width and height of the element.
This class provides an implementation of the
LangCondition interface.This class provides an adapter for LengthHandler
This class provides an adapter for LengthListHandler
This class provides an implementation of the
AttributeCondition interface.The class provides an adapter for PathHandler.
This class provides an adapter for PointsHandler.
This class provides an adapter for PreserveAspectRatioHandler.
This class provides an implementation of the
AttributeCondition interface.This class implements the
ElementSelector interface.Default implementation for the
ScriptSecurity interface.This class implements the
SelectorFactory interface.The
DefaultStyleHandler class provides the default
way to style an SVG Element.Default controller for the
SVGConverter operation.An adapter class for
TimingSpecifierHandler.An adapter class for
TimingSpecifierListHandler.This class provides an adapter for TransformListHandler.
A full featured sXBL manager.
Record class for storing information about an XBL definition.
DOM node removed listener for imported XBL trees.
This class allows for the return of a proxy object quickly, while a
heavy weight object is constrcuted in a background Thread.
Describes the type of destination for an
SVGConverter
operation.This class represents an device-specific color value.
This filter primitive lights an image using the alpha channel as a bump map.
Implementation of the DiffuseLightRable interface.
This class provides a manager for the 'direction' property values.
This class defines the Discrete type transfer function for the
feComponentTransfer filter, as defined in chapter 15, section 11
of the SVG specification.
Implements a DisplacementMap operation, which takes pixel values from
another image to spatially displace the input image
Implements a DisplacementMap operation, which takes pixel values from
another image to spatially displace the input image
This implementation of RenderableImage will render its input
GraphicsNode on demand for tiles.
This class provides a manager for the 'display' property values.
A light source placed at the infinity, such that the light angle is
constant over the whole surface.
Interface for bridge classes that operate on Document nodes.
This class contains informations about a document.
This class implements the behavior of DocumentEvent.
To create a Custom event.
This interface represents an event factory.
To create a keyboard event.
To create a key event.
To create a mouse event.
To create a mutation event.
To create a mutation name event.
To create a simple event.
To create a Text event.
To create a UI event.
This interface represents an object which can build a Document.
This
ClassLoader implementation only grants permission to
connect back to the server from where the document referencing the
jar file was loaded.This class is responsible on loading an SVG document and
maintaining a cache.
String constants used by the DOM classes.
A custom event object.
A swing tree to represent DOM Document.
The adapter for the DOMDocumentTreeListener.
Event to pass to listener.
The DOMDocumentTreeListener.
Contains the info for the 'dropCompleted' Event.
Transferable tree node.
The data being transfered on dnd.
Provides the information to control the DOMDocumentTree behaviour.
A simple event.
This is a Service interface for classes that want to extend the
functionality of the AbstractDocument, to support new tags in the
DOM tree.
This class is used by the Graphics2D SVG Generator to manage
a group of Nodes that can later be added to the SVG DOM Tree
managed by the DOMTreeManager.
A transcoding Key represented as a DOMImplementation.
This class provides a manager for the 'alignment-baseline' property values.
DOM 3 Keyboard event class.
The
KeyEvent interface provides specific contextual
information associated with Key events.The MouseEvent class provides specific contextual information
associated with Mouse events.
The MutationEvent class provides specific contextual information
associated with Mutation events.
Class to implement DOM 3 MutationName events.
This class implements the
NodeIterator
interface.Class to implement DOM 3 Text events.
An event class for SMIL timing events.
This class is used by the SVGGraphics2D SVG Generator to manage
addition of new Nodes to the SVG DOM Tree.
This class implements the
NodeIterator
interface.The UIEvent class provides specific contextual information
associated with User Interface events.
A collection of utility functions for the DOM.
The components of this class are used to view a DOM tree.
To store the node information for an xbl:content node's
selected content.
To store the nodes informations
To store the node information for a shadow tree.
Provides the information needed for the DOMViewer to show and edit the
document.
Helper class.
A set that uses two keys.
This class represents a doubly indexed hash table.
An entry in the
DoublyIndexedTable.A simple Doubly Linked list class, designed to avoid
O(n) behaviour on insert and delete.
Basic doubly linked list node interface.
The drop down menu component.
Default implementation of the scrollable popup menu item.
The Scrollable Popup Menu Component.
The adapter for the ScrollablePopupMenuListener.
Event to pass to listener.
The scrollable pop up menu item.
The ScrollablePopupMenu listener.
The scrollable popup menu model.
The history scrollable popup menu model.
The redo pop up menu model.
The undo pop up menu model.
This class is responsible for creating a GVT tree using an SVG DOM tree.
Simple implementation of the Renderer that supports dynamic updates.
Provides the information to control the ElementOverlay.
Manages element overlay on the canvas.
This implementation of the
ExternalResourceSecurity interface only
allows external resources embeded in the document, i.e., externalResources
embeded with the data protocol.This implementation of the
ScriptSecurity interface only
allows scripts embeded in the document, i.e., scripts whith either
the same URL as the document (as for event attributes) or scripts
embeded with the data protocol.This class provides a manager for the 'enable-background' property values.
This class contains utility functions to manage encodings.
The error code.
The built in error codes.
This interface must be implemented and then registred as the error handler
in order to be notified of parsing errors.
The
ErrorHandler interface allows you to specialize
how the error will be set on an SVG Element.This interface provides a way to catch errors and warnings from a
Transcoder.
A class to handle eventbase SMIL timing specifiers.
Interface for receiving and dispatching events down to a GVT tree.
Generic class to dispatch events in a highly reliable way.
Abstract class from which all event-like timing specifier classes derive.
Class to manager event listeners for one event type.
EventListenerTable entry class.
The class allows registration and removal of EventListeners on
an NodeEventTarget and dispatch of events to that NodeEventTarget.
This interface provides additional features to the
Condition interface.The
ExtendedGeneralPath class represents a geometric
path constructed from straight lines, quadratic and cubic (Bezier)
curves and elliptical arc.This class extends the java.awt.GridBagConstraints in order to
provide some utility methods.
This interface provides much more control over internationalization
than the Localizable interface.
This interface provides an access to the non DOM methods implemented by
all the nodes in this implementation.
This class implements the
Parser interface plus a
set of custom methods.This class implements the
ExtendedParser
interface by wrapping a standard Parser.The
ExtendedPathIterator class represents a geometric
path constructed from straight lines, quadratic and cubic (Bezier)
curves and elliptical arcs.This interface extends the
Selector.The
ExtendedShape class represents a geometric
path constructed from straight lines, quadratic and cubic (Bezier)
curves and elliptical arcs.Interface for SVG DOM classes to expose information about the traits
(XML attributes and CSS properties) their elements support.
This class implements the
DOMImplementation interface.This interface represents a factory for elements.
This class implements the basic features an element must have in order
to be usable as a foreign element within an SVGOMDocument.
The ExtensionHandler interface allows the user to handle
Java 2D API extensions that map to SVG concepts (such as custom
Paints, Composites or BufferedImageOp filters).
An interface that allows UserAgents to describe the security
constraints desired for external resources.
Definition of Feature tags
A subclass of
SeekableStream that may be used to wrap
a regular InputStream.This class provides a manager for the 'fill-rule' property values.
A shape painter that can be used to fill a shape.
This is an extension of RenderableImage that adds some needed
functionality for tracking dirty regions and determining image
dependancies.
FilterAlphaRable implementation.
This strips out the source alpha channel into a one band image.
FilterAsAlphaRable implementation.
This converts any source into a mask according to the SVG masking rules.
Bridge class for vending
Filter objects.Implements a filter operation.
Implements a filter chain.
This is an extension of our Filter interface that adds support for
a color-interpolation specification which indicates what colorspace the
operation should take place in.
This class provides a factory for the 'filter' property values.
Factory class for vending
Filter objects that represents
a filter primitive.Interface for implementing filter resolution.
Interface for implementing filter resolution.
This class represents a Dialog that lets the user searching for text inside
an SVG document.
A handler class that generates an array of floats from parsing a
number list or a point list.
A transcoding Key represented as a float.
This class represents float values.
Fills the input image with a given paint
Concrete implementation of the FloodRable interface.
This implementation of RenderedImage will generate an infinate
field of a single color.
This class implements a regular polygon extension to SVG
A GlyphLayout class for SVG 1.2 flowing text.
Factory instance that returns TextSpanLayouts appropriate to
FlowRoot instances.
One line Class Desc
Complete Class Desc
One line Class Desc
Complete Class Desc
One line Class Desc
Complete Class Desc
This class implements a regular polygon extension to SVG
This class implements a regular polygon extension to SVG
This class implements a regular polygon extension to SVG
This class implements a regular polygon extension to SVG
A class to hold flow region information for a given shape.
This class implements a regular polygon extension to SVG
This class implements a regular polygon extension to SVG
Factory instance that returns TextSpanLayouts appropriate to
FlowRoot instances.
One line Class Desc
Complete Class Desc
One line Class Desc
Complete Class Desc
A class that manages focus on elements.
The TrueType font.
This class represents a <font-face> element or @font-face rule
This class represents a @font-face CSS rule.
This class provides a factory for the 'font-family' property values.
This class provides support for the CSS2 'font' shorthand property.
This class provides a manager for the 'font-size-adjust' property values.
This class provides a manager for the 'font-size' property values.
This class provides a manager for the 'font-stretch' property values.
This class provides a manager for the 'font-style' property values.
This class provides a manager for the 'font-variant' property values.
This class provides a manager for the 'font-weight' property values.
This allows you to specify the ColorModel, Alpha premult and/or
SampleModel to be used for output.
A subclass of
SeekableStream that may be used
to wrap a regular InputStream efficiently.This interface must be implemented and then registred as the
handler of a
PreserveAspectRatioParser instance
in order to be notified of parsing events.This class represents an event-based parser for the SVG
fragment identifiers.
GammaTransfer.java
This class defines the Gamma type transfer function for the
feComponentTransfer filter, as defined in chapter 15, section 11 of the SVG
specification.
Implements a GaussianBlur operation, where the blur size is
defined by standard deviations along the x and y axis.
GaussianBlurRable implementation
This implementation of RenderableImage will render its input
GraphicsNode on demand for tiles.
Represents GDI Objects encountred in WMF Files.
This class implements the
Attr interface.This class implements the
Attr interface with
support for namespaces.A tagging interface that bridges for elements child of
GraphicsNodeBridge
should implement.This class implements the
CDATASection interface.This class implements the
Comment interface.This class delegates to a reader the decoding of an input stream.
This class implements the
Document,
DocumentEvent.This class implements
DocumentFragment interface.This class implements the
DocumentType interface.This class implements the
DOMImplementation.This class implements the
Element interface.This class implements the
Element interface.This class implements the
Entity interface.This class implements the
EntityReference interface.Extends the default ImageHandler interface with calls to
allow caching of raster images in generated SVG content.
This class implements the
Notation interface.This class implements the
ProcessingInstruction interface.This class provides a generic implementation of the
Text
interface.An XBL manager that performs no XBL processing.
Interface for a global scripting object.
Wrapper class for the SVGGlobal object.
Glyph description for composite glyphs.
A Glyph describes a graphics node with some specific glyph rendering
attributes.
An individual glyph within a font.
Specifies access to glyph description classes, simple and composite.
One line Class Desc
Complete Class Desc
Implementation of TextSpanLayout which uses java.awt.font.GlyphVector.
This class provides a manager for the 'glyph-orientation-horizontal'
property values.
This class provides a manager for the 'glyph-orientation' property values.
This class provides a manager for the 'glyph-orientation-vertical'
property values.
Handles the attributes in a graphic context:
+ Composite
+ Font
+ Paint
+ Stroke
+ Clip
+ RenderingHints
+ AffineTransform
+ Composite
+ Font
+ Paint
+ Stroke
+ Clip
+ RenderingHints
+ AffineTransform
An abstract base class for graphical extension elements.
The base class for all graphics nodes.
Bridge class for creating, building, and updating a
GraphicsNode
according to an Element.An abstract adapter class for receiving graphics node change
events.
An event which indicates that a change action occurred on a graphics node.
The interface for listening to changes on graphics nodes.
A low-level event for GraphicsNode.
A low-level event which indicates that a graphics node has gained or
lost the keyboard focus.
The listener interface for receiving keyboard focus events on a
graphics node.
The root event class for all graphics node-level input events.
An abstract adapter class for receiving graphics node key
events.
An event which indicates that a keystroke occurred in a graphics node.
The listener interface for receiving graphics node key events.
An abstract adapter class for receiving graphics node mouse
events.
An event which indicates that a mouse action occurred in a graphics node.
The listener interface for receiving graphics node mouse events.
An event which indicates that a mouse whwel action occurred in a graphics
node.
The listener interface for receiving graphics node mouse wheel events.
This interface allows
GraphicsNode to be seen as
RenderableImages, which can be used for operations such as
filtering, masking or compositing.This implementation of RenderableImage will render its input
GraphicsNode into a BufferedImage upon invokation of one of its
createRendering methods.
This interface lets
GraphicsNode create instances of
GraphicsNodeRable appropriate for the filter module
implementation.This implementation of RenderableImage will render its input
GraphicsNode on demand for tiles.
Set of utility methods for Graphics.
GridBagConstraints constants.GVTACIImpl
Used to implement SVG <tspan> and <text>
attributes.
AttributeFilter which converts (extended) location attributes
SVGAttributedCharacterIterator.TextAttribute.X, TextAttribute.Y,
TextAttribute.ROTATE attributes to TextAttribute.TRANSFORM attributes.
GVTAttributedCharacterIterator
Used to implement SVG <tspan> and <text>
attributes.
Interface for helper class which mutates the attributes of an
AttributedCharacterIterator.
Attribute keys that identify SVG text attributes.
This class is responsible for creating a GVT tree using an SVG DOM tree.
An interface for all GVT font classes.
One line Class Desc
Complete Class Desc
An interface for all font family classes.
GVTGlyphMetrics is essentially a wrapper class for java.awt.font.GlyphMetrics
with the addition of horizontal and vertical advance values.
An interface for all GVT GlyphVector classes.
GVTLineMetrics is a GVT version of java.awt.font.LineMetrics.
This class represents an object which builds asynchroneaously
a GVT tree.
An adapter class that represents a listener to the GVTTreeBuilderEvent
events.
This class represents an event which indicate an event originated
from a GVTTreeBuilder instance.
This interface represents a listener to the GVTTreeBuilderEvent events.
This class represents an object which renders asynchronously
a GVT tree.
An adapter class that represents a listener to the
GVTTreeRendererEvent events.This class represents an event which indicate an event originated
from a GVTTreeRenderer instance.
This interface represents a listener to the GVTTreeRendererEvent events.
GVTTreeWalker objects are used to navigate a GVT tree or subtree.This is a subclass of java.lang.Thread that includes a non-intrusive
'halt' method.
This class represents a stack of HashTable objects.
To store the hashtables.
History browser.
Wrapps the command's execute, undo and redo methods.
Contains the info on the command name being executed, undone or redone and
last undoable and redoable command names.
Lets the DOMViewerController wrap the commands.
The adapter to provide the default behavior.
Event to pass to listener.
The HistoryBrowserListener.
The wrapper for the history browser.
The AppendChild command.
Adds the attribute to an element (MutationEvent.ADDITION)
Modifies the attribute of an element (MutationEvent.MODIFICATION)
Removes the attribute of an element (MutationEvent.REMOVAL)
The Change Node Value command.
Sets the node value.
The compound command.
Inserts the given node as a child to the given parent node before the
specified sibling node, or as the last child of the given parent, if the
sibling node is null.
Inserts the given node as a child of another.
Removes the node from its parent node.
The RemoveChild command.
insertBefore
This class represents an ICC color value.
Deprecated.
use the version from XML Graphics Commons instead
This class represents an ICC named color value.
An interface for DOM nodes that can look up elements with IDs.
This class provides a manager for the property with support for
identifier values.
IdentityTransfer.java
This class defines the Identity type transfer function for the
feComponentTransfer filter, as defined in chapter 15, section 11 of the SVG
specification.
This class implements caching functionality for raster images.
Cache implementation for images embedded in the SVG file.
Cache implementation for file-based 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.
A partial implementation of the ImageEncoder interface useful for
subclassing.
This interface allows the user of the Graphics2D SVG generator
to decide how to handle images that it renders.
This implementation of ImageHandler encodes the input image as
a PNG image first, then encodes the PNG image using Base64
encoding and uses the result to encoder the image url using
the data protocol.
This implementation of the abstract AbstractImageHandlerEncoder
class creates JPEG images in the image directory and sets the
url pointing to that file in the xlink:href attributes of the
image elements it handles.
This implementation of the abstract AbstractImageHandlerEncoder
class creates PNG images in the image directory and sets the
url pointing to that file in the xlink:href attributes of the
image elements it handles.
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.
RegistryEntry implementation for loading JPEG images through Image I/O.
ImageWriter that encodes PNG images using Image I/O.
RegistryEntry implementation for loading PNG images through Image I/O.
ImageWriter that encodes TIFF images using Image I/O.
RegistryEntry implementation for loading TIFF images through Image I/O.
A graphics node that represents an image described as a graphics node.
Interface for GVT Renderers that render into raster images.
Interface for a factory of ImageRenderers
This class provides a manager for the 'image-rendering' property values.
This class handles the registered Image tag handlers.
This class enables to transcode an input to an image of any format.
Interface which allows image library independent image writing.
Parameters for the encoder which is accessed through the
ImageWriter interface.
This class represents a list of Java classes/packages to import
into a scripting environment.
This class represents a @import CSS rule.
A class to handle the 'indefinite' SMIL timing specifier.
This class implements an adaptive palette generator to reduce images to a
specified number of colors.
This singleton class represents the 'inherit' value.
A class that represents an instance time created from a timing
specification.
A transcoding Key represented as an int.
This interface represents an object which interacts with a GVT component.
This class represents an interactor which never interacts.
An abstract animation class for those animations that interpolate
values.
A high level interface that represents an interpreter engine for
a particular scripting language.
An exception that will be thrown when a problem is encountered in the
script by an
Interpreter interface implementation.An interface for factory objects than can create
Interpreter
instances for a particular script language.A class allowing to create/query an
Interpreter corresponding to a particular
Document and scripting language.This class represents the exception thrown by the bridge when the
current thread was interrupted.
A class that represents an interval for a timed element.
A simple hashtable, not synchronized, with fixed load factor,
that maps objects to ints.
To manage collisions.
This class represents an object which decodes ISO-8859-1 characters from
a stream of bytes.
The
JAffineTransformChooser is a pane that contains
controls to let a user select the various components that
make up an AffineTransformThis class is resposible for providing authentication information
when needed by network protocols.
This interface must be implemented by actions which need
to have an access to their associated component(s)
This Image tag registy entry is setup to wrap the core JDK
Image stream tools.
This class represents a dialog to display an error (message + Exception).
An implementation of JPanel that uses the GridBagLayout.
Provides insets desired for a given grid cell
This class represents a component which can display a GVT tree.
An adapter class for
JGVTComponentListener.An interface for listeners of
JGVTComponent events.This class represents a panel to control jpeg encoding quality.
This class is an
ImageTranscoder that produces a JPEG image.This class represents a general-purpose swing SVG component.
Helper class.
A
BeanInfo for the JSVGCanvas.This class represents a swing component that can display SVG documents.
The user-agent wrapper, which call the methods in the event thread.
A Swing component that consists of a JSVGCanvas with optional scroll
bars.
This class represents a SVG viewer swing frame.
Rhino debugger class.
A FileFilter used when exporting the SVG document as an image.
This class represents the buttons used in toolbars.
This class represents a separator for the toolbar buttons.
This class represents the buttons used in toolbars.
The Kern class describes an entry in the "kerning table".
This class provides a manager for the 'kerning' property values.
The KerningTable class holds a kerning table (a collection of Kern
elements).
The
KeyboardEvent interface provides specific contextual
information associated with keyboard devices.This class represents a language selection dialog.
The language selection panel.
A handler class that generates an array of shorts and an array floats from
parsing a length list.
This interface must be implemented and then registred as the
handler of a
LengthParser instance in order to be
notified of parsing events.A transcoding Key represented as a length.
This interface must be implemented and then registred as the
handler of a
LengthListParser instance in order to be
notified of parsing events.This class implements an event-based parser for the SVG length
list values.
This class provides a manager for the property with support for
length values.
This class implements an event-based parser for semicolon separated
length pair lists, as used in the 'values' attribute of the 'animateMotion'
element.
This class implements an event-based parser for the SVG length
values.
This interface defines the constants that represent CSS lexical units.
This interface defines the constants that represent XML lexical units.
Top level interface to model a light element.
A class representing a linear path segment.
The
LinearGradientPaint class provides a way to fill
a Shape with a linear color gradient pattern.LinearTransfer.java
This class defines the Linear type transfer function for the
feComponentTransfer filter, as defined in chapter 15, section 11 of the SVG
specification.
This class provides a factory for the 'margin-*' properties values.
This class represents line-height values.
This class encapsulates the layout information about a single line
in a multi-line flow.
One line Class Desc
Complete Class Desc
This class represents an event which indicate an event originated
from a GVTTreeBuilder instance.
This interface represents a listener to the LinkActivationEvent events.
A class for receiving notification of parsed list items.
Interface that defines the functionnality
of a list handler for the parser of
attributes that are list.
A simple class that implements the DOM NodeList interface by
wrapping an Java List instace.
This class represents a list of values.
Thrown when a live attribute cannot parse an attribute's value.
This interface should be implemented by all the attribute values
objects that must be updated when the attribute node is modified.
This class represents a group of ExtendedLocalizable objects which
have a shared default locale.
This class represents an history of the files visited by a single
browser frame.
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.
This class implements the org.apache.batik.w3c.dom.Location interface for Batik
This class represents a location bar.
Interface for nodes in the LRU cache, basicly nodes in a doubly
linked list.
Interface for object participating in the LRU Cache.
Simple implementation of the Renderer that supports dynamic updates.
This Image tag registry entry is built around the notion of magic
numbers.
Inner class that represents one magic number.
Handles command line parameters to configure the
SVGConverter
and rasterizer images.This class contains the main method of an SVG viewer.
This class is the main class of the svgpp application.
This test runs the True Type Font to SVG Font converter, the
tool that allows some characters from a font to be converted
to the SVG Font format.
This abstract implementation of the
OptionHandler interface
throws an exception if the number of arguments passed to the
handleOption method does not match the number of expected
optionValues.Base class for options which expect a
Color optionValue.Base class for options which expect the single optionValue to
be a float.
Base class for options with no option value (i.e., the presence
of the option means something in itself.
Interface for handling one command line option
This interface represents an option handler.
This interface represents an option handler.
Base class for options which expect a
Rectangle optionValue.Base class for options with a single option value.
Base class for options which expect the single optionValue to
be a time value.
This class provides a factory for the 'margin-*' properties values.
This class represents an object which provide support for the
'margin' shorthand property.
Marker interface, mostly, that encapsulates information about a
selection gesture.
A Marker describes a GraphicsNode with a reference point that can be used to
position the Marker at a particular location and a particular policy for
rotating the marker when drawing it.
Factory class for vending
Marker objects.This class provides a manager for the 'marker-*' property values.
A shape painter that can be used to paint markers on a shape.
This class represents an object which provide support for the
'marker' shorthand properties.
Implements a masking operation.
Describes a mask.
Factory class for vending
Mask objects.This class provides a manager for the 'mask' property values.
MaskRable implementation
A class to handle media marker SMIL timing specifiers.
This class represents a @media CSS rule.
A subclass of
SeekableStream that may be used to wrap
a regular InputStream.This class contains a collection of components that can be used to
track and display the memory usage.
The action associated with the 'Collect' button of the memory monitor.
Displays the memory usage history in a chart.
This interface allows the RepaintThread to notify an object that the
current memory state has changed.
A panel composed of a Usage instance and a History instance.
This thread repaints a list of components.
Displays the current memory usage.
This class represents a menu factory which builds
menubars and menus from the content of a resource file.
This class manages the message for the bridge module.
This class manages the message for the bridge module.
This class manages the message for the css.engine module.
This class manages the message for the css.engine.value module.
This class manages the message for the Swing extensions.
This class manages the message for the Rhino interpreter
This class manages the message for the bridge module.
This class manages the message for the test.svg module.
This class manages the message for the css.engine module.
This class manages the message for the image transcoder module.
This class manages the message for the IO utilities classes.
This class manages the message for the security utilities
This class manages the message for the utilities classes.
This is used to keep data while processing WMF-files.
A record that contain byte arrays elements.
This interface defines constants for Various Mime Types
Signals a missing listener
This class provides an implementation for the SVG
feMorphology filter, as defined in Chapter 15, section 20
of the SVG specification.
Implements a Morphology operation, where the kernel size is
defined by radius along the x and y axis.
Implements a Morphology operation, where the kernel size is
defined by radius along the x and y axis.
An animation class for 'animateMotion' animations.
This is the superclass for Paints which use a multiple color
gradient to fill in their raster.
Inner class to allow for typesafe enumerated ColorSpace values.
Inner class to allow for typesafe enumerated CycleMethod values.
This implements a masking operation by multiply the alpha channel of
one image by a luminance image (the mask).
RasterRable This is used to wrap a Rendered Image back into the
RenderableImage world.
The
MutationNameEvent interface provides specific contextual
information associated with Mutation name event types.This class manages a cache of soft references to named profiles that
we have already loaded.
A Node that uses an EventSupport for its event registration and
dispatch.
Provides the information to control the NodePickerPanel behaviour.
Used to preview and edit nodes.
The attributesTable model.
Dialog for choosing element name.
The adapter for the NodePicker listener.
Event to pass to listener.
Node picker listener.
The panel to view and edit the elements xml representation.
Provides basic xml representation and description for most commonly used
nodes.
Wrapper for a node template.
Interface implemented by all nodes that support XBL.
This implementation does not allow any external resources to be
referenced from an SVG document.
This implementation for the
ScriptSecurity interface
does not allow scripts to be loaded.A tagging interface to prevent a repaint at the end of the
execution of this runnable.
This class represents a reader which normalizes the line break: \n,
\r, \r\n are replaced by \n.
An handler interface for parsing NumberLists.
This class implements an event-based parser for the SVG Number
list values.
This class represents a parser with support for numbers.
Adjusts the input images coordinate system by dx, dy.
A class to handle offset SMIL timing specifiers.
This class provides a manager for the '*-opacity' property values.
This class represents a panel to present users with options.
This class is modal dialog to choose the jpeg encoding quality.
Interface implemented by Event objects usable in an XBL processing
document.
This class is responsible of the output of XML constructs.
To store the informations about an attribute.
To store the informations about a name.
This class provides a manager for the 'overflow' property values.
This interface represents an object painted over the GVT rendering
in a JGVTComponent.
This is a typesafe enumeration of the standard Composite rules for
the CompositeRable operation.
Pads image to the given Rectangle (the rect may be smaller than the
image in which case this is actually a crop).
Concrete implementation of the PadRable interface.
This is an implementation of a Pad operation as a RenderedImage.
Bridge class for vending
Paint objects.A transcoding Key represented as a background paint.
Interface for Rable's that can more efficently represent there
action as a paint method instead of a RenderedImage when going to a
Graphics2D anyways.
A collection of utility methods to deliver
java.awt.Paint,
java.awt.Stroke objects that could be used to paint a
shape.A
URL-like class that supports custom URI schemes
and GZIP encoding.Holds the data for more URLs.
Protocol Handler for the 'data' protocol.
The default protocol handler this handles the most common
protocols, such as 'file' 'http' 'ftp'.
Protocol Handler for the 'jar' protocol.
Provider interface for new url protocols, used by the ParsedURL class.
This class encapsulates a general parse error or warning.
This class encapsulates a general parse error or warning.
This class implements the
Parser interface.This interface represents a parser.
A handler class that generates an array of shorts and an array floats from
parsing path data.
This interface must be implemented and then registred as the
handler of a
PathParser instance in order to be
notified of parsing events.Utilitiy class for length calculations of paths.
A single path segment in the flattened version of the path.
A
PathIterator that returns only the next path segment from
another PathIterator.This class implements an event-based parser for the SVG path's d
attribute values.
The PatternPaint class provides a way to fill a Shape with a a pattern
defined as a GVT Tree.
PaintContext for the ConcretePatterPaint
paint implementation.Platform specific functionality.
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 Batik's PNG codec to
write PNG files.
This class represents a panel to choose the color model
of the PNG, i.e.
A class representing the fields of a PNG suggested palette entry.
This class is an
ImageTranscoder that produces a PNG image.This interface is used by
PNGTranscoder to write PNG images
through different codecs.This class is a helper to
PNGTranscoder that writes PNG images
through the Image I/O API.This class is a helper to
PNGTranscoder that writes PNG images
through the internal PNG codec.This class provides a manager for the 'pointer-events' property values.
A light source which emits a light of constant intensity in all directions.
This interface must be implemented and then registred as the
handler of a
PointsParser instance in order to be
notified of parsing events.This class implements an event-based parser for the SVG points
attribute values (used with polyline and polygon elements).
This class is a Polygon with float coordinates.
This class has the same behavior than
Polygon2D, except that
the figure is not closed.Dialog that displays user preferences.
This class allows to manage users preferences.
This class implements a simple method for handling the node 'prefix'.
This interface must be implemented and then registred as the
handler of a
PreserveAspectRatioParser instance in order to
be notified of parsing events.This class implements an event-based parser for the SVG preserveAspectRatio
attribute values.
This class represents an SVG source files pretty-printer.
This class is a
Transcoder that prints SVG images.Implements the interface expected from a color matrix
operation
This implementation of rendered image forces a color profile
on its source
A graphics node which provides a placeholder for another graphics node.
A class representing a quadratic path segment.
This class provides a way to fill a shape with a circular radial color
gradient pattern.
Coverage Index (GlyphID) = StartCoverageIndex + GlyphID - Start GlyphID
A graphics node that represents a raster image.
Deprecated.
jan '07 : this class is not used anywhere in Batik, it might be removed in the future.
A transcoding Key represented as a rectangle.
RectListManager is a class to manage a list of rectangular regions.
This class provides a manager for the property with support for
rect values.
This class represents CSS rect values.
RasterRable This is used to wrap a Rendered Image back into the
RenderableImage world.
This class holds the neccessary information to render a
<batik:flowRegion> that is defined within the <batik:flowRoot>
element.
This class holds the neccessary information to render a
<batik:flowRegion> that is defined within the <batik:flowRoot>
element.
The base interface for all image tag registry entries.
This implementation of
ExternalResourceSecurity allows any
external references.This implementation for the
ScriptSecurity interface.This implements CachableRed around a RenderedImage.
Interface for GVT Renderers.
Interface for GVT renderer factory.
Contains additional RenderingHints Keys, such as
KEY_AREA_OF_INTEREST
This class manages the rendering of a GVT tree.
A class to handle repeat event SMIL timing specifiers.
Signals a format error in a resource bundle
This class offers convenience methods to decode
resource bundle entries
This interface defines constants for the possible resource
origins.
This class manages the message for the Swing extensions.
This class manages the message for the Swing extensions.
This class represents RGB colors.
This class loader implementation will work whether or not the
documentURL is null.
Class shutter that restricts access to Batik internals from script.
A simple implementation of
Interpreter interface to use
Rhino ECMAScript interpreter.To build an argument list.
Class to store cached compiled scripts.
Allows to create instances of
RhinoInterpreter class.The top-level graphics node of the GVT tree.
This interface represents a CSS rule.
This class represents an object which queues Runnable objects for
invocation in a single thread.
A
Runnable that can also inform the caller how long it should
be until it is run again.To store a Runnable.
To store a Runnable with an object waiting for him to be executed.
This interface must be implemented by an object which wants to
be notified of run events.
This is an adapter class that implements the RunHandler interface.
Type-safe enumeration of queue states.
This class contains methods for creating Document instances
from an URI using SAX2.
Wrapper for SAX Exceptions which would make it possible to
include line and column information with SAX parse errors.
This class contains methods for creating SVGDocument instances
from an URI using SAX2.
This class represents a CSS scanner - an object which decodes CSS lexical
units.
A collection of utility functions for a CSS scanner.
Interface for objects that act as a Java wrapper for a javascript
event object.
This interface must be implemented in order to call Java code from
an SVG document.
This class contains the informations needed by the SVG scripting.
An interface that allows UserAgents to describe the security
constraints desired for scripting.
Definition of Script tags
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.An interface that path segments must implement.
A class representing a list of path segments.
read-only helper class to represent a split-result.
Interface describing object that can be selected or have selections
made on it.
Adapter for the listener interface for receiving selection events.
An event which indicates that a selection is being made or has been made.
The listener interface for receiving selection events.
Interface which allows selection of GraphicsNodes and their contents.
This class handles looking up service providers on the class path.
An animation class for 'set' animations.
Interface for shadow tree related events.
This class wraps a normal path into an extended path.
A graphics node that represents a shape.
Renders the shape of a
ShapeNode.This interface represents objects which creates Shape objects.
This class provides a manager for the 'shape-rendering' property values.
This interface represents the objects which provide support for
shorthand properties.
To handle a property value created by a ShorthandManager.
An animation class for 'animate' animations.
Implements the
GenericImageHandler interface and only
uses <image> elements.A simple class implemented the
RenderedImage
interface.A simple class that provides RenderedImage functionality
given a Raster and a ColorModel.
Constants for SMIL animation element and attribute names and values.
This class represents a doubly indexed hash table, which holds
soft references to the contained values.
This class manages a cache of soft references to objects that may
take some time to load or create, such as images loaded from the
network.
This class provides a manager for the '*-spacing' property values.
This filter follows the specification of the feSpecularLighting filter in
the SVG 1.0 specification.
Implementation of the SpecularLightRable interface.
A light source which emits a light of constant intensity in all directions.
This is the interface expected from classes which can handle specific
types of input for the Squiggle SVG browser.
This class filters file for a given
SquiggleInputHandlerOne line Class Desc
Complete Class Desc
Simple implementation of the Renderer that simply does static
rendering in an offscreen buffer image.
This class represents a viewer status bar.
This class represents a NormalizingReader which handles streams of
bytes.
To create an ASCIIDecoder.
Represents a CharDecoder factory.
To create an ISO_8859_1Decoder.
To create a UTF16Decoder.
To create a UTF8Decoder.
This type of Image tag registy entry is used for most normal image
file formats.
This class reads a string.
A simple hashtable, not synchronized, with fixed load factor.
To manage collisions
A transcoding Key represented as a string.
A simple hashtable, not synchronized, with fixed load factor and with
equality test made with '=='.
To manage collisions
This class represents a NormalizingReader which handles Strings.
This class represents string values.
This class provides a factory for the 'stroke-dasharray' property values.
This class provides a factory for the 'stroke-dashoffset' property values.
This class provides a manager for the 'stroke-linecap' property values.
This class provides a manager for the 'stroke-linejoin' property values.
This class provides a factory for the 'stroke-miterlimit' property values.
A shape painter that can be used to draw the outline of a shape.
This class provides a factory for the 'stroke-width' property values.
More sophisticated implementation of TextPainter which
renders the attributed character iterator of a
TextNode.Inner convenience class for associating a TextLayout for
sub-spans, and the ACI which iterates over that subspan.
This class implements the basic features an element must have in
order to be usable as a foreign element within an SVGOMDocument,
and the support for both the 'style' attribute and the style
attributes (ie: fill="red", ...).
This class represents a collection of CSS property values.
An interface for
CSSStyleDeclaration objects to
expose their underlying StyleDeclaration objects storing the
properties.The
StyleHandler interface allows you to specialize
how the style will be set on an SVG Element.This class represents objects which contains property/value mappings.
A style reference represents a graphics node, CSS property pair.
This class represents a style rule.
This class represents a list of rules.
This interface represents a StyleSheet factory.
This class provides an implementation of the 'xml-stylesheet' processing
instructions.
Bridge context for SVG 1.2 documents.
Wrapper for DOM event listeners so that they will see only
original events (i.e., not retargetted).
A class used to store an implementation EventListener added to the DOM.
This class is responsible for tracking GraphicsNodeMouseEvents and
forwarding them to the DOM as regular DOM MouseEvents.
A GraphicsNodeMouseListener that dispatch DOM events accordingly.
This is a Service interface for classes that want to extend the
functionality of the Bridge, to support new tags in the rendering tree.
A BridgeUpdateHandler interface for SVG 1.2 specific events.
Define SVG 1.2 constants, such as tag names, attribute names and URI
This interface defines constants for CSS with SVG12.
This class provides a CSS engine initialized for SVG.
This class implements the
DOMImplementation interface.To create a 'flowDiv' element.
To create a 'flowLine' element.
To create a 'flowPara' element.
To create a 'flowRegionBreak' element.
To create a 'flowRegion' element.
To create a 'flowRegion' element.
To create a 'flowRoot' element.
To create a 'flowSpan' element.
To create a 'handler' element.
To create a 'multiImage' element.
To create a 'solidColor' element.
To create a 'subImage' element.
To create a 'SubImageRef' element.
To create a 'xbl:content' element.
To create a 'xbl:definition' element.
To create a 'xbl:handlerGroup' element.
To create a 'xbl:import' element.
To create a 'xbl:shadowTree' element.
To create a 'xbl:template' element.
To create a 'xbl:xbl' element.
Focus manager for SVG 1.2 documents.
This class implements
SVGDocument and provides support for
SVG 1.2 specifics.A RhinoInterpreter for SVG 1.2 documents.
Manages scripting handlers for SVG 1.2 'handler' elements.
Bridge class for SVG 'text' elements with support for text content
that has been specified with XBL.
A URIResolver for SVG 1.2 documents.
This interface provides constants for SVG 1.2 values.
This class may be the base class of all transcoders which take an
SVG document as input and which need to build a DOM tree.
Bridge class for the <a> element.
To handle a click on an anchor.
To handle a mouseout on an anchor and set the cursor.
To handle a mouseover on an anchor and set the cursor.
Utility class that converts an AlphaComposite object into
a set of SVG properties and definitions.
Bridge class for the <altGlyph> element.
SVG font altGlyph handler.
Bridge class for the 'animateColor' animation element.
This class provide support for the SVGAnimatedPathData
interface.
Bridge class for the 'animate' animation element.
Bridge class for the 'animateMotion' animation element.
Bridge class for the 'animateTransform' animation element.
Context class for SVG animation elements to support extra methods.
An abstract base class for the SVG animation element bridges.
An AnimationEngine for SVG documents.
Factory class for
AnimatableBooleanValues.Factory class for
AnimatableIntegerValues.Factory class for
AnimatableLengthListValues.Factory class for
AnimatableLengthValues.Factory class for
AnimatableNumberListValues.Factory class for
AnimatableNumberOrPercentageValues.Factory class for
AnimatableNumberValues.Factory class for
AnimatablePathDataValues.Factory class for
AnimatablePointListValues.Factory class for
AnimatablePreserveAspectRatioValues.Factory class for
AnimatableNumberListValues.Idle runnable to tick the animation.
Idle runnable to tick the animation, that reads times from System.in.
Interface for AnimatableValue factories.
Factory class for
AnimatableStringValues.Context interface for elements that can be the target of animations.
Utility class that converts an Arc2D object into
a corresponding SVG element, i.e., a path with an elliptical arc
and optionally lines..
Represents an SVG attribute and provides convenience
methods to determine whether or not the attribute applies
to a given element type.
Repository of SVG attribute descriptions, accessible by
name.
Utility class that converts a Java BasicStroke object into
a set of SVG style attributes
This is a Service interface for classes that want to extend the
functionality of the Bridge, to support new tags in the rendering tree.
This interface is to be used to provide alternate ways of
generating a placeholder image when the ImageTagRegistry
fails to handle a given reference.
Utility class that converts a BufferedImageOp object into
an SVG filter.
Bridge class for the <circle> element.
Utility class that converts a Path object into an SVG clip
Describes an SVG clip
Bridge class for the <clipPath> element.
Utility class that converts a Color object into a set of
corresponding SVG attributes.
This class provides a manager for the SVGColor property values.
This class bridges an SVG
color-profile element with an
ICC_ColorSpace object.This provides an implementation of all the composite rules in SVG.
Utility class that converts a Composite object into
a set of SVG properties and definitions.
The following classes implement the various blend modes from SVG.
This implements SRC_OVER for 4 band byte data.
This implements SRC_OVER for Int packed data where the src is
premultiplied.
This implements SRC_OVER for Int packed data and dest has no Alpha...
This implements SRC_OVER for Int packed data where the src is
unpremultiplied.
This implements SRC_OVER for 4 band byte src data and
3 band byte dst data.
Used to represent an SVG Composite.
Define SVG constants, such as tag names, attribute names and URI
This interface is the placeholder for SVG application informations.
This application can be used to convert SVG images to raster images.
Defines the interface for classes that are able to convert
part or all of a GraphicContext.
Convenience class to filter svg files
Interface for controlling some aspectes of the
SVGConverter operation.Describes an error condition in
SVGConverterDescribes a file source for the
SVGConverterInterface used to handle both Files and URLs in the
SVGConverterUtility class that converts a ConvolveOp object into
an SVG filter descriptor.
This class provides a CSS engine initialized for SVG.
This utility class converts a standard SVG document that uses
attribute into one that uses the CSS style attribute instead.
Utility class that converts an custom BufferedImageOp object into
an equivalent SVG filter.
Utility class that converts an custom Composite object into
a set of SVG properties and definitions.
Utility class that converts an custom Paint object into
a set of SVG properties and definitions.
The base bridge class for decorated shapes.
Bridge class for the <desc> element.
This class provides a common superclass for elements which contain
descriptive text.
Base class for 'descriptive' elements, mostly title and desc.
Defines the interface for a set of SVG attributes and
related definitions.
Bridge class for an SVGDocument node.
This interface represents an object which can build a SVGDocument.
This class represents an object which loads asynchroneaously a SVG document.
An adapter class that represents a listener to the
SVGDocumentLoaderEvent events.This class represents an event which indicate an event originated
from a SVGDocumentLoader instance.
This interface represents a listener to the SVGDocumentLoaderEvent events.
This class implements the
DOMImplementation interface.To create a 'a' element.
To create a 'altGlyphDef' element.
To create a 'altGlyph' element.
To create a 'altGlyphItem' element.
To create a 'animateColor' element.
To create a 'animate' element.
To create a 'animateMotion' element.
To create a 'animateTransform' element.
To create a 'circle' element.
To create a 'clip-path' element.
To create a 'color-profile' element.
To create a 'cursor' element.
To create a 'definition-src' element.
To create a 'defs' element.
To create a 'desc' element.
To create an 'ellipse' element.
To create a 'feBlend' element.
To create a 'feColorMatrix' element.
To create a 'feComponentTransfer' element.
To create a 'feComposite' element.
To create a 'feConvolveMatrix' element.
To create a 'feDiffuseLighting' element.
To create a 'feDisplacementMap' element.
To create a 'feDistantLight' element.
To create a 'feFlood' element.
To create a 'feFuncA' element.
To create a 'feFuncB' element.
To create a 'feFuncG' element.
To create a 'feFuncR' element.
To create a 'feGaussianBlur' element.
To create a 'feImage' element.
To create a 'feMerge' element.
To create a 'feMergeNode' element.
To create a 'feMorphology' element.
To create a 'feOffset' element.
To create a 'fePointLight' element.
To create a 'feSpecularLighting' element.
To create a 'feSpotLight' element.
To create a 'feTile' element.
To create a 'feTurbulence' element
To create a 'filter' element.
To create a 'font' element.
To create a 'font-face' element.
To create a 'font-face-format' element.
To create a 'font-face-name' element.
To create a 'font-face-src' element.
To create a 'font-face-uri' element.
To create a 'foreignObject' element.
To create a 'g' element.
To create a 'glyph' element.
To create a 'glyphRef' element.
To create a 'hkern' element.
To create a 'image' element.
To create a 'linearGradient' element.
To create a 'line' element.
To create a 'marker' element.
To create a 'mask' element.
To create a 'metadata' element.
To create a 'missing-glyph' element.
To create a 'mpath' element.
To create a 'path' element.
To create a 'pattern' element.
To create a 'polygon' element.
To create a 'polyline' element.
To create a 'radialGradient' element.
To create a 'rect' element.
To create a 'script' element.
To create a 'set' element.
To create a 'stop' element.
To create a 'style' element.
To create an 'svg' element.
To create a 'switch' element.
To create a 'symbol' element.
To create a 'text' element.
To create a 'textPath' element.
To create a 'title' element.
To create a 'tref' element.
To create a 'tspan' element.
To create a 'use' element.
To create a 'view' element.
To create a 'vkern' element.
Utility class that converts an Ellipse2D object into
a corresponding SVG element, i.e., a circle or an ellipse.
Bridge class for the <ellipse> element.
Exposes the SVG feature strings that Batik supports.
Bridge class for the <feBlend> element.
Bridge class for the <feColorMatrix> element.
Bridge class for the <feComponentTransfer> element.
Bridge class for the <feFuncA> element.
Bridge class for the <feFuncB> element.
The base bridge class for component transfer function.
Bridge class for the <feFuncG> element.
Bridge class for the <feFuncR> element.
Bridge class for the <feComposite> element.
Bridge class for the <feConvolveMatrix> element.
Bridge class for the <feDiffuseLighting> element.
Bridge class for the <feDisplacementMap> element.
Bridge class for the <feFlood> element.
Bridge class for the <feGaussianBlur> element.
Bridge class for the <feImage> element.
Bridge class for the <feMerge> element.
Bridge class for the <feMergeNode> element.
Bridge class for the <feMorphology> element.
Bridge class for the <feOffset> element.
Bridge class for the <feSpecularLighting> element.
Bridge class for the <feTile> element.
Bridge class for the <feTurbulence> element.
This implementation of FileFilter will allows SVG files
with extention '.svg' or '.svgz'.
Defines the interface for classes that are able to convert
a BufferedImageOp filter.
Used to represent an SVG Composite.
Bridge class for the <filter> element.
Bridge class for the <flowRoot> element.
Converts a TrueType font to an SVG embedded font.
Utility class that converts a Font object into a set of SVG
font attributes
Describes an SVG font
Bridge class for the <font> element.
This class represents a <font-face> element or @font-face rule
Bridge class for the <font-face> element.
A font family class for SVG fonts.
Utility class for SVG fonts.
Bridge class for the <g> element.
This class contains all non graphical contextual information that
are needed by the
SVGGraphics2D to
generate SVG from Java 2D primitives.Class to describe the GraphicContext defaults to
be used.
Interface for a global scripting object for an SVG document.
Bridge class for the <glyph> element.
Represents the SVG equivalent of a Java 2D API graphic
context attribute.
This class performs the task of converting the state of the
Java 2D API graphic context into a set of graphic attributes.
This implementation of the java.awt.Graphics2D abstract class
allows users to generate SVG (Scalable Vector Graphics) content
from Java code.
Thrown when an SVG Generator method receives an illegal argument in parameter.
Thrown when an SVG Generator method receives an illegal argument in parameter.
This class provides a common superclass for all graphics elements.
Represents an SVG font.
A GVTGlyphVector class for SVG fonts.
Describes a set of SVG hints
Bridge class for the <hkern> element.
Generates id for an arbitrary number of prefix
Bridge class for the <image> element.
A simple DOM listener to forward events from the SVG image document to
the original document.
This implementation of the
SquiggleInputHandler class
simply displays an SVG file into the JSVGCanvas.This interface represents an item in an SVGXXXList.
A base Bridge class for the kerning elements.
Utility class that converts a Line2D object into
a corresponding SVG line element.
Utility class that converts a Java GradientPaint into an
SVG linear gradient element
Bridge class for the <linearGradient> element.
Bridge class for the <line> element.
This class dispatches the SVGLoadEvent event on a SVG document.
This class provides an adapter for the SVGLoadEventDispatcherListener
interface.
This class represents an event which indicate an event originated
from a SVGLoadEventDispatcher instance.
This interface represents a listener to the
SVGLoadEventDispatcherEvent events.
This class provides support for the SVGLocatable interface.
Utility class that converts a LookupOp object into
an SVG filter descriptor.
Bridge class for the <marker> element.
Bridge class for the <mask> element.
Bridge class for the <missing-glyph> element.
An interface for SVG elements that can be animated with 'animateMotion'.
Bridge class for the <multiImage> element.
A viewport defined an <svg> element.
Representation of the item SVGNumber.
This class implements
SVGAElement.This class implements
SVGAltGlyphDefElement.This class implements
SVGAltGlyphElement.This class implements
SVGAltGlyphItemElement.Implementation of an
SVGAngle not associated with any attribute.This class implements
SVGAnimateColorElement.This class implements the
SVGAnimatedBoolean interface.This class provides an implementation of the
SVGAnimatedEnumeration interface.This class implements the
SVGAnimatedInteger interface.This class provides an implementation of the
SVGAnimatedLength interface.This class is the implementation of the
SVGAnimatedLengthList
interface.A class that handles an
SVGAnimatedAngle and an
SVGAnimatedEnumeration for the 'marker' element's
'orient' attribute.This class implements the
SVGAnimatedNumber interface.This class is the implementation of the
SVGAnimatedNumberList
interface.This class is the implementation of the
SVGAnimatedPathData
interface.This class is the implementation of the SVGAnimatedPoints interface.
This class implements the
SVGAnimatedPreserveAspectRatio interface.Implementation of
SVGAnimatedRect.This class implements the
SVGAnimatedString interface.This class is the implementation of the SVGAnimatedTransformList interface.
This class implements
SVGAnimateElement.This class implements
SVGAnimateMotionElement.This class implements
SVGAnimateTransformElement.This class provides an implementation of the
SVGAnimationElement interface.This class implements
SVGCircleElement.This class implements
SVGClipPathElement.This class implements
SVGColorProfileElement.This class represents the component transfer function elements.
This class implements
SVGCursorElement.This class implements
SVGDefinitionSrcElement.This class implements
SVGDefsElement.This class implements
SVGDescElement.This class implements
SVGDocument.DOM attribute modified listener wrapper.
DOM character data modified listener wrapper.
DOM node inserted listener wrapper.
DOM node removed listener wrapper.
DOM subtree modified listener wrapper.
This class implements the
SVGElement interface.This class implements
SVGEllipseElement.This class provides an implementation of the SVGEvent interface.
An implementation of the SVGException class.
This class implements
SVGFEBlendElement.This class implements
SVGFEColorMatrixElement.This class implements
SVGFEComponentTransferElement.This class implements
SVGFECompositeElement.This class implements
SVGFEConvolveMatrixElement.This class implements
SVGFEDiffuseLightingElement.This class implements
SVGFEDisplacementMapElement.This class implements
SVGFEDistantLightElement.This class implements
SVGFEFloodElement.This class implements
SVGFEFuncAElement.This class implements
SVGFEFuncBElement.This class implements
SVGFEFuncGElement.This class implements
SVGFEFuncRElement.This class implements
SVGFEGaussianBlurElement.This class implements
SVGFEImageElement.This class implements
SVGFEMergeElement.This class implements
SVGFEMergeNodeElement.This class implements
SVGFEMorphologyElement.This class implements
SVGFEOffsetElement.This class implements
SVGFEPointLightElement.This class implements
SVGFESpecularLightingElement.This class implements
SVGFESpotLightElement.This class implements
SVGFETileElement.This class implements
SVGFETurbulenceElement.This class implements
SVGFilterElement.This class represents a SVGElement with support for standard filter
attributes.
This class implements the flowDiv element from SVG 1.2
This class implements a regular polygon extension to SVG
This class implements a regular polygon extension to SVG
This class implements a regular polygon extension to SVG
This class implements a regular polygon extension to SVG
This class implements a regular polygon extension to SVG
This class implements a regular polygon extension to SVG
This class implements a regular polygon extension to SVG
This class implements
SVGFontElement.This class implements
SVGFontFaceElement.This class implements
SVGFontFaceFormatElement.This class implements
SVGFontFaceNameElement.This class implements
SVGFontFaceSrcElement.This class implements
SVGFontFaceUriElement.This class implements
SVGForeignObjectElement.This class implements
SVGGElement.This class implements
SVGGlyphElement.This class implements
SVGGlyphRefElement.This class implements
SVGGradientElement.This class implements SVGHandlerElement.
This class implements
SVGHKernElement.This class implements
SVGImageElement.Default implementation of SVGLength.
This class implements
SVGLinearGradientElement.This class implements
SVGLineElement.This class implements
SVGMarkerElement.This class implements
SVGMaskElement.This class provides an implementation of the
SVGMatrix interface.This class implements
SVGMetadataElement.This class implements
SVGMissingGlyphElement.This class implements
SVGMPathElement.This class implements a multiImage extension to SVG.
This class implements
SVGPathElement.This class implements
SVGStopElement.An implementation of
SVGPoint that is not associated with any
attribute.This class implements
SVGPolygonElement.This class implements
SVGPolylineElement.This class implements
SVGRadialGradientElement.An implementation of
SVGRect that is not associated with an
attribute.This class implements
SVGRectElement.This class implements
SVGScriptElement.This class implements
SVGSetElement.This class implements a regular polygon extension to SVG
This class implements
SVGStopElement.This class implements
SVGStyleElement.This class implements a multiImage extension to SVG.
This class implements a multiImage extension to SVG.
This class implements
SVGSVGElement.This class implements
SVGSwitchElement.This class implements
SVGSymbolElement.This class provides a common superclass for all graphics elements.
This class implements
SVGTextElement.This class implements
SVGTextPathElement.This class implements
SVGTextPositioningElement.This class implements
SVGTitleElement.This is a development only class.
This class is the implementation of the SVGTransform interface.
This class implements
SVGTRefElement.This class implements
SVGTSpanElement.This class implements
SVGURIReference.This class implements
SVGUseElement.This class implements
DocumentFragment interface.This class implements
SVGViewElement.This class implements
SVGVKernElement.SVG 1.2 mouse wheel event.
This class represents a panel to control svg encoding options.
Utility class that converts a Paint object into an
SVG element.
Used to represent an SVG Paint.
This class provides a manager for the SVGPaint property values.
Utility class that converts a Shape object into an SVG
path element.
Context class for the SVG path element to support extra
methods.
Bridge class for the <path> element.
Constants for the SVGPathSeg interface.
Internal representation of the item SVGPathSeg.
The class provides support for the SVGPath interface.
Bridge class for the <pattern> element.
An
SVGPoint in the list.This class provides a common superclass for shape elements that are
defined with a 'points' attribute (i.e., polygon and polyline).
Utility class that converts a Polygon object into
an SVG element.
Bridge class for the <polygon> element.
Bridge class for the <polyline> element.
Bridge class for the <radialGradient> element.
Utility class that converts a Rectangle2D or RoundRectangle2D
object into an SVG element.
Bridge class for the <rect> element.
Utility class that converts a RenderingHints object into
a set of SVG properties.
Utility class that converts a RescaleOp object into
an SVG filter descriptor.
A bridge class for the 'set' animation element.
Utility class that converts a Shape object into the corresponding
SVG element.
The base bridge class for shapes.
Bridge class for a regular polygon element.
Used to represent an SVG Paint.
This class provides a common superclass for elements which implement
SVGStylable.
This class provides an implementation of the 'xml-stylesheet' processing
instructions.
Defines the set of attributes from Exchange SVG that
are defined as styling properties in Stylable SVG.
Context class for svg:svg elements.
Bridge class for the <svg> element.
A viewport defined an <svg> element.
Bridge class for the <switch> element.
Contains the definition of the SVG tags and attribute names.
This class provides support for SVGTests features.
This class provides the interface for the SVGTextContentElement
for the bridge to implement.
This class provides support for the SVGTextContentElement interface.
Bridge class for the <text> element.
Implementation of
SVGContext for
the children of <text>This class is used to build an AttributedString.
Helper class to collect information about one Glyph
in the GlyphVector
Bridge class for the <textPath> element.
Utility class that converts a TexturePaint object into an
SVG pattern element
Bridge class for the <title> element.
This class is a trancoder from SVG to SVG.
To represent a doctype key.
To represent a doctype value.
To represent a newline key.
To represent a newline value.
Utility class that converts a GraphicContext transform stack
into an SVG transform attribute.
Describes an SVG transform
Abstract class for SVG type related constants.
One line Class Desc
Complete Class Desc
This class provides support for Xlink to a graphics element.
This class implements both
SVGTextPositioningElement
and SVGURIReference..Bridge class for the <use> element.
To handle a mouseover on an anchor and set the cursor.
This interface must be implemented to provide client services to
a JSVGComponent.
This Implements the SVGUserAgent interface to provide a very simple
version of client services to the JSVGComponent.
One line Class Desc
Methods users may want to implement:
displayMessage
A collection of utility methods for SVG.
This interface represents the values for properties like 'fill',
'flood-color'...
This interface provides constants for SVG values.
Bridge class for the <vkern> element.
This class provides support for SVGZoomAndPan features.
This class offers a way to create an SVG document with grouping
that reflects the Swing composite structure (container/components).
A class to handle syncbase SMIL timing specifiers.
This class provides support for AWT system colors.
TableTransfer.java
This class defines the Table type transfer function for the
feComponentTransfer filter, as defined in chapter 15, section 11 of the SVG
specification.
This class provides a manager for the 'text-align' property values.
This class provides a manager for the 'text-anchor' property values.
This class provides a manager for the 'text-decoration' property values.
The
TextEvent interface provides specific contextual
information associated with Text Events.Class that encapsulates information returned from hit testing
a
TextSpanLayout instance.Interface implemented by factory instances that can return
TextSpanLayouts appropriate to AttributedCharacterIterator
instances.
A graphics node that represents text.
Defines where the text of a
TextNode can be anchored
relative to its location.Renders the attributed character iterator of a
TextNode.One line Class Desc
Complete Class Desc
A text path describes a path along which some text will be rendered.
PathLayout can layout text along a Shape, usually a Path object.
This class provides a manager for the 'text-rendering' property values.
This class represents an object which manage GVT text nodes selection.
Class that performs layout of attributed text strings into
glyph sets paintable by TextPainter instances.
This class generate Paints from WMF hatch definitions.
A collection of utility method for text.
This class represents a Dialog that displays a Thumbnail of the current SVG
document.
This class is an
ImageTranscoder that produces a TIFF image.This interface is used by
TIFFTranscoder to write TIFF images
through different codecs.This class is a helper to
TIFFTranscoder that writes TIFF images
through the Image I/O API.This class is responsible for breaking up a block of tiles into
a set of smaller requests that are as large as possible without
rerequesting significant numbers of tiles that are already
available.
This implementation of RenderedImage only serves to put the tiles
generated by it's input into the TileCache.
This the generic interface for a source of tiles.
This is a Grid based implementation of the TileStore.
This is a useful class that wraps a Raster for patricipation in
an LRU Cache.
A renderable that can tile its source into the tile region.
8 bit TileRable implementation
This filter simply tiles its tile starting from the upper
left corner of the tiled region.
This the generic interface for a TileStore.
An abstract base class for time container elements.
An abstract base class for the root time container element
for a document.
An abstract base class for elements that can have timing applied to them.
An adapter class for
TimegraphListeners.An interface for listening to timing events in a timed document.
An abstract base class for SMIL timing value parsers.
An abstract class for SMIL timing specifiers.
This interface must be implemented and then registered as the
handler of a
TimingSpecifierParser instance in order
to be notified of parsing events.An adapter class for
TimingSpecifierListHandler.This class implements an event-based parser for SMIL timing specifier
list values.
A
TimingSpecifierListHandler that creates
TimingSpecifiers.This class implements an event-based parser for SMIL timing specifier
list values.
This class represents a tool bar factory which builds
tool bars from the content of a resource file.
This class allows to simplify the creation of a transcoder which transcodes to
SVG content.
Animation debugging support.
Interface for accessing traits on an element.
Stores information about a specific XML attribute or CSS property.
This class defines an API for transcoding.
Thrown when a transcoder is not able to transcode its input.
This class represents a generic input of a
Transcoder.This class represents a single output for a
Transcoder.This is a utility class that can be used by transcoders that
support transcoding hints and/or error handler.
The
TranscodingHints class defines a way to pass
transcoding parameters or options to any transcoders.Defines the base type of all keys used to control various
aspects of the transcoding operations.
Defines the interface for all the
ComponentTransferOp transfer
functions, which can all be converted to a lookup tableAn animation class for 'animateTransform' animations.
This class implements a transform history mechanism.
This interface must be implemented and then registred as the
handler of a
TransformParser instance in order to
be notified of parsing events.This class implements an event-based parser for the SVG transform
attribute values.
Contains a description of an elementary transform stack element,
such as a rotate or translate.
Enumeration for transformation types.
This is a special case of an Affine that only contains integer
translations, this allows it to do it's work by simply changing
the coordinate system of the tiles.
This class provides support for traversal.
This class represents a triply indexed hash table.
To manage collisions
This class creates a RenderedImage in conformance to the one
defined for the feTurbulence filter of the SVG specification.
Creates a sourceless image from a turbulence function.
Creates a sourceless image from a turbulence function.
The undoable/redoable command.
This class provides a manager for the 'unicode-bidi' property values.
A class that represents a CSS unicode range.
This class provides methods to convert SVG length and coordinate to
float in user units.
This class provides methods to convert SVG length and coordinate to
float in user units.
Holds the informations needed to compute the units.
This class is the default context for a particular element.
A LengthHandler that convert units.
A font family class for unresolved fonts.
This class provides features to manage the update of an SVG document.
This is an adapter for the UpdateManagerListener interface.
This class represents an event which indicate an event originated
from a UpdateManager instance.
This interface represents a listener to the UpdateManagerEvent events.
This class tracks the changes on a GVT tree
This class is a dialog used to enter an URI or to choose a local file.
This class is used to resolve the URI that can be found in a SVG document.
This class represents uri values.
This class manages a cache of soft references to Images that
we have already loaded.
This type of Image tag registy entry is used for 'odd' URL types.
An interface that provides access to the User Agent informations
needed by the bridge.
An abstract user agent adaptor implementation.
Defines a viewport for a
UserAgent.This class represents a dialog to select the user style sheet.
This class represents the main panel of the dialog.
This class represents an object which decodes UTF-16 characters from
a stream of bytes.
This class represents an object which decodes UTF-8 characters from
a stream of bytes.
This interface represents a property value.
This interface defines constants for CSS values.
This interface is implemented by objects which manage the values associated
with a property.
This class defines the Batik version number.
This class provides convenient methods to handle viewport.
This class can be used to store the value of the attribute viewBox or can
also be used to store the various attribute value that can be specified
on a SVG URI fragments.
Defines a viewport.
This class provides a manager for the 'visibility' property values.
A class to handle wallclock SMIL timing specifiers.
This interface represents the 'window' object defined in the global
environment of a SVG document.
To handle the completion of a 'getURL()' or 'postURL' call.
This class wraps a Window object to expose it to the interpreter.
To wrap a function in an handler.
To wrap a function passed to getURL().
Contains the definitions of WMF constants.
Represent a WMF Font, encountered in a Metafile.
This class holds simple properties about a WMF Metafile.
Core class for rendering the WMF image.
Reads a WMF file, including an Aldus Placable Metafile Header.
This class implements the
Transcoder interface and
can convert a WMF input document into an SVG document.This class holds various utilies for importing WMF files that can be used either for
AbstractWMFReaders and
AbstractWMFPaintersOne line Class Desc
Complete Class Desc
This class provides a manager for the 'writing-mode' property values.
Define XBL constants, such as tag names, attribute names and
namespace URI.
Bridge class for the <xbl:content> element.
An EventSupport class that handles XBL-specific event processing.
An interface for classes that can manage XBL functionality for a
document's nodes.
An interface for XBL managers to associate data with nodes.
This class implements the xbl:content element.
This class implements the xbl:definition element.
Base class for all XBL elements to inherit from.
This class implements the xbl:handlerGroup element.
This class implements the xbl:import element.
This class implements the xbl:shadowTree element.
This class implements the
ShadowTreeEvent event class.This class implements the xbl:template element.
This class implements the xbl:xbl element.
The interface for xbl:shadowTree elements.
Bridge class for the <xbl:shadowTree> element.
This class provides support for XLink features.
This class may be the base class of all transcoders which take an
XML document as input and which need to build a DOM tree.
This class contains the definitions of the arrays used to find
the type of the characters found in an XML document.
Contains common XML constants.
A pool of styles and their associated resources
A document that can be marked up using XML style.
This is the set of things needed by a text component to be a reasonably
functioning editor for xml type document.
This class encapsulates a general XML error or warning.
A
SquiggleInputHandler that handles XSLT transformable
XML documents.Implements the URIResolver interface so that relative urls used in
transformations are resolved properly.
An extension of
PreferenceManager which store the preference
in XML.This class describes the XML resources needed to use the various batik
modules.
XML scanner for parsing xml text
This class represents a scanner for XML documents.
This class represents a normalizing reader with encoding detection
management.
This class provides support for XML features.
Simple Text Component to edit xml document with integrated undo / redo behaviour.
XML Token
A collection of utility functions for XML.
View that uses the lexical information to determine the
style characteristics of the text that it renders.
A class to handle the XPath Pattern syntax for XBL content elements.
A class to handle the XPath subset syntax for XBL content elements.
A scanner for XPath subset selectors.