Remove key binding.
325247
def unbind_key(pymux, variables):
    
    key = variables['<key>']
    needs_prefix = not variables['-n']

    pymux.key_bindings_manager.remove_custom_binding(
        key, needs_prefix=needs_prefix)
1279937
public void unbind(BaseUIComponent component) {
        if (componentBindings.remove(component)) {
            keyEventListener.registerComponent(component, false);
            CommandUtil.updateShortcuts(component, shortcutBindings, true);
            setCommandTarget(component, null);
        }
    }
685636
function removeBinding(key, platform) {
        if (!key || ((platform !== null) && (platform !== undefined) && (platform !== brackets.platform))) {
            return;
        }

        var normalizedKey = normalizeKeyDescriptorString(key);

        if (!normalizedKey) {
            console.log("Failed to normalize " + key);
        } else if (_isKeyAssigned(normalizedKey)) {
            var binding = _keyMap[normalizedKey],
                command = CommandManager.get(binding.commandID),
                bindings = _commandMap[binding.commandID];

            // delete key binding record
            delete _keyMap[normalizedKey];

            if (bindings) {
                // delete mapping from command to key binding
                _commandMap[binding.commandID] = bindings.filter(function (b) {
                    return (b.key !== normalizedKey);
                });

                if (command) {
                    command.trigger("keyBindingRemoved", {key: normalizedKey, displayKey: binding.displayKey});
                }
            }
        }
    }
949113
def _remove_add_key(self, key):
        """"""
        if not hasattr(self, '_queue'):
            return  # haven't initialized yet, so don't bother
        if key in self._queue:
            self._queue.remove(key)
        self._queue.append(key)
        if self.maxsize == 0:
            return
        while len(self._queue) > self.maxsize:
            del self[self._queue[0]]
530057
function() {
				// Remove keydown event listeners
				this.handle1.removeEventListener("keydown", this.handle1Keydown, false);
				this.handle2.removeEventListener("keydown", this.handle2Keydown, false);

				if (this.showTooltip) {
					this.handle1.removeEventListener("focus", this.showTooltip, false);
					this.handle2.removeEventListener("focus", this.showTooltip, false);
				}
				if (this.hideTooltip) {
					this.handle1.removeEventListener("blur", this.hideTooltip, false);
					this.handle2.removeEventListener("blur", this.hideTooltip, false);
				}

				// Remove event listeners from sliderElem
				if (this.showTooltip) {
					this.sliderElem.removeEventListener("mouseenter", this.showTooltip, false);
				}
				if (this.hideTooltip) {
					this.sliderElem.removeEventListener("mouseleave", this.hideTooltip, false);
				}
				this.sliderElem.removeEventListener("touchstart", this.mousedown, false);
				this.sliderElem.removeEventListener("mousedown", this.mousedown, false);
			}
745869
function() {
    if (keyboardHasPlugin()) {
      window.removeEventListener('native.keyboardshow', debouncedKeyboardNativeShow );
      window.removeEventListener('native.keyboardhide', keyboardFocusOut);
    } else {
      document.body.removeEventListener('focusout', keyboardFocusOut);
    }

    document.body.removeEventListener('ionic.focusin', debouncedKeyboardFocusIn);
    document.body.removeEventListener('focusin', debouncedKeyboardFocusIn);

    window.removeEventListener('orientationchange', keyboardOrientationChange);

    if ( window.navigator.msPointerEnabled ) {
      document.removeEventListener("MSPointerDown", keyboardInit);
    } else {
      document.removeEventListener('touchstart', keyboardInit);
    }
    ionic.keyboard.isInitialized = false;
  }
900914
def remove_hook(self, key_name, hook_name):
        """"""
        kf = self.dct[key_name]
        if 'hooks' in kf:
            if hook_name in kf['hooks']:
                return kf['hooks'].pop(hook_name)
454926
def remove(config, username, filename, force):
        """"""
        client = Client()
        client.prepare_connection()
        user_api = UserApi(client)
        key_api = API(client)
        key_api.remove(username, user_api, filename, force)
