/** * 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); }
/** * 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); }
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); } } }
