-xterm*
+ case KEYCODE_F1:
+ return (keyMode == 0) ? "\033OP" : transformForModifiers("\033[1", keyMode, 'P');
+ case KEYCODE_F2:
+ return (keyMode == 0) ? "\033OQ" : transformForModifiers("\033[1", keyMode, 'Q');
+ case KEYCODE_F3:
+ return (keyMode == 0) ? "\033OR" : transformForModifiers("\033[1", keyMode, 'R');
+ case KEYCODE_F4:
+ return (keyMode == 0) ? "\033OS" : transformForModifiers("\033[1", keyMode, 'S');
+ case KEYCODE_F5:
+ return transformForModifiers("\033[15", keyMode, '~');
+ case KEYCODE_F6:
+ return transformForModifiers("\033[17", keyMode, '~');
+ case KEYCODE_F7:
+ return transformForModifiers("\033[18", keyMode, '~');
+ case KEYCODE_F8:
+ return transformForModifiers("\033[19", keyMode, '~');
+ case KEYCODE_F9:
+ return transformForModifiers("\033[20", keyMode, '~');
+ case KEYCODE_F10:
+ return transformForModifiers("\033[21", keyMode, '~');
+ case KEYCODE_F11:
+ return transformForModifiers("\033[23", keyMode, '~');
+ case KEYCODE_F12:
+ return transformForModifiers("\033[24", keyMode, '~');
- case KEYCODE_ESCAPE:
- case KeyEvent.KEYCODE_BACK:
- return "\033";
+ case KEYCODE_SYSRQ:
+ return "\033[32~"; // Sys Request / Print
+ // Is this Scroll lock? case Cancel: return "\033[33~";
+ case KEYCODE_BREAK:
+ return "\033[34~"; // Pause/Break
- case KEYCODE_INSERT:
- return transformForModifiers("\033[2", keyMode, '~');
- case KEYCODE_FORWARD_DEL:
- return transformForModifiers("\033[3", keyMode, '~');
+ case KEYCODE_ESCAPE:
+ case KeyEvent.KEYCODE_BACK:
+ return "\033";
- case KEYCODE_NUMPAD_DOT:
- return keypadApplication ? "\033On" : "\033[3~";
+ case KEYCODE_INSERT:
+ return transformForModifiers("\033[2", keyMode, '~');
+ case KEYCODE_FORWARD_DEL:
+ return transformForModifiers("\033[3", keyMode, '~');
- case KEYCODE_PAGE_UP:
- return "\033[5~";
- case KEYCODE_PAGE_DOWN:
- return "\033[6~";
- case KEYCODE_DEL:
- // Yes, this needs to U+007F and not U+0008!
- return "\u007F";
- case KEYCODE_NUM_LOCK:
- return "\033OP";
+ case KEYCODE_NUMPAD_DOT:
+ return keypadApplication ? "\033On" : "\033[3~";
- case KeyEvent.KEYCODE_SPACE:
- // If ctrl is not down, return null so that it goes through normal input processing (which may e.g. cause a
- // combining accent to be written):
- return ((keyMode & KEYMOD_CTRL) == 0) ? null : "\0";
- case KEYCODE_TAB:
- // This is back-tab when shifted:
- return (keyMode & KEYMOD_SHIFT) == 0 ? "\011" : "\033[Z";
- case KEYCODE_ENTER:
- return ((keyMode & KEYMOD_ALT) == 0) ? "\r" : "\033\r";
+ case KEYCODE_PAGE_UP:
+ return "\033[5~";
+ case KEYCODE_PAGE_DOWN:
+ return "\033[6~";
+ case KEYCODE_DEL:
+ // Yes, this needs to U+007F and not U+0008!
+ return "\u007F";
+ case KEYCODE_NUM_LOCK:
+ return "\033OP";
- case KEYCODE_NUMPAD_ENTER:
- return keypadApplication ? transformForModifiers("\033O", keyMode, 'M') : "\n";
- case KEYCODE_NUMPAD_MULTIPLY:
- return keypadApplication ? transformForModifiers("\033O", keyMode, 'j') : "*";
- case KEYCODE_NUMPAD_ADD:
- return keypadApplication ? transformForModifiers("\033O", keyMode, 'k') : "+";
- case KEYCODE_NUMPAD_COMMA:
- return ",";
- case KEYCODE_NUMPAD_SUBTRACT:
- return keypadApplication ? transformForModifiers("\033O", keyMode, 'm') : "-";
- case KEYCODE_NUMPAD_DIVIDE:
- return keypadApplication ? transformForModifiers("\033O", keyMode, 'o') : "/";
- case KEYCODE_NUMPAD_0:
- return keypadApplication ? transformForModifiers("\033O", keyMode, 'p') : "1";
- case KEYCODE_NUMPAD_1:
- return keypadApplication ? transformForModifiers("\033O", keyMode, 'q') : "1";
- case KEYCODE_NUMPAD_2:
- return keypadApplication ? transformForModifiers("\033O", keyMode, 'r') : "2";
- case KEYCODE_NUMPAD_3:
- return keypadApplication ? transformForModifiers("\033O", keyMode, 's') : "3";
- case KEYCODE_NUMPAD_4:
- return keypadApplication ? transformForModifiers("\033O", keyMode, 't') : "4";
- case KEYCODE_NUMPAD_5:
- return keypadApplication ? transformForModifiers("\033O", keyMode, 'u') : "5";
- case KEYCODE_NUMPAD_6:
- return keypadApplication ? transformForModifiers("\033O", keyMode, 'v') : "6";
- case KEYCODE_NUMPAD_7:
- return keypadApplication ? transformForModifiers("\033O", keyMode, 'w') : "7";
- case KEYCODE_NUMPAD_8:
- return keypadApplication ? transformForModifiers("\033O", keyMode, 'x') : "8";
- case KEYCODE_NUMPAD_9:
- return keypadApplication ? transformForModifiers("\033O", keyMode, 'y') : "9";
- case KEYCODE_NUMPAD_EQUALS:
- return keypadApplication ? transformForModifiers("\033O", keyMode, 'X') : "=";
- }
+ case KeyEvent.KEYCODE_SPACE:
+ // If ctrl is not down, return null so that it goes through normal input processing (which may e.g. cause a
+ // combining accent to be written):
+ return ((keyMode & KEYMOD_CTRL) == 0) ? null : "\0";
+ case KEYCODE_TAB:
+ // This is back-tab when shifted:
+ return (keyMode & KEYMOD_SHIFT) == 0 ? "\011" : "\033[Z";
+ case KEYCODE_ENTER:
+ return ((keyMode & KEYMOD_ALT) == 0) ? "\r" : "\033\r";
- return null;
- }
+ case KEYCODE_NUMPAD_ENTER:
+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'M') : "\n";
+ case KEYCODE_NUMPAD_MULTIPLY:
+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'j') : "*";
+ case KEYCODE_NUMPAD_ADD:
+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'k') : "+";
+ case KEYCODE_NUMPAD_COMMA:
+ return ",";
+ case KEYCODE_NUMPAD_SUBTRACT:
+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'm') : "-";
+ case KEYCODE_NUMPAD_DIVIDE:
+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'o') : "/";
+ case KEYCODE_NUMPAD_0:
+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'p') : "1";
+ case KEYCODE_NUMPAD_1:
+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'q') : "1";
+ case KEYCODE_NUMPAD_2:
+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'r') : "2";
+ case KEYCODE_NUMPAD_3:
+ return keypadApplication ? transformForModifiers("\033O", keyMode, 's') : "3";
+ case KEYCODE_NUMPAD_4:
+ return keypadApplication ? transformForModifiers("\033O", keyMode, 't') : "4";
+ case KEYCODE_NUMPAD_5:
+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'u') : "5";
+ case KEYCODE_NUMPAD_6:
+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'v') : "6";
+ case KEYCODE_NUMPAD_7:
+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'w') : "7";
+ case KEYCODE_NUMPAD_8:
+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'x') : "8";
+ case KEYCODE_NUMPAD_9:
+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'y') : "9";
+ case KEYCODE_NUMPAD_EQUALS:
+ return keypadApplication ? transformForModifiers("\033O", keyMode, 'X') : "=";
+ }
- private static String transformForModifiers(String start, int keymod, char lastChar) {
- int modifier;
- switch (keymod) {
- case KEYMOD_SHIFT:
- modifier = 2;
- break;
- case KEYMOD_ALT:
- modifier = 3;
- break;
- case (KEYMOD_SHIFT | KEYMOD_ALT):
- modifier = 4;
- break;
- case KEYMOD_CTRL:
- modifier = 5;
- break;
- case KEYMOD_SHIFT | KEYMOD_CTRL:
- modifier = 6;
- break;
- case KEYMOD_ALT | KEYMOD_CTRL:
- modifier = 7;
- break;
- case KEYMOD_SHIFT | KEYMOD_ALT | KEYMOD_CTRL:
- modifier = 8;
- break;
- default:
- return start + lastChar;
- }
- return start + (";" + modifier) + lastChar;
- }
+ return null;
+ }
+
+ private static String transformForModifiers(String start, int keymod, char lastChar) {
+ int modifier;
+ switch (keymod) {
+ case KEYMOD_SHIFT:
+ modifier = 2;
+ break;
+ case KEYMOD_ALT:
+ modifier = 3;
+ break;
+ case (KEYMOD_SHIFT | KEYMOD_ALT):
+ modifier = 4;
+ break;
+ case KEYMOD_CTRL:
+ modifier = 5;
+ break;
+ case KEYMOD_SHIFT | KEYMOD_CTRL:
+ modifier = 6;
+ break;
+ case KEYMOD_ALT | KEYMOD_CTRL:
+ modifier = 7;
+ break;
+ case KEYMOD_SHIFT | KEYMOD_ALT | KEYMOD_CTRL:
+ modifier = 8;
+ break;
+ default:
+ return start + lastChar;
+ }
+ return start + (";" + modifier) + lastChar;
+ }
}
diff --git a/app/src/main/java/com/termux/terminal/TerminalBuffer.java b/app/src/main/java/com/termux/terminal/TerminalBuffer.java
index c499ee3d..b57a8d00 100644
--- a/app/src/main/java/com/termux/terminal/TerminalBuffer.java
+++ b/app/src/main/java/com/termux/terminal/TerminalBuffer.java
@@ -3,441 +3,425 @@ package com.termux.terminal;
/**
* A circular buffer of {@link TerminalRow}:s which keeps notes about what is visible on a logical screen and the scroll
* history.
- *
+ *
* See {@link #externalToInternalRow(int)} for how to map from logical screen rows to array indices.
*/
public final class TerminalBuffer {
- TerminalRow[] mLines;
- /** The length of {@link #mLines}. */
- int mTotalRows;
- /** The number of rows and columns visible on the screen. */
- int mScreenRows, mColumns;
- /** The number of rows kept in history. */
- private int mActiveTranscriptRows = 0;
- /** The index in the circular buffer where the visible screen starts. */
- private int mScreenFirstRow = 0;
+ TerminalRow[] mLines;
+ /** The length of {@link #mLines}. */
+ int mTotalRows;
+ /** The number of rows and columns visible on the screen. */
+ int mScreenRows, mColumns;
+ /** The number of rows kept in history. */
+ private int mActiveTranscriptRows = 0;
+ /** The index in the circular buffer where the visible screen starts. */
+ private int mScreenFirstRow = 0;
- /**
- * Create a transcript screen.
- *
- * @param columns
- * the width of the screen in characters.
- * @param totalRows
- * the height of the entire text area, in rows of text.
- * @param screenRows
- * the height of just the screen, not including the transcript that holds lines that have scrolled off
- * the top of the screen.
- */
- public TerminalBuffer(int columns, int totalRows, int screenRows) {
- mColumns = columns;
- mTotalRows = totalRows;
- mScreenRows = screenRows;
- mLines = new TerminalRow[totalRows];
+ /**
+ * Create a transcript screen.
+ *
+ * @param columns the width of the screen in characters.
+ * @param totalRows the height of the entire text area, in rows of text.
+ * @param screenRows the height of just the screen, not including the transcript that holds lines that have scrolled off
+ * the top of the screen.
+ */
+ public TerminalBuffer(int columns, int totalRows, int screenRows) {
+ mColumns = columns;
+ mTotalRows = totalRows;
+ mScreenRows = screenRows;
+ mLines = new TerminalRow[totalRows];
- blockSet(0, 0, columns, screenRows, ' ', TextStyle.NORMAL);
- }
+ blockSet(0, 0, columns, screenRows, ' ', TextStyle.NORMAL);
+ }
- public String getTranscriptText() {
- return getSelectedText(0, -getActiveTranscriptRows(), mColumns, mScreenRows).trim();
- }
+ public String getTranscriptText() {
+ return getSelectedText(0, -getActiveTranscriptRows(), mColumns, mScreenRows).trim();
+ }
- public String getSelectedText(int selX1, int selY1, int selX2, int selY2) {
- final StringBuilder builder = new StringBuilder();
- final int columns = mColumns;
+ public String getSelectedText(int selX1, int selY1, int selX2, int selY2) {
+ final StringBuilder builder = new StringBuilder();
+ final int columns = mColumns;
- if (selY1 < -getActiveTranscriptRows()) selY1 = -getActiveTranscriptRows();
- if (selY2 >= mScreenRows) selY2 = mScreenRows - 1;
+ if (selY1 < -getActiveTranscriptRows()) selY1 = -getActiveTranscriptRows();
+ if (selY2 >= mScreenRows) selY2 = mScreenRows - 1;
- for (int row = selY1; row <= selY2; row++) {
- int x1 = (row == selY1) ? selX1 : 0;
- int x2;
- if (row == selY2) {
- x2 = selX2 + 1;
- if (x2 > columns) x2 = columns;
- } else {
- x2 = columns;
- }
- TerminalRow lineObject = mLines[externalToInternalRow(row)];
- int x1Index = lineObject.findStartOfColumn(x1);
- int x2Index = (x2 < mColumns) ? lineObject.findStartOfColumn(x2) : lineObject.getSpaceUsed();
- if (x2Index == x1Index) {
- // Selected the start of a wide character.
- x2Index = lineObject.findStartOfColumn(x2+1);
- }
- char[] line = lineObject.mText;
- int lastPrintingCharIndex = -1;
- int i;
- boolean rowLineWrap = getLineWrap(row);
- if (rowLineWrap && x2 == columns) {
- // If the line was wrapped, we shouldn't lose trailing space:
- lastPrintingCharIndex = x2Index - 1;
- } else {
- for (i = x1Index; i < x2Index; ++i) {
- char c = line[i];
- if (c != ' ') lastPrintingCharIndex = i;
- }
- }
- if (lastPrintingCharIndex != -1) builder.append(line, x1Index, lastPrintingCharIndex - x1Index + 1);
- if (!rowLineWrap && row < selY2 && row < mScreenRows - 1) builder.append('\n');
- }
- return builder.toString();
- }
+ for (int row = selY1; row <= selY2; row++) {
+ int x1 = (row == selY1) ? selX1 : 0;
+ int x2;
+ if (row == selY2) {
+ x2 = selX2 + 1;
+ if (x2 > columns) x2 = columns;
+ } else {
+ x2 = columns;
+ }
+ TerminalRow lineObject = mLines[externalToInternalRow(row)];
+ int x1Index = lineObject.findStartOfColumn(x1);
+ int x2Index = (x2 < mColumns) ? lineObject.findStartOfColumn(x2) : lineObject.getSpaceUsed();
+ if (x2Index == x1Index) {
+ // Selected the start of a wide character.
+ x2Index = lineObject.findStartOfColumn(x2 + 1);
+ }
+ char[] line = lineObject.mText;
+ int lastPrintingCharIndex = -1;
+ int i;
+ boolean rowLineWrap = getLineWrap(row);
+ if (rowLineWrap && x2 == columns) {
+ // If the line was wrapped, we shouldn't lose trailing space:
+ lastPrintingCharIndex = x2Index - 1;
+ } else {
+ for (i = x1Index; i < x2Index; ++i) {
+ char c = line[i];
+ if (c != ' ') lastPrintingCharIndex = i;
+ }
+ }
+ if (lastPrintingCharIndex != -1)
+ builder.append(line, x1Index, lastPrintingCharIndex - x1Index + 1);
+ if (!rowLineWrap && row < selY2 && row < mScreenRows - 1) builder.append('\n');
+ }
+ return builder.toString();
+ }
- public int getActiveTranscriptRows() {
- return mActiveTranscriptRows;
- }
+ public int getActiveTranscriptRows() {
+ return mActiveTranscriptRows;
+ }
- public int getActiveRows() {
- return mActiveTranscriptRows + mScreenRows;
- }
+ public int getActiveRows() {
+ return mActiveTranscriptRows + mScreenRows;
+ }
- /**
- * Convert a row value from the public external coordinate system to our internal private coordinate system.
- *
- *
- * - External coordinate system: -mActiveTranscriptRows to mScreenRows-1, with the screen being 0..mScreenRows-1.
- *
- Internal coordinate system: the mScreenRows lines starting at mScreenFirstRow comprise the screen, while the
- * mActiveTranscriptRows lines ending at mScreenFirstRow-1 form the transcript (as a circular buffer).
- *
- *
- * External <---> Internal:
- *
- *
- * [ ... ] [ ... ]
- * [ -mActiveTranscriptRows ] [ mScreenFirstRow - mActiveTranscriptRows ]
- * [ ... ] [ ... ]
- * [ 0 (visible screen starts here) ] <-----> [ mScreenFirstRow ]
- * [ ... ] [ ... ]
- * [ mScreenRows-1 ] [ mScreenFirstRow + mScreenRows-1 ]
- *
- *
- * @param externalRow
- * a row in the external coordinate system.
- * @return The row corresponding to the input argument in the private coordinate system.
- */
- public int externalToInternalRow(int externalRow) {
- if (externalRow < -mActiveTranscriptRows || externalRow > mScreenRows)
- throw new IllegalArgumentException("extRow=" + externalRow + ", mScreenRows=" + mScreenRows + ", mActiveTranscriptRows=" + mActiveTranscriptRows);
- final int internalRow = mScreenFirstRow + externalRow;
- return (internalRow < 0) ? (mTotalRows + internalRow) : (internalRow % mTotalRows);
- }
+ /**
+ * Convert a row value from the public external coordinate system to our internal private coordinate system.
+ *
+ *
+ * - External coordinate system: -mActiveTranscriptRows to mScreenRows-1, with the screen being 0..mScreenRows-1.
+ *
- Internal coordinate system: the mScreenRows lines starting at mScreenFirstRow comprise the screen, while the
+ * mActiveTranscriptRows lines ending at mScreenFirstRow-1 form the transcript (as a circular buffer).
+ *
+ *
+ * External <---> Internal:
+ *
+ *
+ * [ ... ] [ ... ]
+ * [ -mActiveTranscriptRows ] [ mScreenFirstRow - mActiveTranscriptRows ]
+ * [ ... ] [ ... ]
+ * [ 0 (visible screen starts here) ] <-----> [ mScreenFirstRow ]
+ * [ ... ] [ ... ]
+ * [ mScreenRows-1 ] [ mScreenFirstRow + mScreenRows-1 ]
+ *
+ *
+ * @param externalRow a row in the external coordinate system.
+ * @return The row corresponding to the input argument in the private coordinate system.
+ */
+ public int externalToInternalRow(int externalRow) {
+ if (externalRow < -mActiveTranscriptRows || externalRow > mScreenRows)
+ throw new IllegalArgumentException("extRow=" + externalRow + ", mScreenRows=" + mScreenRows + ", mActiveTranscriptRows=" + mActiveTranscriptRows);
+ final int internalRow = mScreenFirstRow + externalRow;
+ return (internalRow < 0) ? (mTotalRows + internalRow) : (internalRow % mTotalRows);
+ }
- public void setLineWrap(int row) {
- mLines[externalToInternalRow(row)].mLineWrap = true;
- }
+ public void setLineWrap(int row) {
+ mLines[externalToInternalRow(row)].mLineWrap = true;
+ }
- public boolean getLineWrap(int row) {
- return mLines[externalToInternalRow(row)].mLineWrap;
- }
+ public boolean getLineWrap(int row) {
+ return mLines[externalToInternalRow(row)].mLineWrap;
+ }
public void clearLineWrap(int row) {
mLines[externalToInternalRow(row)].mLineWrap = false;
}
- /**
- * Resize the screen which this transcript backs. Currently, this only works if the number of columns does not
- * change or the rows expand (that is, it only works when shrinking the number of rows).
- *
- * @param newColumns
- * The number of columns the screen should have.
- * @param newRows
- * The number of rows the screen should have.
- * @param cursor
- * An int[2] containing the (column, row) cursor location.
- */
- public void resize(int newColumns, int newRows, int newTotalRows, int[] cursor, int currentStyle, boolean altScreen) {
- // newRows > mTotalRows should not normally happen since mTotalRows is TRANSCRIPT_ROWS (10000):
- if (newColumns == mColumns && newRows <= mTotalRows) {
- // Fast resize where just the rows changed.
- int shiftDownOfTopRow = mScreenRows - newRows;
- if (shiftDownOfTopRow > 0 && shiftDownOfTopRow < mScreenRows) {
- // Shrinking. Check if we can skip blank rows at bottom below cursor.
- for (int i = mScreenRows - 1; i > 0; i--) {
- if (cursor[1] >= i) break;
- int r = externalToInternalRow(i);
- if (mLines[r] == null || mLines[r].isBlank()) {
- if (--shiftDownOfTopRow == 0) break;
- }
- }
- } else if (shiftDownOfTopRow < 0) {
- // Negative shift down = expanding. Only move screen up if there is transcript to show:
- int actualShift = Math.max(shiftDownOfTopRow, -mActiveTranscriptRows);
- if (shiftDownOfTopRow != actualShift) {
- // The new lines revealed by the resizing are not all from the transcript. Blank the below ones.
- for (int i = 0; i < actualShift - shiftDownOfTopRow; i++)
- allocateFullLineIfNecessary((mScreenFirstRow + mScreenRows + i) % mTotalRows).clear(currentStyle);
- shiftDownOfTopRow = actualShift;
- }
- }
- mScreenFirstRow += shiftDownOfTopRow;
- mScreenFirstRow = (mScreenFirstRow < 0) ? (mScreenFirstRow + mTotalRows) : (mScreenFirstRow % mTotalRows);
- mTotalRows = newTotalRows;
- mActiveTranscriptRows = altScreen ? 0 : Math.max(0, mActiveTranscriptRows + shiftDownOfTopRow);
- cursor[1] -= shiftDownOfTopRow;
- mScreenRows = newRows;
- } else {
- // Copy away old state and update new:
- TerminalRow[] oldLines = mLines;
- mLines = new TerminalRow[newTotalRows];
- for (int i = 0; i < newTotalRows; i++)
- mLines[i] = new TerminalRow(newColumns, currentStyle);
+ /**
+ * Resize the screen which this transcript backs. Currently, this only works if the number of columns does not
+ * change or the rows expand (that is, it only works when shrinking the number of rows).
+ *
+ * @param newColumns The number of columns the screen should have.
+ * @param newRows The number of rows the screen should have.
+ * @param cursor An int[2] containing the (column, row) cursor location.
+ */
+ public void resize(int newColumns, int newRows, int newTotalRows, int[] cursor, int currentStyle, boolean altScreen) {
+ // newRows > mTotalRows should not normally happen since mTotalRows is TRANSCRIPT_ROWS (10000):
+ if (newColumns == mColumns && newRows <= mTotalRows) {
+ // Fast resize where just the rows changed.
+ int shiftDownOfTopRow = mScreenRows - newRows;
+ if (shiftDownOfTopRow > 0 && shiftDownOfTopRow < mScreenRows) {
+ // Shrinking. Check if we can skip blank rows at bottom below cursor.
+ for (int i = mScreenRows - 1; i > 0; i--) {
+ if (cursor[1] >= i) break;
+ int r = externalToInternalRow(i);
+ if (mLines[r] == null || mLines[r].isBlank()) {
+ if (--shiftDownOfTopRow == 0) break;
+ }
+ }
+ } else if (shiftDownOfTopRow < 0) {
+ // Negative shift down = expanding. Only move screen up if there is transcript to show:
+ int actualShift = Math.max(shiftDownOfTopRow, -mActiveTranscriptRows);
+ if (shiftDownOfTopRow != actualShift) {
+ // The new lines revealed by the resizing are not all from the transcript. Blank the below ones.
+ for (int i = 0; i < actualShift - shiftDownOfTopRow; i++)
+ allocateFullLineIfNecessary((mScreenFirstRow + mScreenRows + i) % mTotalRows).clear(currentStyle);
+ shiftDownOfTopRow = actualShift;
+ }
+ }
+ mScreenFirstRow += shiftDownOfTopRow;
+ mScreenFirstRow = (mScreenFirstRow < 0) ? (mScreenFirstRow + mTotalRows) : (mScreenFirstRow % mTotalRows);
+ mTotalRows = newTotalRows;
+ mActiveTranscriptRows = altScreen ? 0 : Math.max(0, mActiveTranscriptRows + shiftDownOfTopRow);
+ cursor[1] -= shiftDownOfTopRow;
+ mScreenRows = newRows;
+ } else {
+ // Copy away old state and update new:
+ TerminalRow[] oldLines = mLines;
+ mLines = new TerminalRow[newTotalRows];
+ for (int i = 0; i < newTotalRows; i++)
+ mLines[i] = new TerminalRow(newColumns, currentStyle);
- final int oldActiveTranscriptRows = mActiveTranscriptRows;
- final int oldScreenFirstRow = mScreenFirstRow;
- final int oldScreenRows = mScreenRows;
- final int oldTotalRows = mTotalRows;
- mTotalRows = newTotalRows;
- mScreenRows = newRows;
- mActiveTranscriptRows = mScreenFirstRow = 0;
- mColumns = newColumns;
+ final int oldActiveTranscriptRows = mActiveTranscriptRows;
+ final int oldScreenFirstRow = mScreenFirstRow;
+ final int oldScreenRows = mScreenRows;
+ final int oldTotalRows = mTotalRows;
+ mTotalRows = newTotalRows;
+ mScreenRows = newRows;
+ mActiveTranscriptRows = mScreenFirstRow = 0;
+ mColumns = newColumns;
- int newCursorRow = -1;
- int newCursorColumn = -1;
- int oldCursorRow = cursor[1];
- int oldCursorColumn = cursor[0];
- boolean newCursorPlaced = false;
+ int newCursorRow = -1;
+ int newCursorColumn = -1;
+ int oldCursorRow = cursor[1];
+ int oldCursorColumn = cursor[0];
+ boolean newCursorPlaced = false;
- int currentOutputExternalRow = 0;
- int currentOutputExternalColumn = 0;
+ int currentOutputExternalRow = 0;
+ int currentOutputExternalColumn = 0;
- // Loop over every character in the initial state.
- // Blank lines should be skipped only if at end of transcript (just as is done in the "fast" resize), so we
- // keep track how many blank lines we have skipped if we later on find a non-blank line.
- int skippedBlankLines = 0;
- for (int externalOldRow = -oldActiveTranscriptRows; externalOldRow < oldScreenRows; externalOldRow++) {
- // Do what externalToInternalRow() does but for the old state:
- int internalOldRow = oldScreenFirstRow + externalOldRow;
- internalOldRow = (internalOldRow < 0) ? (oldTotalRows + internalOldRow) : (internalOldRow % oldTotalRows);
+ // Loop over every character in the initial state.
+ // Blank lines should be skipped only if at end of transcript (just as is done in the "fast" resize), so we
+ // keep track how many blank lines we have skipped if we later on find a non-blank line.
+ int skippedBlankLines = 0;
+ for (int externalOldRow = -oldActiveTranscriptRows; externalOldRow < oldScreenRows; externalOldRow++) {
+ // Do what externalToInternalRow() does but for the old state:
+ int internalOldRow = oldScreenFirstRow + externalOldRow;
+ internalOldRow = (internalOldRow < 0) ? (oldTotalRows + internalOldRow) : (internalOldRow % oldTotalRows);
- TerminalRow oldLine = oldLines[internalOldRow];
- boolean cursorAtThisRow = externalOldRow == oldCursorRow;
- // The cursor may only be on a non-null line, which we should not skip:
- if (oldLine == null || (!(!newCursorPlaced && cursorAtThisRow)) && oldLine.isBlank()) {
- skippedBlankLines++;
- continue;
- } else if (skippedBlankLines > 0) {
- // After skipping some blank lines we encounter a non-blank line. Insert the skipped blank lines.
- for (int i = 0; i < skippedBlankLines; i++) {
- if (currentOutputExternalRow == mScreenRows - 1) {
- scrollDownOneLine(0, mScreenRows, currentStyle);
- } else {
- currentOutputExternalRow++;
- }
- currentOutputExternalColumn = 0;
- }
- skippedBlankLines = 0;
- }
+ TerminalRow oldLine = oldLines[internalOldRow];
+ boolean cursorAtThisRow = externalOldRow == oldCursorRow;
+ // The cursor may only be on a non-null line, which we should not skip:
+ if (oldLine == null || (!(!newCursorPlaced && cursorAtThisRow)) && oldLine.isBlank()) {
+ skippedBlankLines++;
+ continue;
+ } else if (skippedBlankLines > 0) {
+ // After skipping some blank lines we encounter a non-blank line. Insert the skipped blank lines.
+ for (int i = 0; i < skippedBlankLines; i++) {
+ if (currentOutputExternalRow == mScreenRows - 1) {
+ scrollDownOneLine(0, mScreenRows, currentStyle);
+ } else {
+ currentOutputExternalRow++;
+ }
+ currentOutputExternalColumn = 0;
+ }
+ skippedBlankLines = 0;
+ }
- int lastNonSpaceIndex = 0;
- boolean justToCursor = false;
- if (cursorAtThisRow || oldLine.mLineWrap) {
- // Take the whole line, either because of cursor on it, or if line wrapping.
- lastNonSpaceIndex = oldLine.getSpaceUsed();
- if (cursorAtThisRow) justToCursor = true;
- } else {
- for (int i = 0; i < oldLine.getSpaceUsed(); i++)
- // NEWLY INTRODUCED BUG! Should not index oldLine.mStyle with char indices
- if (oldLine.mText[i] != ' '/* || oldLine.mStyle[i] != currentStyle */) lastNonSpaceIndex = i + 1;
- }
+ int lastNonSpaceIndex = 0;
+ boolean justToCursor = false;
+ if (cursorAtThisRow || oldLine.mLineWrap) {
+ // Take the whole line, either because of cursor on it, or if line wrapping.
+ lastNonSpaceIndex = oldLine.getSpaceUsed();
+ if (cursorAtThisRow) justToCursor = true;
+ } else {
+ for (int i = 0; i < oldLine.getSpaceUsed(); i++)
+ // NEWLY INTRODUCED BUG! Should not index oldLine.mStyle with char indices
+ if (oldLine.mText[i] != ' '/* || oldLine.mStyle[i] != currentStyle */)
+ lastNonSpaceIndex = i + 1;
+ }
- int currentOldCol = 0;
- int styleAtCol = 0;
- for (int i = 0; i < lastNonSpaceIndex; i++) {
- // Note that looping over java character, not cells.
- char c = oldLine.mText[i];
- int codePoint = (Character.isHighSurrogate(c)) ? Character.toCodePoint(c, oldLine.mText[++i]) : c;
- int displayWidth = WcWidth.width(codePoint);
- // Use the last style if this is a zero-width character:
- if (displayWidth > 0) styleAtCol = oldLine.getStyle(currentOldCol);
+ int currentOldCol = 0;
+ int styleAtCol = 0;
+ for (int i = 0; i < lastNonSpaceIndex; i++) {
+ // Note that looping over java character, not cells.
+ char c = oldLine.mText[i];
+ int codePoint = (Character.isHighSurrogate(c)) ? Character.toCodePoint(c, oldLine.mText[++i]) : c;
+ int displayWidth = WcWidth.width(codePoint);
+ // Use the last style if this is a zero-width character:
+ if (displayWidth > 0) styleAtCol = oldLine.getStyle(currentOldCol);
- // Line wrap as necessary:
- if (currentOutputExternalColumn + displayWidth > mColumns) {
- setLineWrap(currentOutputExternalRow);
- if (currentOutputExternalRow == mScreenRows - 1) {
- if (newCursorPlaced) newCursorRow--;
- scrollDownOneLine(0, mScreenRows, currentStyle);
- } else {
- currentOutputExternalRow++;
- }
- currentOutputExternalColumn = 0;
- }
+ // Line wrap as necessary:
+ if (currentOutputExternalColumn + displayWidth > mColumns) {
+ setLineWrap(currentOutputExternalRow);
+ if (currentOutputExternalRow == mScreenRows - 1) {
+ if (newCursorPlaced) newCursorRow--;
+ scrollDownOneLine(0, mScreenRows, currentStyle);
+ } else {
+ currentOutputExternalRow++;
+ }
+ currentOutputExternalColumn = 0;
+ }
- int offsetDueToCombiningChar = ((displayWidth <= 0 && currentOutputExternalColumn > 0) ? 1 : 0);
- int outputColumn = currentOutputExternalColumn - offsetDueToCombiningChar;
- setChar(outputColumn, currentOutputExternalRow, codePoint, styleAtCol);
+ int offsetDueToCombiningChar = ((displayWidth <= 0 && currentOutputExternalColumn > 0) ? 1 : 0);
+ int outputColumn = currentOutputExternalColumn - offsetDueToCombiningChar;
+ setChar(outputColumn, currentOutputExternalRow, codePoint, styleAtCol);
- if (displayWidth > 0) {
- if (oldCursorRow == externalOldRow && oldCursorColumn == currentOldCol) {
- newCursorColumn = currentOutputExternalColumn;
- newCursorRow = currentOutputExternalRow;
- newCursorPlaced = true;
- }
- currentOldCol += displayWidth;
- currentOutputExternalColumn += displayWidth;
- if (justToCursor && newCursorPlaced) break;
- }
- }
- // Old row has been copied. Check if we need to insert newline if old line was not wrapping:
- if (externalOldRow != (oldScreenRows - 1) && !oldLine.mLineWrap) {
- if (currentOutputExternalRow == mScreenRows - 1) {
- if (newCursorPlaced) newCursorRow--;
- scrollDownOneLine(0, mScreenRows, currentStyle);
- } else {
- currentOutputExternalRow++;
- }
- currentOutputExternalColumn = 0;
- }
- }
+ if (displayWidth > 0) {
+ if (oldCursorRow == externalOldRow && oldCursorColumn == currentOldCol) {
+ newCursorColumn = currentOutputExternalColumn;
+ newCursorRow = currentOutputExternalRow;
+ newCursorPlaced = true;
+ }
+ currentOldCol += displayWidth;
+ currentOutputExternalColumn += displayWidth;
+ if (justToCursor && newCursorPlaced) break;
+ }
+ }
+ // Old row has been copied. Check if we need to insert newline if old line was not wrapping:
+ if (externalOldRow != (oldScreenRows - 1) && !oldLine.mLineWrap) {
+ if (currentOutputExternalRow == mScreenRows - 1) {
+ if (newCursorPlaced) newCursorRow--;
+ scrollDownOneLine(0, mScreenRows, currentStyle);
+ } else {
+ currentOutputExternalRow++;
+ }
+ currentOutputExternalColumn = 0;
+ }
+ }
- cursor[0] = newCursorColumn;
- cursor[1] = newCursorRow;
- }
+ cursor[0] = newCursorColumn;
+ cursor[1] = newCursorRow;
+ }
- // Handle cursor scrolling off screen:
- if (cursor[0] < 0 || cursor[1] < 0) cursor[0] = cursor[1] = 0;
- }
+ // Handle cursor scrolling off screen:
+ if (cursor[0] < 0 || cursor[1] < 0) cursor[0] = cursor[1] = 0;
+ }
- /**
- * Block copy lines and associated metadata from one location to another in the circular buffer, taking wraparound
- * into account.
- *
- * @param srcInternal
- * The first line to be copied.
- * @param len
- * The number of lines to be copied.
- */
- private void blockCopyLinesDown(int srcInternal, int len) {
- if (len == 0) return;
- int totalRows = mTotalRows;
+ /**
+ * Block copy lines and associated metadata from one location to another in the circular buffer, taking wraparound
+ * into account.
+ *
+ * @param srcInternal The first line to be copied.
+ * @param len The number of lines to be copied.
+ */
+ private void blockCopyLinesDown(int srcInternal, int len) {
+ if (len == 0) return;
+ int totalRows = mTotalRows;
- int start = len - 1;
- // Save away line to be overwritten:
- TerminalRow lineToBeOverWritten = mLines[(srcInternal + start + 1) % totalRows];
- // Do the copy from bottom to top.
- for (int i = start; i >= 0; --i)
- mLines[(srcInternal + i + 1) % totalRows] = mLines[(srcInternal + i) % totalRows];
- // Put back overwritten line, now above the block:
- mLines[(srcInternal) % totalRows] = lineToBeOverWritten;
- }
+ int start = len - 1;
+ // Save away line to be overwritten:
+ TerminalRow lineToBeOverWritten = mLines[(srcInternal + start + 1) % totalRows];
+ // Do the copy from bottom to top.
+ for (int i = start; i >= 0; --i)
+ mLines[(srcInternal + i + 1) % totalRows] = mLines[(srcInternal + i) % totalRows];
+ // Put back overwritten line, now above the block:
+ mLines[(srcInternal) % totalRows] = lineToBeOverWritten;
+ }
- /**
- * Scroll the screen down one line. To scroll the whole screen of a 24 line screen, the arguments would be (0, 24).
- *
- * @param topMargin
- * First line that is scrolled.
- * @param bottomMargin
- * One line after the last line that is scrolled.
- * @param style
- * the style for the newly exposed line.
- */
- public void scrollDownOneLine(int topMargin, int bottomMargin, int style) {
- if (topMargin > bottomMargin - 1 || topMargin < 0 || bottomMargin > mScreenRows)
- throw new IllegalArgumentException("topMargin=" + topMargin + ", bottomMargin=" + bottomMargin + ", mScreenRows=" + mScreenRows);
+ /**
+ * Scroll the screen down one line. To scroll the whole screen of a 24 line screen, the arguments would be (0, 24).
+ *
+ * @param topMargin First line that is scrolled.
+ * @param bottomMargin One line after the last line that is scrolled.
+ * @param style the style for the newly exposed line.
+ */
+ public void scrollDownOneLine(int topMargin, int bottomMargin, int style) {
+ if (topMargin > bottomMargin - 1 || topMargin < 0 || bottomMargin > mScreenRows)
+ throw new IllegalArgumentException("topMargin=" + topMargin + ", bottomMargin=" + bottomMargin + ", mScreenRows=" + mScreenRows);
- // Copy the fixed topMargin lines one line down so that they remain on screen in same position:
- blockCopyLinesDown(mScreenFirstRow, topMargin);
- // Copy the fixed mScreenRows-bottomMargin lines one line down so that they remain on screen in same
- // position:
- blockCopyLinesDown(externalToInternalRow(bottomMargin), mScreenRows - bottomMargin);
+ // Copy the fixed topMargin lines one line down so that they remain on screen in same position:
+ blockCopyLinesDown(mScreenFirstRow, topMargin);
+ // Copy the fixed mScreenRows-bottomMargin lines one line down so that they remain on screen in same
+ // position:
+ blockCopyLinesDown(externalToInternalRow(bottomMargin), mScreenRows - bottomMargin);
- // Update the screen location in the ring buffer:
- mScreenFirstRow = (mScreenFirstRow + 1) % mTotalRows;
- // Note that the history has grown if not already full:
- if (mActiveTranscriptRows < mTotalRows - mScreenRows) mActiveTranscriptRows++;
+ // Update the screen location in the ring buffer:
+ mScreenFirstRow = (mScreenFirstRow + 1) % mTotalRows;
+ // Note that the history has grown if not already full:
+ if (mActiveTranscriptRows < mTotalRows - mScreenRows) mActiveTranscriptRows++;
- // Blank the newly revealed line above the bottom margin:
- int blankRow = externalToInternalRow(bottomMargin - 1);
- if (mLines[blankRow] == null) {
- mLines[blankRow] = new TerminalRow(mColumns, style);
- } else {
- mLines[blankRow].clear(style);
- }
- }
+ // Blank the newly revealed line above the bottom margin:
+ int blankRow = externalToInternalRow(bottomMargin - 1);
+ if (mLines[blankRow] == null) {
+ mLines[blankRow] = new TerminalRow(mColumns, style);
+ } else {
+ mLines[blankRow].clear(style);
+ }
+ }
- /**
- * Block copy characters from one position in the screen to another. The two positions can overlap. All characters
- * of the source and destination must be within the bounds of the screen, or else an InvalidParameterException will
- * be thrown.
- *
- * @param sx
- * source X coordinate
- * @param sy
- * source Y coordinate
- * @param w
- * width
- * @param h
- * height
- * @param dx
- * destination X coordinate
- * @param dy
- * destination Y coordinate
- */
- public void blockCopy(int sx, int sy, int w, int h, int dx, int dy) {
- if (w == 0) return;
- if (sx < 0 || sx + w > mColumns || sy < 0 || sy + h > mScreenRows || dx < 0 || dx + w > mColumns || dy < 0 || dy + h > mScreenRows)
- throw new IllegalArgumentException();
- boolean copyingUp = sy > dy;
- for (int y = 0; y < h; y++) {
- int y2 = copyingUp ? y : (h - (y + 1));
- TerminalRow sourceRow = allocateFullLineIfNecessary(externalToInternalRow(sy + y2));
- allocateFullLineIfNecessary(externalToInternalRow(dy + y2)).copyInterval(sourceRow, sx, sx + w, dx);
- }
- }
+ /**
+ * Block copy characters from one position in the screen to another. The two positions can overlap. All characters
+ * of the source and destination must be within the bounds of the screen, or else an InvalidParameterException will
+ * be thrown.
+ *
+ * @param sx source X coordinate
+ * @param sy source Y coordinate
+ * @param w width
+ * @param h height
+ * @param dx destination X coordinate
+ * @param dy destination Y coordinate
+ */
+ public void blockCopy(int sx, int sy, int w, int h, int dx, int dy) {
+ if (w == 0) return;
+ if (sx < 0 || sx + w > mColumns || sy < 0 || sy + h > mScreenRows || dx < 0 || dx + w > mColumns || dy < 0 || dy + h > mScreenRows)
+ throw new IllegalArgumentException();
+ boolean copyingUp = sy > dy;
+ for (int y = 0; y < h; y++) {
+ int y2 = copyingUp ? y : (h - (y + 1));
+ TerminalRow sourceRow = allocateFullLineIfNecessary(externalToInternalRow(sy + y2));
+ allocateFullLineIfNecessary(externalToInternalRow(dy + y2)).copyInterval(sourceRow, sx, sx + w, dx);
+ }
+ }
- /**
- * Block set characters. All characters must be within the bounds of the screen, or else and
- * InvalidParemeterException will be thrown. Typically this is called with a "val" argument of 32 to clear a block
- * of characters.
- */
- public void blockSet(int sx, int sy, int w, int h, int val, int style) {
- if (sx < 0 || sx + w > mColumns || sy < 0 || sy + h > mScreenRows) {
- throw new IllegalArgumentException(
- "Illegal arguments! blockSet(" + sx + ", " + sy + ", " + w + ", " + h + ", " + val + ", " + mColumns + ", " + mScreenRows + ")");
- }
- for (int y = 0; y < h; y++)
- for (int x = 0; x < w; x++)
- setChar(sx + x, sy + y, val, style);
- }
+ /**
+ * Block set characters. All characters must be within the bounds of the screen, or else and
+ * InvalidParemeterException will be thrown. Typically this is called with a "val" argument of 32 to clear a block
+ * of characters.
+ */
+ public void blockSet(int sx, int sy, int w, int h, int val, int style) {
+ if (sx < 0 || sx + w > mColumns || sy < 0 || sy + h > mScreenRows) {
+ throw new IllegalArgumentException(
+ "Illegal arguments! blockSet(" + sx + ", " + sy + ", " + w + ", " + h + ", " + val + ", " + mColumns + ", " + mScreenRows + ")");
+ }
+ for (int y = 0; y < h; y++)
+ for (int x = 0; x < w; x++)
+ setChar(sx + x, sy + y, val, style);
+ }
- public TerminalRow allocateFullLineIfNecessary(int row) {
- return (mLines[row] == null) ? (mLines[row] = new TerminalRow(mColumns, 0)) : mLines[row];
- }
+ public TerminalRow allocateFullLineIfNecessary(int row) {
+ return (mLines[row] == null) ? (mLines[row] = new TerminalRow(mColumns, 0)) : mLines[row];
+ }
- public void setChar(int column, int row, int codePoint, int style) {
- if (row >= mScreenRows || column >= mColumns)
- throw new IllegalArgumentException("row=" + row + ", column=" + column + ", mScreenRows=" + mScreenRows + ", mColumns=" + mColumns);
- row = externalToInternalRow(row);
- allocateFullLineIfNecessary(row).setChar(column, codePoint, style);
- }
+ public void setChar(int column, int row, int codePoint, int style) {
+ if (row >= mScreenRows || column >= mColumns)
+ throw new IllegalArgumentException("row=" + row + ", column=" + column + ", mScreenRows=" + mScreenRows + ", mColumns=" + mColumns);
+ row = externalToInternalRow(row);
+ allocateFullLineIfNecessary(row).setChar(column, codePoint, style);
+ }
- public int getStyleAt(int externalRow, int column) {
- return allocateFullLineIfNecessary(externalToInternalRow(externalRow)).getStyle(column);
- }
+ public int getStyleAt(int externalRow, int column) {
+ return allocateFullLineIfNecessary(externalToInternalRow(externalRow)).getStyle(column);
+ }
- /** Support for http://vt100.net/docs/vt510-rm/DECCARA and http://vt100.net/docs/vt510-rm/DECCARA */
- public void setOrClearEffect(int bits, boolean setOrClear, boolean reverse, boolean rectangular, int leftMargin, int rightMargin, int top, int left,
- int bottom, int right) {
- for (int y = top; y < bottom; y++) {
- TerminalRow line = mLines[externalToInternalRow(y)];
- int startOfLine = (rectangular || y == top) ? left : leftMargin;
- int endOfLine = (rectangular || y + 1 == bottom) ? right : rightMargin;
- for (int x = startOfLine; x < endOfLine; x++) {
- int currentStyle = line.getStyle(x);
- int foreColor = TextStyle.decodeForeColor(currentStyle);
- int backColor = TextStyle.decodeBackColor(currentStyle);
- int effect = TextStyle.decodeEffect(currentStyle);
- if (reverse) {
- // Clear out the bits to reverse and add them back in reversed:
- effect = (effect & ~bits) | (bits & ~effect);
- } else if (setOrClear) {
- effect |= bits;
- } else {
- effect &= ~bits;
- }
- line.mStyle[x] = TextStyle.encode(foreColor, backColor, effect);
- }
- }
- }
+ /** Support for http://vt100.net/docs/vt510-rm/DECCARA and http://vt100.net/docs/vt510-rm/DECCARA */
+ public void setOrClearEffect(int bits, boolean setOrClear, boolean reverse, boolean rectangular, int leftMargin, int rightMargin, int top, int left,
+ int bottom, int right) {
+ for (int y = top; y < bottom; y++) {
+ TerminalRow line = mLines[externalToInternalRow(y)];
+ int startOfLine = (rectangular || y == top) ? left : leftMargin;
+ int endOfLine = (rectangular || y + 1 == bottom) ? right : rightMargin;
+ for (int x = startOfLine; x < endOfLine; x++) {
+ int currentStyle = line.getStyle(x);
+ int foreColor = TextStyle.decodeForeColor(currentStyle);
+ int backColor = TextStyle.decodeBackColor(currentStyle);
+ int effect = TextStyle.decodeEffect(currentStyle);
+ if (reverse) {
+ // Clear out the bits to reverse and add them back in reversed:
+ effect = (effect & ~bits) | (bits & ~effect);
+ } else if (setOrClear) {
+ effect |= bits;
+ } else {
+ effect &= ~bits;
+ }
+ line.mStyle[x] = TextStyle.encode(foreColor, backColor, effect);
+ }
+ }
+ }
}
diff --git a/app/src/main/java/com/termux/terminal/TerminalColorScheme.java b/app/src/main/java/com/termux/terminal/TerminalColorScheme.java
index e330b880..e4fd4e9c 100644
--- a/app/src/main/java/com/termux/terminal/TerminalColorScheme.java
+++ b/app/src/main/java/com/termux/terminal/TerminalColorScheme.java
@@ -6,97 +6,98 @@ import java.util.Properties;
/**
* Color scheme for a terminal with default colors, which may be overridden (and then reset) from the shell using
* Operating System Control (OSC) sequences.
- *
+ *
* @see TerminalColors
*/
public final class TerminalColorScheme {
- /** http://upload.wikimedia.org/wikipedia/en/1/15/Xterm_256color_chart.svg, but with blue color brighter. */
- private static final int[] DEFAULT_COLORSCHEME = {
- // 16 original colors. First 8 are dim.
- 0xff000000, // black
- 0xffcd0000, // dim red
- 0xff00cd00, // dim green
- 0xffcdcd00, // dim yellow
- 0xff6495ed, // dim blue
- 0xffcd00cd, // dim magenta
- 0xff00cdcd, // dim cyan
- 0xffe5e5e5, // dim white
- // Second 8 are bright:
- 0xff7f7f7f, // medium grey
- 0xffff0000, // bright red
- 0xff00ff00, // bright green
- 0xffffff00, // bright yellow
- 0xff5c5cff, // light blue
- 0xffff00ff, // bright magenta
- 0xff00ffff, // bright cyan
- 0xffffffff, // bright white
+ /** http://upload.wikimedia.org/wikipedia/en/1/15/Xterm_256color_chart.svg, but with blue color brighter. */
+ private static final int[] DEFAULT_COLORSCHEME = {
+ // 16 original colors. First 8 are dim.
+ 0xff000000, // black
+ 0xffcd0000, // dim red
+ 0xff00cd00, // dim green
+ 0xffcdcd00, // dim yellow
+ 0xff6495ed, // dim blue
+ 0xffcd00cd, // dim magenta
+ 0xff00cdcd, // dim cyan
+ 0xffe5e5e5, // dim white
+ // Second 8 are bright:
+ 0xff7f7f7f, // medium grey
+ 0xffff0000, // bright red
+ 0xff00ff00, // bright green
+ 0xffffff00, // bright yellow
+ 0xff5c5cff, // light blue
+ 0xffff00ff, // bright magenta
+ 0xff00ffff, // bright cyan
+ 0xffffffff, // bright white
- // 216 color cube, six shades of each color:
- 0xff000000, 0xff00005f, 0xff000087, 0xff0000af, 0xff0000d7, 0xff0000ff, 0xff005f00, 0xff005f5f, 0xff005f87, 0xff005faf, 0xff005fd7, 0xff005fff,
- 0xff008700, 0xff00875f, 0xff008787, 0xff0087af, 0xff0087d7, 0xff0087ff, 0xff00af00, 0xff00af5f, 0xff00af87, 0xff00afaf, 0xff00afd7, 0xff00afff,
- 0xff00d700, 0xff00d75f, 0xff00d787, 0xff00d7af, 0xff00d7d7, 0xff00d7ff, 0xff00ff00, 0xff00ff5f, 0xff00ff87, 0xff00ffaf, 0xff00ffd7, 0xff00ffff,
- 0xff5f0000, 0xff5f005f, 0xff5f0087, 0xff5f00af, 0xff5f00d7, 0xff5f00ff, 0xff5f5f00, 0xff5f5f5f, 0xff5f5f87, 0xff5f5faf, 0xff5f5fd7, 0xff5f5fff,
- 0xff5f8700, 0xff5f875f, 0xff5f8787, 0xff5f87af, 0xff5f87d7, 0xff5f87ff, 0xff5faf00, 0xff5faf5f, 0xff5faf87, 0xff5fafaf, 0xff5fafd7, 0xff5fafff,
- 0xff5fd700, 0xff5fd75f, 0xff5fd787, 0xff5fd7af, 0xff5fd7d7, 0xff5fd7ff, 0xff5fff00, 0xff5fff5f, 0xff5fff87, 0xff5fffaf, 0xff5fffd7, 0xff5fffff,
- 0xff870000, 0xff87005f, 0xff870087, 0xff8700af, 0xff8700d7, 0xff8700ff, 0xff875f00, 0xff875f5f, 0xff875f87, 0xff875faf, 0xff875fd7, 0xff875fff,
- 0xff878700, 0xff87875f, 0xff878787, 0xff8787af, 0xff8787d7, 0xff8787ff, 0xff87af00, 0xff87af5f, 0xff87af87, 0xff87afaf, 0xff87afd7, 0xff87afff,
- 0xff87d700, 0xff87d75f, 0xff87d787, 0xff87d7af, 0xff87d7d7, 0xff87d7ff, 0xff87ff00, 0xff87ff5f, 0xff87ff87, 0xff87ffaf, 0xff87ffd7, 0xff87ffff,
- 0xffaf0000, 0xffaf005f, 0xffaf0087, 0xffaf00af, 0xffaf00d7, 0xffaf00ff, 0xffaf5f00, 0xffaf5f5f, 0xffaf5f87, 0xffaf5faf, 0xffaf5fd7, 0xffaf5fff,
- 0xffaf8700, 0xffaf875f, 0xffaf8787, 0xffaf87af, 0xffaf87d7, 0xffaf87ff, 0xffafaf00, 0xffafaf5f, 0xffafaf87, 0xffafafaf, 0xffafafd7, 0xffafafff,
- 0xffafd700, 0xffafd75f, 0xffafd787, 0xffafd7af, 0xffafd7d7, 0xffafd7ff, 0xffafff00, 0xffafff5f, 0xffafff87, 0xffafffaf, 0xffafffd7, 0xffafffff,
- 0xffd70000, 0xffd7005f, 0xffd70087, 0xffd700af, 0xffd700d7, 0xffd700ff, 0xffd75f00, 0xffd75f5f, 0xffd75f87, 0xffd75faf, 0xffd75fd7, 0xffd75fff,
- 0xffd78700, 0xffd7875f, 0xffd78787, 0xffd787af, 0xffd787d7, 0xffd787ff, 0xffd7af00, 0xffd7af5f, 0xffd7af87, 0xffd7afaf, 0xffd7afd7, 0xffd7afff,
- 0xffd7d700, 0xffd7d75f, 0xffd7d787, 0xffd7d7af, 0xffd7d7d7, 0xffd7d7ff, 0xffd7ff00, 0xffd7ff5f, 0xffd7ff87, 0xffd7ffaf, 0xffd7ffd7, 0xffd7ffff,
- 0xffff0000, 0xffff005f, 0xffff0087, 0xffff00af, 0xffff00d7, 0xffff00ff, 0xffff5f00, 0xffff5f5f, 0xffff5f87, 0xffff5faf, 0xffff5fd7, 0xffff5fff,
- 0xffff8700, 0xffff875f, 0xffff8787, 0xffff87af, 0xffff87d7, 0xffff87ff, 0xffffaf00, 0xffffaf5f, 0xffffaf87, 0xffffafaf, 0xffffafd7, 0xffffafff,
- 0xffffd700, 0xffffd75f, 0xffffd787, 0xffffd7af, 0xffffd7d7, 0xffffd7ff, 0xffffff00, 0xffffff5f, 0xffffff87, 0xffffffaf, 0xffffffd7, 0xffffffff,
+ // 216 color cube, six shades of each color:
+ 0xff000000, 0xff00005f, 0xff000087, 0xff0000af, 0xff0000d7, 0xff0000ff, 0xff005f00, 0xff005f5f, 0xff005f87, 0xff005faf, 0xff005fd7, 0xff005fff,
+ 0xff008700, 0xff00875f, 0xff008787, 0xff0087af, 0xff0087d7, 0xff0087ff, 0xff00af00, 0xff00af5f, 0xff00af87, 0xff00afaf, 0xff00afd7, 0xff00afff,
+ 0xff00d700, 0xff00d75f, 0xff00d787, 0xff00d7af, 0xff00d7d7, 0xff00d7ff, 0xff00ff00, 0xff00ff5f, 0xff00ff87, 0xff00ffaf, 0xff00ffd7, 0xff00ffff,
+ 0xff5f0000, 0xff5f005f, 0xff5f0087, 0xff5f00af, 0xff5f00d7, 0xff5f00ff, 0xff5f5f00, 0xff5f5f5f, 0xff5f5f87, 0xff5f5faf, 0xff5f5fd7, 0xff5f5fff,
+ 0xff5f8700, 0xff5f875f, 0xff5f8787, 0xff5f87af, 0xff5f87d7, 0xff5f87ff, 0xff5faf00, 0xff5faf5f, 0xff5faf87, 0xff5fafaf, 0xff5fafd7, 0xff5fafff,
+ 0xff5fd700, 0xff5fd75f, 0xff5fd787, 0xff5fd7af, 0xff5fd7d7, 0xff5fd7ff, 0xff5fff00, 0xff5fff5f, 0xff5fff87, 0xff5fffaf, 0xff5fffd7, 0xff5fffff,
+ 0xff870000, 0xff87005f, 0xff870087, 0xff8700af, 0xff8700d7, 0xff8700ff, 0xff875f00, 0xff875f5f, 0xff875f87, 0xff875faf, 0xff875fd7, 0xff875fff,
+ 0xff878700, 0xff87875f, 0xff878787, 0xff8787af, 0xff8787d7, 0xff8787ff, 0xff87af00, 0xff87af5f, 0xff87af87, 0xff87afaf, 0xff87afd7, 0xff87afff,
+ 0xff87d700, 0xff87d75f, 0xff87d787, 0xff87d7af, 0xff87d7d7, 0xff87d7ff, 0xff87ff00, 0xff87ff5f, 0xff87ff87, 0xff87ffaf, 0xff87ffd7, 0xff87ffff,
+ 0xffaf0000, 0xffaf005f, 0xffaf0087, 0xffaf00af, 0xffaf00d7, 0xffaf00ff, 0xffaf5f00, 0xffaf5f5f, 0xffaf5f87, 0xffaf5faf, 0xffaf5fd7, 0xffaf5fff,
+ 0xffaf8700, 0xffaf875f, 0xffaf8787, 0xffaf87af, 0xffaf87d7, 0xffaf87ff, 0xffafaf00, 0xffafaf5f, 0xffafaf87, 0xffafafaf, 0xffafafd7, 0xffafafff,
+ 0xffafd700, 0xffafd75f, 0xffafd787, 0xffafd7af, 0xffafd7d7, 0xffafd7ff, 0xffafff00, 0xffafff5f, 0xffafff87, 0xffafffaf, 0xffafffd7, 0xffafffff,
+ 0xffd70000, 0xffd7005f, 0xffd70087, 0xffd700af, 0xffd700d7, 0xffd700ff, 0xffd75f00, 0xffd75f5f, 0xffd75f87, 0xffd75faf, 0xffd75fd7, 0xffd75fff,
+ 0xffd78700, 0xffd7875f, 0xffd78787, 0xffd787af, 0xffd787d7, 0xffd787ff, 0xffd7af00, 0xffd7af5f, 0xffd7af87, 0xffd7afaf, 0xffd7afd7, 0xffd7afff,
+ 0xffd7d700, 0xffd7d75f, 0xffd7d787, 0xffd7d7af, 0xffd7d7d7, 0xffd7d7ff, 0xffd7ff00, 0xffd7ff5f, 0xffd7ff87, 0xffd7ffaf, 0xffd7ffd7, 0xffd7ffff,
+ 0xffff0000, 0xffff005f, 0xffff0087, 0xffff00af, 0xffff00d7, 0xffff00ff, 0xffff5f00, 0xffff5f5f, 0xffff5f87, 0xffff5faf, 0xffff5fd7, 0xffff5fff,
+ 0xffff8700, 0xffff875f, 0xffff8787, 0xffff87af, 0xffff87d7, 0xffff87ff, 0xffffaf00, 0xffffaf5f, 0xffffaf87, 0xffffafaf, 0xffffafd7, 0xffffafff,
+ 0xffffd700, 0xffffd75f, 0xffffd787, 0xffffd7af, 0xffffd7d7, 0xffffd7ff, 0xffffff00, 0xffffff5f, 0xffffff87, 0xffffffaf, 0xffffffd7, 0xffffffff,
- // 24 grey scale ramp:
- 0xff080808, 0xff121212, 0xff1c1c1c, 0xff262626, 0xff303030, 0xff3a3a3a, 0xff444444, 0xff4e4e4e, 0xff585858, 0xff626262, 0xff6c6c6c, 0xff767676,
- 0xff808080, 0xff8a8a8a, 0xff949494, 0xff9e9e9e, 0xffa8a8a8, 0xffb2b2b2, 0xffbcbcbc, 0xffc6c6c6, 0xffd0d0d0, 0xffdadada, 0xffe4e4e4, 0xffeeeeee,
+ // 24 grey scale ramp:
+ 0xff080808, 0xff121212, 0xff1c1c1c, 0xff262626, 0xff303030, 0xff3a3a3a, 0xff444444, 0xff4e4e4e, 0xff585858, 0xff626262, 0xff6c6c6c, 0xff767676,
+ 0xff808080, 0xff8a8a8a, 0xff949494, 0xff9e9e9e, 0xffa8a8a8, 0xffb2b2b2, 0xffbcbcbc, 0xffc6c6c6, 0xffd0d0d0, 0xffdadada, 0xffe4e4e4, 0xffeeeeee,
- // COLOR_INDEX_DEFAULT_FOREGROUND, COLOR_INDEX_DEFAULT_BACKGROUND and COLOR_INDEX_DEFAULT_CURSOR:
- 0xffffffff, 0xff000000, 0xffffffff };
+ // COLOR_INDEX_DEFAULT_FOREGROUND, COLOR_INDEX_DEFAULT_BACKGROUND and COLOR_INDEX_DEFAULT_CURSOR:
+ 0xffffffff, 0xff000000, 0xffffffff};
- public final int[] mDefaultColors = new int[TextStyle.NUM_INDEXED_COLORS];
+ public final int[] mDefaultColors = new int[TextStyle.NUM_INDEXED_COLORS];
- public TerminalColorScheme() {
- reset();
- }
+ public TerminalColorScheme() {
+ reset();
+ }
- private void reset() {
- System.arraycopy(DEFAULT_COLORSCHEME, 0, mDefaultColors, 0, TextStyle.NUM_INDEXED_COLORS);
- }
+ private void reset() {
+ System.arraycopy(DEFAULT_COLORSCHEME, 0, mDefaultColors, 0, TextStyle.NUM_INDEXED_COLORS);
+ }
- public void updateWith(Properties props) {
- reset();
- for (Map.Entry entries : props.entrySet()) {
- String key = (String) entries.getKey();
- String value = (String) entries.getValue();
- int colorIndex;
+ public void updateWith(Properties props) {
+ reset();
+ for (Map.Entry entries : props.entrySet()) {
+ String key = (String) entries.getKey();
+ String value = (String) entries.getValue();
+ int colorIndex;
- if (key.equals("foreground")) {
- colorIndex = TextStyle.COLOR_INDEX_FOREGROUND;
- } else if (key.equals("background")) {
- colorIndex = TextStyle.COLOR_INDEX_BACKGROUND;
- } else if (key.equals("cursor")) {
- colorIndex = TextStyle.COLOR_INDEX_CURSOR;
- } else if (key.startsWith("color")) {
- try {
- colorIndex = Integer.parseInt(key.substring(5));
- } catch (NumberFormatException e) {
- throw new IllegalArgumentException("Invalid property: '" + key + "'");
- }
- } else {
- throw new IllegalArgumentException("Invalid property: '" + key + "'");
- }
+ if (key.equals("foreground")) {
+ colorIndex = TextStyle.COLOR_INDEX_FOREGROUND;
+ } else if (key.equals("background")) {
+ colorIndex = TextStyle.COLOR_INDEX_BACKGROUND;
+ } else if (key.equals("cursor")) {
+ colorIndex = TextStyle.COLOR_INDEX_CURSOR;
+ } else if (key.startsWith("color")) {
+ try {
+ colorIndex = Integer.parseInt(key.substring(5));
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException("Invalid property: '" + key + "'");
+ }
+ } else {
+ throw new IllegalArgumentException("Invalid property: '" + key + "'");
+ }
- int colorValue = TerminalColors.parse(value);
- if (colorValue == 0) throw new IllegalArgumentException("Property '" + key + "' has invalid color: '" + value + "'");
+ int colorValue = TerminalColors.parse(value);
+ if (colorValue == 0)
+ throw new IllegalArgumentException("Property '" + key + "' has invalid color: '" + value + "'");
- mDefaultColors[colorIndex] = colorValue;
- }
- }
+ mDefaultColors[colorIndex] = colorValue;
+ }
+ }
}
diff --git a/app/src/main/java/com/termux/terminal/TerminalColors.java b/app/src/main/java/com/termux/terminal/TerminalColors.java
index 3c9f10cd..6d8cfdb9 100644
--- a/app/src/main/java/com/termux/terminal/TerminalColors.java
+++ b/app/src/main/java/com/termux/terminal/TerminalColors.java
@@ -3,74 +3,74 @@ package com.termux.terminal;
/** Current terminal colors (if different from default). */
public final class TerminalColors {
- /** Static data - a bit ugly but ok for now. */
- public static final TerminalColorScheme COLOR_SCHEME = new TerminalColorScheme();
+ /** Static data - a bit ugly but ok for now. */
+ public static final TerminalColorScheme COLOR_SCHEME = new TerminalColorScheme();
- /**
- * The current terminal colors, which are normally set from the color theme, but may be set dynamically with the OSC
- * 4 control sequence.
- */
- public final int[] mCurrentColors = new int[TextStyle.NUM_INDEXED_COLORS];
+ /**
+ * The current terminal colors, which are normally set from the color theme, but may be set dynamically with the OSC
+ * 4 control sequence.
+ */
+ public final int[] mCurrentColors = new int[TextStyle.NUM_INDEXED_COLORS];
- /** Create a new instance with default colors from the theme. */
- public TerminalColors() {
- reset();
- }
+ /** Create a new instance with default colors from the theme. */
+ public TerminalColors() {
+ reset();
+ }
- /** Reset a particular indexed color with the default color from the color theme. */
- public void reset(int index) {
- mCurrentColors[index] = COLOR_SCHEME.mDefaultColors[index];
- }
+ /** Reset a particular indexed color with the default color from the color theme. */
+ public void reset(int index) {
+ mCurrentColors[index] = COLOR_SCHEME.mDefaultColors[index];
+ }
- /** Reset all indexed colors with the default color from the color theme. */
- public void reset() {
- System.arraycopy(COLOR_SCHEME.mDefaultColors, 0, mCurrentColors, 0, TextStyle.NUM_INDEXED_COLORS);
- }
+ /** Reset all indexed colors with the default color from the color theme. */
+ public void reset() {
+ System.arraycopy(COLOR_SCHEME.mDefaultColors, 0, mCurrentColors, 0, TextStyle.NUM_INDEXED_COLORS);
+ }
- /**
- * Parse color according to http://manpages.ubuntu.com/manpages/intrepid/man3/XQueryColor.3.html
- *
- * Highest bit is set if successful, so return value is 0xFF${R}${G}${B}. Return 0 if failed.
- */
- static int parse(String c) {
- try {
- int skipInitial, skipBetween;
- if (c.charAt(0) == '#') {
- // #RGB, #RRGGBB, #RRRGGGBBB or #RRRRGGGGBBBB. Most significant bits.
- skipInitial = 1;
- skipBetween = 0;
- } else if (c.startsWith("rgb:")) {
- // rgb:// where , , := h | hh | hhh | hhhh. Scaled.
- skipInitial = 4;
- skipBetween = 1;
- } else {
- return 0;
- }
- int charsForColors = c.length() - skipInitial - 2 * skipBetween;
- if (charsForColors % 3 != 0) return 0; // Unequal lengths.
- int componentLength = charsForColors / 3;
- double mult = 255 / (Math.pow(2, componentLength * 4) - 1);
+ /**
+ * Parse color according to http://manpages.ubuntu.com/manpages/intrepid/man3/XQueryColor.3.html
+ *
+ * Highest bit is set if successful, so return value is 0xFF${R}${G}${B}. Return 0 if failed.
+ */
+ static int parse(String c) {
+ try {
+ int skipInitial, skipBetween;
+ if (c.charAt(0) == '#') {
+ // #RGB, #RRGGBB, #RRRGGGBBB or #RRRRGGGGBBBB. Most significant bits.
+ skipInitial = 1;
+ skipBetween = 0;
+ } else if (c.startsWith("rgb:")) {
+ // rgb:// where , , := h | hh | hhh | hhhh. Scaled.
+ skipInitial = 4;
+ skipBetween = 1;
+ } else {
+ return 0;
+ }
+ int charsForColors = c.length() - skipInitial - 2 * skipBetween;
+ if (charsForColors % 3 != 0) return 0; // Unequal lengths.
+ int componentLength = charsForColors / 3;
+ double mult = 255 / (Math.pow(2, componentLength * 4) - 1);
- int currentPosition = skipInitial;
- String rString = c.substring(currentPosition, currentPosition + componentLength);
- currentPosition += componentLength + skipBetween;
- String gString = c.substring(currentPosition, currentPosition + componentLength);
- currentPosition += componentLength + skipBetween;
- String bString = c.substring(currentPosition, currentPosition + componentLength);
+ int currentPosition = skipInitial;
+ String rString = c.substring(currentPosition, currentPosition + componentLength);
+ currentPosition += componentLength + skipBetween;
+ String gString = c.substring(currentPosition, currentPosition + componentLength);
+ currentPosition += componentLength + skipBetween;
+ String bString = c.substring(currentPosition, currentPosition + componentLength);
- int r = (int) (Integer.parseInt(rString, 16) * mult);
- int g = (int) (Integer.parseInt(gString, 16) * mult);
- int b = (int) (Integer.parseInt(bString, 16) * mult);
- return 0xFF << 24 | r << 16 | g << 8 | b;
- } catch (NumberFormatException | IndexOutOfBoundsException e) {
- return 0;
- }
- }
+ int r = (int) (Integer.parseInt(rString, 16) * mult);
+ int g = (int) (Integer.parseInt(gString, 16) * mult);
+ int b = (int) (Integer.parseInt(bString, 16) * mult);
+ return 0xFF << 24 | r << 16 | g << 8 | b;
+ } catch (NumberFormatException | IndexOutOfBoundsException e) {
+ return 0;
+ }
+ }
- /** Try parse a color from a text parameter and into a specified index. */
- public void tryParseColor(int intoIndex, String textParameter) {
- int c = parse(textParameter);
- if (c != 0) mCurrentColors[intoIndex] = c;
- }
+ /** Try parse a color from a text parameter and into a specified index. */
+ public void tryParseColor(int intoIndex, String textParameter) {
+ int c = parse(textParameter);
+ if (c != 0) mCurrentColors[intoIndex] = c;
+ }
}
diff --git a/app/src/main/java/com/termux/terminal/TerminalEmulator.java b/app/src/main/java/com/termux/terminal/TerminalEmulator.java
index 5ae7e84e..23f171af 100644
--- a/app/src/main/java/com/termux/terminal/TerminalEmulator.java
+++ b/app/src/main/java/com/termux/terminal/TerminalEmulator.java
@@ -1,18 +1,18 @@
package com.termux.terminal;
+import android.util.Base64;
+import android.util.Log;
+
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Locale;
import java.util.Objects;
import java.util.Stack;
-import android.util.Base64;
-import android.util.Log;
-
/**
* Renders text into a screen. Contains all the terminal-specific knowledge and state. Emulates a subset of the X Window
* System xterm terminal, which in turn is an emulator for a subset of the Digital Equipment Corporation vt100 terminal.
- *
+ *
* References:
*
* - http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
@@ -29,2300 +29,2303 @@ import android.util.Log;
*/
public final class TerminalEmulator {
- /** Log unknown or unimplemented escape sequences received from the shell process. */
- private static final boolean LOG_ESCAPE_SEQUENCES = false;
+ /** Log unknown or unimplemented escape sequences received from the shell process. */
+ private static final boolean LOG_ESCAPE_SEQUENCES = false;
- public static final int MOUSE_LEFT_BUTTON = 0;
+ public static final int MOUSE_LEFT_BUTTON = 0;
- /** Mouse moving while having left mouse button pressed. */
- public static final int MOUSE_LEFT_BUTTON_MOVED = 32;
- public static final int MOUSE_WHEELUP_BUTTON = 64;
- public static final int MOUSE_WHEELDOWN_BUTTON = 65;
+ /** Mouse moving while having left mouse button pressed. */
+ public static final int MOUSE_LEFT_BUTTON_MOVED = 32;
+ public static final int MOUSE_WHEELUP_BUTTON = 64;
+ public static final int MOUSE_WHEELDOWN_BUTTON = 65;
- public static final int CURSOR_STYLE_BLOCK = 0;
- public static final int CURSOR_STYLE_UNDERLINE = 1;
- public static final int CURSOR_STYLE_BAR = 2;
+ public static final int CURSOR_STYLE_BLOCK = 0;
+ public static final int CURSOR_STYLE_UNDERLINE = 1;
+ public static final int CURSOR_STYLE_BAR = 2;
- /** Used for invalid data - http://en.wikipedia.org/wiki/Replacement_character#Replacement_character */
- public static final int UNICODE_REPLACEMENT_CHAR = 0xFFFD;
+ /** Used for invalid data - http://en.wikipedia.org/wiki/Replacement_character#Replacement_character */
+ public static final int UNICODE_REPLACEMENT_CHAR = 0xFFFD;
- /** Escape processing: Not currently in an escape sequence. */
- private static final int ESC_NONE = 0;
- /** Escape processing: Have seen an ESC character - proceed to {@link #doEsc(int)} */
- private static final int ESC = 1;
- /** Escape processing: Have seen ESC POUND */
- private static final int ESC_POUND = 2;
- /** Escape processing: Have seen ESC and a character-set-select ( char */
- private static final int ESC_SELECT_LEFT_PAREN = 3;
- /** Escape processing: Have seen ESC and a character-set-select ) char */
- private static final int ESC_SELECT_RIGHT_PAREN = 4;
- /** Escape processing: Have seen ESC and a character-set-select + char */
- // private static final int ESC_SELECT_PLUS = 5;
- /** Escape processing: "ESC [" or CSI (Control Sequence Introducer). */
- private static final int ESC_CSI = 6;
- /** Escape processing: ESC [ ? */
- private static final int ESC_CSI_QUESTIONMARK = 7;
- /** Escape processing: ESC [ $ */
- private static final int ESC_CSI_DOLLAR = 8;
- /** Escape processing: ESC % */
- private static final int ESC_PERCENT = 9;
- /** Escape processing: ESC ] (AKA OSC - Operating System Controls) */
- private static final int ESC_OSC = 10;
- /** Escape processing: ESC ] (AKA OSC - Operating System Controls) ESC */
- private static final int ESC_OSC_ESC = 11;
- /** Escape processing: ESC [ > */
- private static final int ESC_CSI_BIGGERTHAN = 12;
- /** Escape procession: "ESC P" or Device Control String (DCS) */
- private static final int ESC_P = 13;
- /** Escape processing: CSI > */
- private static final int ESC_CSI_QUESTIONMARK_ARG_DOLLAR = 14;
- /** Escape processing: CSI $ARGS ' ' */
- private static final int ESC_CSI_ARGS_SPACE = 15;
- /** Escape processing: CSI $ARGS '*' */
- private static final int ESC_CSI_ARGS_ASTERIX = 16;
- /** Escape processing: CSI " */
- private static final int ESC_CSI_DOUBLE_QUOTE = 17;
- /** Escape processing: CSI ' */
- private static final int ESC_CSI_SINGLE_QUOTE = 18;
- /** Escape processing: CSI ! */
- private static final int ESC_CSI_EXCLAMATION = 19;
+ /** Escape processing: Not currently in an escape sequence. */
+ private static final int ESC_NONE = 0;
+ /** Escape processing: Have seen an ESC character - proceed to {@link #doEsc(int)} */
+ private static final int ESC = 1;
+ /** Escape processing: Have seen ESC POUND */
+ private static final int ESC_POUND = 2;
+ /** Escape processing: Have seen ESC and a character-set-select ( char */
+ private static final int ESC_SELECT_LEFT_PAREN = 3;
+ /** Escape processing: Have seen ESC and a character-set-select ) char */
+ private static final int ESC_SELECT_RIGHT_PAREN = 4;
+ /** Escape processing: Have seen ESC and a character-set-select + char */
+ // private static final int ESC_SELECT_PLUS = 5;
+ /** Escape processing: "ESC [" or CSI (Control Sequence Introducer). */
+ private static final int ESC_CSI = 6;
+ /** Escape processing: ESC [ ? */
+ private static final int ESC_CSI_QUESTIONMARK = 7;
+ /** Escape processing: ESC [ $ */
+ private static final int ESC_CSI_DOLLAR = 8;
+ /** Escape processing: ESC % */
+ private static final int ESC_PERCENT = 9;
+ /** Escape processing: ESC ] (AKA OSC - Operating System Controls) */
+ private static final int ESC_OSC = 10;
+ /** Escape processing: ESC ] (AKA OSC - Operating System Controls) ESC */
+ private static final int ESC_OSC_ESC = 11;
+ /** Escape processing: ESC [ > */
+ private static final int ESC_CSI_BIGGERTHAN = 12;
+ /** Escape procession: "ESC P" or Device Control String (DCS) */
+ private static final int ESC_P = 13;
+ /** Escape processing: CSI > */
+ private static final int ESC_CSI_QUESTIONMARK_ARG_DOLLAR = 14;
+ /** Escape processing: CSI $ARGS ' ' */
+ private static final int ESC_CSI_ARGS_SPACE = 15;
+ /** Escape processing: CSI $ARGS '*' */
+ private static final int ESC_CSI_ARGS_ASTERIX = 16;
+ /** Escape processing: CSI " */
+ private static final int ESC_CSI_DOUBLE_QUOTE = 17;
+ /** Escape processing: CSI ' */
+ private static final int ESC_CSI_SINGLE_QUOTE = 18;
+ /** Escape processing: CSI ! */
+ private static final int ESC_CSI_EXCLAMATION = 19;
- /** The number of parameter arguments. This name comes from the ANSI standard for terminal escape codes. */
- private static final int MAX_ESCAPE_PARAMETERS = 16;
+ /** The number of parameter arguments. This name comes from the ANSI standard for terminal escape codes. */
+ private static final int MAX_ESCAPE_PARAMETERS = 16;
- /** Needs to be large enough to contain reasonable OSC 52 pastes. */
- private static final int MAX_OSC_STRING_LENGTH = 8192;
+ /** Needs to be large enough to contain reasonable OSC 52 pastes. */
+ private static final int MAX_OSC_STRING_LENGTH = 8192;
- /** DECSET 1 - application cursor keys. */
- private static final int DECSET_BIT_APPLICATION_CURSOR_KEYS = 1;
- private static final int DECSET_BIT_REVERSE_VIDEO = 1 << 1;
- /**
- * http://www.vt100.net/docs/vt510-rm/DECOM: "When DECOM is set, the home cursor position is at the upper-left
- * corner of the screen, within the margins. The starting point for line numbers depends on the current top margin
- * setting. The cursor cannot move outside of the margins. When DECOM is reset, the home cursor position is at the
- * upper-left corner of the screen. The starting point for line numbers is independent of the margins. The cursor
- * can move outside of the margins."
- */
- private static final int DECSET_BIT_ORIGIN_MODE = 1 << 2;
- /**
- * http://www.vt100.net/docs/vt510-rm/DECAWM: "If the DECAWM function is set, then graphic characters received when
- * the cursor is at the right border of the page appear at the beginning of the next line. Any text on the page
- * scrolls up if the cursor is at the end of the scrolling region. If the DECAWM function is reset, then graphic
- * characters received when the cursor is at the right border of the page replace characters already on the page."
- */
- private static final int DECSET_BIT_AUTOWRAP = 1 << 3;
- /** DECSET 25 - if the cursor should be visible, {@link #isShowingCursor()}. */
- private static final int DECSET_BIT_SHOWING_CURSOR = 1 << 4;
- private static final int DECSET_BIT_APPLICATION_KEYPAD = 1 << 5;
- /** DECSET 1000 - if to report mouse press&release events. */
- private static final int DECSET_BIT_MOUSE_TRACKING_PRESS_RELEASE = 1 << 6;
- /** DECSET 1002 - like 1000, but report moving mouse while pressed. */
- private static final int DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT = 1 << 7;
- /** DECSET 1004 - NOT implemented. */
- private static final int DECSET_BIT_SEND_FOCUS_EVENTS = 1 << 8;
- /** DECSET 1006 - SGR-like mouse protocol (the modern sane choice). */
- private static final int DECSET_BIT_MOUSE_PROTOCOL_SGR = 1 << 9;
- /** DECSET 2004 - see {@link #paste(String)} */
- private static final int DECSET_BIT_BRACKETED_PASTE_MODE = 1 << 10;
- /** Toggled with DECLRMM - http://www.vt100.net/docs/vt510-rm/DECLRMM */
- private static final int DECSET_BIT_LEFTRIGHT_MARGIN_MODE = 1 << 11;
- /** Not really DECSET bit... - http://www.vt100.net/docs/vt510-rm/DECSACE */
- private static final int DECSET_BIT_RECTANGULAR_CHANGEATTRIBUTE = 1 << 12;
+ /** DECSET 1 - application cursor keys. */
+ private static final int DECSET_BIT_APPLICATION_CURSOR_KEYS = 1;
+ private static final int DECSET_BIT_REVERSE_VIDEO = 1 << 1;
+ /**
+ * http://www.vt100.net/docs/vt510-rm/DECOM: "When DECOM is set, the home cursor position is at the upper-left
+ * corner of the screen, within the margins. The starting point for line numbers depends on the current top margin
+ * setting. The cursor cannot move outside of the margins. When DECOM is reset, the home cursor position is at the
+ * upper-left corner of the screen. The starting point for line numbers is independent of the margins. The cursor
+ * can move outside of the margins."
+ */
+ private static final int DECSET_BIT_ORIGIN_MODE = 1 << 2;
+ /**
+ * http://www.vt100.net/docs/vt510-rm/DECAWM: "If the DECAWM function is set, then graphic characters received when
+ * the cursor is at the right border of the page appear at the beginning of the next line. Any text on the page
+ * scrolls up if the cursor is at the end of the scrolling region. If the DECAWM function is reset, then graphic
+ * characters received when the cursor is at the right border of the page replace characters already on the page."
+ */
+ private static final int DECSET_BIT_AUTOWRAP = 1 << 3;
+ /** DECSET 25 - if the cursor should be visible, {@link #isShowingCursor()}. */
+ private static final int DECSET_BIT_SHOWING_CURSOR = 1 << 4;
+ private static final int DECSET_BIT_APPLICATION_KEYPAD = 1 << 5;
+ /** DECSET 1000 - if to report mouse press&release events. */
+ private static final int DECSET_BIT_MOUSE_TRACKING_PRESS_RELEASE = 1 << 6;
+ /** DECSET 1002 - like 1000, but report moving mouse while pressed. */
+ private static final int DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT = 1 << 7;
+ /** DECSET 1004 - NOT implemented. */
+ private static final int DECSET_BIT_SEND_FOCUS_EVENTS = 1 << 8;
+ /** DECSET 1006 - SGR-like mouse protocol (the modern sane choice). */
+ private static final int DECSET_BIT_MOUSE_PROTOCOL_SGR = 1 << 9;
+ /** DECSET 2004 - see {@link #paste(String)} */
+ private static final int DECSET_BIT_BRACKETED_PASTE_MODE = 1 << 10;
+ /** Toggled with DECLRMM - http://www.vt100.net/docs/vt510-rm/DECLRMM */
+ private static final int DECSET_BIT_LEFTRIGHT_MARGIN_MODE = 1 << 11;
+ /** Not really DECSET bit... - http://www.vt100.net/docs/vt510-rm/DECSACE */
+ private static final int DECSET_BIT_RECTANGULAR_CHANGEATTRIBUTE = 1 << 12;
- private String mTitle;
- private final Stack mTitleStack = new Stack<>();
+ private String mTitle;
+ private final Stack mTitleStack = new Stack<>();
- /** The cursor position. Between (0,0) and (mRows-1, mColumns-1). */
- private int mCursorRow, mCursorCol;
+ /** The cursor position. Between (0,0) and (mRows-1, mColumns-1). */
+ private int mCursorRow, mCursorCol;
- private int mCursorStyle = CURSOR_STYLE_BLOCK;
+ private int mCursorStyle = CURSOR_STYLE_BLOCK;
- /** The number of character rows and columns in the terminal screen. */
- public int mRows, mColumns;
+ /** The number of character rows and columns in the terminal screen. */
+ public int mRows, mColumns;
- /** The normal screen buffer. Stores the characters that appear on the screen of the emulated terminal. */
- private final TerminalBuffer mMainBuffer;
- /**
- * The alternate screen buffer, exactly as large as the display and contains no additional saved lines (so that when
- * the alternate screen buffer is active, you cannot scroll back to view saved lines).
- *
- * See http://www.xfree86.org/current/ctlseqs.html#The%20Alternate%20Screen%20Buffer
- */
- final TerminalBuffer mAltBuffer;
- /** The current screen buffer, pointing at either {@link #mMainBuffer} or {@link #mAltBuffer}. */
- private TerminalBuffer mScreen;
+ /** The normal screen buffer. Stores the characters that appear on the screen of the emulated terminal. */
+ private final TerminalBuffer mMainBuffer;
+ /**
+ * The alternate screen buffer, exactly as large as the display and contains no additional saved lines (so that when
+ * the alternate screen buffer is active, you cannot scroll back to view saved lines).
+ *
+ * See http://www.xfree86.org/current/ctlseqs.html#The%20Alternate%20Screen%20Buffer
+ */
+ final TerminalBuffer mAltBuffer;
+ /** The current screen buffer, pointing at either {@link #mMainBuffer} or {@link #mAltBuffer}. */
+ private TerminalBuffer mScreen;
- /** The terminal session this emulator is bound to. */
- private final TerminalOutput mSession;
+ /** The terminal session this emulator is bound to. */
+ private final TerminalOutput mSession;
- /** Keeps track of the current argument of the current escape sequence. Ranges from 0 to MAX_ESCAPE_PARAMETERS-1. */
- private int mArgIndex;
- /** Holds the arguments of the current escape sequence. */
- private final int[] mArgs = new int[MAX_ESCAPE_PARAMETERS];
+ /** Keeps track of the current argument of the current escape sequence. Ranges from 0 to MAX_ESCAPE_PARAMETERS-1. */
+ private int mArgIndex;
+ /** Holds the arguments of the current escape sequence. */
+ private final int[] mArgs = new int[MAX_ESCAPE_PARAMETERS];
- /** Holds OSC and device control arguments, which can be strings. */
- private final StringBuilder mOSCOrDeviceControlArgs = new StringBuilder();
+ /** Holds OSC and device control arguments, which can be strings. */
+ private final StringBuilder mOSCOrDeviceControlArgs = new StringBuilder();
- /**
- * True if the current escape sequence should continue, false if the current escape sequence should be terminated.
- * Used when parsing a single character.
- */
- private boolean mContinueSequence;
+ /**
+ * True if the current escape sequence should continue, false if the current escape sequence should be terminated.
+ * Used when parsing a single character.
+ */
+ private boolean mContinueSequence;
- /** The current state of the escape sequence state machine. One of the ESC_* constants. */
- private int mEscapeState;
+ /** The current state of the escape sequence state machine. One of the ESC_* constants. */
+ private int mEscapeState;
- private final SavedScreenState mSavedStateMain = new SavedScreenState();
- private final SavedScreenState mSavedStateAlt = new SavedScreenState();
+ private final SavedScreenState mSavedStateMain = new SavedScreenState();
+ private final SavedScreenState mSavedStateAlt = new SavedScreenState();
- /** http://www.vt100.net/docs/vt102-ug/table5-15.html */
- private boolean mUseLineDrawingG0, mUseLineDrawingG1, mUseLineDrawingUsesG0 = true;
+ /** http://www.vt100.net/docs/vt102-ug/table5-15.html */
+ private boolean mUseLineDrawingG0, mUseLineDrawingG1, mUseLineDrawingUsesG0 = true;
- /**
- * @see TerminalEmulator#mapDecSetBitToInternalBit(int)
- */
- private int mCurrentDecSetFlags, mSavedDecSetFlags;
+ /**
+ * @see TerminalEmulator#mapDecSetBitToInternalBit(int)
+ */
+ private int mCurrentDecSetFlags, mSavedDecSetFlags;
- /**
- * If insert mode (as opposed to replace mode) is active. In insert mode new characters are inserted, pushing
- * existing text to the right. Characters moved past the right margin are lost.
- */
- private boolean mInsertMode;
+ /**
+ * If insert mode (as opposed to replace mode) is active. In insert mode new characters are inserted, pushing
+ * existing text to the right. Characters moved past the right margin are lost.
+ */
+ private boolean mInsertMode;
- /** An array of tab stops. mTabStop[i] is true if there is a tab stop set for column i. */
- private boolean[] mTabStop;
+ /** An array of tab stops. mTabStop[i] is true if there is a tab stop set for column i. */
+ private boolean[] mTabStop;
- /**
- * Top margin of screen for scrolling ranges from 0 to mRows-2. Bottom margin ranges from mTopMargin + 2 to mRows
- * (Defines the first row after the scrolling region). Left/right margin in [0, mColumns].
- */
- private int mTopMargin, mBottomMargin, mLeftMargin, mRightMargin;
+ /**
+ * Top margin of screen for scrolling ranges from 0 to mRows-2. Bottom margin ranges from mTopMargin + 2 to mRows
+ * (Defines the first row after the scrolling region). Left/right margin in [0, mColumns].
+ */
+ private int mTopMargin, mBottomMargin, mLeftMargin, mRightMargin;
- /**
- * If the next character to be emitted will be automatically wrapped to the next line. Used to disambiguate the case
- * where the cursor is positioned on the last column (mColumns-1). When standing there, a written character will be
- * output in the last column, the cursor not moving but this flag will be set. When outputting another character
- * this will move to the next line.
- */
- private boolean mAboutToAutoWrap;
+ /**
+ * If the next character to be emitted will be automatically wrapped to the next line. Used to disambiguate the case
+ * where the cursor is positioned on the last column (mColumns-1). When standing there, a written character will be
+ * output in the last column, the cursor not moving but this flag will be set. When outputting another character
+ * this will move to the next line.
+ */
+ private boolean mAboutToAutoWrap;
- /** Foreground and background color indices, 0..255. */
- int mForeColor, mBackColor;
+ /** Foreground and background color indices, 0..255. */
+ int mForeColor, mBackColor;
- /** Current TextStyle effect */
- private int mEffect;
+ /** Current TextStyle effect */
+ private int mEffect;
- /**
- * The number of scrolled lines since last calling {@link #clearScrollCounter()}. Used for moving selection up along
- * with the scrolling text.
- */
- private int mScrollCounter = 0;
+ /**
+ * The number of scrolled lines since last calling {@link #clearScrollCounter()}. Used for moving selection up along
+ * with the scrolling text.
+ */
+ private int mScrollCounter = 0;
- private byte mUtf8ToFollow, mUtf8Index;
- private final byte[] mUtf8InputBuffer = new byte[4];
+ private byte mUtf8ToFollow, mUtf8Index;
+ private final byte[] mUtf8InputBuffer = new byte[4];
- public final TerminalColors mColors = new TerminalColors();
+ public final TerminalColors mColors = new TerminalColors();
- private boolean isDecsetInternalBitSet(int bit) {
- return (mCurrentDecSetFlags & bit) != 0;
- }
+ private boolean isDecsetInternalBitSet(int bit) {
+ return (mCurrentDecSetFlags & bit) != 0;
+ }
- private void setDecsetinternalBit(int internalBit, boolean set) {
- if (set) {
- // The mouse modes are mutually exclusive.
- if (internalBit == DECSET_BIT_MOUSE_TRACKING_PRESS_RELEASE) {
- setDecsetinternalBit(DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT, false);
- } else if (internalBit == DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT) {
- setDecsetinternalBit(DECSET_BIT_MOUSE_TRACKING_PRESS_RELEASE, false);
- }
- }
- if (set) {
- mCurrentDecSetFlags |= internalBit;
- } else {
- mCurrentDecSetFlags &= ~internalBit;
- }
- }
+ private void setDecsetinternalBit(int internalBit, boolean set) {
+ if (set) {
+ // The mouse modes are mutually exclusive.
+ if (internalBit == DECSET_BIT_MOUSE_TRACKING_PRESS_RELEASE) {
+ setDecsetinternalBit(DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT, false);
+ } else if (internalBit == DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT) {
+ setDecsetinternalBit(DECSET_BIT_MOUSE_TRACKING_PRESS_RELEASE, false);
+ }
+ }
+ if (set) {
+ mCurrentDecSetFlags |= internalBit;
+ } else {
+ mCurrentDecSetFlags &= ~internalBit;
+ }
+ }
- static int mapDecSetBitToInternalBit(int decsetBit) {
- switch (decsetBit) {
- case 1:
- return DECSET_BIT_APPLICATION_CURSOR_KEYS;
- case 5:
- return DECSET_BIT_REVERSE_VIDEO;
- case 6:
- return DECSET_BIT_ORIGIN_MODE;
- case 7:
- return DECSET_BIT_AUTOWRAP;
- case 25:
- return DECSET_BIT_SHOWING_CURSOR;
- case 66:
- return DECSET_BIT_APPLICATION_KEYPAD;
- case 69:
- return DECSET_BIT_LEFTRIGHT_MARGIN_MODE;
- case 1000:
- return DECSET_BIT_MOUSE_TRACKING_PRESS_RELEASE;
- case 1002:
- return DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT;
- case 1004:
- return DECSET_BIT_SEND_FOCUS_EVENTS;
- case 1006:
- return DECSET_BIT_MOUSE_PROTOCOL_SGR;
- case 2004:
- return DECSET_BIT_BRACKETED_PASTE_MODE;
- default:
- return -1;
- // throw new IllegalArgumentException("Unsupported decset: " + decsetBit);
- }
- }
+ static int mapDecSetBitToInternalBit(int decsetBit) {
+ switch (decsetBit) {
+ case 1:
+ return DECSET_BIT_APPLICATION_CURSOR_KEYS;
+ case 5:
+ return DECSET_BIT_REVERSE_VIDEO;
+ case 6:
+ return DECSET_BIT_ORIGIN_MODE;
+ case 7:
+ return DECSET_BIT_AUTOWRAP;
+ case 25:
+ return DECSET_BIT_SHOWING_CURSOR;
+ case 66:
+ return DECSET_BIT_APPLICATION_KEYPAD;
+ case 69:
+ return DECSET_BIT_LEFTRIGHT_MARGIN_MODE;
+ case 1000:
+ return DECSET_BIT_MOUSE_TRACKING_PRESS_RELEASE;
+ case 1002:
+ return DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT;
+ case 1004:
+ return DECSET_BIT_SEND_FOCUS_EVENTS;
+ case 1006:
+ return DECSET_BIT_MOUSE_PROTOCOL_SGR;
+ case 2004:
+ return DECSET_BIT_BRACKETED_PASTE_MODE;
+ default:
+ return -1;
+ // throw new IllegalArgumentException("Unsupported decset: " + decsetBit);
+ }
+ }
- public TerminalEmulator(TerminalOutput session, int columns, int rows, int transcriptRows) {
- mSession = session;
- mScreen = mMainBuffer = new TerminalBuffer(columns, transcriptRows, rows);
- mAltBuffer = new TerminalBuffer(columns, rows, rows);
- mRows = rows;
- mColumns = columns;
- mTabStop = new boolean[mColumns];
- reset();
- }
+ public TerminalEmulator(TerminalOutput session, int columns, int rows, int transcriptRows) {
+ mSession = session;
+ mScreen = mMainBuffer = new TerminalBuffer(columns, transcriptRows, rows);
+ mAltBuffer = new TerminalBuffer(columns, rows, rows);
+ mRows = rows;
+ mColumns = columns;
+ mTabStop = new boolean[mColumns];
+ reset();
+ }
- public TerminalBuffer getScreen() {
- return mScreen;
- }
+ public TerminalBuffer getScreen() {
+ return mScreen;
+ }
- public boolean isAlternateBufferActive() {
- return mScreen == mAltBuffer;
- }
+ public boolean isAlternateBufferActive() {
+ return mScreen == mAltBuffer;
+ }
- /**
- * @param mouseButton
- * one of the MOUSE_* constants of this class.
- */
- public void sendMouseEvent(int mouseButton, int column, int row, boolean pressed) {
- if (mouseButton == MOUSE_LEFT_BUTTON_MOVED && !isDecsetInternalBitSet(DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT)) {
- // Do not send tracking.
- } else if (isDecsetInternalBitSet(DECSET_BIT_MOUSE_PROTOCOL_SGR)) {
- mSession.write(String.format("\033[<%d;%d;%d" + (pressed ? 'M' : 'm'), mouseButton, column, row));
- } else {
- mouseButton = pressed ? mouseButton : 3; // 3 for release of all buttons.
- // Clip to screen, and clip to the limits of 8-bit data.
- boolean out_of_bounds = column < 1 || row < 1 || column > mColumns || row > mRows || column > 255 - 32 || row > 255 - 32;
- if (!out_of_bounds) {
- byte[] data = { '\033', '[', 'M', (byte) (32 + mouseButton), (byte) (32 + column), (byte) (32 + row) };
- mSession.write(data, 0, data.length);
- }
- }
- }
+ /**
+ * @param mouseButton one of the MOUSE_* constants of this class.
+ */
+ public void sendMouseEvent(int mouseButton, int column, int row, boolean pressed) {
+ if (mouseButton == MOUSE_LEFT_BUTTON_MOVED && !isDecsetInternalBitSet(DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT)) {
+ // Do not send tracking.
+ } else if (isDecsetInternalBitSet(DECSET_BIT_MOUSE_PROTOCOL_SGR)) {
+ mSession.write(String.format("\033[<%d;%d;%d" + (pressed ? 'M' : 'm'), mouseButton, column, row));
+ } else {
+ mouseButton = pressed ? mouseButton : 3; // 3 for release of all buttons.
+ // Clip to screen, and clip to the limits of 8-bit data.
+ boolean out_of_bounds = column < 1 || row < 1 || column > mColumns || row > mRows || column > 255 - 32 || row > 255 - 32;
+ if (!out_of_bounds) {
+ byte[] data = {'\033', '[', 'M', (byte) (32 + mouseButton), (byte) (32 + column), (byte) (32 + row)};
+ mSession.write(data, 0, data.length);
+ }
+ }
+ }
- public void resize(int columns, int rows) {
- if (mRows == rows && mColumns == columns) {
- return;
- } else if (columns < 2 || rows < 2) {
- throw new IllegalArgumentException("rows=" + rows + ", columns=" + columns);
- }
+ public void resize(int columns, int rows) {
+ if (mRows == rows && mColumns == columns) {
+ return;
+ } else if (columns < 2 || rows < 2) {
+ throw new IllegalArgumentException("rows=" + rows + ", columns=" + columns);
+ }
- if (mRows != rows) {
- mRows = rows;
- mTopMargin = 0;
- mBottomMargin = mRows;
- }
- if (mColumns != columns) {
- int oldColumns = mColumns;
- mColumns = columns;
- boolean[] oldTabStop = mTabStop;
- mTabStop = new boolean[mColumns];
- setDefaultTabStops();
- int toTransfer = Math.min(oldColumns, columns);
- System.arraycopy(oldTabStop, 0, mTabStop, 0, toTransfer);
- mLeftMargin = 0;
- mRightMargin = mColumns;
- }
+ if (mRows != rows) {
+ mRows = rows;
+ mTopMargin = 0;
+ mBottomMargin = mRows;
+ }
+ if (mColumns != columns) {
+ int oldColumns = mColumns;
+ mColumns = columns;
+ boolean[] oldTabStop = mTabStop;
+ mTabStop = new boolean[mColumns];
+ setDefaultTabStops();
+ int toTransfer = Math.min(oldColumns, columns);
+ System.arraycopy(oldTabStop, 0, mTabStop, 0, toTransfer);
+ mLeftMargin = 0;
+ mRightMargin = mColumns;
+ }
- resizeScreen();
- }
+ resizeScreen();
+ }
- private void resizeScreen() {
- final int[] cursor = { mCursorCol, mCursorRow };
- int newTotalRows = (mScreen == mAltBuffer) ? mRows : mMainBuffer.mTotalRows;
- mScreen.resize(mColumns, mRows, newTotalRows, cursor, getStyle(), isAlternateBufferActive());
- mCursorCol = cursor[0];
- mCursorRow = cursor[1];
- }
+ private void resizeScreen() {
+ final int[] cursor = {mCursorCol, mCursorRow};
+ int newTotalRows = (mScreen == mAltBuffer) ? mRows : mMainBuffer.mTotalRows;
+ mScreen.resize(mColumns, mRows, newTotalRows, cursor, getStyle(), isAlternateBufferActive());
+ mCursorCol = cursor[0];
+ mCursorRow = cursor[1];
+ }
- public int getCursorRow() {
- return mCursorRow;
- }
+ public int getCursorRow() {
+ return mCursorRow;
+ }
- public int getCursorCol() {
- return mCursorCol;
- }
+ public int getCursorCol() {
+ return mCursorCol;
+ }
- /** {@link #CURSOR_STYLE_BAR}, {@link #CURSOR_STYLE_BLOCK} or {@link #CURSOR_STYLE_UNDERLINE} */
- public int getCursorStyle() {
- return mCursorStyle;
- }
+ /** {@link #CURSOR_STYLE_BAR}, {@link #CURSOR_STYLE_BLOCK} or {@link #CURSOR_STYLE_UNDERLINE} */
+ public int getCursorStyle() {
+ return mCursorStyle;
+ }
- public boolean isReverseVideo() {
- return isDecsetInternalBitSet(DECSET_BIT_REVERSE_VIDEO);
- }
+ public boolean isReverseVideo() {
+ return isDecsetInternalBitSet(DECSET_BIT_REVERSE_VIDEO);
+ }
- public boolean isShowingCursor() {
- return isDecsetInternalBitSet(DECSET_BIT_SHOWING_CURSOR);
- }
+ public boolean isShowingCursor() {
+ return isDecsetInternalBitSet(DECSET_BIT_SHOWING_CURSOR);
+ }
- public boolean isKeypadApplicationMode() {
- return isDecsetInternalBitSet(DECSET_BIT_APPLICATION_KEYPAD);
- }
+ public boolean isKeypadApplicationMode() {
+ return isDecsetInternalBitSet(DECSET_BIT_APPLICATION_KEYPAD);
+ }
- public boolean isCursorKeysApplicationMode() {
- return isDecsetInternalBitSet(DECSET_BIT_APPLICATION_CURSOR_KEYS);
- }
+ public boolean isCursorKeysApplicationMode() {
+ return isDecsetInternalBitSet(DECSET_BIT_APPLICATION_CURSOR_KEYS);
+ }
- /** If mouse events are being sent as escape codes to the terminal. */
- public boolean isMouseTrackingActive() {
- return isDecsetInternalBitSet(DECSET_BIT_MOUSE_TRACKING_PRESS_RELEASE) || isDecsetInternalBitSet(DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT);
- }
+ /** If mouse events are being sent as escape codes to the terminal. */
+ public boolean isMouseTrackingActive() {
+ return isDecsetInternalBitSet(DECSET_BIT_MOUSE_TRACKING_PRESS_RELEASE) || isDecsetInternalBitSet(DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT);
+ }
- private void setDefaultTabStops() {
- for (int i = 0; i < mColumns; i++)
- mTabStop[i] = (i & 7) == 0 && i != 0;
- }
+ private void setDefaultTabStops() {
+ for (int i = 0; i < mColumns; i++)
+ mTabStop[i] = (i & 7) == 0 && i != 0;
+ }
- /**
- * Accept bytes (typically from the pseudo-teletype) and process them.
- *
- * @param buffer
- * a byte array containing the bytes to be processed
- * @param length
- * the number of bytes in the array to process
- */
- public void append(byte[] buffer, int length) {
- for (int i = 0; i < length; i++)
- processByte(buffer[i]);
- }
+ /**
+ * Accept bytes (typically from the pseudo-teletype) and process them.
+ *
+ * @param buffer a byte array containing the bytes to be processed
+ * @param length the number of bytes in the array to process
+ */
+ public void append(byte[] buffer, int length) {
+ for (int i = 0; i < length; i++)
+ processByte(buffer[i]);
+ }
- private void processByte(byte byteToProcess) {
- if (mUtf8ToFollow > 0) {
- if ((byteToProcess & 0b11000000) == 0b10000000) {
- // 10xxxxxx, a continuation byte.
- mUtf8InputBuffer[mUtf8Index++] = byteToProcess;
- if (--mUtf8ToFollow == 0) {
- byte firstByteMask = (byte) (mUtf8Index == 2 ? 0b00011111 : (mUtf8Index == 3 ? 0b00001111 : 0b00000111));
- int codePoint = (mUtf8InputBuffer[0] & firstByteMask);
- for (int i = 1; i < mUtf8Index; i++)
- codePoint = ((codePoint << 6) | (mUtf8InputBuffer[i] & 0b00111111));
- if (((codePoint <= 0b1111111) && mUtf8Index > 1) || (codePoint < 0b11111111111 && mUtf8Index > 2)
- || (codePoint < 0b1111111111111111 && mUtf8Index > 3)) {
- // Overlong encoding.
- codePoint = UNICODE_REPLACEMENT_CHAR;
- }
+ private void processByte(byte byteToProcess) {
+ if (mUtf8ToFollow > 0) {
+ if ((byteToProcess & 0b11000000) == 0b10000000) {
+ // 10xxxxxx, a continuation byte.
+ mUtf8InputBuffer[mUtf8Index++] = byteToProcess;
+ if (--mUtf8ToFollow == 0) {
+ byte firstByteMask = (byte) (mUtf8Index == 2 ? 0b00011111 : (mUtf8Index == 3 ? 0b00001111 : 0b00000111));
+ int codePoint = (mUtf8InputBuffer[0] & firstByteMask);
+ for (int i = 1; i < mUtf8Index; i++)
+ codePoint = ((codePoint << 6) | (mUtf8InputBuffer[i] & 0b00111111));
+ if (((codePoint <= 0b1111111) && mUtf8Index > 1) || (codePoint < 0b11111111111 && mUtf8Index > 2)
+ || (codePoint < 0b1111111111111111 && mUtf8Index > 3)) {
+ // Overlong encoding.
+ codePoint = UNICODE_REPLACEMENT_CHAR;
+ }
- mUtf8Index = mUtf8ToFollow = 0;
+ mUtf8Index = mUtf8ToFollow = 0;
- if (codePoint >= 0x80 && codePoint <= 0x9F) {
- // Sequence decoded to a C1 control character which is the same as escape followed by
- // ((code & 0x7F) + 0x40).
- processCodePoint(/* escape (hexadecimal=0x1B, octal=033): */27);
- processCodePoint((codePoint & 0x7F) + 0x40);
- } else {
- switch (Character.getType(codePoint)) {
- case Character.UNASSIGNED:
- case Character.SURROGATE:
- codePoint = UNICODE_REPLACEMENT_CHAR;
- }
- processCodePoint(codePoint);
- }
- }
- } else {
- // Not a UTF-8 continuation byte so replace the entire sequence up to now with the replacement char:
- mUtf8Index = mUtf8ToFollow = 0;
- emitCodePoint(UNICODE_REPLACEMENT_CHAR);
- // The Unicode Standard Version 6.2 – Core Specification
- // (http://www.unicode.org/versions/Unicode6.2.0/ch03.pdf):
- // "If the converter encounters an ill-formed UTF-8 code unit sequence which starts with a valid first
- // byte, but which does not continue with valid successor bytes (see Table 3-7), it must not consume the
- // successor bytes as part of the ill-formed subsequence
- // whenever those successor bytes themselves constitute part of a well-formed UTF-8 code unit
- // subsequence."
- processByte(byteToProcess);
- }
- } else {
- if ((byteToProcess & 0b10000000) == 0) { // The leading bit is not set so it is a 7-bit ASCII character.
- processCodePoint(byteToProcess);
- return;
- } else if ((byteToProcess & 0b11100000) == 0b11000000) { // 110xxxxx, a two-byte sequence.
- mUtf8ToFollow = 1;
- } else if ((byteToProcess & 0b11110000) == 0b11100000) { // 1110xxxx, a three-byte sequence.
- mUtf8ToFollow = 2;
- } else if ((byteToProcess & 0b11111000) == 0b11110000) { // 11110xxx, a four-byte sequence.
- mUtf8ToFollow = 3;
- } else {
- // Not a valid UTF-8 sequence start, signal invalid data:
- processCodePoint(UNICODE_REPLACEMENT_CHAR);
- return;
- }
- mUtf8InputBuffer[mUtf8Index++] = byteToProcess;
- }
- }
-
- public void processCodePoint(int b) {
- switch (b) {
- case 0: // Null character (NUL, ^@). Do nothing.
- break;
- case 7: // Bell (BEL, ^G, \a). If in an OSC sequence, BEL may terminate a string; otherwise signal bell.
- if (mEscapeState == ESC_OSC)
- doOsc(b);
- else
- mSession.onBell();
- break;
- case 8: // Backspace (BS, ^H).
- if (mLeftMargin == mCursorCol) {
- // Jump to previous line if it was auto-wrapped.
- int previousRow = mCursorRow - 1;
- if (previousRow >= 0 && mScreen.getLineWrap(previousRow)) {
- mScreen.clearLineWrap(previousRow);
- setCursorRowCol(previousRow, mRightMargin - 1);
+ if (codePoint >= 0x80 && codePoint <= 0x9F) {
+ // Sequence decoded to a C1 control character which is the same as escape followed by
+ // ((code & 0x7F) + 0x40).
+ processCodePoint(/* escape (hexadecimal=0x1B, octal=033): */27);
+ processCodePoint((codePoint & 0x7F) + 0x40);
+ } else {
+ switch (Character.getType(codePoint)) {
+ case Character.UNASSIGNED:
+ case Character.SURROGATE:
+ codePoint = UNICODE_REPLACEMENT_CHAR;
+ }
+ processCodePoint(codePoint);
+ }
}
} else {
- setCursorCol(mCursorCol - 1);
+ // Not a UTF-8 continuation byte so replace the entire sequence up to now with the replacement char:
+ mUtf8Index = mUtf8ToFollow = 0;
+ emitCodePoint(UNICODE_REPLACEMENT_CHAR);
+ // The Unicode Standard Version 6.2 – Core Specification
+ // (http://www.unicode.org/versions/Unicode6.2.0/ch03.pdf):
+ // "If the converter encounters an ill-formed UTF-8 code unit sequence which starts with a valid first
+ // byte, but which does not continue with valid successor bytes (see Table 3-7), it must not consume the
+ // successor bytes as part of the ill-formed subsequence
+ // whenever those successor bytes themselves constitute part of a well-formed UTF-8 code unit
+ // subsequence."
+ processByte(byteToProcess);
+ }
+ } else {
+ if ((byteToProcess & 0b10000000) == 0) { // The leading bit is not set so it is a 7-bit ASCII character.
+ processCodePoint(byteToProcess);
+ return;
+ } else if ((byteToProcess & 0b11100000) == 0b11000000) { // 110xxxxx, a two-byte sequence.
+ mUtf8ToFollow = 1;
+ } else if ((byteToProcess & 0b11110000) == 0b11100000) { // 1110xxxx, a three-byte sequence.
+ mUtf8ToFollow = 2;
+ } else if ((byteToProcess & 0b11111000) == 0b11110000) { // 11110xxx, a four-byte sequence.
+ mUtf8ToFollow = 3;
+ } else {
+ // Not a valid UTF-8 sequence start, signal invalid data:
+ processCodePoint(UNICODE_REPLACEMENT_CHAR);
+ return;
+ }
+ mUtf8InputBuffer[mUtf8Index++] = byteToProcess;
+ }
+ }
+
+ public void processCodePoint(int b) {
+ switch (b) {
+ case 0: // Null character (NUL, ^@). Do nothing.
+ break;
+ case 7: // Bell (BEL, ^G, \a). If in an OSC sequence, BEL may terminate a string; otherwise signal bell.
+ if (mEscapeState == ESC_OSC)
+ doOsc(b);
+ else
+ mSession.onBell();
+ break;
+ case 8: // Backspace (BS, ^H).
+ if (mLeftMargin == mCursorCol) {
+ // Jump to previous line if it was auto-wrapped.
+ int previousRow = mCursorRow - 1;
+ if (previousRow >= 0 && mScreen.getLineWrap(previousRow)) {
+ mScreen.clearLineWrap(previousRow);
+ setCursorRowCol(previousRow, mRightMargin - 1);
+ }
+ } else {
+ setCursorCol(mCursorCol - 1);
+ }
+ break;
+ case 9: // Horizontal tab (HT, \t) - move to next tab stop, but not past edge of screen
+ // XXX: Should perhaps use color if writing to new cells. Try with
+ // printf "\033[41m\tXX\033[0m\n"
+ // The OSX Terminal.app colors the spaces from the tab red, but xterm does not.
+ // Note that Terminal.app only colors on new cells, in e.g.
+ // printf "\033[41m\t\r\033[42m\tXX\033[0m\n"
+ // the first cells are created with a red background, but when tabbing over
+ // them again with a green background they are not overwritten.
+ mCursorCol = nextTabStop(1);
+ break;
+ case 10: // Line feed (LF, \n).
+ case 11: // Vertical tab (VT, \v).
+ case 12: // Form feed (FF, \f).
+ doLinefeed();
+ break;
+ case 13: // Carriage return (CR, \r).
+ setCursorCol(mLeftMargin);
+ break;
+ case 14: // Shift Out (Ctrl-N, SO) → Switch to Alternate Character Set. This invokes the G1 character set.
+ mUseLineDrawingUsesG0 = false;
+ break;
+ case 15: // Shift In (Ctrl-O, SI) → Switch to Standard Character Set. This invokes the G0 character set.
+ mUseLineDrawingUsesG0 = true;
+ break;
+ case 24: // CAN.
+ case 26: // SUB.
+ if (mEscapeState != ESC_NONE) {
+ // FIXME: What is this??
+ mEscapeState = ESC_NONE;
+ emitCodePoint(127);
+ }
+ break;
+ case 27: // ESC
+ // Starts an escape sequence unless we're parsing a string
+ if (mEscapeState == ESC_P) {
+ // XXX: Ignore escape when reading device control sequence, since it may be part of string terminator.
+ return;
+ } else if (mEscapeState != ESC_OSC) {
+ startEscapeSequence();
+ } else {
+ doOsc(b);
+ }
+ break;
+ default:
+ mContinueSequence = false;
+ switch (mEscapeState) {
+ case ESC_NONE:
+ if (b >= 32) emitCodePoint(b);
+ break;
+ case ESC:
+ doEsc(b);
+ break;
+ case ESC_POUND:
+ doEscPound(b);
+ break;
+ case ESC_SELECT_LEFT_PAREN: // Designate G0 Character Set (ISO 2022, VT100).
+ mUseLineDrawingG0 = (b == '0');
+ break;
+ case ESC_SELECT_RIGHT_PAREN: // Designate G1 Character Set (ISO 2022, VT100).
+ mUseLineDrawingG1 = (b == '0');
+ break;
+ case ESC_CSI:
+ doCsi(b);
+ break;
+ case ESC_CSI_EXCLAMATION:
+ if (b == 'p') { // Soft terminal reset (DECSTR, http://vt100.net/docs/vt510-rm/DECSTR).
+ reset();
+ } else {
+ unknownSequence(b);
+ }
+ break;
+ case ESC_CSI_QUESTIONMARK:
+ doCsiQuestionMark(b);
+ break;
+ case ESC_CSI_BIGGERTHAN:
+ doCsiBiggerThan(b);
+ break;
+ case ESC_CSI_DOLLAR:
+ boolean originMode = isDecsetInternalBitSet(DECSET_BIT_ORIGIN_MODE);
+ int effectiveTopMargin = originMode ? mTopMargin : 0;
+ int effectiveBottomMargin = originMode ? mBottomMargin : mRows;
+ int effectiveLeftMargin = originMode ? mLeftMargin : 0;
+ int effectiveRightMargin = originMode ? mRightMargin : mColumns;
+ switch (b) {
+ case 'v': // ${CSI}${SRC_TOP}${SRC_LEFT}${SRC_BOTTOM}${SRC_RIGHT}${SRC_PAGE}${DST_TOP}${DST_LEFT}${DST_PAGE}$v"
+ // Copy rectangular area (DECCRA - http://vt100.net/docs/vt510-rm/DECCRA):
+ // "If Pbs is greater than Pts, or Pls is greater than Prs, the terminal ignores DECCRA.
+ // The coordinates of the rectangular area are affected by the setting of origin mode (DECOM).
+ // DECCRA is not affected by the page margins.
+ // The copied text takes on the line attributes of the destination area.
+ // If the value of Pt, Pl, Pb, or Pr exceeds the width or height of the active page, then the value
+ // is treated as the width or height of that page.
+ // If the destination area is partially off the page, then DECCRA clips the off-page data.
+ // DECCRA does not change the active cursor position."
+ int topSource = Math.min(getArg(0, 1, true) - 1 + effectiveTopMargin, mRows);
+ int leftSource = Math.min(getArg(1, 1, true) - 1 + effectiveLeftMargin, mColumns);
+ // Inclusive, so do not subtract one:
+ int bottomSource = Math.min(Math.max(getArg(2, mRows, true) + effectiveTopMargin, topSource), mRows);
+ int rightSource = Math.min(Math.max(getArg(3, mColumns, true) + effectiveLeftMargin, leftSource), mColumns);
+ // int sourcePage = getArg(4, 1, true);
+ int destionationTop = Math.min(getArg(5, 1, true) - 1 + effectiveTopMargin, mRows);
+ int destinationLeft = Math.min(getArg(6, 1, true) - 1 + effectiveLeftMargin, mColumns);
+ // int destinationPage = getArg(7, 1, true);
+ int heightToCopy = Math.min(mRows - destionationTop, bottomSource - topSource);
+ int widthToCopy = Math.min(mColumns - destinationLeft, rightSource - leftSource);
+ mScreen.blockCopy(leftSource, topSource, widthToCopy, heightToCopy, destinationLeft, destionationTop);
+ break;
+ case '{': // ${CSI}${TOP}${LEFT}${BOTTOM}${RIGHT}${"
+ // Selective erase rectangular area (DECSERA - http://www.vt100.net/docs/vt510-rm/DECSERA).
+ case 'x': // ${CSI}${CHAR};${TOP}${LEFT}${BOTTOM}${RIGHT}$x"
+ // Fill rectangular area (DECFRA - http://www.vt100.net/docs/vt510-rm/DECFRA).
+ case 'z': // ${CSI}$${TOP}${LEFT}${BOTTOM}${RIGHT}$z"
+ // Erase rectangular area (DECERA - http://www.vt100.net/docs/vt510-rm/DECERA).
+ boolean erase = b != 'x';
+ boolean selective = b == '{';
+ // Only DECSERA keeps visual attributes, DECERA does not:
+ boolean keepVisualAttributes = erase && selective;
+ int argIndex = 0;
+ int fillChar = erase ? ' ' : getArg(argIndex++, -1, true);
+ // "Pch can be any value from 32 to 126 or from 160 to 255. If Pch is not in this range, then the
+ // terminal ignores the DECFRA command":
+ if ((fillChar >= 32 && fillChar <= 126) || (fillChar >= 160 && fillChar <= 255)) {
+ // "If the value of Pt, Pl, Pb, or Pr exceeds the width or height of the active page, the value
+ // is treated as the width or height of that page."
+ int top = Math.min(getArg(argIndex++, 1, true) + effectiveTopMargin, effectiveBottomMargin + 1);
+ int left = Math.min(getArg(argIndex++, 1, true) + effectiveLeftMargin, effectiveRightMargin + 1);
+ int bottom = Math.min(getArg(argIndex++, mRows, true) + effectiveTopMargin, effectiveBottomMargin);
+ int right = Math.min(getArg(argIndex, mColumns, true) + effectiveLeftMargin, effectiveRightMargin);
+ int style = getStyle();
+ for (int row = top - 1; row < bottom; row++)
+ for (int col = left - 1; col < right; col++)
+ if (!selective || (TextStyle.decodeEffect(mScreen.getStyleAt(row, col)) & TextStyle.CHARACTER_ATTRIBUTE_PROTECTED) == 0)
+ mScreen.setChar(col, row, fillChar, keepVisualAttributes ? mScreen.getStyleAt(row, col) : style);
+ }
+ break;
+ case 'r': // "${CSI}${TOP}${LEFT}${BOTTOM}${RIGHT}${ATTRIBUTES}$r"
+ // Change attributes in rectangular area (DECCARA - http://vt100.net/docs/vt510-rm/DECCARA).
+ case 't': // "${CSI}${TOP}${LEFT}${BOTTOM}${RIGHT}${ATTRIBUTES}$t"
+ // Reverse attributes in rectangular area (DECRARA - http://www.vt100.net/docs/vt510-rm/DECRARA).
+ boolean reverse = b == 't';
+ // FIXME: "coordinates of the rectangular area are affected by the setting of origin mode (DECOM)".s
+ int top = Math.min(getArg(0, 1, true) - 1, effectiveBottomMargin) + effectiveTopMargin;
+ int left = Math.min(getArg(1, 1, true) - 1, effectiveRightMargin) + effectiveLeftMargin;
+ int bottom = Math.min(getArg(2, mRows, true) + 1, effectiveBottomMargin - 1) + effectiveTopMargin;
+ int right = Math.min(getArg(3, mColumns, true) + 1, effectiveRightMargin - 1) + effectiveLeftMargin;
+ if (mArgIndex >= 4) {
+ for (int i = 4; i <= mArgIndex; i++) {
+ int bits = 0;
+ boolean setOrClear = true; // True if setting, false if clearing.
+ switch (getArg(i, 0, false)) {
+ case 0: // Attributes off (no bold, no underline, no blink, positive image).
+ bits = (TextStyle.CHARACTER_ATTRIBUTE_BOLD | TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE | TextStyle.CHARACTER_ATTRIBUTE_BLINK
+ | TextStyle.CHARACTER_ATTRIBUTE_INVERSE);
+ if (!reverse) setOrClear = false;
+ break;
+ case 1: // Bold.
+ bits = TextStyle.CHARACTER_ATTRIBUTE_BOLD;
+ break;
+ case 4: // Underline.
+ bits = TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE;
+ break;
+ case 5: // Blink.
+ bits = TextStyle.CHARACTER_ATTRIBUTE_BLINK;
+ break;
+ case 7: // Negative image.
+ bits = TextStyle.CHARACTER_ATTRIBUTE_INVERSE;
+ break;
+ case 22: // No bold.
+ bits = TextStyle.CHARACTER_ATTRIBUTE_BOLD;
+ setOrClear = false;
+ break;
+ case 24: // No underline.
+ bits = TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE;
+ setOrClear = false;
+ break;
+ case 25: // No blink.
+ bits = TextStyle.CHARACTER_ATTRIBUTE_BLINK;
+ setOrClear = false;
+ break;
+ case 27: // Positive image.
+ bits = TextStyle.CHARACTER_ATTRIBUTE_INVERSE;
+ setOrClear = false;
+ break;
+ }
+ if (reverse && !setOrClear) {
+ // Reverse attributes in rectangular area ignores non-(1,4,5,7) bits.
+ } else {
+ mScreen.setOrClearEffect(bits, setOrClear, reverse, isDecsetInternalBitSet(DECSET_BIT_RECTANGULAR_CHANGEATTRIBUTE),
+ effectiveLeftMargin, effectiveRightMargin, top, left, bottom, right);
+ }
+ }
+ } else {
+ // Do nothing.
+ }
+ break;
+ default:
+ unknownSequence(b);
+ }
+ break;
+ case ESC_CSI_DOUBLE_QUOTE:
+ if (b == 'q') {
+ // http://www.vt100.net/docs/vt510-rm/DECSCA
+ int arg = getArg0(0);
+ if (arg == 0 || arg == 2) {
+ // DECSED and DECSEL can erase characters.
+ mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_PROTECTED;
+ } else if (arg == 1) {
+ // DECSED and DECSEL cannot erase characters.
+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_PROTECTED;
+ } else {
+ unknownSequence(b);
+ }
+ } else {
+ unknownSequence(b);
+ }
+ break;
+ case ESC_CSI_SINGLE_QUOTE:
+ if (b == '}') { // Insert Ps Column(s) (default = 1) (DECIC), VT420 and up.
+ int columnsAfterCursor = mRightMargin - mCursorCol;
+ int columnsToInsert = Math.min(getArg0(1), columnsAfterCursor);
+ int columnsToMove = columnsAfterCursor - columnsToInsert;
+ mScreen.blockCopy(mCursorCol, 0, columnsToMove, mRows, mCursorCol + columnsToInsert, 0);
+ blockClear(mCursorCol, 0, columnsToInsert, mRows);
+ } else if (b == '~') { // Delete Ps Column(s) (default = 1) (DECDC), VT420 and up.
+ int columnsAfterCursor = mRightMargin - mCursorCol;
+ int columnsToDelete = Math.min(getArg0(1), columnsAfterCursor);
+ int columnsToMove = columnsAfterCursor - columnsToDelete;
+ mScreen.blockCopy(mCursorCol + columnsToDelete, 0, columnsToMove, mRows, mCursorCol, 0);
+ blockClear(mCursorRow + columnsToMove, 0, columnsToDelete, mRows);
+ } else {
+ unknownSequence(b);
+ }
+ break;
+ case ESC_PERCENT:
+ Log.i(EmulatorDebug.LOG_TAG, "Ignoring character set sequence 'ESC % " + (char) b + "'");
+ break;
+ case ESC_OSC:
+ doOsc(b);
+ break;
+ case ESC_OSC_ESC:
+ doOscEsc(b);
+ break;
+ case ESC_P:
+ doDeviceControl(b);
+ break;
+ case ESC_CSI_QUESTIONMARK_ARG_DOLLAR:
+ if (b == 'p') {
+ // Request DEC private mode (DECRQM).
+ int mode = getArg0(0);
+ int value;
+ if (mode == 47 || mode == 1047 || mode == 1049) {
+ // This state is carried by mScreen pointer.
+ value = (mScreen == mAltBuffer) ? 1 : 2;
+ } else {
+ int internalBit = mapDecSetBitToInternalBit(mode);
+ if (internalBit == -1) {
+ value = isDecsetInternalBitSet(internalBit) ? 1 : 2; // 1=set, 2=reset.
+ } else {
+ Log.e(EmulatorDebug.LOG_TAG, "Got DECRQM for unrecognized private DEC mode=" + mode);
+ value = 0; // 0=not recognized, 3=permanently set, 4=permanently reset
+ }
+ }
+ mSession.write(String.format(Locale.US, "\033[?%d;%d$y", mode, value));
+ } else {
+ unknownSequence(b);
+ }
+ break;
+ case ESC_CSI_ARGS_SPACE:
+ int arg = getArg0(0);
+ switch (b) {
+ case 'q': // "${CSI}${STYLE} q" - set cursor style (http://www.vt100.net/docs/vt510-rm/DECSCUSR).
+ switch (arg) {
+ case 0: // Blinking block.
+ case 1: // Blinking block.
+ case 2: // Steady block.
+ mCursorStyle = CURSOR_STYLE_BLOCK;
+ break;
+ case 3: // Blinking underline.
+ case 4: // Steady underline.
+ mCursorStyle = CURSOR_STYLE_UNDERLINE;
+ break;
+ case 5: // Blinking bar (xterm addition).
+ case 6: // Steady bar (xterm addition).
+ mCursorStyle = CURSOR_STYLE_BAR;
+ break;
+ }
+ break;
+ case 't':
+ case 'u':
+ // Set margin-bell volume - ignore.
+ break;
+ default:
+ unknownSequence(b);
+ }
+ break;
+ case ESC_CSI_ARGS_ASTERIX:
+ int attributeChangeExtent = getArg0(0);
+ if (b == 'x' && (attributeChangeExtent >= 0 && attributeChangeExtent <= 2)) {
+ // Select attribute change extent (DECSACE - http://www.vt100.net/docs/vt510-rm/DECSACE).
+ setDecsetinternalBit(DECSET_BIT_RECTANGULAR_CHANGEATTRIBUTE, attributeChangeExtent == 2);
+ } else {
+ unknownSequence(b);
+ }
+ break;
+ default:
+ unknownSequence(b);
+ break;
+ }
+ if (!mContinueSequence) mEscapeState = ESC_NONE;
+ break;
+ }
+ }
+
+ /** When in {@link #ESC_P} ("device control") sequence. */
+ private void doDeviceControl(int b) {
+ switch (b) {
+ case (byte) '\\': // End of ESC \ string Terminator
+ {
+ String dcs = mOSCOrDeviceControlArgs.toString();
+ // DCS $ q P t ST. Request Status String (DECRQSS)
+ if (dcs.startsWith("$q")) {
+ if (dcs.equals("$q\"p")) {
+ // DECSCL, conformance level, http://www.vt100.net/docs/vt510-rm/DECSCL:
+ String csiString = "64;1\"p";
+ mSession.write("\033P1$r" + csiString + "\033\\");
+ } else {
+ finishSequenceAndLogError("Unrecognized DECRQSS string: '" + dcs + "'");
+ }
+ } else if (dcs.startsWith("+q")) {
+ // Request Termcap/Terminfo String. The string following the "q" is a list of names encoded in
+ // hexadecimal (2 digits per character) separated by ; which correspond to termcap or terminfo key
+ // names.
+ // Two special features are also recognized, which are not key names: Co for termcap colors (or colors
+ // for terminfo colors), and TN for termcap name (or name for terminfo name).
+ // xterm responds with DCS 1 + r P t ST for valid requests, adding to P t an = , and the value of the
+ // corresponding string that xterm would send, or DCS 0 + r P t ST for invalid requests. The strings are
+ // encoded in hexadecimal (2 digits per character).
+ // Example:
+ // :kr=\EOC: ks=\E[?1h\E=: ku=\EOA: le=^H:mb=\E[5m:md=\E[1m:\
+ // where
+ // kd=down-arrow key
+ // kl=left-arrow key
+ // kr=right-arrow key
+ // ku=up-arrow key
+ // #2=key_shome, "shifted home"
+ // #4=key_sleft, "shift arrow left"
+ // %i=key_sright, "shift arrow right"
+ // *7=key_send, "shifted end"
+ // k1=F1 function key
+
+ // Example: Request for ku is "ESC P + q 6 b 7 5 ESC \", where 6b7d=ku in hexadecimal.
+ // Xterm response in normal cursor mode:
+ // "<27> P 1 + r 6 b 7 5 = 1 B 5 B 4 1" where 0x1B 0x5B 0x41 = 27 91 65 = ESC [ A
+ // Xterm response in application cursor mode:
+ // "<27> P 1 + r 6 b 7 5 = 1 B 5 B 4 1" where 0x1B 0x4F 0x41 = 27 91 65 = ESC 0 A
+
+ // #4 is "shift arrow left":
+ // *** Device Control (DCS) for '#4'- 'ESC P + q 23 34 ESC \'
+ // Response: <27> P 1 + r 2 3 3 4 = 1 B 5 B 3 1 3 B 3 2 4 4 <27> \
+ // where 0x1B 0x5B 0x31 0x3B 0x32 0x44 = ESC [ 1 ; 2 D
+ // which we find in: TermKeyListener.java: KEY_MAP.put(KEYMOD_SHIFT | KEYCODE_DPAD_LEFT, "\033[1;2D");
+
+ // See http://h30097.www3.hp.com/docs/base_doc/DOCUMENTATION/V40G_HTML/MAN/MAN4/0178____.HTM for what to
+ // respond, as well as http://www.freebsd.org/cgi/man.cgi?query=termcap&sektion=5#CAPABILITIES for
+ // the meaning of e.g. "ku", "kd", "kr", "kl"
+
+ for (String part : dcs.substring(2).split(";")) {
+ if (part.length() % 2 == 0) {
+ StringBuilder transBuffer = new StringBuilder();
+ for (int i = 0; i < part.length(); i += 2) {
+ char c = (char) Long.decode("0x" + part.charAt(i) + "" + part.charAt(i + 1)).longValue();
+ transBuffer.append(c);
+ }
+ String trans = transBuffer.toString();
+ String responseValue;
+ switch (trans) {
+ case "Co":
+ case "colors":
+ responseValue = "256"; // Number of colors.
+ break;
+ case "TN":
+ case "name":
+ responseValue = "xterm";
+ break;
+ default:
+ responseValue = KeyHandler.getCodeFromTermcap(trans, isDecsetInternalBitSet(DECSET_BIT_APPLICATION_CURSOR_KEYS),
+ isDecsetInternalBitSet(DECSET_BIT_APPLICATION_KEYPAD));
+ break;
+ }
+ if (responseValue == null) {
+ switch (trans) {
+ case "%1": // Help key - ignore
+ case "&8": // Undo key - ignore.
+ break;
+ default:
+ Log.w(EmulatorDebug.LOG_TAG, "Unhandled termcap/terminfo name: '" + trans + "'");
+ }
+ // Respond with invalid request:
+ mSession.write("\033P0+r" + part + "\033\\");
+ } else {
+ StringBuilder hexEncoded = new StringBuilder();
+ for (int j = 0; j < responseValue.length(); j++) {
+ hexEncoded.append(String.format("%02X", (int) responseValue.charAt(j)));
+ }
+ mSession.write("\033P1+r" + part + "=" + hexEncoded + "\033\\");
+ }
+ } else {
+ Log.e(EmulatorDebug.LOG_TAG, "Invalid device termcap/terminfo name of odd length: " + part);
+ }
+ }
+ } else {
+ if (LOG_ESCAPE_SEQUENCES)
+ Log.e(EmulatorDebug.LOG_TAG, "Unrecognized device control string: " + dcs);
+ }
+ finishSequence();
}
break;
- case 9: // Horizontal tab (HT, \t) - move to next tab stop, but not past edge of screen
- // XXX: Should perhaps use color if writing to new cells. Try with
- // printf "\033[41m\tXX\033[0m\n"
- // The OSX Terminal.app colors the spaces from the tab red, but xterm does not.
- // Note that Terminal.app only colors on new cells, in e.g.
- // printf "\033[41m\t\r\033[42m\tXX\033[0m\n"
- // the first cells are created with a red background, but when tabbing over
- // them again with a green background they are not overwritten.
- mCursorCol = nextTabStop(1);
+ default:
+ if (mOSCOrDeviceControlArgs.length() > MAX_OSC_STRING_LENGTH) {
+ // Too long.
+ mOSCOrDeviceControlArgs.setLength(0);
+ finishSequence();
+ } else {
+ mOSCOrDeviceControlArgs.appendCodePoint(b);
+ continueSequence(mEscapeState);
+ }
+ }
+ }
+
+ private int nextTabStop(int numTabs) {
+ for (int i = mCursorCol + 1; i < mColumns; i++)
+ if (mTabStop[i] && --numTabs == 0) return Math.min(i, mRightMargin);
+ return mRightMargin - 1;
+ }
+
+ /** Process byte while in the {@link #ESC_CSI_QUESTIONMARK} escape state. */
+ private void doCsiQuestionMark(int b) {
+ switch (b) {
+ case 'J': // Selective erase in display (DECSED) - http://www.vt100.net/docs/vt510-rm/DECSED.
+ case 'K': // Selective erase in line (DECSEL) - http://vt100.net/docs/vt510-rm/DECSEL.
+ mAboutToAutoWrap = false;
+ int fillChar = ' ';
+ int startCol = -1;
+ int startRow = -1;
+ int endCol = -1;
+ int endRow = -1;
+ boolean justRow = (b == 'K');
+ switch (getArg0(0)) {
+ case 0: // Erase from the active position to the end, inclusive (default).
+ startCol = mCursorCol;
+ startRow = mCursorRow;
+ endCol = mColumns;
+ endRow = justRow ? (mCursorRow + 1) : mRows;
+ break;
+ case 1: // Erase from start to the active position, inclusive.
+ startCol = 0;
+ startRow = justRow ? mCursorRow : 0;
+ endCol = mCursorCol + 1;
+ endRow = mCursorRow + 1;
+ break;
+ case 2: // Erase all of the display/line.
+ startCol = 0;
+ startRow = justRow ? mCursorRow : 0;
+ endCol = mColumns;
+ endRow = justRow ? (mCursorRow + 1) : mRows;
+ break;
+ default:
+ unknownSequence(b);
+ break;
+ }
+ int style = getStyle();
+ for (int row = startRow; row < endRow; row++) {
+ for (int col = startCol; col < endCol; col++) {
+ if ((TextStyle.decodeEffect(mScreen.getStyleAt(row, col)) & TextStyle.CHARACTER_ATTRIBUTE_PROTECTED) == 0)
+ mScreen.setChar(col, row, fillChar, style);
+ }
+ }
+ break;
+ case 'h':
+ case 'l':
+ for (int i = 0; i <= mArgIndex; i++)
+ doDecSetOrReset(b == 'h', mArgs[i]);
+ break;
+ case 'n': // Device Status Report (DSR, DEC-specific).
+ switch (getArg0(-1)) {
+ case 6:
+ // Extended Cursor Position (DECXCPR - http://www.vt100.net/docs/vt510-rm/DECXCPR). Page=1.
+ mSession.write(String.format(Locale.US, "\033[?%d;%d;1R", mCursorRow + 1, mCursorCol + 1));
+ break;
+ default:
+ finishSequence();
+ return;
+ }
+ break;
+ case 'r':
+ case 's':
+ for (int i = 0; i <= mArgIndex; i++) {
+ int externalBit = mArgs[i];
+ int internalBit = mapDecSetBitToInternalBit(externalBit);
+ if (internalBit == -1) {
+ Log.w(EmulatorDebug.LOG_TAG, "Ignoring request to save/recall decset bit=" + externalBit);
+ } else {
+ if (b == 's') {
+ mSavedDecSetFlags |= internalBit;
+ } else {
+ doDecSetOrReset((mSavedDecSetFlags & internalBit) != 0, externalBit);
+ }
+ }
+ }
+ break;
+ case '$':
+ continueSequence(ESC_CSI_QUESTIONMARK_ARG_DOLLAR);
+ return;
+ default:
+ parseArg(b);
+ }
+ }
+
+ public void doDecSetOrReset(boolean setting, int externalBit) {
+ int internalBit = mapDecSetBitToInternalBit(externalBit);
+ if (internalBit != -1) {
+ setDecsetinternalBit(internalBit, setting);
+ }
+ switch (externalBit) {
+ case 1: // Application Cursor Keys (DECCKM).
+ break;
+ case 3: // Set: 132 column mode (. Reset: 80 column mode. ANSI name: DECCOLM.
+ // We don't actually set/reset 132 cols, but we do want the side effects
+ // (FIXME: Should only do this if the 95 DECSET bit (DECNCSM) is set, and if changing value?):
+ // Sets the left, right, top and bottom scrolling margins to their default positions, which is important for
+ // the "reset" utility to really reset the terminal:
+ mLeftMargin = mTopMargin = 0;
+ mBottomMargin = mRows;
+ mRightMargin = mColumns;
+ // "DECCOLM resets vertical split screen mode (DECLRMM) to unavailable":
+ setDecsetinternalBit(DECSET_BIT_LEFTRIGHT_MARGIN_MODE, false);
+ // "Erases all data in page memory":
+ blockClear(0, 0, mColumns, mRows);
+ setCursorRowCol(0, 0);
+ break;
+ case 4: // DECSCLM-Scrolling Mode. Ignore.
+ break;
+ case 5: // Reverse video. No action.
+ break;
+ case 6: // Set: Origin Mode. Reset: Normal Cursor Mode. Ansi name: DECOM.
+ if (setting) setCursorPosition(0, 0);
+ break;
+ case 7: // Wrap-around bit, not specific action.
+ case 8: // Auto-repeat Keys (DECARM). Do not implement.
+ case 9: // X10 mouse reporting - outdated. Do not implement.
+ case 12: // Control cursor blinking - ignore.
+ case 25: // Hide/show cursor - no action needed, renderer will check with isShowingCursor().
+ case 40: // Allow 80 => 132 Mode, ignore.
+ case 45: // TODO: Reverse wrap-around. Implement???
+ case 66: // Application keypad (DECNKM).
+ break;
+ case 69: // Left and right margin mode (DECLRMM).
+ if (!setting) {
+ mLeftMargin = 0;
+ mRightMargin = mColumns;
+ }
+ break;
+ case 1000:
+ case 1001:
+ case 1002:
+ case 1003:
+ case 1004:
+ case 1005: // UTF-8 mouse mode, ignore.
+ case 1006: // SGR Mouse Mode
+ case 1015:
+ case 1034: // Interpret "meta" key, sets eighth bit.
+ break;
+ case 1048: // Set: Save cursor as in DECSC. Reset: Restore cursor as in DECRC.
+ if (setting)
+ saveCursor();
+ else
+ restoreCursor();
+ break;
+ case 47:
+ case 1047:
+ case 1049: {
+ // Set: Save cursor as in DECSC and use Alternate Screen Buffer, clearing it first.
+ // Reset: Use Normal Screen Buffer and restore cursor as in DECRC.
+ TerminalBuffer newScreen = setting ? mAltBuffer : mMainBuffer;
+ if (newScreen != mScreen) {
+ boolean resized = !(newScreen.mColumns == mColumns && newScreen.mScreenRows == mRows);
+ if (setting) saveCursor();
+ mScreen = newScreen;
+ if (!setting) {
+ int col = mSavedStateMain.mSavedCursorCol;
+ int row = mSavedStateMain.mSavedCursorRow;
+ restoreCursor();
+ if (resized) {
+ // Restore cursor position _not_ clipped to current screen (let resizeScreen() handle that):
+ mCursorCol = col;
+ mCursorRow = row;
+ }
+ }
+ // Check if buffer size needs to be updated:
+ if (resized) resizeScreen();
+ // Clear new screen if alt buffer:
+ if (newScreen == mAltBuffer)
+ newScreen.blockSet(0, 0, mColumns, mRows, ' ', getStyle());
+ }
+ break;
+ }
+ case 2004:
+ // Bracketed paste mode - setting bit is enough.
+ break;
+ default:
+ unknownParameter(externalBit);
+ break;
+ }
+ }
+
+ private void doCsiBiggerThan(int b) {
+ switch (b) {
+ case 'c': // "${CSI}>c" or "${CSI}>c". Secondary Device Attributes (DA2).
+ // Originally this was used for the terminal to respond with "identification code, firmware version level,
+ // and hardware options" (http://vt100.net/docs/vt510-rm/DA2), with the first "41" meaning the VT420
+ // terminal type. This is not used anymore, but the second version level field has been changed by xterm
+ // to mean it's release number ("patch numbers" listed at http://invisible-island.net/xterm/xterm.log.html),
+ // and some applications use it as a feature check:
+ // * tmux used to have a "xterm won't reach version 500 for a while so set that as the upper limit" check,
+ // and then check "xterm_version > 270" if rectangular area operations such as DECCRA could be used.
+ // * vim checks xterm version number >140 for "Request termcap/terminfo string" functionality >276 for SGR
+ // mouse report.
+ // The third number is a keyboard identifier not used nowadays.
+ mSession.write("\033[>41;320;0c");
+ break;
+ case 'm':
+ // https://bugs.launchpad.net/gnome-terminal/+bug/96676/comments/25
+ // Depending on the first number parameter, this can set one of the xterm resources
+ // modifyKeyboard, modifyCursorKeys, modifyFunctionKeys and modifyOtherKeys.
+ // http://invisible-island.net/xterm/manpage/xterm.html#RESOURCES
+
+ // * modifyKeyboard (parameter=1):
+ // Normally xterm makes a special case regarding modifiers (shift, control, etc.) to handle special keyboard
+ // layouts (legacy and vt220). This is done to provide compatible keyboards for DEC VT220 and related
+ // terminals that implement user-defined keys (UDK).
+ // The bits of the resource value selectively enable modification of the given category when these keyboards
+ // are selected. The default is "0":
+ // (0) The legacy/vt220 keyboards interpret only the Control-modifier when constructing numbered
+ // function-keys. Other special keys are not modified.
+ // (1) allows modification of the numeric keypad
+ // (2) allows modification of the editing keypad
+ // (4) allows modification of function-keys, overrides use of Shift-modifier for UDK.
+ // (8) allows modification of other special keys
+
+ // * modifyCursorKeys (parameter=2):
+ // Tells how to handle the special case where Control-, Shift-, Alt- or Meta-modifiers are used to add a
+ // parameter to the escape sequence returned by a cursor-key. The default is "2".
+ // - Set it to -1 to disable it.
+ // - Set it to 0 to use the old/obsolete behavior.
+ // - Set it to 1 to prefix modified sequences with CSI.
+ // - Set it to 2 to force the modifier to be the second parameter if it would otherwise be the first.
+ // - Set it to 3 to mark the sequence with a ">" to hint that it is private.
+
+ // * modifyFunctionKeys (parameter=3):
+ // Tells how to handle the special case where Control-, Shift-, Alt- or Meta-modifiers are used to add a
+ // parameter to the escape sequence returned by a (numbered) function-
+ // key. The default is "2". The resource values are similar to modifyCursorKeys:
+ // Set it to -1 to permit the user to use shift- and control-modifiers to construct function-key strings
+ // using the normal encoding scheme.
+ // - Set it to 0 to use the old/obsolete behavior.
+ // - Set it to 1 to prefix modified sequences with CSI.
+ // - Set it to 2 to force the modifier to be the second parameter if it would otherwise be the first.
+ // - Set it to 3 to mark the sequence with a ">" to hint that it is private.
+ // If modifyFunctionKeys is zero, xterm uses Control- and Shift-modifiers to allow the user to construct
+ // numbered function-keys beyond the set provided by the keyboard:
+ // (Control) adds the value given by the ctrlFKeys resource.
+ // (Shift) adds twice the value given by the ctrlFKeys resource.
+ // (Control/Shift) adds three times the value given by the ctrlFKeys resource.
+ //
+ // As a special case, legacy (when oldFunctionKeys is true) or vt220 (when sunKeyboard is true)
+ // keyboards interpret only the Control-modifier when constructing numbered function-keys.
+ // This is done to provide compatible keyboards for DEC VT220 and related terminals that
+ // implement user-defined keys (UDK).
+
+ // * modifyOtherKeys (parameter=4):
+ // Like modifyCursorKeys, tells xterm to construct an escape sequence for other keys (such as "2") when
+ // modified by Control-, Alt- or Meta-modifiers. This feature does not apply to function keys and
+ // well-defined keys such as ESC or the control keys. The default is "0".
+ // (0) disables this feature.
+ // (1) enables this feature for keys except for those with well-known behavior, e.g., Tab, Backarrow and
+ // some special control character cases, e.g., Control-Space to make a NUL.
+ // (2) enables this feature for keys including the exceptions listed.
+ Log.e(EmulatorDebug.LOG_TAG, "(ignored) CSI > MODIFY RESOURCE: " + getArg0(-1) + " to " + getArg1(-1));
+ break;
+ default:
+ parseArg(b);
+ break;
+ }
+ }
+
+ private void startEscapeSequence() {
+ mEscapeState = ESC;
+ mArgIndex = 0;
+ Arrays.fill(mArgs, -1);
+ }
+
+ private void doLinefeed() {
+ int newCursorRow = mCursorRow + 1;
+ if (newCursorRow >= mBottomMargin) {
+ scrollDownOneLine();
+ newCursorRow = mBottomMargin - 1;
+ }
+ setCursorRow(newCursorRow);
+ }
+
+ private void continueSequence(int state) {
+ mEscapeState = state;
+ mContinueSequence = true;
+ }
+
+ private void doEscPound(int b) {
+ switch (b) {
+ case '8': // Esc # 8 - DEC screen alignment test - fill screen with E's.
+ mScreen.blockSet(0, 0, mColumns, mRows, 'E', getStyle());
+ break;
+ default:
+ unknownSequence(b);
+ break;
+ }
+ }
+
+ /** Encountering a character in the {@link #ESC} state. */
+ private void doEsc(int b) {
+ switch (b) {
+ case '#':
+ continueSequence(ESC_POUND);
+ break;
+ case '(':
+ continueSequence(ESC_SELECT_LEFT_PAREN);
+ break;
+ case ')':
+ continueSequence(ESC_SELECT_RIGHT_PAREN);
+ break;
+ case '6': // Back index (http://www.vt100.net/docs/vt510-rm/DECBI). Move left, insert blank column if start.
+ if (mCursorCol > mLeftMargin) {
+ mCursorCol--;
+ } else {
+ int rows = mBottomMargin - mTopMargin;
+ mScreen.blockCopy(mLeftMargin, mTopMargin, mRightMargin - mLeftMargin - 1, rows, mLeftMargin + 1, mTopMargin);
+ mScreen.blockSet(mLeftMargin, mTopMargin, 1, rows, ' ', TextStyle.encode(mForeColor, mBackColor, 0));
+ }
+ break;
+ case '7': // DECSC save cursor - http://www.vt100.net/docs/vt510-rm/DECSC
+ saveCursor();
+ break;
+ case '8': // DECRC restore cursor - http://www.vt100.net/docs/vt510-rm/DECRC
+ restoreCursor();
+ break;
+ case '9': // Forward Index (http://www.vt100.net/docs/vt510-rm/DECFI). Move right, insert blank column if end.
+ if (mCursorCol < mRightMargin - 1) {
+ mCursorCol++;
+ } else {
+ int rows = mBottomMargin - mTopMargin;
+ mScreen.blockCopy(mLeftMargin + 1, mTopMargin, mRightMargin - mLeftMargin - 1, rows, mLeftMargin, mTopMargin);
+ mScreen.blockSet(mRightMargin - 1, mTopMargin, 1, rows, ' ', TextStyle.encode(mForeColor, mBackColor, 0));
+ }
+ break;
+ case 'c': // RIS - Reset to Initial State (http://vt100.net/docs/vt510-rm/RIS).
+ reset();
+ blockClear(0, 0, mColumns, mRows);
+ setCursorPosition(0, 0);
+ break;
+ case 'D': // INDEX
+ doLinefeed();
+ break;
+ case 'E': // Next line (http://www.vt100.net/docs/vt510-rm/NEL).
+ setCursorCol(isDecsetInternalBitSet(DECSET_BIT_ORIGIN_MODE) ? mLeftMargin : 0);
+ doLinefeed();
+ break;
+ case 'F': // Cursor to lower-left corner of screen
+ setCursorRowCol(0, mBottomMargin - 1);
+ break;
+ case 'H': // Tab set
+ mTabStop[mCursorCol] = true;
+ break;
+ case 'M': // "${ESC}M" - reverse index (RI).
+ // http://www.vt100.net/docs/vt100-ug/chapter3.html: "Move the active position to the same horizontal
+ // position on the preceding line. If the active position is at the top margin, a scroll down is performed".
+ if (mCursorRow <= mTopMargin) {
+ mScreen.blockCopy(0, mTopMargin, mColumns, mBottomMargin - (mTopMargin + 1), 0, mTopMargin + 1);
+ blockClear(0, mTopMargin, mColumns);
+ } else {
+ mCursorRow--;
+ }
+ break;
+ case 'N': // SS2, ignore.
+ case '0': // SS3, ignore.
+ break;
+ case 'P': // Device control string
+ mOSCOrDeviceControlArgs.setLength(0);
+ continueSequence(ESC_P);
+ break;
+ case '[':
+ continueSequence(ESC_CSI);
+ break;
+ case '=': // DECKPAM
+ setDecsetinternalBit(DECSET_BIT_APPLICATION_KEYPAD, true);
+ break;
+ case ']': // OSC
+ mOSCOrDeviceControlArgs.setLength(0);
+ continueSequence(ESC_OSC);
+ break;
+ case '>': // DECKPNM
+ setDecsetinternalBit(DECSET_BIT_APPLICATION_KEYPAD, false);
+ break;
+ default:
+ unknownSequence(b);
+ break;
+ }
+ }
+
+ /** DECSC save cursor - http://www.vt100.net/docs/vt510-rm/DECSC . See {@link #restoreCursor()}. */
+ private void saveCursor() {
+ SavedScreenState state = (mScreen == mMainBuffer) ? mSavedStateMain : mSavedStateAlt;
+ state.mSavedCursorRow = mCursorRow;
+ state.mSavedCursorCol = mCursorCol;
+ state.mSavedEffect = mEffect;
+ state.mSavedDecFlags = mCurrentDecSetFlags;
+ state.mUseLineDrawingG0 = mUseLineDrawingG0;
+ state.mUseLineDrawingG1 = mUseLineDrawingG1;
+ state.mUseLineDrawingUsesG0 = mUseLineDrawingUsesG0;
+ }
+
+ /** DECRS restore cursor - http://www.vt100.net/docs/vt510-rm/DECRC. See {@link #saveCursor()}. */
+ private void restoreCursor() {
+ SavedScreenState state = (mScreen == mMainBuffer) ? mSavedStateMain : mSavedStateAlt;
+ setCursorRowCol(state.mSavedCursorRow, state.mSavedCursorCol);
+ mEffect = state.mSavedEffect;
+ int mask = (DECSET_BIT_AUTOWRAP | DECSET_BIT_ORIGIN_MODE);
+ mCurrentDecSetFlags = (mCurrentDecSetFlags & ~mask) | (state.mSavedDecFlags & mask);
+ mUseLineDrawingG0 = state.mUseLineDrawingG0;
+ mUseLineDrawingG1 = state.mUseLineDrawingG1;
+ mUseLineDrawingUsesG0 = state.mUseLineDrawingUsesG0;
+ }
+
+ /** Following a CSI - Control Sequence Introducer, "\033[". {@link #ESC_CSI}. */
+ private void doCsi(int b) {
+ switch (b) {
+ case '!':
+ continueSequence(ESC_CSI_EXCLAMATION);
+ break;
+ case '"':
+ continueSequence(ESC_CSI_DOUBLE_QUOTE);
+ break;
+ case '\'':
+ continueSequence(ESC_CSI_SINGLE_QUOTE);
+ break;
+ case '$':
+ continueSequence(ESC_CSI_DOLLAR);
+ break;
+ case '*':
+ continueSequence(ESC_CSI_ARGS_ASTERIX);
+ break;
+ case '@': {
+ // "CSI{n}@" - Insert ${n} space characters (ICH) - http://www.vt100.net/docs/vt510-rm/ICH.
+ mAboutToAutoWrap = false;
+ int columnsAfterCursor = mColumns - mCursorCol;
+ int spacesToInsert = Math.min(getArg0(1), columnsAfterCursor);
+ int charsToMove = columnsAfterCursor - spacesToInsert;
+ mScreen.blockCopy(mCursorCol, mCursorRow, charsToMove, 1, mCursorCol + spacesToInsert, mCursorRow);
+ blockClear(mCursorCol, mCursorRow, spacesToInsert);
+ }
break;
- case 10: // Line feed (LF, \n).
- case 11: // Vertical tab (VT, \v).
- case 12: // Form feed (FF, \f).
- doLinefeed();
- break;
- case 13: // Carriage return (CR, \r).
- setCursorCol(mLeftMargin);
- break;
- case 14: // Shift Out (Ctrl-N, SO) → Switch to Alternate Character Set. This invokes the G1 character set.
- mUseLineDrawingUsesG0 = false;
- break;
- case 15: // Shift In (Ctrl-O, SI) → Switch to Standard Character Set. This invokes the G0 character set.
- mUseLineDrawingUsesG0 = true;
- break;
- case 24: // CAN.
- case 26: // SUB.
- if (mEscapeState != ESC_NONE) {
- // FIXME: What is this??
- mEscapeState = ESC_NONE;
- emitCodePoint(127);
- }
- break;
- case 27: // ESC
- // Starts an escape sequence unless we're parsing a string
- if (mEscapeState == ESC_P) {
- // XXX: Ignore escape when reading device control sequence, since it may be part of string terminator.
- return;
- } else if (mEscapeState != ESC_OSC) {
- startEscapeSequence();
- } else {
- doOsc(b);
- }
- break;
- default:
- mContinueSequence = false;
- switch (mEscapeState) {
- case ESC_NONE:
- if (b >= 32) emitCodePoint(b);
- break;
- case ESC:
- doEsc(b);
- break;
- case ESC_POUND:
- doEscPound(b);
- break;
- case ESC_SELECT_LEFT_PAREN: // Designate G0 Character Set (ISO 2022, VT100).
- mUseLineDrawingG0 = (b == '0');
- break;
- case ESC_SELECT_RIGHT_PAREN: // Designate G1 Character Set (ISO 2022, VT100).
- mUseLineDrawingG1 = (b == '0');
- break;
- case ESC_CSI:
- doCsi(b);
- break;
- case ESC_CSI_EXCLAMATION:
- if (b == 'p') { // Soft terminal reset (DECSTR, http://vt100.net/docs/vt510-rm/DECSTR).
- reset();
- } else {
- unknownSequence(b);
- }
- break;
- case ESC_CSI_QUESTIONMARK:
- doCsiQuestionMark(b);
- break;
- case ESC_CSI_BIGGERTHAN:
- doCsiBiggerThan(b);
- break;
- case ESC_CSI_DOLLAR:
- boolean originMode = isDecsetInternalBitSet(DECSET_BIT_ORIGIN_MODE);
- int effectiveTopMargin = originMode ? mTopMargin : 0;
- int effectiveBottomMargin = originMode ? mBottomMargin : mRows;
- int effectiveLeftMargin = originMode ? mLeftMargin : 0;
- int effectiveRightMargin = originMode ? mRightMargin : mColumns;
- switch (b) {
- case 'v': // ${CSI}${SRC_TOP}${SRC_LEFT}${SRC_BOTTOM}${SRC_RIGHT}${SRC_PAGE}${DST_TOP}${DST_LEFT}${DST_PAGE}$v"
- // Copy rectangular area (DECCRA - http://vt100.net/docs/vt510-rm/DECCRA):
- // "If Pbs is greater than Pts, or Pls is greater than Prs, the terminal ignores DECCRA.
- // The coordinates of the rectangular area are affected by the setting of origin mode (DECOM).
- // DECCRA is not affected by the page margins.
- // The copied text takes on the line attributes of the destination area.
- // If the value of Pt, Pl, Pb, or Pr exceeds the width or height of the active page, then the value
- // is treated as the width or height of that page.
- // If the destination area is partially off the page, then DECCRA clips the off-page data.
- // DECCRA does not change the active cursor position."
- int topSource = Math.min(getArg(0, 1, true) - 1 + effectiveTopMargin, mRows);
- int leftSource = Math.min(getArg(1, 1, true) - 1 + effectiveLeftMargin, mColumns);
- // Inclusive, so do not subtract one:
- int bottomSource = Math.min(Math.max(getArg(2, mRows, true) + effectiveTopMargin, topSource), mRows);
- int rightSource = Math.min(Math.max(getArg(3, mColumns, true) + effectiveLeftMargin, leftSource), mColumns);
- // int sourcePage = getArg(4, 1, true);
- int destionationTop = Math.min(getArg(5, 1, true) - 1 + effectiveTopMargin, mRows);
- int destinationLeft = Math.min(getArg(6, 1, true) - 1 + effectiveLeftMargin, mColumns);
- // int destinationPage = getArg(7, 1, true);
- int heightToCopy = Math.min(mRows - destionationTop, bottomSource - topSource);
- int widthToCopy = Math.min(mColumns - destinationLeft, rightSource - leftSource);
- mScreen.blockCopy(leftSource, topSource, widthToCopy, heightToCopy, destinationLeft, destionationTop);
- break;
- case '{': // ${CSI}${TOP}${LEFT}${BOTTOM}${RIGHT}${"
- // Selective erase rectangular area (DECSERA - http://www.vt100.net/docs/vt510-rm/DECSERA).
- case 'x': // ${CSI}${CHAR};${TOP}${LEFT}${BOTTOM}${RIGHT}$x"
- // Fill rectangular area (DECFRA - http://www.vt100.net/docs/vt510-rm/DECFRA).
- case 'z': // ${CSI}$${TOP}${LEFT}${BOTTOM}${RIGHT}$z"
- // Erase rectangular area (DECERA - http://www.vt100.net/docs/vt510-rm/DECERA).
- boolean erase = b != 'x';
- boolean selective = b == '{';
- // Only DECSERA keeps visual attributes, DECERA does not:
- boolean keepVisualAttributes = erase && selective;
- int argIndex = 0;
- int fillChar = erase ? ' ' : getArg(argIndex++, -1, true);
- // "Pch can be any value from 32 to 126 or from 160 to 255. If Pch is not in this range, then the
- // terminal ignores the DECFRA command":
- if ((fillChar >= 32 && fillChar <= 126) || (fillChar >= 160 && fillChar <= 255)) {
- // "If the value of Pt, Pl, Pb, or Pr exceeds the width or height of the active page, the value
- // is treated as the width or height of that page."
- int top = Math.min(getArg(argIndex++, 1, true) + effectiveTopMargin, effectiveBottomMargin + 1);
- int left = Math.min(getArg(argIndex++, 1, true) + effectiveLeftMargin, effectiveRightMargin + 1);
- int bottom = Math.min(getArg(argIndex++, mRows, true) + effectiveTopMargin, effectiveBottomMargin);
- int right = Math.min(getArg(argIndex, mColumns, true) + effectiveLeftMargin, effectiveRightMargin);
- int style = getStyle();
- for (int row = top - 1; row < bottom; row++)
- for (int col = left - 1; col < right; col++)
- if (!selective || (TextStyle.decodeEffect(mScreen.getStyleAt(row, col)) & TextStyle.CHARACTER_ATTRIBUTE_PROTECTED) == 0)
- mScreen.setChar(col, row, fillChar, keepVisualAttributes ? mScreen.getStyleAt(row, col) : style);
- }
- break;
- case 'r': // "${CSI}${TOP}${LEFT}${BOTTOM}${RIGHT}${ATTRIBUTES}$r"
- // Change attributes in rectangular area (DECCARA - http://vt100.net/docs/vt510-rm/DECCARA).
- case 't': // "${CSI}${TOP}${LEFT}${BOTTOM}${RIGHT}${ATTRIBUTES}$t"
- // Reverse attributes in rectangular area (DECRARA - http://www.vt100.net/docs/vt510-rm/DECRARA).
- boolean reverse = b == 't';
- // FIXME: "coordinates of the rectangular area are affected by the setting of origin mode (DECOM)".s
- int top = Math.min(getArg(0, 1, true) - 1, effectiveBottomMargin) + effectiveTopMargin;
- int left = Math.min(getArg(1, 1, true) - 1, effectiveRightMargin) + effectiveLeftMargin;
- int bottom = Math.min(getArg(2, mRows, true) + 1, effectiveBottomMargin - 1) + effectiveTopMargin;
- int right = Math.min(getArg(3, mColumns, true) + 1, effectiveRightMargin - 1) + effectiveLeftMargin;
- if (mArgIndex >= 4) {
- for (int i = 4; i <= mArgIndex; i++) {
- int bits = 0;
- boolean setOrClear = true; // True if setting, false if clearing.
- switch (getArg(i, 0, false)) {
- case 0: // Attributes off (no bold, no underline, no blink, positive image).
- bits = (TextStyle.CHARACTER_ATTRIBUTE_BOLD | TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE | TextStyle.CHARACTER_ATTRIBUTE_BLINK
- | TextStyle.CHARACTER_ATTRIBUTE_INVERSE);
- if (!reverse) setOrClear = false;
- break;
- case 1: // Bold.
- bits = TextStyle.CHARACTER_ATTRIBUTE_BOLD;
- break;
- case 4: // Underline.
- bits = TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE;
- break;
- case 5: // Blink.
- bits = TextStyle.CHARACTER_ATTRIBUTE_BLINK;
- break;
- case 7: // Negative image.
- bits = TextStyle.CHARACTER_ATTRIBUTE_INVERSE;
- break;
- case 22: // No bold.
- bits = TextStyle.CHARACTER_ATTRIBUTE_BOLD;
- setOrClear = false;
- break;
- case 24: // No underline.
- bits = TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE;
- setOrClear = false;
- break;
- case 25: // No blink.
- bits = TextStyle.CHARACTER_ATTRIBUTE_BLINK;
- setOrClear = false;
- break;
- case 27: // Positive image.
- bits = TextStyle.CHARACTER_ATTRIBUTE_INVERSE;
- setOrClear = false;
- break;
- }
- if (reverse && !setOrClear) {
- // Reverse attributes in rectangular area ignores non-(1,4,5,7) bits.
- } else {
- mScreen.setOrClearEffect(bits, setOrClear, reverse, isDecsetInternalBitSet(DECSET_BIT_RECTANGULAR_CHANGEATTRIBUTE),
- effectiveLeftMargin, effectiveRightMargin, top, left, bottom, right);
- }
- }
- } else {
- // Do nothing.
- }
- break;
- default:
- unknownSequence(b);
- }
- break;
- case ESC_CSI_DOUBLE_QUOTE:
- if (b == 'q') {
- // http://www.vt100.net/docs/vt510-rm/DECSCA
- int arg = getArg0(0);
- if (arg == 0 || arg == 2) {
- // DECSED and DECSEL can erase characters.
- mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_PROTECTED;
- } else if (arg == 1) {
- // DECSED and DECSEL cannot erase characters.
- mEffect |= TextStyle.CHARACTER_ATTRIBUTE_PROTECTED;
- } else {
- unknownSequence(b);
- }
- } else {
- unknownSequence(b);
- }
- break;
- case ESC_CSI_SINGLE_QUOTE:
- if (b == '}') { // Insert Ps Column(s) (default = 1) (DECIC), VT420 and up.
- int columnsAfterCursor = mRightMargin - mCursorCol;
- int columnsToInsert = Math.min(getArg0(1), columnsAfterCursor);
- int columnsToMove = columnsAfterCursor - columnsToInsert;
- mScreen.blockCopy(mCursorCol, 0, columnsToMove, mRows, mCursorCol + columnsToInsert, 0);
- blockClear(mCursorCol, 0, columnsToInsert, mRows);
- } else if (b == '~') { // Delete Ps Column(s) (default = 1) (DECDC), VT420 and up.
- int columnsAfterCursor = mRightMargin - mCursorCol;
- int columnsToDelete = Math.min(getArg0(1), columnsAfterCursor);
- int columnsToMove = columnsAfterCursor - columnsToDelete;
- mScreen.blockCopy(mCursorCol + columnsToDelete, 0, columnsToMove, mRows, mCursorCol, 0);
- blockClear(mCursorRow + columnsToMove, 0, columnsToDelete, mRows);
- } else {
- unknownSequence(b);
- }
- break;
- case ESC_PERCENT:
- Log.i(EmulatorDebug.LOG_TAG, "Ignoring character set sequence 'ESC % " + (char) b + "'");
- break;
- case ESC_OSC:
- doOsc(b);
- break;
- case ESC_OSC_ESC:
- doOscEsc(b);
- break;
- case ESC_P:
- doDeviceControl(b);
- break;
- case ESC_CSI_QUESTIONMARK_ARG_DOLLAR:
- if (b == 'p') {
- // Request DEC private mode (DECRQM).
- int mode = getArg0(0);
- int value;
- if (mode == 47 || mode == 1047 || mode == 1049) {
- // This state is carried by mScreen pointer.
- value = (mScreen == mAltBuffer) ? 1 : 2;
- } else {
- int internalBit = mapDecSetBitToInternalBit(mode);
- if (internalBit == -1) {
- value = isDecsetInternalBitSet(internalBit) ? 1 : 2; // 1=set, 2=reset.
- } else {
- Log.e(EmulatorDebug.LOG_TAG, "Got DECRQM for unrecognized private DEC mode=" + mode);
- value = 0; // 0=not recognized, 3=permanently set, 4=permanently reset
- }
- }
- mSession.write(String.format(Locale.US, "\033[?%d;%d$y", mode, value));
- } else {
- unknownSequence(b);
- }
- break;
- case ESC_CSI_ARGS_SPACE:
- int arg = getArg0(0);
- switch (b) {
- case 'q': // "${CSI}${STYLE} q" - set cursor style (http://www.vt100.net/docs/vt510-rm/DECSCUSR).
- switch (arg) {
- case 0: // Blinking block.
- case 1: // Blinking block.
- case 2: // Steady block.
- mCursorStyle = CURSOR_STYLE_BLOCK;
- break;
- case 3: // Blinking underline.
- case 4: // Steady underline.
- mCursorStyle = CURSOR_STYLE_UNDERLINE;
- break;
- case 5: // Blinking bar (xterm addition).
- case 6: // Steady bar (xterm addition).
- mCursorStyle = CURSOR_STYLE_BAR;
- break;
- }
- break;
- case 't':
- case 'u':
- // Set margin-bell volume - ignore.
- break;
- default:
- unknownSequence(b);
- }
- break;
- case ESC_CSI_ARGS_ASTERIX:
- int attributeChangeExtent = getArg0(0);
- if (b == 'x' && (attributeChangeExtent >= 0 && attributeChangeExtent <= 2)) {
- // Select attribute change extent (DECSACE - http://www.vt100.net/docs/vt510-rm/DECSACE).
- setDecsetinternalBit(DECSET_BIT_RECTANGULAR_CHANGEATTRIBUTE, attributeChangeExtent == 2);
- } else {
- unknownSequence(b);
- }
- break;
- default:
- unknownSequence(b);
- break;
- }
- if (!mContinueSequence) mEscapeState = ESC_NONE;
- break;
- }
- }
+ case 'A': // "CSI${n}A" - Cursor up (CUU) ${n} rows.
+ setCursorRow(Math.max(mTopMargin, mCursorRow - getArg0(1)));
+ break;
+ case 'B': // "CSI${n}B" - Cursor down (CUD) ${n} rows.
+ setCursorRow(Math.min(mBottomMargin - 1, mCursorRow + getArg0(1)));
+ break;
+ case 'C': // "CSI${n}C" - Cursor forward (CUF).
+ case 'a': // "CSI${n}a" - Horizontal position relative (HPR). From ISO-6428/ECMA-48.
+ setCursorCol(Math.min(mRightMargin - 1, mCursorCol + getArg0(1)));
+ break;
+ case 'D': // "CSI${n}D" - Cursor backward (CUB) ${n} columns.
+ setCursorCol(Math.max(mLeftMargin, mCursorCol - getArg0(1)));
+ break;
+ case 'E': // "CSI{n}E - Cursor Next Line (CNL). From ISO-6428/ECMA-48.
+ setCursorPosition(0, mCursorRow + getArg0(1));
+ break;
+ case 'F': // "CSI{n}F - Cursor Previous Line (CPL). From ISO-6428/ECMA-48.
+ setCursorPosition(0, mCursorRow - getArg0(1));
+ break;
+ case 'G': // "CSI${n}G" - Cursor horizontal absolute (CHA) to column ${n}.
+ setCursorCol(Math.min(Math.max(1, getArg0(1)), mColumns) - 1);
+ break;
+ case 'H': // "${CSI}${ROW};${COLUMN}H" - Cursor position (CUP).
+ case 'f': // "${CSI}${ROW};${COLUMN}f" - Horizontal and Vertical Position (HVP).
+ setCursorPosition(getArg1(1) - 1, getArg0(1) - 1);
+ break;
+ case 'I': // Cursor Horizontal Forward Tabulation (CHT). Move the active position n tabs forward.
+ setCursorCol(nextTabStop(getArg0(1)));
+ break;
+ case 'J': // "${CSI}${0,1,2}J" - Erase in Display (ED)
+ // ED ignores the scrolling margins.
+ switch (getArg0(0)) {
+ case 0: // Erase from the active position to the end of the screen, inclusive (default).
+ blockClear(mCursorCol, mCursorRow, mColumns - mCursorCol);
+ blockClear(0, mCursorRow + 1, mColumns, mRows - (mCursorRow + 1));
+ break;
+ case 1: // Erase from start of the screen to the active position, inclusive.
+ blockClear(0, 0, mColumns, mCursorRow);
+ blockClear(0, mCursorRow, mCursorCol + 1);
+ break;
+ case 2: // Erase all of the display - all lines are erased, changed to single-width, and the cursor does not
+ // move..
+ blockClear(0, 0, mColumns, mRows);
+ break;
+ default:
+ unknownSequence(b);
+ return;
+ }
+ mAboutToAutoWrap = false;
+ break;
+ case 'K': // "CSI{n}K" - Erase in line (EL).
+ switch (getArg0(0)) {
+ case 0: // Erase from the cursor to the end of the line, inclusive (default)
+ blockClear(mCursorCol, mCursorRow, mColumns - mCursorCol);
+ break;
+ case 1: // Erase from the start of the screen to the cursor, inclusive.
+ blockClear(0, mCursorRow, mCursorCol + 1);
+ break;
+ case 2: // Erase all of the line.
+ blockClear(0, mCursorRow, mColumns);
+ break;
+ default:
+ unknownSequence(b);
+ return;
+ }
+ mAboutToAutoWrap = false;
+ break;
+ case 'L': // "${CSI}{N}L" - insert ${N} lines (IL).
+ {
+ int linesAfterCursor = mBottomMargin - mCursorRow;
+ int linesToInsert = Math.min(getArg0(1), linesAfterCursor);
+ int linesToMove = linesAfterCursor - linesToInsert;
+ mScreen.blockCopy(0, mCursorRow, mColumns, linesToMove, 0, mCursorRow + linesToInsert);
+ blockClear(0, mCursorRow, mColumns, linesToInsert);
+ }
+ break;
+ case 'M': // "${CSI}${N}M" - delete N lines (DL).
+ {
+ mAboutToAutoWrap = false;
+ int linesAfterCursor = mBottomMargin - mCursorRow;
+ int linesToDelete = Math.min(getArg0(1), linesAfterCursor);
+ int linesToMove = linesAfterCursor - linesToDelete;
+ mScreen.blockCopy(0, mCursorRow + linesToDelete, mColumns, linesToMove, 0, mCursorRow);
+ blockClear(0, mCursorRow + linesToMove, mColumns, linesToDelete);
+ }
+ break;
+ case 'P': // "${CSI}{N}P" - delete ${N} characters (DCH).
+ {
+ // http://www.vt100.net/docs/vt510-rm/DCH: "If ${N} is greater than the number of characters between the
+ // cursor and the right margin, then DCH only deletes the remaining characters.
+ // As characters are deleted, the remaining characters between the cursor and right margin move to the left.
+ // Character attributes move with the characters. The terminal adds blank spaces with no visual character
+ // attributes at the right margin. DCH has no effect outside the scrolling margins."
+ mAboutToAutoWrap = false;
+ int cellsAfterCursor = mColumns - mCursorCol;
+ int cellsToDelete = Math.min(getArg0(1), cellsAfterCursor);
+ int cellsToMove = cellsAfterCursor - cellsToDelete;
+ mScreen.blockCopy(mCursorCol + cellsToDelete, mCursorRow, cellsToMove, 1, mCursorCol, mCursorRow);
+ blockClear(mCursorCol + cellsToMove, mCursorRow, cellsToDelete);
+ }
+ break;
+ case 'S': { // "${CSI}${N}S" - scroll up ${N} lines (default = 1) (SU).
+ final int linesToScroll = getArg0(1);
+ for (int i = 0; i < linesToScroll; i++)
+ scrollDownOneLine();
+ break;
+ }
+ case 'T':
+ if (mArgIndex == 0) {
+ // "${CSI}${N}T" - Scroll down N lines (default = 1) (SD).
+ // http://vt100.net/docs/vt510-rm/SD: "N is the number of lines to move the user window up in page
+ // memory. N new lines appear at the top of the display. N old lines disappear at the bottom of the
+ // display. You cannot pan past the top margin of the current page".
+ final int linesToScrollArg = getArg0(1);
+ final int linesBetweenTopAndBottomMargins = mBottomMargin - mTopMargin;
+ final int linesToScroll = Math.min(linesBetweenTopAndBottomMargins, linesToScrollArg);
+ mScreen.blockCopy(0, mTopMargin, mColumns, linesBetweenTopAndBottomMargins - linesToScroll, 0, mTopMargin + linesToScroll);
+ blockClear(0, mTopMargin, mColumns, linesToScroll);
+ } else {
+ // "${CSI}${func};${startx};${starty};${firstrow};${lastrow}T" - initiate highlight mouse tracking.
+ unimplementedSequence(b);
+ }
+ break;
+ case 'X': // "${CSI}${N}X" - Erase ${N:=1} character(s) (ECH). FIXME: Clears character attributes?
+ mAboutToAutoWrap = false;
+ mScreen.blockSet(mCursorCol, mCursorRow, Math.min(getArg0(1), mColumns - mCursorCol), 1, ' ', getStyle());
+ break;
+ case 'Z': // Cursor Backward Tabulation (CBT). Move the active position n tabs backward.
+ int numberOfTabs = getArg0(1);
+ int newCol = mLeftMargin;
+ for (int i = mCursorCol - 1; i >= 0; i--)
+ if (mTabStop[i]) {
+ if (--numberOfTabs == 0) {
+ newCol = Math.max(i, mLeftMargin);
+ break;
+ }
+ }
+ mCursorCol = newCol;
+ break;
+ case '?': // Esc [ ? -- start of a private mode set
+ continueSequence(ESC_CSI_QUESTIONMARK);
+ break;
+ case '>': // "Esc [ >" --
+ continueSequence(ESC_CSI_BIGGERTHAN);
+ break;
+ case '`': // Horizontal position absolute (HPA - http://www.vt100.net/docs/vt510-rm/HPA).
+ setCursorColRespectingOriginMode(getArg0(1) - 1);
+ break;
+ case 'c': // Primary Device Attributes (http://www.vt100.net/docs/vt510-rm/DA1) if argument is missing or zero.
+ // The important part that may still be used by some (tmux stores this value but does not currently use it)
+ // is the first response parameter identifying the terminal service class, where we send 64 for "vt420".
+ // This is followed by a list of attributes which is probably unused by applications. Send like xterm.
+ if (getArg0(0) == 0) mSession.write("\033[?64;1;2;6;9;15;18;21;22c");
+ break;
+ case 'd': // ESC [ Pn d - Vert Position Absolute
+ setCursorRow(Math.min(Math.max(1, getArg0(1)), mRows) - 1);
+ break;
+ case 'e': // Vertical Position Relative (VPR). From ISO-6429 (ECMA-48).
+ setCursorPosition(mCursorCol, mCursorRow + getArg0(1));
+ break;
+ // case 'f': "${CSI}${ROW};${COLUMN}f" - Horizontal and Vertical Position (HVP). Grouped with case 'H'.
+ case 'g': // Clear tab stop
+ switch (getArg0(0)) {
+ case 0:
+ mTabStop[mCursorCol] = false;
+ break;
+ case 3:
+ for (int i = 0; i < mColumns; i++) {
+ mTabStop[i] = false;
+ }
+ break;
+ default:
+ // Specified to have no effect.
+ break;
+ }
+ break;
+ case 'h': // Set Mode
+ doSetMode(true);
+ break;
+ case 'l': // Reset Mode
+ doSetMode(false);
+ break;
+ case 'm': // Esc [ Pn m - character attributes. (can have up to 16 numerical arguments)
+ selectGraphicRendition();
+ break;
+ case 'n': // Esc [ Pn n - ECMA-48 Status Report Commands
+ // sendDeviceAttributes()
+ switch (getArg0(0)) {
+ case 5: // Device status report (DSR):
+ // Answer is ESC [ 0 n (Terminal OK).
+ byte[] dsr = {(byte) 27, (byte) '[', (byte) '0', (byte) 'n'};
+ mSession.write(dsr, 0, dsr.length);
+ break;
+ case 6: // Cursor position report (CPR):
+ // Answer is ESC [ y ; x R, where x,y is
+ // the cursor location.
+ mSession.write(String.format(Locale.US, "\033[%d;%dR", mCursorRow + 1, mCursorCol + 1));
+ break;
+ default:
+ break;
+ }
+ break;
+ case 'r': // "CSI${top};${bottom}r" - set top and bottom Margins (DECSTBM).
+ {
+ // http://www.vt100.net/docs/vt510-rm/DECSTBM
+ // The top margin defaults to 1, the bottom margin defaults to mRows.
+ // The escape sequence numbers top 1..23, but we number top 0..22.
+ // The escape sequence numbers bottom 2..24, and so do we (because we use a zero based numbering
+ // scheme, but we store the first line below the bottom-most scrolling line.
+ // As a result, we adjust the top line by -1, but we leave the bottom line alone.
+ // Also require that top + 2 <= bottom.
+ mTopMargin = Math.max(0, Math.min(getArg0(1) - 1, mRows - 2));
+ mBottomMargin = Math.max(mTopMargin + 2, Math.min(getArg1(mRows), mRows));
+ // DECSTBM moves the cursor to column 1, line 1 of the page respecting origin mode.
+ setCursorPosition(0, 0);
+ }
+ break;
+ case 's':
+ if (isDecsetInternalBitSet(DECSET_BIT_LEFTRIGHT_MARGIN_MODE)) {
+ // Set left and right margins (DECSLRM - http://www.vt100.net/docs/vt510-rm/DECSLRM).
+ mLeftMargin = Math.min(getArg0(1) - 1, mColumns - 2);
+ mRightMargin = Math.max(mLeftMargin + 1, Math.min(getArg1(mColumns), mColumns));
+ // DECSLRM moves the cursor to column 1, line 1 of the page.
+ setCursorPosition(0, 0);
+ } else {
+ // Save cursor (ANSI.SYS), available only when DECLRMM is disabled.
+ saveCursor();
+ }
+ break;
+ case 't': // Window manipulation (from dtterm, as well as extensions)
+ switch (getArg0(0)) {
+ case 11: // Report xterm window state. If the xterm window is open (non-iconified), it returns CSI 1 t .
+ mSession.write("\033[1t");
+ break;
+ case 13: // Report xterm window position. Result is CSI 3 ; x ; y t
+ mSession.write("\033[3;0;0t");
+ break;
+ case 14: // Report xterm window in pixels. Result is CSI 4 ; height ; width t
+ // We just report characters time 12 here.
+ mSession.write(String.format(Locale.US, "\033[4;%d;%dt", mRows * 12, mColumns * 12));
+ break;
+ case 18: // Report the size of the text area in characters. Result is CSI 8 ; height ; width t
+ mSession.write(String.format(Locale.US, "\033[8;%d;%dt", mRows, mColumns));
+ break;
+ case 19: // Report the size of the screen in characters. Result is CSI 9 ; height ; width t
+ // We report the same size as the view, since it's the view really isn't resizable from the shell.
+ mSession.write(String.format(Locale.US, "\033[9;%d;%dt", mRows, mColumns));
+ break;
+ case 20: // Report xterm windows icon label. Result is OSC L label ST. Disabled due to security concerns:
+ mSession.write("\033]LIconLabel\033\\");
+ break;
+ case 21: // Report xterm windows title. Result is OSC l label ST. Disabled due to security concerns:
+ mSession.write("\033]l\033\\");
+ break;
+ case 22:
+ // 22;0 -> Save xterm icon and window title on stack.
+ // 22;1 -> Save xterm icon title on stack.
+ // 22;2 -> Save xterm window title on stack.
+ mTitleStack.push(mTitle);
+ if (mTitleStack.size() > 20) {
+ // Limit size
+ mTitleStack.remove(0);
+ }
+ break;
+ case 23: // Like 22 above but restore from stack.
+ if (!mTitleStack.isEmpty()) setTitle(mTitleStack.pop());
+ break;
+ default:
+ // Ignore window manipulation.
+ break;
+ }
+ break;
+ case 'u': // Restore cursor (ANSI.SYS).
+ restoreCursor();
+ break;
+ case ' ':
+ continueSequence(ESC_CSI_ARGS_SPACE);
+ break;
+ default:
+ parseArg(b);
+ break;
+ }
+ }
- /** When in {@link #ESC_P} ("device control") sequence. */
- private void doDeviceControl(int b) {
- switch (b) {
- case (byte) '\\': // End of ESC \ string Terminator
- {
- String dcs = mOSCOrDeviceControlArgs.toString();
- // DCS $ q P t ST. Request Status String (DECRQSS)
- if (dcs.startsWith("$q")) {
- if (dcs.equals("$q\"p")) {
- // DECSCL, conformance level, http://www.vt100.net/docs/vt510-rm/DECSCL:
- String csiString = "64;1\"p";
- mSession.write("\033P1$r" + csiString + "\033\\");
- } else {
- finishSequenceAndLogError("Unrecognized DECRQSS string: '" + dcs + "'");
- }
- } else if (dcs.startsWith("+q")) {
- // Request Termcap/Terminfo String. The string following the "q" is a list of names encoded in
- // hexadecimal (2 digits per character) separated by ; which correspond to termcap or terminfo key
- // names.
- // Two special features are also recognized, which are not key names: Co for termcap colors (or colors
- // for terminfo colors), and TN for termcap name (or name for terminfo name).
- // xterm responds with DCS 1 + r P t ST for valid requests, adding to P t an = , and the value of the
- // corresponding string that xterm would send, or DCS 0 + r P t ST for invalid requests. The strings are
- // encoded in hexadecimal (2 digits per character).
- // Example:
- // :kr=\EOC: ks=\E[?1h\E=: ku=\EOA: le=^H:mb=\E[5m:md=\E[1m:\
- // where
- // kd=down-arrow key
- // kl=left-arrow key
- // kr=right-arrow key
- // ku=up-arrow key
- // #2=key_shome, "shifted home"
- // #4=key_sleft, "shift arrow left"
- // %i=key_sright, "shift arrow right"
- // *7=key_send, "shifted end"
- // k1=F1 function key
+ /** Select Graphic Rendition (SGR) - see http://en.wikipedia.org/wiki/ANSI_escape_code#graphics. */
+ private void selectGraphicRendition() {
+ for (int i = 0; i <= mArgIndex; i++) {
+ int code = mArgs[i];
+ if (code < 0) {
+ if (mArgIndex > 0) {
+ continue;
+ } else {
+ code = 0;
+ }
+ }
+ if (code == 0) { // reset
+ mForeColor = TextStyle.COLOR_INDEX_FOREGROUND;
+ mBackColor = TextStyle.COLOR_INDEX_BACKGROUND;
+ mEffect = 0;
+ } else if (code == 1) {
+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_BOLD;
+ } else if (code == 2) {
+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_DIM;
+ } else if (code == 3) {
+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_ITALIC;
+ } else if (code == 4) {
+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE;
+ } else if (code == 5) {
+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_BLINK;
+ } else if (code == 7) {
+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_INVERSE;
+ } else if (code == 8) {
+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_INVISIBLE;
+ } else if (code == 9) {
+ mEffect |= TextStyle.CHARACTER_ATTRIBUTE_STRIKETHROUGH;
+ } else if (code == 10) {
+ // Exit alt charset (TERM=linux) - ignore.
+ } else if (code == 11) {
+ // Enter alt charset (TERM=linux) - ignore.
+ } else if (code == 22) { // Normal color or intensity, neither bright, bold nor faint.
+ mEffect &= ~(TextStyle.CHARACTER_ATTRIBUTE_BOLD | TextStyle.CHARACTER_ATTRIBUTE_DIM);
+ } else if (code == 23) { // not italic, but rarely used as such; clears standout with TERM=screen
+ mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_ITALIC;
+ } else if (code == 24) { // underline: none
+ mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE;
+ } else if (code == 25) { // blink: none
+ mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_BLINK;
+ } else if (code == 27) { // image: positive
+ mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_INVERSE;
+ } else if (code == 28) {
+ mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_INVISIBLE;
+ } else if (code == 29) {
+ mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_STRIKETHROUGH;
+ } else if (code >= 30 && code <= 37) {
+ mForeColor = code - 30;
+ } else if (code == 38 || code == 48) {
+ // ISO-8613-3 controls to set foreground (38) or background (48) colors.
+ // P_s = (38|48) ; 2 ; P_r ; P_g ; P_b => Set to RGB value in range (0-255).
+ // P_s = (38|48) ; 5 ; P_s => Set to indexed color.
+ if (i + 2 <= mArgIndex) {
+ int color = -1;
+ int firstArg = mArgs[i + 1];
+ if (firstArg == 2) {
+ if (i + 4 > mArgIndex) {
+ Log.w(EmulatorDebug.LOG_TAG, "Too few CSI" + code + ";2 RGB arguments");
+ } else {
+ int red = mArgs[i + 2], green = mArgs[i + 3], blue = mArgs[i + 4];
+ if (red < 0 || green < 0 || blue < 0 || red > 255 || green > 255 || blue > 255) {
+ finishSequenceAndLogError("Invalid RGB: " + red + "," + green + "," + blue);
+ } else {
+ // TODO: Implement 24 bit color.
+ finishSequenceAndLogError("Unimplemented RGB: " + red + "," + green + "," + blue);
+ }
+ i += 4; // "2;P_r;P_g;P_r"
+ }
+ } else if (firstArg == 5) {
+ color = mArgs[i + 2];
+ i += 2; // "5;P_s"
+ } else {
+ finishSequenceAndLogError("Invalid ISO-8613-3 SGR first argument: " + firstArg);
+ }
+ if (i != -1) {
+ if (color >= 0 && color < TextStyle.NUM_INDEXED_COLORS) {
+ if (code == 38) {
+ mForeColor = color;
+ } else {
+ mBackColor = color;
+ }
+ } else {
+ if (LOG_ESCAPE_SEQUENCES)
+ Log.w(EmulatorDebug.LOG_TAG, "Invalid color index: " + color);
+ }
+ }
+ }
+ } else if (code == 39) { // Set default foreground color.
+ mForeColor = TextStyle.COLOR_INDEX_FOREGROUND;
+ } else if (code >= 40 && code <= 47) { // Set background color.
+ mBackColor = code - 40;
+ } else if (code == 49) { // Set default background color.
+ mBackColor = TextStyle.COLOR_INDEX_BACKGROUND;
+ } else if (code >= 90 && code <= 97) { // Bright foreground colors (aixterm codes).
+ mForeColor = code - 90 + 8;
+ } else if (code >= 100 && code <= 107) { // Bright background color (aixterm codes).
+ mBackColor = code - 100 + 8;
+ } else {
+ if (LOG_ESCAPE_SEQUENCES)
+ Log.w(EmulatorDebug.LOG_TAG, String.format("SGR unknown code %d", code));
+ }
+ }
+ }
- // Example: Request for ku is "ESC P + q 6 b 7 5 ESC \", where 6b7d=ku in hexadecimal.
- // Xterm response in normal cursor mode:
- // "<27> P 1 + r 6 b 7 5 = 1 B 5 B 4 1" where 0x1B 0x5B 0x41 = 27 91 65 = ESC [ A
- // Xterm response in application cursor mode:
- // "<27> P 1 + r 6 b 7 5 = 1 B 5 B 4 1" where 0x1B 0x4F 0x41 = 27 91 65 = ESC 0 A
+ private void doOsc(int b) {
+ switch (b) {
+ case 7: // Bell.
+ doOscSetTextParameters("\007");
+ break;
+ case 27: // Escape.
+ continueSequence(ESC_OSC_ESC);
+ break;
+ default:
+ collectOSCArgs(b);
+ break;
+ }
+ }
- // #4 is "shift arrow left":
- // *** Device Control (DCS) for '#4'- 'ESC P + q 23 34 ESC \'
- // Response: <27> P 1 + r 2 3 3 4 = 1 B 5 B 3 1 3 B 3 2 4 4 <27> \
- // where 0x1B 0x5B 0x31 0x3B 0x32 0x44 = ESC [ 1 ; 2 D
- // which we find in: TermKeyListener.java: KEY_MAP.put(KEYMOD_SHIFT | KEYCODE_DPAD_LEFT, "\033[1;2D");
+ private void doOscEsc(int b) {
+ switch (b) {
+ case '\\':
+ doOscSetTextParameters("\033\\");
+ break;
+ default:
+ // The ESC character was not followed by a \, so insert the ESC and
+ // the current character in arg buffer.
+ collectOSCArgs(27);
+ collectOSCArgs(b);
+ continueSequence(ESC_OSC);
+ break;
+ }
+ }
- // See http://h30097.www3.hp.com/docs/base_doc/DOCUMENTATION/V40G_HTML/MAN/MAN4/0178____.HTM for what to
- // respond, as well as http://www.freebsd.org/cgi/man.cgi?query=termcap&sektion=5#CAPABILITIES for
- // the meaning of e.g. "ku", "kd", "kr", "kl"
+ /** An Operating System Controls (OSC) Set Text Parameters. May come here from BEL or ST. */
+ private void doOscSetTextParameters(String bellOrStringTerminator) {
+ int value = -1;
+ String textParameter = "";
+ // Extract initial $value from initial "$value;..." string.
+ for (int mOSCArgTokenizerIndex = 0; mOSCArgTokenizerIndex < mOSCOrDeviceControlArgs.length(); mOSCArgTokenizerIndex++) {
+ char b = mOSCOrDeviceControlArgs.charAt(mOSCArgTokenizerIndex);
+ if (b == ';') {
+ textParameter = mOSCOrDeviceControlArgs.substring(mOSCArgTokenizerIndex + 1);
+ break;
+ } else if (b >= '0' && b <= '9') {
+ value = ((value < 0) ? 0 : value * 10) + (b - '0');
+ } else {
+ unknownSequence(b);
+ return;
+ }
+ }
- for (String part : dcs.substring(2).split(";")) {
- if (part.length() % 2 == 0) {
- StringBuilder transBuffer = new StringBuilder();
- for (int i = 0; i < part.length(); i += 2) {
- char c = (char) Long.decode("0x" + part.charAt(i) + "" + part.charAt(i + 1)).longValue();
- transBuffer.append(c);
- }
- String trans = transBuffer.toString();
- String responseValue;
- switch (trans) {
- case "Co":
- case "colors":
- responseValue = "256"; // Number of colors.
- break;
- case "TN":
- case "name":
- responseValue = "xterm";
- break;
- default:
- responseValue = KeyHandler.getCodeFromTermcap(trans, isDecsetInternalBitSet(DECSET_BIT_APPLICATION_CURSOR_KEYS),
- isDecsetInternalBitSet(DECSET_BIT_APPLICATION_KEYPAD));
- break;
- }
- if (responseValue == null) {
- switch (trans) {
- case "%1": // Help key - ignore
- case "&8": // Undo key - ignore.
- break;
- default:
- Log.w(EmulatorDebug.LOG_TAG, "Unhandled termcap/terminfo name: '" + trans + "'");
- }
- // Respond with invalid request:
- mSession.write("\033P0+r" + part + "\033\\");
- } else {
- StringBuilder hexEncoded = new StringBuilder();
- for (int j = 0; j < responseValue.length(); j++) {
- hexEncoded.append(String.format("%02X", (int) responseValue.charAt(j)));
- }
- mSession.write("\033P1+r" + part + "=" + hexEncoded + "\033\\");
- }
- } else {
- Log.e(EmulatorDebug.LOG_TAG, "Invalid device termcap/terminfo name of odd length: " + part);
- }
- }
- } else {
- if (LOG_ESCAPE_SEQUENCES) Log.e(EmulatorDebug.LOG_TAG, "Unrecognized device control string: " + dcs);
- }
- finishSequence();
- }
- break;
- default:
- if (mOSCOrDeviceControlArgs.length() > MAX_OSC_STRING_LENGTH) {
- // Too long.
- mOSCOrDeviceControlArgs.setLength(0);
- finishSequence();
- } else {
- mOSCOrDeviceControlArgs.appendCodePoint(b);
- continueSequence(mEscapeState);
- }
- }
- }
-
- private int nextTabStop(int numTabs) {
- for (int i = mCursorCol + 1; i < mColumns; i++)
- if (mTabStop[i] && --numTabs == 0) return Math.min(i, mRightMargin);
- return mRightMargin - 1;
- }
-
- /** Process byte while in the {@link #ESC_CSI_QUESTIONMARK} escape state. */
- private void doCsiQuestionMark(int b) {
- switch (b) {
- case 'J': // Selective erase in display (DECSED) - http://www.vt100.net/docs/vt510-rm/DECSED.
- case 'K': // Selective erase in line (DECSEL) - http://vt100.net/docs/vt510-rm/DECSEL.
- mAboutToAutoWrap = false;
- int fillChar = ' ';
- int startCol = -1;
- int startRow = -1;
- int endCol = -1;
- int endRow = -1;
- boolean justRow = (b == 'K');
- switch (getArg0(0)) {
- case 0: // Erase from the active position to the end, inclusive (default).
- startCol = mCursorCol;
- startRow = mCursorRow;
- endCol = mColumns;
- endRow = justRow ? (mCursorRow + 1) : mRows;
- break;
- case 1: // Erase from start to the active position, inclusive.
- startCol = 0;
- startRow = justRow ? mCursorRow : 0;
- endCol = mCursorCol + 1;
- endRow = mCursorRow + 1;
- break;
- case 2: // Erase all of the display/line.
- startCol = 0;
- startRow = justRow ? mCursorRow : 0;
- endCol = mColumns;
- endRow = justRow ? (mCursorRow + 1) : mRows;
- break;
- default:
- unknownSequence(b);
- break;
- }
- int style = getStyle();
- for (int row = startRow; row < endRow; row++) {
- for (int col = startCol; col < endCol; col++) {
- if ((TextStyle.decodeEffect(mScreen.getStyleAt(row, col)) & TextStyle.CHARACTER_ATTRIBUTE_PROTECTED) == 0)
- mScreen.setChar(col, row, fillChar, style);
- }
- }
- break;
- case 'h':
- case 'l':
- for (int i = 0; i <= mArgIndex; i++)
- doDecSetOrReset(b == 'h', mArgs[i]);
- break;
- case 'n': // Device Status Report (DSR, DEC-specific).
- switch (getArg0(-1)) {
- case 6:
- // Extended Cursor Position (DECXCPR - http://www.vt100.net/docs/vt510-rm/DECXCPR). Page=1.
- mSession.write(String.format(Locale.US, "\033[?%d;%d;1R", mCursorRow + 1, mCursorCol + 1));
- break;
- default:
- finishSequence();
- return;
- }
- break;
- case 'r':
- case 's':
- for (int i = 0; i <= mArgIndex; i++) {
- int externalBit = mArgs[i];
- int internalBit = mapDecSetBitToInternalBit(externalBit);
- if (internalBit == -1) {
- Log.w(EmulatorDebug.LOG_TAG, "Ignoring request to save/recall decset bit=" + externalBit);
- } else {
- if (b == 's') {
- mSavedDecSetFlags |= internalBit;
- } else {
- doDecSetOrReset((mSavedDecSetFlags & internalBit) != 0, externalBit);
- }
- }
- }
- break;
- case '$':
- continueSequence(ESC_CSI_QUESTIONMARK_ARG_DOLLAR);
- return;
- default:
- parseArg(b);
- }
- }
-
- public void doDecSetOrReset(boolean setting, int externalBit) {
- int internalBit = mapDecSetBitToInternalBit(externalBit);
- if (internalBit != -1) {
- setDecsetinternalBit(internalBit, setting);
- }
- switch (externalBit) {
- case 1: // Application Cursor Keys (DECCKM).
- break;
- case 3: // Set: 132 column mode (. Reset: 80 column mode. ANSI name: DECCOLM.
- // We don't actually set/reset 132 cols, but we do want the side effects
- // (FIXME: Should only do this if the 95 DECSET bit (DECNCSM) is set, and if changing value?):
- // Sets the left, right, top and bottom scrolling margins to their default positions, which is important for
- // the "reset" utility to really reset the terminal:
- mLeftMargin = mTopMargin = 0;
- mBottomMargin = mRows;
- mRightMargin = mColumns;
- // "DECCOLM resets vertical split screen mode (DECLRMM) to unavailable":
- setDecsetinternalBit(DECSET_BIT_LEFTRIGHT_MARGIN_MODE, false);
- // "Erases all data in page memory":
- blockClear(0, 0, mColumns, mRows);
- setCursorRowCol(0, 0);
- break;
- case 4: // DECSCLM-Scrolling Mode. Ignore.
- break;
- case 5: // Reverse video. No action.
- break;
- case 6: // Set: Origin Mode. Reset: Normal Cursor Mode. Ansi name: DECOM.
- if (setting) setCursorPosition(0, 0);
- break;
- case 7: // Wrap-around bit, not specific action.
- case 8: // Auto-repeat Keys (DECARM). Do not implement.
- case 9: // X10 mouse reporting - outdated. Do not implement.
- case 12: // Control cursor blinking - ignore.
- case 25: // Hide/show cursor - no action needed, renderer will check with isShowingCursor().
- case 40: // Allow 80 => 132 Mode, ignore.
- case 45: // TODO: Reverse wrap-around. Implement???
- case 66: // Application keypad (DECNKM).
- break;
- case 69: // Left and right margin mode (DECLRMM).
- if (!setting) {
- mLeftMargin = 0;
- mRightMargin = mColumns;
- }
- break;
- case 1000:
- case 1001:
- case 1002:
- case 1003:
- case 1004:
- case 1005: // UTF-8 mouse mode, ignore.
- case 1006: // SGR Mouse Mode
- case 1015:
- case 1034: // Interpret "meta" key, sets eighth bit.
- break;
- case 1048: // Set: Save cursor as in DECSC. Reset: Restore cursor as in DECRC.
- if (setting)
- saveCursor();
- else
- restoreCursor();
- break;
- case 47:
- case 1047:
- case 1049: {
- // Set: Save cursor as in DECSC and use Alternate Screen Buffer, clearing it first.
- // Reset: Use Normal Screen Buffer and restore cursor as in DECRC.
- TerminalBuffer newScreen = setting ? mAltBuffer : mMainBuffer;
- if (newScreen != mScreen) {
- boolean resized = !(newScreen.mColumns == mColumns && newScreen.mScreenRows == mRows);
- if (setting) saveCursor();
- mScreen = newScreen;
- if (!setting) {
- int col = mSavedStateMain.mSavedCursorCol;
- int row = mSavedStateMain.mSavedCursorRow;
- restoreCursor();
- if (resized) {
- // Restore cursor position _not_ clipped to current screen (let resizeScreen() handle that):
- mCursorCol = col;
- mCursorRow = row;
- }
- }
- // Check if buffer size needs to be updated:
- if (resized) resizeScreen();
- // Clear new screen if alt buffer:
- if (newScreen == mAltBuffer) newScreen.blockSet(0, 0, mColumns, mRows, ' ', getStyle());
- }
- break;
- }
- case 2004:
- // Bracketed paste mode - setting bit is enough.
- break;
- default:
- unknownParameter(externalBit);
- break;
- }
- }
-
- private void doCsiBiggerThan(int b) {
- switch (b) {
- case 'c': // "${CSI}>c" or "${CSI}>c". Secondary Device Attributes (DA2).
- // Originally this was used for the terminal to respond with "identification code, firmware version level,
- // and hardware options" (http://vt100.net/docs/vt510-rm/DA2), with the first "41" meaning the VT420
- // terminal type. This is not used anymore, but the second version level field has been changed by xterm
- // to mean it's release number ("patch numbers" listed at http://invisible-island.net/xterm/xterm.log.html),
- // and some applications use it as a feature check:
- // * tmux used to have a "xterm won't reach version 500 for a while so set that as the upper limit" check,
- // and then check "xterm_version > 270" if rectangular area operations such as DECCRA could be used.
- // * vim checks xterm version number >140 for "Request termcap/terminfo string" functionality >276 for SGR
- // mouse report.
- // The third number is a keyboard identifier not used nowadays.
- mSession.write("\033[>41;320;0c");
- break;
- case 'm':
- // https://bugs.launchpad.net/gnome-terminal/+bug/96676/comments/25
- // Depending on the first number parameter, this can set one of the xterm resources
- // modifyKeyboard, modifyCursorKeys, modifyFunctionKeys and modifyOtherKeys.
- // http://invisible-island.net/xterm/manpage/xterm.html#RESOURCES
-
- // * modifyKeyboard (parameter=1):
- // Normally xterm makes a special case regarding modifiers (shift, control, etc.) to handle special keyboard
- // layouts (legacy and vt220). This is done to provide compatible keyboards for DEC VT220 and related
- // terminals that implement user-defined keys (UDK).
- // The bits of the resource value selectively enable modification of the given category when these keyboards
- // are selected. The default is "0":
- // (0) The legacy/vt220 keyboards interpret only the Control-modifier when constructing numbered
- // function-keys. Other special keys are not modified.
- // (1) allows modification of the numeric keypad
- // (2) allows modification of the editing keypad
- // (4) allows modification of function-keys, overrides use of Shift-modifier for UDK.
- // (8) allows modification of other special keys
-
- // * modifyCursorKeys (parameter=2):
- // Tells how to handle the special case where Control-, Shift-, Alt- or Meta-modifiers are used to add a
- // parameter to the escape sequence returned by a cursor-key. The default is "2".
- // - Set it to -1 to disable it.
- // - Set it to 0 to use the old/obsolete behavior.
- // - Set it to 1 to prefix modified sequences with CSI.
- // - Set it to 2 to force the modifier to be the second parameter if it would otherwise be the first.
- // - Set it to 3 to mark the sequence with a ">" to hint that it is private.
-
- // * modifyFunctionKeys (parameter=3):
- // Tells how to handle the special case where Control-, Shift-, Alt- or Meta-modifiers are used to add a
- // parameter to the escape sequence returned by a (numbered) function-
- // key. The default is "2". The resource values are similar to modifyCursorKeys:
- // Set it to -1 to permit the user to use shift- and control-modifiers to construct function-key strings
- // using the normal encoding scheme.
- // - Set it to 0 to use the old/obsolete behavior.
- // - Set it to 1 to prefix modified sequences with CSI.
- // - Set it to 2 to force the modifier to be the second parameter if it would otherwise be the first.
- // - Set it to 3 to mark the sequence with a ">" to hint that it is private.
- // If modifyFunctionKeys is zero, xterm uses Control- and Shift-modifiers to allow the user to construct
- // numbered function-keys beyond the set provided by the keyboard:
- // (Control) adds the value given by the ctrlFKeys resource.
- // (Shift) adds twice the value given by the ctrlFKeys resource.
- // (Control/Shift) adds three times the value given by the ctrlFKeys resource.
- //
- // As a special case, legacy (when oldFunctionKeys is true) or vt220 (when sunKeyboard is true)
- // keyboards interpret only the Control-modifier when constructing numbered function-keys.
- // This is done to provide compatible keyboards for DEC VT220 and related terminals that
- // implement user-defined keys (UDK).
-
- // * modifyOtherKeys (parameter=4):
- // Like modifyCursorKeys, tells xterm to construct an escape sequence for other keys (such as "2") when
- // modified by Control-, Alt- or Meta-modifiers. This feature does not apply to function keys and
- // well-defined keys such as ESC or the control keys. The default is "0".
- // (0) disables this feature.
- // (1) enables this feature for keys except for those with well-known behavior, e.g., Tab, Backarrow and
- // some special control character cases, e.g., Control-Space to make a NUL.
- // (2) enables this feature for keys including the exceptions listed.
- Log.e(EmulatorDebug.LOG_TAG, "(ignored) CSI > MODIFY RESOURCE: " + getArg0(-1) + " to " + getArg1(-1));
- break;
- default:
- parseArg(b);
- break;
- }
- }
-
- private void startEscapeSequence() {
- mEscapeState = ESC;
- mArgIndex = 0;
- Arrays.fill(mArgs, -1);
- }
-
- private void doLinefeed() {
- int newCursorRow = mCursorRow + 1;
- if (newCursorRow >= mBottomMargin) {
- scrollDownOneLine();
- newCursorRow = mBottomMargin - 1;
- }
- setCursorRow(newCursorRow);
- }
-
- private void continueSequence(int state) {
- mEscapeState = state;
- mContinueSequence = true;
- }
-
- private void doEscPound(int b) {
- switch (b) {
- case '8': // Esc # 8 - DEC screen alignment test - fill screen with E's.
- mScreen.blockSet(0, 0, mColumns, mRows, 'E', getStyle());
- break;
- default:
- unknownSequence(b);
- break;
- }
- }
-
- /** Encountering a character in the {@link #ESC} state. */
- private void doEsc(int b) {
- switch (b) {
- case '#':
- continueSequence(ESC_POUND);
- break;
- case '(':
- continueSequence(ESC_SELECT_LEFT_PAREN);
- break;
- case ')':
- continueSequence(ESC_SELECT_RIGHT_PAREN);
- break;
- case '6': // Back index (http://www.vt100.net/docs/vt510-rm/DECBI). Move left, insert blank column if start.
- if (mCursorCol > mLeftMargin) {
- mCursorCol--;
- } else {
- int rows = mBottomMargin - mTopMargin;
- mScreen.blockCopy(mLeftMargin, mTopMargin, mRightMargin - mLeftMargin - 1, rows, mLeftMargin + 1, mTopMargin);
- mScreen.blockSet(mLeftMargin, mTopMargin, 1, rows, ' ', TextStyle.encode(mForeColor, mBackColor, 0));
- }
- break;
- case '7': // DECSC save cursor - http://www.vt100.net/docs/vt510-rm/DECSC
- saveCursor();
- break;
- case '8': // DECRC restore cursor - http://www.vt100.net/docs/vt510-rm/DECRC
- restoreCursor();
- break;
- case '9': // Forward Index (http://www.vt100.net/docs/vt510-rm/DECFI). Move right, insert blank column if end.
- if (mCursorCol < mRightMargin - 1) {
- mCursorCol++;
- } else {
- int rows = mBottomMargin - mTopMargin;
- mScreen.blockCopy(mLeftMargin + 1, mTopMargin, mRightMargin - mLeftMargin - 1, rows, mLeftMargin, mTopMargin);
- mScreen.blockSet(mRightMargin - 1, mTopMargin, 1, rows, ' ', TextStyle.encode(mForeColor, mBackColor, 0));
- }
- break;
- case 'c': // RIS - Reset to Initial State (http://vt100.net/docs/vt510-rm/RIS).
- reset();
- blockClear(0, 0, mColumns, mRows);
- setCursorPosition(0, 0);
- break;
- case 'D': // INDEX
- doLinefeed();
- break;
- case 'E': // Next line (http://www.vt100.net/docs/vt510-rm/NEL).
- setCursorCol(isDecsetInternalBitSet(DECSET_BIT_ORIGIN_MODE) ? mLeftMargin : 0);
- doLinefeed();
- break;
- case 'F': // Cursor to lower-left corner of screen
- setCursorRowCol(0, mBottomMargin - 1);
- break;
- case 'H': // Tab set
- mTabStop[mCursorCol] = true;
- break;
- case 'M': // "${ESC}M" - reverse index (RI).
- // http://www.vt100.net/docs/vt100-ug/chapter3.html: "Move the active position to the same horizontal
- // position on the preceding line. If the active position is at the top margin, a scroll down is performed".
- if (mCursorRow <= mTopMargin) {
- mScreen.blockCopy(0, mTopMargin, mColumns, mBottomMargin - (mTopMargin + 1), 0, mTopMargin + 1);
- blockClear(0, mTopMargin, mColumns);
- } else {
- mCursorRow--;
- }
- break;
- case 'N': // SS2, ignore.
- case '0': // SS3, ignore.
- break;
- case 'P': // Device control string
- mOSCOrDeviceControlArgs.setLength(0);
- continueSequence(ESC_P);
- break;
- case '[':
- continueSequence(ESC_CSI);
- break;
- case '=': // DECKPAM
- setDecsetinternalBit(DECSET_BIT_APPLICATION_KEYPAD, true);
- break;
- case ']': // OSC
- mOSCOrDeviceControlArgs.setLength(0);
- continueSequence(ESC_OSC);
- break;
- case '>': // DECKPNM
- setDecsetinternalBit(DECSET_BIT_APPLICATION_KEYPAD, false);
- break;
- default:
- unknownSequence(b);
- break;
- }
- }
-
- /** DECSC save cursor - http://www.vt100.net/docs/vt510-rm/DECSC . See {@link #restoreCursor()}. */
- private void saveCursor() {
- SavedScreenState state = (mScreen == mMainBuffer) ? mSavedStateMain : mSavedStateAlt;
- state.mSavedCursorRow = mCursorRow;
- state.mSavedCursorCol = mCursorCol;
- state.mSavedEffect = mEffect;
- state.mSavedDecFlags = mCurrentDecSetFlags;
- state.mUseLineDrawingG0 = mUseLineDrawingG0;
- state.mUseLineDrawingG1 = mUseLineDrawingG1;
- state.mUseLineDrawingUsesG0 = mUseLineDrawingUsesG0;
- }
-
- /** DECRS restore cursor - http://www.vt100.net/docs/vt510-rm/DECRC. See {@link #saveCursor()}. */
- private void restoreCursor() {
- SavedScreenState state = (mScreen == mMainBuffer) ? mSavedStateMain : mSavedStateAlt;
- setCursorRowCol(state.mSavedCursorRow, state.mSavedCursorCol);
- mEffect = state.mSavedEffect;
- int mask = (DECSET_BIT_AUTOWRAP | DECSET_BIT_ORIGIN_MODE);
- mCurrentDecSetFlags = (mCurrentDecSetFlags & ~mask) | (state.mSavedDecFlags & mask);
- mUseLineDrawingG0 = state.mUseLineDrawingG0;
- mUseLineDrawingG1 = state.mUseLineDrawingG1;
- mUseLineDrawingUsesG0 = state.mUseLineDrawingUsesG0;
- }
-
- /** Following a CSI - Control Sequence Introducer, "\033[". {@link #ESC_CSI}. */
- private void doCsi(int b) {
- switch (b) {
- case '!':
- continueSequence(ESC_CSI_EXCLAMATION);
- break;
- case '"':
- continueSequence(ESC_CSI_DOUBLE_QUOTE);
- break;
- case '\'':
- continueSequence(ESC_CSI_SINGLE_QUOTE);
- break;
- case '$':
- continueSequence(ESC_CSI_DOLLAR);
- break;
- case '*':
- continueSequence(ESC_CSI_ARGS_ASTERIX);
- break;
- case '@': {
- // "CSI{n}@" - Insert ${n} space characters (ICH) - http://www.vt100.net/docs/vt510-rm/ICH.
- mAboutToAutoWrap = false;
- int columnsAfterCursor = mColumns - mCursorCol;
- int spacesToInsert = Math.min(getArg0(1), columnsAfterCursor);
- int charsToMove = columnsAfterCursor - spacesToInsert;
- mScreen.blockCopy(mCursorCol, mCursorRow, charsToMove, 1, mCursorCol + spacesToInsert, mCursorRow);
- blockClear(mCursorCol, mCursorRow, spacesToInsert);
- }
- break;
- case 'A': // "CSI${n}A" - Cursor up (CUU) ${n} rows.
- setCursorRow(Math.max(mTopMargin, mCursorRow - getArg0(1)));
- break;
- case 'B': // "CSI${n}B" - Cursor down (CUD) ${n} rows.
- setCursorRow(Math.min(mBottomMargin - 1, mCursorRow + getArg0(1)));
- break;
- case 'C': // "CSI${n}C" - Cursor forward (CUF).
- case 'a': // "CSI${n}a" - Horizontal position relative (HPR). From ISO-6428/ECMA-48.
- setCursorCol(Math.min(mRightMargin - 1, mCursorCol + getArg0(1)));
- break;
- case 'D': // "CSI${n}D" - Cursor backward (CUB) ${n} columns.
- setCursorCol(Math.max(mLeftMargin, mCursorCol - getArg0(1)));
- break;
- case 'E': // "CSI{n}E - Cursor Next Line (CNL). From ISO-6428/ECMA-48.
- setCursorPosition(0, mCursorRow + getArg0(1));
- break;
- case 'F': // "CSI{n}F - Cursor Previous Line (CPL). From ISO-6428/ECMA-48.
- setCursorPosition(0, mCursorRow - getArg0(1));
- break;
- case 'G': // "CSI${n}G" - Cursor horizontal absolute (CHA) to column ${n}.
- setCursorCol(Math.min(Math.max(1, getArg0(1)), mColumns) - 1);
- break;
- case 'H': // "${CSI}${ROW};${COLUMN}H" - Cursor position (CUP).
- case 'f': // "${CSI}${ROW};${COLUMN}f" - Horizontal and Vertical Position (HVP).
- setCursorPosition(getArg1(1) - 1, getArg0(1) - 1);
- break;
- case 'I': // Cursor Horizontal Forward Tabulation (CHT). Move the active position n tabs forward.
- setCursorCol(nextTabStop(getArg0(1)));
- break;
- case 'J': // "${CSI}${0,1,2}J" - Erase in Display (ED)
- // ED ignores the scrolling margins.
- switch (getArg0(0)) {
- case 0: // Erase from the active position to the end of the screen, inclusive (default).
- blockClear(mCursorCol, mCursorRow, mColumns - mCursorCol);
- blockClear(0, mCursorRow + 1, mColumns, mRows - (mCursorRow + 1));
- break;
- case 1: // Erase from start of the screen to the active position, inclusive.
- blockClear(0, 0, mColumns, mCursorRow);
- blockClear(0, mCursorRow, mCursorCol + 1);
- break;
- case 2: // Erase all of the display - all lines are erased, changed to single-width, and the cursor does not
- // move..
- blockClear(0, 0, mColumns, mRows);
- break;
- default:
- unknownSequence(b);
- return;
- }
- mAboutToAutoWrap = false;
- break;
- case 'K': // "CSI{n}K" - Erase in line (EL).
- switch (getArg0(0)) {
- case 0: // Erase from the cursor to the end of the line, inclusive (default)
- blockClear(mCursorCol, mCursorRow, mColumns - mCursorCol);
- break;
- case 1: // Erase from the start of the screen to the cursor, inclusive.
- blockClear(0, mCursorRow, mCursorCol + 1);
- break;
- case 2: // Erase all of the line.
- blockClear(0, mCursorRow, mColumns);
- break;
- default:
- unknownSequence(b);
- return;
- }
- mAboutToAutoWrap = false;
- break;
- case 'L': // "${CSI}{N}L" - insert ${N} lines (IL).
- {
- int linesAfterCursor = mBottomMargin - mCursorRow;
- int linesToInsert = Math.min(getArg0(1), linesAfterCursor);
- int linesToMove = linesAfterCursor - linesToInsert;
- mScreen.blockCopy(0, mCursorRow, mColumns, linesToMove, 0, mCursorRow + linesToInsert);
- blockClear(0, mCursorRow, mColumns, linesToInsert);
- }
- break;
- case 'M': // "${CSI}${N}M" - delete N lines (DL).
- {
- mAboutToAutoWrap = false;
- int linesAfterCursor = mBottomMargin - mCursorRow;
- int linesToDelete = Math.min(getArg0(1), linesAfterCursor);
- int linesToMove = linesAfterCursor - linesToDelete;
- mScreen.blockCopy(0, mCursorRow + linesToDelete, mColumns, linesToMove, 0, mCursorRow);
- blockClear(0, mCursorRow + linesToMove, mColumns, linesToDelete);
- }
- break;
- case 'P': // "${CSI}{N}P" - delete ${N} characters (DCH).
- {
- // http://www.vt100.net/docs/vt510-rm/DCH: "If ${N} is greater than the number of characters between the
- // cursor and the right margin, then DCH only deletes the remaining characters.
- // As characters are deleted, the remaining characters between the cursor and right margin move to the left.
- // Character attributes move with the characters. The terminal adds blank spaces with no visual character
- // attributes at the right margin. DCH has no effect outside the scrolling margins."
- mAboutToAutoWrap = false;
- int cellsAfterCursor = mColumns - mCursorCol;
- int cellsToDelete = Math.min(getArg0(1), cellsAfterCursor);
- int cellsToMove = cellsAfterCursor - cellsToDelete;
- mScreen.blockCopy(mCursorCol + cellsToDelete, mCursorRow, cellsToMove, 1, mCursorCol, mCursorRow);
- blockClear(mCursorCol + cellsToMove, mCursorRow, cellsToDelete);
- }
- break;
- case 'S': { // "${CSI}${N}S" - scroll up ${N} lines (default = 1) (SU).
- final int linesToScroll = getArg0(1);
- for (int i = 0; i < linesToScroll; i++)
- scrollDownOneLine();
- break;
- }
- case 'T':
- if (mArgIndex == 0) {
- // "${CSI}${N}T" - Scroll down N lines (default = 1) (SD).
- // http://vt100.net/docs/vt510-rm/SD: "N is the number of lines to move the user window up in page
- // memory. N new lines appear at the top of the display. N old lines disappear at the bottom of the
- // display. You cannot pan past the top margin of the current page".
- final int linesToScrollArg = getArg0(1);
- final int linesBetweenTopAndBottomMargins = mBottomMargin - mTopMargin;
- final int linesToScroll = Math.min(linesBetweenTopAndBottomMargins, linesToScrollArg);
- mScreen.blockCopy(0, mTopMargin, mColumns, linesBetweenTopAndBottomMargins - linesToScroll, 0, mTopMargin + linesToScroll);
- blockClear(0, mTopMargin, mColumns, linesToScroll);
- } else {
- // "${CSI}${func};${startx};${starty};${firstrow};${lastrow}T" - initiate highlight mouse tracking.
- unimplementedSequence(b);
- }
- break;
- case 'X': // "${CSI}${N}X" - Erase ${N:=1} character(s) (ECH). FIXME: Clears character attributes?
- mAboutToAutoWrap = false;
- mScreen.blockSet(mCursorCol, mCursorRow, Math.min(getArg0(1), mColumns - mCursorCol), 1, ' ', getStyle());
- break;
- case 'Z': // Cursor Backward Tabulation (CBT). Move the active position n tabs backward.
- int numberOfTabs = getArg0(1);
- int newCol = mLeftMargin;
- for (int i = mCursorCol - 1; i >= 0; i--)
- if (mTabStop[i]) {
- if (--numberOfTabs == 0) {
- newCol = Math.max(i, mLeftMargin);
- break;
- }
- }
- mCursorCol = newCol;
- break;
- case '?': // Esc [ ? -- start of a private mode set
- continueSequence(ESC_CSI_QUESTIONMARK);
- break;
- case '>': // "Esc [ >" --
- continueSequence(ESC_CSI_BIGGERTHAN);
- break;
- case '`': // Horizontal position absolute (HPA - http://www.vt100.net/docs/vt510-rm/HPA).
- setCursorColRespectingOriginMode(getArg0(1) - 1);
- break;
- case 'c': // Primary Device Attributes (http://www.vt100.net/docs/vt510-rm/DA1) if argument is missing or zero.
- // The important part that may still be used by some (tmux stores this value but does not currently use it)
- // is the first response parameter identifying the terminal service class, where we send 64 for "vt420".
- // This is followed by a list of attributes which is probably unused by applications. Send like xterm.
- if (getArg0(0) == 0) mSession.write("\033[?64;1;2;6;9;15;18;21;22c");
- break;
- case 'd': // ESC [ Pn d - Vert Position Absolute
- setCursorRow(Math.min(Math.max(1, getArg0(1)), mRows) - 1);
- break;
- case 'e': // Vertical Position Relative (VPR). From ISO-6429 (ECMA-48).
- setCursorPosition(mCursorCol, mCursorRow + getArg0(1));
- break;
- // case 'f': "${CSI}${ROW};${COLUMN}f" - Horizontal and Vertical Position (HVP). Grouped with case 'H'.
- case 'g': // Clear tab stop
- switch (getArg0(0)) {
- case 0:
- mTabStop[mCursorCol] = false;
- break;
- case 3:
- for (int i = 0; i < mColumns; i++) {
- mTabStop[i] = false;
- }
- break;
- default:
- // Specified to have no effect.
- break;
- }
- break;
- case 'h': // Set Mode
- doSetMode(true);
- break;
- case 'l': // Reset Mode
- doSetMode(false);
- break;
- case 'm': // Esc [ Pn m - character attributes. (can have up to 16 numerical arguments)
- selectGraphicRendition();
- break;
- case 'n': // Esc [ Pn n - ECMA-48 Status Report Commands
- // sendDeviceAttributes()
- switch (getArg0(0)) {
- case 5: // Device status report (DSR):
- // Answer is ESC [ 0 n (Terminal OK).
- byte[] dsr = { (byte) 27, (byte) '[', (byte) '0', (byte) 'n' };
- mSession.write(dsr, 0, dsr.length);
- break;
- case 6: // Cursor position report (CPR):
- // Answer is ESC [ y ; x R, where x,y is
- // the cursor location.
- mSession.write(String.format(Locale.US, "\033[%d;%dR", mCursorRow + 1, mCursorCol + 1));
- break;
- default:
- break;
- }
- break;
- case 'r': // "CSI${top};${bottom}r" - set top and bottom Margins (DECSTBM).
- {
- // http://www.vt100.net/docs/vt510-rm/DECSTBM
- // The top margin defaults to 1, the bottom margin defaults to mRows.
- // The escape sequence numbers top 1..23, but we number top 0..22.
- // The escape sequence numbers bottom 2..24, and so do we (because we use a zero based numbering
- // scheme, but we store the first line below the bottom-most scrolling line.
- // As a result, we adjust the top line by -1, but we leave the bottom line alone.
- // Also require that top + 2 <= bottom.
- mTopMargin = Math.max(0, Math.min(getArg0(1) - 1, mRows - 2));
- mBottomMargin = Math.max(mTopMargin + 2, Math.min(getArg1(mRows), mRows));
- // DECSTBM moves the cursor to column 1, line 1 of the page respecting origin mode.
- setCursorPosition(0, 0);
- }
- break;
- case 's':
- if (isDecsetInternalBitSet(DECSET_BIT_LEFTRIGHT_MARGIN_MODE)) {
- // Set left and right margins (DECSLRM - http://www.vt100.net/docs/vt510-rm/DECSLRM).
- mLeftMargin = Math.min(getArg0(1) - 1, mColumns - 2);
- mRightMargin = Math.max(mLeftMargin + 1, Math.min(getArg1(mColumns), mColumns));
- // DECSLRM moves the cursor to column 1, line 1 of the page.
- setCursorPosition(0, 0);
- } else {
- // Save cursor (ANSI.SYS), available only when DECLRMM is disabled.
- saveCursor();
- }
- break;
- case 't': // Window manipulation (from dtterm, as well as extensions)
- switch (getArg0(0)) {
- case 11: // Report xterm window state. If the xterm window is open (non-iconified), it returns CSI 1 t .
- mSession.write("\033[1t");
- break;
- case 13: // Report xterm window position. Result is CSI 3 ; x ; y t
- mSession.write("\033[3;0;0t");
- break;
- case 14: // Report xterm window in pixels. Result is CSI 4 ; height ; width t
- // We just report characters time 12 here.
- mSession.write(String.format(Locale.US, "\033[4;%d;%dt", mRows * 12, mColumns * 12));
- break;
- case 18: // Report the size of the text area in characters. Result is CSI 8 ; height ; width t
- mSession.write(String.format(Locale.US, "\033[8;%d;%dt", mRows, mColumns));
- break;
- case 19: // Report the size of the screen in characters. Result is CSI 9 ; height ; width t
- // We report the same size as the view, since it's the view really isn't resizable from the shell.
- mSession.write(String.format(Locale.US, "\033[9;%d;%dt", mRows, mColumns));
- break;
- case 20: // Report xterm windows icon label. Result is OSC L label ST. Disabled due to security concerns:
- mSession.write("\033]LIconLabel\033\\");
- break;
- case 21: // Report xterm windows title. Result is OSC l label ST. Disabled due to security concerns:
- mSession.write("\033]l\033\\");
- break;
- case 22:
- // 22;0 -> Save xterm icon and window title on stack.
- // 22;1 -> Save xterm icon title on stack.
- // 22;2 -> Save xterm window title on stack.
- mTitleStack.push(mTitle);
- if (mTitleStack.size() > 20) {
- // Limit size
- mTitleStack.remove(0);
- }
- break;
- case 23: // Like 22 above but restore from stack.
- if (!mTitleStack.isEmpty()) setTitle(mTitleStack.pop());
- break;
- default:
- // Ignore window manipulation.
- break;
- }
- break;
- case 'u': // Restore cursor (ANSI.SYS).
- restoreCursor();
- break;
- case ' ':
- continueSequence(ESC_CSI_ARGS_SPACE);
- break;
- default:
- parseArg(b);
- break;
- }
- }
-
- /** Select Graphic Rendition (SGR) - see http://en.wikipedia.org/wiki/ANSI_escape_code#graphics. */
- private void selectGraphicRendition() {
- for (int i = 0; i <= mArgIndex; i++) {
- int code = mArgs[i];
- if (code < 0) {
- if (mArgIndex > 0) {
- continue;
- } else {
- code = 0;
- }
- }
- if (code == 0) { // reset
- mForeColor = TextStyle.COLOR_INDEX_FOREGROUND;
- mBackColor = TextStyle.COLOR_INDEX_BACKGROUND;
- mEffect = 0;
- } else if (code == 1) {
- mEffect |= TextStyle.CHARACTER_ATTRIBUTE_BOLD;
- } else if (code == 2) {
- mEffect |= TextStyle.CHARACTER_ATTRIBUTE_DIM;
- } else if (code == 3) {
- mEffect |= TextStyle.CHARACTER_ATTRIBUTE_ITALIC;
- } else if (code == 4) {
- mEffect |= TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE;
- } else if (code == 5) {
- mEffect |= TextStyle.CHARACTER_ATTRIBUTE_BLINK;
- } else if (code == 7) {
- mEffect |= TextStyle.CHARACTER_ATTRIBUTE_INVERSE;
- } else if (code == 8) {
- mEffect |= TextStyle.CHARACTER_ATTRIBUTE_INVISIBLE;
- } else if (code == 9) {
- mEffect |= TextStyle.CHARACTER_ATTRIBUTE_STRIKETHROUGH;
- } else if (code == 10) {
- // Exit alt charset (TERM=linux) - ignore.
- } else if (code == 11) {
- // Enter alt charset (TERM=linux) - ignore.
- } else if (code == 22) { // Normal color or intensity, neither bright, bold nor faint.
- mEffect &= ~(TextStyle.CHARACTER_ATTRIBUTE_BOLD | TextStyle.CHARACTER_ATTRIBUTE_DIM);
- } else if (code == 23) { // not italic, but rarely used as such; clears standout with TERM=screen
- mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_ITALIC;
- } else if (code == 24) { // underline: none
- mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE;
- } else if (code == 25) { // blink: none
- mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_BLINK;
- } else if (code == 27) { // image: positive
- mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_INVERSE;
- } else if (code == 28) {
- mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_INVISIBLE;
- } else if (code == 29) {
- mEffect &= ~TextStyle.CHARACTER_ATTRIBUTE_STRIKETHROUGH;
- } else if (code >= 30 && code <= 37) {
- mForeColor = code - 30;
- } else if (code == 38 || code == 48) {
- // ISO-8613-3 controls to set foreground (38) or background (48) colors.
- // P_s = (38|48) ; 2 ; P_r ; P_g ; P_b => Set to RGB value in range (0-255).
- // P_s = (38|48) ; 5 ; P_s => Set to indexed color.
- if (i + 2 <= mArgIndex) {
- int color = -1;
- int firstArg = mArgs[i + 1];
- if (firstArg == 2) {
- if (i + 4 > mArgIndex) {
- Log.w(EmulatorDebug.LOG_TAG, "Too few CSI" + code + ";2 RGB arguments");
- } else {
- int red = mArgs[i + 2], green = mArgs[i + 3], blue = mArgs[i + 4];
- if (red < 0 || green < 0 || blue < 0 || red > 255 || green > 255 || blue > 255) {
- finishSequenceAndLogError("Invalid RGB: " + red + "," + green + "," + blue);
- } else {
- // TODO: Implement 24 bit color.
- finishSequenceAndLogError("Unimplemented RGB: " + red + "," + green + "," + blue);
- }
- i += 4; // "2;P_r;P_g;P_r"
- }
- } else if (firstArg == 5) {
- color = mArgs[i + 2];
- i += 2; // "5;P_s"
- } else {
- finishSequenceAndLogError("Invalid ISO-8613-3 SGR first argument: " + firstArg);
- }
- if (i != -1) {
- if (color >= 0 && color < TextStyle.NUM_INDEXED_COLORS) {
- if (code == 38) {
- mForeColor = color;
- } else {
- mBackColor = color;
- }
- } else {
- if (LOG_ESCAPE_SEQUENCES) Log.w(EmulatorDebug.LOG_TAG, "Invalid color index: " + color);
- }
- }
- }
- } else if (code == 39) { // Set default foreground color.
- mForeColor = TextStyle.COLOR_INDEX_FOREGROUND;
- } else if (code >= 40 && code <= 47) { // Set background color.
- mBackColor = code - 40;
- } else if (code == 49) { // Set default background color.
- mBackColor = TextStyle.COLOR_INDEX_BACKGROUND;
- } else if (code >= 90 && code <= 97) { // Bright foreground colors (aixterm codes).
- mForeColor = code - 90 + 8;
- } else if (code >= 100 && code <= 107) { // Bright background color (aixterm codes).
- mBackColor = code - 100 + 8;
- } else {
- if (LOG_ESCAPE_SEQUENCES) Log.w(EmulatorDebug.LOG_TAG, String.format("SGR unknown code %d", code));
- }
- }
- }
-
- private void doOsc(int b) {
- switch (b) {
- case 7: // Bell.
- doOscSetTextParameters("\007");
- break;
- case 27: // Escape.
- continueSequence(ESC_OSC_ESC);
- break;
- default:
- collectOSCArgs(b);
- break;
- }
- }
-
- private void doOscEsc(int b) {
- switch (b) {
- case '\\':
- doOscSetTextParameters("\033\\");
- break;
- default:
- // The ESC character was not followed by a \, so insert the ESC and
- // the current character in arg buffer.
- collectOSCArgs(27);
- collectOSCArgs(b);
- continueSequence(ESC_OSC);
- break;
- }
- }
-
- /** An Operating System Controls (OSC) Set Text Parameters. May come here from BEL or ST. */
- private void doOscSetTextParameters(String bellOrStringTerminator) {
- int value = -1;
- String textParameter = "";
- // Extract initial $value from initial "$value;..." string.
- for (int mOSCArgTokenizerIndex = 0; mOSCArgTokenizerIndex < mOSCOrDeviceControlArgs.length(); mOSCArgTokenizerIndex++) {
- char b = mOSCOrDeviceControlArgs.charAt(mOSCArgTokenizerIndex);
- if (b == ';') {
- textParameter = mOSCOrDeviceControlArgs.substring(mOSCArgTokenizerIndex + 1);
- break;
- } else if (b >= '0' && b <= '9') {
- value = ((value < 0) ? 0 : value * 10) + (b - '0');
- } else {
- unknownSequence(b);
- return;
- }
- }
-
- switch (value) {
- case 0: // Change icon name and window title to T.
- case 1: // Change icon name to T.
- case 2: // Change window title to T.
- setTitle(textParameter);
- break;
- case 4:
- // P s = 4 ; c ; spec → Change Color Number c to the color specified by spec. This can be a name or RGB
- // specification as per XParseColor. Any number of c name pairs may be given. The color numbers correspond
- // to the ANSI colors 0-7, their bright versions 8-15, and if supported, the remainder of the 88-color or
- // 256-color table.
- // If a "?" is given rather than a name or RGB specification, xterm replies with a control sequence of the
- // same form which can be used to set the corresponding color. Because more than one pair of color number
- // and specification can be given in one control sequence, xterm can make more than one reply.
- int colorIndex = -1;
- int parsingPairStart = -1;
- for (int i = 0;; i++) {
- boolean endOfInput = i == textParameter.length();
- char b = endOfInput ? ';' : textParameter.charAt(i);
- if (b == ';') {
- if (parsingPairStart < 0) {
- parsingPairStart = i + 1;
- } else {
- if (colorIndex < 0 || colorIndex > 255) {
- unknownSequence(b);
- return;
- } else {
- mColors.tryParseColor(colorIndex, textParameter.substring(parsingPairStart, i));
- mSession.onColorsChanged();
- colorIndex = -1;
- parsingPairStart = -1;
- }
- }
- } else if (parsingPairStart >= 0) {
- // We have passed a color index and are now going through color spec.
- } else if (parsingPairStart < 0 && (b >= '0' && b <= '9')) {
- colorIndex = ((colorIndex < 0) ? 0 : colorIndex * 10) + (b - '0');
- } else {
- unknownSequence(b);
- return;
- }
- if (endOfInput) break;
- }
- break;
- case 10: // Set foreground color.
- case 11: // Set background color.
- case 12: // Set cursor color.
- int specialIndex = TextStyle.COLOR_INDEX_FOREGROUND + (value - 10);
- int lastSemiIndex = 0;
- for (int charIndex = 0;; charIndex++) {
- boolean endOfInput = charIndex == textParameter.length();
- if (endOfInput || textParameter.charAt(charIndex) == ';') {
- try {
- String colorSpec = textParameter.substring(lastSemiIndex, charIndex);
- if ("?".equals(colorSpec)) {
- // Report current color in the same format xterm and gnome-terminal does.
- int rgb = mColors.mCurrentColors[specialIndex];
- int r = (65535 * ((rgb & 0x00FF0000) >> 16)) / 255;
- int g = (65535 * ((rgb & 0x0000FF00) >> 8)) / 255;
- int b = (65535 * ((rgb & 0x000000FF))) / 255;
- mSession.write("\033]" + value + ";rgb:" + String.format(Locale.US, "%04x", r) + "/" + String.format(Locale.US, "%04x", g) + "/"
- + String.format(Locale.US, "%04x", b) + bellOrStringTerminator);
- } else {
- mColors.tryParseColor(specialIndex, colorSpec);
- mSession.onColorsChanged();
- }
- specialIndex++;
- if (endOfInput || (specialIndex > TextStyle.COLOR_INDEX_CURSOR) || ++charIndex >= textParameter.length()) break;
- lastSemiIndex = charIndex;
- } catch (NumberFormatException e) {
- // Ignore.
- }
- }
- }
- break;
- case 52: // Manipulate Selection Data. Skip the optional first selection parameter(s).
- int startIndex = textParameter.indexOf(";") + 1;
- try {
- String clipboardText = new String(Base64.decode(textParameter.substring(startIndex), 0), StandardCharsets.UTF_8);
- mSession.clipboardText(clipboardText);
- } catch (Exception e) {
- Log.e(EmulatorDebug.LOG_TAG, "OSC Manipulate selection, invalid string '" + textParameter + "");
- }
- break;
- case 104:
- // "104;$c" → Reset Color Number $c. It is reset to the color specified by the corresponding X
- // resource. Any number of c parameters may be given. These parameters correspond to the ANSI colors 0-7,
- // their bright versions 8-15, and if supported, the remainder of the 88-color or 256-color table. If no
- // parameters are given, the entire table will be reset.
- if (textParameter.isEmpty()) {
- mColors.reset();
+ switch (value) {
+ case 0: // Change icon name and window title to T.
+ case 1: // Change icon name to T.
+ case 2: // Change window title to T.
+ setTitle(textParameter);
+ break;
+ case 4:
+ // P s = 4 ; c ; spec → Change Color Number c to the color specified by spec. This can be a name or RGB
+ // specification as per XParseColor. Any number of c name pairs may be given. The color numbers correspond
+ // to the ANSI colors 0-7, their bright versions 8-15, and if supported, the remainder of the 88-color or
+ // 256-color table.
+ // If a "?" is given rather than a name or RGB specification, xterm replies with a control sequence of the
+ // same form which can be used to set the corresponding color. Because more than one pair of color number
+ // and specification can be given in one control sequence, xterm can make more than one reply.
+ int colorIndex = -1;
+ int parsingPairStart = -1;
+ for (int i = 0; ; i++) {
+ boolean endOfInput = i == textParameter.length();
+ char b = endOfInput ? ';' : textParameter.charAt(i);
+ if (b == ';') {
+ if (parsingPairStart < 0) {
+ parsingPairStart = i + 1;
+ } else {
+ if (colorIndex < 0 || colorIndex > 255) {
+ unknownSequence(b);
+ return;
+ } else {
+ mColors.tryParseColor(colorIndex, textParameter.substring(parsingPairStart, i));
+ mSession.onColorsChanged();
+ colorIndex = -1;
+ parsingPairStart = -1;
+ }
+ }
+ } else if (parsingPairStart >= 0) {
+ // We have passed a color index and are now going through color spec.
+ } else if (parsingPairStart < 0 && (b >= '0' && b <= '9')) {
+ colorIndex = ((colorIndex < 0) ? 0 : colorIndex * 10) + (b - '0');
+ } else {
+ unknownSequence(b);
+ return;
+ }
+ if (endOfInput) break;
+ }
+ break;
+ case 10: // Set foreground color.
+ case 11: // Set background color.
+ case 12: // Set cursor color.
+ int specialIndex = TextStyle.COLOR_INDEX_FOREGROUND + (value - 10);
+ int lastSemiIndex = 0;
+ for (int charIndex = 0; ; charIndex++) {
+ boolean endOfInput = charIndex == textParameter.length();
+ if (endOfInput || textParameter.charAt(charIndex) == ';') {
+ try {
+ String colorSpec = textParameter.substring(lastSemiIndex, charIndex);
+ if ("?".equals(colorSpec)) {
+ // Report current color in the same format xterm and gnome-terminal does.
+ int rgb = mColors.mCurrentColors[specialIndex];
+ int r = (65535 * ((rgb & 0x00FF0000) >> 16)) / 255;
+ int g = (65535 * ((rgb & 0x0000FF00) >> 8)) / 255;
+ int b = (65535 * ((rgb & 0x000000FF))) / 255;
+ mSession.write("\033]" + value + ";rgb:" + String.format(Locale.US, "%04x", r) + "/" + String.format(Locale.US, "%04x", g) + "/"
+ + String.format(Locale.US, "%04x", b) + bellOrStringTerminator);
+ } else {
+ mColors.tryParseColor(specialIndex, colorSpec);
+ mSession.onColorsChanged();
+ }
+ specialIndex++;
+ if (endOfInput || (specialIndex > TextStyle.COLOR_INDEX_CURSOR) || ++charIndex >= textParameter.length())
+ break;
+ lastSemiIndex = charIndex;
+ } catch (NumberFormatException e) {
+ // Ignore.
+ }
+ }
+ }
+ break;
+ case 52: // Manipulate Selection Data. Skip the optional first selection parameter(s).
+ int startIndex = textParameter.indexOf(";") + 1;
+ try {
+ String clipboardText = new String(Base64.decode(textParameter.substring(startIndex), 0), StandardCharsets.UTF_8);
+ mSession.clipboardText(clipboardText);
+ } catch (Exception e) {
+ Log.e(EmulatorDebug.LOG_TAG, "OSC Manipulate selection, invalid string '" + textParameter + "");
+ }
+ break;
+ case 104:
+ // "104;$c" → Reset Color Number $c. It is reset to the color specified by the corresponding X
+ // resource. Any number of c parameters may be given. These parameters correspond to the ANSI colors 0-7,
+ // their bright versions 8-15, and if supported, the remainder of the 88-color or 256-color table. If no
+ // parameters are given, the entire table will be reset.
+ if (textParameter.isEmpty()) {
+ mColors.reset();
+ mSession.onColorsChanged();
+ } else {
+ int lastIndex = 0;
+ for (int charIndex = 0; ; charIndex++) {
+ boolean endOfInput = charIndex == textParameter.length();
+ if (endOfInput || textParameter.charAt(charIndex) == ';') {
+ try {
+ int colorToReset = Integer.parseInt(textParameter.substring(lastIndex, charIndex));
+ mColors.reset(colorToReset);
+ mSession.onColorsChanged();
+ if (endOfInput) break;
+ charIndex++;
+ lastIndex = charIndex;
+ } catch (NumberFormatException e) {
+ // Ignore.
+ }
+ }
+ }
+ }
+ break;
+ case 110: // Reset foreground color.
+ case 111: // Reset background color.
+ case 112: // Reset cursor color.
+ mColors.reset(TextStyle.COLOR_INDEX_FOREGROUND + (value - 110));
mSession.onColorsChanged();
- } else {
- int lastIndex = 0;
- for (int charIndex = 0;; charIndex++) {
- boolean endOfInput = charIndex == textParameter.length();
- if (endOfInput || textParameter.charAt(charIndex) == ';') {
- try {
- int colorToReset = Integer.parseInt(textParameter.substring(lastIndex, charIndex));
- mColors.reset(colorToReset);
- mSession.onColorsChanged();
- if (endOfInput) break;
- charIndex++;
- lastIndex = charIndex;
- } catch (NumberFormatException e) {
- // Ignore.
- }
- }
- }
- }
- break;
- case 110: // Reset foreground color.
- case 111: // Reset background color.
- case 112: // Reset cursor color.
- mColors.reset(TextStyle.COLOR_INDEX_FOREGROUND + (value - 110));
- mSession.onColorsChanged();
- break;
- case 119: // Reset highlight color.
- break;
- default:
- unknownParameter(value);
- break;
- }
- finishSequence();
- }
+ break;
+ case 119: // Reset highlight color.
+ break;
+ default:
+ unknownParameter(value);
+ break;
+ }
+ finishSequence();
+ }
- private void blockClear(int sx, int sy, int w) {
- blockClear(sx, sy, w, 1);
- }
+ private void blockClear(int sx, int sy, int w) {
+ blockClear(sx, sy, w, 1);
+ }
- private void blockClear(int sx, int sy, int w, int h) {
- mScreen.blockSet(sx, sy, w, h, ' ', getStyle());
- }
+ private void blockClear(int sx, int sy, int w, int h) {
+ mScreen.blockSet(sx, sy, w, h, ' ', getStyle());
+ }
- private int getStyle() {
- return TextStyle.encode(mForeColor, mBackColor, mEffect);
- }
+ private int getStyle() {
+ return TextStyle.encode(mForeColor, mBackColor, mEffect);
+ }
- /** "CSI P_m h" for set or "CSI P_m l" for reset ANSI mode. */
- private void doSetMode(boolean newValue) {
- int modeBit = getArg0(0);
- switch (modeBit) {
- case 4: // Set="Insert Mode". Reset="Replace Mode". (IRM).
- mInsertMode = newValue;
- break;
- case 20: // Normal Linefeed (LNM).
- unknownParameter(modeBit);
- // http://www.vt100.net/docs/vt510-rm/LNM
- break;
- case 34:
- // Normal cursor visibility - when using TERM=screen, see
- // http://www.gnu.org/software/screen/manual/html_node/Control-Sequences.html
- break;
- default:
- unknownParameter(modeBit);
- break;
- }
- }
+ /** "CSI P_m h" for set or "CSI P_m l" for reset ANSI mode. */
+ private void doSetMode(boolean newValue) {
+ int modeBit = getArg0(0);
+ switch (modeBit) {
+ case 4: // Set="Insert Mode". Reset="Replace Mode". (IRM).
+ mInsertMode = newValue;
+ break;
+ case 20: // Normal Linefeed (LNM).
+ unknownParameter(modeBit);
+ // http://www.vt100.net/docs/vt510-rm/LNM
+ break;
+ case 34:
+ // Normal cursor visibility - when using TERM=screen, see
+ // http://www.gnu.org/software/screen/manual/html_node/Control-Sequences.html
+ break;
+ default:
+ unknownParameter(modeBit);
+ break;
+ }
+ }
- /**
- * NOTE: The parameters of this function respect the {@link #DECSET_BIT_ORIGIN_MODE}. Use
- * {@link #setCursorRowCol(int, int)} for absolute pos.
- */
- private void setCursorPosition(int x, int y) {
- boolean originMode = isDecsetInternalBitSet(DECSET_BIT_ORIGIN_MODE);
- int effectiveTopMargin = originMode ? mTopMargin : 0;
- int effectiveBottomMargin = originMode ? mBottomMargin : mRows;
- int effectiveLeftMargin = originMode ? mLeftMargin : 0;
- int effectiveRightMargin = originMode ? mRightMargin : mColumns;
- int newRow = Math.max(effectiveTopMargin, Math.min(effectiveTopMargin + y, effectiveBottomMargin - 1));
- int newCol = Math.max(effectiveLeftMargin, Math.min(effectiveLeftMargin + x, effectiveRightMargin - 1));
- setCursorRowCol(newRow, newCol);
- }
+ /**
+ * NOTE: The parameters of this function respect the {@link #DECSET_BIT_ORIGIN_MODE}. Use
+ * {@link #setCursorRowCol(int, int)} for absolute pos.
+ */
+ private void setCursorPosition(int x, int y) {
+ boolean originMode = isDecsetInternalBitSet(DECSET_BIT_ORIGIN_MODE);
+ int effectiveTopMargin = originMode ? mTopMargin : 0;
+ int effectiveBottomMargin = originMode ? mBottomMargin : mRows;
+ int effectiveLeftMargin = originMode ? mLeftMargin : 0;
+ int effectiveRightMargin = originMode ? mRightMargin : mColumns;
+ int newRow = Math.max(effectiveTopMargin, Math.min(effectiveTopMargin + y, effectiveBottomMargin - 1));
+ int newCol = Math.max(effectiveLeftMargin, Math.min(effectiveLeftMargin + x, effectiveRightMargin - 1));
+ setCursorRowCol(newRow, newCol);
+ }
- private void scrollDownOneLine() {
- mScrollCounter++;
- if (mLeftMargin != 0 || mRightMargin != mColumns) {
- // Horizontal margin: Do not put anything into scroll history, just non-margin part of screen up.
- mScreen.blockCopy(mLeftMargin, mTopMargin + 1, mRightMargin - mLeftMargin, mBottomMargin - mTopMargin - 1, mLeftMargin, mTopMargin);
- // .. and blank bottom row between margins:
- mScreen.blockSet(mLeftMargin, mBottomMargin - 1, mRightMargin - mLeftMargin, 1, ' ', mEffect);
- } else {
- mScreen.scrollDownOneLine(mTopMargin, mBottomMargin, getStyle());
- }
- }
+ private void scrollDownOneLine() {
+ mScrollCounter++;
+ if (mLeftMargin != 0 || mRightMargin != mColumns) {
+ // Horizontal margin: Do not put anything into scroll history, just non-margin part of screen up.
+ mScreen.blockCopy(mLeftMargin, mTopMargin + 1, mRightMargin - mLeftMargin, mBottomMargin - mTopMargin - 1, mLeftMargin, mTopMargin);
+ // .. and blank bottom row between margins:
+ mScreen.blockSet(mLeftMargin, mBottomMargin - 1, mRightMargin - mLeftMargin, 1, ' ', mEffect);
+ } else {
+ mScreen.scrollDownOneLine(mTopMargin, mBottomMargin, getStyle());
+ }
+ }
- /** Process the next ASCII character of a parameter. */
- private void parseArg(int b) {
- if (b >= '0' && b <= '9') {
- if (mArgIndex < mArgs.length) {
- int oldValue = mArgs[mArgIndex];
- int thisDigit = b - '0';
- int value;
- if (oldValue >= 0) {
- value = oldValue * 10 + thisDigit;
- } else {
- value = thisDigit;
- }
- mArgs[mArgIndex] = value;
- }
- continueSequence(mEscapeState);
- } else if (b == ';') {
- if (mArgIndex < mArgs.length) {
- mArgIndex++;
- }
- continueSequence(mEscapeState);
- } else {
- unknownSequence(b);
- }
- }
+ /** Process the next ASCII character of a parameter. */
+ private void parseArg(int b) {
+ if (b >= '0' && b <= '9') {
+ if (mArgIndex < mArgs.length) {
+ int oldValue = mArgs[mArgIndex];
+ int thisDigit = b - '0';
+ int value;
+ if (oldValue >= 0) {
+ value = oldValue * 10 + thisDigit;
+ } else {
+ value = thisDigit;
+ }
+ mArgs[mArgIndex] = value;
+ }
+ continueSequence(mEscapeState);
+ } else if (b == ';') {
+ if (mArgIndex < mArgs.length) {
+ mArgIndex++;
+ }
+ continueSequence(mEscapeState);
+ } else {
+ unknownSequence(b);
+ }
+ }
- private int getArg0(int defaultValue) {
- return getArg(0, defaultValue, true);
- }
+ private int getArg0(int defaultValue) {
+ return getArg(0, defaultValue, true);
+ }
- private int getArg1(int defaultValue) {
- return getArg(1, defaultValue, true);
- }
+ private int getArg1(int defaultValue) {
+ return getArg(1, defaultValue, true);
+ }
- private int getArg(int index, int defaultValue, boolean treatZeroAsDefault) {
- int result = mArgs[index];
- if (result < 0 || (result == 0 && treatZeroAsDefault)) {
- result = defaultValue;
- }
- return result;
- }
+ private int getArg(int index, int defaultValue, boolean treatZeroAsDefault) {
+ int result = mArgs[index];
+ if (result < 0 || (result == 0 && treatZeroAsDefault)) {
+ result = defaultValue;
+ }
+ return result;
+ }
- private void collectOSCArgs(int b) {
- if (mOSCOrDeviceControlArgs.length() < MAX_OSC_STRING_LENGTH) {
- mOSCOrDeviceControlArgs.appendCodePoint(b);
- continueSequence(mEscapeState);
- } else {
- unknownSequence(b);
- }
- }
+ private void collectOSCArgs(int b) {
+ if (mOSCOrDeviceControlArgs.length() < MAX_OSC_STRING_LENGTH) {
+ mOSCOrDeviceControlArgs.appendCodePoint(b);
+ continueSequence(mEscapeState);
+ } else {
+ unknownSequence(b);
+ }
+ }
- private void unimplementedSequence(int b) {
- logError("Unimplemented sequence char '" + (char) b + "' (U+" + String.format("%04x", b) + ")");
- finishSequence();
- }
+ private void unimplementedSequence(int b) {
+ logError("Unimplemented sequence char '" + (char) b + "' (U+" + String.format("%04x", b) + ")");
+ finishSequence();
+ }
- private void unknownSequence(int b) {
- logError("Unknown sequence char '" + (char) b + "' (numeric value=" + b + ")");
- finishSequence();
- }
+ private void unknownSequence(int b) {
+ logError("Unknown sequence char '" + (char) b + "' (numeric value=" + b + ")");
+ finishSequence();
+ }
- private void unknownParameter(int parameter) {
- logError("Unknown parameter: " + parameter);
- finishSequence();
- }
+ private void unknownParameter(int parameter) {
+ logError("Unknown parameter: " + parameter);
+ finishSequence();
+ }
- private void logError(String errorType) {
- if (LOG_ESCAPE_SEQUENCES) {
- StringBuilder buf = new StringBuilder();
- buf.append(errorType);
- buf.append(", escapeState=");
- buf.append(mEscapeState);
- boolean firstArg = true;
- for (int i = 0; i <= mArgIndex; i++) {
- int value = mArgs[i];
- if (value >= 0) {
- if (firstArg) {
- firstArg = false;
- buf.append(", args={");
- } else {
- buf.append(',');
- }
- buf.append(value);
- }
- }
- if (!firstArg) buf.append('}');
- finishSequenceAndLogError(buf.toString());
- }
- }
+ private void logError(String errorType) {
+ if (LOG_ESCAPE_SEQUENCES) {
+ StringBuilder buf = new StringBuilder();
+ buf.append(errorType);
+ buf.append(", escapeState=");
+ buf.append(mEscapeState);
+ boolean firstArg = true;
+ for (int i = 0; i <= mArgIndex; i++) {
+ int value = mArgs[i];
+ if (value >= 0) {
+ if (firstArg) {
+ firstArg = false;
+ buf.append(", args={");
+ } else {
+ buf.append(',');
+ }
+ buf.append(value);
+ }
+ }
+ if (!firstArg) buf.append('}');
+ finishSequenceAndLogError(buf.toString());
+ }
+ }
- private void finishSequenceAndLogError(String error) {
- if (LOG_ESCAPE_SEQUENCES) Log.w(EmulatorDebug.LOG_TAG, error);
- finishSequence();
- }
+ private void finishSequenceAndLogError(String error) {
+ if (LOG_ESCAPE_SEQUENCES) Log.w(EmulatorDebug.LOG_TAG, error);
+ finishSequence();
+ }
- private void finishSequence() {
- mEscapeState = ESC_NONE;
- }
+ private void finishSequence() {
+ mEscapeState = ESC_NONE;
+ }
- /**
- * Send a Unicode code point to the screen.
- *
- * @param codePoint
- * The code point of the character to display
- */
- private void emitCodePoint(int codePoint) {
- if (mUseLineDrawingUsesG0 ? mUseLineDrawingG0 : mUseLineDrawingG1) {
- // http://www.vt100.net/docs/vt102-ug/table5-15.html.
- switch (codePoint) {
- case '_':
- codePoint = ' '; // Blank.
- break;
- case '`':
- codePoint = '◆'; // Diamond.
- break;
- case '0':
- codePoint = '█'; // Solid block;
- break;
- case 'a':
- codePoint = '▒'; // Checker board.
- break;
- case 'b':
- codePoint = '␉'; // Horizontal tab.
- break;
- case 'c':
- codePoint = '␌'; // Form feed.
- break;
- case 'd':
- codePoint = '\r'; // Carriage return.
- break;
- case 'e':
- codePoint = '␊'; // Linefeed.
- break;
- case 'f':
- codePoint = '°'; // Degree.
- break;
- case 'g':
- codePoint = '±'; // Plus-minus.
- break;
- case 'h':
- codePoint = '\n'; // Newline.
- break;
- case 'i':
- codePoint = '␋'; // Vertical tab.
- break;
- case 'j':
- codePoint = '┘'; // Lower right corner.
- break;
- case 'k':
- codePoint = '┐'; // Upper right corner.
- break;
- case 'l':
- codePoint = '┌'; // Upper left corner.
- break;
- case 'm':
- codePoint = '└'; // Left left corner.
- break;
- case 'n':
- codePoint = '┼'; // Crossing lines.
- break;
- case 'o':
- codePoint = '⎺'; // Horizontal line - scan 1.
- break;
- case 'p':
- codePoint = '⎻'; // Horizontal line - scan 3.
- break;
- case 'q':
- codePoint = '─'; // Horizontal line - scan 5.
- break;
- case 'r':
- codePoint = '⎼'; // Horizontal line - scan 7.
- break;
- case 's':
- codePoint = '⎽'; // Horizontal line - scan 9.
- break;
- case 't':
- codePoint = '├'; // T facing rightwards.
- break;
- case 'u':
- codePoint = '┤'; // T facing leftwards.
- break;
- case 'v':
- codePoint = '┴'; // T facing upwards.
- break;
- case 'w':
- codePoint = '┬'; // T facing downwards.
- break;
- case 'x':
- codePoint = '│'; // Vertical line.
- break;
- case 'y':
- codePoint = '≤'; // Less than or equal to.
- break;
- case 'z':
- codePoint = '≥'; // Greater than or equal to.
- break;
- case '{':
- codePoint = 'π'; // Pi.
- break;
- case '|':
- codePoint = '≠'; // Not equal to.
- break;
- case '}':
- codePoint = '£'; // UK pound.
- break;
- case '~':
- codePoint = '·'; // Centered dot.
- break;
- }
- }
+ /**
+ * Send a Unicode code point to the screen.
+ *
+ * @param codePoint The code point of the character to display
+ */
+ private void emitCodePoint(int codePoint) {
+ if (mUseLineDrawingUsesG0 ? mUseLineDrawingG0 : mUseLineDrawingG1) {
+ // http://www.vt100.net/docs/vt102-ug/table5-15.html.
+ switch (codePoint) {
+ case '_':
+ codePoint = ' '; // Blank.
+ break;
+ case '`':
+ codePoint = '◆'; // Diamond.
+ break;
+ case '0':
+ codePoint = '█'; // Solid block;
+ break;
+ case 'a':
+ codePoint = '▒'; // Checker board.
+ break;
+ case 'b':
+ codePoint = '␉'; // Horizontal tab.
+ break;
+ case 'c':
+ codePoint = '␌'; // Form feed.
+ break;
+ case 'd':
+ codePoint = '\r'; // Carriage return.
+ break;
+ case 'e':
+ codePoint = '␊'; // Linefeed.
+ break;
+ case 'f':
+ codePoint = '°'; // Degree.
+ break;
+ case 'g':
+ codePoint = '±'; // Plus-minus.
+ break;
+ case 'h':
+ codePoint = '\n'; // Newline.
+ break;
+ case 'i':
+ codePoint = '␋'; // Vertical tab.
+ break;
+ case 'j':
+ codePoint = '┘'; // Lower right corner.
+ break;
+ case 'k':
+ codePoint = '┐'; // Upper right corner.
+ break;
+ case 'l':
+ codePoint = '┌'; // Upper left corner.
+ break;
+ case 'm':
+ codePoint = '└'; // Left left corner.
+ break;
+ case 'n':
+ codePoint = '┼'; // Crossing lines.
+ break;
+ case 'o':
+ codePoint = '⎺'; // Horizontal line - scan 1.
+ break;
+ case 'p':
+ codePoint = '⎻'; // Horizontal line - scan 3.
+ break;
+ case 'q':
+ codePoint = '─'; // Horizontal line - scan 5.
+ break;
+ case 'r':
+ codePoint = '⎼'; // Horizontal line - scan 7.
+ break;
+ case 's':
+ codePoint = '⎽'; // Horizontal line - scan 9.
+ break;
+ case 't':
+ codePoint = '├'; // T facing rightwards.
+ break;
+ case 'u':
+ codePoint = '┤'; // T facing leftwards.
+ break;
+ case 'v':
+ codePoint = '┴'; // T facing upwards.
+ break;
+ case 'w':
+ codePoint = '┬'; // T facing downwards.
+ break;
+ case 'x':
+ codePoint = '│'; // Vertical line.
+ break;
+ case 'y':
+ codePoint = '≤'; // Less than or equal to.
+ break;
+ case 'z':
+ codePoint = '≥'; // Greater than or equal to.
+ break;
+ case '{':
+ codePoint = 'π'; // Pi.
+ break;
+ case '|':
+ codePoint = '≠'; // Not equal to.
+ break;
+ case '}':
+ codePoint = '£'; // UK pound.
+ break;
+ case '~':
+ codePoint = '·'; // Centered dot.
+ break;
+ }
+ }
- final boolean autoWrap = isDecsetInternalBitSet(DECSET_BIT_AUTOWRAP);
- final int displayWidth = WcWidth.width(codePoint);
- final boolean cursorInLastColumn = mCursorCol == mRightMargin - 1;
+ final boolean autoWrap = isDecsetInternalBitSet(DECSET_BIT_AUTOWRAP);
+ final int displayWidth = WcWidth.width(codePoint);
+ final boolean cursorInLastColumn = mCursorCol == mRightMargin - 1;
- if (autoWrap) {
- if (cursorInLastColumn && ((mAboutToAutoWrap && displayWidth == 1) || displayWidth == 2)) {
- mScreen.setLineWrap(mCursorRow);
- mCursorCol = mLeftMargin;
- if (mCursorRow + 1 < mBottomMargin) {
- mCursorRow++;
- } else {
- scrollDownOneLine();
- }
- }
- } else if (cursorInLastColumn && displayWidth == 2) {
- // The behaviour when a wide character is output with cursor in the last column when
- // autowrap is disabled is not obvious - it's ignored here.
- return;
- }
+ if (autoWrap) {
+ if (cursorInLastColumn && ((mAboutToAutoWrap && displayWidth == 1) || displayWidth == 2)) {
+ mScreen.setLineWrap(mCursorRow);
+ mCursorCol = mLeftMargin;
+ if (mCursorRow + 1 < mBottomMargin) {
+ mCursorRow++;
+ } else {
+ scrollDownOneLine();
+ }
+ }
+ } else if (cursorInLastColumn && displayWidth == 2) {
+ // The behaviour when a wide character is output with cursor in the last column when
+ // autowrap is disabled is not obvious - it's ignored here.
+ return;
+ }
- if (mInsertMode && displayWidth > 0) {
- // Move character to right one space.
- int destCol = mCursorCol + displayWidth;
- if (destCol < mRightMargin) mScreen.blockCopy(mCursorCol, mCursorRow, mRightMargin - destCol, 1, destCol, mCursorRow);
- }
+ if (mInsertMode && displayWidth > 0) {
+ // Move character to right one space.
+ int destCol = mCursorCol + displayWidth;
+ if (destCol < mRightMargin)
+ mScreen.blockCopy(mCursorCol, mCursorRow, mRightMargin - destCol, 1, destCol, mCursorRow);
+ }
- int offsetDueToCombiningChar = ((displayWidth <= 0 && mCursorCol > 0 && !mAboutToAutoWrap) ? 1 : 0);
- mScreen.setChar(mCursorCol - offsetDueToCombiningChar, mCursorRow, codePoint, getStyle());
+ int offsetDueToCombiningChar = ((displayWidth <= 0 && mCursorCol > 0 && !mAboutToAutoWrap) ? 1 : 0);
+ mScreen.setChar(mCursorCol - offsetDueToCombiningChar, mCursorRow, codePoint, getStyle());
- if (autoWrap && displayWidth > 0) mAboutToAutoWrap = (mCursorCol == mRightMargin - displayWidth);
+ if (autoWrap && displayWidth > 0)
+ mAboutToAutoWrap = (mCursorCol == mRightMargin - displayWidth);
- mCursorCol = Math.min(mCursorCol + displayWidth, mRightMargin - 1);
- }
+ mCursorCol = Math.min(mCursorCol + displayWidth, mRightMargin - 1);
+ }
- private void setCursorRow(int row) {
- mCursorRow = row;
- mAboutToAutoWrap = false;
- }
+ private void setCursorRow(int row) {
+ mCursorRow = row;
+ mAboutToAutoWrap = false;
+ }
- private void setCursorCol(int col) {
- mCursorCol = col;
- mAboutToAutoWrap = false;
- }
+ private void setCursorCol(int col) {
+ mCursorCol = col;
+ mAboutToAutoWrap = false;
+ }
- /** Set the cursor mode, but limit it to margins if {@link #DECSET_BIT_ORIGIN_MODE} is enabled. */
- private void setCursorColRespectingOriginMode(int col) {
- setCursorPosition(col, mCursorRow);
- }
+ /** Set the cursor mode, but limit it to margins if {@link #DECSET_BIT_ORIGIN_MODE} is enabled. */
+ private void setCursorColRespectingOriginMode(int col) {
+ setCursorPosition(col, mCursorRow);
+ }
- /** TODO: Better name, distinguished from {@link #setCursorPosition(int, int)} by not regarding origin mode. */
- private void setCursorRowCol(int row, int col) {
- mCursorRow = Math.max(0, Math.min(row, mRows - 1));
- mCursorCol = Math.max(0, Math.min(col, mColumns - 1));
- mAboutToAutoWrap = false;
- }
+ /** TODO: Better name, distinguished from {@link #setCursorPosition(int, int)} by not regarding origin mode. */
+ private void setCursorRowCol(int row, int col) {
+ mCursorRow = Math.max(0, Math.min(row, mRows - 1));
+ mCursorCol = Math.max(0, Math.min(col, mColumns - 1));
+ mAboutToAutoWrap = false;
+ }
- public int getScrollCounter() {
- return mScrollCounter;
- }
+ public int getScrollCounter() {
+ return mScrollCounter;
+ }
- public void clearScrollCounter() {
- mScrollCounter = 0;
- }
+ public void clearScrollCounter() {
+ mScrollCounter = 0;
+ }
- /** Reset terminal state so user can interact with it regardless of present state. */
- public void reset() {
- mCursorStyle = CURSOR_STYLE_BLOCK;
- mArgIndex = 0;
- mContinueSequence = false;
- mEscapeState = ESC_NONE;
- mInsertMode = false;
- mTopMargin = mLeftMargin = 0;
- mBottomMargin = mRows;
- mRightMargin = mColumns;
- mAboutToAutoWrap = false;
- mForeColor = TextStyle.COLOR_INDEX_FOREGROUND;
- mBackColor = TextStyle.COLOR_INDEX_BACKGROUND;
- setDefaultTabStops();
+ /** Reset terminal state so user can interact with it regardless of present state. */
+ public void reset() {
+ mCursorStyle = CURSOR_STYLE_BLOCK;
+ mArgIndex = 0;
+ mContinueSequence = false;
+ mEscapeState = ESC_NONE;
+ mInsertMode = false;
+ mTopMargin = mLeftMargin = 0;
+ mBottomMargin = mRows;
+ mRightMargin = mColumns;
+ mAboutToAutoWrap = false;
+ mForeColor = TextStyle.COLOR_INDEX_FOREGROUND;
+ mBackColor = TextStyle.COLOR_INDEX_BACKGROUND;
+ setDefaultTabStops();
- mUseLineDrawingG0 = mUseLineDrawingG1 = false;
- mUseLineDrawingUsesG0 = true;
+ mUseLineDrawingG0 = mUseLineDrawingG1 = false;
+ mUseLineDrawingUsesG0 = true;
- mSavedStateMain.mSavedCursorRow = mSavedStateMain.mSavedCursorCol = mSavedStateMain.mSavedEffect = mSavedStateMain.mSavedDecFlags = 0;
- mSavedStateAlt.mSavedCursorRow = mSavedStateAlt.mSavedCursorCol = mSavedStateAlt.mSavedEffect = mSavedStateAlt.mSavedDecFlags = 0;
- mCurrentDecSetFlags = 0;
- // Initial wrap-around is not accurate but makes terminal more useful, especially on a small screen:
- setDecsetinternalBit(DECSET_BIT_AUTOWRAP, true);
- setDecsetinternalBit(DECSET_BIT_SHOWING_CURSOR, true);
- mSavedDecSetFlags = mSavedStateMain.mSavedDecFlags = mSavedStateAlt.mSavedDecFlags = mCurrentDecSetFlags;
+ mSavedStateMain.mSavedCursorRow = mSavedStateMain.mSavedCursorCol = mSavedStateMain.mSavedEffect = mSavedStateMain.mSavedDecFlags = 0;
+ mSavedStateAlt.mSavedCursorRow = mSavedStateAlt.mSavedCursorCol = mSavedStateAlt.mSavedEffect = mSavedStateAlt.mSavedDecFlags = 0;
+ mCurrentDecSetFlags = 0;
+ // Initial wrap-around is not accurate but makes terminal more useful, especially on a small screen:
+ setDecsetinternalBit(DECSET_BIT_AUTOWRAP, true);
+ setDecsetinternalBit(DECSET_BIT_SHOWING_CURSOR, true);
+ mSavedDecSetFlags = mSavedStateMain.mSavedDecFlags = mSavedStateAlt.mSavedDecFlags = mCurrentDecSetFlags;
- // XXX: Should we set terminal driver back to IUTF8 with termios?
- mUtf8Index = mUtf8ToFollow = 0;
+ // XXX: Should we set terminal driver back to IUTF8 with termios?
+ mUtf8Index = mUtf8ToFollow = 0;
- mColors.reset();
+ mColors.reset();
mSession.onColorsChanged();
- }
+ }
- public String getSelectedText(int x1, int y1, int x2, int y2) {
- return mScreen.getSelectedText(x1, y1, x2, y2);
- }
+ public String getSelectedText(int x1, int y1, int x2, int y2) {
+ return mScreen.getSelectedText(x1, y1, x2, y2);
+ }
- /** Get the terminal session's title (null if not set). */
- public String getTitle() {
- return mTitle;
- }
+ /** Get the terminal session's title (null if not set). */
+ public String getTitle() {
+ return mTitle;
+ }
- /** Change the terminal session's title. */
- private void setTitle(String newTitle) {
- String oldTitle = mTitle;
- mTitle = newTitle;
- if (!Objects.equals(oldTitle, newTitle)) {
- mSession.titleChanged(oldTitle, newTitle);
- }
- }
+ /** Change the terminal session's title. */
+ private void setTitle(String newTitle) {
+ String oldTitle = mTitle;
+ mTitle = newTitle;
+ if (!Objects.equals(oldTitle, newTitle)) {
+ mSession.titleChanged(oldTitle, newTitle);
+ }
+ }
- /** If DECSET 2004 is set, prefix paste with "\033[200~" and suffix with "\033[201~". */
- public void paste(String text) {
- // First: Always remove escape key and C1 control characters [0x80,0x9F]:
- text = text.replaceAll("(\u001B|[\u0080-\u009F])", "");
- // Then: Implement bracketed paste mode if enabled:
- boolean bracketed = isDecsetInternalBitSet(DECSET_BIT_BRACKETED_PASTE_MODE);
- if (bracketed) mSession.write("\033[200~");
- mSession.write(text);
- if (bracketed) mSession.write("\033[201~");
- }
+ /** If DECSET 2004 is set, prefix paste with "\033[200~" and suffix with "\033[201~". */
+ public void paste(String text) {
+ // First: Always remove escape key and C1 control characters [0x80,0x9F]:
+ text = text.replaceAll("(\u001B|[\u0080-\u009F])", "");
+ // Then: Implement bracketed paste mode if enabled:
+ boolean bracketed = isDecsetInternalBitSet(DECSET_BIT_BRACKETED_PASTE_MODE);
+ if (bracketed) mSession.write("\033[200~");
+ mSession.write(text);
+ if (bracketed) mSession.write("\033[201~");
+ }
- /** http://www.vt100.net/docs/vt510-rm/DECSC */
- static final class SavedScreenState {
- /** Saved state of the cursor position, Used to implement the save/restore cursor position escape sequences. */
- int mSavedCursorRow, mSavedCursorCol;
- int mSavedEffect;
- int mSavedDecFlags;
- boolean mUseLineDrawingG0, mUseLineDrawingG1, mUseLineDrawingUsesG0 = true;
- }
+ /** http://www.vt100.net/docs/vt510-rm/DECSC */
+ static final class SavedScreenState {
+ /** Saved state of the cursor position, Used to implement the save/restore cursor position escape sequences. */
+ int mSavedCursorRow, mSavedCursorCol;
+ int mSavedEffect;
+ int mSavedDecFlags;
+ boolean mUseLineDrawingG0, mUseLineDrawingG1, mUseLineDrawingUsesG0 = true;
+ }
- @Override
- public String toString() {
- return "TerminalEmulator[size=" + mScreen.mColumns + "x" + mScreen.mScreenRows + ", margins={" + mTopMargin + "," + mRightMargin + "," + mBottomMargin
- + "," + mLeftMargin + "}]";
- }
+ @Override
+ public String toString() {
+ return "TerminalEmulator[size=" + mScreen.mColumns + "x" + mScreen.mScreenRows + ", margins={" + mTopMargin + "," + mRightMargin + "," + mBottomMargin
+ + "," + mLeftMargin + "}]";
+ }
}
diff --git a/app/src/main/java/com/termux/terminal/TerminalOutput.java b/app/src/main/java/com/termux/terminal/TerminalOutput.java
index 3266779f..f1c7d03e 100644
--- a/app/src/main/java/com/termux/terminal/TerminalOutput.java
+++ b/app/src/main/java/com/termux/terminal/TerminalOutput.java
@@ -5,23 +5,23 @@ import java.nio.charset.StandardCharsets;
/** A client which receives callbacks from events triggered by feeding input to a {@link TerminalEmulator}. */
public abstract class TerminalOutput {
- /** Write a string using the UTF-8 encoding to the terminal client. */
- public final void write(String data) {
- byte[] bytes = data.getBytes(StandardCharsets.UTF_8);
- write(bytes, 0, bytes.length);
- }
+ /** Write a string using the UTF-8 encoding to the terminal client. */
+ public final void write(String data) {
+ byte[] bytes = data.getBytes(StandardCharsets.UTF_8);
+ write(bytes, 0, bytes.length);
+ }
- /** Write bytes to the terminal client. */
- public abstract void write(byte[] data, int offset, int count);
+ /** Write bytes to the terminal client. */
+ public abstract void write(byte[] data, int offset, int count);
- /** Notify the terminal client that the terminal title has changed. */
- public abstract void titleChanged(String oldTitle, String newTitle);
+ /** Notify the terminal client that the terminal title has changed. */
+ public abstract void titleChanged(String oldTitle, String newTitle);
- /** Notify the terminal client that the terminal title has changed. */
- public abstract void clipboardText(String text);
+ /** Notify the terminal client that the terminal title has changed. */
+ public abstract void clipboardText(String text);
- /** Notify the terminal client that a bell character (ASCII 7, bell, BEL, \a, ^G)) has been received. */
- public abstract void onBell();
+ /** Notify the terminal client that a bell character (ASCII 7, bell, BEL, \a, ^G)) has been received. */
+ public abstract void onBell();
public abstract void onColorsChanged();
diff --git a/app/src/main/java/com/termux/terminal/TerminalRow.java b/app/src/main/java/com/termux/terminal/TerminalRow.java
index a1cdd2bd..eb34d39c 100644
--- a/app/src/main/java/com/termux/terminal/TerminalRow.java
+++ b/app/src/main/java/com/termux/terminal/TerminalRow.java
@@ -4,229 +4,229 @@ import java.util.Arrays;
/**
* A row in a terminal, composed of a fixed number of cells.
- *
+ *
* The text in the row is stored in a char[] array, {@link #mText}, for quick access during rendering.
*/
public final class TerminalRow {
- private static final float SPARE_CAPACITY_FACTOR = 1.5f;
+ private static final float SPARE_CAPACITY_FACTOR = 1.5f;
- /** The number of columns in this terminal row. */
- private final int mColumns;
- /** The text filling this terminal row. */
- public char[] mText;
- /** The number of java char:s used in {@link #mText}. */
- private short mSpaceUsed;
- /** If this row has been line wrapped due to text output at the end of line. */
- boolean mLineWrap;
- /** The style bits of each cell in the row. See {@link TextStyle}. */
- final int[] mStyle;
+ /** The number of columns in this terminal row. */
+ private final int mColumns;
+ /** The text filling this terminal row. */
+ public char[] mText;
+ /** The number of java char:s used in {@link #mText}. */
+ private short mSpaceUsed;
+ /** If this row has been line wrapped due to text output at the end of line. */
+ boolean mLineWrap;
+ /** The style bits of each cell in the row. See {@link TextStyle}. */
+ final int[] mStyle;
- /** Construct a blank row (containing only whitespace, ' ') with a specified style. */
- public TerminalRow(int columns, int style) {
- mColumns = columns;
- mText = new char[(int) (SPARE_CAPACITY_FACTOR * columns)];
- mStyle = new int[columns];
- clear(style);
- }
+ /** Construct a blank row (containing only whitespace, ' ') with a specified style. */
+ public TerminalRow(int columns, int style) {
+ mColumns = columns;
+ mText = new char[(int) (SPARE_CAPACITY_FACTOR * columns)];
+ mStyle = new int[columns];
+ clear(style);
+ }
- /** NOTE: The sourceX2 is exclusive. */
- public void copyInterval(TerminalRow line, int sourceX1, int sourceX2, int destinationX) {
- final int x1 = line.findStartOfColumn(sourceX1);
- final int x2 = line.findStartOfColumn(sourceX2);
- boolean startingFromSecondHalfOfWideChar = (sourceX1 > 0 && line.wideDisplayCharacterStartingAt(sourceX1 - 1));
- final char[] sourceChars = (this == line) ? Arrays.copyOf(line.mText, line.mText.length) : line.mText;
- int latestNonCombiningWidth = 0;
- for (int i = x1; i < x2; i++) {
- char sourceChar = sourceChars[i];
- int codePoint = Character.isHighSurrogate(sourceChar) ? Character.toCodePoint(sourceChar, sourceChars[++i]) : sourceChar;
- if (startingFromSecondHalfOfWideChar) {
- // Just treat copying second half of wide char as copying whitespace.
- codePoint = ' ';
- startingFromSecondHalfOfWideChar = false;
- }
- int w = WcWidth.width(codePoint);
- if (w > 0) {
- destinationX += latestNonCombiningWidth;
- sourceX1 += latestNonCombiningWidth;
- latestNonCombiningWidth = w;
- }
- setChar(destinationX, codePoint, line.getStyle(sourceX1));
- }
- }
+ /** NOTE: The sourceX2 is exclusive. */
+ public void copyInterval(TerminalRow line, int sourceX1, int sourceX2, int destinationX) {
+ final int x1 = line.findStartOfColumn(sourceX1);
+ final int x2 = line.findStartOfColumn(sourceX2);
+ boolean startingFromSecondHalfOfWideChar = (sourceX1 > 0 && line.wideDisplayCharacterStartingAt(sourceX1 - 1));
+ final char[] sourceChars = (this == line) ? Arrays.copyOf(line.mText, line.mText.length) : line.mText;
+ int latestNonCombiningWidth = 0;
+ for (int i = x1; i < x2; i++) {
+ char sourceChar = sourceChars[i];
+ int codePoint = Character.isHighSurrogate(sourceChar) ? Character.toCodePoint(sourceChar, sourceChars[++i]) : sourceChar;
+ if (startingFromSecondHalfOfWideChar) {
+ // Just treat copying second half of wide char as copying whitespace.
+ codePoint = ' ';
+ startingFromSecondHalfOfWideChar = false;
+ }
+ int w = WcWidth.width(codePoint);
+ if (w > 0) {
+ destinationX += latestNonCombiningWidth;
+ sourceX1 += latestNonCombiningWidth;
+ latestNonCombiningWidth = w;
+ }
+ setChar(destinationX, codePoint, line.getStyle(sourceX1));
+ }
+ }
- public int getSpaceUsed() {
- return mSpaceUsed;
- }
+ public int getSpaceUsed() {
+ return mSpaceUsed;
+ }
- /** Note that the column may end of second half of wide character. */
- public int findStartOfColumn(int column) {
- if (column == mColumns) return getSpaceUsed();
+ /** Note that the column may end of second half of wide character. */
+ public int findStartOfColumn(int column) {
+ if (column == mColumns) return getSpaceUsed();
- int currentColumn = 0;
- int currentCharIndex = 0;
- while (true) { // 0<2 1 < 2
- int newCharIndex = currentCharIndex;
- char c = mText[newCharIndex++]; // cci=1, cci=2
- boolean isHigh = Character.isHighSurrogate(c);
- int codePoint = isHigh ? Character.toCodePoint(c, mText[newCharIndex++]) : c;
- int wcwidth = WcWidth.width(codePoint); // 1, 2
- if (wcwidth > 0) {
- currentColumn += wcwidth;
- if (currentColumn == column) {
- while (newCharIndex < mSpaceUsed) {
- // Skip combining chars.
- if (Character.isHighSurrogate(mText[newCharIndex])) {
- if (WcWidth.width(Character.toCodePoint(mText[newCharIndex], mText[newCharIndex + 1])) <= 0) {
- newCharIndex += 2;
- } else {
- break;
- }
- } else if (WcWidth.width(mText[newCharIndex]) <= 0) {
- newCharIndex++;
- } else {
- break;
- }
- }
- return newCharIndex;
- } else if (currentColumn > column) {
- // Wide column going past end.
- return currentCharIndex;
- }
- }
- currentCharIndex = newCharIndex;
- }
- }
+ int currentColumn = 0;
+ int currentCharIndex = 0;
+ while (true) { // 0<2 1 < 2
+ int newCharIndex = currentCharIndex;
+ char c = mText[newCharIndex++]; // cci=1, cci=2
+ boolean isHigh = Character.isHighSurrogate(c);
+ int codePoint = isHigh ? Character.toCodePoint(c, mText[newCharIndex++]) : c;
+ int wcwidth = WcWidth.width(codePoint); // 1, 2
+ if (wcwidth > 0) {
+ currentColumn += wcwidth;
+ if (currentColumn == column) {
+ while (newCharIndex < mSpaceUsed) {
+ // Skip combining chars.
+ if (Character.isHighSurrogate(mText[newCharIndex])) {
+ if (WcWidth.width(Character.toCodePoint(mText[newCharIndex], mText[newCharIndex + 1])) <= 0) {
+ newCharIndex += 2;
+ } else {
+ break;
+ }
+ } else if (WcWidth.width(mText[newCharIndex]) <= 0) {
+ newCharIndex++;
+ } else {
+ break;
+ }
+ }
+ return newCharIndex;
+ } else if (currentColumn > column) {
+ // Wide column going past end.
+ return currentCharIndex;
+ }
+ }
+ currentCharIndex = newCharIndex;
+ }
+ }
- private boolean wideDisplayCharacterStartingAt(int column) {
- for (int currentCharIndex = 0, currentColumn = 0; currentCharIndex < mSpaceUsed;) {
- char c = mText[currentCharIndex++];
- int codePoint = Character.isHighSurrogate(c) ? Character.toCodePoint(c, mText[currentCharIndex++]) : c;
- int wcwidth = WcWidth.width(codePoint);
- if (wcwidth > 0) {
- if (currentColumn == column && wcwidth == 2) return true;
- currentColumn += wcwidth;
- if (currentColumn > column) return false;
- }
- }
- return false;
- }
+ private boolean wideDisplayCharacterStartingAt(int column) {
+ for (int currentCharIndex = 0, currentColumn = 0; currentCharIndex < mSpaceUsed; ) {
+ char c = mText[currentCharIndex++];
+ int codePoint = Character.isHighSurrogate(c) ? Character.toCodePoint(c, mText[currentCharIndex++]) : c;
+ int wcwidth = WcWidth.width(codePoint);
+ if (wcwidth > 0) {
+ if (currentColumn == column && wcwidth == 2) return true;
+ currentColumn += wcwidth;
+ if (currentColumn > column) return false;
+ }
+ }
+ return false;
+ }
- public void clear(int style) {
- Arrays.fill(mText, ' ');
- Arrays.fill(mStyle, style);
- mSpaceUsed = (short) mColumns;
- }
+ public void clear(int style) {
+ Arrays.fill(mText, ' ');
+ Arrays.fill(mStyle, style);
+ mSpaceUsed = (short) mColumns;
+ }
- // https://github.com/steven676/Android-Terminal-Emulator/commit/9a47042620bec87617f0b4f5d50568535668fe26
- public void setChar(int columnToSet, int codePoint, int style) {
- mStyle[columnToSet] = style;
+ // https://github.com/steven676/Android-Terminal-Emulator/commit/9a47042620bec87617f0b4f5d50568535668fe26
+ public void setChar(int columnToSet, int codePoint, int style) {
+ mStyle[columnToSet] = style;
- final int newCodePointDisplayWidth = WcWidth.width(codePoint);
- final boolean newIsCombining = newCodePointDisplayWidth <= 0;
+ final int newCodePointDisplayWidth = WcWidth.width(codePoint);
+ final boolean newIsCombining = newCodePointDisplayWidth <= 0;
- boolean wasExtraColForWideChar = (columnToSet > 0) && wideDisplayCharacterStartingAt(columnToSet - 1);
+ boolean wasExtraColForWideChar = (columnToSet > 0) && wideDisplayCharacterStartingAt(columnToSet - 1);
- if (newIsCombining) {
- // When standing at second half of wide character and inserting combining:
- if (wasExtraColForWideChar) columnToSet--;
- } else {
- // Check if we are overwriting the second half of a wide character starting at the previous column:
- if (wasExtraColForWideChar) setChar(columnToSet - 1, ' ', style);
- // Check if we are overwriting the first half of a wide character starting at the next column:
- boolean overwritingWideCharInNextColumn = newCodePointDisplayWidth == 2 && wideDisplayCharacterStartingAt(columnToSet + 1);
- if (overwritingWideCharInNextColumn) setChar(columnToSet + 1, ' ', style);
- }
+ if (newIsCombining) {
+ // When standing at second half of wide character and inserting combining:
+ if (wasExtraColForWideChar) columnToSet--;
+ } else {
+ // Check if we are overwriting the second half of a wide character starting at the previous column:
+ if (wasExtraColForWideChar) setChar(columnToSet - 1, ' ', style);
+ // Check if we are overwriting the first half of a wide character starting at the next column:
+ boolean overwritingWideCharInNextColumn = newCodePointDisplayWidth == 2 && wideDisplayCharacterStartingAt(columnToSet + 1);
+ if (overwritingWideCharInNextColumn) setChar(columnToSet + 1, ' ', style);
+ }
- char[] text = mText;
- final int oldStartOfColumnIndex = findStartOfColumn(columnToSet);
- final int oldCodePointDisplayWidth = WcWidth.width(text, oldStartOfColumnIndex);
+ char[] text = mText;
+ final int oldStartOfColumnIndex = findStartOfColumn(columnToSet);
+ final int oldCodePointDisplayWidth = WcWidth.width(text, oldStartOfColumnIndex);
- // Get the number of elements in the mText array this column uses now
- int oldCharactersUsedForColumn;
- if (columnToSet + oldCodePointDisplayWidth < mColumns) {
- oldCharactersUsedForColumn = findStartOfColumn(columnToSet + oldCodePointDisplayWidth) - oldStartOfColumnIndex;
- } else {
- // Last character.
- oldCharactersUsedForColumn = mSpaceUsed - oldStartOfColumnIndex;
- }
+ // Get the number of elements in the mText array this column uses now
+ int oldCharactersUsedForColumn;
+ if (columnToSet + oldCodePointDisplayWidth < mColumns) {
+ oldCharactersUsedForColumn = findStartOfColumn(columnToSet + oldCodePointDisplayWidth) - oldStartOfColumnIndex;
+ } else {
+ // Last character.
+ oldCharactersUsedForColumn = mSpaceUsed - oldStartOfColumnIndex;
+ }
- // Find how many chars this column will need
- int newCharactersUsedForColumn = Character.charCount(codePoint);
- if (newIsCombining) {
- // Combining characters are added to the contents of the column instead of overwriting them, so that they
- // modify the existing contents.
- // FIXME: Put a limit of combining characters.
- // FIXME: Unassigned characters also get width=0.
- newCharactersUsedForColumn += oldCharactersUsedForColumn;
- }
+ // Find how many chars this column will need
+ int newCharactersUsedForColumn = Character.charCount(codePoint);
+ if (newIsCombining) {
+ // Combining characters are added to the contents of the column instead of overwriting them, so that they
+ // modify the existing contents.
+ // FIXME: Put a limit of combining characters.
+ // FIXME: Unassigned characters also get width=0.
+ newCharactersUsedForColumn += oldCharactersUsedForColumn;
+ }
- int oldNextColumnIndex = oldStartOfColumnIndex + oldCharactersUsedForColumn;
- int newNextColumnIndex = oldStartOfColumnIndex + newCharactersUsedForColumn;
+ int oldNextColumnIndex = oldStartOfColumnIndex + oldCharactersUsedForColumn;
+ int newNextColumnIndex = oldStartOfColumnIndex + newCharactersUsedForColumn;
- final int javaCharDifference = newCharactersUsedForColumn - oldCharactersUsedForColumn;
- if (javaCharDifference > 0) {
- // Shift the rest of the line right.
- int oldCharactersAfterColumn = mSpaceUsed - oldNextColumnIndex;
- if (mSpaceUsed + javaCharDifference > text.length) {
- // We need to grow the array
- char[] newText = new char[text.length + mColumns];
- System.arraycopy(text, 0, newText, 0, oldStartOfColumnIndex + oldCharactersUsedForColumn);
- System.arraycopy(text, oldNextColumnIndex, newText, newNextColumnIndex, oldCharactersAfterColumn);
- mText = text = newText;
- } else {
- System.arraycopy(text, oldNextColumnIndex, text, newNextColumnIndex, oldCharactersAfterColumn);
- }
- } else if (javaCharDifference < 0) {
- // Shift the rest of the line left.
- System.arraycopy(text, oldNextColumnIndex, text, newNextColumnIndex, mSpaceUsed - oldNextColumnIndex);
- }
- mSpaceUsed += javaCharDifference;
+ final int javaCharDifference = newCharactersUsedForColumn - oldCharactersUsedForColumn;
+ if (javaCharDifference > 0) {
+ // Shift the rest of the line right.
+ int oldCharactersAfterColumn = mSpaceUsed - oldNextColumnIndex;
+ if (mSpaceUsed + javaCharDifference > text.length) {
+ // We need to grow the array
+ char[] newText = new char[text.length + mColumns];
+ System.arraycopy(text, 0, newText, 0, oldStartOfColumnIndex + oldCharactersUsedForColumn);
+ System.arraycopy(text, oldNextColumnIndex, newText, newNextColumnIndex, oldCharactersAfterColumn);
+ mText = text = newText;
+ } else {
+ System.arraycopy(text, oldNextColumnIndex, text, newNextColumnIndex, oldCharactersAfterColumn);
+ }
+ } else if (javaCharDifference < 0) {
+ // Shift the rest of the line left.
+ System.arraycopy(text, oldNextColumnIndex, text, newNextColumnIndex, mSpaceUsed - oldNextColumnIndex);
+ }
+ mSpaceUsed += javaCharDifference;
- // Store char. A combining character is stored at the end of the existing contents so that it modifies them:
- //noinspection ResultOfMethodCallIgnored - since we already now how many java chars is used.
- Character.toChars(codePoint, text, oldStartOfColumnIndex + (newIsCombining ? oldCharactersUsedForColumn : 0));
+ // Store char. A combining character is stored at the end of the existing contents so that it modifies them:
+ //noinspection ResultOfMethodCallIgnored - since we already now how many java chars is used.
+ Character.toChars(codePoint, text, oldStartOfColumnIndex + (newIsCombining ? oldCharactersUsedForColumn : 0));
- if (oldCodePointDisplayWidth == 2 && newCodePointDisplayWidth == 1) {
- // Replace second half of wide char with a space. Which mean that we actually add a ' ' java character.
- if (mSpaceUsed + 1 > text.length) {
- char[] newText = new char[text.length + mColumns];
- System.arraycopy(text, 0, newText, 0, newNextColumnIndex);
- System.arraycopy(text, newNextColumnIndex, newText, newNextColumnIndex + 1, mSpaceUsed - newNextColumnIndex);
- mText = text = newText;
- } else {
- System.arraycopy(text, newNextColumnIndex, text, newNextColumnIndex + 1, mSpaceUsed - newNextColumnIndex);
- }
- text[newNextColumnIndex] = ' ';
+ if (oldCodePointDisplayWidth == 2 && newCodePointDisplayWidth == 1) {
+ // Replace second half of wide char with a space. Which mean that we actually add a ' ' java character.
+ if (mSpaceUsed + 1 > text.length) {
+ char[] newText = new char[text.length + mColumns];
+ System.arraycopy(text, 0, newText, 0, newNextColumnIndex);
+ System.arraycopy(text, newNextColumnIndex, newText, newNextColumnIndex + 1, mSpaceUsed - newNextColumnIndex);
+ mText = text = newText;
+ } else {
+ System.arraycopy(text, newNextColumnIndex, text, newNextColumnIndex + 1, mSpaceUsed - newNextColumnIndex);
+ }
+ text[newNextColumnIndex] = ' ';
- ++mSpaceUsed;
- } else if (oldCodePointDisplayWidth == 1 && newCodePointDisplayWidth == 2) {
- if (columnToSet == mColumns - 1) {
- throw new IllegalArgumentException("Cannot put wide character in last column");
- } else if (columnToSet == mColumns - 2) {
- // Truncate the line to the second part of this wide char:
- mSpaceUsed = (short) newNextColumnIndex;
- } else {
- // Overwrite the contents of the next column, which mean we actually remove java characters. Due to the
- // check at the beginning of this method we know that we are not overwriting a wide char.
- int newNextNextColumnIndex = newNextColumnIndex + (Character.isHighSurrogate(mText[newNextColumnIndex]) ? 2 : 1);
- int nextLen = newNextNextColumnIndex - newNextColumnIndex;
+ ++mSpaceUsed;
+ } else if (oldCodePointDisplayWidth == 1 && newCodePointDisplayWidth == 2) {
+ if (columnToSet == mColumns - 1) {
+ throw new IllegalArgumentException("Cannot put wide character in last column");
+ } else if (columnToSet == mColumns - 2) {
+ // Truncate the line to the second part of this wide char:
+ mSpaceUsed = (short) newNextColumnIndex;
+ } else {
+ // Overwrite the contents of the next column, which mean we actually remove java characters. Due to the
+ // check at the beginning of this method we know that we are not overwriting a wide char.
+ int newNextNextColumnIndex = newNextColumnIndex + (Character.isHighSurrogate(mText[newNextColumnIndex]) ? 2 : 1);
+ int nextLen = newNextNextColumnIndex - newNextColumnIndex;
- // Shift the array leftwards.
- System.arraycopy(text, newNextNextColumnIndex, text, newNextColumnIndex, mSpaceUsed - newNextNextColumnIndex);
- mSpaceUsed -= nextLen;
- }
- }
- }
+ // Shift the array leftwards.
+ System.arraycopy(text, newNextNextColumnIndex, text, newNextColumnIndex, mSpaceUsed - newNextNextColumnIndex);
+ mSpaceUsed -= nextLen;
+ }
+ }
+ }
- boolean isBlank() {
- for (int charIndex = 0, charLen = getSpaceUsed(); charIndex < charLen; charIndex++)
- if (mText[charIndex] != ' ') return false;
- return true;
- }
+ boolean isBlank() {
+ for (int charIndex = 0, charLen = getSpaceUsed(); charIndex < charLen; charIndex++)
+ if (mText[charIndex] != ' ') return false;
+ return true;
+ }
- public final int getStyle(int column) {
- return mStyle[column];
- }
+ public final int getStyle(int column) {
+ return mStyle[column];
+ }
}
diff --git a/app/src/main/java/com/termux/terminal/TerminalSession.java b/app/src/main/java/com/termux/terminal/TerminalSession.java
index 4df0d3fa..41ed12b1 100644
--- a/app/src/main/java/com/termux/terminal/TerminalSession.java
+++ b/app/src/main/java/com/termux/terminal/TerminalSession.java
@@ -19,202 +19,200 @@ import java.util.UUID;
/**
* A terminal session, consisting of a process coupled to a terminal interface.
- *
+ *
* The subprocess will be executed by the constructor, and when the size is made known by a call to
* {@link #updateSize(int, int)} terminal emulation will begin and threads will be spawned to handle the subprocess I/O.
* All terminal emulation and callback methods will be performed on the main thread.
- *
+ *
* The child process may be exited forcefully by using the {@link #finishIfRunning()} method.
- *
+ *
* NOTE: The terminal session may outlive the EmulatorView, so be careful with callbacks!
*/
public final class TerminalSession extends TerminalOutput {
- /** Callback to be invoked when a {@link TerminalSession} changes. */
- public interface SessionChangedCallback {
- void onTextChanged(TerminalSession changedSession);
+ /** Callback to be invoked when a {@link TerminalSession} changes. */
+ public interface SessionChangedCallback {
+ void onTextChanged(TerminalSession changedSession);
- void onTitleChanged(TerminalSession changedSession);
+ void onTitleChanged(TerminalSession changedSession);
- void onSessionFinished(TerminalSession finishedSession);
+ void onSessionFinished(TerminalSession finishedSession);
- void onClipboardText(TerminalSession session, String text);
+ void onClipboardText(TerminalSession session, String text);
- void onBell(TerminalSession session);
+ void onBell(TerminalSession session);
void onColorsChanged(TerminalSession session);
- }
+ }
- private static FileDescriptor wrapFileDescriptor(int fileDescriptor) {
- FileDescriptor result = new FileDescriptor();
- try {
- Field descriptorField;
- try {
- descriptorField = FileDescriptor.class.getDeclaredField("descriptor");
- } catch (NoSuchFieldException e) {
- // For desktop java:
- descriptorField = FileDescriptor.class.getDeclaredField("fd");
- }
- descriptorField.setAccessible(true);
- descriptorField.set(result, fileDescriptor);
- } catch (NoSuchFieldException | IllegalAccessException | IllegalArgumentException e) {
- Log.wtf(EmulatorDebug.LOG_TAG, "Error accessing FileDescriptor#descriptor private field", e);
- System.exit(1);
- }
- return result;
- }
+ private static FileDescriptor wrapFileDescriptor(int fileDescriptor) {
+ FileDescriptor result = new FileDescriptor();
+ try {
+ Field descriptorField;
+ try {
+ descriptorField = FileDescriptor.class.getDeclaredField("descriptor");
+ } catch (NoSuchFieldException e) {
+ // For desktop java:
+ descriptorField = FileDescriptor.class.getDeclaredField("fd");
+ }
+ descriptorField.setAccessible(true);
+ descriptorField.set(result, fileDescriptor);
+ } catch (NoSuchFieldException | IllegalAccessException | IllegalArgumentException e) {
+ Log.wtf(EmulatorDebug.LOG_TAG, "Error accessing FileDescriptor#descriptor private field", e);
+ System.exit(1);
+ }
+ return result;
+ }
- private static final int MSG_NEW_INPUT = 1;
- private static final int MSG_PROCESS_EXITED = 4;
+ private static final int MSG_NEW_INPUT = 1;
+ private static final int MSG_PROCESS_EXITED = 4;
- public final String mHandle = UUID.randomUUID().toString();
+ public final String mHandle = UUID.randomUUID().toString();
- TerminalEmulator mEmulator;
+ TerminalEmulator mEmulator;
- /**
- * A queue written to from a separate thread when the process outputs, and read by main thread to process by
- * terminal emulator.
- */
- final ByteQueue mProcessToTerminalIOQueue = new ByteQueue(4096);
- /**
- * A queue written to from the main thread due to user interaction, and read by another thread which forwards by
- * writing to the {@link #mTerminalFileDescriptor}.
- */
- final ByteQueue mTerminalToProcessIOQueue = new ByteQueue(4096);
- /** Buffer to write translate code points into utf8 before writing to mTerminalToProcessIOQueue */
- private final byte[] mUtf8InputBuffer = new byte[5];
+ /**
+ * A queue written to from a separate thread when the process outputs, and read by main thread to process by
+ * terminal emulator.
+ */
+ final ByteQueue mProcessToTerminalIOQueue = new ByteQueue(4096);
+ /**
+ * A queue written to from the main thread due to user interaction, and read by another thread which forwards by
+ * writing to the {@link #mTerminalFileDescriptor}.
+ */
+ final ByteQueue mTerminalToProcessIOQueue = new ByteQueue(4096);
+ /** Buffer to write translate code points into utf8 before writing to mTerminalToProcessIOQueue */
+ private final byte[] mUtf8InputBuffer = new byte[5];
- /** Callback which gets notified when a session finishes or changes title. */
- final SessionChangedCallback mChangeCallback;
+ /** Callback which gets notified when a session finishes or changes title. */
+ final SessionChangedCallback mChangeCallback;
- /** The pid of the shell process. 0 if not started and -1 if finished running. */
- int mShellPid;
+ /** The pid of the shell process. 0 if not started and -1 if finished running. */
+ int mShellPid;
- /** The exit status of the shell process. Only valid if ${@link #mShellPid} is -1. */
- int mShellExitStatus;
+ /** The exit status of the shell process. Only valid if ${@link #mShellPid} is -1. */
+ int mShellExitStatus;
- /**
- * The file descriptor referencing the master half of a pseudo-terminal pair, resulting from calling
- * {@link JNI#createSubprocess(String, String, String[], String[], int[], int, int)}.
- */
- private int mTerminalFileDescriptor;
+ /**
+ * The file descriptor referencing the master half of a pseudo-terminal pair, resulting from calling
+ * {@link JNI#createSubprocess(String, String, String[], String[], int[], int, int)}.
+ */
+ private int mTerminalFileDescriptor;
- /** Set by the application for user identification of session, not by terminal. */
- public String mSessionName;
+ /** Set by the application for user identification of session, not by terminal. */
+ public String mSessionName;
- @SuppressLint("HandlerLeak")
- final Handler mMainThreadHandler = new Handler() {
- final byte[] mReceiveBuffer = new byte[4 * 1024];
+ @SuppressLint("HandlerLeak")
+ final Handler mMainThreadHandler = new Handler() {
+ final byte[] mReceiveBuffer = new byte[4 * 1024];
- @Override
- public void handleMessage(Message msg) {
- if (msg.what == MSG_NEW_INPUT && isRunning()) {
- int bytesRead = mProcessToTerminalIOQueue.read(mReceiveBuffer, false);
- if (bytesRead > 0) {
- mEmulator.append(mReceiveBuffer, bytesRead);
- notifyScreenUpdate();
- }
- } else if (msg.what == MSG_PROCESS_EXITED) {
- int exitCode = (Integer) msg.obj;
- cleanupResources(exitCode);
- mChangeCallback.onSessionFinished(TerminalSession.this);
+ @Override
+ public void handleMessage(Message msg) {
+ if (msg.what == MSG_NEW_INPUT && isRunning()) {
+ int bytesRead = mProcessToTerminalIOQueue.read(mReceiveBuffer, false);
+ if (bytesRead > 0) {
+ mEmulator.append(mReceiveBuffer, bytesRead);
+ notifyScreenUpdate();
+ }
+ } else if (msg.what == MSG_PROCESS_EXITED) {
+ int exitCode = (Integer) msg.obj;
+ cleanupResources(exitCode);
+ mChangeCallback.onSessionFinished(TerminalSession.this);
- String exitDescription = "\r\n[Process completed";
- if (exitCode > 0) {
- // Non-zero process exit.
- exitDescription += " with code " + exitCode;
- } else if (exitCode < 0) {
- // Negated signal.
- exitDescription += " with signal " + (-exitCode);
- }
- exitDescription += " - press Enter to close]";
+ String exitDescription = "\r\n[Process completed";
+ if (exitCode > 0) {
+ // Non-zero process exit.
+ exitDescription += " with code " + exitCode;
+ } else if (exitCode < 0) {
+ // Negated signal.
+ exitDescription += " with signal " + (-exitCode);
+ }
+ exitDescription += " - press Enter to close]";
- byte[] bytesToWrite = exitDescription.getBytes(StandardCharsets.UTF_8);
- mEmulator.append(bytesToWrite, bytesToWrite.length);
- notifyScreenUpdate();
- }
- }
- };
+ byte[] bytesToWrite = exitDescription.getBytes(StandardCharsets.UTF_8);
+ mEmulator.append(bytesToWrite, bytesToWrite.length);
+ notifyScreenUpdate();
+ }
+ }
+ };
- private final String mShellPath;
- private final String mCwd;
- private final String[] mArgs;
- private final String[] mEnv;
+ private final String mShellPath;
+ private final String mCwd;
+ private final String[] mArgs;
+ private final String[] mEnv;
- public TerminalSession(String shellPath, String cwd, String[] args, String[] env, SessionChangedCallback changeCallback) {
- mChangeCallback = changeCallback;
+ public TerminalSession(String shellPath, String cwd, String[] args, String[] env, SessionChangedCallback changeCallback) {
+ mChangeCallback = changeCallback;
- this.mShellPath = shellPath;
- this.mCwd = cwd;
- this.mArgs = args;
- this.mEnv = env;
- }
+ this.mShellPath = shellPath;
+ this.mCwd = cwd;
+ this.mArgs = args;
+ this.mEnv = env;
+ }
- /** Inform the attached pty of the new size and reflow or initialize the emulator. */
- public void updateSize(int columns, int rows) {
- if (mEmulator == null) {
- initializeEmulator(columns, rows);
- } else {
- JNI.setPtyWindowSize(mTerminalFileDescriptor, rows, columns);
- mEmulator.resize(columns, rows);
- }
- }
+ /** Inform the attached pty of the new size and reflow or initialize the emulator. */
+ public void updateSize(int columns, int rows) {
+ if (mEmulator == null) {
+ initializeEmulator(columns, rows);
+ } else {
+ JNI.setPtyWindowSize(mTerminalFileDescriptor, rows, columns);
+ mEmulator.resize(columns, rows);
+ }
+ }
- /** The terminal title as set through escape sequences or null if none set. */
- public String getTitle() {
- return (mEmulator == null) ? null : mEmulator.getTitle();
- }
+ /** The terminal title as set through escape sequences or null if none set. */
+ public String getTitle() {
+ return (mEmulator == null) ? null : mEmulator.getTitle();
+ }
- /**
- * Set the terminal emulator's window size and start terminal emulation.
- *
- * @param columns
- * The number of columns in the terminal window.
- * @param rows
- * The number of rows in the terminal window.
- */
- public void initializeEmulator(int columns, int rows) {
- mEmulator = new TerminalEmulator(this, columns, rows, /* transcript= */5000);
+ /**
+ * Set the terminal emulator's window size and start terminal emulation.
+ *
+ * @param columns The number of columns in the terminal window.
+ * @param rows The number of rows in the terminal window.
+ */
+ public void initializeEmulator(int columns, int rows) {
+ mEmulator = new TerminalEmulator(this, columns, rows, /* transcript= */5000);
- int[] processId = new int[1];
- mTerminalFileDescriptor = JNI.createSubprocess(mShellPath, mCwd, mArgs, mEnv, processId, rows, columns);
- mShellPid = processId[0];
+ int[] processId = new int[1];
+ mTerminalFileDescriptor = JNI.createSubprocess(mShellPath, mCwd, mArgs, mEnv, processId, rows, columns);
+ mShellPid = processId[0];
- final FileDescriptor terminalFileDescriptorWrapped = wrapFileDescriptor(mTerminalFileDescriptor);
+ final FileDescriptor terminalFileDescriptorWrapped = wrapFileDescriptor(mTerminalFileDescriptor);
- new Thread("TermSessionInputReader[pid=" + mShellPid + "]") {
- @Override
- public void run() {
- try (InputStream termIn = new FileInputStream(terminalFileDescriptorWrapped)) {
- final byte[] buffer = new byte[4096];
- while (true) {
- int read = termIn.read(buffer);
- if (read == -1) return;
- if (!mProcessToTerminalIOQueue.write(buffer, 0, read)) return;
- mMainThreadHandler.sendEmptyMessage(MSG_NEW_INPUT);
- }
- } catch (Exception e) {
- // Ignore, just shutting down.
- }
- }
- }.start();
+ new Thread("TermSessionInputReader[pid=" + mShellPid + "]") {
+ @Override
+ public void run() {
+ try (InputStream termIn = new FileInputStream(terminalFileDescriptorWrapped)) {
+ final byte[] buffer = new byte[4096];
+ while (true) {
+ int read = termIn.read(buffer);
+ if (read == -1) return;
+ if (!mProcessToTerminalIOQueue.write(buffer, 0, read)) return;
+ mMainThreadHandler.sendEmptyMessage(MSG_NEW_INPUT);
+ }
+ } catch (Exception e) {
+ // Ignore, just shutting down.
+ }
+ }
+ }.start();
- new Thread("TermSessionOutputWriter[pid=" + mShellPid + "]") {
- @Override
- public void run() {
- final byte[] buffer = new byte[4096];
- try (FileOutputStream termOut = new FileOutputStream(terminalFileDescriptorWrapped)) {
- while (true) {
- int bytesToWrite = mTerminalToProcessIOQueue.read(buffer, true);
- if (bytesToWrite == -1) return;
- termOut.write(buffer, 0, bytesToWrite);
- }
- } catch (IOException e) {
- // Ignore.
- }
- }
- }.start();
+ new Thread("TermSessionOutputWriter[pid=" + mShellPid + "]") {
+ @Override
+ public void run() {
+ final byte[] buffer = new byte[4096];
+ try (FileOutputStream termOut = new FileOutputStream(terminalFileDescriptorWrapped)) {
+ while (true) {
+ int bytesToWrite = mTerminalToProcessIOQueue.read(buffer, true);
+ if (bytesToWrite == -1) return;
+ termOut.write(buffer, 0, bytesToWrite);
+ }
+ } catch (IOException e) {
+ // Ignore.
+ }
+ }
+ }.start();
new Thread("TermSessionWaiter[pid=" + mShellPid + "]") {
@Override
@@ -226,63 +224,63 @@ public final class TerminalSession extends TerminalOutput {
}
- /** Write data to the shell process. */
- @Override
- public void write(byte[] data, int offset, int count) {
- if (mShellPid > 0) mTerminalToProcessIOQueue.write(data, offset, count);
- }
+ /** Write data to the shell process. */
+ @Override
+ public void write(byte[] data, int offset, int count) {
+ if (mShellPid > 0) mTerminalToProcessIOQueue.write(data, offset, count);
+ }
- /** Write the Unicode code point to the terminal encoded in UTF-8. */
- public void writeCodePoint(boolean prependEscape, int codePoint) {
- if (codePoint > 1114111 || (codePoint >= 0xD800 && codePoint <= 0xDFFF)) {
- // 1114111 (= 2**16 + 1024**2 - 1) is the highest code point, [0xD800,0xDFFF] is the surrogate range.
- throw new IllegalArgumentException("Invalid code point: " + codePoint);
- }
+ /** Write the Unicode code point to the terminal encoded in UTF-8. */
+ public void writeCodePoint(boolean prependEscape, int codePoint) {
+ if (codePoint > 1114111 || (codePoint >= 0xD800 && codePoint <= 0xDFFF)) {
+ // 1114111 (= 2**16 + 1024**2 - 1) is the highest code point, [0xD800,0xDFFF] is the surrogate range.
+ throw new IllegalArgumentException("Invalid code point: " + codePoint);
+ }
- int bufferPosition = 0;
- if (prependEscape) mUtf8InputBuffer[bufferPosition++] = 27;
+ int bufferPosition = 0;
+ if (prependEscape) mUtf8InputBuffer[bufferPosition++] = 27;
- if (codePoint <= /* 7 bits */0b1111111) {
- mUtf8InputBuffer[bufferPosition++] = (byte) codePoint;
- } else if (codePoint <= /* 11 bits */0b11111111111) {
- /* 110xxxxx leading byte with leading 5 bits */
- mUtf8InputBuffer[bufferPosition++] = (byte) (0b11000000 | (codePoint >> 6));
+ if (codePoint <= /* 7 bits */0b1111111) {
+ mUtf8InputBuffer[bufferPosition++] = (byte) codePoint;
+ } else if (codePoint <= /* 11 bits */0b11111111111) {
+ /* 110xxxxx leading byte with leading 5 bits */
+ mUtf8InputBuffer[bufferPosition++] = (byte) (0b11000000 | (codePoint >> 6));
/* 10xxxxxx continuation byte with following 6 bits */
- mUtf8InputBuffer[bufferPosition++] = (byte) (0b10000000 | (codePoint & 0b111111));
- } else if (codePoint <= /* 16 bits */0b1111111111111111) {
+ mUtf8InputBuffer[bufferPosition++] = (byte) (0b10000000 | (codePoint & 0b111111));
+ } else if (codePoint <= /* 16 bits */0b1111111111111111) {
/* 1110xxxx leading byte with leading 4 bits */
- mUtf8InputBuffer[bufferPosition++] = (byte) (0b11100000 | (codePoint >> 12));
+ mUtf8InputBuffer[bufferPosition++] = (byte) (0b11100000 | (codePoint >> 12));
/* 10xxxxxx continuation byte with following 6 bits */
- mUtf8InputBuffer[bufferPosition++] = (byte) (0b10000000 | ((codePoint >> 6) & 0b111111));
+ mUtf8InputBuffer[bufferPosition++] = (byte) (0b10000000 | ((codePoint >> 6) & 0b111111));
/* 10xxxxxx continuation byte with following 6 bits */
- mUtf8InputBuffer[bufferPosition++] = (byte) (0b10000000 | (codePoint & 0b111111));
- } else { /* We have checked codePoint <= 1114111 above, so we have max 21 bits = 0b111111111111111111111 */
+ mUtf8InputBuffer[bufferPosition++] = (byte) (0b10000000 | (codePoint & 0b111111));
+ } else { /* We have checked codePoint <= 1114111 above, so we have max 21 bits = 0b111111111111111111111 */
/* 11110xxx leading byte with leading 3 bits */
- mUtf8InputBuffer[bufferPosition++] = (byte) (0b11110000 | (codePoint >> 18));
+ mUtf8InputBuffer[bufferPosition++] = (byte) (0b11110000 | (codePoint >> 18));
/* 10xxxxxx continuation byte with following 6 bits */
- mUtf8InputBuffer[bufferPosition++] = (byte) (0b10000000 | ((codePoint >> 12) & 0b111111));
+ mUtf8InputBuffer[bufferPosition++] = (byte) (0b10000000 | ((codePoint >> 12) & 0b111111));
/* 10xxxxxx continuation byte with following 6 bits */
- mUtf8InputBuffer[bufferPosition++] = (byte) (0b10000000 | ((codePoint >> 6) & 0b111111));
+ mUtf8InputBuffer[bufferPosition++] = (byte) (0b10000000 | ((codePoint >> 6) & 0b111111));
/* 10xxxxxx continuation byte with following 6 bits */
- mUtf8InputBuffer[bufferPosition++] = (byte) (0b10000000 | (codePoint & 0b111111));
- }
- write(mUtf8InputBuffer, 0, bufferPosition);
- }
+ mUtf8InputBuffer[bufferPosition++] = (byte) (0b10000000 | (codePoint & 0b111111));
+ }
+ write(mUtf8InputBuffer, 0, bufferPosition);
+ }
- public TerminalEmulator getEmulator() {
- return mEmulator;
- }
+ public TerminalEmulator getEmulator() {
+ return mEmulator;
+ }
- /** Notify the {@link #mChangeCallback} that the screen has changed. */
- protected void notifyScreenUpdate() {
- mChangeCallback.onTextChanged(this);
- }
+ /** Notify the {@link #mChangeCallback} that the screen has changed. */
+ protected void notifyScreenUpdate() {
+ mChangeCallback.onTextChanged(this);
+ }
- /** Reset state for terminal emulator state. */
- public void reset() {
- mEmulator.reset();
- notifyScreenUpdate();
- }
+ /** Reset state for terminal emulator state. */
+ public void reset() {
+ mEmulator.reset();
+ notifyScreenUpdate();
+ }
/** Finish this terminal session by sending SIGKILL to the shell. */
public void finishIfRunning() {
@@ -295,48 +293,50 @@ public final class TerminalSession extends TerminalOutput {
}
}
- /** Cleanup resources when the process exits. */
- void cleanupResources(int exitStatus) {
- synchronized (this) {
- mShellPid = -1;
- mShellExitStatus = exitStatus;
- }
+ /** Cleanup resources when the process exits. */
+ void cleanupResources(int exitStatus) {
+ synchronized (this) {
+ mShellPid = -1;
+ mShellExitStatus = exitStatus;
+ }
- // Stop the reader and writer threads, and close the I/O streams
- mTerminalToProcessIOQueue.close();
- mProcessToTerminalIOQueue.close();
- JNI.close(mTerminalFileDescriptor);
- }
+ // Stop the reader and writer threads, and close the I/O streams
+ mTerminalToProcessIOQueue.close();
+ mProcessToTerminalIOQueue.close();
+ JNI.close(mTerminalFileDescriptor);
+ }
- @Override
- public void titleChanged(String oldTitle, String newTitle) {
- mChangeCallback.onTitleChanged(this);
- }
+ @Override
+ public void titleChanged(String oldTitle, String newTitle) {
+ mChangeCallback.onTitleChanged(this);
+ }
- public synchronized boolean isRunning() {
- return mShellPid != -1;
- }
+ public synchronized boolean isRunning() {
+ return mShellPid != -1;
+ }
- /** Only valid if not {@link #isRunning()}. */
- public synchronized int getExitStatus() {
- return mShellExitStatus;
- }
+ /** Only valid if not {@link #isRunning()}. */
+ public synchronized int getExitStatus() {
+ return mShellExitStatus;
+ }
- @Override
- public void clipboardText(String text) {
- mChangeCallback.onClipboardText(this, text);
- }
+ @Override
+ public void clipboardText(String text) {
+ mChangeCallback.onClipboardText(this, text);
+ }
- @Override
- public void onBell() {
- mChangeCallback.onBell(this);
- }
+ @Override
+ public void onBell() {
+ mChangeCallback.onBell(this);
+ }
@Override
public void onColorsChanged() {
mChangeCallback.onColorsChanged(this);
}
- public int getPid() { return mShellPid; }
+ public int getPid() {
+ return mShellPid;
+ }
}
diff --git a/app/src/main/java/com/termux/terminal/TextStyle.java b/app/src/main/java/com/termux/terminal/TextStyle.java
index 6b99b5a2..2986c483 100644
--- a/app/src/main/java/com/termux/terminal/TextStyle.java
+++ b/app/src/main/java/com/termux/terminal/TextStyle.java
@@ -3,53 +3,53 @@ package com.termux.terminal;
/**
* Encodes effects, foreground and background colors into a 32 bit integer, which are stored for each cell in a terminal
* row in {@link TerminalRow#mStyle}.
- *
+ *
* The foreground and background colors take 9 bits each, leaving (32-9-9)=14 bits for effect flags. Using 9 for now
* (the different CHARACTER_ATTRIBUTE_* bits).
*/
public final class TextStyle {
- public final static int CHARACTER_ATTRIBUTE_BOLD = 1;
- public final static int CHARACTER_ATTRIBUTE_ITALIC = 1 << 1;
- public final static int CHARACTER_ATTRIBUTE_UNDERLINE = 1 << 2;
- public final static int CHARACTER_ATTRIBUTE_BLINK = 1 << 3;
- public final static int CHARACTER_ATTRIBUTE_INVERSE = 1 << 4;
- public final static int CHARACTER_ATTRIBUTE_INVISIBLE = 1 << 5;
- public final static int CHARACTER_ATTRIBUTE_STRIKETHROUGH = 1 << 6;
- /**
- * The selective erase control functions (DECSED and DECSEL) can only erase characters defined as erasable.
- *
- * This bit is set if DECSCA (Select Character Protection Attribute) has been used to define the characters that
- * come after it as erasable from the screen.
- */
- public final static int CHARACTER_ATTRIBUTE_PROTECTED = 1 << 7;
- /** Dim colors. Also known as faint or half intensity. */
- public final static int CHARACTER_ATTRIBUTE_DIM = 1 << 8;
+ public final static int CHARACTER_ATTRIBUTE_BOLD = 1;
+ public final static int CHARACTER_ATTRIBUTE_ITALIC = 1 << 1;
+ public final static int CHARACTER_ATTRIBUTE_UNDERLINE = 1 << 2;
+ public final static int CHARACTER_ATTRIBUTE_BLINK = 1 << 3;
+ public final static int CHARACTER_ATTRIBUTE_INVERSE = 1 << 4;
+ public final static int CHARACTER_ATTRIBUTE_INVISIBLE = 1 << 5;
+ public final static int CHARACTER_ATTRIBUTE_STRIKETHROUGH = 1 << 6;
+ /**
+ * The selective erase control functions (DECSED and DECSEL) can only erase characters defined as erasable.
+ *
+ * This bit is set if DECSCA (Select Character Protection Attribute) has been used to define the characters that
+ * come after it as erasable from the screen.
+ */
+ public final static int CHARACTER_ATTRIBUTE_PROTECTED = 1 << 7;
+ /** Dim colors. Also known as faint or half intensity. */
+ public final static int CHARACTER_ATTRIBUTE_DIM = 1 << 8;
- public final static int COLOR_INDEX_FOREGROUND = 256;
- public final static int COLOR_INDEX_BACKGROUND = 257;
- public final static int COLOR_INDEX_CURSOR = 258;
+ public final static int COLOR_INDEX_FOREGROUND = 256;
+ public final static int COLOR_INDEX_BACKGROUND = 257;
+ public final static int COLOR_INDEX_CURSOR = 258;
- /** The 256 standard color entries and the three special (foreground, background and cursor) ones. */
- public final static int NUM_INDEXED_COLORS = 259;
+ /** The 256 standard color entries and the three special (foreground, background and cursor) ones. */
+ public final static int NUM_INDEXED_COLORS = 259;
- /** Normal foreground and background colors and no effects. */
- final static int NORMAL = encode(COLOR_INDEX_FOREGROUND, COLOR_INDEX_BACKGROUND, 0);
+ /** Normal foreground and background colors and no effects. */
+ final static int NORMAL = encode(COLOR_INDEX_FOREGROUND, COLOR_INDEX_BACKGROUND, 0);
- static int encode(int foreColor, int backColor, int effect) {
- return ((effect & 0b111111111) << 18) | ((foreColor & 0b111111111) << 9) | (backColor & 0b111111111);
- }
+ static int encode(int foreColor, int backColor, int effect) {
+ return ((effect & 0b111111111) << 18) | ((foreColor & 0b111111111) << 9) | (backColor & 0b111111111);
+ }
- public static int decodeForeColor(int encodedColor) {
- return (encodedColor >> 9) & 0b111111111;
- }
+ public static int decodeForeColor(int encodedColor) {
+ return (encodedColor >> 9) & 0b111111111;
+ }
- public static int decodeBackColor(int encodedColor) {
- return encodedColor & 0b111111111;
- }
+ public static int decodeBackColor(int encodedColor) {
+ return encodedColor & 0b111111111;
+ }
- public static int decodeEffect(int encodedColor) {
- return (encodedColor >> 18) & 0b111111111;
- }
+ public static int decodeEffect(int encodedColor) {
+ return (encodedColor >> 18) & 0b111111111;
+ }
}
diff --git a/app/src/main/java/com/termux/terminal/WcWidth.java b/app/src/main/java/com/termux/terminal/WcWidth.java
index 0e5f391a..a4e8d4b7 100644
--- a/app/src/main/java/com/termux/terminal/WcWidth.java
+++ b/app/src/main/java/com/termux/terminal/WcWidth.java
@@ -2,107 +2,107 @@ package com.termux.terminal;
/**
* wcwidth() implementation from http://git.musl-libc.org/cgit/musl/tree/src/ctype
- *
+ *
* Modified to return 0 instead of -1.
*/
public final class WcWidth {
- private static final short table[] = { 16, 16, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 16, 16, 32, 16, 16, 16, 33, 34, 35, 36, 37, 38,
- 39, 16, 16, 40, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 41, 42, 16, 16, 43, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 44, 16, 45, 46, 47, 48, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
- 49, 16, 16, 50, 51, 16, 52, 16, 16, 16, 16, 16, 16, 16, 16, 53, 16, 16, 16, 16, 16, 54, 55, 16, 16, 16, 16, 56, 16, 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 57, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 58, 59, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255,
- 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
- 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 248, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 254, 255, 255, 255, 255, 191, 182, 0, 0, 0,
- 0, 0, 0, 0, 31, 0, 255, 7, 0, 0, 0, 0, 0, 248, 255, 255, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 192, 191, 159, 61, 0, 0, 0, 128, 2, 0, 0, 0,
- 255, 255, 255, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 192, 255, 1, 0, 0, 0, 0, 0, 0, 248, 15, 0, 0, 0, 192, 251, 239, 62, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 240, 255, 255, 127, 7, 0, 0, 0, 0, 0, 0, 20, 254, 33, 254, 0, 12, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 16, 30, 32, 0,
- 0, 12, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 16, 134, 57, 2, 0, 0, 0, 35, 0, 6, 0, 0, 0, 0, 0, 0, 16, 190, 33, 0, 0, 12, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 144,
- 30, 32, 64, 0, 12, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 1, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 192, 193, 61, 96, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 144, 64, 48, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 30, 32, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 92, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 242, 7, 128, 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 242, 27, 0, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 160, 2, 0, 0, 0, 0, 0, 0, 254,
- 127, 223, 224, 255, 254, 255, 255, 255, 31, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 224, 253, 102, 0, 0, 0, 195, 1, 0, 30, 0, 100, 32, 0, 32, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 224, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0,
- 28, 0, 0, 0, 12, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 176, 63, 64, 254, 15, 32, 0, 0, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 135, 1, 4, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 128, 1, 0, 0, 0, 0, 0, 0, 64, 127, 229, 31, 248, 159, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 208, 23, 4, 0, 0, 0, 0,
- 248, 15, 0, 3, 0, 0, 0, 60, 11, 0, 0, 0, 0, 0, 0, 64, 163, 3, 0, 0, 0, 0, 0, 0, 240, 207, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 247, 255, 253, 33, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 127, 0, 0, 240, 0, 248, 0, 0,
- 0, 124, 0, 0, 0, 0, 0, 0, 31, 252, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255,
- 255, 0, 0, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128,
- 247, 63, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 68, 8, 0, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0,
- 255, 255, 3, 0, 0, 0, 0, 0, 192, 63, 0, 0, 128, 255, 3, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 200, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 126, 102,
- 0, 8, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 157, 193, 2, 0, 0, 0, 0, 48, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 32, 33, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0,
- 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 110, 240, 0,
- 0, 0, 0, 0, 135, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 255, 127, 0, 0, 0, 0, 0, 0, 0, 3, 0,
- 0, 0, 0, 0, 120, 38, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 128, 239, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 192, 127, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 191, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 128, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 3, 248, 255, 231, 15, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, };
+ private static final short table[] = {16, 16, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 16, 16, 32, 16, 16, 16, 33, 34, 35, 36, 37, 38,
+ 39, 16, 16, 40, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 41, 42, 16, 16, 43, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 44, 16, 45, 46, 47, 48, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 49, 16, 16, 50, 51, 16, 52, 16, 16, 16, 16, 16, 16, 16, 16, 53, 16, 16, 16, 16, 16, 54, 55, 16, 16, 16, 16, 56, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 57, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 58, 59, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 248, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 254, 255, 255, 255, 255, 191, 182, 0, 0, 0,
+ 0, 0, 0, 0, 31, 0, 255, 7, 0, 0, 0, 0, 0, 248, 255, 255, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 192, 191, 159, 61, 0, 0, 0, 128, 2, 0, 0, 0,
+ 255, 255, 255, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 192, 255, 1, 0, 0, 0, 0, 0, 0, 248, 15, 0, 0, 0, 192, 251, 239, 62, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 240, 255, 255, 127, 7, 0, 0, 0, 0, 0, 0, 20, 254, 33, 254, 0, 12, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 16, 30, 32, 0,
+ 0, 12, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 16, 134, 57, 2, 0, 0, 0, 35, 0, 6, 0, 0, 0, 0, 0, 0, 16, 190, 33, 0, 0, 12, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 144,
+ 30, 32, 64, 0, 12, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 1, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 192, 193, 61, 96, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 144, 64, 48, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 30, 32, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 92, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 242, 7, 128, 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 242, 27, 0, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 160, 2, 0, 0, 0, 0, 0, 0, 254,
+ 127, 223, 224, 255, 254, 255, 255, 255, 31, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 224, 253, 102, 0, 0, 0, 195, 1, 0, 30, 0, 100, 32, 0, 32, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 224, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0,
+ 28, 0, 0, 0, 12, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 176, 63, 64, 254, 15, 32, 0, 0, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 135, 1, 4, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 128, 1, 0, 0, 0, 0, 0, 0, 64, 127, 229, 31, 248, 159, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 208, 23, 4, 0, 0, 0, 0,
+ 248, 15, 0, 3, 0, 0, 0, 60, 11, 0, 0, 0, 0, 0, 0, 64, 163, 3, 0, 0, 0, 0, 0, 0, 240, 207, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 247, 255, 253, 33, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 127, 0, 0, 240, 0, 248, 0, 0,
+ 0, 124, 0, 0, 0, 0, 0, 0, 31, 252, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255,
+ 255, 0, 0, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128,
+ 247, 63, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 68, 8, 0, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0,
+ 255, 255, 3, 0, 0, 0, 0, 0, 192, 63, 0, 0, 128, 255, 3, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 200, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 126, 102,
+ 0, 8, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 157, 193, 2, 0, 0, 0, 0, 48, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 32, 33, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0,
+ 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 110, 240, 0,
+ 0, 0, 0, 0, 135, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 255, 127, 0, 0, 0, 0, 0, 0, 0, 3, 0,
+ 0, 0, 0, 0, 120, 38, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 128, 239, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 192, 127, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 191, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 128, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 3, 248, 255, 231, 15, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,};
- private static final short wtable[] = { 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 18, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 19, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 20, 21, 22, 23, 24, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
- 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 25, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
- 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
- 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 26, 16, 16, 16, 16, 27, 16, 16, 17, 17, 17, 17, 17,
- 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
- 17, 28, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17,
- 16, 16, 16, 29, 30, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 31, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 32, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255,
- 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
- 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 248, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 252, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 251, 255, 255, 255, 255, 255, 255,
- 255, 255, 255, 255, 15, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
- 255, 255, 63, 0, 0, 0, 255, 15, 255, 255, 255, 255, 255, 255, 255, 127, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 127, 254, 255, 255, 255,
- 255, 255, 255, 255, 255, 255, 255, 255, 255, 224, 255, 255, 255, 255, 63, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 127, 255, 255,
- 255, 255, 255, 7, 255, 255, 255, 255, 15, 0, 255, 255, 255, 255, 255, 127, 255, 255, 255, 255, 255, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255,
- 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 127, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
- 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
- 255, 31, 255, 255, 255, 255, 255, 255, 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 15, 0, 255, 255, 127, 248,
- 255, 255, 255, 255, 255, 15, 0, 0, 255, 3, 0, 0, 255, 255, 255, 255, 247, 255, 127, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 254,
- 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 127, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 255, 255, 255, 255, 255, 7, 255, 1, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+ private static final short wtable[] = {16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 18, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 19, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 20, 21, 22, 23, 24, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+ 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 25, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+ 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+ 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 26, 16, 16, 16, 16, 27, 16, 16, 17, 17, 17, 17, 17,
+ 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+ 17, 28, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17,
+ 16, 16, 16, 29, 30, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 31, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 32, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 248, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 252, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 251, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 15, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 63, 0, 0, 0, 255, 15, 255, 255, 255, 255, 255, 255, 255, 127, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 127, 254, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 224, 255, 255, 255, 255, 63, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 127, 255, 255,
+ 255, 255, 255, 7, 255, 255, 255, 255, 15, 0, 255, 255, 255, 255, 255, 127, 255, 255, 255, 255, 255, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 127, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 31, 255, 255, 255, 255, 255, 255, 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 15, 0, 255, 255, 127, 248,
+ 255, 255, 255, 255, 255, 15, 0, 0, 255, 3, 0, 0, 255, 255, 255, 255, 247, 255, 127, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 254,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 127, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 255, 255, 255, 255, 255, 7, 255, 1, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0};
- /** Return the terminal display width of a code point: 0, 1 or 2. */
- public static int width(int wc) {
- if (wc < 0xff) return (wc + 1 & 0x7f) >= 0x21 ? 1 : (wc != 0) ? 0 : 0;
- if ((wc & 0xfffeffff) < 0xfffe) {
- if (((table[table[wc >> 8] * 32 + ((wc & 255) >> 3)] >> (wc & 7)) & 1) != 0) return 0;
- if (((wtable[wtable[wc >> 8] * 32 + ((wc & 255) >> 3)] >> (wc & 7)) & 1) != 0) return 2;
- return 1;
- }
- if ((wc & 0xfffe) == 0xfffe) return 0;
- if (wc - 0x20000 < 0x20000) return 2;
- if (wc == 0xe0001 || wc - 0xe0020 < 0x5f || wc - 0xe0100 < 0xef) return 0;
- return 1;
- }
+ /** Return the terminal display width of a code point: 0, 1 or 2. */
+ public static int width(int wc) {
+ if (wc < 0xff) return (wc + 1 & 0x7f) >= 0x21 ? 1 : (wc != 0) ? 0 : 0;
+ if ((wc & 0xfffeffff) < 0xfffe) {
+ if (((table[table[wc >> 8] * 32 + ((wc & 255) >> 3)] >> (wc & 7)) & 1) != 0) return 0;
+ if (((wtable[wtable[wc >> 8] * 32 + ((wc & 255) >> 3)] >> (wc & 7)) & 1) != 0) return 2;
+ return 1;
+ }
+ if ((wc & 0xfffe) == 0xfffe) return 0;
+ if (wc - 0x20000 < 0x20000) return 2;
+ if (wc == 0xe0001 || wc - 0xe0020 < 0x5f || wc - 0xe0100 < 0xef) return 0;
+ return 1;
+ }
- /** The width at an index position in a java char array. */
- public static int width(char[] chars, int index) {
- char c = chars[index];
- return Character.isHighSurrogate(c) ? width(Character.toCodePoint(c, chars[index + 1])) : width(c);
- }
+ /** The width at an index position in a java char array. */
+ public static int width(char[] chars, int index) {
+ char c = chars[index];
+ return Character.isHighSurrogate(c) ? width(Character.toCodePoint(c, chars[index + 1])) : width(c);
+ }
}
diff --git a/app/src/main/java/com/termux/view/GestureAndScaleRecognizer.java b/app/src/main/java/com/termux/view/GestureAndScaleRecognizer.java
index 03744360..de41409e 100644
--- a/app/src/main/java/com/termux/view/GestureAndScaleRecognizer.java
+++ b/app/src/main/java/com/termux/view/GestureAndScaleRecognizer.java
@@ -8,104 +8,104 @@ import android.view.ScaleGestureDetector;
/** A combination of {@link GestureDetector} and {@link ScaleGestureDetector}. */
public final class GestureAndScaleRecognizer {
- public interface Listener {
- boolean onSingleTapUp(MotionEvent e);
+ public interface Listener {
+ boolean onSingleTapUp(MotionEvent e);
- boolean onDoubleTap(MotionEvent e);
+ boolean onDoubleTap(MotionEvent e);
- boolean onScroll(MotionEvent e2, float dx, float dy);
+ boolean onScroll(MotionEvent e2, float dx, float dy);
- boolean onFling(MotionEvent e, float velocityX, float velocityY);
+ boolean onFling(MotionEvent e, float velocityX, float velocityY);
- boolean onScale(float focusX, float focusY, float scale);
+ boolean onScale(float focusX, float focusY, float scale);
- boolean onDown(float x, float y);
+ boolean onDown(float x, float y);
- boolean onUp(MotionEvent e);
+ boolean onUp(MotionEvent e);
- void onLongPress(MotionEvent e);
- }
+ void onLongPress(MotionEvent e);
+ }
- private final GestureDetector mGestureDetector;
- private final ScaleGestureDetector mScaleDetector;
- final Listener mListener;
- boolean isAfterLongPress;
+ private final GestureDetector mGestureDetector;
+ private final ScaleGestureDetector mScaleDetector;
+ final Listener mListener;
+ boolean isAfterLongPress;
- public GestureAndScaleRecognizer(Context context, Listener listener) {
- mListener = listener;
+ public GestureAndScaleRecognizer(Context context, Listener listener) {
+ mListener = listener;
- mGestureDetector = new GestureDetector(context, new GestureDetector.SimpleOnGestureListener() {
- @Override
- public boolean onScroll(MotionEvent e1, MotionEvent e2, float dx, float dy) {
- return mListener.onScroll(e2, dx, dy);
- }
+ mGestureDetector = new GestureDetector(context, new GestureDetector.SimpleOnGestureListener() {
+ @Override
+ public boolean onScroll(MotionEvent e1, MotionEvent e2, float dx, float dy) {
+ return mListener.onScroll(e2, dx, dy);
+ }
- @Override
- public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
- return mListener.onFling(e2, velocityX, velocityY);
- }
+ @Override
+ public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
+ return mListener.onFling(e2, velocityX, velocityY);
+ }
- @Override
- public boolean onDown(MotionEvent e) {
- return mListener.onDown(e.getX(), e.getY());
- }
+ @Override
+ public boolean onDown(MotionEvent e) {
+ return mListener.onDown(e.getX(), e.getY());
+ }
- @Override
- public void onLongPress(MotionEvent e) {
- mListener.onLongPress(e);
- isAfterLongPress = true;
- }
- }, null, true /* ignoreMultitouch */);
+ @Override
+ public void onLongPress(MotionEvent e) {
+ mListener.onLongPress(e);
+ isAfterLongPress = true;
+ }
+ }, null, true /* ignoreMultitouch */);
- mGestureDetector.setOnDoubleTapListener(new GestureDetector.OnDoubleTapListener() {
- @Override
- public boolean onSingleTapConfirmed(MotionEvent e) {
- return mListener.onSingleTapUp(e);
- }
+ mGestureDetector.setOnDoubleTapListener(new GestureDetector.OnDoubleTapListener() {
+ @Override
+ public boolean onSingleTapConfirmed(MotionEvent e) {
+ return mListener.onSingleTapUp(e);
+ }
- @Override
- public boolean onDoubleTap(MotionEvent e) {
- return mListener.onDoubleTap(e);
- }
+ @Override
+ public boolean onDoubleTap(MotionEvent e) {
+ return mListener.onDoubleTap(e);
+ }
- @Override
- public boolean onDoubleTapEvent(MotionEvent e) {
- return true;
- }
- });
+ @Override
+ public boolean onDoubleTapEvent(MotionEvent e) {
+ return true;
+ }
+ });
- mScaleDetector = new ScaleGestureDetector(context, new ScaleGestureDetector.SimpleOnScaleGestureListener() {
- @Override
- public boolean onScaleBegin(ScaleGestureDetector detector) {
- return true;
- }
+ mScaleDetector = new ScaleGestureDetector(context, new ScaleGestureDetector.SimpleOnScaleGestureListener() {
+ @Override
+ public boolean onScaleBegin(ScaleGestureDetector detector) {
+ return true;
+ }
- @Override
- public boolean onScale(ScaleGestureDetector detector) {
- return mListener.onScale(detector.getFocusX(), detector.getFocusY(), detector.getScaleFactor());
- }
- });
- }
+ @Override
+ public boolean onScale(ScaleGestureDetector detector) {
+ return mListener.onScale(detector.getFocusX(), detector.getFocusY(), detector.getScaleFactor());
+ }
+ });
+ }
- public void onTouchEvent(MotionEvent event) {
- mGestureDetector.onTouchEvent(event);
- mScaleDetector.onTouchEvent(event);
- switch (event.getAction()) {
- case MotionEvent.ACTION_DOWN:
- isAfterLongPress = false;
- break;
- case MotionEvent.ACTION_UP:
- if (!isAfterLongPress) {
- // This behaviour is desired when in e.g. vim with mouse events, where we do not
- // want to move the cursor when lifting finger after a long press.
- mListener.onUp(event);
- }
- break;
- }
- }
+ public void onTouchEvent(MotionEvent event) {
+ mGestureDetector.onTouchEvent(event);
+ mScaleDetector.onTouchEvent(event);
+ switch (event.getAction()) {
+ case MotionEvent.ACTION_DOWN:
+ isAfterLongPress = false;
+ break;
+ case MotionEvent.ACTION_UP:
+ if (!isAfterLongPress) {
+ // This behaviour is desired when in e.g. vim with mouse events, where we do not
+ // want to move the cursor when lifting finger after a long press.
+ mListener.onUp(event);
+ }
+ break;
+ }
+ }
- public boolean isInProgress() {
- return mScaleDetector.isInProgress();
- }
+ public boolean isInProgress() {
+ return mScaleDetector.isInProgress();
+ }
}
diff --git a/app/src/main/java/com/termux/view/TerminalKeyListener.java b/app/src/main/java/com/termux/view/TerminalKeyListener.java
index a1f801da..0925c075 100644
--- a/app/src/main/java/com/termux/view/TerminalKeyListener.java
+++ b/app/src/main/java/com/termux/view/TerminalKeyListener.java
@@ -9,20 +9,20 @@ import com.termux.terminal.TerminalSession;
/**
* Input and scale listener which may be set on a {@link TerminalView} through
* {@link TerminalView#setOnKeyListener(TerminalKeyListener)}.
- *
+ *
* TODO: Rename to TerminalViewClient.
*/
public interface TerminalKeyListener {
- /** Callback function on scale events according to {@link ScaleGestureDetector#getScaleFactor()}. */
- float onScale(float scale);
+ /** Callback function on scale events according to {@link ScaleGestureDetector#getScaleFactor()}. */
+ float onScale(float scale);
- /** On a single tap on the terminal if terminal mouse reporting not enabled. */
- void onSingleTapUp(MotionEvent e);
+ /** On a single tap on the terminal if terminal mouse reporting not enabled. */
+ void onSingleTapUp(MotionEvent e);
- boolean shouldBackButtonBeMappedToEscape();
+ boolean shouldBackButtonBeMappedToEscape();
- void copyModeChanged(boolean copyMode);
+ void copyModeChanged(boolean copyMode);
boolean onKeyDown(int keyCode, KeyEvent e, TerminalSession session);
diff --git a/app/src/main/java/com/termux/view/TerminalRenderer.java b/app/src/main/java/com/termux/view/TerminalRenderer.java
index 9f56c5d5..4d24b059 100644
--- a/app/src/main/java/com/termux/view/TerminalRenderer.java
+++ b/app/src/main/java/com/termux/view/TerminalRenderer.java
@@ -13,223 +13,213 @@ import com.termux.terminal.WcWidth;
/**
* Renderer of a {@link TerminalEmulator} into a {@link Canvas}.
- *
+ *
* Saves font metrics, so needs to be recreated each time the typeface or font size changes.
*/
final class TerminalRenderer {
- final int mTextSize;
- final Typeface mTypeface;
- private final Paint mTextPaint = new Paint();
+ final int mTextSize;
+ final Typeface mTypeface;
+ private final Paint mTextPaint = new Paint();
- /** The width of a single mono spaced character obtained by {@link Paint#measureText(String)} on a single 'X'. */
- final float mFontWidth;
- /** The {@link Paint#getFontSpacing()}. See http://www.fampennings.nl/maarten/android/08numgrid/font.png */
- final int mFontLineSpacing;
- /** The {@link Paint#ascent()}. See http://www.fampennings.nl/maarten/android/08numgrid/font.png */
- private final int mFontAscent;
- /** The {@link #mFontLineSpacing} + {@link #mFontAscent}. */
- final int mFontLineSpacingAndAscent;
+ /** The width of a single mono spaced character obtained by {@link Paint#measureText(String)} on a single 'X'. */
+ final float mFontWidth;
+ /** The {@link Paint#getFontSpacing()}. See http://www.fampennings.nl/maarten/android/08numgrid/font.png */
+ final int mFontLineSpacing;
+ /** The {@link Paint#ascent()}. See http://www.fampennings.nl/maarten/android/08numgrid/font.png */
+ private final int mFontAscent;
+ /** The {@link #mFontLineSpacing} + {@link #mFontAscent}. */
+ final int mFontLineSpacingAndAscent;
- private final float[] asciiMeasures = new float[127];
+ private final float[] asciiMeasures = new float[127];
- public TerminalRenderer(int textSize, Typeface typeface) {
- mTextSize = textSize;
- mTypeface = typeface;
+ public TerminalRenderer(int textSize, Typeface typeface) {
+ mTextSize = textSize;
+ mTypeface = typeface;
- mTextPaint.setTypeface(typeface);
- mTextPaint.setAntiAlias(true);
- mTextPaint.setTextSize(textSize);
+ mTextPaint.setTypeface(typeface);
+ mTextPaint.setAntiAlias(true);
+ mTextPaint.setTextSize(textSize);
- mFontLineSpacing = (int) Math.ceil(mTextPaint.getFontSpacing());
- mFontAscent = (int) Math.ceil(mTextPaint.ascent());
- mFontLineSpacingAndAscent = mFontLineSpacing + mFontAscent;
- mFontWidth = mTextPaint.measureText("X");
+ mFontLineSpacing = (int) Math.ceil(mTextPaint.getFontSpacing());
+ mFontAscent = (int) Math.ceil(mTextPaint.ascent());
+ mFontLineSpacingAndAscent = mFontLineSpacing + mFontAscent;
+ mFontWidth = mTextPaint.measureText("X");
- StringBuilder sb = new StringBuilder(" ");
- for (int i = 0; i < asciiMeasures.length; i++) {
- sb.setCharAt(0, (char) i);
- asciiMeasures[i] = mTextPaint.measureText(sb, 0, 1);
- }
- }
+ StringBuilder sb = new StringBuilder(" ");
+ for (int i = 0; i < asciiMeasures.length; i++) {
+ sb.setCharAt(0, (char) i);
+ asciiMeasures[i] = mTextPaint.measureText(sb, 0, 1);
+ }
+ }
- /** Render the terminal to a canvas with at a specified row scroll, and an optional rectangular selection. */
- public final void render(TerminalEmulator mEmulator, Canvas canvas, int topRow, int selectionY1, int selectionY2, int selectionX1, int selectionX2) {
- final boolean reverseVideo = mEmulator.isReverseVideo();
- final int endRow = topRow + mEmulator.mRows;
- final int columns = mEmulator.mColumns;
- final int cursorCol = mEmulator.getCursorCol();
- final int cursorRow = mEmulator.getCursorRow();
- final boolean cursorVisible = mEmulator.isShowingCursor();
- final TerminalBuffer screen = mEmulator.getScreen();
- final int[] palette = mEmulator.mColors.mCurrentColors;
+ /** Render the terminal to a canvas with at a specified row scroll, and an optional rectangular selection. */
+ public final void render(TerminalEmulator mEmulator, Canvas canvas, int topRow, int selectionY1, int selectionY2, int selectionX1, int selectionX2) {
+ final boolean reverseVideo = mEmulator.isReverseVideo();
+ final int endRow = topRow + mEmulator.mRows;
+ final int columns = mEmulator.mColumns;
+ final int cursorCol = mEmulator.getCursorCol();
+ final int cursorRow = mEmulator.getCursorRow();
+ final boolean cursorVisible = mEmulator.isShowingCursor();
+ final TerminalBuffer screen = mEmulator.getScreen();
+ final int[] palette = mEmulator.mColors.mCurrentColors;
- if (reverseVideo) canvas.drawColor(palette[TextStyle.COLOR_INDEX_FOREGROUND], PorterDuff.Mode.SRC);
+ if (reverseVideo)
+ canvas.drawColor(palette[TextStyle.COLOR_INDEX_FOREGROUND], PorterDuff.Mode.SRC);
- float heightOffset = mFontLineSpacingAndAscent;
- for (int row = topRow; row < endRow; row++) {
- heightOffset += mFontLineSpacing;
+ float heightOffset = mFontLineSpacingAndAscent;
+ for (int row = topRow; row < endRow; row++) {
+ heightOffset += mFontLineSpacing;
- final int cursorX = (row == cursorRow && cursorVisible) ? cursorCol : -1;
- int selx1 = -1, selx2 = -1;
- if (row >= selectionY1 && row <= selectionY2) {
- if (row == selectionY1) selx1 = selectionX1;
- selx2 = (row == selectionY2) ? selectionX2 : mEmulator.mColumns;
- }
+ final int cursorX = (row == cursorRow && cursorVisible) ? cursorCol : -1;
+ int selx1 = -1, selx2 = -1;
+ if (row >= selectionY1 && row <= selectionY2) {
+ if (row == selectionY1) selx1 = selectionX1;
+ selx2 = (row == selectionY2) ? selectionX2 : mEmulator.mColumns;
+ }
- TerminalRow lineObject = screen.allocateFullLineIfNecessary(screen.externalToInternalRow(row));
- final char[] line = lineObject.mText;
- final int charsUsedInLine = lineObject.getSpaceUsed();
+ TerminalRow lineObject = screen.allocateFullLineIfNecessary(screen.externalToInternalRow(row));
+ final char[] line = lineObject.mText;
+ final int charsUsedInLine = lineObject.getSpaceUsed();
- int lastRunStyle = 0;
- boolean lastRunInsideCursor = false;
- int lastRunStartColumn = -1;
- int lastRunStartIndex = 0;
- boolean lastRunFontWidthMismatch = false;
- int currentCharIndex = 0;
- float measuredWidthForRun = 0.f;
+ int lastRunStyle = 0;
+ boolean lastRunInsideCursor = false;
+ int lastRunStartColumn = -1;
+ int lastRunStartIndex = 0;
+ boolean lastRunFontWidthMismatch = false;
+ int currentCharIndex = 0;
+ float measuredWidthForRun = 0.f;
- for (int column = 0; column < columns;) {
- final char charAtIndex = line[currentCharIndex];
- final boolean charIsHighsurrogate = Character.isHighSurrogate(charAtIndex);
- final int charsForCodePoint = charIsHighsurrogate ? 2 : 1;
- final int codePoint = charIsHighsurrogate ? Character.toCodePoint(charAtIndex, line[currentCharIndex + 1]) : charAtIndex;
- final int codePointWcWidth = WcWidth.width(codePoint);
- final boolean insideCursor = (column >= selx1 && column <= selx2) || (cursorX == column || (codePointWcWidth == 2 && cursorX == column + 1));
- final int style = lineObject.getStyle(column);
+ for (int column = 0; column < columns; ) {
+ final char charAtIndex = line[currentCharIndex];
+ final boolean charIsHighsurrogate = Character.isHighSurrogate(charAtIndex);
+ final int charsForCodePoint = charIsHighsurrogate ? 2 : 1;
+ final int codePoint = charIsHighsurrogate ? Character.toCodePoint(charAtIndex, line[currentCharIndex + 1]) : charAtIndex;
+ final int codePointWcWidth = WcWidth.width(codePoint);
+ final boolean insideCursor = (column >= selx1 && column <= selx2) || (cursorX == column || (codePointWcWidth == 2 && cursorX == column + 1));
+ final int style = lineObject.getStyle(column);
- // Check if the measured text width for this code point is not the same as that expected by wcwidth().
- // This could happen for some fonts which are not truly monospace, or for more exotic characters such as
- // smileys which android font renders as wide.
- // If this is detected, we draw this code point scaled to match what wcwidth() expects.
- final float measuredCodePointWidth = (codePoint < asciiMeasures.length) ? asciiMeasures[codePoint] : mTextPaint.measureText(line,
- currentCharIndex, charsForCodePoint);
- final boolean fontWidthMismatch = Math.abs(measuredCodePointWidth / mFontWidth - codePointWcWidth) > 0.01;
+ // Check if the measured text width for this code point is not the same as that expected by wcwidth().
+ // This could happen for some fonts which are not truly monospace, or for more exotic characters such as
+ // smileys which android font renders as wide.
+ // If this is detected, we draw this code point scaled to match what wcwidth() expects.
+ final float measuredCodePointWidth = (codePoint < asciiMeasures.length) ? asciiMeasures[codePoint] : mTextPaint.measureText(line,
+ currentCharIndex, charsForCodePoint);
+ final boolean fontWidthMismatch = Math.abs(measuredCodePointWidth / mFontWidth - codePointWcWidth) > 0.01;
- if (style != lastRunStyle || insideCursor != lastRunInsideCursor || fontWidthMismatch || lastRunFontWidthMismatch) {
- if (column == 0) {
- // Skip first column as there is nothing to draw, just record the current style.
- } else {
- final int columnWidthSinceLastRun = column - lastRunStartColumn;
- final int charsSinceLastRun = currentCharIndex - lastRunStartIndex;
- drawTextRun(canvas, line, palette, heightOffset, lastRunStartColumn, columnWidthSinceLastRun, lastRunStartIndex, charsSinceLastRun,
- measuredWidthForRun, lastRunInsideCursor, lastRunStyle, reverseVideo);
- }
- measuredWidthForRun = 0.f;
- lastRunStyle = style;
- lastRunInsideCursor = insideCursor;
- lastRunStartColumn = column;
- lastRunStartIndex = currentCharIndex;
- lastRunFontWidthMismatch = fontWidthMismatch;
- }
- measuredWidthForRun += measuredCodePointWidth;
- column += codePointWcWidth;
- currentCharIndex += charsForCodePoint;
- while (currentCharIndex < charsUsedInLine && WcWidth.width(line, currentCharIndex) <= 0) {
- // Eat combining chars so that they are treated as part of the last non-combining code point,
- // instead of e.g. being considered inside the cursor in the next run.
- currentCharIndex += Character.isHighSurrogate(line[currentCharIndex]) ? 2 : 1;
- }
- }
+ if (style != lastRunStyle || insideCursor != lastRunInsideCursor || fontWidthMismatch || lastRunFontWidthMismatch) {
+ if (column == 0) {
+ // Skip first column as there is nothing to draw, just record the current style.
+ } else {
+ final int columnWidthSinceLastRun = column - lastRunStartColumn;
+ final int charsSinceLastRun = currentCharIndex - lastRunStartIndex;
+ drawTextRun(canvas, line, palette, heightOffset, lastRunStartColumn, columnWidthSinceLastRun, lastRunStartIndex, charsSinceLastRun,
+ measuredWidthForRun, lastRunInsideCursor, lastRunStyle, reverseVideo);
+ }
+ measuredWidthForRun = 0.f;
+ lastRunStyle = style;
+ lastRunInsideCursor = insideCursor;
+ lastRunStartColumn = column;
+ lastRunStartIndex = currentCharIndex;
+ lastRunFontWidthMismatch = fontWidthMismatch;
+ }
+ measuredWidthForRun += measuredCodePointWidth;
+ column += codePointWcWidth;
+ currentCharIndex += charsForCodePoint;
+ while (currentCharIndex < charsUsedInLine && WcWidth.width(line, currentCharIndex) <= 0) {
+ // Eat combining chars so that they are treated as part of the last non-combining code point,
+ // instead of e.g. being considered inside the cursor in the next run.
+ currentCharIndex += Character.isHighSurrogate(line[currentCharIndex]) ? 2 : 1;
+ }
+ }
- final int columnWidthSinceLastRun = columns - lastRunStartColumn;
- final int charsSinceLastRun = currentCharIndex - lastRunStartIndex;
- drawTextRun(canvas, line, palette, heightOffset, lastRunStartColumn, columnWidthSinceLastRun, lastRunStartIndex, charsSinceLastRun,
- measuredWidthForRun, lastRunInsideCursor, lastRunStyle, reverseVideo);
- }
- }
+ final int columnWidthSinceLastRun = columns - lastRunStartColumn;
+ final int charsSinceLastRun = currentCharIndex - lastRunStartIndex;
+ drawTextRun(canvas, line, palette, heightOffset, lastRunStartColumn, columnWidthSinceLastRun, lastRunStartIndex, charsSinceLastRun,
+ measuredWidthForRun, lastRunInsideCursor, lastRunStyle, reverseVideo);
+ }
+ }
- /**
- * @param canvas
- * the canvas to render on
- * @param palette
- * the color palette to look up colors from textStyle
- * @param y
- * height offset into the canvas where to render the line: line * {@link #mFontLineSpacing}
- * @param startColumn
- * the run offset in columns
- * @param runWidthColumns
- * the run width in columns - this is computed from wcwidth() and may not be what the font measures to
- * @param text
- * the java char array to render text from
- * @param startCharIndex
- * index into the text array where to start
- * @param runWidthChars
- * number of java characters from the text array to render
- * @param cursor
- * true if rendering a cursor or selection
- * @param textStyle
- * the background, foreground and effect encoded using {@link TextStyle}
- * @param reverseVideo
- * if the screen is rendered with the global reverse video flag set
- */
- private void drawTextRun(Canvas canvas, char[] text, int[] palette, float y, int startColumn, int runWidthColumns, int startCharIndex, int runWidthChars,
- float mes, boolean cursor, int textStyle, boolean reverseVideo) {
- int foreColor = TextStyle.decodeForeColor(textStyle);
- int backColor = TextStyle.decodeBackColor(textStyle);
- final int effect = TextStyle.decodeEffect(textStyle);
- float left = startColumn * mFontWidth;
- float right = left + runWidthColumns * mFontWidth;
+ /**
+ * @param canvas the canvas to render on
+ * @param palette the color palette to look up colors from textStyle
+ * @param y height offset into the canvas where to render the line: line * {@link #mFontLineSpacing}
+ * @param startColumn the run offset in columns
+ * @param runWidthColumns the run width in columns - this is computed from wcwidth() and may not be what the font measures to
+ * @param text the java char array to render text from
+ * @param startCharIndex index into the text array where to start
+ * @param runWidthChars number of java characters from the text array to render
+ * @param cursor true if rendering a cursor or selection
+ * @param textStyle the background, foreground and effect encoded using {@link TextStyle}
+ * @param reverseVideo if the screen is rendered with the global reverse video flag set
+ */
+ private void drawTextRun(Canvas canvas, char[] text, int[] palette, float y, int startColumn, int runWidthColumns, int startCharIndex, int runWidthChars,
+ float mes, boolean cursor, int textStyle, boolean reverseVideo) {
+ int foreColor = TextStyle.decodeForeColor(textStyle);
+ int backColor = TextStyle.decodeBackColor(textStyle);
+ final int effect = TextStyle.decodeEffect(textStyle);
+ float left = startColumn * mFontWidth;
+ float right = left + runWidthColumns * mFontWidth;
- mes = mes / mFontWidth;
- boolean savedMatrix = false;
- if (Math.abs(mes - runWidthColumns) > 0.01) {
- canvas.save();
- canvas.scale(runWidthColumns / mes, 1.f);
- left *= mes / runWidthColumns;
- right *= mes / runWidthColumns;
- savedMatrix = true;
- }
+ mes = mes / mFontWidth;
+ boolean savedMatrix = false;
+ if (Math.abs(mes - runWidthColumns) > 0.01) {
+ canvas.save();
+ canvas.scale(runWidthColumns / mes, 1.f);
+ left *= mes / runWidthColumns;
+ right *= mes / runWidthColumns;
+ savedMatrix = true;
+ }
- // Reverse video here if _one and only one_ of the reverse flags are set:
- boolean reverseVideoHere = reverseVideo ^ (effect & (TextStyle.CHARACTER_ATTRIBUTE_INVERSE)) != 0;
- // Switch if _one and only one_ of reverse video and cursor is set:
- if (reverseVideoHere ^ cursor) {
- int tmp = foreColor;
- foreColor = backColor;
- backColor = tmp;
- }
+ // Reverse video here if _one and only one_ of the reverse flags are set:
+ boolean reverseVideoHere = reverseVideo ^ (effect & (TextStyle.CHARACTER_ATTRIBUTE_INVERSE)) != 0;
+ // Switch if _one and only one_ of reverse video and cursor is set:
+ if (reverseVideoHere ^ cursor) {
+ int tmp = foreColor;
+ foreColor = backColor;
+ backColor = tmp;
+ }
- if (backColor != TextStyle.COLOR_INDEX_BACKGROUND) {
- // Only draw non-default background.
- mTextPaint.setColor(palette[backColor]);
- canvas.drawRect(left, y - mFontLineSpacingAndAscent + mFontAscent, right, y, mTextPaint);
- }
+ if (backColor != TextStyle.COLOR_INDEX_BACKGROUND) {
+ // Only draw non-default background.
+ mTextPaint.setColor(palette[backColor]);
+ canvas.drawRect(left, y - mFontLineSpacingAndAscent + mFontAscent, right, y, mTextPaint);
+ }
- if ((effect & TextStyle.CHARACTER_ATTRIBUTE_INVISIBLE) == 0) {
- // Treat blink as bold:
- final boolean bold = (effect & (TextStyle.CHARACTER_ATTRIBUTE_BOLD | TextStyle.CHARACTER_ATTRIBUTE_BLINK)) != 0;
- final boolean underline = (effect & TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE) != 0;
- final boolean italic = (effect & TextStyle.CHARACTER_ATTRIBUTE_ITALIC) != 0;
- final boolean strikeThrough = (effect & TextStyle.CHARACTER_ATTRIBUTE_STRIKETHROUGH) != 0;
- final boolean dim = (effect & TextStyle.CHARACTER_ATTRIBUTE_DIM) != 0;
+ if ((effect & TextStyle.CHARACTER_ATTRIBUTE_INVISIBLE) == 0) {
+ // Treat blink as bold:
+ final boolean bold = (effect & (TextStyle.CHARACTER_ATTRIBUTE_BOLD | TextStyle.CHARACTER_ATTRIBUTE_BLINK)) != 0;
+ final boolean underline = (effect & TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE) != 0;
+ final boolean italic = (effect & TextStyle.CHARACTER_ATTRIBUTE_ITALIC) != 0;
+ final boolean strikeThrough = (effect & TextStyle.CHARACTER_ATTRIBUTE_STRIKETHROUGH) != 0;
+ final boolean dim = (effect & TextStyle.CHARACTER_ATTRIBUTE_DIM) != 0;
- // Let bold have bright colors if applicable (one of the first 8):
- final int actualForeColor = foreColor + (bold && foreColor < 8 ? 8 : 0);
+ // Let bold have bright colors if applicable (one of the first 8):
+ final int actualForeColor = foreColor + (bold && foreColor < 8 ? 8 : 0);
- int foreColorARGB = palette[actualForeColor];
- if (dim) {
- int red = (0xFF & (foreColorARGB >> 16));
- int green = (0xFF & (foreColorARGB >> 8));
- int blue = (0xFF & foreColorARGB);
- // Dim color handling used by libvte which in turn took it from xterm
- // (https://bug735245.bugzilla-attachments.gnome.org/attachment.cgi?id=284267):
- red = red * 2 / 3;
- green = green * 2 / 3;
- blue = blue * 2 / 3;
- foreColorARGB = 0xFF000000 + (red << 16) + (green << 8) + blue;
- }
+ int foreColorARGB = palette[actualForeColor];
+ if (dim) {
+ int red = (0xFF & (foreColorARGB >> 16));
+ int green = (0xFF & (foreColorARGB >> 8));
+ int blue = (0xFF & foreColorARGB);
+ // Dim color handling used by libvte which in turn took it from xterm
+ // (https://bug735245.bugzilla-attachments.gnome.org/attachment.cgi?id=284267):
+ red = red * 2 / 3;
+ green = green * 2 / 3;
+ blue = blue * 2 / 3;
+ foreColorARGB = 0xFF000000 + (red << 16) + (green << 8) + blue;
+ }
- mTextPaint.setFakeBoldText(bold);
- mTextPaint.setUnderlineText(underline);
- mTextPaint.setTextSkewX(italic ? -0.35f : 0.f);
- mTextPaint.setStrikeThruText(strikeThrough);
- mTextPaint.setColor(foreColorARGB);
+ mTextPaint.setFakeBoldText(bold);
+ mTextPaint.setUnderlineText(underline);
+ mTextPaint.setTextSkewX(italic ? -0.35f : 0.f);
+ mTextPaint.setStrikeThruText(strikeThrough);
+ mTextPaint.setColor(foreColorARGB);
- // The text alignment is the default Paint.Align.LEFT.
- canvas.drawText(text, startCharIndex, runWidthChars, left, y - mFontLineSpacingAndAscent, mTextPaint);
- }
+ // The text alignment is the default Paint.Align.LEFT.
+ canvas.drawText(text, startCharIndex, runWidthChars, left, y - mFontLineSpacingAndAscent, mTextPaint);
+ }
- if (savedMatrix) canvas.restore();
- }
+ if (savedMatrix) canvas.restore();
+ }
}
diff --git a/app/src/main/java/com/termux/view/TerminalView.java b/app/src/main/java/com/termux/view/TerminalView.java
index 49bbd387..d33f9940 100644
--- a/app/src/main/java/com/termux/view/TerminalView.java
+++ b/app/src/main/java/com/termux/view/TerminalView.java
@@ -42,208 +42,209 @@ public final class TerminalView extends View {
/** Log view key and IME events. */
private static final boolean LOG_KEY_EVENTS = false;
- /** The currently displayed terminal session, whose emulator is {@link #mEmulator}. */
- TerminalSession mTermSession;
- /** Our terminal emulator whose session is {@link #mTermSession}. */
- TerminalEmulator mEmulator;
+ /** The currently displayed terminal session, whose emulator is {@link #mEmulator}. */
+ TerminalSession mTermSession;
+ /** Our terminal emulator whose session is {@link #mTermSession}. */
+ TerminalEmulator mEmulator;
- TerminalRenderer mRenderer;
+ TerminalRenderer mRenderer;
- TerminalKeyListener mOnKeyListener;
+ TerminalKeyListener mOnKeyListener;
- /** The top row of text to display. Ranges from -activeTranscriptRows to 0. */
- int mTopRow;
+ /** The top row of text to display. Ranges from -activeTranscriptRows to 0. */
+ int mTopRow;
- boolean mIsSelectingText = false, mIsDraggingLeftSelection, mInitialTextSelection;
- int mSelX1 = -1, mSelX2 = -1, mSelY1 = -1, mSelY2 = -1;
- float mSelectionDownX, mSelectionDownY;
- private ActionMode mActionMode;
- private BitmapDrawable mLeftSelectionHandle, mRightSelectionHandle;
+ boolean mIsSelectingText = false, mIsDraggingLeftSelection, mInitialTextSelection;
+ int mSelX1 = -1, mSelX2 = -1, mSelY1 = -1, mSelY2 = -1;
+ float mSelectionDownX, mSelectionDownY;
+ private ActionMode mActionMode;
+ private BitmapDrawable mLeftSelectionHandle, mRightSelectionHandle;
- float mScaleFactor = 1.f;
- final GestureAndScaleRecognizer mGestureRecognizer;
+ float mScaleFactor = 1.f;
+ final GestureAndScaleRecognizer mGestureRecognizer;
- /** Keep track of where mouse touch event started which we report as mouse scroll. */
- private int mMouseScrollStartX = -1, mMouseScrollStartY = -1;
- /** Keep track of the time when a touch event leading to sending mouse scroll events started. */
- private long mMouseStartDownTime = -1;
+ /** Keep track of where mouse touch event started which we report as mouse scroll. */
+ private int mMouseScrollStartX = -1, mMouseScrollStartY = -1;
+ /** Keep track of the time when a touch event leading to sending mouse scroll events started. */
+ private long mMouseStartDownTime = -1;
- final Scroller mScroller;
+ final Scroller mScroller;
- /** What was left in from scrolling movement. */
- float mScrollRemainder;
+ /** What was left in from scrolling movement. */
+ float mScrollRemainder;
- /** If non-zero, this is the last unicode code point received if that was a combining character. */
- int mCombiningAccent;
+ /** If non-zero, this is the last unicode code point received if that was a combining character. */
+ int mCombiningAccent;
- public TerminalView(Context context, AttributeSet attributes) { // NO_UCD (unused code)
- super(context, attributes);
- mGestureRecognizer = new GestureAndScaleRecognizer(context, new GestureAndScaleRecognizer.Listener() {
+ public TerminalView(Context context, AttributeSet attributes) { // NO_UCD (unused code)
+ super(context, attributes);
+ mGestureRecognizer = new GestureAndScaleRecognizer(context, new GestureAndScaleRecognizer.Listener() {
- @Override
- public boolean onUp(MotionEvent e) {
- mScrollRemainder = 0.0f;
- if (mEmulator != null && mEmulator.isMouseTrackingActive() && !mIsSelectingText) {
- // Quick event processing when mouse tracking is active - do not wait for check of double tapping
- // for zooming.
- sendMouseEventCode(e, TerminalEmulator.MOUSE_LEFT_BUTTON, true);
- sendMouseEventCode(e, TerminalEmulator.MOUSE_LEFT_BUTTON, false);
- return true;
- }
- return false;
- }
+ @Override
+ public boolean onUp(MotionEvent e) {
+ mScrollRemainder = 0.0f;
+ if (mEmulator != null && mEmulator.isMouseTrackingActive() && !mIsSelectingText) {
+ // Quick event processing when mouse tracking is active - do not wait for check of double tapping
+ // for zooming.
+ sendMouseEventCode(e, TerminalEmulator.MOUSE_LEFT_BUTTON, true);
+ sendMouseEventCode(e, TerminalEmulator.MOUSE_LEFT_BUTTON, false);
+ return true;
+ }
+ return false;
+ }
- @Override
- public boolean onSingleTapUp(MotionEvent e) {
- if (mEmulator == null) return true;
- if (mIsSelectingText) { toggleSelectingText(null); return true; }
- requestFocus();
- if (!mEmulator.isMouseTrackingActive()) {
- if (!e.isFromSource(InputDevice.SOURCE_MOUSE)) {
- mOnKeyListener.onSingleTapUp(e);
- return true;
- }
- }
- return false;
- }
+ @Override
+ public boolean onSingleTapUp(MotionEvent e) {
+ if (mEmulator == null) return true;
+ if (mIsSelectingText) {
+ toggleSelectingText(null);
+ return true;
+ }
+ requestFocus();
+ if (!mEmulator.isMouseTrackingActive()) {
+ if (!e.isFromSource(InputDevice.SOURCE_MOUSE)) {
+ mOnKeyListener.onSingleTapUp(e);
+ return true;
+ }
+ }
+ return false;
+ }
- @Override
- public boolean onScroll(MotionEvent e2, float distanceX, float distanceY) {
- if (mEmulator == null || mIsSelectingText) return true;
- if (mEmulator.isMouseTrackingActive() && e2.isFromSource(InputDevice.SOURCE_MOUSE)) {
- // If moving with mouse pointer while pressing button, report that instead of scroll.
- // This means that we never report moving with button press-events for touch input,
- // since we cannot just start sending these events without a starting press event,
- // which we do not do for touch input, only mouse in onTouchEvent().
- sendMouseEventCode(e2, TerminalEmulator.MOUSE_LEFT_BUTTON_MOVED, true);
- } else {
- distanceY += mScrollRemainder;
- int deltaRows = (int) (distanceY / mRenderer.mFontLineSpacing);
- mScrollRemainder = distanceY - deltaRows * mRenderer.mFontLineSpacing;
- doScroll(e2, deltaRows);
- }
- return true;
- }
+ @Override
+ public boolean onScroll(MotionEvent e2, float distanceX, float distanceY) {
+ if (mEmulator == null || mIsSelectingText) return true;
+ if (mEmulator.isMouseTrackingActive() && e2.isFromSource(InputDevice.SOURCE_MOUSE)) {
+ // If moving with mouse pointer while pressing button, report that instead of scroll.
+ // This means that we never report moving with button press-events for touch input,
+ // since we cannot just start sending these events without a starting press event,
+ // which we do not do for touch input, only mouse in onTouchEvent().
+ sendMouseEventCode(e2, TerminalEmulator.MOUSE_LEFT_BUTTON_MOVED, true);
+ } else {
+ distanceY += mScrollRemainder;
+ int deltaRows = (int) (distanceY / mRenderer.mFontLineSpacing);
+ mScrollRemainder = distanceY - deltaRows * mRenderer.mFontLineSpacing;
+ doScroll(e2, deltaRows);
+ }
+ return true;
+ }
- @Override
- public boolean onScale(float focusX, float focusY, float scale) {
- if (mEmulator == null || mIsSelectingText) return true;
- mScaleFactor *= scale;
- mScaleFactor = mOnKeyListener.onScale(mScaleFactor);
- return true;
- }
+ @Override
+ public boolean onScale(float focusX, float focusY, float scale) {
+ if (mEmulator == null || mIsSelectingText) return true;
+ mScaleFactor *= scale;
+ mScaleFactor = mOnKeyListener.onScale(mScaleFactor);
+ return true;
+ }
- @Override
- public boolean onFling(final MotionEvent e2, float velocityX, float velocityY) {
- if (mEmulator == null || mIsSelectingText) return true;
- // Do not start scrolling until last fling has been taken care of:
- if (!mScroller.isFinished()) return true;
+ @Override
+ public boolean onFling(final MotionEvent e2, float velocityX, float velocityY) {
+ if (mEmulator == null || mIsSelectingText) return true;
+ // Do not start scrolling until last fling has been taken care of:
+ if (!mScroller.isFinished()) return true;
- final boolean mouseTrackingAtStartOfFling = mEmulator.isMouseTrackingActive();
- float SCALE = 0.25f;
- if (mouseTrackingAtStartOfFling) {
- mScroller.fling(0, 0, 0, -(int) (velocityY * SCALE), 0, 0, -mEmulator.mRows / 2, mEmulator.mRows / 2);
- } else {
- mScroller.fling(0, mTopRow, 0, -(int) (velocityY * SCALE), 0, 0, -mEmulator.getScreen().getActiveTranscriptRows(), 0);
- }
+ final boolean mouseTrackingAtStartOfFling = mEmulator.isMouseTrackingActive();
+ float SCALE = 0.25f;
+ if (mouseTrackingAtStartOfFling) {
+ mScroller.fling(0, 0, 0, -(int) (velocityY * SCALE), 0, 0, -mEmulator.mRows / 2, mEmulator.mRows / 2);
+ } else {
+ mScroller.fling(0, mTopRow, 0, -(int) (velocityY * SCALE), 0, 0, -mEmulator.getScreen().getActiveTranscriptRows(), 0);
+ }
- post(new Runnable() {
- private int mLastY = 0;
+ post(new Runnable() {
+ private int mLastY = 0;
- @Override
- public void run() {
- if (mouseTrackingAtStartOfFling != mEmulator.isMouseTrackingActive()) {
- mScroller.abortAnimation();
- return;
- }
- if (mScroller.isFinished()) return;
- boolean more = mScroller.computeScrollOffset();
- int newY = mScroller.getCurrY();
- int diff = mouseTrackingAtStartOfFling ? (newY - mLastY) : (newY - mTopRow);
- doScroll(e2, diff);
- mLastY = newY;
- if (more) post(this);
- }
- });
+ @Override
+ public void run() {
+ if (mouseTrackingAtStartOfFling != mEmulator.isMouseTrackingActive()) {
+ mScroller.abortAnimation();
+ return;
+ }
+ if (mScroller.isFinished()) return;
+ boolean more = mScroller.computeScrollOffset();
+ int newY = mScroller.getCurrY();
+ int diff = mouseTrackingAtStartOfFling ? (newY - mLastY) : (newY - mTopRow);
+ doScroll(e2, diff);
+ mLastY = newY;
+ if (more) post(this);
+ }
+ });
- return true;
- }
+ return true;
+ }
- @Override
- public boolean onDown(float x, float y) {
- return false;
- }
+ @Override
+ public boolean onDown(float x, float y) {
+ return false;
+ }
- @Override
- public boolean onDoubleTap(MotionEvent e) {
- // Do not treat is as a single confirmed tap - it may be followed by zoom.
- return false;
- }
+ @Override
+ public boolean onDoubleTap(MotionEvent e) {
+ // Do not treat is as a single confirmed tap - it may be followed by zoom.
+ return false;
+ }
- @Override
- public void onLongPress(MotionEvent e) {
- if (!mGestureRecognizer.isInProgress() && !mIsSelectingText) {
- performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
- toggleSelectingText(e);
- }
- }
- });
- mScroller = new Scroller(context);
- }
+ @Override
+ public void onLongPress(MotionEvent e) {
+ if (!mGestureRecognizer.isInProgress() && !mIsSelectingText) {
+ performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
+ toggleSelectingText(e);
+ }
+ }
+ });
+ mScroller = new Scroller(context);
+ }
- /**
- * @param onKeyListener
- * Listener for all kinds of key events, both hardware and IME (which makes it different from that
- * available with {@link View#setOnKeyListener(OnKeyListener)}.
- */
- public void setOnKeyListener(TerminalKeyListener onKeyListener) {
- this.mOnKeyListener = onKeyListener;
- }
+ /**
+ * @param onKeyListener Listener for all kinds of key events, both hardware and IME (which makes it different from that
+ * available with {@link View#setOnKeyListener(OnKeyListener)}.
+ */
+ public void setOnKeyListener(TerminalKeyListener onKeyListener) {
+ this.mOnKeyListener = onKeyListener;
+ }
- /**
- * Attach a {@link TerminalSession} to this view.
- *
- * @param session
- * The {@link TerminalSession} this view will be displaying.
- */
- public boolean attachSession(TerminalSession session) {
- if (session == mTermSession) return false;
- mTopRow = 0;
+ /**
+ * Attach a {@link TerminalSession} to this view.
+ *
+ * @param session The {@link TerminalSession} this view will be displaying.
+ */
+ public boolean attachSession(TerminalSession session) {
+ if (session == mTermSession) return false;
+ mTopRow = 0;
- mTermSession = session;
- mEmulator = null;
- mCombiningAccent = 0;
+ mTermSession = session;
+ mEmulator = null;
+ mCombiningAccent = 0;
- updateSize();
+ updateSize();
- // Wait with enabling the scrollbar until we have a terminal to get scroll position from.
- setVerticalScrollBarEnabled(true);
+ // Wait with enabling the scrollbar until we have a terminal to get scroll position from.
+ setVerticalScrollBarEnabled(true);
- return true;
- }
+ return true;
+ }
- @Override
- public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
- // Make the IME run in a limited "generate key events" mode.
- //
- // If using just "TYPE_NULL", there is a problem with the "Google Pinyin Input" being in
- // word mode when used with the "En" tab available when the "Show English keyboard" option
- // is enabled - see https://github.com/termux/termux-packages/issues/25. It also causes
+ @Override
+ public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
+ // Make the IME run in a limited "generate key events" mode.
+ //
+ // If using just "TYPE_NULL", there is a problem with the "Google Pinyin Input" being in
+ // word mode when used with the "En" tab available when the "Show English keyboard" option
+ // is enabled - see https://github.com/termux/termux-packages/issues/25. It also causes
// the normal Google keyboard to show a row of numbers, see
// https://github.com/termux/termux-app/issues/87
- //
- // Adding TYPE_TEXT_FLAG_NO_SUGGESTIONS fixes Pinyin Input and removes the row of numbers
+ //
+ // Adding TYPE_TEXT_FLAG_NO_SUGGESTIONS fixes Pinyin Input and removes the row of numbers
// on the Google keyboard. . It also causes Swype to be put in
- // word mode, but using TYPE_TEXT_VARIATION_VISIBLE_PASSWORD fixes that.
- //
- // So a bit messy. If this gets too messy it's perhaps best resolved by reverting back to just
- // "TYPE_NULL" and let the Pinyin Input english keyboard be in word mode.
- outAttrs.inputType = InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS | InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD;
+ // word mode, but using TYPE_TEXT_VARIATION_VISIBLE_PASSWORD fixes that.
+ //
+ // So a bit messy. If this gets too messy it's perhaps best resolved by reverting back to just
+ // "TYPE_NULL" and let the Pinyin Input english keyboard be in word mode.
+ outAttrs.inputType = InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS | InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD;
- // Let part of the application show behind when in landscape:
- outAttrs.imeOptions |= EditorInfo.IME_FLAG_NO_FULLSCREEN;
+ // Let part of the application show behind when in landscape:
+ outAttrs.imeOptions |= EditorInfo.IME_FLAG_NO_FULLSCREEN;
- return new BaseInputConnection(this, true) {
+ return new BaseInputConnection(this, true) {
@Override
public boolean finishComposingText() {
@@ -258,53 +259,65 @@ public final class TerminalView extends View {
@Override
public boolean commitText(CharSequence text, int newCursorPosition) {
- if (LOG_KEY_EVENTS) Log.i(EmulatorDebug.LOG_TAG, "IME: commitText(\"" + text + "\", " + newCursorPosition + ")");
- if (mEmulator == null) return true;
- final int textLengthInChars = text.length();
- for (int i = 0; i < textLengthInChars; i++) {
- char firstChar = text.charAt(i);
- int codePoint;
- if (Character.isHighSurrogate(firstChar)) {
- if (++i < textLengthInChars) {
- codePoint = Character.toCodePoint(firstChar, text.charAt(i));
- } else {
- // At end of string, with no low surrogate following the high:
- codePoint = TerminalEmulator.UNICODE_REPLACEMENT_CHAR;
- }
- } else {
- codePoint = firstChar;
- }
+ if (LOG_KEY_EVENTS)
+ Log.i(EmulatorDebug.LOG_TAG, "IME: commitText(\"" + text + "\", " + newCursorPosition + ")");
+ if (mEmulator == null) return true;
+ final int textLengthInChars = text.length();
+ for (int i = 0; i < textLengthInChars; i++) {
+ char firstChar = text.charAt(i);
+ int codePoint;
+ if (Character.isHighSurrogate(firstChar)) {
+ if (++i < textLengthInChars) {
+ codePoint = Character.toCodePoint(firstChar, text.charAt(i));
+ } else {
+ // At end of string, with no low surrogate following the high:
+ codePoint = TerminalEmulator.UNICODE_REPLACEMENT_CHAR;
+ }
+ } else {
+ codePoint = firstChar;
+ }
boolean ctrlHeld = false;
if (codePoint <= 31 && codePoint != 27) {
// E.g. penti keyboard for ctrl input.
ctrlHeld = true;
switch (codePoint) {
- case 31: codePoint = '_'; break;
- case 30: codePoint = '^'; break;
- case 29: codePoint = ']'; break;
- case 28: codePoint = '\\'; break;
- default: codePoint += 96; break;
+ case 31:
+ codePoint = '_';
+ break;
+ case 30:
+ codePoint = '^';
+ break;
+ case 29:
+ codePoint = ']';
+ break;
+ case 28:
+ codePoint = '\\';
+ break;
+ default:
+ codePoint += 96;
+ break;
}
}
inputCodePoint(codePoint, ctrlHeld, false);
- }
+ }
return true;
- }
+ }
- @Override
- public boolean deleteSurroundingText(int leftLength, int rightLength) {
- if (LOG_KEY_EVENTS) Log.i(EmulatorDebug.LOG_TAG, "IME: deleteSurroundingText(" + leftLength + ", " + rightLength + ")");
+ @Override
+ public boolean deleteSurroundingText(int leftLength, int rightLength) {
+ if (LOG_KEY_EVENTS)
+ Log.i(EmulatorDebug.LOG_TAG, "IME: deleteSurroundingText(" + leftLength + ", " + rightLength + ")");
- // Swype keyboard sometimes(?) sends this on backspace:
- if (leftLength == 0 && rightLength == 0) leftLength = 1;
+ // Swype keyboard sometimes(?) sends this on backspace:
+ if (leftLength == 0 && rightLength == 0) leftLength = 1;
- for (int i = 0; i < leftLength; i++)
- sendKeyEvent(new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DEL));
- return true;
- }
+ for (int i = 0; i < leftLength; i++)
+ sendKeyEvent(new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DEL));
+ return true;
+ }
@Override
public boolean setComposingText(CharSequence text, int newCursorPosition) {
@@ -318,69 +331,68 @@ public final class TerminalView extends View {
return true;
}
};
- }
+ }
- @Override
- protected int computeVerticalScrollRange() {
- return mEmulator == null ? 1 : mEmulator.getScreen().getActiveRows();
- }
+ @Override
+ protected int computeVerticalScrollRange() {
+ return mEmulator == null ? 1 : mEmulator.getScreen().getActiveRows();
+ }
- @Override
- protected int computeVerticalScrollExtent() {
- return mEmulator == null ? 1 : mEmulator.mRows;
- }
+ @Override
+ protected int computeVerticalScrollExtent() {
+ return mEmulator == null ? 1 : mEmulator.mRows;
+ }
- @Override
- protected int computeVerticalScrollOffset() {
- return mEmulator == null ? 1 : mEmulator.getScreen().getActiveRows() + mTopRow - mEmulator.mRows;
- }
+ @Override
+ protected int computeVerticalScrollOffset() {
+ return mEmulator == null ? 1 : mEmulator.getScreen().getActiveRows() + mTopRow - mEmulator.mRows;
+ }
- public void onScreenUpdated() {
- if (mEmulator == null) return;
+ public void onScreenUpdated() {
+ if (mEmulator == null) return;
- boolean skipScrolling = false;
- if (mIsSelectingText) {
- // Do not scroll when selecting text.
- int rowsInHistory = mEmulator.getScreen().getActiveTranscriptRows();
- int rowShift = mEmulator.getScrollCounter();
- if (-mTopRow + rowShift > rowsInHistory) {
- // .. unless we're hitting the end of history transcript, in which
- // case we abort text selection and scroll to end.
- toggleSelectingText(null);
- } else {
- skipScrolling = true;
- mTopRow -= rowShift;
- mSelY1 -= rowShift;
- mSelY2 -= rowShift;
- }
- }
+ boolean skipScrolling = false;
+ if (mIsSelectingText) {
+ // Do not scroll when selecting text.
+ int rowsInHistory = mEmulator.getScreen().getActiveTranscriptRows();
+ int rowShift = mEmulator.getScrollCounter();
+ if (-mTopRow + rowShift > rowsInHistory) {
+ // .. unless we're hitting the end of history transcript, in which
+ // case we abort text selection and scroll to end.
+ toggleSelectingText(null);
+ } else {
+ skipScrolling = true;
+ mTopRow -= rowShift;
+ mSelY1 -= rowShift;
+ mSelY2 -= rowShift;
+ }
+ }
- if (!skipScrolling && mTopRow != 0) {
- // Scroll down if not already there.
- if (mTopRow < -3) {
- // Awaken scroll bars only if scrolling a noticeable amount
- // - we do not want visible scroll bars during normal typing
- // of one row at a time.
- awakenScrollBars();
- }
- mTopRow = 0;
- }
+ if (!skipScrolling && mTopRow != 0) {
+ // Scroll down if not already there.
+ if (mTopRow < -3) {
+ // Awaken scroll bars only if scrolling a noticeable amount
+ // - we do not want visible scroll bars during normal typing
+ // of one row at a time.
+ awakenScrollBars();
+ }
+ mTopRow = 0;
+ }
- mEmulator.clearScrollCounter();
+ mEmulator.clearScrollCounter();
- invalidate();
- }
+ invalidate();
+ }
- /**
- * Sets the text size, which in turn sets the number of rows and columns.
- *
- * @param textSize
- * the new font size, in density-independent pixels.
- */
- public void setTextSize(int textSize) {
- mRenderer = new TerminalRenderer(textSize, mRenderer == null ? Typeface.MONOSPACE : mRenderer.mTypeface);
- updateSize();
- }
+ /**
+ * Sets the text size, which in turn sets the number of rows and columns.
+ *
+ * @param textSize the new font size, in density-independent pixels.
+ */
+ public void setTextSize(int textSize) {
+ mRenderer = new TerminalRenderer(textSize, mRenderer == null ? Typeface.MONOSPACE : mRenderer.mTypeface);
+ updateSize();
+ }
public void setTypeface(Typeface newTypeface) {
mRenderer = new TerminalRenderer(mRenderer.mTextSize, newTypeface);
@@ -388,180 +400,185 @@ public final class TerminalView extends View {
invalidate();
}
- @Override
- public boolean onCheckIsTextEditor() {
- return true;
- }
+ @Override
+ public boolean onCheckIsTextEditor() {
+ return true;
+ }
- @Override
- public boolean isOpaque() {
- return true;
- }
+ @Override
+ public boolean isOpaque() {
+ return true;
+ }
- /** Send a single mouse event code to the terminal. */
- void sendMouseEventCode(MotionEvent e, int button, boolean pressed) {
- int x = (int) (e.getX() / mRenderer.mFontWidth) + 1;
- int y = (int) ((e.getY() - mRenderer.mFontLineSpacingAndAscent) / mRenderer.mFontLineSpacing) + 1;
- if (pressed && (button == TerminalEmulator.MOUSE_WHEELDOWN_BUTTON || button == TerminalEmulator.MOUSE_WHEELUP_BUTTON)) {
- if (mMouseStartDownTime == e.getDownTime()) {
- x = mMouseScrollStartX;
- y = mMouseScrollStartY;
- } else {
- mMouseStartDownTime = e.getDownTime();
- mMouseScrollStartX = x;
- mMouseScrollStartY = y;
- }
- }
- mEmulator.sendMouseEvent(button, x, y, pressed);
- }
+ /** Send a single mouse event code to the terminal. */
+ void sendMouseEventCode(MotionEvent e, int button, boolean pressed) {
+ int x = (int) (e.getX() / mRenderer.mFontWidth) + 1;
+ int y = (int) ((e.getY() - mRenderer.mFontLineSpacingAndAscent) / mRenderer.mFontLineSpacing) + 1;
+ if (pressed && (button == TerminalEmulator.MOUSE_WHEELDOWN_BUTTON || button == TerminalEmulator.MOUSE_WHEELUP_BUTTON)) {
+ if (mMouseStartDownTime == e.getDownTime()) {
+ x = mMouseScrollStartX;
+ y = mMouseScrollStartY;
+ } else {
+ mMouseStartDownTime = e.getDownTime();
+ mMouseScrollStartX = x;
+ mMouseScrollStartY = y;
+ }
+ }
+ mEmulator.sendMouseEvent(button, x, y, pressed);
+ }
- /** Perform a scroll, either from dragging the screen or by scrolling a mouse wheel. */
- void doScroll(MotionEvent event, int rowsDown) {
- boolean up = rowsDown < 0;
- int amount = Math.abs(rowsDown);
- for (int i = 0; i < amount; i++) {
- if (mEmulator.isMouseTrackingActive()) {
- sendMouseEventCode(event, up ? TerminalEmulator.MOUSE_WHEELUP_BUTTON : TerminalEmulator.MOUSE_WHEELDOWN_BUTTON, true);
- } else if (mEmulator.isAlternateBufferActive()) {
- // Send up and down key events for scrolling, which is what some terminals do to make scroll work in
- // e.g. less, which shifts to the alt screen without mouse handling.
- handleKeyCode(up ? KeyEvent.KEYCODE_DPAD_UP : KeyEvent.KEYCODE_DPAD_DOWN, 0);
- } else {
- mTopRow = Math.min(0, Math.max(-(mEmulator.getScreen().getActiveTranscriptRows()), mTopRow + (up ? -1 : 1)));
- if (!awakenScrollBars()) invalidate();
- }
- }
- }
+ /** Perform a scroll, either from dragging the screen or by scrolling a mouse wheel. */
+ void doScroll(MotionEvent event, int rowsDown) {
+ boolean up = rowsDown < 0;
+ int amount = Math.abs(rowsDown);
+ for (int i = 0; i < amount; i++) {
+ if (mEmulator.isMouseTrackingActive()) {
+ sendMouseEventCode(event, up ? TerminalEmulator.MOUSE_WHEELUP_BUTTON : TerminalEmulator.MOUSE_WHEELDOWN_BUTTON, true);
+ } else if (mEmulator.isAlternateBufferActive()) {
+ // Send up and down key events for scrolling, which is what some terminals do to make scroll work in
+ // e.g. less, which shifts to the alt screen without mouse handling.
+ handleKeyCode(up ? KeyEvent.KEYCODE_DPAD_UP : KeyEvent.KEYCODE_DPAD_DOWN, 0);
+ } else {
+ mTopRow = Math.min(0, Math.max(-(mEmulator.getScreen().getActiveTranscriptRows()), mTopRow + (up ? -1 : 1)));
+ if (!awakenScrollBars()) invalidate();
+ }
+ }
+ }
- /** Overriding {@link View#onGenericMotionEvent(MotionEvent)}. */
- @Override
- public boolean onGenericMotionEvent(MotionEvent event) {
- if (mEmulator != null && event.isFromSource(InputDevice.SOURCE_MOUSE) && event.getAction() == MotionEvent.ACTION_SCROLL) {
- // Handle mouse wheel scrolling.
- boolean up = event.getAxisValue(MotionEvent.AXIS_VSCROLL) > 0.0f;
- doScroll(event, up ? -3 : 3);
- return true;
- }
- return false;
- }
+ /** Overriding {@link View#onGenericMotionEvent(MotionEvent)}. */
+ @Override
+ public boolean onGenericMotionEvent(MotionEvent event) {
+ if (mEmulator != null && event.isFromSource(InputDevice.SOURCE_MOUSE) && event.getAction() == MotionEvent.ACTION_SCROLL) {
+ // Handle mouse wheel scrolling.
+ boolean up = event.getAxisValue(MotionEvent.AXIS_VSCROLL) > 0.0f;
+ doScroll(event, up ? -3 : 3);
+ return true;
+ }
+ return false;
+ }
- @SuppressLint("ClickableViewAccessibility")
- @Override
- @TargetApi(23)
- public boolean onTouchEvent(MotionEvent ev) {
- if (mEmulator == null) return true;
- final int action = ev.getAction();
+ @SuppressLint("ClickableViewAccessibility")
+ @Override
+ @TargetApi(23)
+ public boolean onTouchEvent(MotionEvent ev) {
+ if (mEmulator == null) return true;
+ final int action = ev.getAction();
- if (mIsSelectingText) {
- int cy = (int) (ev.getY() / mRenderer.mFontLineSpacing) + mTopRow;
- int cx = (int) (ev.getX() / mRenderer.mFontWidth);
+ if (mIsSelectingText) {
+ int cy = (int) (ev.getY() / mRenderer.mFontLineSpacing) + mTopRow;
+ int cx = (int) (ev.getX() / mRenderer.mFontWidth);
- switch (action) {
- case MotionEvent.ACTION_UP:
- mInitialTextSelection = false;
- break;
- case MotionEvent.ACTION_DOWN:
- int distanceFromSel1 = Math.abs(cx-mSelX1) + Math.abs(cy-mSelY1);
- int distanceFromSel2 = Math.abs(cx-mSelX2) + Math.abs(cy-mSelY2);
- mIsDraggingLeftSelection = distanceFromSel1 <= distanceFromSel2;
- mSelectionDownX = ev.getX();
- mSelectionDownY = ev.getY();
- break;
- case MotionEvent.ACTION_MOVE:
- if (mInitialTextSelection) break;
- float deltaX = ev.getX() - mSelectionDownX;
- float deltaY = ev.getY() - mSelectionDownY;
- int deltaCols = (int) Math.ceil(deltaX / mRenderer.mFontWidth);
- int deltaRows = (int) Math.ceil(deltaY / mRenderer.mFontLineSpacing);
- mSelectionDownX += deltaCols * mRenderer.mFontWidth;
- mSelectionDownY += deltaRows * mRenderer.mFontLineSpacing;
- if (mIsDraggingLeftSelection) {
- mSelX1 += deltaCols;
- mSelY1 += deltaRows;
- } else {
- mSelX2 += deltaCols;
- mSelY2 += deltaRows;
- }
+ switch (action) {
+ case MotionEvent.ACTION_UP:
+ mInitialTextSelection = false;
+ break;
+ case MotionEvent.ACTION_DOWN:
+ int distanceFromSel1 = Math.abs(cx - mSelX1) + Math.abs(cy - mSelY1);
+ int distanceFromSel2 = Math.abs(cx - mSelX2) + Math.abs(cy - mSelY2);
+ mIsDraggingLeftSelection = distanceFromSel1 <= distanceFromSel2;
+ mSelectionDownX = ev.getX();
+ mSelectionDownY = ev.getY();
+ break;
+ case MotionEvent.ACTION_MOVE:
+ if (mInitialTextSelection) break;
+ float deltaX = ev.getX() - mSelectionDownX;
+ float deltaY = ev.getY() - mSelectionDownY;
+ int deltaCols = (int) Math.ceil(deltaX / mRenderer.mFontWidth);
+ int deltaRows = (int) Math.ceil(deltaY / mRenderer.mFontLineSpacing);
+ mSelectionDownX += deltaCols * mRenderer.mFontWidth;
+ mSelectionDownY += deltaRows * mRenderer.mFontLineSpacing;
+ if (mIsDraggingLeftSelection) {
+ mSelX1 += deltaCols;
+ mSelY1 += deltaRows;
+ } else {
+ mSelX2 += deltaCols;
+ mSelY2 += deltaRows;
+ }
- mSelX1 = Math.min(mEmulator.mColumns, Math.max(0, mSelX1));
- mSelX2 = Math.min(mEmulator.mColumns, Math.max(0, mSelX2));
+ mSelX1 = Math.min(mEmulator.mColumns, Math.max(0, mSelX1));
+ mSelX2 = Math.min(mEmulator.mColumns, Math.max(0, mSelX2));
- if (mSelY1 == mSelY2 && mSelX1 > mSelX2 || mSelY1 > mSelY2) {
- // Switch handles.
- mIsDraggingLeftSelection = !mIsDraggingLeftSelection;
- int tmpX1 = mSelX1, tmpY1 = mSelY1;
- mSelX1 = mSelX2; mSelY1 = mSelY2;
- mSelX2 = tmpX1; mSelY2 = tmpY1;
- }
+ if (mSelY1 == mSelY2 && mSelX1 > mSelX2 || mSelY1 > mSelY2) {
+ // Switch handles.
+ mIsDraggingLeftSelection = !mIsDraggingLeftSelection;
+ int tmpX1 = mSelX1, tmpY1 = mSelY1;
+ mSelX1 = mSelX2;
+ mSelY1 = mSelY2;
+ mSelX2 = tmpX1;
+ mSelY2 = tmpY1;
+ }
- if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) mActionMode.invalidateContentRect();
- invalidate();
- break;
- default:
- break;
- }
- mGestureRecognizer.onTouchEvent(ev);
- return true;
- } else if (ev.isFromSource(InputDevice.SOURCE_MOUSE)) {
- if (ev.isButtonPressed(MotionEvent.BUTTON_SECONDARY)) {
- if (action == MotionEvent.ACTION_DOWN) showContextMenu();
- return true;
- } else if (ev.isButtonPressed(MotionEvent.BUTTON_TERTIARY)) {
- ClipboardManager clipboard = (ClipboardManager) getContext().getSystemService(Context.CLIPBOARD_SERVICE);
- ClipData clipData = clipboard.getPrimaryClip();
- if (clipData != null) {
- CharSequence paste = clipData.getItemAt(0).coerceToText(getContext());
- if (!TextUtils.isEmpty(paste)) mEmulator.paste(paste.toString());
- }
- } else if (mEmulator.isMouseTrackingActive()) { // BUTTON_PRIMARY.
- switch (ev.getAction()) {
- case MotionEvent.ACTION_DOWN:
- case MotionEvent.ACTION_UP:
- sendMouseEventCode(ev, TerminalEmulator.MOUSE_LEFT_BUTTON, ev.getAction() == MotionEvent.ACTION_DOWN);
- break;
- case MotionEvent.ACTION_MOVE:
- sendMouseEventCode(ev, TerminalEmulator.MOUSE_LEFT_BUTTON_MOVED, true);
- break;
- }
- return true;
- }
- }
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
+ mActionMode.invalidateContentRect();
+ invalidate();
+ break;
+ default:
+ break;
+ }
+ mGestureRecognizer.onTouchEvent(ev);
+ return true;
+ } else if (ev.isFromSource(InputDevice.SOURCE_MOUSE)) {
+ if (ev.isButtonPressed(MotionEvent.BUTTON_SECONDARY)) {
+ if (action == MotionEvent.ACTION_DOWN) showContextMenu();
+ return true;
+ } else if (ev.isButtonPressed(MotionEvent.BUTTON_TERTIARY)) {
+ ClipboardManager clipboard = (ClipboardManager) getContext().getSystemService(Context.CLIPBOARD_SERVICE);
+ ClipData clipData = clipboard.getPrimaryClip();
+ if (clipData != null) {
+ CharSequence paste = clipData.getItemAt(0).coerceToText(getContext());
+ if (!TextUtils.isEmpty(paste)) mEmulator.paste(paste.toString());
+ }
+ } else if (mEmulator.isMouseTrackingActive()) { // BUTTON_PRIMARY.
+ switch (ev.getAction()) {
+ case MotionEvent.ACTION_DOWN:
+ case MotionEvent.ACTION_UP:
+ sendMouseEventCode(ev, TerminalEmulator.MOUSE_LEFT_BUTTON, ev.getAction() == MotionEvent.ACTION_DOWN);
+ break;
+ case MotionEvent.ACTION_MOVE:
+ sendMouseEventCode(ev, TerminalEmulator.MOUSE_LEFT_BUTTON_MOVED, true);
+ break;
+ }
+ return true;
+ }
+ }
- mGestureRecognizer.onTouchEvent(ev);
- return true;
- }
+ mGestureRecognizer.onTouchEvent(ev);
+ return true;
+ }
- @Override
- public boolean onKeyPreIme(int keyCode, KeyEvent event) {
- if (LOG_KEY_EVENTS) Log.i(EmulatorDebug.LOG_TAG, "onKeyPreIme(keyCode=" + keyCode + ", event=" + event + ")");
- if (keyCode == KeyEvent.KEYCODE_BACK) {
- if (mIsSelectingText) {
- toggleSelectingText(null);
- return true;
- } else if (mOnKeyListener.shouldBackButtonBeMappedToEscape()) {
- // Intercept back button to treat it as escape:
- switch (event.getAction()) {
- case KeyEvent.ACTION_DOWN:
- return onKeyDown(keyCode, event);
- case KeyEvent.ACTION_UP:
- return onKeyUp(keyCode, event);
- }
- }
- }
- return super.onKeyPreIme(keyCode, event);
- }
+ @Override
+ public boolean onKeyPreIme(int keyCode, KeyEvent event) {
+ if (LOG_KEY_EVENTS)
+ Log.i(EmulatorDebug.LOG_TAG, "onKeyPreIme(keyCode=" + keyCode + ", event=" + event + ")");
+ if (keyCode == KeyEvent.KEYCODE_BACK) {
+ if (mIsSelectingText) {
+ toggleSelectingText(null);
+ return true;
+ } else if (mOnKeyListener.shouldBackButtonBeMappedToEscape()) {
+ // Intercept back button to treat it as escape:
+ switch (event.getAction()) {
+ case KeyEvent.ACTION_DOWN:
+ return onKeyDown(keyCode, event);
+ case KeyEvent.ACTION_UP:
+ return onKeyUp(keyCode, event);
+ }
+ }
+ }
+ return super.onKeyPreIme(keyCode, event);
+ }
- @Override
- public boolean onKeyDown(int keyCode, KeyEvent event) {
- if (LOG_KEY_EVENTS) Log.i(EmulatorDebug.LOG_TAG, "onKeyDown(keyCode=" + keyCode + ", isSystem()=" + event.isSystem() + ", event=" + event + ")");
- if (mEmulator == null) return true;
+ @Override
+ public boolean onKeyDown(int keyCode, KeyEvent event) {
+ if (LOG_KEY_EVENTS)
+ Log.i(EmulatorDebug.LOG_TAG, "onKeyDown(keyCode=" + keyCode + ", isSystem()=" + event.isSystem() + ", event=" + event + ")");
+ if (mEmulator == null) return true;
- if (mOnKeyListener.onKeyDown(keyCode, event, mTermSession)) {
- invalidate();
- return true;
- } else if (event.isSystem() && (!mOnKeyListener.shouldBackButtonBeMappedToEscape() || keyCode != KeyEvent.KEYCODE_BACK)) {
- return super.onKeyDown(keyCode, event);
- } else if (event.getAction() == KeyEvent.ACTION_MULTIPLE && keyCode == KeyEvent.KEYCODE_UNKNOWN) {
+ if (mOnKeyListener.onKeyDown(keyCode, event, mTermSession)) {
+ invalidate();
+ return true;
+ } else if (event.isSystem() && (!mOnKeyListener.shouldBackButtonBeMappedToEscape() || keyCode != KeyEvent.KEYCODE_BACK)) {
+ return super.onKeyDown(keyCode, event);
+ } else if (event.getAction() == KeyEvent.ACTION_MULTIPLE && keyCode == KeyEvent.KEYCODE_UNKNOWN) {
mTermSession.write(event.getCharacters());
return true;
}
@@ -572,54 +589,56 @@ public final class TerminalView extends View {
final boolean rightAltDownFromEvent = (metaState & KeyEvent.META_ALT_RIGHT_ON) != 0;
int keyMod = 0;
- if (controlDownFromEvent) keyMod |= KeyHandler.KEYMOD_CTRL;
- if (event.isAltPressed()) keyMod |= KeyHandler.KEYMOD_ALT;
- if (event.isShiftPressed()) keyMod |= KeyHandler.KEYMOD_SHIFT;
- if (handleKeyCode(keyCode, keyMod)) {
- if (LOG_KEY_EVENTS) Log.i(EmulatorDebug.LOG_TAG, "handleKeyCode() took key event");
- return true;
- }
+ if (controlDownFromEvent) keyMod |= KeyHandler.KEYMOD_CTRL;
+ if (event.isAltPressed()) keyMod |= KeyHandler.KEYMOD_ALT;
+ if (event.isShiftPressed()) keyMod |= KeyHandler.KEYMOD_SHIFT;
+ if (handleKeyCode(keyCode, keyMod)) {
+ if (LOG_KEY_EVENTS) Log.i(EmulatorDebug.LOG_TAG, "handleKeyCode() took key event");
+ return true;
+ }
- // Clear Ctrl since we handle that ourselves:
- int bitsToClear = KeyEvent.META_CTRL_MASK;
- if (rightAltDownFromEvent) {
- // Let right Alt/Alt Gr be used to compose characters.
- } else {
- // Use left alt to send to terminal (e.g. Left Alt+B to jump back a word), so remove:
- bitsToClear |= KeyEvent.META_ALT_ON | KeyEvent.META_ALT_LEFT_ON;
- }
- int effectiveMetaState = event.getMetaState() & ~bitsToClear;
+ // Clear Ctrl since we handle that ourselves:
+ int bitsToClear = KeyEvent.META_CTRL_MASK;
+ if (rightAltDownFromEvent) {
+ // Let right Alt/Alt Gr be used to compose characters.
+ } else {
+ // Use left alt to send to terminal (e.g. Left Alt+B to jump back a word), so remove:
+ bitsToClear |= KeyEvent.META_ALT_ON | KeyEvent.META_ALT_LEFT_ON;
+ }
+ int effectiveMetaState = event.getMetaState() & ~bitsToClear;
- int result = event.getUnicodeChar(effectiveMetaState);
- if (LOG_KEY_EVENTS) Log.i(EmulatorDebug.LOG_TAG, "KeyEvent#getUnicodeChar(" + effectiveMetaState + ") returned: " + result);
- if (result == 0) {
- return true;
- }
+ int result = event.getUnicodeChar(effectiveMetaState);
+ if (LOG_KEY_EVENTS)
+ Log.i(EmulatorDebug.LOG_TAG, "KeyEvent#getUnicodeChar(" + effectiveMetaState + ") returned: " + result);
+ if (result == 0) {
+ return true;
+ }
- int oldCombiningAccent = mCombiningAccent;
- if ((result & KeyCharacterMap.COMBINING_ACCENT) != 0) {
- // If entered combining accent previously, write it out:
- if (mCombiningAccent != 0) inputCodePoint(mCombiningAccent, controlDownFromEvent, leftAltDownFromEvent);
- mCombiningAccent = result & KeyCharacterMap.COMBINING_ACCENT_MASK;
- } else {
- if (mCombiningAccent != 0) {
- int combinedChar = KeyCharacterMap.getDeadChar(mCombiningAccent, result);
- if (combinedChar > 0) result = combinedChar;
- mCombiningAccent = 0;
- }
- inputCodePoint(result, controlDownFromEvent, leftAltDownFromEvent);
- }
+ int oldCombiningAccent = mCombiningAccent;
+ if ((result & KeyCharacterMap.COMBINING_ACCENT) != 0) {
+ // If entered combining accent previously, write it out:
+ if (mCombiningAccent != 0)
+ inputCodePoint(mCombiningAccent, controlDownFromEvent, leftAltDownFromEvent);
+ mCombiningAccent = result & KeyCharacterMap.COMBINING_ACCENT_MASK;
+ } else {
+ if (mCombiningAccent != 0) {
+ int combinedChar = KeyCharacterMap.getDeadChar(mCombiningAccent, result);
+ if (combinedChar > 0) result = combinedChar;
+ mCombiningAccent = 0;
+ }
+ inputCodePoint(result, controlDownFromEvent, leftAltDownFromEvent);
+ }
- if (mCombiningAccent != oldCombiningAccent) invalidate();
+ if (mCombiningAccent != oldCombiningAccent) invalidate();
- return true;
- }
+ return true;
+ }
- void inputCodePoint(int codePoint, boolean controlDownFromEvent, boolean leftAltDownFromEvent) {
- if (LOG_KEY_EVENTS) {
- Log.i(EmulatorDebug.LOG_TAG, "inputCodePoint(codePoint=" + codePoint + ", controlDownFromEvent=" + controlDownFromEvent + ", leftAltDownFromEvent="
- + leftAltDownFromEvent + ")");
- }
+ void inputCodePoint(int codePoint, boolean controlDownFromEvent, boolean leftAltDownFromEvent) {
+ if (LOG_KEY_EVENTS) {
+ Log.i(EmulatorDebug.LOG_TAG, "inputCodePoint(codePoint=" + codePoint + ", controlDownFromEvent=" + controlDownFromEvent + ", leftAltDownFromEvent="
+ + leftAltDownFromEvent + ")");
+ }
final boolean controlDown = controlDownFromEvent || mOnKeyListener.readControlKey();
final boolean altDown = leftAltDownFromEvent || mOnKeyListener.readAltKey();
@@ -627,26 +646,26 @@ public final class TerminalView extends View {
if (mOnKeyListener.onCodePoint(codePoint, controlDown, mTermSession)) return;
if (controlDown) {
- if (codePoint >= 'a' && codePoint <= 'z') {
- codePoint = codePoint - 'a' + 1;
- } else if (codePoint >= 'A' && codePoint <= 'Z') {
- codePoint = codePoint - 'A' + 1;
- } else if (codePoint == ' ' || codePoint == '2') {
- codePoint = 0;
- } else if (codePoint == '[' || codePoint == '3') {
- codePoint = 27; // ^[ (Esc)
- } else if (codePoint == '\\' || codePoint == '4') {
- codePoint = 28;
- } else if (codePoint == ']' || codePoint == '5') {
- codePoint = 29;
- } else if (codePoint == '^' || codePoint == '6') {
- codePoint = 30; // control-^
- } else if (codePoint == '_' || codePoint == '7') {
- codePoint = 31;
- } else if (codePoint == '8') {
- codePoint = 127; // DEL
- }
- }
+ if (codePoint >= 'a' && codePoint <= 'z') {
+ codePoint = codePoint - 'a' + 1;
+ } else if (codePoint >= 'A' && codePoint <= 'Z') {
+ codePoint = codePoint - 'A' + 1;
+ } else if (codePoint == ' ' || codePoint == '2') {
+ codePoint = 0;
+ } else if (codePoint == '[' || codePoint == '3') {
+ codePoint = 27; // ^[ (Esc)
+ } else if (codePoint == '\\' || codePoint == '4') {
+ codePoint = 28;
+ } else if (codePoint == ']' || codePoint == '5') {
+ codePoint = 29;
+ } else if (codePoint == '^' || codePoint == '6') {
+ codePoint = 30; // control-^
+ } else if (codePoint == '_' || codePoint == '7') {
+ codePoint = 31;
+ } else if (codePoint == '8') {
+ codePoint = 127; // DEL
+ }
+ }
if (codePoint > -1) {
// Work around bluetooth keyboards sending funny unicode characters instead
@@ -669,135 +688,134 @@ public final class TerminalView extends View {
}
}
- /** Input the specified keyCode if applicable and return if the input was consumed. */
- public boolean handleKeyCode(int keyCode, int keyMod) {
- TerminalEmulator term = mTermSession.getEmulator();
- String code = KeyHandler.getCode(keyCode, keyMod, term.isCursorKeysApplicationMode(), term.isKeypadApplicationMode());
- if (code == null) return false;
- mTermSession.write(code);
- return true;
- }
+ /** Input the specified keyCode if applicable and return if the input was consumed. */
+ public boolean handleKeyCode(int keyCode, int keyMod) {
+ TerminalEmulator term = mTermSession.getEmulator();
+ String code = KeyHandler.getCode(keyCode, keyMod, term.isCursorKeysApplicationMode(), term.isKeypadApplicationMode());
+ if (code == null) return false;
+ mTermSession.write(code);
+ return true;
+ }
- /**
- * Called when a key is released in the view.
- *
- * @param keyCode
- * The keycode of the key which was released.
- * @param event
- * A {@link KeyEvent} describing the event.
- * @return Whether the event was handled.
- */
- @Override
- public boolean onKeyUp(int keyCode, KeyEvent event) {
- if (LOG_KEY_EVENTS) Log.i(EmulatorDebug.LOG_TAG, "onKeyUp(keyCode=" + keyCode + ", event=" + event + ")");
- if (mEmulator == null) return true;
+ /**
+ * Called when a key is released in the view.
+ *
+ * @param keyCode The keycode of the key which was released.
+ * @param event A {@link KeyEvent} describing the event.
+ * @return Whether the event was handled.
+ */
+ @Override
+ public boolean onKeyUp(int keyCode, KeyEvent event) {
+ if (LOG_KEY_EVENTS)
+ Log.i(EmulatorDebug.LOG_TAG, "onKeyUp(keyCode=" + keyCode + ", event=" + event + ")");
+ if (mEmulator == null) return true;
- if (mOnKeyListener.onKeyUp(keyCode, event)) {
- invalidate();
- return true;
- } else if (event.isSystem()) {
- // Let system key events through.
- return super.onKeyUp(keyCode, event);
- }
+ if (mOnKeyListener.onKeyUp(keyCode, event)) {
+ invalidate();
+ return true;
+ } else if (event.isSystem()) {
+ // Let system key events through.
+ return super.onKeyUp(keyCode, event);
+ }
- return true;
- }
+ return true;
+ }
- /**
- * This is called during layout when the size of this view has changed. If you were just added to the view
- * hierarchy, you're called with the old values of 0.
- */
- @Override
- protected void onSizeChanged(int w, int h, int oldw, int oldh) {
- updateSize();
- }
+ /**
+ * This is called during layout when the size of this view has changed. If you were just added to the view
+ * hierarchy, you're called with the old values of 0.
+ */
+ @Override
+ protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+ updateSize();
+ }
- /** Check if the terminal size in rows and columns should be updated. */
- public void updateSize() {
- int viewWidth = getWidth();
- int viewHeight = getHeight();
- if (viewWidth == 0 || viewHeight == 0 || mTermSession == null) return;
+ /** Check if the terminal size in rows and columns should be updated. */
+ public void updateSize() {
+ int viewWidth = getWidth();
+ int viewHeight = getHeight();
+ if (viewWidth == 0 || viewHeight == 0 || mTermSession == null) return;
- // Set to 80 and 24 if you want to enable vttest.
- int newColumns = Math.max(4, (int) (viewWidth / mRenderer.mFontWidth));
- int newRows = Math.max(4, (viewHeight - mRenderer.mFontLineSpacingAndAscent) / mRenderer.mFontLineSpacing);
+ // Set to 80 and 24 if you want to enable vttest.
+ int newColumns = Math.max(4, (int) (viewWidth / mRenderer.mFontWidth));
+ int newRows = Math.max(4, (viewHeight - mRenderer.mFontLineSpacingAndAscent) / mRenderer.mFontLineSpacing);
- if (mEmulator == null || (newColumns != mEmulator.mColumns || newRows != mEmulator.mRows)) {
- mTermSession.updateSize(newColumns, newRows);
- mEmulator = mTermSession.getEmulator();
+ if (mEmulator == null || (newColumns != mEmulator.mColumns || newRows != mEmulator.mRows)) {
+ mTermSession.updateSize(newColumns, newRows);
+ mEmulator = mTermSession.getEmulator();
- mTopRow = 0;
- scrollTo(0, 0);
- invalidate();
- }
- }
+ mTopRow = 0;
+ scrollTo(0, 0);
+ invalidate();
+ }
+ }
- @Override
- protected void onDraw(Canvas canvas) {
- if (mEmulator == null) {
- canvas.drawColor(0XFF000000);
- } else {
- mRenderer.render(mEmulator, canvas, mTopRow, mSelY1, mSelY2, mSelX1, mSelX2);
+ @Override
+ protected void onDraw(Canvas canvas) {
+ if (mEmulator == null) {
+ canvas.drawColor(0XFF000000);
+ } else {
+ mRenderer.render(mEmulator, canvas, mTopRow, mSelY1, mSelY2, mSelX1, mSelX2);
- if (mIsSelectingText) {
- final int gripHandleWidth = mLeftSelectionHandle.getIntrinsicWidth();
- final int gripHandleMargin = gripHandleWidth / 4; // See the png.
+ if (mIsSelectingText) {
+ final int gripHandleWidth = mLeftSelectionHandle.getIntrinsicWidth();
+ final int gripHandleMargin = gripHandleWidth / 4; // See the png.
- int right = Math.round((mSelX1) * mRenderer.mFontWidth) + gripHandleMargin;
- int top = (mSelY1+1 - mTopRow)*mRenderer.mFontLineSpacing + mRenderer.mFontLineSpacingAndAscent;
- mLeftSelectionHandle.setBounds(right - gripHandleWidth, top, right, top + mLeftSelectionHandle.getIntrinsicHeight());
- mLeftSelectionHandle.draw(canvas);
+ int right = Math.round((mSelX1) * mRenderer.mFontWidth) + gripHandleMargin;
+ int top = (mSelY1 + 1 - mTopRow) * mRenderer.mFontLineSpacing + mRenderer.mFontLineSpacingAndAscent;
+ mLeftSelectionHandle.setBounds(right - gripHandleWidth, top, right, top + mLeftSelectionHandle.getIntrinsicHeight());
+ mLeftSelectionHandle.draw(canvas);
- int left = Math.round((mSelX2+1)*mRenderer.mFontWidth) - gripHandleMargin;
- top = (mSelY2+1 - mTopRow) *mRenderer.mFontLineSpacing + mRenderer.mFontLineSpacingAndAscent;
- mRightSelectionHandle.setBounds(left, top, left + gripHandleWidth, top + mRightSelectionHandle.getIntrinsicHeight());
- mRightSelectionHandle.draw(canvas);
- }
- }
- }
+ int left = Math.round((mSelX2 + 1) * mRenderer.mFontWidth) - gripHandleMargin;
+ top = (mSelY2 + 1 - mTopRow) * mRenderer.mFontLineSpacing + mRenderer.mFontLineSpacingAndAscent;
+ mRightSelectionHandle.setBounds(left, top, left + gripHandleWidth, top + mRightSelectionHandle.getIntrinsicHeight());
+ mRightSelectionHandle.draw(canvas);
+ }
+ }
+ }
- /** Toggle text selection mode in the view. */
- @TargetApi(23)
- public void toggleSelectingText(MotionEvent ev) {
- mIsSelectingText = !mIsSelectingText;
- mOnKeyListener.copyModeChanged(mIsSelectingText);
+ /** Toggle text selection mode in the view. */
+ @TargetApi(23)
+ public void toggleSelectingText(MotionEvent ev) {
+ mIsSelectingText = !mIsSelectingText;
+ mOnKeyListener.copyModeChanged(mIsSelectingText);
- if (mIsSelectingText) {
- if (mLeftSelectionHandle == null) {
- mLeftSelectionHandle = (BitmapDrawable) getContext().getDrawable(R.drawable.text_select_handle_left_material);
- mRightSelectionHandle = (BitmapDrawable) getContext().getDrawable(R.drawable.text_select_handle_right_material);
- }
+ if (mIsSelectingText) {
+ if (mLeftSelectionHandle == null) {
+ mLeftSelectionHandle = (BitmapDrawable) getContext().getDrawable(R.drawable.text_select_handle_left_material);
+ mRightSelectionHandle = (BitmapDrawable) getContext().getDrawable(R.drawable.text_select_handle_right_material);
+ }
- int cx = (int) (ev.getX() / mRenderer.mFontWidth);
- final boolean eventFromMouse = ev.isFromSource(InputDevice.SOURCE_MOUSE);
- // Offset for finger:
- final int SELECT_TEXT_OFFSET_Y = eventFromMouse ? 0 : -40;
- int cy = (int) ((ev.getY() + SELECT_TEXT_OFFSET_Y) / mRenderer.mFontLineSpacing) + mTopRow;
+ int cx = (int) (ev.getX() / mRenderer.mFontWidth);
+ final boolean eventFromMouse = ev.isFromSource(InputDevice.SOURCE_MOUSE);
+ // Offset for finger:
+ final int SELECT_TEXT_OFFSET_Y = eventFromMouse ? 0 : -40;
+ int cy = (int) ((ev.getY() + SELECT_TEXT_OFFSET_Y) / mRenderer.mFontLineSpacing) + mTopRow;
- mSelX1 = mSelX2 = cx;
- mSelY1 = mSelY2 = cy;
+ mSelX1 = mSelX2 = cx;
+ mSelY1 = mSelY2 = cy;
- TerminalBuffer screen = mEmulator.getScreen();
- if (!" ".equals(screen.getSelectedText(mSelX1, mSelY1, mSelX1, mSelY1))) {
- // Selecting something other than whitespace. Expand to word.
- while (mSelX1 > 0 && !"".equals(screen.getSelectedText(mSelX1-1, mSelY1, mSelX1-1, mSelY1))) {
- mSelX1--;
- }
- while (mSelX2 < mEmulator.mColumns-1 && !"".equals(screen.getSelectedText(mSelX2+1, mSelY1, mSelX2+1, mSelY1))) {
- mSelX2++;
- }
- }
+ TerminalBuffer screen = mEmulator.getScreen();
+ if (!" ".equals(screen.getSelectedText(mSelX1, mSelY1, mSelX1, mSelY1))) {
+ // Selecting something other than whitespace. Expand to word.
+ while (mSelX1 > 0 && !"".equals(screen.getSelectedText(mSelX1 - 1, mSelY1, mSelX1 - 1, mSelY1))) {
+ mSelX1--;
+ }
+ while (mSelX2 < mEmulator.mColumns - 1 && !"".equals(screen.getSelectedText(mSelX2 + 1, mSelY1, mSelX2 + 1, mSelY1))) {
+ mSelX2++;
+ }
+ }
- mInitialTextSelection = true;
- mIsDraggingLeftSelection = true;
- mSelectionDownX = ev.getX();
- mSelectionDownY = ev.getY();
+ mInitialTextSelection = true;
+ mIsDraggingLeftSelection = true;
+ mSelectionDownX = ev.getX();
+ mSelectionDownY = ev.getY();
- final ActionMode.Callback callback = new ActionMode.Callback() {
- @Override
- public boolean onCreateActionMode(ActionMode mode, Menu menu) {
- final int[] ACTION_MODE_ATTRS = { android.R.attr.actionModeCopyDrawable, android.R.attr.actionModePasteDrawable, };
- TypedArray styledAttributes = getContext().obtainStyledAttributes(ACTION_MODE_ATTRS);
+ final ActionMode.Callback callback = new ActionMode.Callback() {
+ @Override
+ public boolean onCreateActionMode(ActionMode mode, Menu menu) {
+ final int[] ACTION_MODE_ATTRS = {android.R.attr.actionModeCopyDrawable, android.R.attr.actionModePasteDrawable,};
+ TypedArray styledAttributes = getContext().obtainStyledAttributes(ACTION_MODE_ATTRS);
try {
int show = MenuItem.SHOW_AS_ACTION_ALWAYS | MenuItem.SHOW_AS_ACTION_WITH_TEXT;
@@ -808,89 +826,89 @@ public final class TerminalView extends View {
} finally {
styledAttributes.recycle();
}
- return true;
- }
+ return true;
+ }
- @Override
- public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
- return false;
- }
+ @Override
+ public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
+ return false;
+ }
- @Override
- public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
- switch (item.getItemId()) {
- case 1:
- String selectedText = mEmulator.getSelectedText(mSelX1, mSelY1, mSelX2, mSelY2).trim();
- mTermSession.clipboardText(selectedText);
- break;
- case 2:
- ClipboardManager clipboard = (ClipboardManager) getContext().getSystemService(Context.CLIPBOARD_SERVICE);
- ClipData clipData = clipboard.getPrimaryClip();
- if (clipData != null) {
- CharSequence paste = clipData.getItemAt(0).coerceToText(getContext());
- if (!TextUtils.isEmpty(paste)) mEmulator.paste(paste.toString());
- }
- break;
- case 3:
- showContextMenu();
- break;
- }
- toggleSelectingText(null);
- return true;
- }
+ @Override
+ public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
+ switch (item.getItemId()) {
+ case 1:
+ String selectedText = mEmulator.getSelectedText(mSelX1, mSelY1, mSelX2, mSelY2).trim();
+ mTermSession.clipboardText(selectedText);
+ break;
+ case 2:
+ ClipboardManager clipboard = (ClipboardManager) getContext().getSystemService(Context.CLIPBOARD_SERVICE);
+ ClipData clipData = clipboard.getPrimaryClip();
+ if (clipData != null) {
+ CharSequence paste = clipData.getItemAt(0).coerceToText(getContext());
+ if (!TextUtils.isEmpty(paste)) mEmulator.paste(paste.toString());
+ }
+ break;
+ case 3:
+ showContextMenu();
+ break;
+ }
+ toggleSelectingText(null);
+ return true;
+ }
- @Override
- public void onDestroyActionMode(ActionMode mode) {
- }
+ @Override
+ public void onDestroyActionMode(ActionMode mode) {
+ }
- };
+ };
- if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
- mActionMode = startActionMode(new ActionMode.Callback2() {
- @Override
- public boolean onCreateActionMode(ActionMode mode, Menu menu) {
- return callback.onCreateActionMode(mode, menu);
- }
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+ mActionMode = startActionMode(new ActionMode.Callback2() {
+ @Override
+ public boolean onCreateActionMode(ActionMode mode, Menu menu) {
+ return callback.onCreateActionMode(mode, menu);
+ }
- @Override
- public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
- return false;
- }
+ @Override
+ public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
+ return false;
+ }
- @Override
- public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
- return callback.onActionItemClicked(mode, item);
- }
+ @Override
+ public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
+ return callback.onActionItemClicked(mode, item);
+ }
- @Override
- public void onDestroyActionMode(ActionMode mode) {
- // Ignore.
- }
+ @Override
+ public void onDestroyActionMode(ActionMode mode) {
+ // Ignore.
+ }
- @Override
- public void onGetContentRect(ActionMode mode, View view, Rect outRect) {
- int x1 = Math.round(mSelX1 * mRenderer.mFontWidth);
- int x2 = Math.round(mSelX2 * mRenderer.mFontWidth);
- int y1 = Math.round((mSelY1 - mTopRow) * mRenderer.mFontLineSpacing);
- int y2 = Math.round((mSelY2 + 1 - mTopRow) * mRenderer.mFontLineSpacing);
- outRect.set(Math.min(x1, x2), y1, Math.max(x1, x2), y2);
- }
- }, ActionMode.TYPE_FLOATING);
- } else {
- mActionMode = startActionMode(callback);
- }
+ @Override
+ public void onGetContentRect(ActionMode mode, View view, Rect outRect) {
+ int x1 = Math.round(mSelX1 * mRenderer.mFontWidth);
+ int x2 = Math.round(mSelX2 * mRenderer.mFontWidth);
+ int y1 = Math.round((mSelY1 - mTopRow) * mRenderer.mFontLineSpacing);
+ int y2 = Math.round((mSelY2 + 1 - mTopRow) * mRenderer.mFontLineSpacing);
+ outRect.set(Math.min(x1, x2), y1, Math.max(x1, x2), y2);
+ }
+ }, ActionMode.TYPE_FLOATING);
+ } else {
+ mActionMode = startActionMode(callback);
+ }
- invalidate();
- } else {
- mActionMode.finish();
- mSelX1 = mSelY1 = mSelX2 = mSelY2 = -1;
- invalidate();
- }
- }
+ invalidate();
+ } else {
+ mActionMode.finish();
+ mSelX1 = mSelY1 = mSelX2 = mSelY2 = -1;
+ invalidate();
+ }
+ }
- public TerminalSession getCurrentSession() {
- return mTermSession;
- }
+ public TerminalSession getCurrentSession() {
+ return mTermSession;
+ }
}