Remove a touch listener for the button specified by {@code name}.
@param name The {@linkplain Widget#getName() name} of the button to listen to
@param listener A valid listener or null to clear
558749
public boolean removeControlListener(String name, Widget.OnTouchListener listener) {
        Widget control = findChildByName(name);
        if (control != null) {
            return control.removeTouchListener(listener);
        }
        return 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);
        }
    }
349923
public function removeEventListener($name, AnObjectHandlable $listener)
    {
        if (is_object($listener)) {
            if (isset($this->_listeners[$name])) {
                $this->_listeners[$name]->dequeue($listener);
            }
        }
        
        return $this;
    }
1020584
def off(self, name, callback, once=False):
        

        if name not in self.event_listeners:
            return

        self.event_listeners[name].remove((callback, once))
611364
public void removeScrollListener(@NonNull final ScrollListener listener) {
        Condition.INSTANCE.ensureNotNull(listener, "The listener may not be null");
        this.scrollListeners.remove(listener);
    }
938450
public void removeConfigurationListener(NodeConfigListener listener) {
        StanzaListener conListener = configEventToListenerMap .remove(listener);

        if (conListener != null)
            pubSubManager.getConnection().removeSyncStanzaListener(conListener);
    }
869012
<T> boolean remove(Class<T> eventClass, Listener<T> listener) {
		lock.readLock().lock();
		TreeSet<ListenerReferenceHolder> set = listeners.get(eventClass);
		if (set != null) {
			lock.readLock().unlock();
			lock.writeLock().lock();
			try {
				DefaultListenerWrapper wrapper = new DefaultListenerWrapper(listener);
				for (ListenerReferenceHolder current : set) {
					if (wrapper.equals(current.getListenerWrapper())) {
						return removeListenerAndSetIfNeeded(eventClass, current, set);
					}
				}
				return false;
			} finally {
				lock.writeLock().unlock();
			}
		}
		lock.readLock().unlock();
		return false;
	}
1260488
public final void removeLayerListener(MapLayerListener listener) {
		if (this.listeners != null) {
			this.listeners.remove(MapLayerListener.class, listener);
			if (this.listeners.isEmpty()) {
				this.listeners = null;
			}
		}
	}
1154826
public void removeListener(ILabelProviderListener listener)
	{
		if (fListeners != null)
		{
			fListeners.remove(listener);
			if (fListeners.isEmpty() && fProblemChangedListener != null)
			{
				VdmUIPlugin.getDefault()
						.getProblemMarkerManager()
						.removeListener(fProblemChangedListener);
				fProblemChangedListener = null;
			}
		}
	}
1122316
public void removeReferenceListener(ReferenceListener listener) {
		final List<ReferenceListener> list = this.listeners;
		if (list != null) {
			synchronized (list) {
				list.remove(listener);
				if (list.isEmpty()) {
					this.listeners = null;
				}
			}
		}
	}
417775
@Override
    public void removeAppender(String name) {
        if (name == null || aai == null) {
            return;
        }
        Appender appender = aai.getAppender(name);
        aai.removeAppender(name);
        if (appender != null) {
            fireRemoveAppenderEvent(appender);
        }
    }
582549
public void remove(Object listener) {
		checkListenerType(listener);
		synchronized (this) {
			if (listeners == EMPTY_OBJECT_ARRAY)
				return;

			int listenersLength = listeners.length;
			int index = 0;
			for (; index < listenersLength; index++) {
				if (listeners[index] == listener) {
					break;
				}
			}
			if (index < listenersLength) {
				if (listenersLength == 1) {
					listeners = EMPTY_OBJECT_ARRAY;
				}
				else {
					Object[] tmp = new Object[listenersLength - 1];
					System.arraycopy(listeners, 0, tmp, 0, index);
					if (index < tmp.length) {
						System.arraycopy(listeners, index + 1, tmp, index, tmp.length - index);
					}
					listeners = tmp;
				}
			}
		}
	}
1152026
public void removeLifeCycleListener(EventListener listener) {
        if (listener != null) {
            if (listener instanceof javax.servlet.ServletContextListener) {
                // add to the context listener list
                servletContextListeners.remove(listener);
            }
            if (listener instanceof javax.servlet.ServletContextAttributeListener) {
                // add to the context attr listener list
                servletContextLAttrListeners.remove(listener);
            }

            if (listener instanceof javax.servlet.http.HttpSessionListener) {
                // session context currently has no way to remove
                // lifecycle listeners
            }
            
            // For Servlet 3.1 need to ensure we check to see if it is a HttpSessionIdListener
            if (isHttpSessionIdListener(listener)) {
                // session context currently has no way to remove lifecycle listener
            }

            // 2.4 Listeners
            if (listener instanceof javax.servlet.ServletRequestListener) {
                servletRequestListeners.remove(listener);
            }
            if (listener instanceof javax.servlet.ServletRequestAttributeListener) {
                servletRequestLAttrListeners.remove(listener);
            }
        }
    }
169977
function(obj, name, callback) {
      var listeners = this._listeners;
      if (!listeners) return this;
      var deleteListener = !name && !callback;
      if (typeof name === 'object') callback = this;
      if (obj) (listeners = {})[obj._listenerId] = obj;
      for (var id in listeners) {
        listeners[id].off(name, callback, this);
        if (deleteListener) delete this._listeners[id];
      }
      return this;
    }
980918
public synchronized void removeEventListener(EventListener listener)
    {
        _contextListeners= LazyList.remove(_contextListeners, listener);
        super.removeEventListener(listener);
    }
544056
public void removeCmsEventListener(I_CmsEventListener listener) {

        synchronized (m_eventListeners) {
            Iterator<Integer> it = m_eventListeners.keySet().iterator();
            while (it.hasNext()) {
                List<I_CmsEventListener> listeners = m_eventListeners.get(it.next());
                listeners.remove(listener);
            }
        }
    }
1151532
public function removeListener($eventName, $listener)
    {
        if (!isset($this->listeners[$eventName])) {
            return false;
        }

        // removing listeners for a given event
        foreach ($this->listeners[$eventName] as $i => $callback) {
            if ($listener === $callback) {
                unset($this->listeners[$eventName][$i]);
            }
        }

        // cleaning listener container if there is not more listeners on it
        if (count($this->listeners[$eventName]) == 0) {
            unset($this->listeners[$eventName]);
        }
    }