Fonction finale pour désactiver un événement

@param string $event_name

@return \FreeFW\EventManager
551485
final public function deRegisterEvent($event_name)
    {
        if (isset($this->listeners[$event_name])) {
            unset($this->listeners[$event_name]);
        }
        return $this;
    }
1136594
function(event_name) {

		if (event_name == 'mouse_events') {

			this._events_listeners['mouseover'] =
				Lava.Core.addGlobalHandler('mouseover', this.handleMouseMovement, this);
			this._events_listeners['mouseout'] =
				Lava.Core.addGlobalHandler('mouseout', this.handleMouseMovement, this);

		} else {

			this._events_listeners[event_name] =
				Lava.Core.addGlobalHandler(event_name, this.onDOMEvent, this);

		}

	}
151291
static function notify($event_name, $parameters = [], $subject = null, $desc = null) {
        self::register($event_name, $desc);
        $event = new \sfEvent($subject, $event_name, $parameters);
        self::dispatcher()
            ->notify($event);
    }
887607
final private function route($event_name, ProxyEvent $event){
		$url = $event['request']->getUri();
		
		// url filter provided and current request url does not match it
		if($this->url_pattern){
			if(starts_with($this->url_pattern, '/') && preg_match($this->url_pattern, $url) !== 1){
				return;
			} else if(stripos($url, $this->url_pattern) === false){
				return;
			}
		}
		
		switch($event_name){
			
			case 'request.before_send':
				$this->onBeforeRequest($event);
			break;
			
			case 'request.sent': 
				$this->onHeadersReceived($event);
			break;
			
			case 'curl.callback.write':
				$this->onCurlWrite($event);
			break;
			
			case 'request.complete':
				$this->onCompleted($event);
			break;
		}
	}
293183
public function help($event_name, $callback)
    {
        if (!isset($this->event_helpers[$event_name]))
        {
            $this->event_helpers[$event_name] = $callback;
        }
    }
162860
public function getEvent($name, $default = null)
    {
        if (isset($this->events[$name])) {
            return $this->events[$name];
        }

        return $default;
    }
884015
function(event_name) {

		this._event_listeners[event_name] = this._createEventWrapper(event_name);

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

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

		} else {

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

		}

	}
1356181
public function callEvent($event_name)
    {
        $classname = get_called_class();
        if (!isset(static::$callbacks[$classname][$event_name])) {
            return;
        }

        foreach (static::$callbacks[$classname][$event_name] as $callback) {
            $callback($this);
        }
    }
15422
public function get_listener_priority( $event_name, $listener ) {

		if ( ! is_callable( $listener, true ) ) {
			throw new InvalidListenerException( '$listener must be callable.' );
		}

		$priority = has_filter( $event_name, $listener );

		if ( false === $priority ) {
			return null;
		}

		return $priority;
	}
847213
def get_event_from_name(self, event_name):
        
        return next((e for e in self.events if e.name == event_name), None)
738510
public function on($event_name, $handler_callback)
    {
        $event = null;
        if (!isset($this->event_queue[$event_name])) {
            $event = new Event($event_name);
            $this->event_queue[$event_name] = $event;
        }

        $event = $this->event_queue[$event_name];
        $event->setHandlerCallback($handler_callback);
    }
544095
public function dispatch($eventName, sfEvent $event = null)
    {
        if (null !== $this->application) {
            $this->application->debug(sprintf('Dispatching `%s` event.', $eventName));
        }

        return parent::dispatch($eventName, $event);
    }
122771
public function notify($event_name, array $data = array())
    {
        $listener = $this->getListener($event_name);
        if (!$listener) {
            return $this;
        }
        foreach ($listener as $event) {
            call_user_func($event['callback'], $data);
        }
        return $this;
    }
654069
public static function getEventManager()
    {
        if (!isset(self::$event_manager[get_called_class()])) {
            self::$event_manager[get_called_class()] =
                EventDispatcher::getShareable(static::$static_scope);
        }
        return self::$event_manager[get_called_class()];
    }
994519
def getEvent(self, name):
        
        to_return = None
        for event in self._observer.caught_events:
            if event["name"] == name:
                to_return = event
                break
        if to_return:
            self._observer.caught_events.remove(to_return)
            self._observer.activate_event(to_return["name"])
        return to_return
1211235
public function getEventManager()
    {
        if (null === $this->events) {
            $this->setEventManager($this->getServiceLocator()->get('EventManager'));
        }

        return $this->events;
    }
864057
def clear_events(self, event_name):
        
        self.lock.acquire()
        try:
            q = self.get_event_q(event_name)
            q.queue.clear()
        except queue.Empty:
            return
        finally:
            self.lock.release()