Stop listening to an event.

@param eventDefinition
@param eventListener
16647
public void unregister(EventDefinition eventDefinition, IEventListener eventListener) {
        if (eventDefinition.getType() == EventDefinition.TYPE_POST) {
            unregister(listenersPost, eventDefinition, eventListener);
        } else {
            unregister(listeners, eventDefinition, eventListener);
        }
    }
137661
public void cancel(final String eventName) {

        BurstEvent oe = m_memory.remove(eventName);
        if (oe != null) {
            // disable the old event.
            oe.getTimer().cancel();
        }
    }
179986
public void register(EventDefinition eventDefinition, IEventListener listener) {
        if (eventDefinition.getType() == EventDefinition.TYPE_POST) {
            register(listenersPost, eventDefinition, listener, true);
        } else {
            register(listeners, eventDefinition, listener, false);
        }
    }
840552
synchronized void deleteListener(final AbstractEventListener<?> listener) {
        final String eventType = listener.getEventType();
        if (null == eventType) {
            throw new NullPointerException();
        }

        final List<AbstractEventListener<?>> listenerList = listeners.get(eventType);
        if (null != listenerList) {
            listenerList.remove(listener);
        }
    }
1020672
public void removeUserEventListener(UserEventListener listener)
   {
      SecurityHelper.validateSecurityPermission(PermissionConstants.MANAGE_LISTENERS);
      listeners.remove(listener);
   }
922612
function(event, handler) {
    return events.off({
      listeners: this._listeners,
      event: event,
      handler: handler
    });
  }
705094
public synchronized void removeEventListener(EventListener listener)
    {
        if (_sessionManager != null)
            _sessionManager.removeEventListener(listener);

        _sessionListeners= LazyList.remove(_sessionListeners, listener);
        _requestListeners= LazyList.remove(_requestListeners, listener);
        _requestAttributeListeners= LazyList.remove(_requestAttributeListeners, listener);
        _contextAttributeListeners= LazyList.remove(_contextAttributeListeners, listener);
        super.removeEventListener(listener);
    }
573717
public void consumeEvents(Listener listener)
    {
        while (!isEmpty()) {
            Event event = remove();
            event.eventType.fireEvent(listener, event.eventParameters);
        }
    }
275138
public void notifyListeners (DEvent event)
    {
        if (_listeners == null) {
            return;
        }

        for (int ii = 0, ll = _listeners.length; ii < ll; ii++) {
            Object listener = _listeners[ii];
            if (listener == null) {
                continue;
            }
            if (listener instanceof WeakReference<?>) {
                if ((listener = ((WeakReference<?>)listener).get()) == null) {
                    _listeners[ii] = null;
                    continue;
                }
            }

            try {
                // do any event specific notifications
                event.notifyListener(listener);

                // and notify them if they are listening for all events
                if (listener instanceof EventListener) {
                    ((EventListener)listener).eventReceived(event);
                }

            } catch (Exception e) {
                log.warning("Listener choked during notification", "list", listener,
                            "event", event, e);
            }
        }
    }
