X-Git-Url: http://git.nikiroo.be/?a=blobdiff_plain;f=src%2Fjexer%2Ftterminal%2FECMA48.java;h=9376828ee7689411ff7492de501d7109bc892445;hb=051e29138b18fb4b731a72f8727475b10e4c74e4;hp=ca3ce5c80ea952877578c001128b58f8a7a1cc03;hpb=329fd62e4acdaa8e9f4cccd518d47c0b07e79f51;p=fanfix.git diff --git a/src/jexer/tterminal/ECMA48.java b/src/jexer/tterminal/ECMA48.java index ca3ce5c..9376828 100644 --- a/src/jexer/tterminal/ECMA48.java +++ b/src/jexer/tterminal/ECMA48.java @@ -1,35 +1,34 @@ /* * Jexer - Java Text User Interface * - * License: LGPLv3 or later + * The MIT License (MIT) * - * This module is licensed under the GNU Lesser General Public License - * Version 3. Please see the file "COPYING" in this directory for more - * information about the GNU Lesser General Public License Version 3. + * Copyright (C) 2017 Kevin Lamonte * - * Copyright (C) 2015 Kevin Lamonte + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public License - * as published by the Free Software Foundation; either version 3 of - * the License, or (at your option) any later version. + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this program; if not, see - * http://www.gnu.org/licenses/, or write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA - * 02110-1301 USA + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. * * @author Kevin Lamonte [kevin.lamonte@gmail.com] * @version 1 */ package jexer.tterminal; +import java.io.BufferedOutputStream; import java.io.InputStream; import java.io.InputStreamReader; import java.io.IOException; @@ -48,10 +47,12 @@ import jexer.event.TMouseEvent; import jexer.bits.Color; import jexer.bits.Cell; import jexer.bits.CellAttributes; +import jexer.io.ReadTimeoutException; +import jexer.io.TimeoutInputStream; import static jexer.TKeypress.*; /** - * This implements a complex ANSI ECMA-48/ISO 6429/ANSI X3.64 type consoles, + * This implements a complex ECMA-48/ISO 6429/ANSI X3.64 type console, * including a scrollback buffer. * *

