Java 类org.w3c.dom.events.EventListener 实例源码

/**
 * Is called only for the root element in order to dispatch GVT
 * events to the DOM.
 */
public static void addGVTListener(BridgeContext ctx, Document doc) {
    UserAgent ua = ctx.getUserAgent();
    if (ua != null) {
        EventDispatcher dispatcher = ua.getEventDispatcher();
        if (dispatcher != null) {
            final Listener listener = new Listener(ctx, ua);
            dispatcher.addGraphicsNodeMouseListener(listener);
            dispatcher.addGraphicsNodeKeyListener(listener);
            // add an unload listener on the SVGDocument to remove
            // that listener for dispatching events
            EventListener l = new GVTUnloadListener(dispatcher, listener);
            NodeEventTarget target = (NodeEventTarget)doc;
            target.addEventListenerNS
                (XMLConstants.XML_EVENTS_NAMESPACE_URI,
                 "SVGUnload",
                 l, false, null);
            storeEventListenerNS
                (ctx, target,
                 XMLConstants.XML_EVENTS_NAMESPACE_URI,
                 "SVGUnload",
                 l, false);
        }
    }
}

/**
 * Updates the registration of a listener on the given element.
 */
protected void updateScriptingListeners(Element elt, String attr) {
    String domEvt = (String) attrToDOMEvent.get(attr);
    if (domEvt == null) {
        return;  // Not an event attr.
    }
    EventListener listener = (EventListener) attrToListener.get(attr);
    NodeEventTarget target = (NodeEventTarget) elt;
    if (elt.hasAttributeNS(null, attr)) {
        target.addEventListenerNS
            (XMLConstants.XML_EVENTS_NAMESPACE_URI, domEvt,
             listener, false, null);
    } else {
        target.removeEventListenerNS
            (XMLConstants.XML_EVENTS_NAMESPACE_URI, domEvt,
             listener, false);
    }
}

/**
 * Is called only for the root element in order to dispatch GVT
 * events to the DOM.
 */
public static void addGVTListener(BridgeContext ctx, Document doc) {
    UserAgent ua = ctx.getUserAgent();
    if (ua != null) {
        EventDispatcher dispatcher = ua.getEventDispatcher();
        if (dispatcher != null) {
            final Listener listener = new Listener(ctx, ua);
            dispatcher.addGraphicsNodeMouseListener(listener);
            dispatcher.addGraphicsNodeMouseWheelListener(listener);
            dispatcher.addGraphicsNodeKeyListener(listener);
            // add an unload listener on the SVGDocument to remove
            // that listener for dispatching events
            EventListener l = new GVTUnloadListener(dispatcher, listener);
            NodeEventTarget target = (NodeEventTarget) doc;
            target.addEventListenerNS
                (XMLConstants.XML_EVENTS_NAMESPACE_URI,
                 "SVGUnload",
                 l, false, null);
            storeEventListenerNS
                (ctx, target,
                 XMLConstants.XML_EVENTS_NAMESPACE_URI,
                 "SVGUnload",
                 l, false);
        }
    }
}

/**
 * Builds using the specified BridgeContext and element, the
 * specified graphics node.
 *
 * @param ctx the bridge context to use
 * @param e the element that describes the graphics node to build
 * @param node the graphics node to build
 */
public void buildGraphicsNode(BridgeContext ctx,
                              Element e,
                              GraphicsNode node) {

    super.buildGraphicsNode(ctx, e, node);

    if (ctx.isInteractive()) {
        NodeEventTarget target = (NodeEventTarget)e;
        EventListener l = new CursorMouseOverListener(ctx);
        target.addEventListenerNS
            (XMLConstants.XML_EVENTS_NAMESPACE_URI, SVG_EVENT_MOUSEOVER,
             l, false, null);
        ctx.storeEventListenerNS
            (target, XMLConstants.XML_EVENTS_NAMESPACE_URI, SVG_EVENT_MOUSEOVER,
             l, false);
    }
}