1300545
async def removeKeyPair(self, *args, **kwargs):
        

        return await self._makeApiCall(self.funcinfo["removeKeyPair"], *args, **kwargs)
471493
def remove(self, branch, turn, tick):
        """"""
        time_entity, parents, branches, keys, settings, presettings, remove_keycache, send = self._remove_stuff
        parent, entity, key = time_entity[branch, turn, tick]
        branchkey = parent + (entity, key)
        keykey = parent + (entity,)
        if parent in parents:
            parentt = parents[parent]
            if entity in parentt:
                entty = parentt[entity]
                if key in entty:
                    kee = entty[key]
                    if branch in kee:
                        branhc = kee[branch]
                        if turn in branhc:
                            trn = branhc[turn]
                            del trn[tick]
                            if not trn:
                                del branhc[turn]
                            if not branhc:
                                del kee[branch]
                    if not kee:
                        del entty[key]
                if not entty:
                    del parentt[entity]
            if not parentt:
                del parents[parent]
        if branchkey in branches:
            entty = branches[branchkey]
            if branch in entty:
                branhc = entty[branch]
                if turn in branhc:
                    trn = branhc[turn]
                    if tick in trn:
                        del trn[tick]
                    if not trn:
                        del branhc[turn]
                if not branhc:
                    del entty[branch]
            if not entty:
                del branches[branchkey]
        if keykey in keys:
            entty = keys[keykey]
            if key in entty:
                kee = entty[key]
                if branch in kee:
                    branhc = kee[branch]
                    if turn in branhc:
                        trn = entty[turn]
                        if tick in trn:
                            del trn[tick]
                        if not trn:
                            del branhc[turn]
                    if not branhc:
                        del kee[branch]
                if not kee:
                    del entty[key]
            if not entty:
                del keys[keykey]
        branhc = settings[branch]
        pbranhc = presettings[branch]
        trn = branhc[turn]
        ptrn = pbranhc[turn]
        if tick in trn:
            del trn[tick]
        if tick in ptrn:
            del ptrn[tick]
        if not ptrn:
            del pbranhc[turn]
            del branhc[turn]
        if not pbranhc:
            del settings[branch]
            del presettings[branch]
        self.shallowest = OrderedDict()
        remove_keycache(parent + (entity, branch), turn, tick)
        send(self, branch=branch, turn=turn, tick=tick, action='remove')
517904
function unbind(el, type, fn, capt) {
	el.removeEventListener(type.slice(2), fn, capt);
}
998964
function remove(keyId, callback) {
    commons.del(format('/%s/keys/%s', deis.version, keyId), callback);
  }
996160
function() {
            for (var i = this._keys.length - 1; 0 <= i; i -= 1) {
                var key = this._keys[i];
                _engine.callSWF("removeItem", [key]);
            }

            this._keys = [];
            this.length = 0;
        }
19158
function() {

		var input_element = this.getDOMElement();
		Firestorm.Element.removeListener(input_element, "onpropertychange", this._OldIE_property_change_callback);
		Firestorm.Element.removeListener(input_element, "selectionchange", this._OldIE_refresh_callback);
		Firestorm.Element.removeListener(input_element, "keyup", this._OldIE_refresh_callback);
		Firestorm.Element.removeListener(input_element, "keydown", this._OldIE_refresh_callback);

		this.Element$informRemove();

	}
603332
function removeBinding ($prop)
  {
    if (isset($this->bindings)) {
      unset($this->bindings[$prop]);
      if (empty($this->bindings))
        $this->bindings = null;
    }
  }
914591
function free(key) {
    if (locks[key]) {
        delete locks[key];
        stats.lock_remove();
    }
    tick(key);
}
439181
def unset(self, key):
        
        key = key.strip().upper()
        if key not in dir(default_settings) and key not in self._defaults:
            self.logger.debug("Unset %s", key)
            delattr(self, key)
            self.store.pop(key, None)