src/jexer/io/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
 715         // System.err.printf("state: %s ch %c\r\n", state, ch);
 716
 717         switch (state) {
 718         case GROUND:
 719
 720             if (ch == 0x1B) {
 721                 state = ParseState.ESCAPE;
 722                 escapeTime = now.getTime();
 723                 return;
 724             }
 725
 726             if (ch <= 0x1F) {
 727                 // Control character
 728                 events.add(controlChar(ch, false));
 729                 reset();
 730                 return;
 731             }
 732
 733             if (ch >= 0x20) {
 734                 // Normal character
 735                 events.add(new TKeypressEvent(false, 0, ch,
 736                         false, false, false));
 737                 reset();
 738                 return;
 739             }
 740
 741             break;
 742
 743         case ESCAPE:
 744             if (ch <= 0x1F) {
 745                 // ALT-Control character
 746                 events.add(controlChar(ch, true));
 747                 reset();
 748                 return;
 749             }
 750
 751             if (ch == 'O') {
 752                 // This will be one of the function keys
 753                 state = ParseState.ESCAPE_INTERMEDIATE;
 754                 return;
 755             }
 756
 757             // '[' goes to CSI_ENTRY
 758             if (ch == '[') {
 759                 state = ParseState.CSI_ENTRY;
 760                 return;
 761             }
 762
 763             // Everything else is assumed to be Alt-keystroke
 764             if ((ch >= 'A') && (ch <= 'Z')) {
 765                 shift = true;
 766             }
 767             alt = true;
 768             events.add(new TKeypressEvent(false, 0, ch, alt, ctrl, shift));
 769             reset();
 770             return;
 771
 772         case ESCAPE_INTERMEDIATE:
 773             if ((ch >= 'P') && (ch <= 'S')) {
 774                 // Function key
 775                 switch (ch) {
 776                 case 'P':
 777                     events.add(new TKeypressEvent(kbF1));
 778                     break;
 779                 case 'Q':
 780                     events.add(new TKeypressEvent(kbF2));
 781                     break;
 782                 case 'R':
 783                     events.add(new TKeypressEvent(kbF3));
 784                     break;
 785                 case 'S':
 786                     events.add(new TKeypressEvent(kbF4));
 787                     break;
 788                 default:
 789                     break;
 790                 }
 791                 reset();
 792                 return;
 793             }
 794
 795             // Unknown keystroke, ignore
 796             reset();
 797             return;
 798
 799         case CSI_ENTRY:
 800             // Numbers - parameter values
 801             if ((ch >= '0') && (ch <= '9')) {
 802                 params.set(params.size() - 1,
 803                     params.get(params.size() - 1) + ch);
 804                 state = ParseState.CSI_PARAM;
 805                 return;
 806             }
 807             // Parameter separator
 808             if (ch == ';') {
 809                 params.add("");
 810                 return;
 811             }
 812
 813             if ((ch >= 0x30) && (ch <= 0x7E)) {
 814                 switch (ch) {
 815                 case 'A':
 816                     // Up
 817                     if (params.size() > 1) {
 818                         if (params.get(1).equals("2")) {
 819                             shift = true;
 820                         }
 821                         if (params.get(1).equals("5")) {
 822                             ctrl = true;
 823                         }
 824                         if (params.get(1).equals("3")) {
 825                             alt = true;
 826                         }
 827                     }
 828                     events.add(new TKeypressEvent(kbUp, alt, ctrl, shift));
 829                     reset();
 830                     return;
 831                 case 'B':
 832                     // Down
 833                     if (params.size() > 1) {
 834                         if (params.get(1).equals("2")) {
 835                             shift = true;
 836                         }
 837                         if (params.get(1).equals("5")) {
 838                             ctrl = true;
 839                         }
 840                         if (params.get(1).equals("3")) {
 841                             alt = true;
 842                         }
 843                     }
 844                     events.add(new TKeypressEvent(kbDown, alt, ctrl, shift));
 845                     reset();
 846                     return;
 847                 case 'C':
 848                     // Right
 849                     if (params.size() > 1) {
 850                         if (params.get(1).equals("2")) {
 851                             shift = true;
 852                         }
 853                         if (params.get(1).equals("5")) {
 854                             ctrl = true;
 855                         }
 856                         if (params.get(1).equals("3")) {
 857                             alt = true;
 858                         }
 859                     }
 860                     events.add(new TKeypressEvent(kbRight, alt, ctrl, shift));
 861                     reset();
 862                     return;
 863                 case 'D':
 864                     // Left
 865                     if (params.size() > 1) {
 866                         if (params.get(1).equals("2")) {
 867                             shift = true;
 868                         }
 869                         if (params.get(1).equals("5")) {
 870                             ctrl = true;
 871                         }
 872                         if (params.get(1).equals("3")) {
 873                             alt = true;
 874                         }
 875                     }
 876                     events.add(new TKeypressEvent(kbLeft, alt, ctrl, shift));
 877                     reset();
 878                     return;
 879                 case 'H':
 880                     // Home
 881                     events.add(new TKeypressEvent(kbHome));
 882                     reset();
 883                     return;
 884                 case 'F':
 885                     // End
 886                     events.add(new TKeypressEvent(kbEnd));
 887                     reset();
 888                     return;
 889                 case 'Z':
 890                     // CBT - Cursor backward X tab stops (default 1)
 891                     events.add(new TKeypressEvent(kbBackTab));
 892                     reset();
 893                     return;
 894                 case 'M':
 895                     // Mouse position
 896                     state = ParseState.MOUSE;
 897                     return;
 898                 default:
 899                     break;
 900                 }
 901             }
 902
 903             // Unknown keystroke, ignore
 904             reset();
 905             return;
 906
 907         case CSI_PARAM:
 908             // Numbers - parameter values
 909             if ((ch >= '0') && (ch <= '9')) {
 910                 params.set(params.size() - 1,
 911                     params.get(params.size() - 1) + ch);
 912                 state = ParseState.CSI_PARAM;
 913                 return;
 914             }
 915             // Parameter separator
 916             if (ch == ';') {
 917                 params.add("");
 918                 return;
 919             }
 920
 921             if (ch == '~') {
 922                 events.add(csiFnKey());
 923                 reset();
 924                 return;
 925             }
 926
 927             if ((ch >= 0x30) && (ch <= 0x7E)) {
 928                 switch (ch) {
 929                 case 'A':
 930                     // Up
 931                     if (params.size() > 1) {
 932                         if (params.get(1).equals("2")) {
 933                             shift = true;
 934                         }
 935                         if (params.get(1).equals("5")) {
 936                             ctrl = true;
 937                         }
 938                         if (params.get(1).equals("3")) {
 939                             alt = true;
 940                         }
 941                     }
 942                     events.add(new TKeypressEvent(kbUp, alt, ctrl, shift));
 943                     reset();
 944                     return;
 945                 case 'B':
 946                     // Down
 947                     if (params.size() > 1) {
 948                         if (params.get(1).equals("2")) {
 949                             shift = true;
 950                         }
 951                         if (params.get(1).equals("5")) {
 952                             ctrl = true;
 953                         }
 954                         if (params.get(1).equals("3")) {
 955                             alt = true;
 956                         }
 957                     }
 958                     events.add(new TKeypressEvent(kbDown, alt, ctrl, shift));
 959                     reset();
 960                     return;
 961                 case 'C':
 962                     // Right
 963                     if (params.size() > 1) {
 964                         if (params.get(1).equals("2")) {
 965                             shift = true;
 966                         }
 967                         if (params.get(1).equals("5")) {
 968                             ctrl = true;
 969                         }
 970                         if (params.get(1).equals("3")) {
 971                             alt = true;
 972                         }
 973                     }
 974                     events.add(new TKeypressEvent(kbRight, alt, ctrl, shift));
 975                     reset();
 976                     return;
 977                 case 'D':
 978                     // Left
 979                     if (params.size() > 1) {
 980                         if (params.get(1).equals("2")) {
 981                             shift = true;
 982                         }
 983                         if (params.get(1).equals("5")) {
 984                             ctrl = true;
 985                         }
 986                         if (params.get(1).equals("3")) {
 987                             alt = true;
 988                         }
 989                     }
 990                     events.add(new TKeypressEvent(kbLeft, alt, ctrl, shift));
 991                     reset();
 992                     return;
 993                 default:
 994                     break;
 995                 }
 996             }
 997
 998             // Unknown keystroke, ignore
 999             reset();
1000             return;
1001
1002         case MOUSE:
1003             params.set(0, params.get(params.size() - 1) + ch);
1004             if (params.get(0).length() == 3) {
1005                 // We have enough to generate a mouse event
1006                 events.add(parseMouse());
1007                 reset();
1008             }
1009             return;
1010
1011         default:
1012             break;
1013         }
1014
1015         // This "should" be impossible to reach
1016         return;
1017     }
1018
1019     /**
1020      * Tell (u)xterm that we want alt- keystrokes to send escape + character
1021      * rather than set the 8th bit.  Anyone who wants UTF8 should want this
1022      * enabled.
1023      *
1024      * @param on if true, enable metaSendsEscape
1025      * @return the string to emit to xterm
1026      */
1027     public String xtermMetaSendsEscape(final boolean on) {
1028         if (on) {
1029             return "\033[?1036h\033[?1034l";
1030         }
1031         return "\033[?1036l";
1032     }
1033
1034     /**
1035      * Convert a list of SGR parameters into a full escape sequence.  This
1036      * also eliminates a trailing ';' which would otherwise reset everything
1037      * to white-on-black not-bold.
1038      *
1039      * @param str string of parameters, e.g. "31;1;"
1040      * @return the string to emit to an ANSI / ECMA-style terminal,
1041      * e.g. "\033[31;1m"
1042      */
1043     public String addHeaderSGR(String str) {
1044         if (str.length() > 0) {
1045             // Nix any trailing ';' because that resets all attributes
1046             while (str.endsWith(":")) {
1047                 str = str.substring(0, str.length() - 1);
1048             }
1049         }
1050         return "\033[" + str + "m";
1051     }
1052
1053     /**
1054      * Create a SGR parameter sequence for a single color change.
1055      *
1056      * @param color one of the Color.WHITE, Color.BLUE, etc. constants
1057      * @param foreground if true, this is a foreground color
1058      * @return the string to emit to an ANSI / ECMA-style terminal,
1059      * e.g. "\033[42m"
1060      */
1061     public String color(final Color color, final boolean foreground) {
1062         return color(color, foreground, true);
1063     }
1064
1065     /**
1066      * Create a SGR parameter sequence for a single color change.
1067      *
1068      * @param color one of the Color.WHITE, Color.BLUE, etc. constants
1069      * @param foreground if true, this is a foreground color
1070      * @param header if true, make the full header, otherwise just emit the
1071      * color parameter e.g. "42;"
1072      * @return the string to emit to an ANSI / ECMA-style terminal,
1073      * e.g. "\033[42m"
1074      */
1075     public String color(final Color color, final boolean foreground,
1076         final boolean header) {
1077
1078         int ecmaColor = color.getValue();
1079
1080         // Convert Color.* values to SGR numerics
1081         if (foreground) {
1082             ecmaColor += 30;
1083         } else {
1084             ecmaColor += 40;
1085         }
1086
1087         if (header) {
1088             return String.format("\033[%dm", ecmaColor);
1089         } else {
1090             return String.format("%d;", ecmaColor);
1091         }
1092     }
1093
1094     /**
1095      * Create a SGR parameter sequence for both foreground and
1096      * background color change.
1097      *
1098      * @param foreColor one of the Color.WHITE, Color.BLUE, etc. constants
1099      * @param backColor one of the Color.WHITE, Color.BLUE, etc. constants
1100      * @return the string to emit to an ANSI / ECMA-style terminal,
1101      * e.g. "\033[31;42m"
1102      */
1103     public String color(final Color foreColor, final Color backColor) {
1104         return color(foreColor, backColor, true);
1105     }
1106
1107     /**
1108      * Create a SGR parameter sequence for both foreground and
1109      * background color change.
1110      *
1111      * @param foreColor one of the Color.WHITE, Color.BLUE, etc. constants
1112      * @param backColor one of the Color.WHITE, Color.BLUE, etc. constants
1113      * @param header if true, make the full header, otherwise just emit the
1114      * color parameter e.g. "31;42;"
1115      * @return the string to emit to an ANSI / ECMA-style terminal,
1116      * e.g. "\033[31;42m"
1117      */
1118     public String color(final Color foreColor, final Color backColor,
1119         final boolean header) {
1120
1121         int ecmaForeColor = foreColor.getValue();
1122         int ecmaBackColor = backColor.getValue();
1123
1124         // Convert Color.* values to SGR numerics
1125         ecmaBackColor += 40;
1126         ecmaForeColor += 30;
1127
1128         if (header) {
1129             return String.format("\033[%d;%dm", ecmaForeColor, ecmaBackColor);
1130         } else {
1131             return String.format("%d;%d;", ecmaForeColor, ecmaBackColor);
1132         }
1133     }
1134
1135     /**
1136      * Create a SGR parameter sequence for foreground, background, and
1137      * several attributes.  This sequence first resets all attributes to
1138      * default, then sets attributes as per the parameters.
1139      *
1140      * @param foreColor one of the Color.WHITE, Color.BLUE, etc. constants
1141      * @param backColor one of the Color.WHITE, Color.BLUE, etc. constants
1142      * @param bold if true, set bold
1143      * @param reverse if true, set reverse
1144      * @param blink if true, set blink
1145      * @param underline if true, set underline
1146      * @return the string to emit to an ANSI / ECMA-style terminal,
1147      * e.g. "\033[0;1;31;42m"
1148      */
1149     public String color(final Color foreColor, final Color backColor,
1150         final boolean bold, final boolean reverse, final boolean blink,
1151         final boolean underline) {
1152
1153         int ecmaForeColor = foreColor.getValue();
1154         int ecmaBackColor = backColor.getValue();
1155
1156         // Convert Color.* values to SGR numerics
1157         ecmaBackColor += 40;
1158         ecmaForeColor += 30;
1159
1160         StringBuilder sb = new StringBuilder();
1161         if        (  bold &&  reverse &&  blink && !underline ) {
1162             sb.append("\033[0;1;7;5;");
1163         } else if (  bold &&  reverse && !blink && !underline ) {
1164             sb.append("\033[0;1;7;");
1165         } else if ( !bold &&  reverse &&  blink && !underline ) {
1166             sb.append("\033[0;7;5;");
1167         } else if (  bold && !reverse &&  blink && !underline ) {
1168             sb.append("\033[0;1;5;");
1169         } else if (  bold && !reverse && !blink && !underline ) {
1170             sb.append("\033[0;1;");
1171         } else if ( !bold &&  reverse && !blink && !underline ) {
1172             sb.append("\033[0;7;");
1173         } else if ( !bold && !reverse &&  blink && !underline) {
1174             sb.append("\033[0;5;");
1175         } else if (  bold &&  reverse &&  blink &&  underline ) {
1176             sb.append("\033[0;1;7;5;4;");
1177         } else if (  bold &&  reverse && !blink &&  underline ) {
1178             sb.append("\033[0;1;7;4;");
1179         } else if ( !bold &&  reverse &&  blink &&  underline ) {
1180             sb.append("\033[0;7;5;4;");
1181         } else if (  bold && !reverse &&  blink &&  underline ) {
1182             sb.append("\033[0;1;5;4;");
1183         } else if (  bold && !reverse && !blink &&  underline ) {
1184             sb.append("\033[0;1;4;");
1185         } else if ( !bold &&  reverse && !blink &&  underline ) {
1186             sb.append("\033[0;7;4;");
1187         } else if ( !bold && !reverse &&  blink &&  underline) {
1188             sb.append("\033[0;5;4;");
1189         } else if ( !bold && !reverse && !blink &&  underline) {
1190             sb.append("\033[0;4;");
1191         } else {
1192             assert (!bold && !reverse && !blink && !underline);
1193             sb.append("\033[0;");
1194         }
1195         sb.append(String.format("%d;%dm", ecmaForeColor, ecmaBackColor));
1196         return sb.toString();
1197     }
1198
1199     /**
1200      * Create a SGR parameter sequence for enabling reverse color.
1201      *
1202      * @param on if true, turn on reverse
1203      * @return the string to emit to an ANSI / ECMA-style terminal,
1204      * e.g. "\033[7m"
1205      */
1206     public String reverse(final boolean on) {
1207         if (on) {
1208             return "\033[7m";
1209         }
1210         return "\033[27m";
1211     }
1212
1213     /**
1214      * Create a SGR parameter sequence to reset to defaults.
1215      *
1216      * @return the string to emit to an ANSI / ECMA-style terminal,
1217      * e.g. "\033[0m"
1218      */
1219     public String normal() {
1220         return normal(true);
1221     }
1222
1223     /**
1224      * Create a SGR parameter sequence to reset to defaults.
1225      *
1226      * @param header if true, make the full header, otherwise just emit the
1227      * bare parameter e.g. "0;"
1228      * @return the string to emit to an ANSI / ECMA-style terminal,
1229      * e.g. "\033[0m"
1230      */
1231     public String normal(final boolean header) {
1232         if (header) {
1233             return "\033[0;37;40m";
1234         }
1235         return "0;37;40";
1236     }
1237
1238     /**
1239      * Create a SGR parameter sequence for enabling boldface.
1240      *
1241      * @param on if true, turn on bold
1242      * @return the string to emit to an ANSI / ECMA-style terminal,
1243      * e.g. "\033[1m"
1244      */
1245     public String bold(final boolean on) {
1246         return bold(on, true);
1247     }
1248
1249     /**
1250      * Create a SGR parameter sequence for enabling boldface.
1251      *
1252      * @param on if true, turn on bold
1253      * @param header if true, make the full header, otherwise just emit the
1254      * bare parameter e.g. "1;"
1255      * @return the string to emit to an ANSI / ECMA-style terminal,
1256      * e.g. "\033[1m"
1257      */
1258     public String bold(final boolean on, final boolean header) {
1259         if (header) {
1260             if (on) {
1261                 return "\033[1m";
1262             }
1263             return "\033[22m";
1264         }
1265         if (on) {
1266             return "1;";
1267         }
1268         return "22;";
1269     }
1270
1271     /**
1272      * Create a SGR parameter sequence for enabling blinking text.
1273      *
1274      * @param on if true, turn on blink
1275      * @return the string to emit to an ANSI / ECMA-style terminal,
1276      * e.g. "\033[5m"
1277      */
1278     public String blink(final boolean on) {
1279         return blink(on, true);
1280     }
1281
1282     /**
1283      * Create a SGR parameter sequence for enabling blinking text.
1284      *
1285      * @param on if true, turn on blink
1286      * @param header if true, make the full header, otherwise just emit the
1287      * bare parameter e.g. "5;"
1288      * @return the string to emit to an ANSI / ECMA-style terminal,
1289      * e.g. "\033[5m"
1290      */
1291     public String blink(final boolean on, final boolean header) {
1292         if (header) {
1293             if (on) {
1294                 return "\033[5m";
1295             }
1296             return "\033[25m";
1297         }
1298         if (on) {
1299             return "5;";
1300         }
1301         return "25;";
1302     }
1303
1304     /**
1305      * Create a SGR parameter sequence for enabling underline / underscored
1306      * text.
1307      *
1308      * @param on if true, turn on underline
1309      * @return the string to emit to an ANSI / ECMA-style terminal,
1310      * e.g. "\033[4m"
1311      */
1312     public String underline(final boolean on) {
1313         if (on) {
1314             return "\033[4m";
1315         }
1316         return "\033[24m";
1317     }
1318
1319     /**
1320      * Create a SGR parameter sequence for enabling the visible cursor.
1321      *
1322      * @param on if true, turn on cursor
1323      * @return the string to emit to an ANSI / ECMA-style terminal
1324      */
1325     public String cursor(final boolean on) {
1326         if (on && !cursorOn) {
1327             cursorOn = true;
1328             return "\033[?25h";
1329         }
1330         if (!on && cursorOn) {
1331             cursorOn = false;
1332             return "\033[?25l";
1333         }
1334         return "";
1335     }
1336
1337     /**
1338      * Clear the entire screen.  Because some terminals use back-color-erase,
1339      * set the color to white-on-black beforehand.
1340      *
1341      * @return the string to emit to an ANSI / ECMA-style terminal
1342      */
1343     public String clearAll() {
1344         return "\033[0;37;40m\033[2J";
1345     }
1346
1347     /**
1348      * Clear the line from the cursor (inclusive) to the end of the screen.
1349      * Because some terminals use back-color-erase, set the color to
1350      * white-on-black beforehand.
1351      *
1352      * @return the string to emit to an ANSI / ECMA-style terminal
1353      */
1354     public String clearRemainingLine() {
1355         return "\033[0;37;40m\033[K";
1356     }
1357
1358     /**
1359      * Clear the line up the cursor (inclusive).  Because some terminals use
1360      * back-color-erase, set the color to white-on-black beforehand.
1361      *
1362      * @return the string to emit to an ANSI / ECMA-style terminal
1363      */
1364     public String clearPreceedingLine() {
1365         return "\033[0;37;40m\033[1K";
1366     }
1367
1368     /**
1369      * Clear the line.  Because some terminals use back-color-erase, set the
1370      * color to white-on-black beforehand.
1371      *
1372      * @return the string to emit to an ANSI / ECMA-style terminal
1373      */
1374     public String clearLine() {
1375         return "\033[0;37;40m\033[2K";
1376     }
1377
1378     /**
1379      * Move the cursor to the top-left corner.
1380      *
1381      * @return the string to emit to an ANSI / ECMA-style terminal
1382      */
1383     public String home() {
1384         return "\033[H";
1385     }
1386
1387     /**
1388      * Move the cursor to (x, y).
1389      *
1390      * @param x column coordinate.  0 is the left-most column.
1391      * @param y row coordinate.  0 is the top-most row.
1392      * @return the string to emit to an ANSI / ECMA-style terminal
1393      */
1394     public String gotoXY(final int x, final int y) {
1395         return String.format("\033[%d;%dH", y + 1, x + 1);
1396     }
1397
1398     /**
1399      * Tell (u)xterm that we want to receive mouse events based on "Any event
1400      * tracking" and UTF-8 coordinates.  See
1401      * http://invisible-island.net/xterm/ctlseqs/ctlseqs.html#Mouse%20Tracking
1402      *
1403      * Note that this also sets the alternate/primary screen buffer.
1404      *
1405      * @param on If true, enable mouse report and use the alternate screen
1406      * buffer.  If false disable mouse reporting and use the primary screen
1407      * buffer.
1408      * @return the string to emit to xterm
1409      */
1410     public String mouse(final boolean on) {
1411         if (on) {
1412             return "\033[?1003;1005h\033[?1049h";
1413         }
1414         return "\033[?1003;1005l\033[?1049l";
1415     }
1416
1417     /**
1418      * Read function runs on a separate thread.
1419      */
1420     public void run() {
1421         boolean done = false;
1422         // available() will often return > 1, so we need to read in chunks to
1423         // stay caught up.
1424         char [] readBuffer = new char[128];
1425         List<TInputEvent> events = new LinkedList<TInputEvent>();
1426
1427         while (!done && !stopReaderThread) {
1428             try {
1429                 // We assume that if inputStream has bytes available, then
1430                 // input won't block on read().
1431                 int n = inputStream.available();
1432                 if (n > 0) {
1433                     if (readBuffer.length < n) {
1434                         // The buffer wasn't big enough, make it huger
1435                         readBuffer = new char[readBuffer.length * 2];
1436                     }
1437
1438                     int rc = input.read(readBuffer, 0, readBuffer.length);
1439                     // System.err.printf("read() %d", rc); System.err.flush();
1440                     if (rc == -1) {
1441                         // This is EOF
1442                         done = true;
1443                     } else {
1444                         for (int i = 0; i < rc; i++) {
1445                             int ch = readBuffer[i];
1446                             processChar(events, (char)ch);
1447                             if (events.size() > 0) {
1448                                 // Add to the queue for the backend thread to
1449                                 // be able to obtain.
1450                                 synchronized (eventQueue) {
1451                                     eventQueue.addAll(events);
1452                                 }
1453                                 synchronized (listener) {
1454                                     listener.notifyAll();
1455                                 }
1456                                 events.clear();
1457                             }
1458                         }
1459                     }
1460                 } else {
1461                     getIdleEvents(events);
1462                     if (events.size() > 0) {
1463                         synchronized (eventQueue) {
1464                             eventQueue.addAll(events);
1465                         }
1466                         events.clear();
1467                         synchronized (listener) {
1468                             listener.notifyAll();
1469                         }
1470                     }
1471
1472                     // Wait 10 millis for more data
1473                     Thread.sleep(10);
1474                 }
1475                 // System.err.println("end while loop"); System.err.flush();
1476             } catch (InterruptedException e) {
1477                 // SQUASH
1478             } catch (IOException e) {
1479                 e.printStackTrace();
1480                 done = true;
1481             }
1482         } // while ((done == false) && (stopReaderThread == false))
1483         // System.err.println("*** run() exiting..."); System.err.flush();
1484     }
1485
1486 }