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
.Type eventType
= TMouseEvent
.Type
.MOUSE_DOWN
;
534 boolean eventMouse1
= false;
535 boolean eventMouse2
= false;
536 boolean eventMouse3
= false;
537 boolean eventMouseWheelUp
= false;
538 boolean eventMouseWheelDown
= false;
540 // System.err.printf("buttons: %04x\r\n", buttons);
557 if (!mouse1
&& !mouse2
&& !mouse3
) {
558 eventType
= TMouseEvent
.Type
.MOUSE_MOTION
;
560 eventType
= TMouseEvent
.Type
.MOUSE_UP
;
577 // Dragging with mouse1 down
580 eventType
= TMouseEvent
.Type
.MOUSE_MOTION
;
584 // Dragging with mouse2 down
587 eventType
= TMouseEvent
.Type
.MOUSE_MOTION
;
591 // Dragging with mouse3 down
594 eventType
= TMouseEvent
.Type
.MOUSE_MOTION
;
598 // Dragging with mouse2 down after wheelUp
601 eventType
= TMouseEvent
.Type
.MOUSE_MOTION
;
605 // Dragging with mouse2 down after wheelDown
608 eventType
= TMouseEvent
.Type
.MOUSE_MOTION
;
612 eventMouseWheelUp
= true;
616 eventMouseWheelDown
= true;
620 // Unknown, just make it motion
621 eventType
= TMouseEvent
.Type
.MOUSE_MOTION
;
624 return new TMouseEvent(eventType
, x
, y
, x
, y
,
625 eventMouse1
, eventMouse2
, eventMouse3
,
626 eventMouseWheelUp
, eventMouseWheelDown
);
630 * Return any events in the IO queue.
632 * @param queue list to append new events to
634 public void getEvents(final List
<TInputEvent
> queue
) {
635 synchronized (eventQueue
) {
636 if (eventQueue
.size() > 0) {
637 queue
.addAll(eventQueue
);
644 * Return any events in the IO queue due to timeout.
646 * @param queue list to append new events to
648 public void getIdleEvents(final List
<TInputEvent
> queue
) {
650 // Check for new window size
651 sessionInfo
.queryWindowSize();
652 int newWidth
= sessionInfo
.getWindowWidth();
653 int newHeight
= sessionInfo
.getWindowHeight();
654 if ((newWidth
!= windowResize
.getWidth())
655 || (newHeight
!= windowResize
.getHeight())
657 TResizeEvent event
= new TResizeEvent(TResizeEvent
.Type
.SCREEN
,
658 newWidth
, newHeight
);
659 windowResize
= new TResizeEvent(TResizeEvent
.Type
.SCREEN
,
660 newWidth
, newHeight
);
661 synchronized (eventQueue
) {
662 eventQueue
.add(event
);
666 synchronized (eventQueue
) {
667 if (eventQueue
.size() > 0) {
668 queue
.addAll(eventQueue
);
675 * Parses the next character of input to see if an InputEvent is
678 * @param events list to append new events to
679 * @param ch Unicode code point
681 private void processChar(final List
<TInputEvent
> events
, final char ch
) {
683 // ESCDELAY type timeout
684 Date now
= new Date();
685 if (state
== ParseState
.ESCAPE
) {
686 long escDelay
= now
.getTime() - escapeTime
;
687 if (escDelay
> 250) {
688 // After 0.25 seconds, assume a true escape character
689 events
.add(controlChar((char)0x1B, false));
695 boolean ctrl
= false;
697 boolean shift
= false;
701 // System.err.printf("state: %s ch %c\r\n", state, ch);
707 state
= ParseState
.ESCAPE
;
708 escapeTime
= now
.getTime();
714 events
.add(controlChar(ch
, false));
721 events
.add(new TKeypressEvent(false, 0, ch
,
722 false, false, false));
731 // ALT-Control character
732 events
.add(controlChar(ch
, true));
738 // This will be one of the function keys
739 state
= ParseState
.ESCAPE_INTERMEDIATE
;
743 // '[' goes to CSI_ENTRY
745 state
= ParseState
.CSI_ENTRY
;
749 // Everything else is assumed to be Alt-keystroke
750 if ((ch
>= 'A') && (ch
<= 'Z')) {
754 events
.add(new TKeypressEvent(false, 0, ch
, alt
, ctrl
, shift
));
758 case ESCAPE_INTERMEDIATE
:
759 if ((ch
>= 'P') && (ch
<= 'S')) {
763 events
.add(new TKeypressEvent(kbF1
));
766 events
.add(new TKeypressEvent(kbF2
));
769 events
.add(new TKeypressEvent(kbF3
));
772 events
.add(new TKeypressEvent(kbF4
));
781 // Unknown keystroke, ignore
786 // Numbers - parameter values
787 if ((ch
>= '0') && (ch
<= '9')) {
788 params
.set(paramI
, params
.get(paramI
) + ch
);
789 state
= ParseState
.CSI_PARAM
;
792 // Parameter separator
795 params
.set(paramI
, "");
799 if ((ch
>= 0x30) && (ch
<= 0x7E)) {
803 if (params
.size() > 1) {
804 if (params
.get(1).equals("2")) {
807 if (params
.get(1).equals("5")) {
810 if (params
.get(1).equals("3")) {
814 events
.add(new TKeypressEvent(kbUp
, alt
, ctrl
, shift
));
819 if (params
.size() > 1) {
820 if (params
.get(1).equals("2")) {
823 if (params
.get(1).equals("5")) {
826 if (params
.get(1).equals("3")) {
830 events
.add(new TKeypressEvent(kbDown
, alt
, ctrl
, shift
));
835 if (params
.size() > 1) {
836 if (params
.get(1).equals("2")) {
839 if (params
.get(1).equals("5")) {
842 if (params
.get(1).equals("3")) {
846 events
.add(new TKeypressEvent(kbRight
, alt
, ctrl
, shift
));
851 if (params
.size() > 1) {
852 if (params
.get(1).equals("2")) {
855 if (params
.get(1).equals("5")) {
858 if (params
.get(1).equals("3")) {
862 events
.add(new TKeypressEvent(kbLeft
, alt
, ctrl
, shift
));
867 events
.add(new TKeypressEvent(kbHome
));
872 events
.add(new TKeypressEvent(kbEnd
));
876 // CBT - Cursor backward X tab stops (default 1)
877 events
.add(new TKeypressEvent(kbBackTab
));
882 state
= ParseState
.MOUSE
;
889 // Unknown keystroke, ignore
894 // Numbers - parameter values
895 if ((ch
>= '0') && (ch
<= '9')) {
896 params
.set(paramI
, params
.get(paramI
) + ch
);
897 state
= ParseState
.CSI_PARAM
;
900 // Parameter separator
903 params
.set(paramI
, "");
908 events
.add(csiFnKey());
913 if ((ch
>= 0x30) && (ch
<= 0x7E)) {
917 if (params
.size() > 1) {
918 if (params
.get(1).equals("2")) {
921 if (params
.get(1).equals("5")) {
924 if (params
.get(1).equals("3")) {
928 events
.add(new TKeypressEvent(kbUp
, alt
, ctrl
, shift
));
933 if (params
.size() > 1) {
934 if (params
.get(1).equals("2")) {
937 if (params
.get(1).equals("5")) {
940 if (params
.get(1).equals("3")) {
944 events
.add(new TKeypressEvent(kbDown
, alt
, ctrl
, shift
));
949 if (params
.size() > 1) {
950 if (params
.get(1).equals("2")) {
953 if (params
.get(1).equals("5")) {
956 if (params
.get(1).equals("3")) {
960 events
.add(new TKeypressEvent(kbRight
, alt
, ctrl
, shift
));
965 if (params
.size() > 1) {
966 if (params
.get(1).equals("2")) {
969 if (params
.get(1).equals("5")) {
972 if (params
.get(1).equals("3")) {
976 events
.add(new TKeypressEvent(kbLeft
, alt
, ctrl
, shift
));
984 // Unknown keystroke, ignore
989 params
.set(0, params
.get(paramI
) + ch
);
990 if (params
.get(0).length() == 3) {
991 // We have enough to generate a mouse event
992 events
.add(parseMouse());
1001 // This "should" be impossible to reach
1006 * Tell (u)xterm that we want alt- keystrokes to send escape + character
1007 * rather than set the 8th bit. Anyone who wants UTF8 should want this
1010 * @param on if true, enable metaSendsEscape
1011 * @return the string to emit to xterm
1013 public String
xtermMetaSendsEscape(final boolean on
) {
1015 return "\033[?1036h\033[?1034l";
1017 return "\033[?1036l";
1021 * Convert a list of SGR parameters into a full escape sequence. This
1022 * also eliminates a trailing ';' which would otherwise reset everything
1023 * to white-on-black not-bold.
1025 * @param str string of parameters, e.g. "31;1;"
1026 * @return the string to emit to an ANSI / ECMA-style terminal,
1029 public String
addHeaderSGR(String str
) {
1030 if (str
.length() > 0) {
1031 // Nix any trailing ';' because that resets all attributes
1032 while (str
.endsWith(":")) {
1033 str
= str
.substring(0, str
.length() - 1);
1036 return "\033[" + str
+ "m";
1040 * Create a SGR parameter sequence for a single color change.
1042 * @param color one of the Color.WHITE, Color.BLUE, etc. constants
1043 * @param foreground if true, this is a foreground color
1044 * @return the string to emit to an ANSI / ECMA-style terminal,
1047 public String
color(final Color color
, final boolean foreground
) {
1048 return color(color
, foreground
, true);
1052 * Create a SGR parameter sequence for a single color change.
1054 * @param color one of the Color.WHITE, Color.BLUE, etc. constants
1055 * @param foreground if true, this is a foreground color
1056 * @param header if true, make the full header, otherwise just emit the
1057 * color parameter e.g. "42;"
1058 * @return the string to emit to an ANSI / ECMA-style terminal,
1061 public String
color(final Color color
, final boolean foreground
,
1062 final boolean header
) {
1064 int ecmaColor
= color
.getValue();
1066 // Convert Color.* values to SGR numerics
1074 return String
.format("\033[%dm", ecmaColor
);
1076 return String
.format("%d;", ecmaColor
);
1081 * Create a SGR parameter sequence for both foreground and
1082 * background color change.
1084 * @param foreColor one of the Color.WHITE, Color.BLUE, etc. constants
1085 * @param backColor one of the Color.WHITE, Color.BLUE, etc. constants
1086 * @return the string to emit to an ANSI / ECMA-style terminal,
1087 * e.g. "\033[31;42m"
1089 public String
color(final Color foreColor
, final Color backColor
) {
1090 return color(foreColor
, backColor
, true);
1094 * Create a SGR parameter sequence for both foreground and
1095 * background color change.
1097 * @param foreColor one of the Color.WHITE, Color.BLUE, etc. constants
1098 * @param backColor one of the Color.WHITE, Color.BLUE, etc. constants
1099 * @param header if true, make the full header, otherwise just emit the
1100 * color parameter e.g. "31;42;"
1101 * @return the string to emit to an ANSI / ECMA-style terminal,
1102 * e.g. "\033[31;42m"
1104 public String
color(final Color foreColor
, final Color backColor
,
1105 final boolean header
) {
1107 int ecmaForeColor
= foreColor
.getValue();
1108 int ecmaBackColor
= backColor
.getValue();
1110 // Convert Color.* values to SGR numerics
1111 ecmaBackColor
+= 40;
1112 ecmaForeColor
+= 30;
1115 return String
.format("\033[%d;%dm", ecmaForeColor
, ecmaBackColor
);
1117 return String
.format("%d;%d;", ecmaForeColor
, ecmaBackColor
);
1122 * Create a SGR parameter sequence for foreground, background, and
1123 * several attributes. This sequence first resets all attributes to
1124 * default, then sets attributes as per the parameters.
1126 * @param foreColor one of the Color.WHITE, Color.BLUE, etc. constants
1127 * @param backColor one of the Color.WHITE, Color.BLUE, etc. constants
1128 * @param bold if true, set bold
1129 * @param reverse if true, set reverse
1130 * @param blink if true, set blink
1131 * @param underline if true, set underline
1132 * @return the string to emit to an ANSI / ECMA-style terminal,
1133 * e.g. "\033[0;1;31;42m"
1135 public String
color(final Color foreColor
, final Color backColor
,
1136 final boolean bold
, final boolean reverse
, final boolean blink
,
1137 final boolean underline
) {
1139 int ecmaForeColor
= foreColor
.getValue();
1140 int ecmaBackColor
= backColor
.getValue();
1142 // Convert Color.* values to SGR numerics
1143 ecmaBackColor
+= 40;
1144 ecmaForeColor
+= 30;
1146 StringBuilder sb
= new StringBuilder();
1147 if ( bold
&& reverse
&& blink
&& !underline
) {
1148 sb
.append("\033[0;1;7;5;");
1149 } else if ( bold
&& reverse
&& !blink
&& !underline
) {
1150 sb
.append("\033[0;1;7;");
1151 } else if ( !bold
&& reverse
&& blink
&& !underline
) {
1152 sb
.append("\033[0;7;5;");
1153 } else if ( bold
&& !reverse
&& blink
&& !underline
) {
1154 sb
.append("\033[0;1;5;");
1155 } else if ( bold
&& !reverse
&& !blink
&& !underline
) {
1156 sb
.append("\033[0;1;");
1157 } else if ( !bold
&& reverse
&& !blink
&& !underline
) {
1158 sb
.append("\033[0;7;");
1159 } else if ( !bold
&& !reverse
&& blink
&& !underline
) {
1160 sb
.append("\033[0;5;");
1161 } else if ( bold
&& reverse
&& blink
&& underline
) {
1162 sb
.append("\033[0;1;7;5;4;");
1163 } else if ( bold
&& reverse
&& !blink
&& underline
) {
1164 sb
.append("\033[0;1;7;4;");
1165 } else if ( !bold
&& reverse
&& blink
&& underline
) {
1166 sb
.append("\033[0;7;5;4;");
1167 } else if ( bold
&& !reverse
&& blink
&& underline
) {
1168 sb
.append("\033[0;1;5;4;");
1169 } else if ( bold
&& !reverse
&& !blink
&& underline
) {
1170 sb
.append("\033[0;1;4;");
1171 } else if ( !bold
&& reverse
&& !blink
&& underline
) {
1172 sb
.append("\033[0;7;4;");
1173 } else if ( !bold
&& !reverse
&& blink
&& underline
) {
1174 sb
.append("\033[0;5;4;");
1175 } else if ( !bold
&& !reverse
&& !blink
&& underline
) {
1176 sb
.append("\033[0;4;");
1178 assert (!bold
&& !reverse
&& !blink
&& !underline
);
1179 sb
.append("\033[0;");
1181 sb
.append(String
.format("%d;%dm", ecmaForeColor
, ecmaBackColor
));
1182 return sb
.toString();
1186 * Create a SGR parameter sequence for enabling reverse color.
1188 * @param on if true, turn on reverse
1189 * @return the string to emit to an ANSI / ECMA-style terminal,
1192 public String
reverse(final boolean on
) {
1200 * Create a SGR parameter sequence to reset to defaults.
1202 * @return the string to emit to an ANSI / ECMA-style terminal,
1205 public String
normal() {
1206 return normal(true);
1210 * Create a SGR parameter sequence to reset to defaults.
1212 * @param header if true, make the full header, otherwise just emit the
1213 * bare parameter e.g. "0;"
1214 * @return the string to emit to an ANSI / ECMA-style terminal,
1217 public String
normal(final boolean header
) {
1219 return "\033[0;37;40m";
1225 * Create a SGR parameter sequence for enabling boldface.
1227 * @param on if true, turn on bold
1228 * @return the string to emit to an ANSI / ECMA-style terminal,
1231 public String
bold(final boolean on
) {
1232 return bold(on
, true);
1236 * Create a SGR parameter sequence for enabling boldface.
1238 * @param on if true, turn on bold
1239 * @param header if true, make the full header, otherwise just emit the
1240 * bare parameter e.g. "1;"
1241 * @return the string to emit to an ANSI / ECMA-style terminal,
1244 public String
bold(final boolean on
, final boolean header
) {
1258 * Create a SGR parameter sequence for enabling blinking text.
1260 * @param on if true, turn on blink
1261 * @return the string to emit to an ANSI / ECMA-style terminal,
1264 public String
blink(final boolean on
) {
1265 return blink(on
, true);
1269 * Create a SGR parameter sequence for enabling blinking text.
1271 * @param on if true, turn on blink
1272 * @param header if true, make the full header, otherwise just emit the
1273 * bare parameter e.g. "5;"
1274 * @return the string to emit to an ANSI / ECMA-style terminal,
1277 public String
blink(final boolean on
, final boolean header
) {
1291 * Create a SGR parameter sequence for enabling underline / underscored
1294 * @param on if true, turn on underline
1295 * @return the string to emit to an ANSI / ECMA-style terminal,
1298 public String
underline(final boolean on
) {
1306 * Create a SGR parameter sequence for enabling the visible cursor.
1308 * @param on if true, turn on cursor
1309 * @return the string to emit to an ANSI / ECMA-style terminal
1311 public String
cursor(final boolean on
) {
1312 if (on
&& !cursorOn
) {
1316 if (!on
&& cursorOn
) {
1324 * Clear the entire screen. Because some terminals use back-color-erase,
1325 * set the color to white-on-black beforehand.
1327 * @return the string to emit to an ANSI / ECMA-style terminal
1329 public String
clearAll() {
1330 return "\033[0;37;40m\033[2J";
1334 * Clear the line from the cursor (inclusive) to the end of the screen.
1335 * Because some terminals use back-color-erase, set the color to
1336 * white-on-black beforehand.
1338 * @return the string to emit to an ANSI / ECMA-style terminal
1340 public String
clearRemainingLine() {
1341 return "\033[0;37;40m\033[K";
1345 * Clear the line up the cursor (inclusive). Because some terminals use
1346 * back-color-erase, set the color to white-on-black beforehand.
1348 * @return the string to emit to an ANSI / ECMA-style terminal
1350 public String
clearPreceedingLine() {
1351 return "\033[0;37;40m\033[1K";
1355 * Clear the line. Because some terminals use back-color-erase, set the
1356 * color to white-on-black beforehand.
1358 * @return the string to emit to an ANSI / ECMA-style terminal
1360 public String
clearLine() {
1361 return "\033[0;37;40m\033[2K";
1365 * Move the cursor to the top-left corner.
1367 * @return the string to emit to an ANSI / ECMA-style terminal
1369 public String
home() {
1374 * Move the cursor to (x, y).
1376 * @param x column coordinate. 0 is the left-most column.
1377 * @param y row coordinate. 0 is the top-most row.
1378 * @return the string to emit to an ANSI / ECMA-style terminal
1380 public String
gotoXY(final int x
, final int y
) {
1381 return String
.format("\033[%d;%dH", y
+ 1, x
+ 1);
1385 * Tell (u)xterm that we want to receive mouse events based on "Any event
1386 * tracking" and UTF-8 coordinates. See
1387 * http://invisible-island.net/xterm/ctlseqs/ctlseqs.html#Mouse%20Tracking
1389 * Note that this also sets the alternate/primary screen buffer.
1391 * @param on If true, enable mouse report and use the alternate screen
1392 * buffer. If false disable mouse reporting and use the primary screen
1394 * @return the string to emit to xterm
1396 public String
mouse(final boolean on
) {
1398 return "\033[?1003;1005h\033[?1049h";
1400 return "\033[?1003;1005l\033[?1049l";
1404 * Read function runs on a separate thread.
1407 boolean done
= false;
1408 // available() will often return > 1, so we need to read in chunks to
1410 char [] readBuffer
= new char[128];
1411 List
<TInputEvent
> events
= new LinkedList
<TInputEvent
>();
1413 while (!done
&& !stopReaderThread
) {
1415 // We assume that if inputStream has bytes available, then
1416 // input won't block on read().
1417 int n
= inputStream
.available();
1419 if (readBuffer
.length
< n
) {
1420 // The buffer wasn't big enough, make it huger
1421 readBuffer
= new char[readBuffer
.length
* 2];
1424 int rc
= input
.read(readBuffer
, 0, n
);
1425 // System.err.printf("read() %d", rc); System.err.flush();
1430 for (int i
= 0; i
< rc
; i
++) {
1431 int ch
= readBuffer
[i
];
1432 processChar(events
, (char)ch
);
1433 if (events
.size() > 0) {
1434 // Add to the queue for the backend thread to
1435 // be able to obtain.
1436 synchronized (eventQueue
) {
1437 eventQueue
.addAll(events
);
1439 // Now wake up the backend
1440 synchronized (this) {
1448 // Wait 5 millis for more data
1451 // System.err.println("end while loop"); System.err.flush();
1452 } catch (InterruptedException e
) {
1454 } catch (IOException e
) {
1455 e
.printStackTrace();
1458 } // while ((done == false) && (stopReaderThread == false))
1459 // System.err.println("*** run() exiting..."); System.err.flush();