Sends the given number of backspace key presses.
186999
def send_backspace(self, count):
        
        for i in range(count):
            self.interface.send_key(Key.BACKSPACE)
83890
private void handleBackKey() throws IOException {
		if (commandLineBuffer.size() > 0 && curPos > 0) {
			if (echoEnabled) {
				ps.write(BACK);
			}
			String curLine = overwriteCommandlineSkippingChar(curPos - 1);
			eraseLastCharAndMoveBack(curLine, curPos);
			curPos--;
		}
	}
1348453
def send(self, send_string, newline=None):
        """"""
        self.current_send_string = send_string
        newline = newline if newline is not None else self.newline

        self.channel.send(send_string + newline)
372106
function handleKeydown(keyCodes, e, callback) {
    const keyCode = e.charCode || e.keyCode;
    if (keyCodes.indexOf(keyCode) !== -1) {
        callback();
    }
}
994293
def sendline(self, s=''):
        ''' '''

        n = self.send(s)
        return n + self.send(self.linesep)
1344703
public void sendKeys(final By by, final CharSequence... keysToSend) {
		checkTopmostElement(by);
		findElement(by).sendKeys(keysToSend);
	}
169678
def keyPressEvent(self, keyEvent):
        
        undoObj = UndoSelfInsert(self, keyEvent.text())
        self.qteUndoStack.push(undoObj)
74396
function press(event) {
      if (event.keyCode === 39) {
        Components.Run.make(Components.Direction.resolve('>'));
      }

      if (event.keyCode === 37) {
        Components.Run.make(Components.Direction.resolve('<'));
      }
    }
1035342
private void sendHandshake(ChannelHandlerContext ctx) {
    boolean needToFlush = false;

    // Iterate until there is nothing left to write.
    while (true) {
      buffer = getOrCreateBuffer(ctx.alloc());
      try {
        handshaker.getBytesToSendToPeer(buffer);
      } catch (GeneralSecurityException e) {
        throw new RuntimeException(e);
      }
      if (!buffer.isReadable()) {
        break;
      }

      needToFlush = true;
      @SuppressWarnings("unused") // go/futurereturn-lsc
      Future<?> possiblyIgnoredError = ctx.write(buffer);
      buffer = null;
    }

    // If something was written, flush.
    if (needToFlush) {
      ctx.flush();
    }
  }
1103023
def send_keystrokes(ip, keystrokes, wait=False):
        """"""
        tv_url = 'http://{}:6095/controller?action=keyevent&keycode='.format(ip)

        for keystroke in keystrokes:
            if keystroke == 'wait' or wait is True:

                time.sleep(0.7)
            else:
                request = requests.get(tv_url + keystroke)

                if request.status_code != 200:
                    return False

        return True
397863
def keyPressEvent(self, event):
        """"""
        if event == QKeySequence.Copy:
            self.copy()
        else:
            QTableView.keyPressEvent(self, event)
940086
@Override
    public void keyPressed(int keyCode, char keyChar)
    {
        // Validate message
        if (keyCode == keyValidate)
        {
            if (message.length() > 0)
            {
                sendValidatedMessage();
            }
        }
        else if (keyCode == keyBackSpace)
        {
            if (message.length() > 0)
            {
                message.deleteCharAt(message.length() - 1);
            }
        }
        else if (Character.isDefined(keyChar) && canAddChar(keyChar))
        {
            message.append(keyChar);
        }
        display = message.toString();
    }
863916
def keyEvent(self, key, down=1):
        """"""
        self.transport.write(pack("!BBxxI", 4, down, key))
100518
function send_commands(cmds, cb) {
        function callback(value) {
            if (cb) cb(value)
            this.locked = false
        }
        function run() { 
            if (this.locked = cmds.length > 0) send_command(cmds.shift(), (success) => {
                if (success) setTimeout(run, 200);
                else callback(false);
            });
            else callback(true); 
        };
        if(!this.locked) run();
    }
358365
def send_keys(self, keys):
        """"""
        try:
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            sock.settimeout(self._timeout)
            sock.connect((self._ip, self._port['cmd']))
            # mandatory dance
            version_info = sock.recv(15)
            sock.send(version_info)
            sock.recv(2)
            sock.send(bytes.fromhex('01'))
            sock.recv(4)
            sock.recv(24)
            # send our command now!
            for key in keys:
                if key in self._keys:
                    sock.send(bytes.fromhex("04 01 00 00 00 00 " +
                                            self._keys[key]))
                    sock.send(bytes.fromhex("04 00 00 00 00 00 " +
                                            self._keys[key]))
            sock.close()
        except socket.error:
            raise
925861
public void goBack() {
		sleeper.sleep();
		try {
			inst.sendKeyDownUpSync(KeyEvent.KEYCODE_BACK);
			sleeper.sleep();
		} catch (Throwable ignored) {}
	}
516872
public void sendBatch() {
        LrsStatement statement = null;
        List<LrsStatement> list = new ArrayList<LrsStatement>();

        while ((statement = statementQueue.poll()) != null) {
            list.add(statement);
        }

        if (!list.isEmpty()) {
            postStatementList(list);
        }
    }