Called when a key is released after being pressed.
        Adjust method signature as appropriate for callback.
427621
def key_release_event(self, widget, event):
        
        # get keyname or keycode and translate to ginga standard
        # keyname =
        # keycode =
        keyname = ''  # self.transkey(keyname, keycode)
        self.logger.debug("key release event, key=%s" % (keyname))
        return self.make_ui_callback('key-release', keyname)
147468
def on_key_up(self):
        
        if (self.last_pressed is not None):
            self.set_key_state(self.last_pressed, 0)
            self.buffer = self.last_pressed.update_buffer(self.buffer)
            self.text_consumer(self.buffer)
            self.last_pressed = None
437463
def shift_fn(self, i, pre_dl=None, post_dl=None):
        
        self.delay(pre_dl)
        self.k.press_key(self.k.shift_key)
        self.k.tap_key(self.k.function_keys[i])
        self.k.release_key(self.k.shift_key)
        self.delay(post_dl)
1294180
def _bind_key(self, key, func):
        """
        if not callable(func):
            print u"Trying to bind non method to keystroke:%s,%s"%(key,func)
            raise ReadlineError(u"Trying to bind non method to keystroke:%s,%s,%s,%s"%(key,func,type(func),type(self._bind_key)))
        keyinfo = make_KeyPress_from_keydescr(key.lower()).tuple()
        log(u">>>%s -> %s<<<"%(keyinfo,func.__name__))
        self.key_dispatch[keyinfo] = func
1046615
function(e) {
      var t = this;

      // Make view options changes immediately on keydown
      // Note: Don't be so aggressive with monitor initParams, because that
      // could result in backend round-trips for each keystroke.
      setTimeout(function(){
        t.viewOptionBinder._onElChanged(e);
      },0);

      // Call the parent keydown
      t.onKeydown(e);
    }
1006896
def on_key_event(self, event):
        ''''''
        keycode = event.GetKeyCode()
        if keycode == wx.WXK_HOME:
            self.zoom = 1.0
            self.dragpos = wx.Point(0, 0)
            self.need_redraw = True
716856
def press(*keys):
    

    for key in keys:
        win32api.keybd_event(codes[key], 0, 0, 0)
        release(key)
1224255
def keyReleaseEvent( self, event ):
        
        # when the user releases the space bar, remove
        # the scene view edit override
        if ( event.key() == Qt.Key_Space ):
            self.setViewMode(False)
            event.accept()
        
        # otherwise, eat all other key press events until the 
        # view mode is released
        elif ( self.inViewMode() ):
            event.accept()
        
        # otherwise, handle the event like normal
        else:
            super(XNodeScene, self).keyPressEvent(event)
738204
def keyPress(self, key):
        
        log.debug('keyPress %s', key)
        self.keyDown(key)
        self.keyUp(key)

        return self
18505
def key_event(self, key, action):
        
        if action == self.wnd.keys.ACTION_PRESS:
            if key == self.wnd.keys.SPACE:
                print("Space was pressed")

        if action == self.wnd.keys.ACTION_RELEASE:
            if key == self.wnd.keys.SPACE:
                print("Space was released")
155727
def observe(self, key: str, callback: Callable[[Any, Any], None]):
        """"""
        if key not in self._callbacks:
            self._add_key(key)
        self._callbacks[key].append(callback)
517685
def tap_key(self, character='', n=1, interval=0):
        """"""
        for i in range(n):
            self.press_key(character)
            self.release_key(character)
            time.sleep(interval)
1147540
public void pressKey(final String key) {
        if (key == null) return;

        runWithRetries(() -> {
            elementImpl.locateElement().sendKeys(key);
        });
    }
162235
def release(self, key: str, callback: Callable[[Any, Any], None]):
        """"""
        try:
            self._callbacks[key].remove(callback)
        except (KeyError, ValueError):
            pass
57966
function (key) {
        let _that = this[PRIVATE];

        key = KEYMAP[key.toUpperCase()];
        if (key < _that.pressed.length && key != null) {
            _that.pressed[key] = true;
        }
    }
53146
def key_release_event(self, event):
        
        self.example.key_event(event.key(), self.keys.ACTION_RELEASE)
1183158
public void onRead(SelectionKey key) {
    if (this.readEventDispatcher == null) {
      dispatchReadEvent(key);
    } else {
      this.readEventDispatcher.dispatch(new ReadTask(key));
    }
  }