78aae45c63b315d2c40a340f60071dbdd527f0be
[fanfix.git] / ECMA48Terminal.java
1 /*
2 * Jexer - Java Text User Interface
3 *
4 * The MIT License (MIT)
5 *
6 * Copyright (C) 2017 Kevin Lamonte
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the "Software"),
10 * to deal in the Software without restriction, including without limitation
11 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12 * and/or sell copies of the Software, and to permit persons to whom the
13 * Software is furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
23 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
24 * DEALINGS IN THE SOFTWARE.
25 *
26 * @author Kevin Lamonte [kevin.lamonte@gmail.com]
27 * @version 1
28 */
29 package jexer.backend;
30
31 import java.io.BufferedReader;
32 import java.io.FileDescriptor;
33 import java.io.FileInputStream;
34 import java.io.InputStream;
35 import java.io.InputStreamReader;
36 import java.io.IOException;
37 import java.io.OutputStream;
38 import java.io.OutputStreamWriter;
39 import java.io.PrintWriter;
40 import java.io.Reader;
41 import java.io.UnsupportedEncodingException;
42 import java.util.ArrayList;
43 import java.util.Date;
44 import java.util.List;
45 import java.util.LinkedList;
46
47 import jexer.bits.Cell;
48 import jexer.bits.CellAttributes;
49 import jexer.bits.Color;
50 import jexer.event.TInputEvent;
51 import jexer.event.TKeypressEvent;
52 import jexer.event.TMouseEvent;
53 import jexer.event.TResizeEvent;
54 import static jexer.TKeypress.*;
55
56 /**
57 * This class reads keystrokes and mouse events and emits output to ANSI
58 * X3.64 / ECMA-48 type terminals e.g. xterm, linux, vt100, ansi.sys, etc.
59 */
60 public final class ECMA48Terminal extends LogicalScreen
61 implements TerminalReader, Runnable {
62
63 /**
64 * Emit debugging to stderr.
65 */
66 private boolean debugToStderr = false;
67
68 /**
69 * If true, emit T.416-style RGB colors. This is a) expensive in
70 * bandwidth, and b) potentially terrible looking for non-xterms.
71 */
72 private static boolean doRgbColor = false;
73
74 /**
75 * The session information.
76 */
77 private SessionInfo sessionInfo;
78
79 /**
80 * Getter for sessionInfo.
81 *
82 * @return the SessionInfo
83 */
84 public SessionInfo getSessionInfo() {
85 return sessionInfo;
86 }
87
88 /**
89 * The event queue, filled up by a thread reading on input.
90 */
91 private List<TInputEvent> eventQueue;
92
93 /**
94 * If true, we want the reader thread to exit gracefully.
95 */
96 private boolean stopReaderThread;
97
98 /**
99 * The reader thread.
100 */
101 private Thread readerThread;
102
103 /**
104 * Parameters being collected. E.g. if the string is \033[1;3m, then
105 * params[0] will be 1 and params[1] will be 3.
106 */
107 private ArrayList<String> params;
108
109 /**
110 * States in the input parser.
111 */
112 private enum ParseState {
113 GROUND,
114 ESCAPE,
115 ESCAPE_INTERMEDIATE,
116 CSI_ENTRY,
117 CSI_PARAM,
118 MOUSE,
119 MOUSE_SGR,
120 }
121
122 /**
123 * Current parsing state.
124 */
125 private ParseState state;
126
127 /**
128 * The time we entered ESCAPE. If we get a bare escape without a code
129 * following it, this is used to return that bare escape.
130 */
131 private long escapeTime;
132
133 /**
134 * The time we last checked the window size. We try not to spawn stty
135 * more than once per second.
136 */
137 private long windowSizeTime;
138
139 /**
140 * true if mouse1 was down. Used to report mouse1 on the release event.
141 */
142 private boolean mouse1;
143
144 /**
145 * true if mouse2 was down. Used to report mouse2 on the release event.
146 */
147 private boolean mouse2;
148
149 /**
150 * true if mouse3 was down. Used to report mouse3 on the release event.
151 */
152 private boolean mouse3;
153
154 /**
155 * Cache the cursor visibility value so we only emit the sequence when we
156 * need to.
157 */
158 private boolean cursorOn = true;
159
160 /**
161 * Cache the last window size to figure out if a TResizeEvent needs to be
162 * generated.
163 */
164 private TResizeEvent windowResize = null;
165
166 /**
167 * If true, then we changed System.in and need to change it back.
168 */
169 private boolean setRawMode;
170
171 /**
172 * The terminal's input. If an InputStream is not specified in the
173 * constructor, then this InputStreamReader will be bound to System.in
174 * with UTF-8 encoding.
175 */
176 private Reader input;
177
178 /**
179 * The terminal's raw InputStream. If an InputStream is not specified in
180 * the constructor, then this InputReader will be bound to System.in.
181 * This is used by run() to see if bytes are available() before calling
182 * (Reader)input.read().
183 */
184 private InputStream inputStream;
185
186 /**
187 * The terminal's output. If an OutputStream is not specified in the
188 * constructor, then this PrintWriter will be bound to System.out with
189 * UTF-8 encoding.
190 */
191 private PrintWriter output;
192
193 /**
194 * The listening object that run() wakes up on new input.
195 */
196 private Object listener;
197
198 /**
199 * Set listener to a different Object.
200 *
201 * @param listener the new listening object that run() wakes up on new
202 * input
203 */
204 public void setListener(final Object listener) {
205 this.listener = listener;
206 }
207
208 /**
209 * Get the output writer.
210 *
211 * @return the Writer
212 */
213 public PrintWriter getOutput() {
214 return output;
215 }
216
217 /**
218 * Check if there are events in the queue.
219 *
220 * @return if true, getEvents() has something to return to the backend
221 */
222 public boolean hasEvents() {
223 synchronized (eventQueue) {
224 return (eventQueue.size() > 0);
225 }
226 }
227
228 /**
229 * Call 'stty' to set cooked mode.
230 *
231 * <p>Actually executes '/bin/sh -c stty sane cooked &lt; /dev/tty'
232 */
233 private void sttyCooked() {
234 doStty(false);
235 }
236
237 /**
238 * Call 'stty' to set raw mode.
239 *
240 * <p>Actually executes '/bin/sh -c stty -ignbrk -brkint -parmrk -istrip
241 * -inlcr -igncr -icrnl -ixon -opost -echo -echonl -icanon -isig -iexten
242 * -parenb cs8 min 1 &lt; /dev/tty'
243 */
244 private void sttyRaw() {
245 doStty(true);
246 }
247
248 /**
249 * Call 'stty' to set raw or cooked mode.
250 *
251 * @param mode if true, set raw mode, otherwise set cooked mode
252 */
253 private void doStty(final boolean mode) {
254 String [] cmdRaw = {
255 "/bin/sh", "-c", "stty -ignbrk -brkint -parmrk -istrip -inlcr -igncr -icrnl -ixon -opost -echo -echonl -icanon -isig -iexten -parenb cs8 min 1 < /dev/tty"
256 };
257 String [] cmdCooked = {
258 "/bin/sh", "-c", "stty sane cooked < /dev/tty"
259 };
260 try {
261 Process process;
262 if (mode) {
263 process = Runtime.getRuntime().exec(cmdRaw);
264 } else {
265 process = Runtime.getRuntime().exec(cmdCooked);
266 }
267 BufferedReader in = new BufferedReader(new InputStreamReader(process.getInputStream(), "UTF-8"));
268 String line = in.readLine();
269 if ((line != null) && (line.length() > 0)) {
270 System.err.println("WEIRD?! Normal output from stty: " + line);
271 }
272 while (true) {
273 BufferedReader err = new BufferedReader(new InputStreamReader(process.getErrorStream(), "UTF-8"));
274 line = err.readLine();
275 if ((line != null) && (line.length() > 0)) {
276 System.err.println("Error output from stty: " + line);
277 }
278 try {
279 process.waitFor();
280 break;
281 } catch (InterruptedException e) {
282 e.printStackTrace();
283 }
284 }
285 int rc = process.exitValue();
286 if (rc != 0) {
287 System.err.println("stty returned error code: " + rc);
288 }
289 } catch (IOException e) {
290 e.printStackTrace();
291 }
292 }
293
294 /**
295 * Constructor sets up state for getEvent().
296 *
297 * @param listener the object this backend needs to wake up when new
298 * input comes in
299 * @param input an InputStream connected to the remote user, or null for
300 * System.in. If System.in is used, then on non-Windows systems it will
301 * be put in raw mode; shutdown() will (blindly!) put System.in in cooked
302 * mode. input is always converted to a Reader with UTF-8 encoding.
303 * @param output an OutputStream connected to the remote user, or null
304 * for System.out. output is always converted to a Writer with UTF-8
305 * encoding.
306 * @throws UnsupportedEncodingException if an exception is thrown when
307 * creating the InputStreamReader
308 */
309 public ECMA48Terminal(final Object listener, final InputStream input,
310 final OutputStream output) throws UnsupportedEncodingException {
311
312 resetParser();
313 mouse1 = false;
314 mouse2 = false;
315 mouse3 = false;
316 stopReaderThread = false;
317 this.listener = listener;
318
319 if (input == null) {
320 // inputStream = System.in;
321 inputStream = new FileInputStream(FileDescriptor.in);
322 sttyRaw();
323 setRawMode = true;
324 } else {
325 inputStream = input;
326 }
327 this.input = new InputStreamReader(inputStream, "UTF-8");
328
329 if (input instanceof SessionInfo) {
330 // This is a TelnetInputStream that exposes window size and
331 // environment variables from the telnet layer.
332 sessionInfo = (SessionInfo) input;
333 }
334 if (sessionInfo == null) {
335 if (input == null) {
336 // Reading right off the tty
337 sessionInfo = new TTYSessionInfo();
338 } else {
339 sessionInfo = new TSessionInfo();
340 }
341 }
342
343 if (output == null) {
344 this.output = new PrintWriter(new OutputStreamWriter(System.out,
345 "UTF-8"));
346 } else {
347 this.output = new PrintWriter(new OutputStreamWriter(output,
348 "UTF-8"));
349 }
350
351 // Enable mouse reporting and metaSendsEscape
352 this.output.printf("%s%s", mouse(true), xtermMetaSendsEscape(true));
353 this.output.flush();
354
355 // Query the screen size
356 sessionInfo.queryWindowSize();
357 setDimensions(sessionInfo.getWindowWidth(),
358 sessionInfo.getWindowHeight());
359
360 // Hang onto the window size
361 windowResize = new TResizeEvent(TResizeEvent.Type.SCREEN,
362 sessionInfo.getWindowWidth(), sessionInfo.getWindowHeight());
363
364 // Permit RGB colors only if externally requested
365 if (System.getProperty("jexer.ECMA48.rgbColor") != null) {
366 if (System.getProperty("jexer.ECMA48.rgbColor").equals("true")) {
367 doRgbColor = true;
368 } else {
369 doRgbColor = false;
370 }
371 }
372
373 // Spin up the input reader
374 eventQueue = new LinkedList<TInputEvent>();
375 readerThread = new Thread(this);
376 readerThread.start();
377
378 // Clear the screen
379 this.output.write(clearAll());
380 this.output.flush();
381 }
382
383 /**
384 * Constructor sets up state for getEvent().
385 *
386 * @param listener the object this backend needs to wake up when new
387 * input comes in
388 * @param input the InputStream underlying 'reader'. Its available()
389 * method is used to determine if reader.read() will block or not.
390 * @param reader a Reader connected to the remote user.
391 * @param writer a PrintWriter connected to the remote user.
392 * @param setRawMode if true, set System.in into raw mode with stty.
393 * This should in general not be used. It is here solely for Demo3,
394 * which uses System.in.
395 * @throws IllegalArgumentException if input, reader, or writer are null.
396 */
397 public ECMA48Terminal(final Object listener, final InputStream input,
398 final Reader reader, final PrintWriter writer,
399 final boolean setRawMode) {
400
401 if (input == null) {
402 throw new IllegalArgumentException("InputStream must be specified");
403 }
404 if (reader == null) {
405 throw new IllegalArgumentException("Reader must be specified");
406 }
407 if (writer == null) {
408 throw new IllegalArgumentException("Writer must be specified");
409 }
410 resetParser();
411 mouse1 = false;
412 mouse2 = false;
413 mouse3 = false;
414 stopReaderThread = false;
415 this.listener = listener;
416
417 inputStream = input;
418 this.input = reader;
419
420 if (setRawMode == true) {
421 sttyRaw();
422 }
423 this.setRawMode = setRawMode;
424
425 if (input instanceof SessionInfo) {
426 // This is a TelnetInputStream that exposes window size and
427 // environment variables from the telnet layer.
428 sessionInfo = (SessionInfo) input;
429 }
430 if (sessionInfo == null) {
431 if (setRawMode == true) {
432 // Reading right off the tty
433 sessionInfo = new TTYSessionInfo();
434 } else {
435 sessionInfo = new TSessionInfo();
436 }
437 }
438
439 this.output = writer;
440
441 // Enable mouse reporting and metaSendsEscape
442 this.output.printf("%s%s", mouse(true), xtermMetaSendsEscape(true));
443 this.output.flush();
444
445 // Query the screen size
446 sessionInfo.queryWindowSize();
447 setDimensions(sessionInfo.getWindowWidth(),
448 sessionInfo.getWindowHeight());
449
450 // Hang onto the window size
451 windowResize = new TResizeEvent(TResizeEvent.Type.SCREEN,
452 sessionInfo.getWindowWidth(), sessionInfo.getWindowHeight());
453
454 // Permit RGB colors only if externally requested
455 if (System.getProperty("jexer.ECMA48.rgbColor") != null) {
456 if (System.getProperty("jexer.ECMA48.rgbColor").equals("true")) {
457 doRgbColor = true;
458 } else {
459 doRgbColor = false;
460 }
461 }
462
463 // Spin up the input reader
464 eventQueue = new LinkedList<TInputEvent>();
465 readerThread = new Thread(this);
466 readerThread.start();
467
468 // Clear the screen
469 this.output.write(clearAll());
470 this.output.flush();
471 }
472
473 /**
474 * Constructor sets up state for getEvent().
475 *
476 * @param listener the object this backend needs to wake up when new
477 * input comes in
478 * @param input the InputStream underlying 'reader'. Its available()
479 * method is used to determine if reader.read() will block or not.
480 * @param reader a Reader connected to the remote user.
481 * @param writer a PrintWriter connected to the remote user.
482 * @throws IllegalArgumentException if input, reader, or writer are null.
483 */
484 public ECMA48Terminal(final Object listener, final InputStream input,
485 final Reader reader, final PrintWriter writer) {
486
487 this(listener, input, reader, writer, false);
488 }
489
490 /**
491 * Restore terminal to normal state.
492 */
493 public void closeTerminal() {
494
495 // System.err.println("=== shutdown() ==="); System.err.flush();
496
497 // Tell the reader thread to stop looking at input
498 stopReaderThread = true;
499 try {
500 readerThread.join();
501 } catch (InterruptedException e) {
502 e.printStackTrace();
503 }
504
505 // Disable mouse reporting and show cursor
506 output.printf("%s%s%s", mouse(false), cursor(true), normal());
507 output.flush();
508
509 if (setRawMode) {
510 sttyCooked();
511 setRawMode = false;
512 // We don't close System.in/out
513 } else {
514 // Shut down the streams, this should wake up the reader thread
515 // and make it exit.
516 try {
517 if (input != null) {
518 input.close();
519 input = null;
520 }
521 if (output != null) {
522 output.close();
523 output = null;
524 }
525 } catch (IOException e) {
526 e.printStackTrace();
527 }
528 }
529 }
530
531 /**
532 * Flush output.
533 */
534 public void flush() {
535 output.flush();
536 }
537
538 /**
539 * Perform a somewhat-optimal rendering of a line.
540 *
541 * @param y row coordinate. 0 is the top-most row.
542 * @param sb StringBuilder to write escape sequences to
543 * @param lastAttr cell attributes from the last call to flushLine
544 */
545 private void flushLine(final int y, final StringBuilder sb,
546 CellAttributes lastAttr) {
547
548 int lastX = -1;
549 int textEnd = 0;
550 for (int x = 0; x < width; x++) {
551 Cell lCell = logical[x][y];
552 if (!lCell.isBlank()) {
553 textEnd = x;
554 }
555 }
556 // Push textEnd to first column beyond the text area
557 textEnd++;
558
559 // DEBUG
560 // reallyCleared = true;
561
562 for (int x = 0; x < width; x++) {
563 Cell lCell = logical[x][y];
564 Cell pCell = physical[x][y];
565
566 if (!lCell.equals(pCell) || reallyCleared) {
567
568 if (debugToStderr) {
569 System.err.printf("\n--\n");
570 System.err.printf(" Y: %d X: %d\n", y, x);
571 System.err.printf(" lCell: %s\n", lCell);
572 System.err.printf(" pCell: %s\n", pCell);
573 System.err.printf(" ==== \n");
574 }
575
576 if (lastAttr == null) {
577 lastAttr = new CellAttributes();
578 sb.append(normal());
579 }
580
581 // Place the cell
582 if ((lastX != (x - 1)) || (lastX == -1)) {
583 // Advancing at least one cell, or the first gotoXY
584 sb.append(gotoXY(x, y));
585 }
586
587 assert (lastAttr != null);
588
589 if ((x == textEnd) && (textEnd < width - 1)) {
590 assert (lCell.isBlank());
591
592 for (int i = x; i < width; i++) {
593 assert (logical[i][y].isBlank());
594 // Physical is always updated
595 physical[i][y].reset();
596 }
597
598 // Clear remaining line
599 sb.append(clearRemainingLine());
600 lastAttr.reset();
601 return;
602 }
603
604 // Now emit only the modified attributes
605 if ((lCell.getForeColor() != lastAttr.getForeColor())
606 && (lCell.getBackColor() != lastAttr.getBackColor())
607 && (lCell.isBold() == lastAttr.isBold())
608 && (lCell.isReverse() == lastAttr.isReverse())
609 && (lCell.isUnderline() == lastAttr.isUnderline())
610 && (lCell.isBlink() == lastAttr.isBlink())
611 ) {
612 // Both colors changed, attributes the same
613 sb.append(color(lCell.isBold(),
614 lCell.getForeColor(), lCell.getBackColor()));
615
616 if (debugToStderr) {
617 System.err.printf("1 Change only fore/back colors\n");
618 }
619 } else if ((lCell.getForeColor() != lastAttr.getForeColor())
620 && (lCell.getBackColor() != lastAttr.getBackColor())
621 && (lCell.isBold() != lastAttr.isBold())
622 && (lCell.isReverse() != lastAttr.isReverse())
623 && (lCell.isUnderline() != lastAttr.isUnderline())
624 && (lCell.isBlink() != lastAttr.isBlink())
625 ) {
626 // Everything is different
627 sb.append(color(lCell.getForeColor(),
628 lCell.getBackColor(),
629 lCell.isBold(), lCell.isReverse(),
630 lCell.isBlink(),
631 lCell.isUnderline()));
632
633 if (debugToStderr) {
634 System.err.printf("2 Set all attributes\n");
635 }
636 } else if ((lCell.getForeColor() != lastAttr.getForeColor())
637 && (lCell.getBackColor() == lastAttr.getBackColor())
638 && (lCell.isBold() == lastAttr.isBold())
639 && (lCell.isReverse() == lastAttr.isReverse())
640 && (lCell.isUnderline() == lastAttr.isUnderline())
641 && (lCell.isBlink() == lastAttr.isBlink())
642 ) {
643
644 // Attributes same, foreColor different
645 sb.append(color(lCell.isBold(),
646 lCell.getForeColor(), true));
647
648 if (debugToStderr) {
649 System.err.printf("3 Change foreColor\n");
650 }
651 } else if ((lCell.getForeColor() == lastAttr.getForeColor())
652 && (lCell.getBackColor() != lastAttr.getBackColor())
653 && (lCell.isBold() == lastAttr.isBold())
654 && (lCell.isReverse() == lastAttr.isReverse())
655 && (lCell.isUnderline() == lastAttr.isUnderline())
656 && (lCell.isBlink() == lastAttr.isBlink())
657 ) {
658 // Attributes same, backColor different
659 sb.append(color(lCell.isBold(),
660 lCell.getBackColor(), false));
661
662 if (debugToStderr) {
663 System.err.printf("4 Change backColor\n");
664 }
665 } else if ((lCell.getForeColor() == lastAttr.getForeColor())
666 && (lCell.getBackColor() == lastAttr.getBackColor())
667 && (lCell.isBold() == lastAttr.isBold())
668 && (lCell.isReverse() == lastAttr.isReverse())
669 && (lCell.isUnderline() == lastAttr.isUnderline())
670 && (lCell.isBlink() == lastAttr.isBlink())
671 ) {
672
673 // All attributes the same, just print the char
674 // NOP
675
676 if (debugToStderr) {
677 System.err.printf("5 Only emit character\n");
678 }
679 } else {
680 // Just reset everything again
681 sb.append(color(lCell.getForeColor(),
682 lCell.getBackColor(),
683 lCell.isBold(),
684 lCell.isReverse(),
685 lCell.isBlink(),
686 lCell.isUnderline()));
687
688 if (debugToStderr) {
689 System.err.printf("6 Change all attributes\n");
690 }
691 }
692 // Emit the character
693 sb.append(lCell.getChar());
694
695 // Save the last rendered cell
696 lastX = x;
697 lastAttr.setTo(lCell);
698
699 // Physical is always updated
700 physical[x][y].setTo(lCell);
701
702 } // if (!lCell.equals(pCell) || (reallyCleared == true))
703
704 } // for (int x = 0; x < width; x++)
705 }
706
707 /**
708 * Render the screen to a string that can be emitted to something that
709 * knows how to process ECMA-48/ANSI X3.64 escape sequences.
710 *
711 * @return escape sequences string that provides the updates to the
712 * physical screen
713 */
714 private String flushString() {
715 if (!dirty) {
716 assert (!reallyCleared);
717 return "";
718 }
719
720 CellAttributes attr = null;
721
722 StringBuilder sb = new StringBuilder();
723 if (reallyCleared) {
724 attr = new CellAttributes();
725 sb.append(clearAll());
726 }
727
728 for (int y = 0; y < height; y++) {
729 flushLine(y, sb, attr);
730 }
731
732 dirty = false;
733 reallyCleared = false;
734
735 String result = sb.toString();
736 if (debugToStderr) {
737 System.err.printf("flushString(): %s\n", result);
738 }
739 return result;
740 }
741
742 /**
743 * Push the logical screen to the physical device.
744 */
745 @Override
746 public void flushPhysical() {
747 String result = flushString();
748 if ((cursorVisible)
749 && (cursorY <= height - 1)
750 && (cursorX <= width - 1)
751 ) {
752 result += cursor(true);
753 result += gotoXY(cursorX, cursorY);
754 } else {
755 result += cursor(false);
756 }
757 output.write(result);
758 flush();
759 }
760
761 /**
762 * Set the window title.
763 *
764 * @param title the new title
765 */
766 public void setTitle(final String title) {
767 output.write(getSetTitleString(title));
768 flush();
769 }
770
771 /**
772 * Reset keyboard/mouse input parser.
773 */
774 private void resetParser() {
775 state = ParseState.GROUND;
776 params = new ArrayList<String>();
777 params.clear();
778 params.add("");
779 }
780
781 /**
782 * Produce a control character or one of the special ones (ENTER, TAB,
783 * etc.).
784 *
785 * @param ch Unicode code point
786 * @param alt if true, set alt on the TKeypress
787 * @return one TKeypress event, either a control character (e.g. isKey ==
788 * false, ch == 'A', ctrl == true), or a special key (e.g. isKey == true,
789 * fnKey == ESC)
790 */
791 private TKeypressEvent controlChar(final char ch, final boolean alt) {
792 // System.err.printf("controlChar: %02x\n", ch);
793
794 switch (ch) {
795 case 0x0D:
796 // Carriage return --> ENTER
797 return new TKeypressEvent(kbEnter, alt, false, false);
798 case 0x0A:
799 // Linefeed --> ENTER
800 return new TKeypressEvent(kbEnter, alt, false, false);
801 case 0x1B:
802 // ESC
803 return new TKeypressEvent(kbEsc, alt, false, false);
804 case '\t':
805 // TAB
806 return new TKeypressEvent(kbTab, alt, false, false);
807 default:
808 // Make all other control characters come back as the alphabetic
809 // character with the ctrl field set. So SOH would be 'A' +
810 // ctrl.
811 return new TKeypressEvent(false, 0, (char)(ch + 0x40),
812 alt, true, false);
813 }
814 }
815
816 /**
817 * Produce special key from CSI Pn ; Pm ; ... ~
818 *
819 * @return one KEYPRESS event representing a special key
820 */
821 private TInputEvent csiFnKey() {
822 int key = 0;
823 if (params.size() > 0) {
824 key = Integer.parseInt(params.get(0));
825 }
826 boolean alt = false;
827 boolean ctrl = false;
828 boolean shift = false;
829 if (params.size() > 1) {
830 shift = csiIsShift(params.get(1));
831 alt = csiIsAlt(params.get(1));
832 ctrl = csiIsCtrl(params.get(1));
833 }
834
835 switch (key) {
836 case 1:
837 return new TKeypressEvent(kbHome, alt, ctrl, shift);
838 case 2:
839 return new TKeypressEvent(kbIns, alt, ctrl, shift);
840 case 3:
841 return new TKeypressEvent(kbDel, alt, ctrl, shift);
842 case 4:
843 return new TKeypressEvent(kbEnd, alt, ctrl, shift);
844 case 5:
845 return new TKeypressEvent(kbPgUp, alt, ctrl, shift);
846 case 6:
847 return new TKeypressEvent(kbPgDn, alt, ctrl, shift);
848 case 15:
849 return new TKeypressEvent(kbF5, alt, ctrl, shift);
850 case 17:
851 return new TKeypressEvent(kbF6, alt, ctrl, shift);
852 case 18:
853 return new TKeypressEvent(kbF7, alt, ctrl, shift);
854 case 19:
855 return new TKeypressEvent(kbF8, alt, ctrl, shift);
856 case 20:
857 return new TKeypressEvent(kbF9, alt, ctrl, shift);
858 case 21:
859 return new TKeypressEvent(kbF10, alt, ctrl, shift);
860 case 23:
861 return new TKeypressEvent(kbF11, alt, ctrl, shift);
862 case 24:
863 return new TKeypressEvent(kbF12, alt, ctrl, shift);
864 default:
865 // Unknown
866 return null;
867 }
868 }
869
870 /**
871 * Produce mouse events based on "Any event tracking" and UTF-8
872 * coordinates. See
873 * http://invisible-island.net/xterm/ctlseqs/ctlseqs.html#Mouse%20Tracking
874 *
875 * @return a MOUSE_MOTION, MOUSE_UP, or MOUSE_DOWN event
876 */
877 private TInputEvent parseMouse() {
878 int buttons = params.get(0).charAt(0) - 32;
879 int x = params.get(0).charAt(1) - 32 - 1;
880 int y = params.get(0).charAt(2) - 32 - 1;
881
882 // Clamp X and Y to the physical screen coordinates.
883 if (x >= windowResize.getWidth()) {
884 x = windowResize.getWidth() - 1;
885 }
886 if (y >= windowResize.getHeight()) {
887 y = windowResize.getHeight() - 1;
888 }
889
890 TMouseEvent.Type eventType = TMouseEvent.Type.MOUSE_DOWN;
891 boolean eventMouse1 = false;
892 boolean eventMouse2 = false;
893 boolean eventMouse3 = false;
894 boolean eventMouseWheelUp = false;
895 boolean eventMouseWheelDown = false;
896
897 // System.err.printf("buttons: %04x\r\n", buttons);
898
899 switch (buttons) {
900 case 0:
901 eventMouse1 = true;
902 mouse1 = true;
903 break;
904 case 1:
905 eventMouse2 = true;
906 mouse2 = true;
907 break;
908 case 2:
909 eventMouse3 = true;
910 mouse3 = true;
911 break;
912 case 3:
913 // Release or Move
914 if (!mouse1 && !mouse2 && !mouse3) {
915 eventType = TMouseEvent.Type.MOUSE_MOTION;
916 } else {
917 eventType = TMouseEvent.Type.MOUSE_UP;
918 }
919 if (mouse1) {
920 mouse1 = false;
921 eventMouse1 = true;
922 }
923 if (mouse2) {
924 mouse2 = false;
925 eventMouse2 = true;
926 }
927 if (mouse3) {
928 mouse3 = false;
929 eventMouse3 = true;
930 }
931 break;
932
933 case 32:
934 // Dragging with mouse1 down
935 eventMouse1 = true;
936 mouse1 = true;
937 eventType = TMouseEvent.Type.MOUSE_MOTION;
938 break;
939
940 case 33:
941 // Dragging with mouse2 down
942 eventMouse2 = true;
943 mouse2 = true;
944 eventType = TMouseEvent.Type.MOUSE_MOTION;
945 break;
946
947 case 34:
948 // Dragging with mouse3 down
949 eventMouse3 = true;
950 mouse3 = true;
951 eventType = TMouseEvent.Type.MOUSE_MOTION;
952 break;
953
954 case 96:
955 // Dragging with mouse2 down after wheelUp
956 eventMouse2 = true;
957 mouse2 = true;
958 eventType = TMouseEvent.Type.MOUSE_MOTION;
959 break;
960
961 case 97:
962 // Dragging with mouse2 down after wheelDown
963 eventMouse2 = true;
964 mouse2 = true;
965 eventType = TMouseEvent.Type.MOUSE_MOTION;
966 break;
967
968 case 64:
969 eventMouseWheelUp = true;
970 break;
971
972 case 65:
973 eventMouseWheelDown = true;
974 break;
975
976 default:
977 // Unknown, just make it motion
978 eventType = TMouseEvent.Type.MOUSE_MOTION;
979 break;
980 }
981 return new TMouseEvent(eventType, x, y, x, y,
982 eventMouse1, eventMouse2, eventMouse3,
983 eventMouseWheelUp, eventMouseWheelDown);
984 }
985
986 /**
987 * Produce mouse events based on "Any event tracking" and SGR
988 * coordinates. See
989 * http://invisible-island.net/xterm/ctlseqs/ctlseqs.html#Mouse%20Tracking
990 *
991 * @param release if true, this was a release ('m')
992 * @return a MOUSE_MOTION, MOUSE_UP, or MOUSE_DOWN event
993 */
994 private TInputEvent parseMouseSGR(final boolean release) {
995 // SGR extended coordinates - mode 1006
996 if (params.size() < 3) {
997 // Invalid position, bail out.
998 return null;
999 }
1000 int buttons = Integer.parseInt(params.get(0));
1001 int x = Integer.parseInt(params.get(1)) - 1;
1002 int y = Integer.parseInt(params.get(2)) - 1;
1003
1004 // Clamp X and Y to the physical screen coordinates.
1005 if (x >= windowResize.getWidth()) {
1006 x = windowResize.getWidth() - 1;
1007 }
1008 if (y >= windowResize.getHeight()) {
1009 y = windowResize.getHeight() - 1;
1010 }
1011
1012 TMouseEvent.Type eventType = TMouseEvent.Type.MOUSE_DOWN;
1013 boolean eventMouse1 = false;
1014 boolean eventMouse2 = false;
1015 boolean eventMouse3 = false;
1016 boolean eventMouseWheelUp = false;
1017 boolean eventMouseWheelDown = false;
1018
1019 if (release) {
1020 eventType = TMouseEvent.Type.MOUSE_UP;
1021 }
1022
1023 switch (buttons) {
1024 case 0:
1025 eventMouse1 = true;
1026 break;
1027 case 1:
1028 eventMouse2 = true;
1029 break;
1030 case 2:
1031 eventMouse3 = true;
1032 break;
1033 case 35:
1034 // Motion only, no buttons down
1035 eventType = TMouseEvent.Type.MOUSE_MOTION;
1036 break;
1037
1038 case 32:
1039 // Dragging with mouse1 down
1040 eventMouse1 = true;
1041 eventType = TMouseEvent.Type.MOUSE_MOTION;
1042 break;
1043
1044 case 33:
1045 // Dragging with mouse2 down
1046 eventMouse2 = true;
1047 eventType = TMouseEvent.Type.MOUSE_MOTION;
1048 break;
1049
1050 case 34:
1051 // Dragging with mouse3 down
1052 eventMouse3 = true;
1053 eventType = TMouseEvent.Type.MOUSE_MOTION;
1054 break;
1055
1056 case 96:
1057 // Dragging with mouse2 down after wheelUp
1058 eventMouse2 = true;
1059 eventType = TMouseEvent.Type.MOUSE_MOTION;
1060 break;
1061
1062 case 97:
1063 // Dragging with mouse2 down after wheelDown
1064 eventMouse2 = true;
1065 eventType = TMouseEvent.Type.MOUSE_MOTION;
1066 break;
1067
1068 case 64:
1069 eventMouseWheelUp = true;
1070 break;
1071
1072 case 65:
1073 eventMouseWheelDown = true;
1074 break;
1075
1076 default:
1077 // Unknown, bail out
1078 return null;
1079 }
1080 return new TMouseEvent(eventType, x, y, x, y,
1081 eventMouse1, eventMouse2, eventMouse3,
1082 eventMouseWheelUp, eventMouseWheelDown);
1083 }
1084
1085 /**
1086 * Return any events in the IO queue.
1087 *
1088 * @param queue list to append new events to
1089 */
1090 public void getEvents(final List<TInputEvent> queue) {
1091 synchronized (eventQueue) {
1092 if (eventQueue.size() > 0) {
1093 synchronized (queue) {
1094 queue.addAll(eventQueue);
1095 }
1096 eventQueue.clear();
1097 }
1098 }
1099 }
1100
1101 /**
1102 * Return any events in the IO queue due to timeout.
1103 *
1104 * @param queue list to append new events to
1105 */
1106 private void getIdleEvents(final List<TInputEvent> queue) {
1107 Date now = new Date();
1108
1109 // Check for new window size
1110 long windowSizeDelay = now.getTime() - windowSizeTime;
1111 if (windowSizeDelay > 1000) {
1112 sessionInfo.queryWindowSize();
1113 int newWidth = sessionInfo.getWindowWidth();
1114 int newHeight = sessionInfo.getWindowHeight();
1115 if ((newWidth != windowResize.getWidth())
1116 || (newHeight != windowResize.getHeight())
1117 ) {
1118 TResizeEvent event = new TResizeEvent(TResizeEvent.Type.SCREEN,
1119 newWidth, newHeight);
1120 windowResize = new TResizeEvent(TResizeEvent.Type.SCREEN,
1121 newWidth, newHeight);
1122 queue.add(event);
1123 }
1124 windowSizeTime = now.getTime();
1125 }
1126
1127 // ESCDELAY type timeout
1128 if (state == ParseState.ESCAPE) {
1129 long escDelay = now.getTime() - escapeTime;
1130 if (escDelay > 100) {
1131 // After 0.1 seconds, assume a true escape character
1132 queue.add(controlChar((char)0x1B, false));
1133 resetParser();
1134 }
1135 }
1136 }
1137
1138 /**
1139 * Returns true if the CSI parameter for a keyboard command means that
1140 * shift was down.
1141 */
1142 private boolean csiIsShift(final String x) {
1143 if ((x.equals("2"))
1144 || (x.equals("4"))
1145 || (x.equals("6"))
1146 || (x.equals("8"))
1147 ) {
1148 return true;
1149 }
1150 return false;
1151 }
1152
1153 /**
1154 * Returns true if the CSI parameter for a keyboard command means that
1155 * alt was down.
1156 */
1157 private boolean csiIsAlt(final String x) {
1158 if ((x.equals("3"))
1159 || (x.equals("4"))
1160 || (x.equals("7"))
1161 || (x.equals("8"))
1162 ) {
1163 return true;
1164 }
1165 return false;
1166 }
1167
1168 /**
1169 * Returns true if the CSI parameter for a keyboard command means that
1170 * ctrl was down.
1171 */
1172 private boolean csiIsCtrl(final String x) {
1173 if ((x.equals("5"))
1174 || (x.equals("6"))
1175 || (x.equals("7"))
1176 || (x.equals("8"))
1177 ) {
1178 return true;
1179 }
1180 return false;
1181 }
1182
1183 /**
1184 * Parses the next character of input to see if an InputEvent is
1185 * fully here.
1186 *
1187 * @param events list to append new events to
1188 * @param ch Unicode code point
1189 */
1190 private void processChar(final List<TInputEvent> events, final char ch) {
1191
1192 // ESCDELAY type timeout
1193 Date now = new Date();
1194 if (state == ParseState.ESCAPE) {
1195 long escDelay = now.getTime() - escapeTime;
1196 if (escDelay > 250) {
1197 // After 0.25 seconds, assume a true escape character
1198 events.add(controlChar((char)0x1B, false));
1199 resetParser();
1200 }
1201 }
1202
1203 // TKeypress fields
1204 boolean ctrl = false;
1205 boolean alt = false;
1206 boolean shift = false;
1207
1208 // System.err.printf("state: %s ch %c\r\n", state, ch);
1209
1210 switch (state) {
1211 case GROUND:
1212
1213 if (ch == 0x1B) {
1214 state = ParseState.ESCAPE;
1215 escapeTime = now.getTime();
1216 return;
1217 }
1218
1219 if (ch <= 0x1F) {
1220 // Control character
1221 events.add(controlChar(ch, false));
1222 resetParser();
1223 return;
1224 }
1225
1226 if (ch >= 0x20) {
1227 // Normal character
1228 events.add(new TKeypressEvent(false, 0, ch,
1229 false, false, false));
1230 resetParser();
1231 return;
1232 }
1233
1234 break;
1235
1236 case ESCAPE:
1237 if (ch <= 0x1F) {
1238 // ALT-Control character
1239 events.add(controlChar(ch, true));
1240 resetParser();
1241 return;
1242 }
1243
1244 if (ch == 'O') {
1245 // This will be one of the function keys
1246 state = ParseState.ESCAPE_INTERMEDIATE;
1247 return;
1248 }
1249
1250 // '[' goes to CSI_ENTRY
1251 if (ch == '[') {
1252 state = ParseState.CSI_ENTRY;
1253 return;
1254 }
1255
1256 // Everything else is assumed to be Alt-keystroke
1257 if ((ch >= 'A') && (ch <= 'Z')) {
1258 shift = true;
1259 }
1260 alt = true;
1261 events.add(new TKeypressEvent(false, 0, ch, alt, ctrl, shift));
1262 resetParser();
1263 return;
1264
1265 case ESCAPE_INTERMEDIATE:
1266 if ((ch >= 'P') && (ch <= 'S')) {
1267 // Function key
1268 switch (ch) {
1269 case 'P':
1270 events.add(new TKeypressEvent(kbF1));
1271 break;
1272 case 'Q':
1273 events.add(new TKeypressEvent(kbF2));
1274 break;
1275 case 'R':
1276 events.add(new TKeypressEvent(kbF3));
1277 break;
1278 case 'S':
1279 events.add(new TKeypressEvent(kbF4));
1280 break;
1281 default:
1282 break;
1283 }
1284 resetParser();
1285 return;
1286 }
1287
1288 // Unknown keystroke, ignore
1289 resetParser();
1290 return;
1291
1292 case CSI_ENTRY:
1293 // Numbers - parameter values
1294 if ((ch >= '0') && (ch <= '9')) {
1295 params.set(params.size() - 1,
1296 params.get(params.size() - 1) + ch);
1297 state = ParseState.CSI_PARAM;
1298 return;
1299 }
1300 // Parameter separator
1301 if (ch == ';') {
1302 params.add("");
1303 return;
1304 }
1305
1306 if ((ch >= 0x30) && (ch <= 0x7E)) {
1307 switch (ch) {
1308 case 'A':
1309 // Up
1310 events.add(new TKeypressEvent(kbUp, alt, ctrl, shift));
1311 resetParser();
1312 return;
1313 case 'B':
1314 // Down
1315 events.add(new TKeypressEvent(kbDown, alt, ctrl, shift));
1316 resetParser();
1317 return;
1318 case 'C':
1319 // Right
1320 events.add(new TKeypressEvent(kbRight, alt, ctrl, shift));
1321 resetParser();
1322 return;
1323 case 'D':
1324 // Left
1325 events.add(new TKeypressEvent(kbLeft, alt, ctrl, shift));
1326 resetParser();
1327 return;
1328 case 'H':
1329 // Home
1330 events.add(new TKeypressEvent(kbHome));
1331 resetParser();
1332 return;
1333 case 'F':
1334 // End
1335 events.add(new TKeypressEvent(kbEnd));
1336 resetParser();
1337 return;
1338 case 'Z':
1339 // CBT - Cursor backward X tab stops (default 1)
1340 events.add(new TKeypressEvent(kbBackTab));
1341 resetParser();
1342 return;
1343 case 'M':
1344 // Mouse position
1345 state = ParseState.MOUSE;
1346 return;
1347 case '<':
1348 // Mouse position, SGR (1006) coordinates
1349 state = ParseState.MOUSE_SGR;
1350 return;
1351 default:
1352 break;
1353 }
1354 }
1355
1356 // Unknown keystroke, ignore
1357 resetParser();
1358 return;
1359
1360 case MOUSE_SGR:
1361 // Numbers - parameter values
1362 if ((ch >= '0') && (ch <= '9')) {
1363 params.set(params.size() - 1,
1364 params.get(params.size() - 1) + ch);
1365 return;
1366 }
1367 // Parameter separator
1368 if (ch == ';') {
1369 params.add("");
1370 return;
1371 }
1372
1373 switch (ch) {
1374 case 'M':
1375 // Generate a mouse press event
1376 TInputEvent event = parseMouseSGR(false);
1377 if (event != null) {
1378 events.add(event);
1379 }
1380 resetParser();
1381 return;
1382 case 'm':
1383 // Generate a mouse release event
1384 event = parseMouseSGR(true);
1385 if (event != null) {
1386 events.add(event);
1387 }
1388 resetParser();
1389 return;
1390 default:
1391 break;
1392 }
1393
1394 // Unknown keystroke, ignore
1395 resetParser();
1396 return;
1397
1398 case CSI_PARAM:
1399 // Numbers - parameter values
1400 if ((ch >= '0') && (ch <= '9')) {
1401 params.set(params.size() - 1,
1402 params.get(params.size() - 1) + ch);
1403 state = ParseState.CSI_PARAM;
1404 return;
1405 }
1406 // Parameter separator
1407 if (ch == ';') {
1408 params.add("");
1409 return;
1410 }
1411
1412 if (ch == '~') {
1413 events.add(csiFnKey());
1414 resetParser();
1415 return;
1416 }
1417
1418 if ((ch >= 0x30) && (ch <= 0x7E)) {
1419 switch (ch) {
1420 case 'A':
1421 // Up
1422 if (params.size() > 1) {
1423 shift = csiIsShift(params.get(1));
1424 alt = csiIsAlt(params.get(1));
1425 ctrl = csiIsCtrl(params.get(1));
1426 }
1427 events.add(new TKeypressEvent(kbUp, alt, ctrl, shift));
1428 resetParser();
1429 return;
1430 case 'B':
1431 // Down
1432 if (params.size() > 1) {
1433 shift = csiIsShift(params.get(1));
1434 alt = csiIsAlt(params.get(1));
1435 ctrl = csiIsCtrl(params.get(1));
1436 }
1437 events.add(new TKeypressEvent(kbDown, alt, ctrl, shift));
1438 resetParser();
1439 return;
1440 case 'C':
1441 // Right
1442 if (params.size() > 1) {
1443 shift = csiIsShift(params.get(1));
1444 alt = csiIsAlt(params.get(1));
1445 ctrl = csiIsCtrl(params.get(1));
1446 }
1447 events.add(new TKeypressEvent(kbRight, alt, ctrl, shift));
1448 resetParser();
1449 return;
1450 case 'D':
1451 // Left
1452 if (params.size() > 1) {
1453 shift = csiIsShift(params.get(1));
1454 alt = csiIsAlt(params.get(1));
1455 ctrl = csiIsCtrl(params.get(1));
1456 }
1457 events.add(new TKeypressEvent(kbLeft, alt, ctrl, shift));
1458 resetParser();
1459 return;
1460 case 'H':
1461 // Home
1462 if (params.size() > 1) {
1463 shift = csiIsShift(params.get(1));
1464 alt = csiIsAlt(params.get(1));
1465 ctrl = csiIsCtrl(params.get(1));
1466 }
1467 events.add(new TKeypressEvent(kbHome, alt, ctrl, shift));
1468 resetParser();
1469 return;
1470 case 'F':
1471 // End
1472 if (params.size() > 1) {
1473 shift = csiIsShift(params.get(1));
1474 alt = csiIsAlt(params.get(1));
1475 ctrl = csiIsCtrl(params.get(1));
1476 }
1477 events.add(new TKeypressEvent(kbEnd, alt, ctrl, shift));
1478 resetParser();
1479 return;
1480 default:
1481 break;
1482 }
1483 }
1484
1485 // Unknown keystroke, ignore
1486 resetParser();
1487 return;
1488
1489 case MOUSE:
1490 params.set(0, params.get(params.size() - 1) + ch);
1491 if (params.get(0).length() == 3) {
1492 // We have enough to generate a mouse event
1493 events.add(parseMouse());
1494 resetParser();
1495 }
1496 return;
1497
1498 default:
1499 break;
1500 }
1501
1502 // This "should" be impossible to reach
1503 return;
1504 }
1505
1506 /**
1507 * Tell (u)xterm that we want alt- keystrokes to send escape + character
1508 * rather than set the 8th bit. Anyone who wants UTF8 should want this
1509 * enabled.
1510 *
1511 * @param on if true, enable metaSendsEscape
1512 * @return the string to emit to xterm
1513 */
1514 private String xtermMetaSendsEscape(final boolean on) {
1515 if (on) {
1516 return "\033[?1036h\033[?1034l";
1517 }
1518 return "\033[?1036l";
1519 }
1520
1521 /**
1522 * Create an xterm OSC sequence to change the window title.
1523 *
1524 * @param title the new title
1525 * @return the string to emit to xterm
1526 */
1527 private String getSetTitleString(final String title) {
1528 return "\033]2;" + title + "\007";
1529 }
1530
1531 /**
1532 * Create a SGR parameter sequence for a single color change.
1533 *
1534 * @param bold if true, set bold
1535 * @param color one of the Color.WHITE, Color.BLUE, etc. constants
1536 * @param foreground if true, this is a foreground color
1537 * @return the string to emit to an ANSI / ECMA-style terminal,
1538 * e.g. "\033[42m"
1539 */
1540 private String color(final boolean bold, final Color color,
1541 final boolean foreground) {
1542 return color(color, foreground, true) +
1543 rgbColor(bold, color, foreground);
1544 }
1545
1546 /**
1547 * Create a T.416 RGB parameter sequence for a single color change.
1548 *
1549 * @param bold if true, set bold
1550 * @param color one of the Color.WHITE, Color.BLUE, etc. constants
1551 * @param foreground if true, this is a foreground color
1552 * @return the string to emit to an xterm terminal with RGB support,
1553 * e.g. "\033[38;2;RR;GG;BBm"
1554 */
1555 private String rgbColor(final boolean bold, final Color color,
1556 final boolean foreground) {
1557 if (doRgbColor == false) {
1558 return "";
1559 }
1560 StringBuilder sb = new StringBuilder("\033[");
1561 if (bold) {
1562 // Bold implies foreground only
1563 sb.append("38;2;");
1564 if (color.equals(Color.BLACK)) {
1565 sb.append("84;84;84");
1566 } else if (color.equals(Color.RED)) {
1567 sb.append("252;84;84");
1568 } else if (color.equals(Color.GREEN)) {
1569 sb.append("84;252;84");
1570 } else if (color.equals(Color.YELLOW)) {
1571 sb.append("252;252;84");
1572 } else if (color.equals(Color.BLUE)) {
1573 sb.append("84;84;252");
1574 } else if (color.equals(Color.MAGENTA)) {
1575 sb.append("252;84;252");
1576 } else if (color.equals(Color.CYAN)) {
1577 sb.append("84;252;252");
1578 } else if (color.equals(Color.WHITE)) {
1579 sb.append("252;252;252");
1580 }
1581 } else {
1582 if (foreground) {
1583 sb.append("38;2;");
1584 } else {
1585 sb.append("48;2;");
1586 }
1587 if (color.equals(Color.BLACK)) {
1588 sb.append("0;0;0");
1589 } else if (color.equals(Color.RED)) {
1590 sb.append("168;0;0");
1591 } else if (color.equals(Color.GREEN)) {
1592 sb.append("0;168;0");
1593 } else if (color.equals(Color.YELLOW)) {
1594 sb.append("168;84;0");
1595 } else if (color.equals(Color.BLUE)) {
1596 sb.append("0;0;168");
1597 } else if (color.equals(Color.MAGENTA)) {
1598 sb.append("168;0;168");
1599 } else if (color.equals(Color.CYAN)) {
1600 sb.append("0;168;168");
1601 } else if (color.equals(Color.WHITE)) {
1602 sb.append("168;168;168");
1603 }
1604 }
1605 sb.append("m");
1606 return sb.toString();
1607 }
1608
1609 /**
1610 * Create a T.416 RGB parameter sequence for both foreground and
1611 * background color change.
1612 *
1613 * @param bold if true, set bold
1614 * @param foreColor one of the Color.WHITE, Color.BLUE, etc. constants
1615 * @param backColor one of the Color.WHITE, Color.BLUE, etc. constants
1616 * @return the string to emit to an xterm terminal with RGB support,
1617 * e.g. "\033[38;2;RR;GG;BB;48;2;RR;GG;BBm"
1618 */
1619 private String rgbColor(final boolean bold, final Color foreColor,
1620 final Color backColor) {
1621 if (doRgbColor == false) {
1622 return "";
1623 }
1624
1625 return rgbColor(bold, foreColor, true) +
1626 rgbColor(false, backColor, false);
1627 }
1628
1629 /**
1630 * Create a SGR parameter sequence for a single color change.
1631 *
1632 * @param color one of the Color.WHITE, Color.BLUE, etc. constants
1633 * @param foreground if true, this is a foreground color
1634 * @param header if true, make the full header, otherwise just emit the
1635 * color parameter e.g. "42;"
1636 * @return the string to emit to an ANSI / ECMA-style terminal,
1637 * e.g. "\033[42m"
1638 */
1639 private String color(final Color color, final boolean foreground,
1640 final boolean header) {
1641
1642 int ecmaColor = color.getValue();
1643
1644 // Convert Color.* values to SGR numerics
1645 if (foreground) {
1646 ecmaColor += 30;
1647 } else {
1648 ecmaColor += 40;
1649 }
1650
1651 if (header) {
1652 return String.format("\033[%dm", ecmaColor);
1653 } else {
1654 return String.format("%d;", ecmaColor);
1655 }
1656 }
1657
1658 /**
1659 * Create a SGR parameter sequence for both foreground and background
1660 * color change.
1661 *
1662 * @param bold if true, set bold
1663 * @param foreColor one of the Color.WHITE, Color.BLUE, etc. constants
1664 * @param backColor one of the Color.WHITE, Color.BLUE, etc. constants
1665 * @return the string to emit to an ANSI / ECMA-style terminal,
1666 * e.g. "\033[31;42m"
1667 */
1668 private String color(final boolean bold, final Color foreColor,
1669 final Color backColor) {
1670 return color(foreColor, backColor, true) +
1671 rgbColor(bold, foreColor, backColor);
1672 }
1673
1674 /**
1675 * Create a SGR parameter sequence for both foreground and
1676 * background color change.
1677 *
1678 * @param foreColor one of the Color.WHITE, Color.BLUE, etc. constants
1679 * @param backColor one of the Color.WHITE, Color.BLUE, etc. constants
1680 * @param header if true, make the full header, otherwise just emit the
1681 * color parameter e.g. "31;42;"
1682 * @return the string to emit to an ANSI / ECMA-style terminal,
1683 * e.g. "\033[31;42m"
1684 */
1685 private String color(final Color foreColor, final Color backColor,
1686 final boolean header) {
1687
1688 int ecmaForeColor = foreColor.getValue();
1689 int ecmaBackColor = backColor.getValue();
1690
1691 // Convert Color.* values to SGR numerics
1692 ecmaBackColor += 40;
1693 ecmaForeColor += 30;
1694
1695 if (header) {
1696 return String.format("\033[%d;%dm", ecmaForeColor, ecmaBackColor);
1697 } else {
1698 return String.format("%d;%d;", ecmaForeColor, ecmaBackColor);
1699 }
1700 }
1701
1702 /**
1703 * Create a SGR parameter sequence for foreground, background, and
1704 * several attributes. This sequence first resets all attributes to
1705 * default, then sets attributes as per the parameters.
1706 *
1707 * @param foreColor one of the Color.WHITE, Color.BLUE, etc. constants
1708 * @param backColor one of the Color.WHITE, Color.BLUE, etc. constants
1709 * @param bold if true, set bold
1710 * @param reverse if true, set reverse
1711 * @param blink if true, set blink
1712 * @param underline if true, set underline
1713 * @return the string to emit to an ANSI / ECMA-style terminal,
1714 * e.g. "\033[0;1;31;42m"
1715 */
1716 private String color(final Color foreColor, final Color backColor,
1717 final boolean bold, final boolean reverse, final boolean blink,
1718 final boolean underline) {
1719
1720 int ecmaForeColor = foreColor.getValue();
1721 int ecmaBackColor = backColor.getValue();
1722
1723 // Convert Color.* values to SGR numerics
1724 ecmaBackColor += 40;
1725 ecmaForeColor += 30;
1726
1727 StringBuilder sb = new StringBuilder();
1728 if ( bold && reverse && blink && !underline ) {
1729 sb.append("\033[0;1;7;5;");
1730 } else if ( bold && reverse && !blink && !underline ) {
1731 sb.append("\033[0;1;7;");
1732 } else if ( !bold && reverse && blink && !underline ) {
1733 sb.append("\033[0;7;5;");
1734 } else if ( bold && !reverse && blink && !underline ) {
1735 sb.append("\033[0;1;5;");
1736 } else if ( bold && !reverse && !blink && !underline ) {
1737 sb.append("\033[0;1;");
1738 } else if ( !bold && reverse && !blink && !underline ) {
1739 sb.append("\033[0;7;");
1740 } else if ( !bold && !reverse && blink && !underline) {
1741 sb.append("\033[0;5;");
1742 } else if ( bold && reverse && blink && underline ) {
1743 sb.append("\033[0;1;7;5;4;");
1744 } else if ( bold && reverse && !blink && underline ) {
1745 sb.append("\033[0;1;7;4;");
1746 } else if ( !bold && reverse && blink && underline ) {
1747 sb.append("\033[0;7;5;4;");
1748 } else if ( bold && !reverse && blink && underline ) {
1749 sb.append("\033[0;1;5;4;");
1750 } else if ( bold && !reverse && !blink && underline ) {
1751 sb.append("\033[0;1;4;");
1752 } else if ( !bold && reverse && !blink && underline ) {
1753 sb.append("\033[0;7;4;");
1754 } else if ( !bold && !reverse && blink && underline) {
1755 sb.append("\033[0;5;4;");
1756 } else if ( !bold && !reverse && !blink && underline) {
1757 sb.append("\033[0;4;");
1758 } else {
1759 assert (!bold && !reverse && !blink && !underline);
1760 sb.append("\033[0;");
1761 }
1762 sb.append(String.format("%d;%dm", ecmaForeColor, ecmaBackColor));
1763 sb.append(rgbColor(bold, foreColor, backColor));
1764 return sb.toString();
1765 }
1766
1767 /**
1768 * Create a SGR parameter sequence to reset to defaults.
1769 *
1770 * @return the string to emit to an ANSI / ECMA-style terminal,
1771 * e.g. "\033[0m"
1772 */
1773 private String normal() {
1774 return normal(true) + rgbColor(false, Color.WHITE, Color.BLACK);
1775 }
1776
1777 /**
1778 * Create a SGR parameter sequence to reset to defaults.
1779 *
1780 * @param header if true, make the full header, otherwise just emit the
1781 * bare parameter e.g. "0;"
1782 * @return the string to emit to an ANSI / ECMA-style terminal,
1783 * e.g. "\033[0m"
1784 */
1785 private String normal(final boolean header) {
1786 if (header) {
1787 return "\033[0;37;40m";
1788 }
1789 return "0;37;40";
1790 }
1791
1792 /**
1793 * Create a SGR parameter sequence for enabling the visible cursor.
1794 *
1795 * @param on if true, turn on cursor
1796 * @return the string to emit to an ANSI / ECMA-style terminal
1797 */
1798 private String cursor(final boolean on) {
1799 if (on && !cursorOn) {
1800 cursorOn = true;
1801 return "\033[?25h";
1802 }
1803 if (!on && cursorOn) {
1804 cursorOn = false;
1805 return "\033[?25l";
1806 }
1807 return "";
1808 }
1809
1810 /**
1811 * Clear the entire screen. Because some terminals use back-color-erase,
1812 * set the color to white-on-black beforehand.
1813 *
1814 * @return the string to emit to an ANSI / ECMA-style terminal
1815 */
1816 private String clearAll() {
1817 return "\033[0;37;40m\033[2J";
1818 }
1819
1820 /**
1821 * Clear the line from the cursor (inclusive) to the end of the screen.
1822 * Because some terminals use back-color-erase, set the color to
1823 * white-on-black beforehand.
1824 *
1825 * @return the string to emit to an ANSI / ECMA-style terminal
1826 */
1827 private String clearRemainingLine() {
1828 return "\033[0;37;40m\033[K";
1829 }
1830
1831 /**
1832 * Move the cursor to (x, y).
1833 *
1834 * @param x column coordinate. 0 is the left-most column.
1835 * @param y row coordinate. 0 is the top-most row.
1836 * @return the string to emit to an ANSI / ECMA-style terminal
1837 */
1838 private String gotoXY(final int x, final int y) {
1839 return String.format("\033[%d;%dH", y + 1, x + 1);
1840 }
1841
1842 /**
1843 * Tell (u)xterm that we want to receive mouse events based on "Any event
1844 * tracking", UTF-8 coordinates, and then SGR coordinates. Ideally we
1845 * will end up with SGR coordinates with UTF-8 coordinates as a fallback.
1846 * See
1847 * http://invisible-island.net/xterm/ctlseqs/ctlseqs.html#Mouse%20Tracking
1848 *
1849 * Note that this also sets the alternate/primary screen buffer.
1850 *
1851 * @param on If true, enable mouse report and use the alternate screen
1852 * buffer. If false disable mouse reporting and use the primary screen
1853 * buffer.
1854 * @return the string to emit to xterm
1855 */
1856 private String mouse(final boolean on) {
1857 if (on) {
1858 return "\033[?1002;1003;1005;1006h\033[?1049h";
1859 }
1860 return "\033[?1002;1003;1006;1005l\033[?1049l";
1861 }
1862
1863 /**
1864 * Read function runs on a separate thread.
1865 */
1866 public void run() {
1867 boolean done = false;
1868 // available() will often return > 1, so we need to read in chunks to
1869 // stay caught up.
1870 char [] readBuffer = new char[128];
1871 List<TInputEvent> events = new LinkedList<TInputEvent>();
1872
1873 while (!done && !stopReaderThread) {
1874 try {
1875 // We assume that if inputStream has bytes available, then
1876 // input won't block on read().
1877 int n = inputStream.available();
1878 if (n > 0) {
1879 if (readBuffer.length < n) {
1880 // The buffer wasn't big enough, make it huger
1881 readBuffer = new char[readBuffer.length * 2];
1882 }
1883
1884 int rc = input.read(readBuffer, 0, readBuffer.length);
1885 // System.err.printf("read() %d", rc); System.err.flush();
1886 if (rc == -1) {
1887 // This is EOF
1888 done = true;
1889 } else {
1890 for (int i = 0; i < rc; i++) {
1891 int ch = readBuffer[i];
1892 processChar(events, (char)ch);
1893 }
1894 getIdleEvents(events);
1895 if (events.size() > 0) {
1896 // Add to the queue for the backend thread to
1897 // be able to obtain.
1898 synchronized (eventQueue) {
1899 eventQueue.addAll(events);
1900 }
1901 if (listener != null) {
1902 synchronized (listener) {
1903 listener.notifyAll();
1904 }
1905 }
1906 events.clear();
1907 }
1908 }
1909 } else {
1910 getIdleEvents(events);
1911 if (events.size() > 0) {
1912 synchronized (eventQueue) {
1913 eventQueue.addAll(events);
1914 }
1915 events.clear();
1916 if (listener != null) {
1917 synchronized (listener) {
1918 listener.notifyAll();
1919 }
1920 }
1921 }
1922
1923 // Wait 10 millis for more data
1924 Thread.sleep(10);
1925 }
1926 // System.err.println("end while loop"); System.err.flush();
1927 } catch (InterruptedException e) {
1928 // SQUASH
1929 } catch (IOException e) {
1930 e.printStackTrace();
1931 done = true;
1932 }
1933 } // while ((done == false) && (stopReaderThread == false))
1934 // System.err.println("*** run() exiting..."); System.err.flush();
1935 }
1936
1937 }