| /***************************************************************************** |
| * Copyright (C) The Apache Software Foundation. All rights reserved. * |
| * ------------------------------------------------------------------------- * |
| * This software is published under the terms of the Apache Software License * |
| * version 1.1, a copy of which has been included with this distribution in * |
| * the LICENSE file. * |
| *****************************************************************************/ |
| |
| package org.apache.batik.bridge; |
| |
| import java.awt.geom.Dimension2D; |
| import java.io.IOException; |
| import java.net.MalformedURLException; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.apache.batik.css.HiddenChildElementSupport; |
| import org.apache.batik.gvt.GraphicsNode; |
| import org.apache.batik.gvt.GraphicsNodeRenderContext; |
| import org.apache.batik.script.InterpreterPool; |
| import org.apache.batik.util.SVGConstants; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.svg.SVGDocument; |
| |
| import org.apache.batik.gvt.filter.GraphicsNodeRableFactory; |
| import org.apache.batik.gvt.filter.ConcreteGraphicsNodeRableFactory; |
| |
| /** |
| * This class represents a context used by the various bridges and the |
| * builder. A bridge context is associated to a particular document |
| * and cannot be reused. |
| * |
| * The context encapsulates the dynamic bindings between DOM elements |
| * and GVT nodes, graphic contexts such as a <tt>GraphicsNodeRenderContext</tt>, |
| * and the different objects required by the GVT builder to interpret |
| * a SVG DOM tree such as the current viewport or the user agent. |
| * |
| * @author <a href="mailto:Thierry.Kormann@sophia.inria.fr">Thierry Kormann</a> |
| * @version $Id$ |
| */ |
| public class BridgeContext implements ErrorConstants { |
| |
| /** |
| * The GVT builder that might be used to create a GVT subtree. |
| */ |
| protected GVTBuilder gvtBuilder; |
| |
| /** |
| * The viewports. |
| * key is an Element - |
| * value is a Viewport |
| */ |
| protected Map viewportMap = new HashMap(); |
| |
| /** |
| * The viewport stack. Used in building time. |
| */ |
| protected List viewportStack = new LinkedList(); |
| |
| /** |
| * The user agent. |
| */ |
| protected UserAgent userAgent; |
| |
| /** |
| * Binding Map: |
| * key is an SVG Element - |
| * value is a GraphicsNode |
| */ |
| protected HashMap elementNodeMap; |
| |
| /** |
| * Binding Map: |
| * key is GraphicsNode - |
| * value is a SVG Element. |
| */ |
| protected HashMap nodeElementMap; |
| |
| /** |
| * Binding Map: |
| * key is style Element - |
| * value is a list of styleReference |
| */ |
| protected HashMap elementStyleAttMap; |
| |
| /** |
| * Binding Map: |
| * key is GraphicsNode - |
| * value is list of StyleElement. |
| */ |
| protected HashMap nodeStyleMap; |
| |
| /** |
| * Bridge Map: |
| * Keys are namespace URI - values are HashMap (with keys are local |
| * name and values are a Bridge instance). |
| */ |
| protected HashMap namespaceURIMap; |
| |
| /** |
| * The current <tt>GraphicsNodeRenderContext</tt> for <tt>GraphicsNode</tt>. |
| */ |
| protected GraphicsNodeRenderContext rc; |
| |
| /** |
| * The interpreter pool used to handle scripts. |
| */ |
| protected InterpreterPool interpreterPool; |
| |
| /** |
| * The document loader used to load/create Document. |
| */ |
| protected DocumentLoader documentLoader; |
| |
| /** |
| * The size of the document. |
| */ |
| protected Dimension2D documentSize; |
| |
| /** |
| * Constructs a new empty bridge context. |
| */ |
| protected BridgeContext() {} |
| |
| /** |
| * By default we share a unique instance of InterpreterPool. |
| */ |
| private static InterpreterPool sharedPool = new InterpreterPool(); |
| |
| /** |
| * Constructs a new bridge context. |
| * @param userAgent the user agent |
| * @param rc the graphics node renderer context |
| */ |
| public BridgeContext(UserAgent userAgent, |
| GraphicsNodeRenderContext rc) { |
| this(userAgent, |
| rc, |
| sharedPool, |
| new DocumentLoader(userAgent)); |
| } |
| |
| /** |
| * Constructs a new bridge context. |
| * @param userAgent the user agent |
| * @param rc the graphics node renderer context |
| * @param documentLoader document loader |
| */ |
| public BridgeContext(UserAgent userAgent, |
| GraphicsNodeRenderContext rc, |
| DocumentLoader loader) { |
| this(userAgent, rc, sharedPool, loader); |
| } |
| |
| /** |
| * Constructs a new bridge context. |
| * @param userAgent the user agent |
| * @param rc the graphics node renderer context |
| * @param interpreterPool the interpreter pool |
| * @param documentLoader document loader |
| */ |
| public BridgeContext(UserAgent userAgent, |
| GraphicsNodeRenderContext rc, |
| InterpreterPool interpreterPool, |
| DocumentLoader documentLoader) { |
| this.userAgent = userAgent; |
| this.viewportMap.put(userAgent, new UserAgentViewport(userAgent)); |
| this.rc = rc; |
| this.interpreterPool = interpreterPool; |
| this.documentLoader = documentLoader; |
| registerSVGBridges(this); |
| } |
| |
| ///////////////////////////////////////////////////////////////////////// |
| // properties |
| ///////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * Returns the user agent of this bridge context. |
| */ |
| public UserAgent getUserAgent() { |
| return userAgent; |
| } |
| |
| /** |
| * Sets the user agent to the specified user agent. |
| * @param userAgent the user agent |
| */ |
| protected void setUserAgent(UserAgent userAgent) { |
| this.userAgent = userAgent; |
| } |
| |
| /** |
| * Sets the GVT builder that uses this context. |
| */ |
| protected void setGVTBuilder(GVTBuilder gvtBuilder) { |
| this.gvtBuilder = gvtBuilder; |
| } |
| |
| /** |
| * Returns the GVT builder that is currently used to build the GVT tree. |
| */ |
| public GVTBuilder getGVTBuilder() { |
| return gvtBuilder; |
| } |
| |
| /** |
| * Returns the interpreter pool used to handle scripts. |
| */ |
| public InterpreterPool getInterpreterPool() { |
| return interpreterPool; |
| } |
| |
| /** |
| * Sets the interpreter pool used to handle scripts to the |
| * specified interpreter pool. |
| * @param interpreterPool the interpreter pool |
| */ |
| protected void setInterpreterPool(InterpreterPool interpreterPool) { |
| this.interpreterPool = interpreterPool; |
| } |
| |
| /** |
| * Returns the document loader used to load external documents. |
| */ |
| public DocumentLoader getDocumentLoader() { |
| return documentLoader; |
| } |
| |
| /** |
| * Sets the document loader used to load external documents. |
| * @param newDocumentLoader the new document loader |
| */ |
| protected void setDocumentLoader(DocumentLoader newDocumentLoader) { |
| this.documentLoader = newDocumentLoader; |
| } |
| |
| /** |
| * Returns a <tt>GraphicsNodeRenderContext</tt> to use. |
| */ |
| public GraphicsNodeRenderContext getGraphicsNodeRenderContext() { |
| return rc; |
| } |
| |
| /** |
| * Sets the <tt>GraphicsNodeRenderContext</tt> to use. |
| * @param rc the new GraphicsNodeRenderContext |
| */ |
| protected void setGraphicsNodeRenderContext(GraphicsNodeRenderContext rc) { |
| this.rc = rc; |
| } |
| |
| ///////////////////////////////////////////////////////////////////////// |
| // convenient methods |
| ///////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * Returns the element referenced by the specified element by the |
| * specified uri. The referenced element can not be a Document. |
| * |
| * @param e the element referencing |
| * @param uri the uri of the referenced element |
| */ |
| public Element getReferencedElement(Element e, String uri) { |
| try { |
| SVGDocument document = (SVGDocument)e.getOwnerDocument(); |
| URIResolver ur = new URIResolver(document, documentLoader); |
| Element ref = ur.getElement(uri); |
| if (ref == null) { |
| throw new BridgeException(e, ERR_URI_MALFORMED, |
| new Object[] {uri}); |
| } else { |
| return ref; |
| } |
| } catch (MalformedURLException ex) { |
| throw new BridgeException(e, ERR_URI_MALFORMED, |
| new Object[] {uri}); |
| } catch (IOException ex) { |
| throw new BridgeException(e, ERR_URI_IO, |
| new Object[] {uri}); |
| } catch (IllegalArgumentException ex) { |
| throw new BridgeException(e, ERR_URI_REFERENCE_A_DOCUMENT, |
| new Object[] {uri}); |
| } |
| } |
| |
| ///////////////////////////////////////////////////////////////////////// |
| // methods to access to the current state of the bridge context |
| ///////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * Returns the actual size of the document or null if the document |
| * has not been built yet. |
| */ |
| public Dimension2D getDocumentSize() { |
| return documentSize; |
| } |
| |
| /** |
| * Sets the size of the document to the specified dimension. |
| * |
| * @param d the actual size of the SVG document |
| */ |
| protected void setDocumentSize(Dimension2D d) { |
| this.documentSize = d; |
| } |
| |
| /** |
| * Returns the viewport of the specified element. |
| * @param e the element interested in its viewport |
| */ |
| public Viewport getViewport(Element e) { |
| if (viewportStack != null) { // building time |
| if (viewportStack.size() > 0) { |
| return (Viewport)viewportStack.get(0); |
| } else { |
| return (Viewport)viewportMap.get(userAgent); |
| } |
| } else { |
| // search the first parent which has defined a viewport |
| e = HiddenChildElementSupport.getParentElement(e); |
| while (e != null) { |
| Viewport viewport = (Viewport)viewportMap.get(e); |
| if (viewport != null) { |
| return viewport; |
| } |
| e = HiddenChildElementSupport.getParentElement(e); |
| } |
| return (Viewport)viewportMap.get(userAgent); |
| } |
| } |
| |
| /** |
| * Starts a new viewport from the specified element. |
| * @param e the element that starts the viewport |
| * @param viewport the viewport of the element |
| */ |
| public void openViewport(Element e, Viewport viewport) { |
| viewportMap.put(e, viewport); |
| viewportStack.add(0, viewport); |
| } |
| |
| /** |
| * Closes the viewport associated to the specified element. |
| * @param e the element that closes its viewport |
| */ |
| public void closeViewport(Element e) { |
| viewportMap.remove(e); |
| viewportStack.remove(0); |
| } |
| |
| /** |
| * Returns true if the bridge should support dynamic SVG content, |
| * false otherwise. |
| */ |
| public boolean isDynamic() { |
| return true; |
| } |
| |
| ///////////////////////////////////////////////////////////////////////// |
| // binding methods |
| ///////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * Binds the specified GraphicsNode to the specified Element. This method |
| * automatically bind the graphics node to the element and the element to |
| * the graphics node. |
| * @param element the element to bind to the specified graphics node |
| * @param node the graphics node to bind to the specified element |
| */ |
| public void bind(Element element, GraphicsNode node) { |
| if (elementNodeMap == null) { |
| elementNodeMap = new HashMap(); |
| nodeElementMap = new HashMap(); |
| } |
| elementNodeMap.put(element, node); |
| nodeElementMap.put(node, element); |
| } |
| |
| /** |
| * Removes the binding of the specified Element. This method |
| * unbinds the specified element to its associated graphics node, |
| * remove the binding from the graphics node to the specified |
| * element, and all the style references associated to the |
| * specified element are also removed. |
| * @param element the element to unbind |
| */ |
| public void unbind(Element element) { |
| if (elementNodeMap == null) { |
| return; |
| } |
| GraphicsNode node = (GraphicsNode)elementNodeMap.get(element); |
| elementNodeMap.remove(element); |
| nodeElementMap.remove(node); |
| // Removes all styles bound to this GraphicsNode |
| removeStyleReferences(node); |
| } |
| |
| /** |
| * Returns the GraphicsNode associated to the specified Element or |
| * null if any. |
| * @param element the element associated to the graphics node to return |
| */ |
| public GraphicsNode getGraphicsNode(Element element) { |
| if (elementNodeMap != null) { |
| return (GraphicsNode)elementNodeMap.get(element); |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Returns the Element associated to the specified GraphicsNode or |
| * null if any. |
| * @param node the graphics node associated to the element to return |
| */ |
| public Element getElement(GraphicsNode node) { |
| if (nodeElementMap != null) { |
| return (Element)nodeElementMap.get(node); |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Binds a style element to a style reference. |
| * Several style reference can be bound to the same style element. |
| * @param element the element |
| * @param reference the style reference |
| */ |
| public void bind(Element element, StyleReference reference) { |
| if (elementStyleAttMap == null) { |
| elementStyleAttMap = new HashMap(); |
| } |
| LinkedList list = (LinkedList)elementStyleAttMap.get(element); |
| if (list == null) { |
| list = new LinkedList(); |
| elementStyleAttMap.put(element, list); |
| } |
| list.add(reference); |
| if (nodeStyleMap == null) |
| nodeStyleMap = new HashMap(); |
| |
| GraphicsNode node = reference.getGraphicsNode(); |
| list = (LinkedList)nodeStyleMap.get(node); |
| if (list == null) { |
| list = new LinkedList(); |
| nodeStyleMap.put(node, list); |
| } |
| list.add(element); |
| } |
| |
| /** |
| * Returns an enumeration of all style refence for the specified |
| * style element. |
| * @param element the element |
| */ |
| public List getStyleReferenceList(Element element) { |
| if (elementStyleAttMap == null) { |
| return Collections.EMPTY_LIST; |
| } else { |
| LinkedList list = (LinkedList)elementStyleAttMap.get(element); |
| if (list != null) { |
| return list; |
| } else { |
| return Collections.EMPTY_LIST; |
| } |
| } |
| } |
| |
| /** |
| * Removes all bindings between a style Element and the specified |
| * GraphicsNode. |
| * @param node the graphics node |
| */ |
| private void removeStyleReferences(GraphicsNode node){ |
| // Get the list of style Elements used by this node |
| if (nodeStyleMap == null) { |
| return; |
| } |
| List styles = (List)nodeStyleMap.get(node); |
| if (styles != null) { |
| nodeStyleMap.remove(node); |
| } |
| for (Iterator it = styles.iterator(); it.hasNext();){ |
| Element style = (Element)it.next(); |
| removeStyleReference(node, style); |
| } |
| } |
| |
| /** |
| * Removes all StyleReference corresponding to the specified GraphicsNode. |
| * @param node the graphics node |
| * @param style the style element |
| */ |
| private void removeStyleReference(GraphicsNode node, Element style){ |
| if (elementStyleAttMap == null) { |
| return; |
| } |
| LinkedList list = (LinkedList)elementStyleAttMap.get(style); |
| List removed = null; |
| if (list == null) { |
| return; |
| } |
| for (Iterator it = list.iterator(); it.hasNext();){ |
| StyleReference styleRef = (StyleReference)it.next(); |
| if (styleRef.getGraphicsNode()==node) { |
| if (removed == null) { |
| removed = new LinkedList(); |
| } |
| removed.add(styleRef); |
| } |
| } |
| if (removed != null) { |
| for (Iterator it = removed.iterator(); it.hasNext();) { |
| list.remove(it.next()); |
| } |
| } |
| if (list.size() == 0) { |
| elementStyleAttMap.remove(style); |
| } |
| } |
| |
| ///////////////////////////////////////////////////////////////////////// |
| // bridge support |
| ///////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * Returns the bridge associated with the specified element. |
| * @param element the element |
| */ |
| public Bridge getBridge(Element element) { |
| if (namespaceURIMap == null || element == null) { |
| return null; |
| } |
| String namespaceURI = element.getNamespaceURI(); |
| String localName = element.getLocalName(); |
| namespaceURI = ((namespaceURI == null)? "" : namespaceURI); |
| HashMap localNameMap = (HashMap) namespaceURIMap.get(namespaceURI); |
| if (localNameMap == null) { |
| return null; |
| } |
| return (Bridge)localNameMap.get(localName); |
| } |
| |
| /** |
| * Returns the bridge associated with the element type |
| * @param nameSpaceURI namespace of the requested element |
| * @param localName element's local name |
| * |
| */ |
| public Bridge getBridge(String namespaceURI, |
| String localName){ |
| HashMap localNameMap = (HashMap) namespaceURIMap.get(namespaceURI); |
| if (localNameMap == null) { |
| return null; |
| } |
| return (Bridge)localNameMap.get(localName); |
| } |
| |
| /** |
| * Associates the specified <tt>Bridge</tt> object with the specified |
| * namespace URI and local name. |
| * @param namespaceURI the namespace URI |
| * @param localName the local name |
| * @param bridge the bridge that manages the element |
| */ |
| public void putBridge(String namespaceURI, String localName, |
| Bridge bridge) { |
| if (namespaceURIMap == null) { |
| namespaceURIMap = new HashMap(); |
| } |
| namespaceURI = ((namespaceURI == null)? "" : namespaceURI); |
| HashMap localNameMap = (HashMap) namespaceURIMap.get(namespaceURI); |
| if (localNameMap == null) { |
| localNameMap = new HashMap(); |
| namespaceURIMap.put(namespaceURI, localNameMap); |
| } |
| localNameMap.put(localName, bridge); |
| } |
| |
| /** |
| * Removes the <tt>Bridge</tt> object associated to the specified |
| * namespace URI and local name. |
| * @param namespaceURI the namespace URI |
| * @param localName the local name |
| */ |
| public void removeBridge(String namespaceURI, String localName) { |
| if (namespaceURIMap == null) { |
| return; |
| } |
| namespaceURI = ((namespaceURI == null)? "" : namespaceURI); |
| HashMap localNameMap = (HashMap) namespaceURIMap.get(namespaceURI); |
| if (localNameMap != null) { |
| localNameMap.remove(localName); |
| if (localNameMap.isEmpty()) { |
| namespaceURIMap.remove(namespaceURI); |
| if (namespaceURIMap.isEmpty()) { |
| namespaceURIMap = null; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Registers the bridges to handle SVG 1.0 elements. |
| * @param ctx the bridge context to initialize |
| */ |
| public static void registerSVGBridges(BridgeContext ctx) { |
| // bridges to handle elements in the SVG namespace |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_A_TAG, |
| new SVGAElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_CIRCLE_TAG, |
| new SVGCircleElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_CLIP_PATH_TAG, |
| new SVGClipPathElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_COLOR_PROFILE_TAG, |
| new SVGColorProfileElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_ELLIPSE_TAG, |
| new SVGEllipseElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FE_BLEND_TAG, |
| new SVGFeBlendElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FE_COLOR_MATRIX_TAG, |
| new SVGFeColorMatrixElementBridge()); |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FE_COMPONENT_TRANSFER_TAG, |
| new SVGFeComponentTransferElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FE_COMPOSITE_TAG, |
| new SVGFeCompositeElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FE_CONVOLVE_MATRIX_TAG, |
| new SVGFeConvolveMatrixElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FE_DIFFUSE_LIGHTING_TAG, |
| new SVGFeDiffuseLightingElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FE_DISPLACEMENT_MAP_TAG, |
| new SVGFeDisplacementMapElementBridge()); |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FE_FLOOD_TAG, |
| new SVGFeFloodElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FE_GAUSSIAN_BLUR_TAG, |
| new SVGFeGaussianBlurElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FE_IMAGE_TAG, |
| new SVGFeImageElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FE_MERGE_TAG, |
| new SVGFeMergeElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FE_MERGE_NODE_TAG, |
| new SVGFeMergeElementBridge.SVGFeMergeNodeElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FE_MORPHOLOGY_TAG, |
| new SVGFeMorphologyElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FE_OFFSET_TAG, |
| new SVGFeOffsetElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FE_SPECULAR_LIGHTING_TAG, |
| new SVGFeSpecularLightingElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FE_TILE_TAG, |
| new SVGFeTileElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FE_TURBULENCE_TAG, |
| new SVGFeTurbulenceElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FILTER_TAG, |
| new SVGFilterElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FE_FUNC_A_TAG, |
| new SVGFeComponentTransferElementBridge.SVGFeFuncAElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FE_FUNC_R_TAG, |
| new SVGFeComponentTransferElementBridge.SVGFeFuncRElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FE_FUNC_G_TAG, |
| new SVGFeComponentTransferElementBridge.SVGFeFuncGElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FE_FUNC_B_TAG, |
| new SVGFeComponentTransferElementBridge.SVGFeFuncBElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_G_TAG, |
| new SVGGElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_IMAGE_TAG, |
| new SVGImageElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_LINE_TAG, |
| new SVGLineElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_LINEAR_GRADIENT_TAG, |
| new SVGLinearGradientElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_MARKER_TAG, |
| new SVGMarkerElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_MASK_TAG, |
| new SVGMaskElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_PATH_TAG, |
| new SVGPathElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_PATTERN_TAG, |
| new SVGPatternElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_POLYLINE_TAG, |
| new SVGPolylineElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_POLYGON_TAG, |
| new SVGPolygonElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_RADIAL_GRADIENT_TAG, |
| new SVGRadialGradientElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_RECT_TAG, |
| new SVGRectElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_STOP_TAG, |
| new SVGAbstractGradientElementBridge.SVGStopElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_SVG_TAG, |
| new SVGSVGElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_SWITCH_TAG, |
| new SVGSwitchElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_TEXT_TAG, |
| new SVGTextElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_USE_TAG, |
| new SVGUseElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FE_SPOT_LIGHT_TAG, |
| new SVGFeAbstractLightingElementBridge.SVGFeSpotLightElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FE_POINT_LIGHT_TAG, |
| new SVGFeAbstractLightingElementBridge.SVGFePointLightElementBridge()); |
| |
| ctx.putBridge(SVGConstants.SVG_NAMESPACE_URI, |
| SVGConstants.SVG_FE_DISTANT_LIGHT_TAG, |
| new SVGFeAbstractLightingElementBridge.SVGFeDistantLightElementBridge()); |
| |
| } |
| } |
