org.w3c.dom.events.Event Java Examples

private void addMouseHandler(final SvgEventSpec spec, final String eventType) {
  final EventListener listener = new EventListener() {
    @Override
    public void handleEvent(Event evt) {
      evt.stopPropagation();
      getSource().dispatch(spec, new MouseEvent(((DOMMouseEvent) evt).getClientX(), ((DOMMouseEvent) evt).getClientY()));
    }
  };
  getTarget().addEventListener(eventType, listener, false);
  myHandlerRegs.put(spec, new Registration() {
    @Override
    protected void doRemove() {
      getTarget().removeEventListener(eventType, listener, false);
    }
  });
}
 

/**
 * Dispatches event to the target node's descendents recursively
 *
 * @param n node to dispatch to
 * @param e event to be sent to that node and its subtree
 */
protected void dispatchingEventToSubtree(Node n, Event e) {
    if (n==null)
            return;

    // ***** Recursive implementation. This is excessively expensive,
    // and should be replaced in conjunction with optimization
    // mentioned above.
    ((NodeImpl) n).dispatchEvent(e);
    if (n.getNodeType() == Node.ELEMENT_NODE) {
        NamedNodeMap a = n.getAttributes();
        for (int i = a.getLength() - 1; i >= 0; --i)
            dispatchingEventToSubtree(a.item(i), e);
    }
    dispatchingEventToSubtree(n.getFirstChild(), e);
    dispatchingEventToSubtree(n.getNextSibling(), e);
}
 

public void handleEvent(final Event evt) {
    try {
        getLock().write(new Runnable() {
            public void run() {
                Document d = (Document)evt.getCurrentTarget();
                Document old = (Document)getValueNonBlocking();
                assert old == null || old == d;
                logger.log(Level.FINEST, "DomSupport got DOM event {0} on {1}, inIsolatingChange={2}", new Object[] {evt, ph, inIsolatingChange ? Boolean.TRUE : Boolean.FALSE});
                if (!inIsolatingChange) {
                    try {
                        setDocument(d);
                    } catch (IOException e) {
                        assert false : e;
                    }
                } else {
                    madeIsolatedChanges = true;
                }
            }
        });
    } catch (RuntimeException e) {
        // Xerces ignores them.
        e.printStackTrace();
    }
}
 

/**
 * Dispatches event to the target node's descendents recursively
 *
 * @param n node to dispatch to
 * @param e event to be sent to that node and its subtree
 */
protected void dispatchingEventToSubtree(Node n, Event e) {
    if (n==null)
            return;

    // ***** Recursive implementation. This is excessively expensive,
    // and should be replaced in conjunction with optimization
    // mentioned above.
    ((NodeImpl) n).dispatchEvent(e);
    if (n.getNodeType() == Node.ELEMENT_NODE) {
        NamedNodeMap a = n.getAttributes();
        for (int i = a.getLength() - 1; i >= 0; --i)
            dispatchingEventToSubtree(a.item(i), e);
    }
    dispatchingEventToSubtree(n.getFirstChild(), e);
    dispatchingEventToSubtree(n.getNextSibling(), e);
}
 

/**
 * Dispatches event to the target node's descendents recursively
 *
 * @param n node to dispatch to
 * @param e event to be sent to that node and its subtree
 */
protected void dispatchingEventToSubtree(Node n, Event e) {
    if (n==null)
            return;

    // ***** Recursive implementation. This is excessively expensive,
    // and should be replaced in conjunction with optimization
    // mentioned above.
    ((NodeImpl) n).dispatchEvent(e);
    if (n.getNodeType() == Node.ELEMENT_NODE) {
        NamedNodeMap a = n.getAttributes();
        for (int i = a.getLength() - 1; i >= 0; --i)
            dispatchingEventToSubtree(a.item(i), e);
    }
    dispatchingEventToSubtree(n.getFirstChild(), e);
    dispatchingEventToSubtree(n.getNextSibling(), e);
}
 

/**
 * Dispatches event to the target node's descendents recursively
 *
 * @param n node to dispatch to
 * @param e event to be sent to that node and its subtree
 */
protected void dispatchingEventToSubtree(Node n, Event e) {
    if (n==null)
            return;

    // ***** Recursive implementation. This is excessively expensive,
    // and should be replaced in conjunction with optimization
    // mentioned above.
    ((NodeImpl) n).dispatchEvent(e);
    if (n.getNodeType() == Node.ELEMENT_NODE) {
        NamedNodeMap a = n.getAttributes();
        for (int i = a.getLength() - 1; i >= 0; --i)
            dispatchingEventToSubtree(a.item(i), e);
    }
    dispatchingEventToSubtree(n.getFirstChild(), e);
    dispatchingEventToSubtree(n.getNextSibling(), e);
}
 

