org.w3c.dom.events.EventListener Java Examples

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.;
//                }
//            };

        }
    }
 

/**
 * Introduced in DOM Level 2. <p> Register an event listener with this
 * Node. A listener may be independently registered as both Capturing and
 * Bubbling, but may only be registered once per role; redundant
 * registrations are ignored.
 * @param node node to add listener to
 * @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
 */
@Override
protected void addEventListener(NodeImpl node, String type,
                                EventListener listener, boolean useCapture)
{
    // We can't dispatch to blank type-name, and of course we need
    // a listener to dispatch to
    if (type == null || type.equals("") || listener == null)
        return;

    // Each listener may be registered only once per type per phase.
    // Simplest way to code that is to zap the previous entry, if any.
    removeEventListener(node, type, listener, useCapture);

    List<LEntry> nodeListeners = getEventListeners(node);
    if(nodeListeners == null) {
        nodeListeners = new ArrayList<>();
        setEventListeners(node, nodeListeners);
    }
    nodeListeners.add(new LEntry(type, listener, useCapture));

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

}
 

/**
 * 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
 */
@Override
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;
    List<LEntry> 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 = nodeListeners.get(i);
        if (le.useCapture == useCapture && le.listener == listener &&
            le.type.equals(type)) {
            nodeListeners.remove(i);
            // Storage management: Discard empty listener lists
            if (nodeListeners.isEmpty())
                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.
        }
    }
}
 

/**
 * Introduced in DOM Level 2. <p> Register an event listener with this
 * Node. A listener may be independently registered as both Capturing and
 * Bubbling, but may only be registered once per role; redundant
 * registrations are ignored.
 * @param node node to add listener to
 * @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
 */
@Override
protected void addEventListener(NodeImpl node, String type,
                                EventListener listener, boolean useCapture)
{
    // We can't dispatch to blank type-name, and of course we need
    // a listener to dispatch to
    if (type == null || type.equals("") || listener == null)
        return;

    // Each listener may be registered only once per type per phase.
    // Simplest way to code that is to zap the previous entry, if any.
    removeEventListener(node, type, listener, useCapture);

    List<LEntry> nodeListeners = getEventListeners(node);
    if(nodeListeners == null) {
        nodeListeners = new ArrayList<>();
        setEventListeners(node, nodeListeners);
    }
    nodeListeners.add(new LEntry(type, listener, useCapture));

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

}
 

/**
 * Introduced in DOM Level 2. <p> Register an event listener with this
 * Node. A listener may be independently registered as both Capturing and
 * Bubbling, but may only be registered once per role; redundant
 * registrations are ignored.
 * @param node node to add listener to
 * @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
 */
@Override
protected void addEventListener(NodeImpl node, String type,
                                EventListener listener, boolean useCapture)
{
    // We can't dispatch to blank type-name, and of course we need
    // a listener to dispatch to
    if (type == null || type.equals("") || listener == null)
        return;

    // Each listener may be registered only once per type per phase.
    // Simplest way to code that is to zap the previous entry, if any.
    removeEventListener(node, type, listener, useCapture);

    List<LEntry> nodeListeners = getEventListeners(node);
    if(nodeListeners == null) {
        nodeListeners = new ArrayList<>();
        setEventListeners(node, nodeListeners);
    }
    nodeListeners.add(new LEntry(type, listener, useCapture));

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

}
 

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

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

/** 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> Register an event listener with this
 * Node. A listener may be independently registered as both Capturing and
 * Bubbling, but may only be registered once per role; redundant
 * registrations are ignored.
 * @param node node to add listener to
 * @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
 */
@Override
protected void addEventListener(NodeImpl node, String type,
                                EventListener listener, boolean useCapture)
{
    // We can't dispatch to blank type-name, and of course we need
    // a listener to dispatch to
    if (type == null || type.equals("") || listener == null)
        return;

    // Each listener may be registered only once per type per phase.
    // Simplest way to code that is to zap the previous entry, if any.
    removeEventListener(node, type, listener, useCapture);

    List<LEntry> nodeListeners = getEventListeners(node);
    if(nodeListeners == null) {
        nodeListeners = new ArrayList<>();
        setEventListeners(node, nodeListeners);
    }
    nodeListeners.add(new LEntry(type, listener, useCapture));

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

}
 

/**
 * 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
 */
@Override
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;
    List<LEntry> 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 = nodeListeners.get(i);
        if (le.useCapture == useCapture && le.listener == listener &&
            le.type.equals(type)) {
            nodeListeners.remove(i);
            // Storage management: Discard empty listener lists
            if (nodeListeners.isEmpty())
                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.
        }
    }
}
 

/** 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> Register an event listener with this
 * Node. A listener may be independently registered as both Capturing and
 * Bubbling, but may only be registered once per role; redundant
 * registrations are ignored.
 * @param node node to add listener to
 * @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
 */