public void removeUIEventListeners(Document doc) {
    EventTarget evtTarget = (EventTarget)doc.getDocumentElement();
    synchronized (eventListenerSet) {
        Iterator i = eventListenerSet.iterator();
        while (i.hasNext()) {
            EventListenerMememto elm = (EventListenerMememto)i.next();
            NodeEventTarget et = elm.getTarget();
            if (et == evtTarget) {
                EventListener el = elm.getListener();
                boolean       uc = elm.getUseCapture();
                String        t  = elm.getEventType();
                boolean       n  = elm.getNamespaced();
                if (et == null || el == null || t == null) {
                    continue;
                }
                if (n) {
                    String ns = elm.getNamespaceURI();
                    et.removeEventListenerNS(ns, t, el, uc);
                } else {
                    et.removeEventListener(t, el, uc);
                }
            }
        }
    }
}

/**
 * <b>DOM</b>: Implements
 * {@link
 * NodeEventTarget#addEventListenerNS(String,String,EventListener,boolean,Object)}.
 */
public void addEventListenerNS(String namespaceURI,
                               String type,
                               EventListener listener,
                               boolean useCapture,
                               Object evtGroup) {
    if (eventSupport == null) {
        initializeEventSupport();
    }
    if (namespaceURI != null && namespaceURI.length() == 0) {
        namespaceURI = null;
    }
    eventSupport.addEventListenerNS(namespaceURI,
                                    type,
                                    listener,
                                    useCapture,
                                    evtGroup);
}

/**
 * Deregisters an event listener.
 */
public void removeEventListenerNS(String namespaceURI,
                                  String type,
                                  EventListener listener,
                                  boolean useCapture) {
    HashTable listeners;
    if (useCapture) {
        listeners = capturingListeners;
    } else {
        listeners = bubblingListeners;
    }
    if (listeners == null) {
        return;
    }
    EventListenerList list = (EventListenerList) listeners.get(type);
    if (list != null) {
        list.removeListener(namespaceURI, listener);
        if (list.size() == 0) {
            listeners.remove(type);
        }
    }
}

/**
 * Adds a listener.
 */
public void addListener(String namespaceURI,
                        Object group,
                        EventListener listener) {
    for (Entry e = head; e != null; e = e.next) {
        if ((namespaceURI != null && namespaceURI.equals(e.namespaceURI)
                    || namespaceURI == null && e.namespaceURI == null)
                && e.listener == listener) {
            // Listener is already in the list, so do nothing.
            return;
        }
    }
    head = new Entry(listener, namespaceURI, group, head);
    counts.inc(namespaceURI);
    n++;
    listeners = null;
    listenersNS.remove(namespaceURI);
}

public void documentLoadingCompleted(SVGDocumentLoaderEvent e) {
    NodeEventTarget root
        = (NodeEventTarget) e.getSVGDocument().getRootElement();
    root.addEventListenerNS
        (XMLConstants.XML_EVENTS_NAMESPACE_URI,
         SVGConstants.SVG_SVGZOOM_EVENT_TYPE,
         new EventListener() {
             public void handleEvent(Event evt) {
                 if (!(evt.getTarget() instanceof SVGSVGElement))
                     return;
                 // assert(evt.getType() ==
                 //        SVGConstants.SVG_SVGZOOM_EVENT_TYPE);
                 SVGSVGElement svg = (SVGSVGElement) evt.getTarget();
                 scaleChange(svg.getCurrentScale());
             } // handleEvent()
         }, false, null);
}

/**
 * Registers an event listener for the given namespaced event type
 * in the specified group.
 */
public void addEventListenerNS(String namespaceURI,
                               String type,
                               EventListener listener,
                               boolean useCapture,
                               Object group) {
    super.addEventListenerNS
        (namespaceURI, type, listener, useCapture, group);
    if (namespaceURI == null
            || namespaceURI.equals(XMLConstants.XML_EVENTS_NAMESPACE_URI)) {
        String alias = (String) eventTypeAliases.get(type);
        if (alias != null) {
            super.addEventListenerNS
                (namespaceURI, alias, listener, useCapture, group);
        }
    }
}