protected void clickLink() {
        EventListener listener = new EventListener() {
            public void handleEvent(Event ev) {
//                    ev.;
            }
        };
        Document doc = webEngine.getDocument();
        Element el = doc.getElementById("exit-app");
        ((EventTarget) el).addEventListener("click", listener, false);

        NodeList links = doc.getElementsByTagName("a");
        for (int i = 0; i < links.getLength(); ++i) {
//            Node node = links.item(i);
//            String link = links.item(i).toString();
//
//            EventListener listener = new EventListener() {
//                public void handleEvent(Event ev) {
////                    ev.;
//                }
//            };

        }
    }
 

/**
 * Dispatches event to the target node's descendents recursively
 *
 * @param n node to dispatch to
 * @param e event to be sent to that node and its subtree
 */
protected void dispatchingEventToSubtree(Node n, Event e) {
    if (n==null)
            return;

    // ***** Recursive implementation. This is excessively expensive,
    // and should be replaced in conjunction with optimization
    // mentioned above.
    ((NodeImpl) n).dispatchEvent(e);
    if (n.getNodeType() == Node.ELEMENT_NODE) {
        NamedNodeMap a = n.getAttributes();
        for (int i = a.getLength() - 1; i >= 0; --i)
            dispatchingEventToSubtree(a.item(i), e);
    }
    dispatchingEventToSubtree(n.getFirstChild(), e);
    dispatchingEventToSubtree(n.getNextSibling(), e);
}
 

/**
 * Dispatches event to the target node's descendents recursively
 *
 * @param n node to dispatch to
 * @param e event to be sent to that node and its subtree
 */
protected void dispatchingEventToSubtree(Node n, Event e) {
    if (n==null)
            return;

    // ***** Recursive implementation. This is excessively expensive,
    // and should be replaced in conjunction with optimization
    // mentioned above.
    ((NodeImpl) n).dispatchEvent(e);
    if (n.getNodeType() == Node.ELEMENT_NODE) {
        NamedNodeMap a = n.getAttributes();
        for (int i = a.getLength() - 1; i >= 0; --i)
            dispatchingEventToSubtree(a.item(i), e);
    }
    dispatchingEventToSubtree(n.getFirstChild(), e);
    dispatchingEventToSubtree(n.getNextSibling(), e);
}
 

/**
 * Dispatches event to the target node's descendents recursively
 *
 * @param n node to dispatch to
 * @param e event to be sent to that node and its subtree
 */
protected void dispatchingEventToSubtree(Node n, Event e) {
    if (n==null)
            return;

    // ***** Recursive implementation. This is excessively expensive,
    // and should be replaced in conjunction with optimization
    // mentioned above.
    ((NodeImpl) n).dispatchEvent(e);
    if (n.getNodeType() == Node.ELEMENT_NODE) {
        NamedNodeMap a = n.getAttributes();
        for (int i = a.getLength() - 1; i >= 0; --i)
            dispatchingEventToSubtree(a.item(i), e);
    }
    dispatchingEventToSubtree(n.getFirstChild(), e);
    dispatchingEventToSubtree(n.getNextSibling(), e);
}
 

/**
 * Dispatches event to the target node's descendents recursively
 *
 * @param n node to dispatch to
 * @param e event to be sent to that node and its subtree
 */
protected void dispatchingEventToSubtree(Node n, Event e) {
    if (n==null)
            return;

    // ***** Recursive implementation. This is excessively expensive,
    // and should be replaced in conjunction with optimization
    // mentioned above.
    ((NodeImpl) n).dispatchEvent(e);
    if (n.getNodeType() == Node.ELEMENT_NODE) {
        NamedNodeMap a = n.getAttributes();
        for (int i = a.getLength() - 1; i >= 0; --i)
            dispatchingEventToSubtree(a.item(i), e);
    }
    dispatchingEventToSubtree(n.getFirstChild(), e);
    dispatchingEventToSubtree(n.getNextSibling(), e);
}
 

/**
 * Dispatches event to the target node's descendents recursively
 *
 * @param n node to dispatch to
 * @param e event to be sent to that node and its subtree
 */
