2 * Jexer - Java Text User Interface
4 * License: LGPLv3 or later
6 * This module is licensed under the GNU Lesser General Public License
7 * Version 3. Please see the file "COPYING" in this directory for more
8 * information about the GNU Lesser General Public License Version 3.
10 * Copyright (C) 2015 Kevin Lamonte
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public License
14 * as published by the Free Software Foundation; either version 3 of
15 * the License, or (at your option) any later version.
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
22 * You should have received a copy of the GNU Lesser General Public
23 * License along with this program; if not, see
24 * http://www.gnu.org/licenses/, or write to the Free Software
25 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
28 * @author Kevin Lamonte [kevin.lamonte@gmail.com]
33 import java
.io
.BufferedReader
;
34 import java
.io
.FileDescriptor
;
35 import java
.io
.FileInputStream
;
36 import java
.io
.InputStream
;
37 import java
.io
.InputStreamReader
;
38 import java
.io
.IOException
;
39 import java
.io
.OutputStream
;
40 import java
.io
.OutputStreamWriter
;
41 import java
.io
.PrintWriter
;
42 import java
.io
.Reader
;
43 import java
.io
.UnsupportedEncodingException
;
44 import java
.util
.ArrayList
;
45 import java
.util
.Date
;
46 import java
.util
.List
;
47 import java
.util
.LinkedList
;
49 import jexer
.TKeypress
;
50 import jexer
.bits
.Color
;
51 import jexer
.event
.TInputEvent
;
52 import jexer
.event
.TKeypressEvent
;
53 import jexer
.event
.TMouseEvent
;
54 import jexer
.event
.TResizeEvent
;
55 import jexer
.session
.SessionInfo
;
56 import jexer
.session
.TSessionInfo
;
57 import jexer
.session
.TTYSessionInfo
;
58 import static jexer
.TKeypress
.*;
61 * This class reads keystrokes and mouse events and emits output to ANSI
62 * X3.64 / ECMA-48 type terminals e.g. xterm, linux, vt100, ansi.sys, etc.
64 public class ECMA48Terminal
implements Runnable
{
67 * The session information.
69 private SessionInfo sessionInfo
;
72 * Getter for sessionInfo.
74 * @return the SessionInfo
76 public final SessionInfo
getSessionInfo() {
81 * The event queue, filled up by a thread reading on input.
83 private List
<TInputEvent
> eventQueue
;
86 * If true, we want the reader thread to exit gracefully.
88 private boolean stopReaderThread
;
93 private Thread readerThread
;
96 * Parameters being collected. E.g. if the string is \033[1;3m, then
97 * params[0] will be 1 and params[1] will be 3.
99 private ArrayList
<String
> params
;
102 * params[paramI] is being appended to.
107 * States in the input parser.
109 private enum ParseState
{
120 * Current parsing state.
122 private ParseState state
;
125 * The time we entered ESCAPE. If we get a bare escape without a code
126 * following it, this is used to return that bare escape.
128 private long escapeTime
;
131 * true if mouse1 was down. Used to report mouse1 on the release event.
133 private boolean mouse1
;
136 * true if mouse2 was down. Used to report mouse2 on the release event.
138 private boolean mouse2
;
141 * true if mouse3 was down. Used to report mouse3 on the release event.
143 private boolean mouse3
;
146 * Cache the cursor visibility value so we only emit the sequence when we
149 private boolean cursorOn
= true;
152 * Cache the last window size to figure out if a TResizeEvent needs to be
155 private TResizeEvent windowResize
= null;
158 * If true, then we changed System.in and need to change it back.
160 private boolean setRawMode
;
163 * The terminal's input. If an InputStream is not specified in the
164 * constructor, then this InputStreamReader will be bound to System.in
165 * with UTF-8 encoding.
167 private Reader input
;
170 * The terminal's raw InputStream. If an InputStream is not specified in
171 * the constructor, then this InputReader will be bound to System.in.
172 * This is used by run() to see if bytes are available() before calling
173 * (Reader)input.read().
175 private InputStream inputStream
;
178 * The terminal's output. If an OutputStream is not specified in the
179 * constructor, then this PrintWriter will be bound to System.out with
182 private PrintWriter output
;
185 * When true, the terminal is sending non-UTF8 bytes when reporting mouse
188 * TODO: Add broken mouse detection back into the reader.
190 private boolean brokenTerminalUTFMouse
= false;
193 * Get the output writer.
197 public PrintWriter
getOutput() {
202 * Check if there are events in the queue.
204 * @return if true, getEvents() has something to return to the backend
206 public boolean hasEvents() {
207 synchronized (eventQueue
) {
208 return (eventQueue
.size() > 0);
213 * Call 'stty' to set cooked mode.
215 * <p>Actually executes '/bin/sh -c stty sane cooked < /dev/tty'
217 private void sttyCooked() {
222 * Call 'stty' to set raw mode.
224 * <p>Actually executes '/bin/sh -c stty -ignbrk -brkint -parmrk -istrip
225 * -inlcr -igncr -icrnl -ixon -opost -echo -echonl -icanon -isig -iexten
226 * -parenb cs8 min 1 < /dev/tty'
228 private void sttyRaw() {
233 * Call 'stty' to set raw or cooked mode.
235 * @param mode if true, set raw mode, otherwise set cooked mode
237 private void doStty(final boolean mode
) {
239 "/bin/sh", "-c", "stty -ignbrk -brkint -parmrk -istrip -inlcr -igncr -icrnl -ixon -opost -echo -echonl -icanon -isig -iexten -parenb cs8 min 1 < /dev/tty"
241 String
[] cmdCooked
= {
242 "/bin/sh", "-c", "stty sane cooked < /dev/tty"
247 process
= Runtime
.getRuntime().exec(cmdRaw
);
249 process
= Runtime
.getRuntime().exec(cmdCooked
);
251 BufferedReader in
= new BufferedReader(new InputStreamReader(process
.getInputStream(), "UTF-8"));
252 String line
= in
.readLine();
253 if ((line
!= null) && (line
.length() > 0)) {
254 System
.err
.println("WEIRD?! Normal output from stty: " + line
);
257 BufferedReader err
= new BufferedReader(new InputStreamReader(process
.getErrorStream(), "UTF-8"));
258 line
= err
.readLine();
259 if ((line
!= null) && (line
.length() > 0)) {
260 System
.err
.println("Error output from stty: " + line
);
265 } catch (InterruptedException e
) {
269 int rc
= process
.exitValue();
271 System
.err
.println("stty returned error code: " + rc
);
273 } catch (IOException e
) {
279 * Constructor sets up state for getEvent().
281 * @param input an InputStream connected to the remote user, or null for
282 * System.in. If System.in is used, then on non-Windows systems it will
283 * be put in raw mode; shutdown() will (blindly!) put System.in in cooked
284 * mode. input is always converted to a Reader with UTF-8 encoding.
285 * @param output an OutputStream connected to the remote user, or null
286 * for System.out. output is always converted to a Writer with UTF-8
288 * @throws UnsupportedEncodingException if an exception is thrown when
289 * creating the InputStreamReader
291 public ECMA48Terminal(final InputStream input
,
292 final OutputStream output
) throws UnsupportedEncodingException
{
298 stopReaderThread
= false;
301 // inputStream = System.in;
302 inputStream
= new FileInputStream(FileDescriptor
.in
);
308 this.input
= new InputStreamReader(inputStream
, "UTF-8");
310 // TODO: include TelnetSocket from NIB and have it implement
312 if (input
instanceof SessionInfo
) {
313 sessionInfo
= (SessionInfo
) input
;
315 if (sessionInfo
== null) {
317 // Reading right off the tty
318 sessionInfo
= new TTYSessionInfo();
320 sessionInfo
= new TSessionInfo();
324 if (output
== null) {
325 this.output
= new PrintWriter(new OutputStreamWriter(System
.out
,
328 this.output
= new PrintWriter(new OutputStreamWriter(output
,
332 // Enable mouse reporting and metaSendsEscape
333 this.output
.printf("%s%s", mouse(true), xtermMetaSendsEscape(true));
335 // Hang onto the window size
336 windowResize
= new TResizeEvent(TResizeEvent
.Type
.SCREEN
,
337 sessionInfo
.getWindowWidth(), sessionInfo
.getWindowHeight());
339 // Spin up the input reader
340 eventQueue
= new LinkedList
<TInputEvent
>();
341 readerThread
= new Thread(this);
342 readerThread
.start();
346 * Restore terminal to normal state.
348 public void shutdown() {
350 // System.err.println("=== shutdown() ==="); System.err.flush();
352 // Tell the reader thread to stop looking at input
353 stopReaderThread
= true;
356 } catch (InterruptedException e
) {
360 // Disable mouse reporting and show cursor
361 output
.printf("%s%s%s", mouse(false), cursor(true), normal());
367 // We don't close System.in/out
369 // Shut down the streams, this should wake up the reader thread
376 if (output
!= null) {
380 } catch (IOException e
) {
389 public void flush() {
394 * Reset keyboard/mouse input parser.
396 private void reset() {
397 state
= ParseState
.GROUND
;
398 params
= new ArrayList
<String
>();
405 * Produce a control character or one of the special ones (ENTER, TAB,
408 * @param ch Unicode code point
409 * @param alt if true, set alt on the TKeypress
410 * @return one TKeypress event, either a control character (e.g. isKey ==
411 * false, ch == 'A', ctrl == true), or a special key (e.g. isKey == true,
414 private TKeypressEvent
controlChar(final char ch
, final boolean alt
) {
415 // System.err.printf("controlChar: %02x\n", ch);
419 // Carriage return --> ENTER
420 return new TKeypressEvent(kbEnter
, alt
, false, false);
422 // Linefeed --> ENTER
423 return new TKeypressEvent(kbEnter
, alt
, false, false);
426 return new TKeypressEvent(kbEsc
, alt
, false, false);
429 return new TKeypressEvent(kbTab
, alt
, false, false);
431 // Make all other control characters come back as the alphabetic
432 // character with the ctrl field set. So SOH would be 'A' +
434 return new TKeypressEvent(false, 0, (char)(ch
+ 0x40),
440 * Produce special key from CSI Pn ; Pm ; ... ~
442 * @return one KEYPRESS event representing a special key
444 private TInputEvent
csiFnKey() {
447 if (params
.size() > 0) {
448 key
= Integer
.parseInt(params
.get(0));
450 if (params
.size() > 1) {
451 modifier
= Integer
.parseInt(params
.get(1));
454 boolean ctrl
= false;
455 boolean shift
= false;
474 // Unknown modifier, bail out
480 return new TKeypressEvent(kbHome
, alt
, ctrl
, shift
);
482 return new TKeypressEvent(kbIns
, alt
, ctrl
, shift
);
484 return new TKeypressEvent(kbDel
, alt
, ctrl
, shift
);
486 return new TKeypressEvent(kbEnd
, alt
, ctrl
, shift
);
488 return new TKeypressEvent(kbPgUp
, alt
, ctrl
, shift
);
490 return new TKeypressEvent(kbPgDn
, alt
, ctrl
, shift
);
492 return new TKeypressEvent(kbF5
, alt
, ctrl
, shift
);
494 return new TKeypressEvent(kbF6
, alt
, ctrl
, shift
);
496 return new TKeypressEvent(kbF7
, alt
, ctrl
, shift
);
498 return new TKeypressEvent(kbF8
, alt
, ctrl
, shift
);
500 return new TKeypressEvent(kbF9
, alt
, ctrl
, shift
);
502 return new TKeypressEvent(kbF10
, alt
, ctrl
, shift
);
504 return new TKeypressEvent(kbF11
, alt
, ctrl
, shift
);
506 return new TKeypressEvent(kbF12
, alt
, ctrl
, shift
);
514 * Produce mouse events based on "Any event tracking" and UTF-8
516 * http://invisible-island.net/xterm/ctlseqs/ctlseqs.html#Mouse%20Tracking
518 * @return a MOUSE_MOTION, MOUSE_UP, or MOUSE_DOWN event
520 private TInputEvent
parseMouse() {
521 int buttons
= params
.get(0).charAt(0) - 32;
522 int x
= params
.get(0).charAt(1) - 32 - 1;
523 int y
= params
.get(0).charAt(2) - 32 - 1;
525 // Clamp X and Y to the physical screen coordinates.
526 if (x
>= windowResize
.getWidth()) {
527 x
= windowResize
.getWidth() - 1;
529 if (y
>= windowResize
.getHeight()) {
530 y
= windowResize
.getHeight() - 1;
533 TMouseEvent event
= new TMouseEvent(TMouseEvent
.Type
.MOUSE_DOWN
);
539 // System.err.printf("buttons: %04x\r\n", buttons);
556 if (!mouse1
&& !mouse2
&& !mouse3
) {
557 event
.type
= TMouseEvent
.Type
.MOUSE_MOTION
;
559 event
.type
= TMouseEvent
.Type
.MOUSE_UP
;
576 // Dragging with mouse1 down
579 event
.type
= TMouseEvent
.Type
.MOUSE_MOTION
;
583 // Dragging with mouse2 down
586 event
.type
= TMouseEvent
.Type
.MOUSE_MOTION
;
590 // Dragging with mouse3 down
593 event
.type
= TMouseEvent
.Type
.MOUSE_MOTION
;
597 // Dragging with mouse2 down after wheelUp
600 event
.type
= TMouseEvent
.Type
.MOUSE_MOTION
;
604 // Dragging with mouse2 down after wheelDown
607 event
.type
= TMouseEvent
.Type
.MOUSE_MOTION
;
611 event
.mouseWheelUp
= true;
615 event
.mouseWheelDown
= true;
619 // Unknown, just make it motion
620 event
.type
= TMouseEvent
.Type
.MOUSE_MOTION
;
627 * Return any events in the IO queue.
629 * @param queue list to append new events to
631 public void getEvents(final List
<TInputEvent
> queue
) {
632 synchronized (eventQueue
) {
633 if (eventQueue
.size() > 0) {
634 queue
.addAll(eventQueue
);
641 * Return any events in the IO queue due to timeout.
643 * @param queue list to append new events to
645 public void getIdleEvents(final List
<TInputEvent
> queue
) {
647 // Check for new window size
648 sessionInfo
.queryWindowSize();
649 int newWidth
= sessionInfo
.getWindowWidth();
650 int newHeight
= sessionInfo
.getWindowHeight();
651 if ((newWidth
!= windowResize
.getWidth())
652 || (newHeight
!= windowResize
.getHeight())
654 TResizeEvent event
= new TResizeEvent(TResizeEvent
.Type
.SCREEN
,
655 newWidth
, newHeight
);
656 windowResize
= new TResizeEvent(TResizeEvent
.Type
.SCREEN
,
657 newWidth
, newHeight
);
658 synchronized (eventQueue
) {
659 eventQueue
.add(event
);
663 synchronized (eventQueue
) {
664 if (eventQueue
.size() > 0) {
665 queue
.addAll(eventQueue
);
672 * Parses the next character of input to see if an InputEvent is
675 * @param events list to append new events to
676 * @param ch Unicode code point
678 private void processChar(final List
<TInputEvent
> events
, final char ch
) {
680 // ESCDELAY type timeout
681 Date now
= new Date();
682 if (state
== ParseState
.ESCAPE
) {
683 long escDelay
= now
.getTime() - escapeTime
;
684 if (escDelay
> 250) {
685 // After 0.25 seconds, assume a true escape character
686 events
.add(controlChar((char)0x1B, false));
692 boolean ctrl
= false;
694 boolean shift
= false;
698 // System.err.printf("state: %s ch %c\r\n", state, ch);
704 state
= ParseState
.ESCAPE
;
705 escapeTime
= now
.getTime();
711 events
.add(controlChar(ch
, false));
718 events
.add(new TKeypressEvent(false, 0, ch
,
719 false, false, false));
728 // ALT-Control character
729 events
.add(controlChar(ch
, true));
735 // This will be one of the function keys
736 state
= ParseState
.ESCAPE_INTERMEDIATE
;
740 // '[' goes to CSI_ENTRY
742 state
= ParseState
.CSI_ENTRY
;
746 // Everything else is assumed to be Alt-keystroke
747 if ((ch
>= 'A') && (ch
<= 'Z')) {
751 events
.add(new TKeypressEvent(false, 0, ch
, alt
, ctrl
, shift
));
755 case ESCAPE_INTERMEDIATE
:
756 if ((ch
>= 'P') && (ch
<= 'S')) {
760 events
.add(new TKeypressEvent(kbF1
));
763 events
.add(new TKeypressEvent(kbF2
));
766 events
.add(new TKeypressEvent(kbF3
));
769 events
.add(new TKeypressEvent(kbF4
));
778 // Unknown keystroke, ignore
783 // Numbers - parameter values
784 if ((ch
>= '0') && (ch
<= '9')) {
785 params
.set(paramI
, params
.get(paramI
) + ch
);
786 state
= ParseState
.CSI_PARAM
;
789 // Parameter separator
792 params
.set(paramI
, "");
796 if ((ch
>= 0x30) && (ch
<= 0x7E)) {
800 if (params
.size() > 1) {
801 if (params
.get(1).equals("2")) {
804 if (params
.get(1).equals("5")) {
807 if (params
.get(1).equals("3")) {
811 events
.add(new TKeypressEvent(kbUp
, alt
, ctrl
, shift
));
816 if (params
.size() > 1) {
817 if (params
.get(1).equals("2")) {
820 if (params
.get(1).equals("5")) {
823 if (params
.get(1).equals("3")) {
827 events
.add(new TKeypressEvent(kbDown
, alt
, ctrl
, shift
));
832 if (params
.size() > 1) {
833 if (params
.get(1).equals("2")) {
836 if (params
.get(1).equals("5")) {
839 if (params
.get(1).equals("3")) {
843 events
.add(new TKeypressEvent(kbRight
, alt
, ctrl
, shift
));
848 if (params
.size() > 1) {
849 if (params
.get(1).equals("2")) {
852 if (params
.get(1).equals("5")) {
855 if (params
.get(1).equals("3")) {
859 events
.add(new TKeypressEvent(kbLeft
, alt
, ctrl
, shift
));
864 events
.add(new TKeypressEvent(kbHome
));
869 events
.add(new TKeypressEvent(kbEnd
));
873 // CBT - Cursor backward X tab stops (default 1)
874 events
.add(new TKeypressEvent(kbBackTab
));
879 state
= ParseState
.MOUSE
;
886 // Unknown keystroke, ignore
891 // Numbers - parameter values
892 if ((ch
>= '0') && (ch
<= '9')) {
893 params
.set(paramI
, params
.get(paramI
) + ch
);
894 state
= ParseState
.CSI_PARAM
;
897 // Parameter separator
900 params
.set(paramI
, "");
905 events
.add(csiFnKey());
910 if ((ch
>= 0x30) && (ch
<= 0x7E)) {
914 if (params
.size() > 1) {
915 if (params
.get(1).equals("2")) {
918 if (params
.get(1).equals("5")) {
921 if (params
.get(1).equals("3")) {
925 events
.add(new TKeypressEvent(kbUp
, alt
, ctrl
, shift
));
930 if (params
.size() > 1) {
931 if (params
.get(1).equals("2")) {
934 if (params
.get(1).equals("5")) {
937 if (params
.get(1).equals("3")) {
941 events
.add(new TKeypressEvent(kbDown
, alt
, ctrl
, shift
));
946 if (params
.size() > 1) {
947 if (params
.get(1).equals("2")) {
950 if (params
.get(1).equals("5")) {
953 if (params
.get(1).equals("3")) {
957 events
.add(new TKeypressEvent(kbRight
, alt
, ctrl
, shift
));
962 if (params
.size() > 1) {
963 if (params
.get(1).equals("2")) {
966 if (params
.get(1).equals("5")) {
969 if (params
.get(1).equals("3")) {
973 events
.add(new TKeypressEvent(kbLeft
, alt
, ctrl
, shift
));
981 // Unknown keystroke, ignore
986 params
.set(0, params
.get(paramI
) + ch
);
987 if (params
.get(0).length() == 3) {
988 // We have enough to generate a mouse event
989 events
.add(parseMouse());
998 // This "should" be impossible to reach
1003 * Tell (u)xterm that we want alt- keystrokes to send escape + character
1004 * rather than set the 8th bit. Anyone who wants UTF8 should want this
1007 * @param on if true, enable metaSendsEscape
1008 * @return the string to emit to xterm
1010 public String
xtermMetaSendsEscape(final boolean on
) {
1012 return "\033[?1036h\033[?1034l";
1014 return "\033[?1036l";
1018 * Convert a list of SGR parameters into a full escape sequence. This
1019 * also eliminates a trailing ';' which would otherwise reset everything
1020 * to white-on-black not-bold.
1022 * @param str string of parameters, e.g. "31;1;"
1023 * @return the string to emit to an ANSI / ECMA-style terminal,
1026 public String
addHeaderSGR(String str
) {
1027 if (str
.length() > 0) {
1028 // Nix any trailing ';' because that resets all attributes
1029 while (str
.endsWith(":")) {
1030 str
= str
.substring(0, str
.length() - 1);
1033 return "\033[" + str
+ "m";
1037 * Create a SGR parameter sequence for a single color change.
1039 * @param color one of the Color.WHITE, Color.BLUE, etc. constants
1040 * @param foreground if true, this is a foreground color
1041 * @return the string to emit to an ANSI / ECMA-style terminal,
1044 public String
color(final Color color
, final boolean foreground
) {
1045 return color(color
, foreground
, true);
1049 * Create a SGR parameter sequence for a single color change.
1051 * @param color one of the Color.WHITE, Color.BLUE, etc. constants
1052 * @param foreground if true, this is a foreground color
1053 * @param header if true, make the full header, otherwise just emit the
1054 * color parameter e.g. "42;"
1055 * @return the string to emit to an ANSI / ECMA-style terminal,
1058 public String
color(final Color color
, final boolean foreground
,
1059 final boolean header
) {
1061 int ecmaColor
= color
.getValue();
1063 // Convert Color.* values to SGR numerics
1071 return String
.format("\033[%dm", ecmaColor
);
1073 return String
.format("%d;", ecmaColor
);
1078 * Create a SGR parameter sequence for both foreground and
1079 * background color change.
1081 * @param foreColor one of the Color.WHITE, Color.BLUE, etc. constants
1082 * @param backColor one of the Color.WHITE, Color.BLUE, etc. constants
1083 * @return the string to emit to an ANSI / ECMA-style terminal,
1084 * e.g. "\033[31;42m"
1086 public String
color(final Color foreColor
, final Color backColor
) {
1087 return color(foreColor
, backColor
, true);
1091 * Create a SGR parameter sequence for both foreground and
1092 * background color change.
1094 * @param foreColor one of the Color.WHITE, Color.BLUE, etc. constants
1095 * @param backColor one of the Color.WHITE, Color.BLUE, etc. constants
1096 * @param header if true, make the full header, otherwise just emit the
1097 * color parameter e.g. "31;42;"
1098 * @return the string to emit to an ANSI / ECMA-style terminal,
1099 * e.g. "\033[31;42m"
1101 public String
color(final Color foreColor
, final Color backColor
,
1102 final boolean header
) {
1104 int ecmaForeColor
= foreColor
.getValue();
1105 int ecmaBackColor
= backColor
.getValue();
1107 // Convert Color.* values to SGR numerics
1108 ecmaBackColor
+= 40;
1109 ecmaForeColor
+= 30;
1112 return String
.format("\033[%d;%dm", ecmaForeColor
, ecmaBackColor
);
1114 return String
.format("%d;%d;", ecmaForeColor
, ecmaBackColor
);
1119 * Create a SGR parameter sequence for foreground, background, and
1120 * several attributes. This sequence first resets all attributes to
1121 * default, then sets attributes as per the parameters.
1123 * @param foreColor one of the Color.WHITE, Color.BLUE, etc. constants
1124 * @param backColor one of the Color.WHITE, Color.BLUE, etc. constants
1125 * @param bold if true, set bold
1126 * @param reverse if true, set reverse
1127 * @param blink if true, set blink
1128 * @param underline if true, set underline
1129 * @return the string to emit to an ANSI / ECMA-style terminal,
1130 * e.g. "\033[0;1;31;42m"
1132 public String
color(final Color foreColor
, final Color backColor
,
1133 final boolean bold
, final boolean reverse
, final boolean blink
,
1134 final boolean underline
) {
1136 int ecmaForeColor
= foreColor
.getValue();
1137 int ecmaBackColor
= backColor
.getValue();
1139 // Convert Color.* values to SGR numerics
1140 ecmaBackColor
+= 40;
1141 ecmaForeColor
+= 30;
1143 StringBuilder sb
= new StringBuilder();
1144 if ( bold
&& reverse
&& blink
&& !underline
) {
1145 sb
.append("\033[0;1;7;5;");
1146 } else if ( bold
&& reverse
&& !blink
&& !underline
) {
1147 sb
.append("\033[0;1;7;");
1148 } else if ( !bold
&& reverse
&& blink
&& !underline
) {
1149 sb
.append("\033[0;7;5;");
1150 } else if ( bold
&& !reverse
&& blink
&& !underline
) {
1151 sb
.append("\033[0;1;5;");
1152 } else if ( bold
&& !reverse
&& !blink
&& !underline
) {
1153 sb
.append("\033[0;1;");
1154 } else if ( !bold
&& reverse
&& !blink
&& !underline
) {
1155 sb
.append("\033[0;7;");
1156 } else if ( !bold
&& !reverse
&& blink
&& !underline
) {
1157 sb
.append("\033[0;5;");
1158 } else if ( bold
&& reverse
&& blink
&& underline
) {
1159 sb
.append("\033[0;1;7;5;4;");
1160 } else if ( bold
&& reverse
&& !blink
&& underline
) {
1161 sb
.append("\033[0;1;7;4;");
1162 } else if ( !bold
&& reverse
&& blink
&& underline
) {
1163 sb
.append("\033[0;7;5;4;");
1164 } else if ( bold
&& !reverse
&& blink
&& underline
) {
1165 sb
.append("\033[0;1;5;4;");
1166 } else if ( bold
&& !reverse
&& !blink
&& underline
) {
1167 sb
.append("\033[0;1;4;");
1168 } else if ( !bold
&& reverse
&& !blink
&& underline
) {
1169 sb
.append("\033[0;7;4;");
1170 } else if ( !bold
&& !reverse
&& blink
&& underline
) {
1171 sb
.append("\033[0;5;4;");
1172 } else if ( !bold
&& !reverse
&& !blink
&& underline
) {
1173 sb
.append("\033[0;4;");
1175 assert (!bold
&& !reverse
&& !blink
&& !underline
);
1176 sb
.append("\033[0;");
1178 sb
.append(String
.format("%d;%dm", ecmaForeColor
, ecmaBackColor
));
1179 return sb
.toString();
1183 * Create a SGR parameter sequence for enabling reverse color.
1185 * @param on if true, turn on reverse
1186 * @return the string to emit to an ANSI / ECMA-style terminal,
1189 public String
reverse(final boolean on
) {
1197 * Create a SGR parameter sequence to reset to defaults.
1199 * @return the string to emit to an ANSI / ECMA-style terminal,
1202 public String
normal() {
1203 return normal(true);
1207 * Create a SGR parameter sequence to reset to defaults.
1209 * @param header if true, make the full header, otherwise just emit the
1210 * bare parameter e.g. "0;"
1211 * @return the string to emit to an ANSI / ECMA-style terminal,
1214 public String
normal(final boolean header
) {
1216 return "\033[0;37;40m";
1222 * Create a SGR parameter sequence for enabling boldface.
1224 * @param on if true, turn on bold
1225 * @return the string to emit to an ANSI / ECMA-style terminal,
1228 public String
bold(final boolean on
) {
1229 return bold(on
, true);
1233 * Create a SGR parameter sequence for enabling boldface.
1235 * @param on if true, turn on bold
1236 * @param header if true, make the full header, otherwise just emit the
1237 * bare parameter e.g. "1;"
1238 * @return the string to emit to an ANSI / ECMA-style terminal,
1241 public String
bold(final boolean on
, final boolean header
) {
1255 * Create a SGR parameter sequence for enabling blinking text.
1257 * @param on if true, turn on blink
1258 * @return the string to emit to an ANSI / ECMA-style terminal,
1261 public String
blink(final boolean on
) {
1262 return blink(on
, true);
1266 * Create a SGR parameter sequence for enabling blinking text.
1268 * @param on if true, turn on blink
1269 * @param header if true, make the full header, otherwise just emit the
1270 * bare parameter e.g. "5;"
1271 * @return the string to emit to an ANSI / ECMA-style terminal,
1274 public String
blink(final boolean on
, final boolean header
) {
1288 * Create a SGR parameter sequence for enabling underline / underscored
1291 * @param on if true, turn on underline
1292 * @return the string to emit to an ANSI / ECMA-style terminal,
1295 public String
underline(final boolean on
) {
1303 * Create a SGR parameter sequence for enabling the visible cursor.
1305 * @param on if true, turn on cursor
1306 * @return the string to emit to an ANSI / ECMA-style terminal
1308 public String
cursor(final boolean on
) {
1309 if (on
&& !cursorOn
) {
1313 if (!on
&& cursorOn
) {
1321 * Clear the entire screen. Because some terminals use back-color-erase,
1322 * set the color to white-on-black beforehand.
1324 * @return the string to emit to an ANSI / ECMA-style terminal
1326 public String
clearAll() {
1327 return "\033[0;37;40m\033[2J";
1331 * Clear the line from the cursor (inclusive) to the end of the screen.
1332 * Because some terminals use back-color-erase, set the color to
1333 * white-on-black beforehand.
1335 * @return the string to emit to an ANSI / ECMA-style terminal
1337 public String
clearRemainingLine() {
1338 return "\033[0;37;40m\033[K";
1342 * Clear the line up the cursor (inclusive). Because some terminals use
1343 * back-color-erase, set the color to white-on-black beforehand.
1345 * @return the string to emit to an ANSI / ECMA-style terminal
1347 public String
clearPreceedingLine() {
1348 return "\033[0;37;40m\033[1K";
1352 * Clear the line. Because some terminals use back-color-erase, set the
1353 * color to white-on-black beforehand.
1355 * @return the string to emit to an ANSI / ECMA-style terminal
1357 public String
clearLine() {
1358 return "\033[0;37;40m\033[2K";
1362 * Move the cursor to the top-left corner.
1364 * @return the string to emit to an ANSI / ECMA-style terminal
1366 public String
home() {
1371 * Move the cursor to (x, y).
1373 * @param x column coordinate. 0 is the left-most column.
1374 * @param y row coordinate. 0 is the top-most row.
1375 * @return the string to emit to an ANSI / ECMA-style terminal
1377 public String
gotoXY(final int x
, final int y
) {
1378 return String
.format("\033[%d;%dH", y
+ 1, x
+ 1);
1382 * Tell (u)xterm that we want to receive mouse events based on "Any event
1383 * tracking" and UTF-8 coordinates. See
1384 * http://invisible-island.net/xterm/ctlseqs/ctlseqs.html#Mouse%20Tracking
1386 * Note that this also sets the alternate/primary screen buffer.
1388 * @param on If true, enable mouse report and use the alternate screen
1389 * buffer. If false disable mouse reporting and use the primary screen
1391 * @return the string to emit to xterm
1393 public String
mouse(final boolean on
) {
1395 return "\033[?1003;1005h\033[?1049h";
1397 return "\033[?1003;1005l\033[?1049l";
1401 * Read function runs on a separate thread.
1404 boolean done
= false;
1405 // available() will often return > 1, so we need to read in chunks to
1407 char [] readBuffer
= new char[128];
1408 List
<TInputEvent
> events
= new LinkedList
<TInputEvent
>();
1410 while (!done
&& !stopReaderThread
) {
1412 // We assume that if inputStream has bytes available, then
1413 // input won't block on read().
1414 int n
= inputStream
.available();
1416 if (readBuffer
.length
< n
) {
1417 // The buffer wasn't big enough, make it huger
1418 readBuffer
= new char[readBuffer
.length
* 2];
1421 int rc
= input
.read(readBuffer
, 0, n
);
1422 // System.err.printf("read() %d", rc); System.err.flush();
1427 for (int i
= 0; i
< rc
; i
++) {
1428 int ch
= readBuffer
[i
];
1429 processChar(events
, (char)ch
);
1430 if (events
.size() > 0) {
1431 // Add to the queue for the backend thread to
1432 // be able to obtain.
1433 synchronized (eventQueue
) {
1434 eventQueue
.addAll(events
);
1436 // Now wake up the backend
1437 synchronized (this) {
1445 // Wait 5 millis for more data
1448 // System.err.println("end while loop"); System.err.flush();
1449 } catch (InterruptedException e
) {
1451 } catch (IOException e
) {
1452 e
.printStackTrace();
1455 } // while ((done == false) && (stopReaderThread == false))
1456 // System.err.println("*** run() exiting..."); System.err.flush();