@@ -89,6 +90,10 @@ import static jexer.TKeypress.*; */ public class ECMA48 implements Runnable { + // ------------------------------------------------------------------------ + // Constants -------------------------------------------------------------- + // ------------------------------------------------------------------------ + /** * The emulator can emulate several kinds of terminals. */ @@ -115,215 +120,119 @@ public class ECMA48 implements Runnable { } /** - * Return the proper primary Device Attributes string. - * - * @return string to send to remote side that is appropriate for the - * this.type + * Parser character scan states. */ - private String deviceTypeResponse() { - switch (type) { - case VT100: - // "I am a VT100 with advanced video option" (often VT102) - return "\033[?1;2c"; - - case VT102: - // "I am a VT102" - return "\033[?6c"; - - case VT220: - // "I am a VT220" - 7 bit version - if (!s8c1t) { - return "\033[?62;1;6c"; - } - // "I am a VT220" - 8 bit version - return "\u009b?62;1;6c"; - case XTERM: - // "I am a VT100 with advanced video option" (often VT102) - return "\033[?1;2c"; - default: - throw new IllegalArgumentException("Invalid device type: " + type); - } + private enum ScanState { + GROUND, + ESCAPE, + ESCAPE_INTERMEDIATE, + CSI_ENTRY, + CSI_PARAM, + CSI_INTERMEDIATE, + CSI_IGNORE, + DCS_ENTRY, + DCS_INTERMEDIATE, + DCS_PARAM, + DCS_PASSTHROUGH, + DCS_IGNORE, + SOSPMAPC_STRING, + OSC_STRING, + VT52_DIRECT_CURSOR_ADDRESS } /** - * Return the proper TERM environment variable for this device type. - * - * @param deviceType DeviceType.VT100, DeviceType, XTERM, etc. - * @return "vt100", "xterm", etc. + * The selected number pad mode (DECKPAM, DECKPNM). We record this, but + * can't really use it in keypress() because we do not see number pad + * events from TKeypress. */ - public static String deviceTypeTerm(final DeviceType deviceType) { - switch (deviceType) { - case VT100: - return "vt100"; - - case VT102: - return "vt102"; - - case VT220: - return "vt220"; - - case XTERM: - return "xterm"; - - default: - throw new IllegalArgumentException("Invalid device type: " - + deviceType); - } + private enum KeypadMode { + Application, + Numeric } /** - * Return the proper LANG for this device type. Only XTERM devices know - * about UTF-8, the others are defined by their standard to be either - * 7-bit or 8-bit characters only. - * - * @param deviceType DeviceType.VT100, DeviceType, XTERM, etc. - * @param baseLang a base language without UTF-8 flag such as "C" or - * "en_US" - * @return "en_US", "en_US.UTF-8", etc. + * Arrow keys can emit three different sequences (DECCKM or VT52 + * submode). */ - public static String deviceTypeLang(final DeviceType deviceType, - final String baseLang) { - - switch (deviceType) { - - case VT100: - case VT102: - case VT220: - return baseLang; - - case XTERM: - return baseLang + ".UTF-8"; - - default: - throw new IllegalArgumentException("Invalid device type: " - + deviceType); - } + private enum ArrowKeyMode { + VT52, + ANSI, + VT100 } /** - * Write a string directly to the remote side. - * - * @param str string to send + * Available character sets for GL, GR, G0, G1, G2, G3. */ - private void writeRemote(final String str) { - if (stopReaderThread) { - // Reader hit EOF, bail out now. - close(); - return; - } - - // System.err.printf("writeRemote() '%s'\n", str); + private enum CharacterSet { + US, + UK, + DRAWING, + ROM, + ROM_SPECIAL, + VT52_GRAPHICS, + DEC_SUPPLEMENTAL, + NRC_DUTCH, + NRC_FINNISH, + NRC_FRENCH, + NRC_FRENCH_CA, + NRC_GERMAN, + NRC_ITALIAN, + NRC_NORWEGIAN, + NRC_SPANISH, + NRC_SWEDISH, + NRC_SWISS + } - switch (type) { - case VT100: - case VT102: - case VT220: - if (outputStream == null) { - return; - } - try { - for (int i = 0; i < str.length(); i++) { - outputStream.write(str.charAt(i)); - } - outputStream.flush(); - } catch (IOException e) { - // Assume EOF - close(); - } - break; - case XTERM: - if (output == null) { - return; - } - try { - output.write(str); - output.flush(); - } catch (IOException e) { - // Assume EOF - close(); - } - break; - default: - throw new IllegalArgumentException("Invalid device type: " + type); - } + /** + * Single-shift states used by the C1 control characters SS2 (0x8E) and + * SS3 (0x8F). + */ + private enum Singleshift { + NONE, + SS2, + SS3 } /** - * Close the input and output streams and stop the reader thread. Note - * that it is safe to call this multiple times. + * VT220+ lockshift states. */ - public final void close() { + private enum LockshiftMode { + NONE, + G1_GR, + G2_GR, + G2_GL, + G3_GR, + G3_GL + } - // Synchronize so we don't stomp on the reader thread. - synchronized (this) { + /** + * XTERM mouse reporting protocols. + */ + private enum MouseProtocol { + OFF, + X10, + NORMAL, + BUTTONEVENT, + ANYEVENT + } - // Close the input stream - switch (type) { - case VT100: - case VT102: - case VT220: - if (inputStream != null) { - try { - inputStream.close(); - } catch (IOException e) { - // SQUASH - } - inputStream = null; - } - break; - case XTERM: - if (input != null) { - try { - input.close(); - } catch (IOException e) { - // SQUASH - } - input = null; - inputStream = null; - } - break; - } + /** + * XTERM mouse reporting encodings. + */ + private enum MouseEncoding { + X10, + UTF8, + SGR + } - // Tell the reader thread to stop looking at input. - if (stopReaderThread == false) { - stopReaderThread = true; - try { - readerThread.join(); - } catch (InterruptedException e) { - e.printStackTrace(); - } - } + // ------------------------------------------------------------------------ + // Variables -------------------------------------------------------------- + // ------------------------------------------------------------------------ - // Close the output stream. - switch (type) { - case VT100: - case VT102: - case VT220: - if (outputStream != null) { - try { - outputStream.close(); - } catch (IOException e) { - // SQUASH - } - outputStream = null; - } - break; - case XTERM: - if (output != null) { - try { - output.close(); - } catch (IOException e) { - // SQUASH - } - output = null; - } - break; - default: - throw new IllegalArgumentException("Invalid device type: " - + type); - } - } // synchronized (this) - } + /** + * The enclosing listening object. + */ + private DisplayListener displayListener; /** * When true, the reader thread is expected to exit. @@ -336,58 +245,20 @@ public class ECMA48 implements Runnable { private Thread readerThread = null; /** - * See if the reader thread is still running. - * - * @return if true, we are still connected to / reading from the remote - * side + * The type of emulator to be. */ - public final boolean isReading() { - return (!stopReaderThread); - } + private DeviceType type = DeviceType.VT102; /** - * The type of emulator to be. + * The scrollback buffer characters + attributes. */ - private DeviceType type = DeviceType.VT102; - - /** - * Obtain a new blank display line for an external user - * (e.g. TTerminalWindow). - * - * @return new blank line - */ - public final DisplayLine getBlankDisplayLine() { - return new DisplayLine(currentState.attr); - } - - /** - * The scrollback buffer characters + attributes. - */ - private volatile List scrollback; - - /** - * Get the scrollback buffer. - * - * @return the scrollback buffer - */ - public final List getScrollbackBuffer() { - return scrollback; - } + private volatile List scrollback; /** * The raw display buffer characters + attributes. */ private volatile List display; - /** - * Get the display buffer. - * - * @return the display buffer - */ - public final List getDisplayBuffer() { - return display; - } - /** * The terminal's input. For type == XTERM, this is an InputStreamReader * with UTF-8 encoding. @@ -397,7 +268,7 @@ public class ECMA48 implements Runnable { /** * The terminal's raw InputStream. This is used for type != XTERM. */ - private volatile InputStream inputStream; + private volatile TimeoutInputStream inputStream; /** * The terminal's output. For type == XTERM, this wraps an @@ -410,122 +281,16 @@ public class ECMA48 implements Runnable { */ private OutputStream outputStream; - /** - * Parser character scan states. - */ - enum ScanState { - GROUND, - ESCAPE, - ESCAPE_INTERMEDIATE, - CSI_ENTRY, - CSI_PARAM, - CSI_INTERMEDIATE, - CSI_IGNORE, - DCS_ENTRY, - DCS_INTERMEDIATE, - DCS_PARAM, - DCS_PASSTHROUGH, - DCS_IGNORE, - SOSPMAPC_STRING, - OSC_STRING, - VT52_DIRECT_CURSOR_ADDRESS - } - /** * Current scanning state. */ private ScanState scanState; - /** - * The selected number pad mode (DECKPAM, DECKPNM). We record this, but - * can't really use it in keypress() because we do not see number pad - * events from TKeypress. - */ - private enum KeypadMode { - Application, - Numeric - } - - /** - * Arrow keys can emit three different sequences (DECCKM or VT52 - * submode). - */ - private enum ArrowKeyMode { - VT52, - ANSI, - VT100 - } - - /** - * Available character sets for GL, GR, G0, G1, G2, G3. - */ - private enum CharacterSet { - US, - UK, - DRAWING, - ROM, - ROM_SPECIAL, - VT52_GRAPHICS, - DEC_SUPPLEMENTAL, - NRC_DUTCH, - NRC_FINNISH, - NRC_FRENCH, - NRC_FRENCH_CA, - NRC_GERMAN, - NRC_ITALIAN, - NRC_NORWEGIAN, - NRC_SPANISH, - NRC_SWEDISH, - NRC_SWISS - } - - /** - * Single-shift states used by the C1 control characters SS2 (0x8E) and - * SS3 (0x8F). - */ - private enum Singleshift { - NONE, - SS2, - SS3 - } - - /** - * VT220+ lockshift states. - */ - private enum LockshiftMode { - NONE, - G1_GR, - G2_GR, - G2_GL, - G3_GR, - G3_GL - } - - /** - * XTERM mouse reporting protocols. - */ - private enum MouseProtocol { - OFF, - X10, - NORMAL, - BUTTONEVENT, - ANYEVENT - } - /** * Which mouse protocol is active. */ private MouseProtocol mouseProtocol = MouseProtocol.OFF; - /** - * XTERM mouse reporting encodings. - */ - private enum MouseEncoding { - X10, - UTF8, - SGR - } - /** * Which mouse encoding is active. */ @@ -537,30 +302,12 @@ public class ECMA48 implements Runnable { */ private int width; - /** - * Get the display width. - * - * @return the width (usually 80 or 132) - */ - public final int getWidth() { - return width; - } - /** * Physical display height. We start at 80x24, but the user can resize * us bigger/smaller. */ private int height; - /** - * Get the display height. - * - * @return the height (usually 24) - */ - public final int getHeight() { - return height; - } - /** * Top margin of the scrolling region. */ @@ -610,32 +357,12 @@ public class ECMA48 implements Runnable { */ private boolean cursorVisible = true; - /** - * Get visible cursor flag. - * - * @return if true, the cursor is visible - */ - public final boolean isCursorVisible() { - return cursorVisible; - } - /** * Screen title as set by the xterm OSC sequence. Lots of applications * send a screenTitle regardless of whether it is an xterm client or not. */ private String screenTitle = ""; - /** - * Get the screen title as set by the xterm OSC sequence. Lots of - * applications send a screenTitle regardless of whether it is an xterm - * client or not. - * - * @return screen title - */ - public final String getScreenTitle() { - return screenTitle; - } - /** * Parameter characters being collected. */ @@ -677,161 +404,664 @@ public class ECMA48 implements Runnable { /** * Whether arrow keys send ANSI, VT100, or VT52 sequences. */ - private ArrowKeyMode arrowKeyMode; + private ArrowKeyMode arrowKeyMode; + + /** + * Whether number pad keys send VT100 or VT52, application or numeric + * sequences. + */ + @SuppressWarnings("unused") + private KeypadMode keypadMode; + + /** + * When true, the terminal is in 132-column mode (DECCOLM). + */ + private boolean columns132 = false; + + /** + * true = reverse video. Set by DECSCNM. + */ + private boolean reverseVideo = false; + + /** + * false = echo characters locally. + */ + private boolean fullDuplex = true; + + /** + * The current terminal state. + */ + private SaveableState currentState; + + /** + * The last saved terminal state. + */ + private SaveableState savedState; + + /** + * The 88- or 256-color support RGB colors. + */ + private List colors88; + + /** + * DECSC/DECRC save/restore a subset of the total state. This class + * encapsulates those specific flags/modes. + */ + private class SaveableState { + + /** + * When true, cursor positions are relative to the scrolling region. + */ + public boolean originMode = false; + + /** + * The current editing X position. + */ + public int cursorX = 0; + + /** + * The current editing Y position. + */ + public int cursorY = 0; + + /** + * Which character set is currently selected in G0. + */ + public CharacterSet g0Charset = CharacterSet.US; + + /** + * Which character set is currently selected in G1. + */ + public CharacterSet g1Charset = CharacterSet.DRAWING; + + /** + * Which character set is currently selected in G2. + */ + public CharacterSet g2Charset = CharacterSet.US; + + /** + * Which character set is currently selected in G3. + */ + public CharacterSet g3Charset = CharacterSet.US; + + /** + * Which character set is currently selected in GR. + */ + public CharacterSet grCharset = CharacterSet.DRAWING; + + /** + * The current drawing attributes. + */ + public CellAttributes attr; + + /** + * GL lockshift mode. + */ + public LockshiftMode glLockshift = LockshiftMode.NONE; + + /** + * GR lockshift mode. + */ + public LockshiftMode grLockshift = LockshiftMode.NONE; + + /** + * Line wrap. + */ + public boolean lineWrap = true; + + /** + * Reset to defaults. + */ + public void reset() { + originMode = false; + cursorX = 0; + cursorY = 0; + g0Charset = CharacterSet.US; + g1Charset = CharacterSet.DRAWING; + g2Charset = CharacterSet.US; + g3Charset = CharacterSet.US; + grCharset = CharacterSet.DRAWING; + attr = new CellAttributes(); + glLockshift = LockshiftMode.NONE; + grLockshift = LockshiftMode.NONE; + lineWrap = true; + } + + /** + * Copy attributes from another instance. + * + * @param that the other instance to match + */ + public void setTo(final SaveableState that) { + this.originMode = that.originMode; + this.cursorX = that.cursorX; + this.cursorY = that.cursorY; + this.g0Charset = that.g0Charset; + this.g1Charset = that.g1Charset; + this.g2Charset = that.g2Charset; + this.g3Charset = that.g3Charset; + this.grCharset = that.grCharset; + this.attr = new CellAttributes(); + this.attr.setTo(that.attr); + this.glLockshift = that.glLockshift; + this.grLockshift = that.grLockshift; + this.lineWrap = that.lineWrap; + } + + /** + * Public constructor. + */ + public SaveableState() { + reset(); + } + } + + // ------------------------------------------------------------------------ + // Constructors ----------------------------------------------------------- + // ------------------------------------------------------------------------ + + /** + * Public constructor. + * + * @param type one of the DeviceType constants to select VT100, VT102, + * VT220, or XTERM + * @param inputStream an InputStream connected to the remote side. For + * type == XTERM, inputStream is converted to a Reader with UTF-8 + * encoding. + * @param outputStream an OutputStream connected to the remote user. For + * type == XTERM, outputStream is converted to a Writer with UTF-8 + * encoding. + * @param displayListener a callback to the outer display, or null for + * default VT100 behavior + * @throws UnsupportedEncodingException if an exception is thrown when + * creating the InputStreamReader + */ + public ECMA48(final DeviceType type, final InputStream inputStream, + final OutputStream outputStream, final DisplayListener displayListener) + throws UnsupportedEncodingException { + + assert (inputStream != null); + assert (outputStream != null); + + csiParams = new ArrayList(); + tabStops = new ArrayList(); + scrollback = new LinkedList(); + display = new LinkedList(); + + this.type = type; + if (inputStream instanceof TimeoutInputStream) { + this.inputStream = (TimeoutInputStream)inputStream; + } else { + this.inputStream = new TimeoutInputStream(inputStream, 2000); + } + if (type == DeviceType.XTERM) { + this.input = new InputStreamReader(this.inputStream, "UTF-8"); + this.output = new OutputStreamWriter(new + BufferedOutputStream(outputStream), "UTF-8"); + this.outputStream = null; + } else { + this.output = null; + this.outputStream = new BufferedOutputStream(outputStream); + } + this.displayListener = displayListener; + + reset(); + for (int i = 0; i < height; i++) { + display.add(new DisplayLine(currentState.attr)); + } + + // Spin up the input reader + readerThread = new Thread(this); + readerThread.start(); + } + + // ------------------------------------------------------------------------ + // Runnable --------------------------------------------------------------- + // ------------------------------------------------------------------------ + + /** + * Read function runs on a separate thread. + */ + public final void run() { + boolean utf8 = false; + boolean done = false; + + if (type == DeviceType.XTERM) { + utf8 = true; + } + + // available() will often return > 1, so we need to read in chunks to + // stay caught up. + char [] readBufferUTF8 = null; + byte [] readBuffer = null; + if (utf8) { + readBufferUTF8 = new char[128]; + } else { + readBuffer = new byte[128]; + } + + while (!done && !stopReaderThread) { + try { + int n = inputStream.available(); + + // System.err.printf("available() %d\n", n); System.err.flush(); + if (utf8) { + if (readBufferUTF8.length < n) { + // The buffer wasn't big enough, make it huger + int newSizeHalf = Math.max(readBufferUTF8.length, + n); + + readBufferUTF8 = new char[newSizeHalf * 2]; + } + } else { + if (readBuffer.length < n) { + // The buffer wasn't big enough, make it huger + int newSizeHalf = Math.max(readBuffer.length, n); + readBuffer = new byte[newSizeHalf * 2]; + } + } + if (n == 0) { + try { + Thread.sleep(2); + } catch (InterruptedException e) { + // SQUASH + } + continue; + } + + int rc = -1; + try { + if (utf8) { + rc = input.read(readBufferUTF8, 0, + readBufferUTF8.length); + } else { + rc = inputStream.read(readBuffer, 0, + readBuffer.length); + } + } catch (ReadTimeoutException e) { + rc = 0; + } + + // System.err.printf("read() %d\n", rc); System.err.flush(); + if (rc == -1) { + // This is EOF + done = true; + } else { + // Don't step on UI events + synchronized (this) { + for (int i = 0; i < rc; i++) { + int ch = 0; + if (utf8) { + ch = readBufferUTF8[i]; + } else { + ch = readBuffer[i]; + } + + consume((char)ch); + } + } + // Permit my enclosing UI to know that I updated. + if (displayListener != null) { + displayListener.displayChanged(); + } + } + // System.err.println("end while loop"); System.err.flush(); + } catch (IOException e) { + e.printStackTrace(); + done = true; + } + + } // while ((done == false) && (stopReaderThread == false)) + + // Let the rest of the world know that I am done. + stopReaderThread = true; + + try { + inputStream.cancelRead(); + inputStream.close(); + inputStream = null; + } catch (IOException e) { + // SQUASH + } + try { + input.close(); + input = null; + } catch (IOException e) { + // SQUASH + } + + // Permit my enclosing UI to know that I updated. + if (displayListener != null) { + displayListener.displayChanged(); + } + + // System.err.println("*** run() exiting..."); System.err.flush(); + } + + // ------------------------------------------------------------------------ + // ECMA48 ----------------------------------------------------------------- + // ------------------------------------------------------------------------ + + /** + * Return the proper primary Device Attributes string. + * + * @return string to send to remote side that is appropriate for the + * this.type + */ + private String deviceTypeResponse() { + switch (type) { + case VT100: + // "I am a VT100 with advanced video option" (often VT102) + return "\033[?1;2c"; + + case VT102: + // "I am a VT102" + return "\033[?6c"; + + case VT220: + case XTERM: + // "I am a VT220" - 7 bit version + if (!s8c1t) { + return "\033[?62;1;6c"; + } + // "I am a VT220" - 8 bit version + return "\u009b?62;1;6c"; + default: + throw new IllegalArgumentException("Invalid device type: " + type); + } + } + + /** + * Return the proper TERM environment variable for this device type. + * + * @param deviceType DeviceType.VT100, DeviceType, XTERM, etc. + * @return "vt100", "xterm", etc. + */ + public static String deviceTypeTerm(final DeviceType deviceType) { + switch (deviceType) { + case VT100: + return "vt100"; + + case VT102: + return "vt102"; + + case VT220: + return "vt220"; + + case XTERM: + return "xterm"; + + default: + throw new IllegalArgumentException("Invalid device type: " + + deviceType); + } + } + + /** + * Return the proper LANG for this device type. Only XTERM devices know + * about UTF-8, the others are defined by their standard to be either + * 7-bit or 8-bit characters only. + * + * @param deviceType DeviceType.VT100, DeviceType, XTERM, etc. + * @param baseLang a base language without UTF-8 flag such as "C" or + * "en_US" + * @return "en_US", "en_US.UTF-8", etc. + */ + public static String deviceTypeLang(final DeviceType deviceType, + final String baseLang) { + + switch (deviceType) { + + case VT100: + case VT102: + case VT220: + return baseLang; + + case XTERM: + return baseLang + ".UTF-8"; + + default: + throw new IllegalArgumentException("Invalid device type: " + + deviceType); + } + } + + /** + * Write a string directly to the remote side. + * + * @param str string to send + */ + public void writeRemote(final String str) { + if (stopReaderThread) { + // Reader hit EOF, bail out now. + close(); + return; + } + + // System.err.printf("writeRemote() '%s'\n", str); + + switch (type) { + case VT100: + case VT102: + case VT220: + if (outputStream == null) { + return; + } + try { + outputStream.flush(); + for (int i = 0; i < str.length(); i++) { + outputStream.write(str.charAt(i)); + } + outputStream.flush(); + } catch (IOException e) { + // Assume EOF + close(); + } + break; + case XTERM: + if (output == null) { + return; + } + try { + output.flush(); + output.write(str); + output.flush(); + } catch (IOException e) { + // Assume EOF + close(); + } + break; + default: + throw new IllegalArgumentException("Invalid device type: " + type); + } + } + + /** + * Close the input and output streams and stop the reader thread. Note + * that it is safe to call this multiple times. + */ + public final void close() { + + // Tell the reader thread to stop looking at input. It will close + // the input streams. + if (stopReaderThread == false) { + stopReaderThread = true; + try { + readerThread.join(1000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + // Now close the output stream. + switch (type) { + case VT100: + case VT102: + case VT220: + if (outputStream != null) { + try { + outputStream.close(); + } catch (IOException e) { + // SQUASH + } + outputStream = null; + } + break; + case XTERM: + if (outputStream != null) { + try { + outputStream.close(); + } catch (IOException e) { + // SQUASH + } + outputStream = null; + } + if (output != null) { + try { + output.close(); + } catch (IOException e) { + // SQUASH + } + output = null; + } + break; + default: + throw new IllegalArgumentException("Invalid device type: " + + type); + } + } + + /** + * See if the reader thread is still running. + * + * @return if true, we are still connected to / reading from the remote + * side + */ + public final boolean isReading() { + return (!stopReaderThread); + } + + /** + * Obtain a new blank display line for an external user + * (e.g. TTerminalWindow). + * + * @return new blank line + */ + public final DisplayLine getBlankDisplayLine() { + return new DisplayLine(currentState.attr); + } + + /** + * Get the scrollback buffer. + * + * @return the scrollback buffer + */ + public final List getScrollbackBuffer() { + return scrollback; + } /** - * Whether number pad keys send VT100 or VT52, application or numeric - * sequences. + * Get the display buffer. + * + * @return the display buffer */ - @SuppressWarnings("unused") - private KeypadMode keypadMode; + public final List getDisplayBuffer() { + return display; + } /** - * When true, the terminal is in 132-column mode (DECCOLM). + * Get the display width. + * + * @return the width (usually 80 or 132) */ - private boolean columns132 = false; + public final int getWidth() { + return width; + } /** - * Get 132 columns value. + * Set the display width. * - * @return if true, the terminal is in 132 column mode + * @param width the new width */ - public final boolean isColumns132() { - return columns132; + public final void setWidth(final int width) { + this.width = width; + rightMargin = width - 1; + if (currentState.cursorX >= width) { + currentState.cursorX = width - 1; } - - /** - * true = reverse video. Set by DECSCNM. - */ - private boolean reverseVideo = false; + if (savedState.cursorX >= width) { + savedState.cursorX = width - 1; + } + } /** - * false = echo characters locally. + * Get the display height. + * + * @return the height (usually 24) */ - private boolean fullDuplex = true; + public final int getHeight() { + return height; + } /** - * DECSC/DECRC save/restore a subset of the total state. This class - * encapsulates those specific flags/modes. + * Set the display height. + * + * @param height the new height */ - private class SaveableState { - - /** - * When true, cursor positions are relative to the scrolling region. - */ - public boolean originMode = false; - - /** - * The current editing X position. - */ - public int cursorX = 0; - - /** - * The current editing Y position. - */ - public int cursorY = 0; - - /** - * Which character set is currently selected in G0. - */ - public CharacterSet g0Charset = CharacterSet.US; - - /** - * Which character set is currently selected in G1. - */ - public CharacterSet g1Charset = CharacterSet.DRAWING; - - /** - * Which character set is currently selected in G2. - */ - public CharacterSet g2Charset = CharacterSet.US; - - /** - * Which character set is currently selected in G3. - */ - public CharacterSet g3Charset = CharacterSet.US; - - /** - * Which character set is currently selected in GR. - */ - public CharacterSet grCharset = CharacterSet.DRAWING; - - /** - * The current drawing attributes. - */ - public CellAttributes attr; - - /** - * GL lockshift mode. - */ - public LockshiftMode glLockshift = LockshiftMode.NONE; - - /** - * GR lockshift mode. - */ - public LockshiftMode grLockshift = LockshiftMode.NONE; - - /** - * Line wrap. - */ - public boolean lineWrap = true; - - /** - * Reset to defaults. - */ - public void reset() { - originMode = false; - cursorX = 0; - cursorY = 0; - g0Charset = CharacterSet.US; - g1Charset = CharacterSet.DRAWING; - g2Charset = CharacterSet.US; - g3Charset = CharacterSet.US; - grCharset = CharacterSet.DRAWING; - attr = new CellAttributes(); - glLockshift = LockshiftMode.NONE; - grLockshift = LockshiftMode.NONE; - lineWrap = true; + public final void setHeight(final int height) { + int delta = height - this.height; + this.height = height; + scrollRegionBottom += delta; + if (scrollRegionBottom < 0) { + scrollRegionBottom = height; } - - /** - * Copy attributes from another instance. - * - * @param that the other instance to match - */ - public void setTo(final SaveableState that) { - this.originMode = that.originMode; - this.cursorX = that.cursorX; - this.cursorY = that.cursorY; - this.g0Charset = that.g0Charset; - this.g1Charset = that.g1Charset; - this.g2Charset = that.g2Charset; - this.g3Charset = that.g3Charset; - this.grCharset = that.grCharset; - this.attr = new CellAttributes(); - this.attr.setTo(that.attr); - this.glLockshift = that.glLockshift; - this.grLockshift = that.grLockshift; - this.lineWrap = that.lineWrap; + if (scrollRegionTop >= scrollRegionBottom) { + scrollRegionTop = 0; } - - /** - * Public constructor. - */ - public SaveableState() { - reset(); + if (currentState.cursorY >= height) { + currentState.cursorY = height - 1; + } + if (savedState.cursorY >= height) { + savedState.cursorY = height - 1; + } + while (display.size() < height) { + DisplayLine line = new DisplayLine(currentState.attr); + line.setReverseColor(reverseVideo); + display.add(line); + } + while (display.size() > height) { + scrollback.add(display.remove(0)); } } /** - * The current terminal state. + * Get visible cursor flag. + * + * @return if true, the cursor is visible */ - private SaveableState currentState; + public final boolean isCursorVisible() { + return cursorVisible; + } /** - * The last saved terminal state. + * Get the screen title as set by the xterm OSC sequence. Lots of + * applications send a screenTitle regardless of whether it is an xterm + * client or not. + * + * @return screen title */ - private SaveableState savedState; + public final String getScreenTitle() { + return screenTitle; + } + + /** + * Get 132 columns value. + * + * @return if true, the terminal is in 132 column mode + */ + public final boolean isColumns132() { + return columns132; + } /** * Clear the CSI parameters and flags. @@ -852,6 +1082,99 @@ public class ECMA48 implements Runnable { } } + /** + * Reset the 88- or 256-colors. + */ + private void resetColors() { + colors88 = new ArrayList(256); + for (int i = 0; i < 256; i++) { + colors88.add(0); + } + + // Set default system colors. + colors88.set(0, 0x00000000); + colors88.set(1, 0x00a80000); + colors88.set(2, 0x0000a800); + colors88.set(3, 0x00a85400); + colors88.set(4, 0x000000a8); + colors88.set(5, 0x00a800a8); + colors88.set(6, 0x0000a8a8); + colors88.set(7, 0x00a8a8a8); + + colors88.set(8, 0x00545454); + colors88.set(9, 0x00fc5454); + colors88.set(10, 0x0054fc54); + colors88.set(11, 0x00fcfc54); + colors88.set(12, 0x005454fc); + colors88.set(13, 0x00fc54fc); + colors88.set(14, 0x0054fcfc); + colors88.set(15, 0x00fcfcfc); + } + + /** + * Get the RGB value of one of the indexed colors. + * + * @param index the color index + * @return the RGB value + */ + private int get88Color(final int index) { + // System.err.print("get88Color: " + index); + if ((index < 0) || (index > colors88.size())) { + // System.err.println(" -- UNKNOWN"); + return 0; + } + // System.err.printf(" %08x\n", colors88.get(index)); + return colors88.get(index); + } + + /** + * Set one of the indexed colors to a color specification. + * + * @param index the color index + * @param spec the specification, typically something like "rgb:aa/bb/cc" + */ + private void set88Color(final int index, final String spec) { + // System.err.println("set88Color: " + index + " '" + spec + "'"); + + if ((index < 0) || (index > colors88.size())) { + return; + } + if (spec.startsWith("rgb:")) { + String [] rgbTokens = spec.substring(4).split("/"); + if (rgbTokens.length == 3) { + try { + int rgb = (Integer.parseInt(rgbTokens[0], 16) << 16); + rgb |= Integer.parseInt(rgbTokens[1], 16) << 8; + rgb |= Integer.parseInt(rgbTokens[2], 16); + // System.err.printf(" set to %08x\n", rgb); + colors88.set(index, rgb); + } catch (NumberFormatException e) { + // SQUASH + } + } + return; + } + + if (spec.toLowerCase().equals("black")) { + colors88.set(index, 0x00000000); + } else if (spec.toLowerCase().equals("red")) { + colors88.set(index, 0x00a80000); + } else if (spec.toLowerCase().equals("green")) { + colors88.set(index, 0x0000a800); + } else if (spec.toLowerCase().equals("yellow")) { + colors88.set(index, 0x00a85400); + } else if (spec.toLowerCase().equals("blue")) { + colors88.set(index, 0x000000a8); + } else if (spec.toLowerCase().equals("magenta")) { + colors88.set(index, 0x00a800a8); + } else if (spec.toLowerCase().equals("cyan")) { + colors88.set(index, 0x0000a8a8); + } else if (spec.toLowerCase().equals("white")) { + colors88.set(index, 0x00a8a8a8); + } + + } + /** * Reset the emulation state. */ @@ -869,6 +1192,11 @@ public class ECMA48 implements Runnable { arrowKeyMode = ArrowKeyMode.ANSI; keypadMode = KeypadMode.Numeric; wrapLineFlag = false; + if (displayListener != null) { + width = displayListener.getDisplayWidth(); + height = displayListener.getDisplayHeight(); + rightMargin = width - 1; + } // Flags shiftOut = false; @@ -892,56 +1220,13 @@ public class ECMA48 implements Runnable { // Tab stops resetTabStops(); + // Reset extra colors + resetColors(); + // Clear CSI stuff toGround(); } - /** - * Public constructor. - * - * @param type one of the DeviceType constants to select VT100, VT102, - * VT220, or XTERM - * @param inputStream an InputStream connected to the remote side. For - * type == XTERM, inputStream is converted to a Reader with UTF-8 - * encoding. - * @param outputStream an OutputStream connected to the remote user. For - * type == XTERM, outputStream is converted to a Writer with UTF-8 - * encoding. - * @throws UnsupportedEncodingException if an exception is thrown when - * creating the InputStreamReader - */ - public ECMA48(final DeviceType type, final InputStream inputStream, - final OutputStream outputStream) throws UnsupportedEncodingException { - - assert (inputStream != null); - assert (outputStream != null); - - csiParams = new ArrayList(); - tabStops = new ArrayList(); - scrollback = new LinkedList(); - display = new LinkedList(); - - this.type = type; - this.inputStream = inputStream; - if (type == DeviceType.XTERM) { - this.input = new InputStreamReader(inputStream, "UTF-8"); - this.output = new OutputStreamWriter(outputStream, "UTF-8"); - this.outputStream = null; - } else { - this.output = null; - this.outputStream = outputStream; - } - - reset(); - for (int i = 0; i < height; i++) { - display.add(new DisplayLine(currentState.attr)); - } - - // Spin up the input reader - readerThread = new Thread(this); - readerThread.start(); - } - /** * Append a new line to the bottom of the display, adding lines off the * top to the scrollback buffer. @@ -1257,6 +1542,46 @@ public class ECMA48 implements Runnable { writeRemote(keypressToString(keypress)); } + /** + * Build one of the complex xterm keystroke sequences, storing the result in + * xterm_keystroke_buffer. + * + * @param ss3 the prefix to use based on VT100 state. + * @param first the first character, usually a number. + * @param first the last character, one of the following: ~ A B C D F H + * @param ctrl whether or not ctrl is down + * @param alt whether or not alt is down + * @param shift whether or not shift is down + * @return the buffer with the full key sequence + */ + private String xtermBuildKeySequence(final String ss3, final char first, + final char last, boolean ctrl, boolean alt, boolean shift) { + + StringBuilder sb = new StringBuilder(ss3); + if ((last == '~') || (ctrl == true) || (alt == true) + || (shift == true) + ) { + sb.append(first); + if ( (ctrl == false) && (alt == false) && (shift == true)) { + sb.append(";2"); + } else if ((ctrl == false) && (alt == true) && (shift == false)) { + sb.append(";3"); + } else if ((ctrl == false) && (alt == true) && (shift == true)) { + sb.append(";4"); + } else if ((ctrl == true) && (alt == false) && (shift == false)) { + sb.append(";5"); + } else if ((ctrl == true) && (alt == false) && (shift == true)) { + sb.append(";6"); + } else if ((ctrl == true) && (alt == true) && (shift == false)) { + sb.append(";7"); + } else if ((ctrl == true) && (alt == true) && (shift == true)) { + sb.append(";8"); + } + } + sb.append(last); + return sb.toString(); + } + /** * Translate the keyboard press to a VT100, VT220, or XTERM sequence. * @@ -1300,7 +1625,7 @@ public class ECMA48 implements Runnable { return sb.toString(); } - if (keypress.equals(kbBackspace)) { + if (keypress.equals(kbBackspaceDel)) { switch (type) { case VT100: return "\010"; @@ -1313,69 +1638,177 @@ public class ECMA48 implements Runnable { } } - if (keypress.equals(kbLeft)) { - switch (arrowKeyMode) { - case ANSI: - return "\033[D"; - case VT52: - return "\033D"; - case VT100: - return "\033OD"; + if (keypress.equalsWithoutModifiers(kbLeft)) { + switch (type) { + case XTERM: + switch (arrowKeyMode) { + case ANSI: + return xtermBuildKeySequence("\033[", '1', 'D', + keypress.isCtrl(), keypress.isAlt(), + keypress.isShift()); + case VT52: + return xtermBuildKeySequence("\033", '1', 'D', + keypress.isCtrl(), keypress.isAlt(), + keypress.isShift()); + case VT100: + return xtermBuildKeySequence("\033O", '1', 'D', + keypress.isCtrl(), keypress.isAlt(), + keypress.isShift()); + } + default: + switch (arrowKeyMode) { + case ANSI: + return "\033[D"; + case VT52: + return "\033D"; + case VT100: + return "\033OD"; + } } } - if (keypress.equals(kbRight)) { - switch (arrowKeyMode) { - case ANSI: - return "\033[C"; - case VT52: - return "\033C"; - case VT100: - return "\033OC"; + if (keypress.equalsWithoutModifiers(kbRight)) { + switch (type) { + case XTERM: + switch (arrowKeyMode) { + case ANSI: + return xtermBuildKeySequence("\033[", '1', 'C', + keypress.isCtrl(), keypress.isAlt(), + keypress.isShift()); + case VT52: + return xtermBuildKeySequence("\033", '1', 'C', + keypress.isCtrl(), keypress.isAlt(), + keypress.isShift()); + case VT100: + return xtermBuildKeySequence("\033O", '1', 'C', + keypress.isCtrl(), keypress.isAlt(), + keypress.isShift()); + } + default: + switch (arrowKeyMode) { + case ANSI: + return "\033[C"; + case VT52: + return "\033C"; + case VT100: + return "\033OC"; + } } } - if (keypress.equals(kbUp)) { - switch (arrowKeyMode) { - case ANSI: - return "\033[A"; - case VT52: - return "\033A"; - case VT100: - return "\033OA"; + if (keypress.equalsWithoutModifiers(kbUp)) { + switch (type) { + case XTERM: + switch (arrowKeyMode) { + case ANSI: + return xtermBuildKeySequence("\033[", '1', 'A', + keypress.isCtrl(), keypress.isAlt(), + keypress.isShift()); + case VT52: + return xtermBuildKeySequence("\033", '1', 'A', + keypress.isCtrl(), keypress.isAlt(), + keypress.isShift()); + case VT100: + return xtermBuildKeySequence("\033O", '1', 'A', + keypress.isCtrl(), keypress.isAlt(), + keypress.isShift()); + } + default: + switch (arrowKeyMode) { + case ANSI: + return "\033[A"; + case VT52: + return "\033A"; + case VT100: + return "\033OA"; + } } } - if (keypress.equals(kbDown)) { - switch (arrowKeyMode) { - case ANSI: - return "\033[B"; - case VT52: - return "\033B"; - case VT100: - return "\033OB"; + if (keypress.equalsWithoutModifiers(kbDown)) { + switch (type) { + case XTERM: + switch (arrowKeyMode) { + case ANSI: + return xtermBuildKeySequence("\033[", '1', 'B', + keypress.isCtrl(), keypress.isAlt(), + keypress.isShift()); + case VT52: + return xtermBuildKeySequence("\033", '1', 'B', + keypress.isCtrl(), keypress.isAlt(), + keypress.isShift()); + case VT100: + return xtermBuildKeySequence("\033O", '1', 'B', + keypress.isCtrl(), keypress.isAlt(), + keypress.isShift()); + } + default: + switch (arrowKeyMode) { + case ANSI: + return "\033[B"; + case VT52: + return "\033B"; + case VT100: + return "\033OB"; + } } } - if (keypress.equals(kbHome)) { - switch (arrowKeyMode) { - case ANSI: - return "\033[H"; - case VT52: - return "\033H"; - case VT100: - return "\033OH"; + if (keypress.equalsWithoutModifiers(kbHome)) { + switch (type) { + case XTERM: + switch (arrowKeyMode) { + case ANSI: + return xtermBuildKeySequence("\033[", '1', 'H', + keypress.isCtrl(), keypress.isAlt(), + keypress.isShift()); + case VT52: + return xtermBuildKeySequence("\033", '1', 'H', + keypress.isCtrl(), keypress.isAlt(), + keypress.isShift()); + case VT100: + return xtermBuildKeySequence("\033O", '1', 'H', + keypress.isCtrl(), keypress.isAlt(), + keypress.isShift()); + } + default: + switch (arrowKeyMode) { + case ANSI: + return "\033[H"; + case VT52: + return "\033H"; + case VT100: + return "\033OH"; + } } } - if (keypress.equals(kbEnd)) { - switch (arrowKeyMode) { - case ANSI: - return "\033[F"; - case VT52: - return "\033F"; - case VT100: - return "\033OF"; + if (keypress.equalsWithoutModifiers(kbEnd)) { + switch (type) { + case XTERM: + switch (arrowKeyMode) { + case ANSI: + return xtermBuildKeySequence("\033[", '1', 'F', + keypress.isCtrl(), keypress.isAlt(), + keypress.isShift()); + case VT52: + return xtermBuildKeySequence("\033", '1', 'F', + keypress.isCtrl(), keypress.isAlt(), + keypress.isShift()); + case VT100: + return xtermBuildKeySequence("\033O", '1', 'F', + keypress.isCtrl(), keypress.isAlt(), + keypress.isShift()); + } + default: + switch (arrowKeyMode) { + case ANSI: + return "\033[F"; + case VT52: + return "\033F"; + case VT100: + return "\033OF"; + } } } @@ -1502,6 +1935,9 @@ public class ECMA48 implements Runnable { if (vt52Mode) { return "\0332P"; } + if (type == DeviceType.XTERM) { + return "\0331;2P"; + } return "\033O2P"; } @@ -1510,6 +1946,9 @@ public class ECMA48 implements Runnable { if (vt52Mode) { return "\0332Q"; } + if (type == DeviceType.XTERM) { + return "\0331;2Q"; + } return "\033O2Q"; } @@ -1518,6 +1957,9 @@ public class ECMA48 implements Runnable { if (vt52Mode) { return "\0332R"; } + if (type == DeviceType.XTERM) { + return "\0331;2R"; + } return "\033O2R"; } @@ -1526,6 +1968,9 @@ public class ECMA48 implements Runnable { if (vt52Mode) { return "\0332S"; } + if (type == DeviceType.XTERM) { + return "\0331;2S"; + } return "\033O2S"; } @@ -1574,6 +2019,9 @@ public class ECMA48 implements Runnable { if (vt52Mode) { return "\0335P"; } + if (type == DeviceType.XTERM) { + return "\0331;5P"; + } return "\033O5P"; } @@ -1582,6 +2030,9 @@ public class ECMA48 implements Runnable { if (vt52Mode) { return "\0335Q"; } + if (type == DeviceType.XTERM) { + return "\0331;5Q"; + } return "\033O5Q"; } @@ -1590,6 +2041,9 @@ public class ECMA48 implements Runnable { if (vt52Mode) { return "\0335R"; } + if (type == DeviceType.XTERM) { + return "\0331;5R"; + } return "\033O5R"; } @@ -1598,6 +2052,9 @@ public class ECMA48 implements Runnable { if (vt52Mode) { return "\0335S"; } + if (type == DeviceType.XTERM) { + return "\0331;5S"; + } return "\033O5S"; } @@ -1641,39 +2098,49 @@ public class ECMA48 implements Runnable { return "\033[24;5~"; } - if (keypress.equals(kbPgUp)) { - // Page Up - return "\033[5~"; - } - - if (keypress.equals(kbPgDn)) { - // Page Down - return "\033[6~"; - } - - if (keypress.equals(kbIns)) { - // Ins - return "\033[2~"; + if (keypress.equalsWithoutModifiers(kbPgUp)) { + switch (type) { + case XTERM: + return xtermBuildKeySequence("\033[", '5', '~', + keypress.isCtrl(), keypress.isAlt(), + keypress.isShift()); + default: + return "\033[5~"; + } } - if (keypress.equals(kbShiftIns)) { - // This is what xterm sends for SHIFT-INS - return "\033[2;2~"; - // This is what xterm sends for CTRL-INS - // return "\033[2;5~"; + if (keypress.equalsWithoutModifiers(kbPgDn)) { + switch (type) { + case XTERM: + return xtermBuildKeySequence("\033[", '6', '~', + keypress.isCtrl(), keypress.isAlt(), + keypress.isShift()); + default: + return "\033[6~"; + } } - if (keypress.equals(kbShiftDel)) { - // This is what xterm sends for SHIFT-DEL - return "\033[3;2~"; - // This is what xterm sends for CTRL-DEL - // return "\033[3;5~"; + if (keypress.equalsWithoutModifiers(kbIns)) { + switch (type) { + case XTERM: + return xtermBuildKeySequence("\033[", '2', '~', + keypress.isCtrl(), keypress.isAlt(), + keypress.isShift()); + default: + return "\033[2~"; + } } - if (keypress.equals(kbDel)) { - // Delete sends real delete for VTxxx - return "\177"; - // return "\033[3~"; + if (keypress.equalsWithoutModifiers(kbDel)) { + switch (type) { + case XTERM: + return xtermBuildKeySequence("\033[", '3', '~', + keypress.isCtrl(), keypress.isAlt(), + keypress.isShift()); + default: + // Delete sends real delete for VTxxx + return "\177"; + } } if (keypress.equals(kbEnter)) { @@ -1692,6 +2159,17 @@ public class ECMA48 implements Runnable { return "\011"; } + if ((keypress.equalsWithoutModifiers(kbBackTab)) || + (keypress.equals(kbShiftTab)) + ) { + switch (type) { + case XTERM: + return "\033[Z"; + default: + return "\011"; + } + } + // Non-alt, non-ctrl characters if (!keypress.isFnKey()) { StringBuilder sb = new StringBuilder(); @@ -2268,9 +2746,18 @@ public class ECMA48 implements Runnable { } else { // 80 columns columns132 = false; - rightMargin = 79; + if ((displayListener != null) + && (type == DeviceType.XTERM) + ) { + // For xterms, reset to the actual width, not 80 + // columns. + width = displayListener.getDisplayWidth(); + rightMargin = width - 1; + } else { + rightMargin = 79; + width = rightMargin + 1; + } } - width = rightMargin + 1; // Entire screen is cleared, and scrolling region is // reset eraseScreen(0, 0, height - 1, width - 1, false); @@ -3143,8 +3630,87 @@ public class ECMA48 implements Runnable { return; } + int sgrColorMode = -1; + boolean idx88Color = false; + boolean rgbColor = false; + int rgbRed = -1; + int rgbGreen = -1; + for (Integer i: csiParams) { + if ((sgrColorMode == 38) || (sgrColorMode == 48)) { + + assert (type == DeviceType.XTERM); + + if (idx88Color) { + /* + * Indexed color mode, we now have the index number. + */ + if (sgrColorMode == 38) { + currentState.attr.setForeColorRGB(get88Color(i)); + } else { + assert (sgrColorMode == 48); + currentState.attr.setBackColorRGB(get88Color(i)); + } + sgrColorMode = -1; + idx88Color = false; + continue; + } + + if (rgbColor) { + /* + * RGB color mode, we are collecting tokens. + */ + if (rgbRed == -1) { + rgbRed = i & 0xFF; + } else if (rgbGreen == -1) { + rgbGreen = i & 0xFF; + } else { + int rgb = rgbRed << 16; + rgb |= rgbGreen << 8; + rgb |= i & 0xFF; + + // System.err.printf("RGB: %08x\n", rgb); + + if (sgrColorMode == 38) { + currentState.attr.setForeColorRGB(rgb); + } else { + assert (sgrColorMode == 48); + currentState.attr.setBackColorRGB(rgb); + } + rgbRed = -1; + rgbGreen = -1; + sgrColorMode = -1; + rgbColor = false; + } + continue; + } + + switch (i) { + + case 2: + /* + * RGB color mode. + */ + rgbColor = true; + break; + + case 5: + /* + * Indexed color mode. + */ + idx88Color = true; + break; + + default: + /* + * This is neither indexed nor RGB color. Bail out. + */ + return; + } + + } // if ((sgrColorMode == 38) || (sgrColorMode == 48)) + switch (i) { case 0: @@ -3185,6 +3751,72 @@ public class ECMA48 implements Runnable { // TODO break; + case 90: + // Set black foreground + currentState.attr.setForeColorRGB(get88Color(8)); + break; + case 91: + // Set red foreground + currentState.attr.setForeColorRGB(get88Color(9)); + break; + case 92: + // Set green foreground + currentState.attr.setForeColorRGB(get88Color(10)); + break; + case 93: + // Set yellow foreground + currentState.attr.setForeColorRGB(get88Color(11)); + break; + case 94: + // Set blue foreground + currentState.attr.setForeColorRGB(get88Color(12)); + break; + case 95: + // Set magenta foreground + currentState.attr.setForeColorRGB(get88Color(13)); + break; + case 96: + // Set cyan foreground + currentState.attr.setForeColorRGB(get88Color(14)); + break; + case 97: + // Set white foreground + currentState.attr.setForeColorRGB(get88Color(15)); + break; + + case 100: + // Set black background + currentState.attr.setBackColorRGB(get88Color(8)); + break; + case 101: + // Set red background + currentState.attr.setBackColorRGB(get88Color(9)); + break; + case 102: + // Set green background + currentState.attr.setBackColorRGB(get88Color(10)); + break; + case 103: + // Set yellow background + currentState.attr.setBackColorRGB(get88Color(11)); + break; + case 104: + // Set blue background + currentState.attr.setBackColorRGB(get88Color(12)); + break; + case 105: + // Set magenta background + currentState.attr.setBackColorRGB(get88Color(13)); + break; + case 106: + // Set cyan background + currentState.attr.setBackColorRGB(get88Color(14)); + break; + case 107: + // Set white background + currentState.attr.setBackColorRGB(get88Color(15)); + break; + default: break; } @@ -3229,80 +3861,179 @@ public class ECMA48 implements Runnable { case 30: // Set black foreground currentState.attr.setForeColor(Color.BLACK); + currentState.attr.setForeColorRGB(-1); break; case 31: // Set red foreground currentState.attr.setForeColor(Color.RED); + currentState.attr.setForeColorRGB(-1); break; case 32: // Set green foreground currentState.attr.setForeColor(Color.GREEN); + currentState.attr.setForeColorRGB(-1); break; case 33: // Set yellow foreground currentState.attr.setForeColor(Color.YELLOW); + currentState.attr.setForeColorRGB(-1); break; case 34: // Set blue foreground currentState.attr.setForeColor(Color.BLUE); + currentState.attr.setForeColorRGB(-1); break; case 35: // Set magenta foreground currentState.attr.setForeColor(Color.MAGENTA); + currentState.attr.setForeColorRGB(-1); break; case 36: // Set cyan foreground currentState.attr.setForeColor(Color.CYAN); + currentState.attr.setForeColorRGB(-1); break; case 37: // Set white foreground currentState.attr.setForeColor(Color.WHITE); + currentState.attr.setForeColorRGB(-1); break; case 38: - // Underscore on, default foreground color - currentState.attr.setUnderline(true); - currentState.attr.setForeColor(Color.WHITE); + if (type == DeviceType.XTERM) { + /* + * Xterm supports T.416 / ISO-8613-3 codes to select + * either an indexed color or an RGB value. (It also + * permits these ISO-8613-3 SGR sequences to be separated + * by colons rather than semicolons.) + * + * We will support only the following: + * + * 1. Indexed color mode (88- or 256-color modes). + * + * 2. Direct RGB. + * + * These cover most of the use cases in the real world. + * + * HOWEVER, note that this is an awful broken "standard", + * with no way to do it "right". See + * http://invisible-island.net/ncurses/ncurses.faq.html#xterm_16MegaColors + * for a detailed discussion of the current state of RGB + * in various terminals, the point of which is that none + * of them really do the same thing despite all appearing + * to be "xterm". + * + * Also see + * https://bugs.kde.org/show_bug.cgi?id=107487#c3 . + * where it is assumed that supporting just the "indexed + * mode" of these sequences (which could align easily + * with existing SGR colors) is assumed to mean full + * support of 24-bit RGB. So it is all or nothing. + * + * Finally, these sequences break the assumptions of + * standard ECMA-48 style parsers as pointed out at + * https://bugs.kde.org/show_bug.cgi?id=107487#c11 . + * Therefore in order to keep a clean display, we cannot + * parse anything else in this sequence. + */ + sgrColorMode = 38; + continue; + } else { + // Underscore on, default foreground color + currentState.attr.setUnderline(true); + currentState.attr.setForeColor(Color.WHITE); + } break; case 39: // Underscore off, default foreground color currentState.attr.setUnderline(false); currentState.attr.setForeColor(Color.WHITE); + currentState.attr.setForeColorRGB(-1); break; case 40: // Set black background currentState.attr.setBackColor(Color.BLACK); + currentState.attr.setBackColorRGB(-1); break; case 41: // Set red background currentState.attr.setBackColor(Color.RED); + currentState.attr.setBackColorRGB(-1); break; case 42: // Set green background currentState.attr.setBackColor(Color.GREEN); + currentState.attr.setBackColorRGB(-1); break; case 43: // Set yellow background currentState.attr.setBackColor(Color.YELLOW); + currentState.attr.setBackColorRGB(-1); break; case 44: // Set blue background currentState.attr.setBackColor(Color.BLUE); + currentState.attr.setBackColorRGB(-1); break; case 45: // Set magenta background currentState.attr.setBackColor(Color.MAGENTA); + currentState.attr.setBackColorRGB(-1); break; case 46: // Set cyan background currentState.attr.setBackColor(Color.CYAN); + currentState.attr.setBackColorRGB(-1); break; case 47: // Set white background currentState.attr.setBackColor(Color.WHITE); + currentState.attr.setBackColorRGB(-1); + break; + case 48: + if (type == DeviceType.XTERM) { + /* + * Xterm supports T.416 / ISO-8613-3 codes to select + * either an indexed color or an RGB value. (It also + * permits these ISO-8613-3 SGR sequences to be separated + * by colons rather than semicolons.) + * + * We will support only the following: + * + * 1. Indexed color mode (88- or 256-color modes). + * + * 2. Direct RGB. + * + * These cover most of the use cases in the real world. + * + * HOWEVER, note that this is an awful broken "standard", + * with no way to do it "right". See + * http://invisible-island.net/ncurses/ncurses.faq.html#xterm_16MegaColors + * for a detailed discussion of the current state of RGB + * in various terminals, the point of which is that none + * of them really do the same thing despite all appearing + * to be "xterm". + * + * Also see + * https://bugs.kde.org/show_bug.cgi?id=107487#c3 . + * where it is assumed that supporting just the "indexed + * mode" of these sequences (which could align easily + * with existing SGR colors) is assumed to mean full + * support of 24-bit RGB. So it is all or nothing. + * + * Finally, these sequences break the assumptions of + * standard ECMA-48 style parsers as pointed out at + * https://bugs.kde.org/show_bug.cgi?id=107487#c11 . + * Therefore in order to keep a clean display, we cannot + * parse anything else in this sequence. + */ + sgrColorMode = 48; + continue; + } break; case 49: // Default background currentState.attr.setBackColor(Color.BLACK); + currentState.attr.setBackColorRGB(-1); break; default: @@ -3478,6 +4209,7 @@ public class ECMA48 implements Runnable { */ private void dsr() { boolean decPrivateModeFlag = false; + int row = currentState.cursorY; for (int i = 0; i < collectBuffer.length(); i++) { if (collectBuffer.charAt(i) == '?') { @@ -3505,15 +4237,18 @@ public class ECMA48 implements Runnable { case 6: // Request cursor position. Respond with current position. + if (currentState.originMode == true) { + row -= scrollRegionTop; + } String str = ""; if (((type == DeviceType.VT220) || (type == DeviceType.XTERM)) && (s8c1t == true) ) { - str = String.format("\u009b%d;%dR", - currentState.cursorY + 1, currentState.cursorX + 1); + str = String.format("\u009b%d;%dR", row + 1, + currentState.cursorX + 1); } else { - str = String.format("\033[%d;%dR", - currentState.cursorY + 1, currentState.cursorX + 1); + str = String.format("\033[%d;%dR", row + 1, + currentState.cursorX + 1); } // Send string directly to remote side @@ -3749,13 +4484,22 @@ public class ECMA48 implements Runnable { * @param xtermChar the character received from the remote side */ private void oscPut(final char xtermChar) { + // System.err.println("oscPut: " + xtermChar); + // Collect first collectBuffer.append(xtermChar); // Xterm cases... - if (xtermChar == 0x07) { - String args = collectBuffer.substring(0, - collectBuffer.length() - 1); + if ((xtermChar == 0x07) + || (collectBuffer.toString().endsWith("\033\\")) + ) { + String args = null; + if (xtermChar == 0x07) { + args = collectBuffer.substring(0, collectBuffer.length() - 1); + } else { + args = collectBuffer.substring(0, collectBuffer.length() - 2); + } + String [] p = args.toString().split(";"); if (p.length > 0) { if ((p[0].equals("0")) || (p[0].equals("2"))) { @@ -3764,6 +4508,17 @@ public class ECMA48 implements Runnable { screenTitle = p[1]; } } + + if (p[0].equals("4")) { + for (int i = 1; i + 1 < p.length; i += 2) { + // Set a color index value + try { + set88Color(Integer.parseInt(p[i]), p[i + 1]); + } catch (NumberFormatException e) { + // SQUASH + } + } + } } // Go to SCAN_GROUND state @@ -3799,16 +4554,21 @@ public class ECMA48 implements Runnable { // 80-8F, 91-97, 99, 9A, 9C --> execute, then switch to SCAN_GROUND // 0x1B == ESCAPE - if ((ch == 0x1B) - && (scanState != ScanState.DCS_ENTRY) - && (scanState != ScanState.DCS_INTERMEDIATE) - && (scanState != ScanState.DCS_IGNORE) - && (scanState != ScanState.DCS_PARAM) - && (scanState != ScanState.DCS_PASSTHROUGH) - ) { + if (ch == 0x1B) { + if ((type == DeviceType.XTERM) + && (scanState == ScanState.OSC_STRING) + ) { + // Xterm can pass ESCAPE to its OSC sequence. + } else if ((scanState != ScanState.DCS_ENTRY) + && (scanState != ScanState.DCS_INTERMEDIATE) + && (scanState != ScanState.DCS_IGNORE) + && (scanState != ScanState.DCS_PARAM) + && (scanState != ScanState.DCS_PASSTHROUGH) + ) { - scanState = ScanState.ESCAPE; - return; + scanState = ScanState.ESCAPE; + return; + } } // 0x9B == CSI 8-bit sequence @@ -5663,7 +6423,7 @@ public class ECMA48 implements Runnable { case OSC_STRING: // Special case for Xterm: OSC can pass control characters - if ((ch == 0x9C) || (ch <= 0x07)) { + if ((ch == 0x9C) || (ch == 0x07) || (ch == 0x1B)) { oscPut(ch); } @@ -5717,83 +6477,4 @@ public class ECMA48 implements Runnable { return currentState.cursorY; } - /** - * Read function runs on a separate thread. - */ - public final void run() { - boolean utf8 = false; - boolean done = false; - - if (type == DeviceType.XTERM) { - utf8 = true; - } - - // available() will often return > 1, so we need to read in chunks to - // stay caught up. - char [] readBufferUTF8 = null; - byte [] readBuffer = null; - if (utf8) { - readBufferUTF8 = new char[128]; - } else { - readBuffer = new byte[128]; - } - - while (!done && !stopReaderThread) { - try { - int n = inputStream.available(); - // System.err.printf("available() %d\n", n); System.err.flush(); - if (utf8) { - if (readBufferUTF8.length < n) { - // The buffer wasn't big enough, make it huger - int newSizeHalf = Math.max(readBufferUTF8.length, n); - - readBufferUTF8 = new char[newSizeHalf * 2]; - } - } else { - if (readBuffer.length < n) { - // The buffer wasn't big enough, make it huger - int newSizeHalf = Math.max(readBuffer.length, n); - readBuffer = new byte[newSizeHalf * 2]; - } - } - - int rc = -1; - if (utf8) { - rc = input.read(readBufferUTF8, 0, - readBufferUTF8.length); - } else { - rc = inputStream.read(readBuffer, 0, - readBuffer.length); - } - // System.err.printf("read() %d\n", rc); System.err.flush(); - if (rc == -1) { - // This is EOF - done = true; - } else { - for (int i = 0; i < rc; i++) { - int ch = 0; - if (utf8) { - ch = readBufferUTF8[i]; - } else { - ch = readBuffer[i]; - } - // Don't step on UI events - synchronized (this) { - consume((char)ch); - } - } - } - // System.err.println("end while loop"); System.err.flush(); - } catch (IOException e) { - e.printStackTrace(); - done = true; - } - } // while ((done == false) && (stopReaderThread == false)) - - // Let the rest of the world know that I am done. - stopReaderThread = true; - - // System.err.println("*** run() exiting..."); System.err.flush(); - } - }