/**
 * Unregisters an implementation event listener.
 */
public void removeImplementationEventListenerNS(String namespaceURI,
                                                String type,
                                                EventListener listener,
                                                boolean useCapture) {
    HashTable listeners = useCapture ? capturingImplementationListeners
                                     : bubblingImplementationListeners;
    if (listeners == null) {
        return;
    }
    EventListenerList list = (EventListenerList) listeners.get(type);
    if (list == null) {
        return;
    }
    list.removeListener(namespaceURI, listener);
    if (list.size() == 0) {
        listeners.remove(type);
    }
}

/**
 * Removes an event listener for mutations on the
 * CSSNavigableDocument tree.
 */
public void removeCSSNavigableDocumentListener
        (CSSNavigableDocumentListener l) {
    EventListener[] listeners
        = (EventListener[]) cssNavigableDocumentListeners.get(l);
    if (listeners == null) {
        return;
    }

    removeEventListenerNS(XMLConstants.XML_EVENTS_NAMESPACE_URI,
                          "DOMNodeInserted", listeners[0], false);
    removeEventListenerNS(XMLConstants.XML_EVENTS_NAMESPACE_URI,
                          "DOMNodeRemoved", listeners[1], false);
    removeEventListenerNS(XMLConstants.XML_EVENTS_NAMESPACE_URI,
                          "DOMSubtreeModified", listeners[2], false);
    removeEventListenerNS(XMLConstants.XML_EVENTS_NAMESPACE_URI,
                          "DOMCharacterDataModified", listeners[3], false);
    removeEventListenerNS(XMLConstants.XML_EVENTS_NAMESPACE_URI,
                          "DOMAttrModified", listeners[4], false);

    cssNavigableDocumentListeners.remove(l);
}

public JProxyExampleDocument(ItsNatServletRequest request,ItsNatHTMLDocument itsNatDoc,FalseDB db)
{       
    this.itsNatDoc = itsNatDoc;

    HTMLDocument doc = itsNatDoc.getHTMLDocument();

    ItsNatComponentManager compMgr = itsNatDoc.getItsNatComponentManager();
    this.textInput = (ItsNatHTMLInputText)compMgr.createItsNatComponentById("inputId");


    EventListener listener = new EventListener()
    {        
        @Override
        public void handleEvent(Event evt) 
        {               
            String text = textInput.getText();
            String comment = "  YES I SAID THAT"; // " YES I SAID THAT";                
            resultsElem.setTextContent(text + comment);
        }
    };

    Element buttonElem = doc.getElementById("buttonId");
    ((EventTarget)buttonElem).addEventListener("click",listener,false);

    this.resultsElem = doc.getElementById("resultsId");            
}

@Override
public void changed (ObservableValue<? extends State> ov, State oldState, State newState) {
    if (newState == Worker.State.SUCCEEDED) {
        EventListener listener = event -> {
            final String href = ((Element)event.getTarget()).getAttribute(HTML_LINK);
            if (href != null) {
                String domEventType = event.getType();
                if (domEventType.equals(EVENT_CLICK)) {
                    showPage(href);
                } else if (domEventType.equals(EVENT_MOUSEOVER)) {
                    showStatus(href);
                } else if (domEventType.equals(EVENT_MOUSEOUT)) {
                    showStatus(BLANK);
                }
            }
        };
        Document doc = myPage.getEngine().getDocument();
        NodeList nodes = doc.getElementsByTagName("a");
        for (int i = 0; i < nodes.getLength(); i++) {
            EventTarget node = (EventTarget)nodes.item(i);
            node.addEventListener(EVENT_CLICK, listener, false);
            node.addEventListener(EVENT_MOUSEOVER, listener, false);
            node.addEventListener(EVENT_MOUSEOUT, listener, false);
        }
    }
}

/**
 * Registers an event listener for the given namespaced event type
 * in the specified group.
 */