1027133
public void stopListeners(String stoppingJ2eename) {
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
            LoggingUtil.SESSION_LOGGER_CORE.entering(methodClassName, methodNames[STOP_LISTENERS], "stopListeners for " + stoppingJ2eename);
        }

        if (stoppingJ2eename != null) { // should never be null, but make sure
            // do mHttpSessionListeners first
            if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
                LoggingUtil.SESSION_LOGGER_CORE.logp(Level.FINE, methodClassName, methodNames[STOP_LISTENERS],
                                                     "mHttpSessListenersJ2eeNames.size is " + mHttpSessionListenersJ2eeNames.size());
            }
            synchronized (mHttpSessionListeners) {
                for (int x = mHttpSessionListenersJ2eeNames.size() - 1; x >= 0; x--) {
                    String listenerJ2eeName = (String) mHttpSessionListenersJ2eeNames.get(x);
                    if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
                        LoggingUtil.SESSION_LOGGER_CORE.logp(Level.FINE, methodClassName, methodNames[STOP_LISTENERS], "listenerJ2eeName is " + listenerJ2eeName);
                    }
                    if (stoppingJ2eename.equals(listenerJ2eeName)) {
                        mHttpSessionListeners.remove(x);
                        mHttpSessionListenersJ2eeNames.remove(x);
                    }
                    if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
                        LoggingUtil.SESSION_LOGGER_CORE.logp(Level.FINE, methodClassName, methodNames[STOP_LISTENERS], "stopping http session listener for: " + stoppingJ2eename);
                    }
                }
                if (mHttpSessionListeners.size() == 0) {
                    sessionListener = false;
                    _coreHttpSessionManager.getIStore().setHttpSessionListener(false);
                    if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
                        LoggingUtil.SESSION_LOGGER_CORE.logp(Level.FINE, methodClassName, methodNames[STOP_LISTENERS], "stopped all http session listeners");
                    }
                }
                if (wasHttpSessionObserver.getDoesContainIBMSessionListener()) {
                    // if we used to contain an IBMSessionListener, checking remaining
                    // listeners to see if we need to update the boolean
                    boolean mIBMSessionListenerImplemented = isIBMSessionListenerImplemented(mHttpSessionListeners);
                    if (!mIBMSessionListenerImplemented) {
                        wasHttpSessionObserver.setDoesContainIBMSessionListener(false);
                    }
                }
            }
            // now do mHttpSessionAttributeListeners

            for (int x = mHttpSessionAttributeListenersJ2eeNames.size() - 1; x >= 0; x--) {
                String listenerJ2eeName = (String) mHttpSessionAttributeListenersJ2eeNames.get(x);
                if (stoppingJ2eename.equals(listenerJ2eeName)) {
                    mHttpSessionAttributeListeners.remove(x);
                    mHttpSessionAttributeListenersJ2eeNames.remove(x);
                    if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
                        LoggingUtil.SESSION_LOGGER_CORE.logp(Level.FINE, methodClassName, methodNames[STOP_LISTENERS], "stopping http session attribute listener for: "
                                                                                                                       + stoppingJ2eename);
                    }
                }
            }
            if (mHttpSessionAttributeListeners.size() == 0) {
                sessionAttributeListener = false;
                if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
                    LoggingUtil.SESSION_LOGGER_CORE.logp(Level.FINE, methodClassName, methodNames[STOP_LISTENERS], "stopped all http session attribute listeners");
                }
            }
        }

        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
            LoggingUtil.SESSION_LOGGER_CORE.exiting(methodClassName, methodNames[STOP_LISTENERS]);
        }
    }
1365259
function removeEventListener(el, eventName, handler) {
    if (window.jQuery) {
      $(el).off(eventName, handler);
    } else if (el.removeEventListener) {
      el.removeEventListener(eventName, handler);
    } else {
      el.detachEvent('on' + eventName, handler);
    }
  }
734205
private void removeListeners( final RTDataEvents event )
  {
    removeEventListener( new Predicate()
    {
      @Override
      public boolean test( RTSubscription subscription )
      {
        return isEventSubscription( subscription, event );
      }
    } );
  }
49863
public <T> boolean remove(Class<T> eventClass, Listener<T> listener) {
        return remove(eventClass, listener, HIDDEN_STATION);
    }
830921
function(event_name) {

		if ((event_name in this._dom_event_support) && this._dom_event_support[event_name].delegation) {

			Firestorm.Element.removeDelegation(window, event_name, '*', this._event_listeners[event_name]);

		} else {

			Firestorm.Element.removeListener(window, event_name, this._event_listeners[event_name]);

		}

	}
217749
@Override
	public void unsubscribeFromEvent(EventListener eventListener, Class<? extends AbstractTaskEvent> eventType) {
		this.eventHandler.unsubscribeFromEvent(eventListener, eventType);
	}
1288795
protected final <T extends EventListener> void removeListener(Class<T> listenerType, T listener) {
		if (this.listeners != null) {
			this.listeners.remove(listenerType, listener);
			if (this.listeners.isEmpty()) {
				this.listeners = null;
			}
		}
	}
212940
function disableEventListeners() {
  if (this.state.eventsEnabled) {
    if (window.cancelAnimationFrame) {
      cancelAnimationFrame(this.scheduleUpdate);
    }
    this.state = removeEventListeners(this.reference, this.state);
  }
}