protected void dispatchingEventToSubtree(Node n, Event e) {
    if (n==null)
            return;

    // ***** Recursive implementation. This is excessively expensive,
    // and should be replaced in conjunction with optimization
    // mentioned above.
    ((NodeImpl) n).dispatchEvent(e);
    if (n.getNodeType() == Node.ELEMENT_NODE) {
        NamedNodeMap a = n.getAttributes();
        for (int i = a.getLength() - 1; i >= 0; --i)
            dispatchingEventToSubtree(a.item(i), e);
    }
    dispatchingEventToSubtree(n.getFirstChild(), e);
    dispatchingEventToSubtree(n.getNextSibling(), e);
}
 

/**
 * Dispatches event to the target node's descendents recursively
 *
 * @param n node to dispatch to
 * @param e event to be sent to that node and its subtree
 */
protected void dispatchingEventToSubtree(Node n, Event e) {
    if (n==null)
            return;

    // ***** Recursive implementation. This is excessively expensive,
    // and should be replaced in conjunction with optimization
    // mentioned above.
    ((NodeImpl) n).dispatchEvent(e);
    if (n.getNodeType() == Node.ELEMENT_NODE) {
        NamedNodeMap a = n.getAttributes();
        for (int i = a.getLength() - 1; i >= 0; --i)
            dispatchingEventToSubtree(a.item(i), e);
    }
    dispatchingEventToSubtree(n.getFirstChild(), e);
    dispatchingEventToSubtree(n.getNextSibling(), e);
}
 

/**
 * Dispatches event to the target node's descendents recursively
 *
 * @param n node to dispatch to
 * @param e event to be sent to that node and its subtree
 */
protected void dispatchingEventToSubtree(Node n, Event e) {
    if (n==null)
            return;

    // ***** Recursive implementation. This is excessively expensive,
    // and should be replaced in conjunction with optimization
    // mentioned above.
    ((NodeImpl) n).dispatchEvent(e);
    if (n.getNodeType() == Node.ELEMENT_NODE) {
        NamedNodeMap a = n.getAttributes();
        for (int i = a.getLength() - 1; i >= 0; --i)
            dispatchingEventToSubtree(a.item(i), e);
    }
    dispatchingEventToSubtree(n.getFirstChild(), e);
    dispatchingEventToSubtree(n.getNextSibling(), e);
}
 

@Override
public void handleEvent(Event event) {
    HTMLAnchorElement anchorElement = (HTMLAnchorElement) event.getCurrentTarget();
    String href = anchorElement.getHref();

    boolean done = false;
    try {
        if(Desktop.isDesktopSupported()) {
            openLinkInSystemBrowser(href);
            done = true;
        } else {
            LOGGER.warn("OS does not support desktop operations like browsing. Cannot open link '{}'.", href);
        }
    } catch(URISyntaxException | IOException e) {
        LOGGER.warn("OS does not support desktop operations like browsing. Failed open link '{}'.", href, e);
    }
    if(done) {
        event.preventDefault();
    }
}
 

public LocationAnnotator(final XMLReader xmlReader, final Document document) {
    super(xmlReader);

    final EventListener listener = new EventListener() {

        @Override
        public void handleEvent(final Event event) {
            final Node node = (Node) event.getTarget();
            if (node.getNodeType() == Node.ELEMENT_NODE) {
                domNodes.push(node);
            }
        }

    };

    ((EventTarget) document).addEventListener(DOM_NODE_INSERTED, listener, true);
}
 

/**
 * @see org.w3c.dom.events.EventListener#handleEvent(Event)
 */
public void handleEvent(Event event) {

        if (event.getType().equals("DOMSubtreeModified")) {
                // invalidate the iterator
                m_isInvalidIteratorState = true;

                // deregister as a listener to reduce computational load
                removeEventListener();
        }
}
 

/**
 * @see org.w3c.dom.events.EventListener#handleEvent(Event)
 */
public void handleEvent(Event event) {

        if (event.getType().equals("DOMSubtreeModified")) {
                // invalidate the iterator
                m_isInvalidIteratorState = true;

                // deregister as a listener to reduce computational load
                removeEventListener();
        }
}
 

@Override
public void handleEvent(Event event) {
    HTMLAnchorElement anchorElement = (HTMLAnchorElement) event.getCurrentTarget();
    String href = anchorElement.getHref();

    if (Desktop.isDesktopSupported()) {
        openLinkInSystemBrowser(href);
    } else {
        LOGGER.warning("OS does not support desktop operations like browsing. Cannot open link '{" + href + "}'.");
    }

    event.preventDefault();
}
 

