Remove an event listener

@param   string  The event name
@param   object  An object implementing the AnObjectHandlable interface
@return  AnObject  The mixer object
183029
public function removeEventDispatcher($subscriber)
    {
        if (! ($subscriber instanceof AnEventSubscriberInterface)) {
            $subscriber = $this->getEventSubscriber($subscriber, $config);
        }
        
        $this->_event_dispatcher->removeEventSubscriber($subscriber);
        return $this->getMixer();
    }
735380
function (object) {
      removeFromArray(this._objects, object);
      if (this.getActiveObject() === object) {

        // removing active object should fire "selection:cleared" events
        this.fire('before:selection:cleared', { target: object });
        this.discardActiveObject();
        this.fire('selection:cleared');
      }
      this.renderAll();
      return object;
    }
1248271
public function removeEventListener($event, $listener){
     if (!$this->events[$event]) return $this;
   

    $indexOf = 0;
    foreach ($this->Iterator('Array') as $EventListener) {
       if($EventListener === $listener)	{
         array_splice($this->events[$event], $indexOf, 1);	   	
         $indexOf--;
	   }
         $indexOf++;
    }
    return $this; 	
  }
12104
function deleteListener(event, callback, idx) {
  if ((idx = event.listeners.indexOf(callback)) >= 0) {
    event.listeners.splice(idx, 1);
    event.meta.delete(callback);
    return true;
  }
  return false;
}
121164
function (name, method) {
        this.map.events.unregister(name, this, method);   
        this.map.events.unregister(name, this, this.setEvent);
    }
404800
function(obj, eventName, alias) {
    ['addEventListener', 'removeEventListener'].forEach(function(method) {
      var nativeMethod = obj[method];
      obj[method] = function(nativeEventName, cb) {
        if (nativeEventName !== alias) {
          return nativeMethod.apply(this, arguments);
        }
        return nativeMethod.apply(this, [eventName, cb]);
      };
    });

    Object.defineProperty(obj, 'on' + alias, {
      get: function() {
        return this['_on' + alias];
      },
      set: function(cb) {
        if (this['_on' + alias]) {
          this.removeEventListener(alias, this['_on' + alias]);
          delete this['_on' + alias];
        }
        if (cb) {
          this.addEventListener(alias, this['_on' + alias] = cb);
        }
      }
    });
  }
992064
public function removeEventListener($listener)
	{
		$this->ensureEventListeners();
		
		unset($this->_eventListeners[Ioc::resolveClassName($listener)]);
		
		return $this;
	}
17330
function _gpfRemoveEventListener (event, eventsHandler) {
    /*jshint validthis:true*/ // will be invoked as an object method
    var listeners = this._eventDispatcherListeners,
        eventListeners,
        index;
    if (listeners) {
        eventListeners = listeners[event];
        if (undefined !== eventListeners) {
            index = eventListeners.indexOf(eventsHandler);
            if (-1 !== index) {
                eventListeners.splice(index, 1);
            }
        }
    }
    return this;
}
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;
    }
96997
function removeAllListeners(string $eventName = null) {

        if (!\is_null($eventName)) {
            unset($this->listeners[$eventName]);
            unset($this->listeners_flat[$eventName]);
        } else {
            $this->listeners = [];
            $this->listeners_flat = [];
        }

    }
1366851
public function removeListener($event_name, $listener) {
	    	if(!is_callable($listener)){
	    		throw new \InvalidArgumentException("Argument 'listener' is not callable.");
	    	}

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

}
1000200
function(eventName, handler) {
    if (!this.__eventListeners) {
      this.__eventListeners = { };
    }
    if (this.__eventListeners[eventName]) {
      fabric.util.removeFromArray(this.__eventListeners[eventName], handler);
    }
  }
154732
public function clearListeners($event = null)
	{
		if ($event)
		{
			$event = $this->resolveEventName($event);

			if (isset($this->listeners[$event]))
			{
				unset($this->listeners[$event]);
			}
		}
		else
		{
			$this->listeners = array();
		}

		return $this;
	}
379465
function deleteListener(event, id) {
    if (hasListener(event, id)) {
      delete context._events[event][id];

      if (_.keys(getListeners(event)).length === 0)
        deleteEvent(event);
      
      return true;
    }

    return false;
  }
754229
public static function off(
        string $class,
        string $name,
        ? callable $handler = null
    ): bool {
        $class = ltrim($class, '\\');
        if (
            empty(static::$_events[$name][$class])
            && empty(static::$_eventWildcards[$name][$class])
        ) {
            return false;
        }
        if ($handler === null) {
            unset(static::$_events[$name][$class]);
            if (empty(static::$_events[$name])) {
                unset(static::$_events[$name]);
            }
            unset(static::$_eventWildcards[$name][$class]);
            if (empty(static::$_eventWildcards[$name])) {
                unset(static::$_eventWildcards[$name]);
            }
            return true;
        }
        return static::remove(
            static::$_events,
            $name,
            $class,
            $handler
        ) || static::remove(
            static::$_eventWildcards,
            $name,
            $class,
            $handler
        );
    }
573878
public void removeObjectListeners(Class<?> objectClass, long objectId) {
        if (objectClass == null) {
            return;
        }
        synchronized (objectListeners) {
            Map<Long, Map<Class<? extends ObjectAttachableListener>,
                    Map<ObjectAttachableListener, ListenerManagerImpl<? extends ObjectAttachableListener>>>>
                    objects = objectListeners.get(objectClass);
            if (objects == null) {
                return;
            }
            // Remove all listeners
            objects.computeIfPresent(objectId, (id, listeners) -> {
                listeners.values().stream()
                        .flatMap(map -> map.values().stream())
                        .forEach(ListenerManagerImpl::removed);
                listeners.clear();
                return null;
            });
            // Cleanup
            if (objects.isEmpty()) {
                objectListeners.remove(objectClass);
            }
        }
    }