Remove a callback from the callback list.

        msg: Message template
        callback: Callback method to remove.

        If callback is None, all callbacks for the message template are
        removed.
429534
def remove(self, msg, callback):
        
        if callback is None:
            self._dict.pop(msg, None)
        else:
            cb = self._dict.get(msg, [])
            try:
                cb.remove(callback)
            except ValueError:
                pass
            if cb:
                _LOGGER.debug('%d callbacks for message: %s', len(cb), msg)
                self.add(msg, cb, True)
            else:
                self._dict.pop(msg, None)
                _LOGGER.debug('Removed all callbacks for message: %s', msg)
916328
function(item, callback) {
                for (var i = 0; i < chatSendQueue.length; i++) {
                    if (chatSendQueue[i].message.uniqueId == item.message.uniqueId) {
                        chatSendQueue.splice(i, 1);
                    }
                }
                callback && callback();
            }
39983
def remove(self, elem):
    """"""
    self._values.remove(elem)
    self._message_listener.Modified()
1122518
def RemoveMethod(self, function):
        
        self.added_methods = [dm for dm in self.added_methods if not dm.method is function]
728872
def remove_callback(self, name, fn, *args, **kwargs):
        
        try:
            tup = (fn, args, kwargs)
            if tup in self.cb[name]:
                self.cb[name].remove(tup)
        except KeyError:
            raise CallbackError("No callback category of '%s'" % (
                name))
1239260
function _detach() {
  if (win == null) { return; }

  if (win.removeEventListener) {
    win.removeEventListener('message', _onmessage, false);
  } else if (win.detachEvent) {
    win.detachEvent('onmessage', _onmessage);
  } else if (win.onmessage === _onmessage) {
    win.onmessage = null;
  }

  win = null;
  popups = [];
  subscribers = {};
}
1267754
def remove_callback(self, signal_name, callback):
		
		try:
			self.__direct_callbacks[signal_name].remove(callback)
		except KeyError:
			raise ValueError('Signal "%s" does not have the specified callback' % signal_name)
1267276
def removeCallback(cls, eventType, func, record=None):
        
        callbacks = cls.callbacks()
        callbacks.setdefault(eventType, [])
        for i in xrange(len(callbacks[eventType])):
            my_func, my_record, _ = callbacks[eventType][i]
            if func == my_func and record == my_record:
                del callbacks[eventType][i]
                break
558755
def remove_callback(self, callback):
        """"""
        if callback in self._async_callbacks:
            self._async_callbacks.remove(callback)
467621
def unbind (self, event, callback):
        
        if self._events.has_key(event) and len(self._events[event]) > 0:
            for _callback in self._events[event]:
                if _callback == callback:
                    self._events[event].remove(callback)
                if len(self._events[event]) == 0:
                    del self._events[event]
786105
async def register_callback(self, cb):
        
        self._callbacks.add(cb)

        def unregister():
            self._callbacks.remove(cb)

        return unregister
356653
def remove_update_callback(self, callback, device):
        
        if [callback, device] in self._update_callbacks:
            self._update_callbacks.remove([callback, device])
            _LOGGER.debug('Removed update callback %s for %s',
                          callback, device)
1164324
def remove_request_init_listener(self, fn, *args, **kwargs):
        
        self._request_init_callbacks.remove((fn, args, kwargs))
976027
def remove_on_change(self, attr, *callbacks):
        '''  '''
        if len(callbacks) == 0:
            raise ValueError("remove_on_change takes an attribute name and one or more callbacks, got only one parameter")
        _callbacks = self._callbacks.setdefault(attr, [])
        for callback in callbacks:
            _callbacks.remove(callback)
289050
public void removeMessageListener(DigitalChannel channel, MessageListener<? extends Message> messageListener) {
        removeListener(channel.getIdentifier(), messageListener.getMessageType(), messageListener);
    }
630447
def remove_all_callbacks(self):
        
        for action in self.registered_shortcut_callbacks.keys():
            for callback in self.registered_shortcut_callbacks[action]:
                self.shortcut_manager.remove_callback_for_action(action, callback)
        # delete all registered shortcut callbacks
        self.registered_shortcut_callbacks = {}
196557
public void removeMessage(Message message) {
        synchronized (messages) {
            messages.removeIf(messageRef -> Objects.equals(messageRef.get(), message));
        }
    }