public void handleEvent(Event evt) {
    // XXX for some reason, sometimes if refactoring is done while an XML phadhail is
    // expanded, some infinite loop occurs and this method is called repeatedly
    try {
        Element parent = (Element)evt.getCurrentTarget();
        if (logger.isLoggable(Level.FINER)) {
            logger.log(Level.FINER, "ElementLook: event on {0}: {1}; co={2}", new Object[] {parent.getTagName(), evt, getChildObjects(parent, null)});
        }
        fireChange(parent, Look.GET_CHILD_OBJECTS | Look.GET_DISPLAY_NAME);
    } catch (RuntimeException e) {
        e.printStackTrace();
    }
}
 

/**
 * @see org.w3c.dom.events.EventListener#handleEvent(Event)
 */
public void handleEvent(Event event) {

        if (event.getType().equals("DOMSubtreeModified")) {
                // invalidate the iterator
                m_isInvalidIteratorState = true;

                // deregister as a listener to reduce computational load
                removeEventListener();
        }
}
 

/**
 * @see org.w3c.dom.events.EventListener#handleEvent(Event)
 */
public void handleEvent(Event event) {

        if (event.getType().equals("DOMSubtreeModified")) {
                // invalidate the iterator
                m_isInvalidIteratorState = true;

                // deregister as a listener to reduce computational load
                removeEventListener();
        }
}
 

/**
 * @see org.w3c.dom.events.EventListener#handleEvent(Event)
 */
public void handleEvent(Event event) {

        if (event.getType().equals("DOMSubtreeModified")) {
                // invalidate the iterator
                m_isInvalidIteratorState = true;

                // deregister as a listener to reduce computational load
                removeEventListener();
        }
}
 

/**
 * @see org.w3c.dom.events.EventListener#handleEvent(Event)
 */
public void handleEvent(Event event) {

        if (event.getType().equals("DOMSubtreeModified")) {
                // invalidate the iterator
                m_isInvalidIteratorState = true;

                // deregister as a listener to reduce computational load
                removeEventListener();
        }
}
 

public XmlLocationAnnotator(XMLReader xmlReader, Document dom) {
    super(xmlReader);

    // Add listener to DOM, so we know which node was added.
    EventListener modListener = new EventListener() {
        @Override
        public void handleEvent(Event e) {
            EventTarget target = ((MutationEvent) e).getTarget();
            elementStack.push((Element) target);
        }
    };
    ((EventTarget) dom).addEventListener("DOMNodeInserted", modListener, true);
}
 

/**
 * @see org.w3c.dom.events.EventListener#handleEvent(Event)
 */
public void handleEvent(Event event) {

        if (event.getType().equals("DOMSubtreeModified")) {
                // invalidate the iterator
                m_isInvalidIteratorState = true;

                // deregister as a listener to reduce computational load
                removeEventListener();
        }
}
 

public XmlLocationAnnotator(XMLReader xmlReader, Document dom) {
    super(xmlReader);

    // Add listener to DOM, so we know which node was added.
    EventListener modListener = new EventListener() {
        @Override
        public void handleEvent(Event e) {
            EventTarget target = ((MutationEvent) e).getTarget();
            elementStack.push((Element) target);
        }
    };
    ((EventTarget) dom).addEventListener("DOMNodeInserted", modListener, true);
}
 

public XmlLocationAnnotator(XMLReader xmlReader, Document dom) {
    super(xmlReader);

    // Add listener to DOM, so we know which node was added.
    EventListener modListener = new EventListener() {
        @Override
        public void handleEvent(Event e) {
            EventTarget target = ((MutationEvent) e).getTarget();
            elementStack.push((Element) target);
        }
    };
    ((EventTarget) dom).addEventListener("DOMNodeInserted", modListener, true);
}
 

public XmlLocationAnnotator(XMLReader xmlReader, Document dom) {
    super(xmlReader);

    // Add listener to DOM, so we know which node was added.
    EventListener modListener = new EventListener() {
        @Override
        public void handleEvent(Event e) {
            EventTarget target = ((MutationEvent) e).getTarget();
            elementStack.push((Element) target);
        }
    };
    ((EventTarget) dom).addEventListener("DOMNodeInserted", modListener, true);
}
 

/**
 * @see org.w3c.dom.events.EventListener#handleEvent(Event)
 */
public void handleEvent(Event event) {

        if (event.getType().equals("DOMSubtreeModified")) {
                // invalidate the iterator
                m_isInvalidIteratorState = true;

                // deregister as a listener to reduce computational load
                removeEventListener();
        }
}