X-Git-Url: http://git.nikiroo.be/?a=blobdiff_plain;f=src%2Fjexer%2Ftterminal%2FECMA48.java;h=46952da4b19066ce96b8dab768074e054e5e3665;hb=be72cb5ccbd42fe304c0acafc380c5636f0d03a2;hp=80f733b132c2e7024f131f6a8232fddbbcabbdcb;hpb=8582f35a3ffb8212463076217eb89278f42331d4;p=fanfix.git diff --git a/src/jexer/tterminal/ECMA48.java b/src/jexer/tterminal/ECMA48.java index 80f733b..46952da 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. * *

@@ -131,15 +132,13 @@ public class ECMA48 implements Runnable { 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"; - case XTERM: - // "I am a VT100 with advanced video option" (often VT102) - return "\033[?1;2c"; default: throw new IllegalArgumentException("Invalid device type: " + type); } @@ -254,75 +253,68 @@ public class ECMA48 implements Runnable { */ public final void close() { - // Synchronize so we don't stomp on the reader thread. - synchronized (this) { - - // 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; + // 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(); } + } - // Tell the reader thread to stop looking at input. - if (stopReaderThread == false) { - stopReaderThread = true; + // Now close the output stream. + switch (type) { + case VT100: + case VT102: + case VT220: + if (outputStream != null) { try { - readerThread.join(); - } catch (InterruptedException e) { - e.printStackTrace(); + outputStream.close(); + } catch (IOException e) { + // SQUASH } + outputStream = null; } - - // 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 } - break; - case XTERM: - if (output != null) { - try { - output.close(); - } catch (IOException e) { - // SQUASH - } - output = null; + outputStream = null; + } + if (output != null) { + try { + output.close(); + } catch (IOException e) { + // SQUASH } - break; - default: - throw new IllegalArgumentException("Invalid device type: " - + type); + output = null; } - } // synchronized (this) + break; + default: + throw new IllegalArgumentException("Invalid device type: " + + type); + } + } + + /** + * The enclosing listening object. + */ + private DisplayListener listener; + + /** + * Set a listening object. + * + * @param listener the object that will have displayChanged() called + * after bytes are received from the remote terminal + */ + public void setListener(final DisplayListener listener) { + this.listener = listener; } /** @@ -397,7 +389,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 @@ -700,7 +692,7 @@ public class ECMA48 implements Runnable { return columns132; } - /** + /** * true = reverse video. Set by DECSCNM. */ private boolean reverseVideo = false; @@ -922,14 +914,19 @@ public class ECMA48 implements Runnable { display = new LinkedList(); this.type = type; - this.inputStream = inputStream; + if (inputStream instanceof TimeoutInputStream) { + this.inputStream = (TimeoutInputStream)inputStream; + } else { + this.inputStream = new TimeoutInputStream(inputStream, 2000); + } if (type == DeviceType.XTERM) { - this.input = new InputStreamReader(inputStream, "UTF-8"); - this.output = new OutputStreamWriter(outputStream, "UTF-8"); + 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 = outputStream; + this.outputStream = new BufferedOutputStream(outputStream); } reset(); @@ -1257,6 +1254,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. * @@ -1313,69 +1350,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 +1647,9 @@ public class ECMA48 implements Runnable { if (vt52Mode) { return "\0332P"; } + if (type == DeviceType.XTERM) { + return "\0331;2P"; + } return "\033O2P"; } @@ -1510,6 +1658,9 @@ public class ECMA48 implements Runnable { if (vt52Mode) { return "\0332Q"; } + if (type == DeviceType.XTERM) { + return "\0331;2Q"; + } return "\033O2Q"; } @@ -1518,6 +1669,9 @@ public class ECMA48 implements Runnable { if (vt52Mode) { return "\0332R"; } + if (type == DeviceType.XTERM) { + return "\0331;2R"; + } return "\033O2R"; } @@ -1526,6 +1680,9 @@ public class ECMA48 implements Runnable { if (vt52Mode) { return "\0332S"; } + if (type == DeviceType.XTERM) { + return "\0331;2S"; + } return "\033O2S"; } @@ -1574,6 +1731,9 @@ public class ECMA48 implements Runnable { if (vt52Mode) { return "\0335P"; } + if (type == DeviceType.XTERM) { + return "\0331;5P"; + } return "\033O5P"; } @@ -1582,6 +1742,9 @@ public class ECMA48 implements Runnable { if (vt52Mode) { return "\0335Q"; } + if (type == DeviceType.XTERM) { + return "\0331;5Q"; + } return "\033O5Q"; } @@ -1590,6 +1753,9 @@ public class ECMA48 implements Runnable { if (vt52Mode) { return "\0335R"; } + if (type == DeviceType.XTERM) { + return "\0331;5R"; + } return "\033O5R"; } @@ -1598,6 +1764,9 @@ public class ECMA48 implements Runnable { if (vt52Mode) { return "\0335S"; } + if (type == DeviceType.XTERM) { + return "\0331;5S"; + } return "\033O5S"; } @@ -1641,39 +1810,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 +1871,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(); @@ -2185,8 +2375,9 @@ public class ECMA48 implements Runnable { } /** - * Set or unset a toggle. value is 'true' for set ('h'), false for reset - * ('l'). + * Set or unset a toggle. + * + * @param value true for set ('h'), false for reset ('l') */ private void setToggle(final boolean value) { boolean decPrivateModeFlag = false; @@ -3258,9 +3449,41 @@ public class ECMA48 implements Runnable { currentState.attr.setForeColor(Color.WHITE); 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 not support any of these additional color + * codes at this time: + * + * 1. http://invisible-island.net/ncurses/ncurses.faq.html#xterm_16MegaColors + * has 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". + * + * 2. As seen in + * https://bugs.kde.org/show_bug.cgi?id=107487#c3, + * even 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. + */ + return; + } else { + // Underscore on, default foreground color + currentState.attr.setUnderline(true); + currentState.attr.setForeColor(Color.WHITE); + } break; case 39: // Underscore off, default foreground color @@ -3299,6 +3522,21 @@ public class ECMA48 implements Runnable { // Set white background currentState.attr.setBackColor(Color.WHITE); 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 not support this at this time. Also, in order + * to keep a clean display, we cannot parse anything else + * in this sequence. + */ + return; + } + break; case 49: // Default background currentState.attr.setBackColor(Color.BLACK); @@ -3477,6 +3715,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) == '?') { @@ -3504,15 +3743,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 @@ -5534,8 +5776,8 @@ public class ECMA48 implements Runnable { collect(ch); } if (ch == 0x5C) { - if ((collectBuffer.length() > 0) && - (collectBuffer.charAt(collectBuffer.length() - 1) == 0x1B) + if ((collectBuffer.length() > 0) + && (collectBuffer.charAt(collectBuffer.length() - 1) == 0x1B) ) { toGround(); } @@ -5566,8 +5808,8 @@ public class ECMA48 implements Runnable { collect(ch); } if (ch == 0x5C) { - if ((collectBuffer.length() > 0) && - (collectBuffer.charAt(collectBuffer.length() - 1) == 0x1B) + if ((collectBuffer.length() > 0) + && (collectBuffer.charAt(collectBuffer.length() - 1) == 0x1B) ) { toGround(); } @@ -5719,7 +5961,7 @@ public class ECMA48 implements Runnable { /** * Read function runs on a separate thread. */ - public void run() { + public final void run() { boolean utf8 = false; boolean done = false; @@ -5740,11 +5982,13 @@ public class ECMA48 implements Runnable { 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); + int newSizeHalf = Math.max(readBufferUTF8.length, + n); readBufferUTF8 = new char[newSizeHalf * 2]; } @@ -5755,15 +5999,28 @@ public class ECMA48 implements Runnable { readBuffer = new byte[newSizeHalf * 2]; } } + if (n == 0) { + try { + Thread.sleep(2); + } catch (InterruptedException e) { + // SQUASH + } + continue; + } int rc = -1; - if (utf8) { - rc = input.read(readBufferUTF8, 0, - readBufferUTF8.length); - } else { - rc = inputStream.read(readBuffer, 0, - readBuffer.length); + 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 @@ -5776,22 +6033,42 @@ public class ECMA48 implements Runnable { } else { ch = readBuffer[i]; } - // Don't step on UI events + synchronized (this) { + // Don't step on UI events consume((char)ch); } } + // Permit my enclosing UI to know that I updated. + if (listener != null) { + listener.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 + } + // System.err.println("*** run() exiting..."); System.err.flush(); }