public void addEventListenerNS(String namespaceURI,
                               String type,
                               EventListener listener,
                               boolean useCapture,
                               Object group) {
    HashTable listeners;
    if (useCapture) {
        if (capturingListeners == null) {
            capturingListeners = new HashTable();
        }
        listeners = capturingListeners;
    } else {
        if (bubblingListeners == null) {
            bubblingListeners = new HashTable();
        }
        listeners = bubblingListeners;
    }
    EventListenerList list = (EventListenerList) listeners.get(type);
    if (list == null) {
        list = new EventListenerList();
        listeners.put(type, list);
    }
    list.addListener(namespaceURI, group, listener);
}

/**
 * Updates the registration of a listener on the given element.
 */
protected void updateScriptingListeners(Element elt, String attr) {
    String domEvt = (String) attrToDOMEvent.get(attr);
    if (domEvt == null) {
        return;  // Not an event attr.
    }
    EventListener listener = (EventListener) attrToListener.get(attr);
    NodeEventTarget target = (NodeEventTarget) elt;
    if (elt.hasAttributeNS(null, attr)) {
        target.addEventListenerNS
            (XMLConstants.XML_EVENTS_NAMESPACE_URI, domEvt,
             listener, false, null);
    } else {
        target.removeEventListenerNS
            (XMLConstants.XML_EVENTS_NAMESPACE_URI, domEvt,
             listener, false);
    }
}

/**
 * Is called only for the root element in order to dispatch GVT
 * events to the DOM.
 */
public static void addGVTListener(BridgeContext ctx, Document doc) {
    UserAgent ua = ctx.getUserAgent();
    if (ua != null) {
        EventDispatcher dispatcher = ua.getEventDispatcher();
        if (dispatcher != null) {
            final Listener listener = new Listener(ctx, ua);
            dispatcher.addGraphicsNodeMouseListener(listener);
            dispatcher.addGraphicsNodeMouseWheelListener(listener);
            dispatcher.addGraphicsNodeKeyListener(listener);
            // add an unload listener on the SVGDocument to remove
            // that listener for dispatching events
            EventListener l = new GVTUnloadListener(dispatcher, listener);
            NodeEventTarget target = (NodeEventTarget) doc;
            target.addEventListenerNS
                (XMLConstants.XML_EVENTS_NAMESPACE_URI,
                 "SVGUnload",
                 l, false, null);
            storeEventListenerNS
                (ctx, target,
                 XMLConstants.XML_EVENTS_NAMESPACE_URI,
                 "SVGUnload",
                 l, false);
        }
    }
}

/**
 * Builds using the specified BridgeContext and element, the
 * specified graphics node.
 *
 * @param ctx the bridge context to use
 * @param e the element that describes the graphics node to build
 * @param node the graphics node to build
 */
public void buildGraphicsNode(BridgeContext ctx,
                              Element e,
                              GraphicsNode node) {

    super.buildGraphicsNode(ctx, e, node);

    if (ctx.isInteractive()) {
        NodeEventTarget target = (NodeEventTarget)e;
        EventListener l = new CursorMouseOverListener(ctx);
        target.addEventListenerNS
            (XMLConstants.XML_EVENTS_NAMESPACE_URI, SVG_EVENT_MOUSEOVER,
             l, false, null);
        ctx.storeEventListenerNS
            (target, XMLConstants.XML_EVENTS_NAMESPACE_URI, SVG_EVENT_MOUSEOVER,
             l, false);
    }
}

public void removeUIEventListeners(Document doc) {
    EventTarget evtTarget = (EventTarget)doc.getDocumentElement();
    synchronized (eventListenerSet) {
        Iterator i = eventListenerSet.iterator();
        while (i.hasNext()) {
            EventListenerMememto elm = (EventListenerMememto)i.next();
            NodeEventTarget et = elm.getTarget();
            if (et == evtTarget) {
                EventListener el = elm.getListener();
                boolean       uc = elm.getUseCapture();
                String        t  = elm.getEventType();
                boolean       n  = elm.getNamespaced();
                if (et == null || el == null || t == null) {
                    continue;
                }
                if (n) {
                    String ns = elm.getNamespaceURI();
                    et.removeEventListenerNS(ns, t, el, uc);
                } else {
                    et.removeEventListener(t, el, uc);
                }
            }
        }
    }
}

