9e9ffe3be47495f50d4cc3dd146ea7d0401faab1
[fanfix.git] / ECMA48Terminal.java
1 /**
2 * Jexer - Java Text User Interface
3 *
4 * License: LGPLv3 or later
5 *
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.
9 *
10 * Copyright (C) 2015 Kevin Lamonte
11 *
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.
16 *
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.
21 *
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
26 * 02110-1301 USA
27 *
28 * @author Kevin Lamonte [kevin.lamonte@gmail.com]
29 * @version 1
30 */
31 package jexer.io;
32
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;
48
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.*;
59
60 /**
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.
63 */
64 public final class ECMA48Terminal implements Runnable {
65
66 /**
67 * The session information.
68 */
69 private SessionInfo sessionInfo;
70
71 /**
72 * Getter for sessionInfo.
73 *
74 * @return the SessionInfo
75 */
76 public SessionInfo getSessionInfo() {
77 return sessionInfo;
78 }
79
80 /**
81 * The event queue, filled up by a thread reading on input.
82 */
83 private List<TInputEvent> eventQueue;
84
85 /**
86 * If true, we want the reader thread to exit gracefully.
87 */
88 private boolean stopReaderThread;
89
90 /**
91 * The reader thread.
92 */
93 private Thread readerThread;
94
95 /**
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.
98 */
99 private ArrayList<String> params;
100
101 /**
102 * States in the input parser.
103 */
104 private enum ParseState {
105 GROUND,
106 ESCAPE,
107 ESCAPE_INTERMEDIATE,
108 CSI_ENTRY,
109 CSI_PARAM,
110 // CSI_INTERMEDIATE,
111 MOUSE
112 }
113
114 /**
115 * Current parsing state.
116 */
117 private ParseState state;
118
119 /**
120 * The time we entered ESCAPE. If we get a bare escape without a code
121 * following it, this is used to return that bare escape.
122 */
123 private long escapeTime;
124
125 /**
126 * The time we last checked the window size. We try not to spawn stty
127 * more than once per second.
128 */
129 private long windowSizeTime;
130
131 /**
132 * true if mouse1 was down. Used to report mouse1 on the release event.
133 */
134 private boolean mouse1;
135
136 /**
137 * true if mouse2 was down. Used to report mouse2 on the release event.
138 */
139 private boolean mouse2;
140
141 /**
142 * true if mouse3 was down. Used to report mouse3 on the release event.
143 */
144 private boolean mouse3;
145
146 /**
147 * Cache the cursor visibility value so we only emit the sequence when we
148 * need to.
149 */
150 private boolean cursorOn = true;
151
152 /**
153 * Cache the last window size to figure out if a TResizeEvent needs to be
154 * generated.
155 */
156 private TResizeEvent windowResize = null;
157
158 /**
159 * If true, then we changed System.in and need to change it back.
160 */
161 private boolean setRawMode;
162
163 /**
164 * The terminal's input. If an InputStream is not specified in the
165 * constructor, then this InputStreamReader will be bound to System.in
166 * with UTF-8 encoding.
167 */
168 private Reader input;
169
170 /**
171 * The terminal's raw InputStream. If an InputStream is not specified in
172 * the constructor, then this InputReader will be bound to System.in.
173 * This is used by run() to see if bytes are available() before calling
174 * (Reader)input.read().
175 */
176 private InputStream inputStream;
177
178 /**
179 * The terminal's output. If an OutputStream is not specified in the
180 * constructor, then this PrintWriter will be bound to System.out with
181 * UTF-8 encoding.
182 */
183 private PrintWriter output;
184
185 /**
186 * The listening object that run() wakes up on new input.
187 */
188 private Object listener;
189
190 /**
191 * When true, the terminal is sending non-UTF8 bytes when reporting mouse
192 * events.
193 *
194 * TODO: Add broken mouse detection back into the reader.
195 */
196 private boolean brokenTerminalUTFMouse = false;
197
198 /**
199 * Get the output writer.
200 *
201 * @return the Writer
202 */
203 public PrintWriter getOutput() {
204 return output;
205 }
206
207 /**
208 * Check if there are events in the queue.
209 *
210 * @return if true, getEvents() has something to return to the backend
211 */
212 public boolean hasEvents() {
213 synchronized (eventQueue) {
214 return (eventQueue.size() > 0);
215 }
216 }
217
218 /**
219 * Call 'stty' to set cooked mode.
220 *
221 * <p>Actually executes '/bin/sh -c stty sane cooked &lt; /dev/tty'
222 */
223 private void sttyCooked() {
224 doStty(false);
225 }
226
227 /**
228 * Call 'stty' to set raw mode.
229 *
230 * <p>Actually executes '/bin/sh -c stty -ignbrk -brkint -parmrk -istrip
231 * -inlcr -igncr -icrnl -ixon -opost -echo -echonl -icanon -isig -iexten
232 * -parenb cs8 min 1 &lt; /dev/tty'
233 */
234 private void sttyRaw() {
235 doStty(true);
236 }
237
238 /**
239 * Call 'stty' to set raw or cooked mode.
240 *
241 * @param mode if true, set raw mode, otherwise set cooked mode
242 */
243 private void doStty(final boolean mode) {
244 String [] cmdRaw = {
245 "/bin/sh", "-c", "stty -ignbrk -brkint -parmrk -istrip -inlcr -igncr -icrnl -ixon -opost -echo -echonl -icanon -isig -iexten -parenb cs8 min 1 < /dev/tty"
246 };
247 String [] cmdCooked = {
248 "/bin/sh", "-c", "stty sane cooked < /dev/tty"
249 };
250 try {
251 Process process;
252 if (mode) {
253 process = Runtime.getRuntime().exec(cmdRaw);
254 } else {
255 process = Runtime.getRuntime().exec(cmdCooked);
256 }
257 BufferedReader in = new BufferedReader(new InputStreamReader(process.getInputStream(), "UTF-8"));
258 String line = in.readLine();
259 if ((line != null) && (line.length() > 0)) {
260 System.err.println("WEIRD?! Normal output from stty: " + line);
261 }
262 while (true) {
263 BufferedReader err = new BufferedReader(new InputStreamReader(process.getErrorStream(), "UTF-8"));
264 line = err.readLine();
265 if ((line != null) && (line.length() > 0)) {
266 System.err.println("Error output from stty: " + line);
267 }
268 try {
269 process.waitFor();
270 break;
271 } catch (InterruptedException e) {
272 e.printStackTrace();
273 }
274 }
275 int rc = process.exitValue();
276 if (rc != 0) {
277 System.err.println("stty returned error code: " + rc);
278 }
279 } catch (IOException e) {
280 e.printStackTrace();
281 }
282 }
283
284 /**
285 * Constructor sets up state for getEvent().
286 *
287 * @param listener the object this backend needs to wake up when new
288 * input comes in
289 * @param input an InputStream connected to the remote user, or null for
290 * System.in. If System.in is used, then on non-Windows systems it will
291 * be put in raw mode; shutdown() will (blindly!) put System.in in cooked
292 * mode. input is always converted to a Reader with UTF-8 encoding.
293 * @param output an OutputStream connected to the remote user, or null
294 * for System.out. output is always converted to a Writer with UTF-8
295 * encoding.
296 * @throws UnsupportedEncodingException if an exception is thrown when
297 * creating the InputStreamReader
298 */
299 public ECMA48Terminal(final Object listener, final InputStream input,
300 final OutputStream output) throws UnsupportedEncodingException {
301
302 reset();
303 mouse1 = false;
304 mouse2 = false;
305 mouse3 = false;
306 stopReaderThread = false;
307 this.listener = listener;
308
309 if (input == null) {
310 // inputStream = System.in;
311 inputStream = new FileInputStream(FileDescriptor.in);
312 sttyRaw();
313 setRawMode = true;
314 } else {
315 inputStream = input;
316 }
317 this.input = new InputStreamReader(inputStream, "UTF-8");
318
319 // TODO: include TelnetSocket from NIB and have it implement
320 // SessionInfo
321 if (input instanceof SessionInfo) {
322 sessionInfo = (SessionInfo) input;
323 }
324 if (sessionInfo == null) {
325 if (input == null) {
326 // Reading right off the tty
327 sessionInfo = new TTYSessionInfo();
328 } else {
329 sessionInfo = new TSessionInfo();
330 }
331 }
332
333 if (output == null) {
334 this.output = new PrintWriter(new OutputStreamWriter(System.out,
335 "UTF-8"));
336 } else {
337 this.output = new PrintWriter(new OutputStreamWriter(output,
338 "UTF-8"));
339 }
340
341 // Enable mouse reporting and metaSendsEscape
342 this.output.printf("%s%s", mouse(true), xtermMetaSendsEscape(true));
343
344 // Hang onto the window size
345 windowResize = new TResizeEvent(TResizeEvent.Type.SCREEN,
346 sessionInfo.getWindowWidth(), sessionInfo.getWindowHeight());
347
348 // Spin up the input reader
349 eventQueue = new LinkedList<TInputEvent>();
350 readerThread = new Thread(this);
351 readerThread.start();
352 }
353
354 /**
355 * Restore terminal to normal state.
356 */
357 public void shutdown() {
358
359 // System.err.println("=== shutdown() ==="); System.err.flush();
360
361 // Tell the reader thread to stop looking at input
362 stopReaderThread = true;
363 try {
364 readerThread.join();
365 } catch (InterruptedException e) {
366 e.printStackTrace();
367 }
368
369 // Disable mouse reporting and show cursor
370 output.printf("%s%s%s", mouse(false), cursor(true), normal());
371 output.flush();
372
373 if (setRawMode) {
374 sttyCooked();
375 setRawMode = false;
376 // We don't close System.in/out
377 } else {
378 // Shut down the streams, this should wake up the reader thread
379 // and make it exit.
380 try {
381 if (input != null) {
382 input.close();
383 input = null;
384 }
385 if (output != null) {
386 output.close();
387 output = null;
388 }
389 } catch (IOException e) {
390 e.printStackTrace();
391 }
392 }
393 }
394
395 /**
396 * Flush output.
397 */
398 public void flush() {
399 output.flush();
400 }
401
402 /**
403 * Reset keyboard/mouse input parser.
404 */
405 private void reset() {
406 state = ParseState.GROUND;
407 params = new ArrayList<String>();
408 params.clear();
409 params.add("");
410 }
411
412 /**
413 * Produce a control character or one of the special ones (ENTER, TAB,
414 * etc.).
415 *
416 * @param ch Unicode code point
417 * @param alt if true, set alt on the TKeypress
418 * @return one TKeypress event, either a control character (e.g. isKey ==
419 * false, ch == 'A', ctrl == true), or a special key (e.g. isKey == true,
420 * fnKey == ESC)
421 */
422 private TKeypressEvent controlChar(final char ch, final boolean alt) {
423 // System.err.printf("controlChar: %02x\n", ch);
424
425 switch (ch) {
426 case 0x0D:
427 // Carriage return --> ENTER
428 return new TKeypressEvent(kbEnter, alt, false, false);
429 case 0x0A:
430 // Linefeed --> ENTER
431 return new TKeypressEvent(kbEnter, alt, false, false);
432 case 0x1B:
433 // ESC
434 return new TKeypressEvent(kbEsc, alt, false, false);
435 case '\t':
436 // TAB
437 return new TKeypressEvent(kbTab, alt, false, false);
438 default:
439 // Make all other control characters come back as the alphabetic
440 // character with the ctrl field set. So SOH would be 'A' +
441 // ctrl.
442 return new TKeypressEvent(false, 0, (char)(ch + 0x40),
443 alt, true, false);
444 }
445 }
446
447 /**
448 * Produce special key from CSI Pn ; Pm ; ... ~
449 *
450 * @return one KEYPRESS event representing a special key
451 */
452 private TInputEvent csiFnKey() {
453 int key = 0;
454 int modifier = 0;
455 if (params.size() > 0) {
456 key = Integer.parseInt(params.get(0));
457 }
458 if (params.size() > 1) {
459 modifier = Integer.parseInt(params.get(1));
460 }
461 boolean alt = false;
462 boolean ctrl = false;
463 boolean shift = false;
464
465 switch (modifier) {
466 case 0:
467 // No modifier
468 break;
469 case 2:
470 // Shift
471 shift = true;
472 break;
473 case 3:
474 // Alt
475 alt = true;
476 break;
477 case 5:
478 // Ctrl
479 ctrl = true;
480 break;
481 default:
482 // Unknown modifier, bail out
483 return null;
484 }
485
486 switch (key) {
487 case 1:
488 return new TKeypressEvent(kbHome, alt, ctrl, shift);
489 case 2:
490 return new TKeypressEvent(kbIns, alt, ctrl, shift);
491 case 3:
492 return new TKeypressEvent(kbDel, alt, ctrl, shift);
493 case 4:
494 return new TKeypressEvent(kbEnd, alt, ctrl, shift);
495 case 5:
496 return new TKeypressEvent(kbPgUp, alt, ctrl, shift);
497 case 6:
498 return new TKeypressEvent(kbPgDn, alt, ctrl, shift);
499 case 15:
500 return new TKeypressEvent(kbF5, alt, ctrl, shift);
501 case 17:
502 return new TKeypressEvent(kbF6, alt, ctrl, shift);
503 case 18:
504 return new TKeypressEvent(kbF7, alt, ctrl, shift);
505 case 19:
506 return new TKeypressEvent(kbF8, alt, ctrl, shift);
507 case 20:
508 return new TKeypressEvent(kbF9, alt, ctrl, shift);
509 case 21:
510 return new TKeypressEvent(kbF10, alt, ctrl, shift);
511 case 23:
512 return new TKeypressEvent(kbF11, alt, ctrl, shift);
513 case 24:
514 return new TKeypressEvent(kbF12, alt, ctrl, shift);
515 default:
516 // Unknown
517 return null;
518 }
519 }
520
521 /**
522 * Produce mouse events based on "Any event tracking" and UTF-8
523 * coordinates. See
524 * http://invisible-island.net/xterm/ctlseqs/ctlseqs.html#Mouse%20Tracking
525 *
526 * @return a MOUSE_MOTION, MOUSE_UP, or MOUSE_DOWN event
527 */
528 private TInputEvent parseMouse() {
529 int buttons = params.get(0).charAt(0) - 32;
530 int x = params.get(0).charAt(1) - 32 - 1;
531 int y = params.get(0).charAt(2) - 32 - 1;
532
533 // Clamp X and Y to the physical screen coordinates.
534 if (x >= windowResize.getWidth()) {
535 x = windowResize.getWidth() - 1;
536 }
537 if (y >= windowResize.getHeight()) {
538 y = windowResize.getHeight() - 1;
539 }
540
541 TMouseEvent.Type eventType = TMouseEvent.Type.MOUSE_DOWN;
542 boolean eventMouse1 = false;
543 boolean eventMouse2 = false;
544 boolean eventMouse3 = false;
545 boolean eventMouseWheelUp = false;
546 boolean eventMouseWheelDown = false;
547
548 // System.err.printf("buttons: %04x\r\n", buttons);
549
550 switch (buttons) {
551 case 0:
552 eventMouse1 = true;
553 mouse1 = true;
554 break;
555 case 1:
556 eventMouse2 = true;
557 mouse2 = true;
558 break;
559 case 2:
560 eventMouse3 = true;
561 mouse3 = true;
562 break;
563 case 3:
564 // Release or Move
565 if (!mouse1 && !mouse2 && !mouse3) {
566 eventType = TMouseEvent.Type.MOUSE_MOTION;
567 } else {
568 eventType = TMouseEvent.Type.MOUSE_UP;
569 }
570 if (mouse1) {
571 mouse1 = false;
572 eventMouse1 = true;
573 }
574 if (mouse2) {
575 mouse2 = false;
576 eventMouse2 = true;
577 }
578 if (mouse3) {
579 mouse3 = false;
580 eventMouse3 = true;
581 }
582 break;
583
584 case 32:
585 // Dragging with mouse1 down
586 eventMouse1 = true;
587 mouse1 = true;
588 eventType = TMouseEvent.Type.MOUSE_MOTION;
589 break;
590
591 case 33:
592 // Dragging with mouse2 down
593 eventMouse2 = true;
594 mouse2 = true;
595 eventType = TMouseEvent.Type.MOUSE_MOTION;
596 break;
597
598 case 34:
599 // Dragging with mouse3 down
600 eventMouse3 = true;
601 mouse3 = true;
602 eventType = TMouseEvent.Type.MOUSE_MOTION;
603 break;
604
605 case 96:
606 // Dragging with mouse2 down after wheelUp
607 eventMouse2 = true;
608 mouse2 = true;
609 eventType = TMouseEvent.Type.MOUSE_MOTION;
610 break;
611
612 case 97:
613 // Dragging with mouse2 down after wheelDown
614 eventMouse2 = true;
615 mouse2 = true;
616 eventType = TMouseEvent.Type.MOUSE_MOTION;
617 break;
618
619 case 64:
620 eventMouseWheelUp = true;
621 break;
622
623 case 65:
624 eventMouseWheelDown = true;
625 break;
626
627 default:
628 // Unknown, just make it motion
629 eventType = TMouseEvent.Type.MOUSE_MOTION;
630 break;
631 }
632 return new TMouseEvent(eventType, x, y, x, y,
633 eventMouse1, eventMouse2, eventMouse3,
634 eventMouseWheelUp, eventMouseWheelDown);
635 }
636
637 /**
638 * Return any events in the IO queue.
639 *
640 * @param queue list to append new events to
641 */
642 public void getEvents(final List<TInputEvent> queue) {
643 synchronized (eventQueue) {
644 if (eventQueue.size() > 0) {
645 synchronized (queue) {
646 queue.addAll(eventQueue);
647 }
648 eventQueue.clear();
649 }
650 }
651 }
652
653 /**
654 * Return any events in the IO queue due to timeout.
655 *
656 * @param queue list to append new events to
657 */
658 private void getIdleEvents(final List<TInputEvent> queue) {
659 Date now = new Date();
660
661 // Check for new window size
662 long windowSizeDelay = now.getTime() - windowSizeTime;
663 if (windowSizeDelay > 1000) {
664 sessionInfo.queryWindowSize();
665 int newWidth = sessionInfo.getWindowWidth();
666 int newHeight = sessionInfo.getWindowHeight();
667 if ((newWidth != windowResize.getWidth())
668 || (newHeight != windowResize.getHeight())
669 ) {
670 TResizeEvent event = new TResizeEvent(TResizeEvent.Type.SCREEN,
671 newWidth, newHeight);
672 windowResize = new TResizeEvent(TResizeEvent.Type.SCREEN,
673 newWidth, newHeight);
674 queue.add(event);
675 }
676 windowSizeTime = now.getTime();
677 }
678
679 // ESCDELAY type timeout
680 if (state == ParseState.ESCAPE) {
681 long escDelay = now.getTime() - escapeTime;
682 if (escDelay > 100) {
683 // After 0.1 seconds, assume a true escape character
684 queue.add(controlChar((char)0x1B, false));
685 reset();
686 }
687 }
688 }
689
690 /**
691 * Parses the next character of input to see if an InputEvent is
692 * fully here.
693 *
694 * @param events list to append new events to
695 * @param ch Unicode code point
696 */
697 private void processChar(final List<TInputEvent> events, final char ch) {
698
699 // ESCDELAY type timeout
700 Date now = new Date();
701 if (state == ParseState.ESCAPE) {
702 long escDelay = now.getTime() - escapeTime;
703 if (escDelay > 250) {
704 // After 0.25 seconds, assume a true escape character
705 events.add(controlChar((char)0x1B, false));
706 reset();
707 }
708 }
709
710 // TKeypress fields
711 boolean ctrl = false;
712 boolean alt = false;
713 boolean shift = false;
714 char keyCh = ch;
715 TKeypress key;
716
717 // System.err.printf("state: %s ch %c\r\n", state, ch);
718
719 switch (state) {
720 case GROUND:
721
722 if (ch == 0x1B) {
723 state = ParseState.ESCAPE;
724 escapeTime = now.getTime();
725 return;
726 }
727
728 if (ch <= 0x1F) {
729 // Control character
730 events.add(controlChar(ch, false));
731 reset();
732 return;
733 }
734
735 if (ch >= 0x20) {
736 // Normal character
737 events.add(new TKeypressEvent(false, 0, ch,
738 false, false, false));
739 reset();
740 return;
741 }
742
743 break;
744
745 case ESCAPE:
746 if (ch <= 0x1F) {
747 // ALT-Control character
748 events.add(controlChar(ch, true));
749 reset();
750 return;
751 }
752
753 if (ch == 'O') {
754 // This will be one of the function keys
755 state = ParseState.ESCAPE_INTERMEDIATE;
756 return;
757 }
758
759 // '[' goes to CSI_ENTRY
760 if (ch == '[') {
761 state = ParseState.CSI_ENTRY;
762 return;
763 }
764
765 // Everything else is assumed to be Alt-keystroke
766 if ((ch >= 'A') && (ch <= 'Z')) {
767 shift = true;
768 }
769 alt = true;
770 events.add(new TKeypressEvent(false, 0, ch, alt, ctrl, shift));
771 reset();
772 return;
773
774 case ESCAPE_INTERMEDIATE:
775 if ((ch >= 'P') && (ch <= 'S')) {
776 // Function key
777 switch (ch) {
778 case 'P':
779 events.add(new TKeypressEvent(kbF1));
780 break;
781 case 'Q':
782 events.add(new TKeypressEvent(kbF2));
783 break;
784 case 'R':
785 events.add(new TKeypressEvent(kbF3));
786 break;
787 case 'S':
788 events.add(new TKeypressEvent(kbF4));
789 break;
790 default:
791 break;
792 }
793 reset();
794 return;
795 }
796
797 // Unknown keystroke, ignore
798 reset();
799 return;
800
801 case CSI_ENTRY:
802 // Numbers - parameter values
803 if ((ch >= '0') && (ch <= '9')) {
804 params.set(params.size() - 1,
805 params.get(params.size() - 1) + ch);
806 state = ParseState.CSI_PARAM;
807 return;
808 }
809 // Parameter separator
810 if (ch == ';') {
811 params.add("");
812 return;
813 }
814
815 if ((ch >= 0x30) && (ch <= 0x7E)) {
816 switch (ch) {
817 case 'A':
818 // Up
819 if (params.size() > 1) {
820 if (params.get(1).equals("2")) {
821 shift = true;
822 }
823 if (params.get(1).equals("5")) {
824 ctrl = true;
825 }
826 if (params.get(1).equals("3")) {
827 alt = true;
828 }
829 }
830 events.add(new TKeypressEvent(kbUp, alt, ctrl, shift));
831 reset();
832 return;
833 case 'B':
834 // Down
835 if (params.size() > 1) {
836 if (params.get(1).equals("2")) {
837 shift = true;
838 }
839 if (params.get(1).equals("5")) {
840 ctrl = true;
841 }
842 if (params.get(1).equals("3")) {
843 alt = true;
844 }
845 }
846 events.add(new TKeypressEvent(kbDown, alt, ctrl, shift));
847 reset();
848 return;
849 case 'C':
850 // Right
851 if (params.size() > 1) {
852 if (params.get(1).equals("2")) {
853 shift = true;
854 }
855 if (params.get(1).equals("5")) {
856 ctrl = true;
857 }
858 if (params.get(1).equals("3")) {
859 alt = true;
860 }
861 }
862 events.add(new TKeypressEvent(kbRight, alt, ctrl, shift));
863 reset();
864 return;
865 case 'D':
866 // Left
867 if (params.size() > 1) {
868 if (params.get(1).equals("2")) {
869 shift = true;
870 }
871 if (params.get(1).equals("5")) {
872 ctrl = true;
873 }
874 if (params.get(1).equals("3")) {
875 alt = true;
876 }
877 }
878 events.add(new TKeypressEvent(kbLeft, alt, ctrl, shift));
879 reset();
880 return;
881 case 'H':
882 // Home
883 events.add(new TKeypressEvent(kbHome));
884 reset();
885 return;
886 case 'F':
887 // End
888 events.add(new TKeypressEvent(kbEnd));
889 reset();
890 return;
891 case 'Z':
892 // CBT - Cursor backward X tab stops (default 1)
893 events.add(new TKeypressEvent(kbBackTab));
894 reset();
895 return;
896 case 'M':
897 // Mouse position
898 state = ParseState.MOUSE;
899 return;
900 default:
901 break;
902 }
903 }
904
905 // Unknown keystroke, ignore
906 reset();
907 return;
908
909 case CSI_PARAM:
910 // Numbers - parameter values
911 if ((ch >= '0') && (ch <= '9')) {
912 params.set(params.size() - 1,
913 params.get(params.size() - 1) + ch);
914 state = ParseState.CSI_PARAM;
915 return;
916 }
917 // Parameter separator
918 if (ch == ';') {
919 params.add("");
920 return;
921 }
922
923 if (ch == '~') {
924 events.add(csiFnKey());
925 reset();
926 return;
927 }
928
929 if ((ch >= 0x30) && (ch <= 0x7E)) {
930 switch (ch) {
931 case 'A':
932 // Up
933 if (params.size() > 1) {
934 if (params.get(1).equals("2")) {
935 shift = true;
936 }
937 if (params.get(1).equals("5")) {
938 ctrl = true;
939 }
940 if (params.get(1).equals("3")) {
941 alt = true;
942 }
943 }
944 events.add(new TKeypressEvent(kbUp, alt, ctrl, shift));
945 reset();
946 return;
947 case 'B':
948 // Down
949 if (params.size() > 1) {
950 if (params.get(1).equals("2")) {
951 shift = true;
952 }
953 if (params.get(1).equals("5")) {
954 ctrl = true;
955 }
956 if (params.get(1).equals("3")) {
957 alt = true;
958 }
959 }
960 events.add(new TKeypressEvent(kbDown, alt, ctrl, shift));
961 reset();
962 return;
963 case 'C':
964 // Right
965 if (params.size() > 1) {
966 if (params.get(1).equals("2")) {
967 shift = true;
968 }
969 if (params.get(1).equals("5")) {
970 ctrl = true;
971 }
972 if (params.get(1).equals("3")) {
973 alt = true;
974 }
975 }
976 events.add(new TKeypressEvent(kbRight, alt, ctrl, shift));
977 reset();
978 return;
979 case 'D':
980 // Left
981 if (params.size() > 1) {
982 if (params.get(1).equals("2")) {
983 shift = true;
984 }
985 if (params.get(1).equals("5")) {
986 ctrl = true;
987 }
988 if (params.get(1).equals("3")) {
989 alt = true;
990 }
991 }
992 events.add(new TKeypressEvent(kbLeft, alt, ctrl, shift));
993 reset();
994 return;
995 default:
996 break;
997 }
998 }
999
1000 // Unknown keystroke, ignore
1001 reset();
1002 return;
1003
1004 case MOUSE:
1005 params.set(0, params.get(params.size() - 1) + ch);
1006 if (params.get(0).length() == 3) {
1007 // We have enough to generate a mouse event
1008 events.add(parseMouse());
1009 reset();
1010 }
1011 return;
1012
1013 default:
1014 break;
1015 }
1016
1017 // This "should" be impossible to reach
1018 return;
1019 }
1020
1021 /**
1022 * Tell (u)xterm that we want alt- keystrokes to send escape + character
1023 * rather than set the 8th bit. Anyone who wants UTF8 should want this
1024 * enabled.
1025 *
1026 * @param on if true, enable metaSendsEscape
1027 * @return the string to emit to xterm
1028 */
1029 public String xtermMetaSendsEscape(final boolean on) {
1030 if (on) {
1031 return "\033[?1036h\033[?1034l";
1032 }
1033 return "\033[?1036l";
1034 }
1035
1036 /**
1037 * Convert a list of SGR parameters into a full escape sequence. This
1038 * also eliminates a trailing ';' which would otherwise reset everything
1039 * to white-on-black not-bold.
1040 *
1041 * @param str string of parameters, e.g. "31;1;"
1042 * @return the string to emit to an ANSI / ECMA-style terminal,
1043 * e.g. "\033[31;1m"
1044 */
1045 public String addHeaderSGR(String str) {
1046 if (str.length() > 0) {
1047 // Nix any trailing ';' because that resets all attributes
1048 while (str.endsWith(":")) {
1049 str = str.substring(0, str.length() - 1);
1050 }
1051 }
1052 return "\033[" + str + "m";
1053 }
1054
1055 /**
1056 * Create a SGR parameter sequence for a single color change.
1057 *
1058 * @param color one of the Color.WHITE, Color.BLUE, etc. constants
1059 * @param foreground if true, this is a foreground color
1060 * @return the string to emit to an ANSI / ECMA-style terminal,
1061 * e.g. "\033[42m"
1062 */
1063 public String color(final Color color, final boolean foreground) {
1064 return color(color, foreground, true);
1065 }
1066
1067 /**
1068 * Create a SGR parameter sequence for a single color change.
1069 *
1070 * @param color one of the Color.WHITE, Color.BLUE, etc. constants
1071 * @param foreground if true, this is a foreground color
1072 * @param header if true, make the full header, otherwise just emit the
1073 * color parameter e.g. "42;"
1074 * @return the string to emit to an ANSI / ECMA-style terminal,
1075 * e.g. "\033[42m"
1076 */
1077 public String color(final Color color, final boolean foreground,
1078 final boolean header) {
1079
1080 int ecmaColor = color.getValue();
1081
1082 // Convert Color.* values to SGR numerics
1083 if (foreground) {
1084 ecmaColor += 30;
1085 } else {
1086 ecmaColor += 40;
1087 }
1088
1089 if (header) {
1090 return String.format("\033[%dm", ecmaColor);
1091 } else {
1092 return String.format("%d;", ecmaColor);
1093 }
1094 }
1095
1096 /**
1097 * Create a SGR parameter sequence for both foreground and
1098 * background color change.
1099 *
1100 * @param foreColor one of the Color.WHITE, Color.BLUE, etc. constants
1101 * @param backColor one of the Color.WHITE, Color.BLUE, etc. constants
1102 * @return the string to emit to an ANSI / ECMA-style terminal,
1103 * e.g. "\033[31;42m"
1104 */
1105 public String color(final Color foreColor, final Color backColor) {
1106 return color(foreColor, backColor, true);
1107 }
1108
1109 /**
1110 * Create a SGR parameter sequence for both foreground and
1111 * background color change.
1112 *
1113 * @param foreColor one of the Color.WHITE, Color.BLUE, etc. constants
1114 * @param backColor one of the Color.WHITE, Color.BLUE, etc. constants
1115 * @param header if true, make the full header, otherwise just emit the
1116 * color parameter e.g. "31;42;"
1117 * @return the string to emit to an ANSI / ECMA-style terminal,
1118 * e.g. "\033[31;42m"
1119 */
1120 public String color(final Color foreColor, final Color backColor,
1121 final boolean header) {
1122
1123 int ecmaForeColor = foreColor.getValue();
1124 int ecmaBackColor = backColor.getValue();
1125
1126 // Convert Color.* values to SGR numerics
1127 ecmaBackColor += 40;
1128 ecmaForeColor += 30;
1129
1130 if (header) {
1131 return String.format("\033[%d;%dm", ecmaForeColor, ecmaBackColor);
1132 } else {
1133 return String.format("%d;%d;", ecmaForeColor, ecmaBackColor);
1134 }
1135 }
1136
1137 /**
1138 * Create a SGR parameter sequence for foreground, background, and
1139 * several attributes. This sequence first resets all attributes to
1140 * default, then sets attributes as per the parameters.
1141 *
1142 * @param foreColor one of the Color.WHITE, Color.BLUE, etc. constants
1143 * @param backColor one of the Color.WHITE, Color.BLUE, etc. constants
1144 * @param bold if true, set bold
1145 * @param reverse if true, set reverse
1146 * @param blink if true, set blink
1147 * @param underline if true, set underline
1148 * @return the string to emit to an ANSI / ECMA-style terminal,
1149 * e.g. "\033[0;1;31;42m"
1150 */
1151 public String color(final Color foreColor, final Color backColor,
1152 final boolean bold, final boolean reverse, final boolean blink,
1153 final boolean underline) {
1154
1155 int ecmaForeColor = foreColor.getValue();
1156 int ecmaBackColor = backColor.getValue();
1157
1158 // Convert Color.* values to SGR numerics
1159 ecmaBackColor += 40;
1160 ecmaForeColor += 30;
1161
1162 StringBuilder sb = new StringBuilder();
1163 if ( bold && reverse && blink && !underline ) {
1164 sb.append("\033[0;1;7;5;");
1165 } else if ( bold && reverse && !blink && !underline ) {
1166 sb.append("\033[0;1;7;");
1167 } else if ( !bold && reverse && blink && !underline ) {
1168 sb.append("\033[0;7;5;");
1169 } else if ( bold && !reverse && blink && !underline ) {
1170 sb.append("\033[0;1;5;");
1171 } else if ( bold && !reverse && !blink && !underline ) {
1172 sb.append("\033[0;1;");
1173 } else if ( !bold && reverse && !blink && !underline ) {
1174 sb.append("\033[0;7;");
1175 } else if ( !bold && !reverse && blink && !underline) {
1176 sb.append("\033[0;5;");
1177 } else if ( bold && reverse && blink && underline ) {
1178 sb.append("\033[0;1;7;5;4;");
1179 } else if ( bold && reverse && !blink && underline ) {
1180 sb.append("\033[0;1;7;4;");
1181 } else if ( !bold && reverse && blink && underline ) {
1182 sb.append("\033[0;7;5;4;");
1183 } else if ( bold && !reverse && blink && underline ) {
1184 sb.append("\033[0;1;5;4;");
1185 } else if ( bold && !reverse && !blink && underline ) {
1186 sb.append("\033[0;1;4;");
1187 } else if ( !bold && reverse && !blink && underline ) {
1188 sb.append("\033[0;7;4;");
1189 } else if ( !bold && !reverse && blink && underline) {
1190 sb.append("\033[0;5;4;");
1191 } else if ( !bold && !reverse && !blink && underline) {
1192 sb.append("\033[0;4;");
1193 } else {
1194 assert (!bold && !reverse && !blink && !underline);
1195 sb.append("\033[0;");
1196 }
1197 sb.append(String.format("%d;%dm", ecmaForeColor, ecmaBackColor));
1198 return sb.toString();
1199 }
1200
1201 /**
1202 * Create a SGR parameter sequence for enabling reverse color.
1203 *
1204 * @param on if true, turn on reverse
1205 * @return the string to emit to an ANSI / ECMA-style terminal,
1206 * e.g. "\033[7m"
1207 */
1208 public String reverse(final boolean on) {
1209 if (on) {
1210 return "\033[7m";
1211 }
1212 return "\033[27m";
1213 }
1214
1215 /**
1216 * Create a SGR parameter sequence to reset to defaults.
1217 *
1218 * @return the string to emit to an ANSI / ECMA-style terminal,
1219 * e.g. "\033[0m"
1220 */
1221 public String normal() {
1222 return normal(true);
1223 }
1224
1225 /**
1226 * Create a SGR parameter sequence to reset to defaults.
1227 *
1228 * @param header if true, make the full header, otherwise just emit the
1229 * bare parameter e.g. "0;"
1230 * @return the string to emit to an ANSI / ECMA-style terminal,
1231 * e.g. "\033[0m"
1232 */
1233 public String normal(final boolean header) {
1234 if (header) {
1235 return "\033[0;37;40m";
1236 }
1237 return "0;37;40";
1238 }
1239
1240 /**
1241 * Create a SGR parameter sequence for enabling boldface.
1242 *
1243 * @param on if true, turn on bold
1244 * @return the string to emit to an ANSI / ECMA-style terminal,
1245 * e.g. "\033[1m"
1246 */
1247 public String bold(final boolean on) {
1248 return bold(on, true);
1249 }
1250
1251 /**
1252 * Create a SGR parameter sequence for enabling boldface.
1253 *
1254 * @param on if true, turn on bold
1255 * @param header if true, make the full header, otherwise just emit the
1256 * bare parameter e.g. "1;"
1257 * @return the string to emit to an ANSI / ECMA-style terminal,
1258 * e.g. "\033[1m"
1259 */
1260 public String bold(final boolean on, final boolean header) {
1261 if (header) {
1262 if (on) {
1263 return "\033[1m";
1264 }
1265 return "\033[22m";
1266 }
1267 if (on) {
1268 return "1;";
1269 }
1270 return "22;";
1271 }
1272
1273 /**
1274 * Create a SGR parameter sequence for enabling blinking text.
1275 *
1276 * @param on if true, turn on blink
1277 * @return the string to emit to an ANSI / ECMA-style terminal,
1278 * e.g. "\033[5m"
1279 */
1280 public String blink(final boolean on) {
1281 return blink(on, true);
1282 }
1283
1284 /**
1285 * Create a SGR parameter sequence for enabling blinking text.
1286 *
1287 * @param on if true, turn on blink
1288 * @param header if true, make the full header, otherwise just emit the
1289 * bare parameter e.g. "5;"
1290 * @return the string to emit to an ANSI / ECMA-style terminal,
1291 * e.g. "\033[5m"
1292 */
1293 public String blink(final boolean on, final boolean header) {
1294 if (header) {
1295 if (on) {
1296 return "\033[5m";
1297 }
1298 return "\033[25m";
1299 }
1300 if (on) {
1301 return "5;";
1302 }
1303 return "25;";
1304 }
1305
1306 /**
1307 * Create a SGR parameter sequence for enabling underline / underscored
1308 * text.
1309 *
1310 * @param on if true, turn on underline
1311 * @return the string to emit to an ANSI / ECMA-style terminal,
1312 * e.g. "\033[4m"
1313 */
1314 public String underline(final boolean on) {
1315 if (on) {
1316 return "\033[4m";
1317 }
1318 return "\033[24m";
1319 }
1320
1321 /**
1322 * Create a SGR parameter sequence for enabling the visible cursor.
1323 *
1324 * @param on if true, turn on cursor
1325 * @return the string to emit to an ANSI / ECMA-style terminal
1326 */
1327 public String cursor(final boolean on) {
1328 if (on && !cursorOn) {
1329 cursorOn = true;
1330 return "\033[?25h";
1331 }
1332 if (!on && cursorOn) {
1333 cursorOn = false;
1334 return "\033[?25l";
1335 }
1336 return "";
1337 }
1338
1339 /**
1340 * Clear the entire screen. Because some terminals use back-color-erase,
1341 * set the color to white-on-black beforehand.
1342 *
1343 * @return the string to emit to an ANSI / ECMA-style terminal
1344 */
1345 public String clearAll() {
1346 return "\033[0;37;40m\033[2J";
1347 }
1348
1349 /**
1350 * Clear the line from the cursor (inclusive) to the end of the screen.
1351 * Because some terminals use back-color-erase, set the color to
1352 * white-on-black beforehand.
1353 *
1354 * @return the string to emit to an ANSI / ECMA-style terminal
1355 */
1356 public String clearRemainingLine() {
1357 return "\033[0;37;40m\033[K";
1358 }
1359
1360 /**
1361 * Clear the line up the cursor (inclusive). Because some terminals use
1362 * back-color-erase, set the color to white-on-black beforehand.
1363 *
1364 * @return the string to emit to an ANSI / ECMA-style terminal
1365 */
1366 public String clearPreceedingLine() {
1367 return "\033[0;37;40m\033[1K";
1368 }
1369
1370 /**
1371 * Clear the line. Because some terminals use back-color-erase, set the
1372 * color to white-on-black beforehand.
1373 *
1374 * @return the string to emit to an ANSI / ECMA-style terminal
1375 */
1376 public String clearLine() {
1377 return "\033[0;37;40m\033[2K";
1378 }
1379
1380 /**
1381 * Move the cursor to the top-left corner.
1382 *
1383 * @return the string to emit to an ANSI / ECMA-style terminal
1384 */
1385 public String home() {
1386 return "\033[H";
1387 }
1388
1389 /**
1390 * Move the cursor to (x, y).
1391 *
1392 * @param x column coordinate. 0 is the left-most column.
1393 * @param y row coordinate. 0 is the top-most row.
1394 * @return the string to emit to an ANSI / ECMA-style terminal
1395 */
1396 public String gotoXY(final int x, final int y) {
1397 return String.format("\033[%d;%dH", y + 1, x + 1);
1398 }
1399
1400 /**
1401 * Tell (u)xterm that we want to receive mouse events based on "Any event
1402 * tracking" and UTF-8 coordinates. See
1403 * http://invisible-island.net/xterm/ctlseqs/ctlseqs.html#Mouse%20Tracking
1404 *
1405 * Note that this also sets the alternate/primary screen buffer.
1406 *
1407 * @param on If true, enable mouse report and use the alternate screen
1408 * buffer. If false disable mouse reporting and use the primary screen
1409 * buffer.
1410 * @return the string to emit to xterm
1411 */
1412 public String mouse(final boolean on) {
1413 if (on) {
1414 return "\033[?1003;1005h\033[?1049h";
1415 }
1416 return "\033[?1003;1005l\033[?1049l";
1417 }
1418
1419 /**
1420 * Read function runs on a separate thread.
1421 */
1422 public void run() {
1423 boolean done = false;
1424 // available() will often return > 1, so we need to read in chunks to
1425 // stay caught up.
1426 char [] readBuffer = new char[128];
1427 List<TInputEvent> events = new LinkedList<TInputEvent>();
1428
1429 while (!done && !stopReaderThread) {
1430 try {
1431 // We assume that if inputStream has bytes available, then
1432 // input won't block on read().
1433 int n = inputStream.available();
1434 if (n > 0) {
1435 if (readBuffer.length < n) {
1436 // The buffer wasn't big enough, make it huger
1437 readBuffer = new char[readBuffer.length * 2];
1438 }
1439
1440 int rc = input.read(readBuffer, 0, n);
1441 // System.err.printf("read() %d", rc); System.err.flush();
1442 if (rc == -1) {
1443 // This is EOF
1444 done = true;
1445 } else {
1446 for (int i = 0; i < rc; i++) {
1447 int ch = readBuffer[i];
1448 processChar(events, (char)ch);
1449 if (events.size() > 0) {
1450 // Add to the queue for the backend thread to
1451 // be able to obtain.
1452 synchronized (eventQueue) {
1453 eventQueue.addAll(events);
1454 }
1455 synchronized (listener) {
1456 listener.notifyAll();
1457 }
1458 events.clear();
1459 }
1460 }
1461 }
1462 } else {
1463 getIdleEvents(events);
1464 if (events.size() > 0) {
1465 synchronized (eventQueue) {
1466 eventQueue.addAll(events);
1467 }
1468 events.clear();
1469 synchronized (listener) {
1470 listener.notifyAll();
1471 }
1472 }
1473
1474 // Wait 10 millis for more data
1475 Thread.sleep(10);
1476 }
1477 // System.err.println("end while loop"); System.err.flush();
1478 } catch (InterruptedException e) {
1479 // SQUASH
1480 } catch (IOException e) {
1481 e.printStackTrace();
1482 done = true;
1483 }
1484 } // while ((done == false) && (stopReaderThread == false))
1485 // System.err.println("*** run() exiting..."); System.err.flush();
1486 }
1487
1488 }