All Classes and Interfaces
Class
Description
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 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 implements the
Comment interface.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.
Base class for device-specific (uncalibrated) color spaces.
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 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 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.
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.
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.
Deprecated.
Handles the processing of arabic text.
Enumerated type for an ARGB Channel selector.
An
ArrayList-backed node list.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.
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 defines the CIE L*a*b* (CIE 1976) color space.
This class represents an CIE LCH color value.
This class contains utility methods to manipulate Java classes.
A reference queue cleaner thread.
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.
Utility for implementing a color conversion scheme.
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.
Helper methods for handling color profiles.
This class provides a manager for the 'color-rendering' property values.
TranscodingHint as to what the destination of the drawing is.
Interface used to decorate java.awt.color.ColorSpaces subclasses to report
the origin of the associated color profile.
Provides access to various color spaces.
Bridge class for the "color switch" extension element.
This class implements a "color switch" extension to SVG.
Generic Color helper class.
Extended
Color class allowing to specify a prioritized list of
alternative colors.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. the image
are applied in the order they are in the List given.
Composites a list of images according to a single composite rule. the image
are applied in the order they are in the List given.
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 interface defines constants for CSS.
This interface allows the user of a CSSEngine to provide contextual
informations.
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 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 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.
Utility for transcoding documents that use modern CSS, bypassing the EchoSVG
style computations.
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 adapter for AngleHandler
This class is a default implementation of the GenericImageHandler for
handlers implementing a caching strategy.
A default implementation that does not apply any conversion
A class to handle content selection when the includes attribute is not
present.
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 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 adapter for LengthHandler
This class provides an adapter for LengthListHandler
The class provides an adapter for PathHandler.
This class provides an adapter for PointsHandler.
This class provides an adapter for PreserveAspectRatioHandler.
Default implementation for the
ScriptSecurity 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 uncalibrated CMYK color space.
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 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.
Helper class.
A set that uses two keys.
This class represents a doubly indexed hash table.
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.
This class is responsible for creating a GVT tree using an SVG DOM tree.
Simple implementation of the Renderer that supports dynamic updates.
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 'colorSwitch' element.
To create a 'histogramNormalization' element.
To create a 'regularPolygon' element.
To create a 'star' 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.
EchoSVG 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 EchoSVG only.Deprecated, for removal: This API element is subject to removal in a future version.
This class implements a star shape extension to sVG
Bridge class for a star element.
Control the behavior of an animated element.
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.
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.
The
ExtendedPathIterator class represents a geometric path
constructed from straight lines, quadratic and cubic (Bezier) curves and
elliptical arcs.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
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.
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.
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.
Converts to grayscale using the standard RED=30%, GREEN=59% and BLUE=11%
weights (see http://en.wikipedia.org/wiki/Grayscale)
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.
This class represents an ICC color value.
Deprecated.
use the version from XML Graphics Commons instead
This class extends the ICCColorSpace class by providing convenience methods
to convert to sRGB using various methods, forcing a given intent, such as
perceptual or relative colorimetric.
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.
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.
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 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 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 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 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 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 io.sf.carte.echosvg.w3c.dom.Location interface for
EchoSVG
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 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.
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.
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.
Localized messages.
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.Simplified in-memory representation of an ICC named color profile.
This class is a parser for ICC named color profiles.
Implements a pseudo color space for a named color which is defined in the CIE
XYZ color space.
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.
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.
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 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.
Parameters for the PNG encoder which is accessed through the ImageWriter
interface.
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 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.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 EchoSVG, 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. allows the
script to be loaded and does not impose constraints on the urls.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
Enumeration for rendering intents.
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 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 EchoSVG 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.
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 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.
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.Helper methods for SVG sizing.
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.
One 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 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.
A transcoding Key represented as a string array.
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 EchoSVG 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 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.
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.
Used for CSS selector matching.
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 is an
ImageTranscoder that produces a TIFF image.This interface is used by
TIFFTranscoder to write TIFF images
through different codecs.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.
Provides specific contextual information associated with Time events.
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 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.
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 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.
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.