/**
 * Removes an event listener for mutations on the
 * CSSNavigableDocument tree.
 */
public void removeCSSNavigableDocumentListener
        (CSSNavigableDocumentListener l) {
    EventListener[] listeners
        = (EventListener[]) cssNavigableDocumentListeners.get(l);
    if (listeners == null) {
        return;
    }

    removeEventListenerNS(XMLConstants.XML_EVENTS_NAMESPACE_URI,
                          "DOMNodeInserted", listeners[0], false);
    removeEventListenerNS(XMLConstants.XML_EVENTS_NAMESPACE_URI,
                          "DOMNodeRemoved", listeners[1], false);
    removeEventListenerNS(XMLConstants.XML_EVENTS_NAMESPACE_URI,
                          "DOMSubtreeModified", listeners[2], false);
    removeEventListenerNS(XMLConstants.XML_EVENTS_NAMESPACE_URI,
                          "DOMCharacterDataModified", listeners[3], false);
    removeEventListenerNS(XMLConstants.XML_EVENTS_NAMESPACE_URI,
                          "DOMAttrModified", listeners[4], false);

    cssNavigableDocumentListeners.remove(l);
}

/**
 * <b>DOM</b>: Implements
 * {@link
 * NodeEventTarget#addEventListenerNS(String,String,EventListener,boolean,Object)}.
 */
public void addEventListenerNS(String namespaceURI,
                               String type,
                               EventListener listener,
                               boolean useCapture,
                               Object evtGroup) {
    if (eventSupport == null) {
        initializeEventSupport();
    }
    if (namespaceURI != null && namespaceURI.length() == 0) {
        namespaceURI = null;
    }
    eventSupport.addEventListenerNS(namespaceURI,
                                    type,
                                    listener,
                                    useCapture,
                                    evtGroup);
}

/**
 * Deregisters an event listener.
 */
public void removeEventListenerNS(String namespaceURI,
                                  String type,
                                  EventListener listener,
                                  boolean useCapture) {
    HashTable listeners;
    if (useCapture) {
        listeners = capturingListeners;
    } else {
        listeners = bubblingListeners;
    }
    if (listeners == null) {
        return;
    }
    EventListenerList list = (EventListenerList) listeners.get(type);
    if (list != null) {
        list.removeListener(namespaceURI, listener);
        if (list.size() == 0) {
            listeners.remove(type);
        }
    }
}

/**
 * Unregisters an implementation event listener.
 */
public void removeImplementationEventListenerNS(String namespaceURI,
                                                String type,
                                                EventListener listener,
                                                boolean useCapture) {
    HashTable listeners = useCapture ? capturingImplementationListeners
                                     : bubblingImplementationListeners;
    if (listeners == null) {
        return;
    }
    EventListenerList list = (EventListenerList) listeners.get(type);
    if (list == null) {
        return;
    }
    list.removeListener(namespaceURI, listener);
    if (list.size() == 0) {
        listeners.remove(type);
    }
}

public void documentLoadingCompleted(SVGDocumentLoaderEvent e) {
    NodeEventTarget root
        = (NodeEventTarget) e.getSVGDocument().getRootElement();
    root.addEventListenerNS
        (XMLConstants.XML_EVENTS_NAMESPACE_URI,
         SVGConstants.SVG_SVGZOOM_EVENT_TYPE,
         new EventListener() {
             public void handleEvent(Event evt) {
                 if (!(evt.getTarget() instanceof SVGSVGElement))
                     return;
                 // assert(evt.getType() ==
                 //        SVGConstants.SVG_SVGZOOM_EVENT_TYPE);
                 SVGSVGElement svg = (SVGSVGElement) evt.getTarget();
                 scaleChange(svg.getCurrentScale());
             } // handleEvent()
         }, false, null);
}

/**
 * Registers an event listener for the given namespaced event type
 * in the specified group.
 */
