Remove all event listeners

@param string $eventName

@return void
334013
public function removeListeners(string $eventName): void
    {
        foreach ($this->dispatcher->getListeners($eventName) as $listener) {
            $this->removeListener($eventName, $listener);
        }
    }
1076349
public function handleEvent( $eventName )
	{
		$counter	= 0;
		if( !array_key_exists( $eventName, $this->callbacks ) )
			return $counter;
		foreach( $this->callbacks[$eventName] as $callback )
		{
			extract( $callback );
			$factory	= new Alg_Object_MethodFactory;												//  build a new Method Factory
			$factory->callObjectMethod( $object, $methodName, $methodParameters );
			$counter++;																				//  increase Callback Counter
			$this->counter++;																		//  increase total Callback Counter
		}
		return $counter;
	}
496195
public function removeListener($event_name, callable $listener)
    {
        // Read in our config/events file so that we have them all!
        if (! $this->have_read_from_file)
        {
            $this->readConfigFile();
        }

        if (! isset($this->listeners[$event_name]))
        {
            return false;
        }

        foreach ($this->listeners[$event_name][2] as $index => $check)
        {
            if ($check === $listener)
            {
                unset($this->listeners[$event_name][1][$index]);
                unset($this->listeners[$event_name][2][$index]);

                return true;
            }
        }

        return false;
    }
52201
public function removeListener($name)
    {
        $listeners = $this->getConfig('listeners');
        if (!array_key_exists($name, $listeners)) {
            return false;
        }

        if (isset($this->_listenerInstances[$name])) {
            $this->_eventManager->off($this->_listenerInstances[$name]);
            unset($this->_listenerInstances[$name]);
        }

        unset($listeners[$name]);
        $this->_config['listeners'] = $listeners;
    }
28675
public function removeAllListeners($event_name = null) {
	        if (!is_null($event_name)) {
	            unset($this->listeners[$event_name]);
	        } else {
	            $this->listeners = array();
	        }
	    }
46008
protected function emitWithoutCancellingPropagationCheck(string $eventName, array $arguments = []): void
    {
        foreach ($this->getEventSubscribers($eventName) as $subscriber) {
            call_user_func_array($subscriber, $arguments);
        }
    }
394500
function off(eventName, handler, context, args, once) {
    if (!this.__listeners || !this.__listeners[eventName]) {
        return;
    }
    this
        .getListeners(eventName, handler, context, args, once)
        .forEach((config) => {
            this.__listeners[eventName].splice(this.__listeners[eventName].indexOf(config), 1);
        });

}
359492
private function markBeginningOrEndOfTheBackground($eventName)
    {
        if (BackgroundTested::BEFORE === $eventName) {
            $this->inBackground = true;
        }

        if (BackgroundTested::AFTER === $eventName) {
            $this->inBackground = false;
        }
    }
389628
private function sortListeners($eventName)
    {
        $this->sorted[$eventName] = array();

        if (isset($this->listeners[$eventName])) {
            krsort($this->listeners[$eventName]);
            $this->sorted[$eventName] = call_user_func_array('array_merge', $this->listeners[$eventName]);
        }
    }
663359
public function removeEventListener($eventName, $listener)
    {
        if (!$this->dispatcher) {
            $this->dispatcher = new EventDispatcher();
        }

        $this->dispatcher->removeListener($eventName, $listener);

        return $this;
    }
213846
public function removeListener(string $eventName, callable $listener): bool
    {
        // If it ends with a wildcard, we use the wildcardListeners array
        if ('*' === $eventName[\strlen($eventName) - 1]) {
            $eventName = \substr($eventName, 0, -1);
            $listeners = &$this->wildcardListeners;
        } else {
            $listeners = &$this->listeners;
        }

        if (!isset($listeners[$eventName])) {
            return false;
        }

        foreach ($listeners[$eventName] as $index => $check) {
            if ($check[1] === $listener) {
                // Remove listener
                unset($listeners[$eventName][$index]);
                // Reset index
                $this->listenerIndex = [];

                return true;
            }
        }

        return false;
    }
812334
public function disable()
    {
        if (!$this->enabled) {
            return;
        }
        $this->enabled = false;
        if ($this->ev instanceof \Event) {
            $this->ev->del();
        } elseif ($this->ev instanceof \EventListener) {
            $this->ev->disable();
        }
    }
332915
public function hasListeners(string $eventName) : bool
    {
        return isset($this->events[$eventName]) && count($this->events[$eventName]) > 0;
    }
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]);

		}

	}
508999
function removeEvent(target, name, callback, capture) {
      if (target.removeEventListener) {
        target.removeEventListener(name, callback, capture || false);
      } else if (target.detachEvent) {
        target.detachEvent('on' + name, callback);
      }
    }
1085170
protected function lazyLoad($eventName)
    {
        parent::lazyLoad($eventName);

        if (isset($this->listenerIds[$eventName])) {
            foreach ($this->listenerIds[$eventName] as $args) {
                list($serviceId, $method, $priority, $queueName) = $args;
                if ($queueName != null) {
                    $listener = $this->container->get($serviceId);
                    $key = $serviceId.'.'.$method;
                    $this->listeners[$eventName][$key] = array($listener, $queueName);
                }
            }
        }
    }
601024
public function removeListener($event, $callback)
    {
        if (false === isset($this->listeners[$event])) {

            return;
        }

        $key = array_search($callback, $this->listeners[$event]);
        if ($key !== false) {
            unset($this->listeners[$event][$key]);

            if (0 === count($this->listeners[$event])) {
                unset($this->listeners[$event]);
            }
        }
    }