@Override
protected void addEventListener(NodeImpl node, String type,
                                EventListener listener, boolean useCapture)
{
    // We can't dispatch to blank type-name, and of course we need
    // a listener to dispatch to
    if (type == null || type.equals("") || listener == null)
        return;

    // Each listener may be registered only once per type per phase.
    // Simplest way to code that is to zap the previous entry, if any.
    removeEventListener(node, type, listener, useCapture);

    List<LEntry> nodeListeners = getEventListeners(node);
    if(nodeListeners == null) {
        nodeListeners = new ArrayList<>();
        setEventListeners(node, nodeListeners);
    }
    nodeListeners.add(new LEntry(type, listener, useCapture));

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

}
 

/**
 * 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
 */
@Override
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;
    List<LEntry> 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 = nodeListeners.get(i);
        if (le.useCapture == useCapture && le.listener == listener &&
            le.type.equals(type)) {
            nodeListeners.remove(i);
            // Storage management: Discard empty listener lists
            if (nodeListeners.isEmpty())
                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.
        }
    }
}
 

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

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

/**
 * 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
 */
@Override
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;
    List<LEntry> 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 = nodeListeners.get(i);
        if (le.useCapture == useCapture && le.listener == listener &&
            le.type.equals(type)) {
            nodeListeners.remove(i);
            // Storage management: Discard empty listener lists
            if (nodeListeners.isEmpty())
                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.
        }
    }
}
 

/** 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> Register an event listener with this
 * Node. A listener may be independently registered as both Capturing and
 * Bubbling, but may only be registered once per role; redundant
 * registrations are ignored.
 * @param node node to add listener to
 * @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
 */
@Override
protected void addEventListener(NodeImpl node, String type,
                                EventListener listener, boolean useCapture)
{
    // We can't dispatch to blank type-name, and of course we need
    // a listener to dispatch to
    if (type == null || type.equals("") || listener == null)
        return;

    // Each listener may be registered only once per type per phase.
    // Simplest way to code that is to zap the previous entry, if any.
    removeEventListener(node, type, listener, useCapture);

    List<LEntry> nodeListeners = getEventListeners(node);
    if(nodeListeners == null) {
        nodeListeners = new ArrayList<>();
        setEventListeners(node, nodeListeners);
    }
    nodeListeners.add(new LEntry(type, listener, useCapture));

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

}
 

/**
 * 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
 */
@Override
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;
    List<LEntry> 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 = nodeListeners.get(i);
        if (le.useCapture == useCapture && le.listener == listener &&
            le.type.equals(type)) {
            nodeListeners.remove(i);
            // Storage management: Discard empty listener lists
            if (nodeListeners.isEmpty())
                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.
        }
    }
}
 

/** 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> Register an event listener with this
 * Node. A listener may be independently registered as both Capturing and
 * Bubbling, but may only be registered once per role; redundant
 * registrations are ignored.
 * @param node node to add listener to
 * @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
 */
@Override
protected void addEventListener(NodeImpl node, String type,
                                EventListener listener, boolean useCapture)
{
    // We can't dispatch to blank type-name, and of course we need
    // a listener to dispatch to
    if (type == null || type.equals("") || listener == null)
        return;

    // Each listener may be registered only once per type per phase.
    // Simplest way to code that is to zap the previous entry, if any.
    removeEventListener(node, type, listener, useCapture);

    List<LEntry> nodeListeners = getEventListeners(node);
    if(nodeListeners == null) {
        nodeListeners = new ArrayList<>();
        setEventListeners(node, nodeListeners);
    }
    nodeListeners.add(new LEntry(type, listener, useCapture));

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

}
 

/**
 * 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
 */
@Override
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;
    List<LEntry> 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 = nodeListeners.get(i);
        if (le.useCapture == useCapture && le.listener == listener &&
            le.type.equals(type)) {
            nodeListeners.remove(i);
            // Storage management: Discard empty listener lists
            if (nodeListeners.isEmpty())
                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.
        }
    }
}
 

/** 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> Register an event listener with this
 * Node. A listener may be independently registered as both Capturing and
 * Bubbling, but may only be registered once per role; redundant
 * registrations are ignored.
 * @param node node to add listener to
 * @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
 */
@Override
protected void addEventListener(NodeImpl node, String type,
                                EventListener listener, boolean useCapture)
{
    // We can't dispatch to blank type-name, and of course we need
    // a listener to dispatch to
    if (type == null || type.equals("") || listener == null)
        return;

    // Each listener may be registered only once per type per phase.
    // Simplest way to code that is to zap the previous entry, if any.
    removeEventListener(node, type, listener, useCapture);

    List<LEntry> nodeListeners = getEventListeners(node);
    if(nodeListeners == null) {
        nodeListeners = new ArrayList<>();
        setEventListeners(node, nodeListeners);
    }
    nodeListeners.add(new LEntry(type, listener, useCapture));

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

}
 

/**
 * 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
 */
@Override
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;
    List<LEntry> 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 = nodeListeners.get(i);
        if (le.useCapture == useCapture && le.listener == listener &&
            le.type.equals(type)) {
            nodeListeners.remove(i);
            // Storage management: Discard empty listener lists
            if (nodeListeners.isEmpty())
                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.
        }
    }
}
 

/** 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.
        }
    }
}
 

/** 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.
        }
    }
}