public void addEventListenerNS(String namespaceURI,
                               String type,
                               EventListener listener,
                               boolean useCapture,
                               Object group) {
    super.addEventListenerNS
        (namespaceURI, type, listener, useCapture, group);
    if (namespaceURI == null
            || namespaceURI.equals(XMLConstants.XML_EVENTS_NAMESPACE_URI)) {
        String alias = (String) eventTypeAliases.get(type);
        if (alias != null) {
            super.addEventListenerNS
                (namespaceURI, alias, listener, useCapture, group);
        }
    }
}

/**
 * Unregisters an implementation event listener.
 */
public void removeImplementationEventListenerNS(String namespaceURI,
                                                String type,
                                                EventListener listener,
                                                boolean useCapture) {
    HashTable listeners = useCapture ? capturingImplementationListeners
                                     : bubblingImplementationListeners;
    if (listeners == null) {
        return;
    }
    EventListenerList list = (EventListenerList) listeners.get(type);
    if (list == null) {
        return;
    }
    list.removeListener(namespaceURI, listener);
    if (list.size() == 0) {
        listeners.remove(type);
    }
}

/**
 * Removes an event listener for mutations on the
 * CSSNavigableDocument tree.
 */
public void removeCSSNavigableDocumentListener
        (CSSNavigableDocumentListener l) {
    EventListener[] listeners
        = (EventListener[]) cssNavigableDocumentListeners.get(l);
    if (listeners == null) {
        return;
    }

    removeEventListenerNS(XMLConstants.XML_EVENTS_NAMESPACE_URI,
                          "DOMNodeInserted", listeners[0], false);
    removeEventListenerNS(XMLConstants.XML_EVENTS_NAMESPACE_URI,
                          "DOMNodeRemoved", listeners[1], false);
    removeEventListenerNS(XMLConstants.XML_EVENTS_NAMESPACE_URI,
                          "DOMSubtreeModified", listeners[2], false);
    removeEventListenerNS(XMLConstants.XML_EVENTS_NAMESPACE_URI,
                          "DOMCharacterDataModified", listeners[3], false);
    removeEventListenerNS(XMLConstants.XML_EVENTS_NAMESPACE_URI,
                          "DOMAttrModified", listeners[4], false);

    cssNavigableDocumentListeners.remove(l);
}

/**
 * Registers an event listener that will not be stopped by the usual
 * XBL stopping.
 */
public void addImplementationEventListenerNS(String namespaceURI,
                                             String type,
                                             EventListener listener,
                                             boolean useCapture) {
    HashTable listeners;
    if (useCapture) {
        if (capturingImplementationListeners == null) {
            capturingImplementationListeners = new HashTable();
        }
        listeners = capturingImplementationListeners;
    } else {
        if (bubblingImplementationListeners == null) {
            bubblingImplementationListeners = new HashTable();
        }
        listeners = bubblingImplementationListeners;
    }
    EventListenerList list = (EventListenerList) listeners.get(type);
    if (list == null) {
        list = new EventListenerList();
        listeners.put(type, list);
    }
    list.addListener(namespaceURI, null, listener);
}

/**
 * Is called only for the root element in order to dispatch GVT
 * events to the DOM.
 */
public static void addGVTListener(BridgeContext ctx, Document doc) {
    UserAgent ua = ctx.getUserAgent();
    if (ua != null) {
        EventDispatcher dispatcher = ua.getEventDispatcher();
        if (dispatcher != null) {
            final Listener listener = new Listener(ctx, ua);
            dispatcher.addGraphicsNodeMouseListener(listener);
            dispatcher.addGraphicsNodeKeyListener(listener);
            // add an unload listener on the SVGDocument to remove
            // that listener for dispatching events
            EventListener l = new GVTUnloadListener(dispatcher, listener);
            NodeEventTarget target = (NodeEventTarget)doc;
            target.addEventListenerNS
                (XMLConstants.XML_EVENTS_NAMESPACE_URI,
                 "SVGUnload",
                 l, false, null);
            storeEventListenerNS
                (ctx, target,
                 XMLConstants.XML_EVENTS_NAMESPACE_URI,
                 "SVGUnload",
                 l, false);
        }
    }
}

