@Override
public void keyPressed(KeyEvent evt) {
if (evt.isConsumed()) return;
Component comp = getFocusOwner();
if (evt.getKeyCode() == KeyEvent.VK_ENTER && enterEnabled) {
while (comp != null) {
if (comp instanceof JComboBox) {
JComboBox<?> combo = (JComboBox<?>) comp;
if (combo.isEditable()) {
Object selected = combo.getEditor().getItem();
if (selected != null) combo.setSelectedItem(selected);
}
if (combo.isPopupVisible()) {
evt.consume();
combo.setPopupVisible(false);
}
return;
}
// TODO: add other classes that need custom key handling here.
comp = comp.getParent();
}
evt.consume();
ok();
} else if (evt.getKeyCode() == KeyEvent.VK_ESCAPE || isCloseBufferShortcut(evt)) {
evt.consume();
if (comp instanceof JComboBox) {
JComboBox<?> combo = (JComboBox<?>) comp;
if (combo.isPopupVisible()) combo.setPopupVisible(false);
else cancel();
} else cancel();
}
}
@Override
public void keyPressed(KeyEvent e) {
TreePath path = myTree.getLeadSelectionPath();
if (path == null) return;
final Object lastComponent = path.getLastPathComponent();
if (e.getKeyCode() == KeyEvent.VK_ENTER) {
if (lastComponent instanceof ParentNode) return;
doOKAction();
e.consume();
} else if (e.getKeyCode() == KeyEvent.VK_INSERT) {
if (lastComponent instanceof ElementNode) {
final DefaultMutableTreeNode node = (DefaultMutableTreeNode) lastComponent;
if (!mySelectedNodes.contains(node)) {
if (node.getNextNode() != null) {
myTree.setSelectionPath(new TreePath(node.getNextNode().getPath()));
}
} else {
if (node.getNextNode() != null) {
myTree.removeSelectionPath(new TreePath(node.getPath()));
myTree.setSelectionPath(new TreePath(node.getNextNode().getPath()));
myTree.repaint();
}
}
e.consume();
}
}
}
@Override
public void keyPressed(KeyEvent evt) {
switch (evt.getKeyCode()) {
case KeyEvent.VK_SPACE:
goToSelectedNode(M_OPEN);
// f**k me dead
EventQueue.invokeLater(
new Runnable() {
@Override
public void run() {
resultTree.requestFocus();
}
});
evt.consume();
break;
case KeyEvent.VK_ENTER:
goToSelectedNode(M_OPEN);
evt.consume();
break;
case KeyEvent.VK_DELETE:
removeSelectedNode();
evt.consume();
break;
default:
break;
}
}
public void processKeyEvent(KeyEvent evt) {
evt = KeyEventWorkaround.processKeyEvent(evt);
if (evt == null) return;
switch (evt.getID()) {
case KeyEvent.KEY_TYPED:
char ch = evt.getKeyChar();
if (!nonDigit && Character.isDigit(ch)) {
super.processKeyEvent(evt);
repeat = true;
repeatCount = Integer.parseInt(action.getText());
} else {
nonDigit = true;
if (repeat) {
passToView(evt);
} else super.processKeyEvent(evt);
}
break;
case KeyEvent.KEY_PRESSED:
int keyCode = evt.getKeyCode();
if (evt.isActionKey()
|| evt.isControlDown()
|| evt.isAltDown()
|| evt.isMetaDown()
|| keyCode == KeyEvent.VK_BACK_SPACE
|| keyCode == KeyEvent.VK_DELETE
|| keyCode == KeyEvent.VK_ENTER
|| keyCode == KeyEvent.VK_TAB
|| keyCode == KeyEvent.VK_ESCAPE) {
nonDigit = true;
if (repeat) {
passToView(evt);
break;
} else if (keyCode == KeyEvent.VK_TAB) {
complete(true);
evt.consume();
} else if (keyCode == KeyEvent.VK_ESCAPE) {
evt.consume();
if (popup != null) {
popup.dispose();
popup = null;
action.requestFocus();
} else {
if (temp) view.removeToolBar(ActionBar.this);
view.getEditPane().focusOnTextArea();
}
break;
} else if ((keyCode == KeyEvent.VK_UP || keyCode == KeyEvent.VK_DOWN)
&& popup != null) {
popup.list.processKeyEvent(evt);
break;
}
}
super.processKeyEvent(evt);
break;
}
}
@Override
public void keyTyped(final KeyEvent e) {
if (undo == null || control(e) || DELNEXT.is(e) || DELPREV.is(e) || ESCAPE.is(e)) return;
text.pos(text.cursor());
// string to be added
String ch = String.valueOf(e.getKeyChar());
// remember if marked text is to be deleted
boolean del = true;
final byte[] txt = text.text();
if (TAB.is(e)) {
if (text.marked()) {
// check if lines are to be indented
final int s = Math.min(text.pos(), text.start());
final int l = Math.max(text.pos(), text.start()) - 1;
for (int p = s; p <= l && p < txt.length; p++) del &= txt[p] != '\n';
if (!del) {
text.indent(s, l, e.isShiftDown());
ch = null;
}
} else {
boolean c = true;
for (int p = text.pos() - 1; p >= 0 && c; p--) {
final byte b = txt[p];
c = ws(b);
if (b == '\n') break;
}
if (c) ch = " ";
}
}
// delete marked text
if (text.marked() && del) text.delete();
if (ENTER.is(e)) {
// adopt indentation from previous line
final StringBuilder sb = new StringBuilder(1).append(e.getKeyChar());
int s = 0;
for (int p = text.pos() - 1; p >= 0; p--) {
final byte b = txt[p];
if (b == '\n') break;
if (b == '\t') {
s += 2;
} else if (b == ' ') {
s++;
} else {
s = 0;
}
}
for (int p = 0; p < s; p++) sb.append(' ');
ch = sb.toString();
}
if (ch != null) text.add(ch);
text.setCaret();
rend.calc();
showCursor(2);
e.consume();
}
@FXML
void playTrackFromKeyboard(KeyEvent e) {
if (e.getCode() == KeyCode.ENTER) {
playSelectedTrack();
e.consume();
}
}
public void keyPressed(KeyEvent e) {
int code = e.getKeyCode();
if (code == KeyEvent.VK_ENTER) {
document.enter();
e.consume();
}
}
public void keyTyped(KeyEvent k) {
if (k.getKeyChar() == '\n' && k.isControlDown()) {
k.consume();
execute();
}
}
@Override
public void keyTyped(final KeyEvent e) {
if (!hist.active()
|| control(e)
|| DELNEXT.is(e)
|| DELPREV.is(e)
|| ESCAPE.is(e)
|| CUT2.is(e)) return;
final int caret = editor.pos();
// remember if marked text is to be deleted
final StringBuilder sb = new StringBuilder(1).append(e.getKeyChar());
final boolean indent = TAB.is(e) && editor.indent(sb, e.isShiftDown());
// delete marked text
final boolean selected = editor.selected() && !indent;
if (selected) editor.delete();
final int move = ENTER.is(e) ? editor.enter(sb) : editor.add(sb, selected);
// refresh history and adjust cursor position
hist.store(editor.text(), caret, editor.pos());
if (move != 0) editor.pos(Math.min(editor.size(), caret + move));
// adjust text height
scrollCode.invokeLater(true);
e.consume();
}
public void keyPressed(KeyEvent evt) {
int keyCode = evt.getKeyCode();
if (keyCode == KeyEvent.VK_ESCAPE) action.processKeyEvent(evt);
else if (keyCode == KeyEvent.VK_ENTER) invoke();
else if (keyCode == KeyEvent.VK_UP) {
int selected = list.getSelectedIndex();
if (selected == 0) {
list.setSelectedIndex(list.getModel().getSize() - 1);
evt.consume();
}
} else if (keyCode == KeyEvent.VK_DOWN) {
int selected = list.getSelectedIndex();
if (selected == list.getModel().getSize() - 1) {
list.setSelectedIndex(0);
evt.consume();
}
}
}
// keypressed
public void keyPressed(KeyEvent e) {
int KeyCode = e.getKeyCode();
if (KeyCode == KeyEvent.VK_ESCAPE) { // VK_ what ever
stop();
} else {
mess = "You pressed: " + KeyEvent.getKeyText(KeyCode);
e.consume(); // not allowing key combinations
}
}
// KeyListener interface ---------------
public void keyPressed(KeyEvent e) {
int code = e.getKeyCode();
switch (code) {
case KeyEvent.VK_DOWN:
fireActionPerformed("down");
e.consume();
break;
case KeyEvent.VK_UP:
fireActionPerformed("up");
e.consume();
break;
case KeyEvent.VK_PAGE_DOWN:
fireActionPerformed("next");
e.consume();
break;
case KeyEvent.VK_PAGE_UP:
fireActionPerformed("prev");
e.consume();
break;
}
}
@SuppressWarnings("HardCodedStringLiteral")
private void processListSelection(final KeyEvent e) {
if (togglePopup(e)) return;
if (!isPopupShowing()) return;
final InputMap map = myPathTextField.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
if (map != null) {
final Object object = map.get(KeyStroke.getKeyStrokeForEvent(e));
if (object instanceof Action) {
final Action action = (Action) object;
if (action.isEnabled()) {
action.actionPerformed(new ActionEvent(this, ActionEvent.ACTION_PERFORMED, "action"));
e.consume();
return;
}
}
}
final Object action = getAction(e, myList);
if ("selectNextRow".equals(action)) {
if (ensureSelectionExists()) {
ListScrollingUtil.moveDown(myList, e.getModifiersEx());
}
} else if ("selectPreviousRow".equals(action)) {
ListScrollingUtil.moveUp(myList, e.getModifiersEx());
} else if ("scrollDown".equals(action)) {
ListScrollingUtil.movePageDown(myList);
} else if ("scrollUp".equals(action)) {
ListScrollingUtil.movePageUp(myList);
} else if (getSelectedFileFromCompletionPopup() != null
&& (e.getKeyCode() == KeyEvent.VK_ENTER || e.getKeyCode() == KeyEvent.VK_TAB)
&& e.getModifiers() == 0) {
hideCurrentPopup();
e.consume();
processChosenFromCompletion(e.getKeyCode() == KeyEvent.VK_TAB);
}
}
/**
* Invokes special keys.
*
* @param e key event
* @return {@code true} if special key was processed
*/
private boolean specialKey(final KeyEvent e) {
if (PREVTAB.is(e)) {
gui.editor.tab(false);
} else if (NEXTTAB.is(e)) {
gui.editor.tab(true);
} else if (CLOSETAB.is(e)) {
gui.editor.close(null);
} else if (search != null && ESCAPE.is(e)) {
search.deactivate(true);
} else {
return false;
}
e.consume();
return true;
}
public void keyPressed(KeyEvent e) {
if (isDisplayable()) setPopupVisible(true);
hitBackspace = false;
switch (e.getKeyCode()) {
// determine if the pressed key is backspace (needed by the remove method)
case KeyEvent.VK_BACK_SPACE:
hitBackspace = true;
hitBackspaceOnSelection = editor.getSelectionStart() != editor.getSelectionEnd();
break;
// ignore delete key
case KeyEvent.VK_DELETE:
e.consume();
getToolkit().beep();
break;
}
}
@Override
public void keyPressed(KeyEvent e) {
// Accept "copy" key strokes
KeyStroke ks = KeyStroke.getKeyStroke(e.getKeyCode(), e.getModifiers());
JComponent comp = (JComponent) e.getSource();
for (int i = 0; i < 3; i++) {
InputMap im = comp.getInputMap(i);
Object key = im.get(ks);
if (defaultEditorKitCopyActionName.equals(key)
|| transferHandlerCopyActionName.equals(key)) {
return;
}
}
// Accept JTable navigation key strokes
if (!tableNavigationKeys.contains(e.getKeyCode())) {
e.consume();
}
}
@Override
public void processKeyEvent(final KeyEvent e) {
handleKeyEvent(e);
e.consume();
}
@Override
public void keyTyped(KeyEvent e) {
e.consume();
}
private synchronized void type(KeyEvent e) {
switch (e.getKeyCode()) {
case (KeyEvent.VK_ENTER):
if (e.getID() == KeyEvent.KEY_PRESSED) {
processCommand();
initCommandPos();
text.setCaretPosition(commandPos);
}
e.consume();
text.repaint();
break;
case (KeyEvent.VK_UP):
if (e.getID() == KeyEvent.KEY_PRESSED) prevHistory();
e.consume();
break;
case (KeyEvent.VK_DOWN):
if (e.getID() == KeyEvent.KEY_PRESSED) nextHistory();
e.consume();
break;
case (KeyEvent.VK_LEFT):
case (KeyEvent.VK_BACK_SPACE):
case (KeyEvent.VK_DELETE):
if (text.getCaretPosition() <= commandPos) e.consume();
break;
case (KeyEvent.VK_HOME):
text.setCaretPosition(commandPos);
e.consume();
break;
case (KeyEvent.VK_U):
if ((e.getModifiers() & InputEvent.CTRL_MASK) > 0) {
replaceConsoleText("", commandPos, textLength());
commandHistoryIndex = 0;
e.consume();
}
break;
case (KeyEvent.VK_ALT):
case (KeyEvent.VK_CAPS_LOCK):
case (KeyEvent.VK_CONTROL):
case (KeyEvent.VK_META):
case (KeyEvent.VK_SHIFT):
case (KeyEvent.VK_PRINTSCREEN):
case (KeyEvent.VK_SCROLL_LOCK):
case (KeyEvent.VK_PAUSE):
case (KeyEvent.VK_INSERT):
case (KeyEvent.VK_F1):
case (KeyEvent.VK_F2):
case (KeyEvent.VK_F3):
case (KeyEvent.VK_F4):
case (KeyEvent.VK_F5):
case (KeyEvent.VK_F6):
case (KeyEvent.VK_F7):
case (KeyEvent.VK_F8):
case (KeyEvent.VK_F9):
case (KeyEvent.VK_F10):
case (KeyEvent.VK_F11):
case (KeyEvent.VK_F12):
case (KeyEvent.VK_ESCAPE):
case (KeyEvent.VK_C):
break;
default:
if ((e.getModifiers()
& (InputEvent.CTRL_MASK | InputEvent.ALT_MASK | InputEvent.META_MASK))
== 0) {
moveCaret();
}
if ((e.paramString().contains("Backspace")) && (text.getCaretPosition() <= commandPos)) {
e.consume();
}
break;
}
}
// {{{ processKeyEvent() method
public void processKeyEvents(KeyEvent ke) {
if ((ke.getID() == KeyEvent.KEY_PRESSED) && (ke.getKeyCode() == KeyEvent.VK_ESCAPE)) {
cancel();
ke.consume();
}
} // }}}
@Override
protected void processKeyEvent(KeyEvent evt) {
if (evt.getID() == KeyEvent.KEY_PRESSED) {
ActionContext ac = VFSBrowser.getActionContext();
int row = parentDirectories.getSelectedIndex();
switch (evt.getKeyCode()) {
case KeyEvent.VK_DOWN:
evt.consume();
if (row < parentDirectories.getSize().height - 1)
parentDirectories.setSelectedIndex(++row);
break;
case KeyEvent.VK_LEFT:
if ((evt.getModifiers() & InputEvent.ALT_MASK) > 0) {
evt.consume();
browser.previousDirectory();
} else super.processEvent(evt);
break;
case KeyEvent.VK_RIGHT:
if ((evt.getModifiers() & InputEvent.ALT_MASK) > 0) {
evt.consume();
browser.nextDirectory();
} else super.processEvent(evt);
break;
case KeyEvent.VK_TAB:
evt.consume();
if ((evt.getModifiers() & InputEvent.SHIFT_MASK) > 0) browser.focusOnDefaultComponent();
else table.requestFocus();
break;
case KeyEvent.VK_UP:
evt.consume();
if (row > 0) {
parentDirectories.setSelectedIndex(--row);
}
break;
case KeyEvent.VK_BACK_SPACE:
evt.consume();
EditAction up = ac.getAction("vfs.browser.up");
ac.invokeAction(evt, up);
break;
case KeyEvent.VK_F5:
evt.consume();
EditAction reload = ac.getAction("vfs.browser.reload");
ac.invokeAction(evt, reload);
break;
case KeyEvent.VK_ENTER:
evt.consume();
if (row != -1) {
// basically the same handling as in ParentMouseHandler#mouseReleased
Object obj = parentDirectories.getModel().getElementAt(row);
if (obj instanceof VFSFile) {
VFSFile dirEntry = (VFSFile) obj;
browser.setDirectory(dirEntry.getPath());
if (browser.getMode() == VFSBrowser.BROWSER) focusOnFileView();
}
}
break;
/* These actions don't work because they look at the EntryTable for the current selected
* item. We need actions that look at the parentDirectoryList item instead.
*
case KeyEvent.VK_DELETE:
evt.consume();
ea = ac.getAction("vfs.browser.delete");
ac.invokeAction(evt, ea);
break;
case KeyEvent.CTRL_MASK | KeyEvent.VK_N:
evt.consume();
ea = ac.getAction("vfs.browser.new-file");
ac.invokeAction(evt, ea);
break;
case KeyEvent.VK_INSERT:
evt.consume();
ea = ac.getAction("vfs.browser.new-directory");
ac.invokeAction(evt, ea);
break; */
}
} else if (evt.getID() == KeyEvent.KEY_TYPED) {
if (evt.isControlDown() || evt.isAltDown() || evt.isMetaDown()) {
evt.consume();
return;
}
switch (evt.getKeyChar()) {
case '~':
evt.consume();
if (browser.getMode() == VFSBrowser.BROWSER)
browser.setDirectory(System.getProperty("user.home"));
break;
case '/':
evt.consume();
if (browser.getMode() == VFSBrowser.BROWSER) browser.rootDirectory();
break;
case '-':
evt.consume();
if (browser.getMode() == VFSBrowser.BROWSER) {
browser.setDirectory(browser.getView().getBuffer().getDirectory());
}
break;
}
}
if (!evt.isConsumed()) super.processKeyEvent(evt);
}
@Override
public void keyPressed(final KeyEvent e) {
if (modifier(e)) return;
// operations that change the focus are put first..
if (PREVTAB.is(e)) {
transferFocusBackward();
return;
}
if (NEXTTAB.is(e)) {
transferFocus();
return;
}
if (FIND.is(e)) {
if (find != null) find.requestFocusInWindow();
return;
}
// re-animate cursor
cursor(true);
// operations without cursor movement...
final int fh = rend.fontH();
if (SCROLLDOWN.is(e)) {
scroll.pos(scroll.pos() + fh);
return;
}
if (SCROLLUP.is(e)) {
scroll.pos(scroll.pos() - fh);
return;
}
if (COPY1.is(e) || COPY2.is(e)) {
copy();
return;
}
// set cursor position and reset last column
text.pos(text.cursor());
if (!PREVLINE.is(e) && !NEXTLINE.is(e)) lastCol = -1;
if (FINDNEXT.is(e) || FINDNEXT2.is(e)) {
scroll(rend.find(true, true));
return;
}
if (FINDPREV.is(e) || FINDPREV2.is(e)) {
scroll(rend.find(false, true));
return;
}
if (SELECTALL.is(e)) {
selectAll();
return;
}
// necessary on Macs as the shift button is pressed for REDO
final boolean marking =
e.isShiftDown()
&& !DELNEXT.is(e)
&& !DELPREV.is(e)
&& !PASTE2.is(e)
&& !COMMENT.is(e)
&& !DELLINE.is(e)
&& !REDOSTEP.is(e);
final boolean nomark = !text.marked();
if (marking && nomark) text.startMark();
boolean down = true;
boolean consumed = true;
// operations that consider the last text mark..
final byte[] txt = text.text();
if (NEXTWORD.is(e)) {
text.nextToken(marking);
} else if (PREVWORD.is(e)) {
text.prevToken(marking);
down = false;
} else if (TEXTSTART.is(e)) {
if (!marking) text.noMark();
text.pos(0);
down = false;
} else if (TEXTEND.is(e)) {
if (!marking) text.noMark();
text.pos(text.size());
} else if (LINESTART.is(e)) {
text.bol(marking);
down = false;
} else if (LINEEND.is(e)) {
text.eol(marking);
} else if (NEXTPAGE.is(e)) {
down(getHeight() / fh, marking);
} else if (PREVPAGE.is(e)) {
up(getHeight() / fh, marking);
down = false;
} else if (NEXT.is(e)) {
text.next(marking);
} else if (PREV.is(e)) {
text.prev(marking);
down = false;
} else if (PREVLINE.is(e)) {
up(1, marking);
down = false;
} else if (NEXTLINE.is(e)) {
down(1, marking);
} else if (FINDERROR.is(e)) {
final int p = text.error();
if (p != -1) setCaret(p);
} else {
consumed = false;
}
if (marking) {
// refresh scroll position
text.endMark();
text.checkMark();
} else if (undo != null) {
// edit operations...
if (CUT1.is(e) || CUT2.is(e)) {
cut();
} else if (PASTE1.is(e) || PASTE2.is(e)) {
paste();
} else if (UNDOSTEP.is(e)) {
undo();
} else if (REDOSTEP.is(e)) {
redo();
} else if (COMMENT.is(e)) {
text.comment(rend.getSyntax());
} else if (DELLINE.is(e)) {
text.deleteLine();
} else if (DELLINEEND.is(e) || DELNEXTWORD.is(e) || DELNEXT.is(e)) {
if (nomark) {
if (text.pos() == text.size()) return;
text.startMark();
if (DELNEXTWORD.is(e)) {
text.nextToken(true);
} else if (DELLINEEND.is(e)) {
text.eol(true);
} else {
text.next(true);
}
text.endMark();
}
undo.cursor(text.cursor());
text.delete();
} else if (DELLINESTART.is(e) || DELPREVWORD.is(e) || DELPREV.is(e)) {
if (nomark) {
if (text.pos() == 0) return;
text.startMark();
if (DELPREVWORD.is(e)) {
text.prevToken(true);
} else if (DELLINESTART.is(e)) {
text.bol(true);
} else {
text.prev();
}
text.endMark();
}
undo.cursor(text.cursor());
text.delete();
down = false;
} else {
consumed = false;
}
}
if (consumed) e.consume();
text.setCaret();
if (txt != text.text()) rend.calc();
showCursor(down ? 2 : 0);
}
// key released
public void keyReleased(KeyEvent e) {
int KeyCode = e.getKeyCode();
mess = "You released: " + KeyEvent.getKeyText(KeyCode);
e.consume();
}
@Override
public void keyPressed(final KeyEvent e) {
// ignore modifier keys
if (specialKey(e) || modifier(e)) return;
// re-animate cursor
caret(true);
// operations without cursor movement...
final int fh = rend.fontHeight();
if (SCROLLDOWN.is(e)) {
scroll.pos(scroll.pos() + fh);
return;
}
if (SCROLLUP.is(e)) {
scroll.pos(scroll.pos() - fh);
return;
}
// set cursor position
final boolean selected = editor.selected();
final int pos = editor.pos();
final boolean shift = e.isShiftDown();
boolean down = true, consumed = true;
// move caret
int lc = Integer.MIN_VALUE;
final byte[] txt = editor.text();
if (NEXTWORD.is(e)) {
editor.nextWord(shift);
} else if (PREVWORD.is(e)) {
editor.prevWord(shift);
down = false;
} else if (TEXTSTART.is(e)) {
editor.textStart(shift);
down = false;
} else if (TEXTEND.is(e)) {
editor.textEnd(shift);
} else if (LINESTART.is(e)) {
editor.lineStart(shift);
down = false;
} else if (LINEEND.is(e)) {
editor.lineEnd(shift);
} else if (PREVPAGE_RO.is(e) && !hist.active()) {
lc = editor.linesUp(getHeight() / fh, false, lastCol);
down = false;
} else if (NEXTPAGE_RO.is(e) && !hist.active()) {
lc = editor.linesDown(getHeight() / fh, false, lastCol);
} else if (PREVPAGE.is(e) && !sc(e)) {
lc = editor.linesUp(getHeight() / fh, shift, lastCol);
down = false;
} else if (NEXTPAGE.is(e) && !sc(e)) {
lc = editor.linesDown(getHeight() / fh, shift, lastCol);
} else if (NEXTLINE.is(e) && !MOVEDOWN.is(e)) {
lc = editor.linesDown(1, shift, lastCol);
} else if (PREVLINE.is(e) && !MOVEUP.is(e)) {
lc = editor.linesUp(1, shift, lastCol);
down = false;
} else if (NEXTCHAR.is(e)) {
editor.next(shift);
} else if (PREVCHAR.is(e)) {
editor.previous(shift);
down = false;
} else {
consumed = false;
}
lastCol = lc == Integer.MIN_VALUE ? -1 : lc;
// edit text
if (hist.active()) {
if (COMPLETE.is(e)) {
complete();
return;
}
if (MOVEDOWN.is(e)) {
editor.move(true);
} else if (MOVEUP.is(e)) {
editor.move(false);
} else if (DELLINE.is(e)) {
editor.deleteLine();
} else if (DELNEXTWORD.is(e)) {
editor.deleteNext(true);
} else if (DELLINEEND.is(e)) {
editor.deleteNext(false);
} else if (DELNEXT.is(e)) {
editor.delete();
} else if (DELPREVWORD.is(e)) {
editor.deletePrev(true);
down = false;
} else if (DELLINESTART.is(e)) {
editor.deletePrev(false);
down = false;
} else if (DELPREV.is(e)) {
editor.deletePrev();
down = false;
} else {
consumed = false;
}
}
if (consumed) e.consume();
final byte[] tmp = editor.text();
if (txt != tmp) {
// text has changed: add old text to history
hist.store(tmp, pos, editor.pos());
scrollCode.invokeLater(down);
} else if (pos != editor.pos() || selected != editor.selected()) {
// cursor position or selection state has changed
cursorCode.invokeLater(down ? 2 : 0);
}
}