/**
 * Is called only for the root element in order to dispatch GVT
 * events to the DOM.
 */
public static void addGVTListener(BridgeContext ctx, Document doc) {
    UserAgent ua = ctx.getUserAgent();
    if (ua != null) {
        EventDispatcher dispatcher = ua.getEventDispatcher();
        if (dispatcher != null) {
            final Listener listener = new Listener(ctx, ua);
            dispatcher.addGraphicsNodeMouseListener(listener);
            dispatcher.addGraphicsNodeMouseWheelListener(listener);
            dispatcher.addGraphicsNodeKeyListener(listener);
            // add an unload listener on the SVGDocument to remove
            // that listener for dispatching events
            EventListener l = new GVTUnloadListener(dispatcher, listener);
            NodeEventTarget target = (NodeEventTarget) doc;
            target.addEventListenerNS
                (XMLConstants.XML_EVENTS_NAMESPACE_URI,
                 "SVGUnload",
                 l, false, null);
            storeEventListenerNS
                (ctx, target,
                 XMLConstants.XML_EVENTS_NAMESPACE_URI,
                 "SVGUnload",
                 l, false);
        }
    }
}

/**
 * Registers an event listener for the given namespaced event type
 * in the specified group.
 */
public void addEventListenerNS(String namespaceURI,
                               String type,
                               EventListener listener,
                               boolean useCapture,
                               Object group) {
    super.addEventListenerNS
        (namespaceURI, type, listener, useCapture, group);
    if (namespaceURI == null
            || namespaceURI.equals(XMLConstants.XML_EVENTS_NAMESPACE_URI)) {
        String alias = (String) eventTypeAliases.get(type);
        if (alias != null) {
            super.addEventListenerNS
                (namespaceURI, alias, listener, useCapture, group);
        }
    }
}

/**
 * Builds using the specified BridgeContext and element, the
 * specified graphics node.
 *
 * @param ctx the bridge context to use
 * @param e the element that describes the graphics node to build
 * @param node the graphics node to build
 */
public void buildGraphicsNode(BridgeContext ctx,
                              Element e,
                              GraphicsNode node) {

    super.buildGraphicsNode(ctx, e, node);

    if (ctx.isInteractive()) {
        NodeEventTarget target = (NodeEventTarget)e;
        EventListener l = new CursorMouseOverListener(ctx);
        target.addEventListenerNS
            (XMLConstants.XML_EVENTS_NAMESPACE_URI, SVG_EVENT_MOUSEOVER,
             l, false, null);
        ctx.storeEventListenerNS
            (target, XMLConstants.XML_EVENTS_NAMESPACE_URI, SVG_EVENT_MOUSEOVER,
             l, false);
    }
}

public void removeUIEventListeners(Document doc) {
    EventTarget evtTarget = (EventTarget)doc.getDocumentElement();
    synchronized (eventListenerSet) {
        Iterator i = eventListenerSet.iterator();
        while (i.hasNext()) {
            EventListenerMememto elm = (EventListenerMememto)i.next();
            NodeEventTarget et = elm.getTarget();
            if (et == evtTarget) {
                EventListener el = elm.getListener();
                boolean       uc = elm.getUseCapture();
                String        t  = elm.getEventType();
                boolean       n  = elm.getNamespaced();
                if (et == null || el == null || t == null) {
                    continue;
                }
                if (n) {
                    String ns = elm.getNamespaceURI();
                    et.removeEventListenerNS(ns, t, el, uc);
                } else {
                    et.removeEventListener(t, el, uc);
                }
            }
        }
    }
}

/**
 * <b>DOM</b>: Implements
 * {@link
 * NodeEventTarget#addEventListenerNS(String,String,EventListener,boolean,Object)}.
 */
public void addEventListenerNS(String namespaceURI,
                               String type,
                               EventListener listener,
                               boolean useCapture,
                               Object evtGroup) {
    if (eventSupport == null) {
        initializeEventSupport();
    }
    if (namespaceURI != null && namespaceURI.length() == 0) {
        namespaceURI = null;
    }
    eventSupport.addEventListenerNS(namespaceURI,
                                    type,
                                    listener,
                                    useCapture,
                                    evtGroup);
}

public void addEventListener(String type, EventListener listener, boolean useCapture) {
    if ((type == null) || type.equals("") || (listener == null)) {
        return;
    }

    // Make sure we have only one entry
    removeEventListener(type, listener, useCapture);

    if (mListenerEntries == null) {
        mListenerEntries = new ArrayList<EventListenerEntry>();
    }
    mListenerEntries.add(new EventListenerEntry(type, listener, useCapture));
}

public void removeEventListener(String type, EventListener listener,
        boolean useCapture) {
    if (null == mListenerEntries) {
        return;
    }
    for (int i = 0; i < mListenerEntries.size(); i ++) {
        EventListenerEntry listenerEntry = mListenerEntries.get(i);
        if ((listenerEntry.mUseCapture == useCapture)
                && (listenerEntry.mListener == listener)
                && listenerEntry.mType.equals(type)) {
            mListenerEntries.remove(i);
            break;
        }
    }
}

/** NON-DOM INTERNAL: Constructor for Listener list Entry
 * @param type Event name (NOT event group!) to listen for.
 * @param listener Who gets called when event is dispatched
 * @param useCaptue True iff listener is registered on
 *  capturing phase rather than at-target or bubbling
 */
LEntry(String type, EventListener listener, boolean useCapture)
{
    this.type = type;
    this.listener = listener;
    this.useCapture = useCapture;
}

/**
 * Introduced in DOM Level 2. <p> Deregister an event listener previously
 * registered with this Node.  A listener must be independently removed
 * from the Capturing and Bubbling roles. Redundant removals (of listeners
 * not currently registered for this role) are ignored.
 * @param node node to remove listener from
 * @param type Event name (NOT event group!) to listen for.
 * @param listener Who gets called when event is dispatched
 * @param useCapture True iff listener is registered on
 *  capturing phase rather than at-target or bubbling
 */
protected void removeEventListener(NodeImpl node, String type,
                                   EventListener listener,
                                   boolean useCapture)
{
    // If this couldn't be a valid listener registration, ignore request
    if (type == null || type.equals("") || listener == null)
        return;
    Vector nodeListeners = getEventListeners(node);
    if (nodeListeners == null)
        return;

    // Note that addListener has previously ensured that
    // each listener may be registered only once per type per phase.
    // count-down is OK for deletions!
    for (int i = nodeListeners.size() - 1; i >= 0; --i) {
        LEntry le = (LEntry) nodeListeners.elementAt(i);
        if (le.useCapture == useCapture && le.listener == listener &&
            le.type.equals(type)) {
            nodeListeners.removeElementAt(i);
            // Storage management: Discard empty listener lists
            if (nodeListeners.size() == 0)
                setEventListeners(node, null);

            // Remove active listener
            LCount lc = LCount.lookup(type);
            if (useCapture) {
                --lc.captures;
                --lc.total;
            }
            else {
                --lc.bubbles;
                --lc.total;
            }

            break;  // Found it; no need to loop farther.
        }
    }
}

private void initHyperlinkListener() {
  myEngine.getLoadWorker().stateProperty().addListener((ov, oldState, newState) -> {
    if (newState == Worker.State.SUCCEEDED) {
      final EventListener listener = makeHyperLinkListener();

      addListenerToAllHyperlinkItems(listener);
    }
  });
}

private void addListenerToAllHyperlinkItems(EventListener listener) {
  final Document doc = myEngine.getDocument();
  if (doc != null) {
    final NodeList nodeList = doc.getElementsByTagName("a");
    for (int i = 0; i < nodeList.getLength(); i++) {
      ((EventTarget)nodeList.item(i)).addEventListener(EVENT_TYPE_CLICK, listener, false);
    }
  }
}