package jexer.io;
import java.io.BufferedReader;
+import java.io.FileDescriptor;
+import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
* X3.64 / ECMA-48 type terminals e.g. xterm, linux, vt100, ansi.sys,
* etc.
*/
-public class ECMA48Terminal {
+public class ECMA48Terminal implements Runnable {
/**
* The session information
*/
public SessionInfo session;
+ /**
+ * The event queue, filled up by a thread reading on input
+ */
+ private List<TInputEvent> eventQueue;
+
+ /**
+ * If true, we want the reader thread to exit gracefully.
+ */
+ private boolean stopReaderThread;
+
+ /**
+ * The reader thread
+ */
+ private Thread readerThread;
+
/**
* Parameters being collected. E.g. if the string is \033[1;3m, then
* params[0] will be 1 and params[1] will be 3.
/**
* The terminal's input. If an InputStream is not specified in the
- * constructor, then this InputReader will be bound to System.in with
- * UTF-8 encoding.
+ * constructor, then this InputStreamReader will be bound to System.in
+ * with UTF-8 encoding.
*/
private Reader input;
+ /**
+ * The terminal's raw InputStream. If an InputStream is not specified in
+ * the constructor, then this InputReader will be bound to System.in.
+ * This is used by run() to see if bytes are available() before calling
+ * (Reader)input.read().
+ */
+ private InputStream inputStream;
+
/**
* The terminal's output. If an OutputStream is not specified in the
* constructor, then this PrintWriter will be bound to System.out with
return output;
}
+ /**
+ * Check if there are events in the queue.
+ *
+ * @return if true, getEvents() has something to return to the backend
+ */
+ public boolean hasEvents() {
+ synchronized (eventQueue) {
+ return (eventQueue.size() > 0);
+ }
+ }
+
/**
* Call 'stty cooked' to set cooked mode.
*/
*/
private void doStty(boolean mode) {
String [] cmdRaw = {
- "/bin/sh", "-c", "stty raw < /dev/tty"
+ "/bin/sh", "-c", "stty -ignbrk -brkint -parmrk -istrip -inlcr -igncr -icrnl -ixon -opost -echo -echonl -icanon -isig -iexten -parenb cs8 min 1 < /dev/tty"
};
String [] cmdCooked = {
- "/bin/sh", "-c", "stty cooked < /dev/tty"
+ "/bin/sh", "-c", "stty sane cooked < /dev/tty"
};
try {
- System.out.println("spawn stty");
-
Process process;
if (mode == true) {
process = Runtime.getRuntime().exec(cmdRaw);
public ECMA48Terminal(InputStream input, OutputStream output) throws UnsupportedEncodingException {
reset();
- mouse1 = false;
- mouse2 = false;
- mouse3 = false;
+ mouse1 = false;
+ mouse2 = false;
+ mouse3 = false;
+ stopReaderThread = false;
if (input == null) {
- this.input = new InputStreamReader(System.in, "UTF-8");
+ // inputStream = System.in;
+ inputStream = new FileInputStream(FileDescriptor.in);
sttyRaw();
setRawMode = true;
} else {
- this.input = new InputStreamReader(input);
+ inputStream = input;
}
+ this.input = new InputStreamReader(inputStream, "UTF-8");
+
// TODO: include TelnetSocket from NIB and have it implement
// SessionInfo
if (input instanceof SessionInfo) {
// Hang onto the window size
windowResize = new TResizeEvent(TResizeEvent.Type.Screen,
session.getWindowWidth(), session.getWindowHeight());
+
+ // Spin up the input reader
+ eventQueue = new LinkedList<TInputEvent>();
+ readerThread = new Thread(this);
+ readerThread.start();
}
/**
* Restore terminal to normal state
*/
public void shutdown() {
+
+ // System.err.println("=== shutdown() ==="); System.err.flush();
+
+ // Tell the reader thread to stop looking at input
+ stopReaderThread = true;
+ try {
+ readerThread.join();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+
+ // Disable mouse reporting and show cursor
+ output.printf("%s%s%s", mouse(false), cursor(true), normal());
+ output.flush();
+
if (setRawMode) {
sttyCooked();
setRawMode = false;
+ // We don't close System.in/out
+ } else {
+ // Shut down the streams, this should wake up the reader thread
+ // and make it exit.
+ try {
+ if (input != null) {
+ input.close();
+ input = null;
+ }
+ if (output != null) {
+ output.close();
+ output = null;
+ }
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
}
- // Disable mouse reporting and show cursor
- output.printf("%s%s%s", mouse(false), cursor(true), normal());
}
/**
*/
private void reset() {
state = ParseState.GROUND;
+ params = new ArrayList<String>();
paramI = 0;
params.clear();
params.add("");
// System.err.printf("controlChar: %02x\n", ch);
switch (ch) {
- case '\r':
- // ENTER
+ case 0x0D:
+ // Carriage return --> ENTER
+ event.key = kbEnter;
+ break;
+ case 0x0A:
+ // Linefeed --> ENTER
event.key = kbEnter;
break;
case 0x1B:
/**
* Return any events in the IO queue.
*
- * @return list of new events (which may be empty)
+ * @param queue list to append new events to
*/
- public List<TInputEvent> getEvents() {
- List<TInputEvent> events = new LinkedList<TInputEvent>();
- return events;
+ public void getEvents(List<TInputEvent> queue) {
+ synchronized (eventQueue) {
+ if (eventQueue.size() > 0) {
+ queue.addAll(eventQueue);
+ eventQueue.clear();
+ }
+ }
}
/**
- * Parses the next character of input to see if an InputEvent is fully
- * here.
+ * Return any events in the IO queue due to timeout.
*
- * @param ch Unicode code point
- * @return list of new events (which may be empty)
+ * @param queue list to append new events to
*/
- public List<TInputEvent> getEvents(char ch) {
- return getEvents(ch, false);
+ public void getIdleEvents(List<TInputEvent> queue) {
+
+ // Check for new window size
+ session.queryWindowSize();
+ int newWidth = session.getWindowWidth();
+ int newHeight = session.getWindowHeight();
+ if ((newWidth != windowResize.width) ||
+ (newHeight != windowResize.height)) {
+ TResizeEvent event = new TResizeEvent(TResizeEvent.Type.Screen,
+ newWidth, newHeight);
+ windowResize.width = newWidth;
+ windowResize.height = newHeight;
+ synchronized (eventQueue) {
+ eventQueue.add(event);
+ }
+ }
+
+ synchronized (eventQueue) {
+ if (eventQueue.size() > 0) {
+ queue.addAll(eventQueue);
+ eventQueue.clear();
+ }
+ }
}
/**
* Parses the next character of input to see if an InputEvent is
* fully here.
*
+ * @param events list to append new events to
* @param ch Unicode code point
- * @param noChar if true, ignore ch. This is currently used to return a
- * bare ESC and RESIZE events.
- * @return list of new events (which may be empty)
*/
- public List<TInputEvent> getEvents(char ch, boolean noChar) {
- List<TInputEvent> events = new LinkedList<TInputEvent>();
+ private void processChar(List<TInputEvent> events, char ch) {
TKeypressEvent keypress;
Date now = new Date();
}
}
- if (noChar == true) {
- int newWidth = session.getWindowWidth();
- int newHeight = session.getWindowHeight();
- if ((newWidth != windowResize.width) ||
- (newHeight != windowResize.height)) {
- TResizeEvent event = new TResizeEvent(TResizeEvent.Type.Screen,
- newWidth, newHeight);
- windowResize.width = newWidth;
- windowResize.height = newHeight;
- events.add(event);
- }
-
- // Nothing else to do, bail out
- return events;
- }
-
// System.err.printf("state: %s ch %c\r\n", state, ch);
switch (state) {
if (ch == 0x1B) {
state = ParseState.ESCAPE;
escapeTime = now.getTime();
- return events;
+ return;
}
if (ch <= 0x1F) {
// Control character
events.add(controlChar(ch));
reset();
- return events;
+ return;
}
if (ch >= 0x20) {
keypress.key.ch = ch;
events.add(keypress);
reset();
- return events;
+ return;
}
break;
keypress.key.alt = true;
events.add(keypress);
reset();
- return events;
+ return;
}
if (ch == 'O') {
// This will be one of the function keys
state = ParseState.ESCAPE_INTERMEDIATE;
- return events;
+ return;
}
// '[' goes to CSI_ENTRY
if (ch == '[') {
state = ParseState.CSI_ENTRY;
- return events;
+ return;
}
// Everything else is assumed to be Alt-keystroke
}
events.add(keypress);
reset();
- return events;
+ return;
case ESCAPE_INTERMEDIATE:
if ((ch >= 'P') && (ch <= 'S')) {
}
events.add(keypress);
reset();
- return events;
+ return;
}
// Unknown keystroke, ignore
reset();
- return events;
+ return;
case CSI_ENTRY:
// Numbers - parameter values
if ((ch >= '0') && (ch <= '9')) {
params.set(paramI, params.get(paramI) + ch);
state = ParseState.CSI_PARAM;
- return events;
+ return;
}
// Parameter separator
if (ch == ';') {
paramI++;
params.set(paramI, "");
- return events;
+ return;
}
if ((ch >= 0x30) && (ch <= 0x7E)) {
}
events.add(keypress);
reset();
- return events;
+ return;
case 'B':
// Down
keypress = new TKeypressEvent();
}
events.add(keypress);
reset();
- return events;
+ return;
case 'C':
// Right
keypress = new TKeypressEvent();
}
events.add(keypress);
reset();
- return events;
+ return;
case 'D':
// Left
keypress = new TKeypressEvent();
}
events.add(keypress);
reset();
- return events;
+ return;
case 'H':
// Home
keypress = new TKeypressEvent();
keypress.key.fnKey = TKeypress.HOME;
events.add(keypress);
reset();
- return events;
+ return;
case 'F':
// End
keypress = new TKeypressEvent();
keypress.key.fnKey = TKeypress.END;
events.add(keypress);
reset();
- return events;
+ return;
case 'Z':
// CBT - Cursor backward X tab stops (default 1)
keypress = new TKeypressEvent();
keypress.key.fnKey = TKeypress.BTAB;
events.add(keypress);
reset();
- return events;
+ return;
case 'M':
// Mouse position
state = ParseState.MOUSE;
- return events;
+ return;
default:
break;
}
// Unknown keystroke, ignore
reset();
- return events;
+ return;
case CSI_PARAM:
// Numbers - parameter values
if ((ch >= '0') && (ch <= '9')) {
params.set(paramI, params.get(paramI) + ch);
state = ParseState.CSI_PARAM;
- return events;
+ return;
}
// Parameter separator
if (ch == ';') {
paramI++;
params.set(paramI, "");
- return events;
+ return;
}
if (ch == '~') {
events.add(csiFnKey());
reset();
- return events;
+ return;
}
if ((ch >= 0x30) && (ch <= 0x7E)) {
}
events.add(keypress);
reset();
- return events;
+ return;
case 'B':
// Down
keypress = new TKeypressEvent();
}
events.add(keypress);
reset();
- return events;
+ return;
case 'C':
// Right
keypress = new TKeypressEvent();
}
events.add(keypress);
reset();
- return events;
+ return;
case 'D':
// Left
keypress = new TKeypressEvent();
}
events.add(keypress);
reset();
- return events;
+ return;
default:
break;
}
// Unknown keystroke, ignore
reset();
- return events;
+ return;
case MOUSE:
params.set(0, params.get(paramI) + ch);
events.add(parseMouse());
reset();
}
- return events;
+ return;
default:
break;
}
// This "should" be impossible to reach
- return events;
+ return;
}
/**
return "\033[?1003;1005l\033[?1049l";
}
+ /**
+ * Read function runs on a separate thread.
+ */
+ public void run() {
+ boolean done = false;
+ // available() will often return > 1, so we need to read in chunks to
+ // stay caught up.
+ char [] readBuffer = new char[128];
+ List<TInputEvent> events = new LinkedList<TInputEvent>();
+
+ while ((done == false) && (stopReaderThread == false)) {
+ try {
+ // We assume that if inputStream has bytes available, then
+ // input won't block on read().
+ int n = inputStream.available();
+ if (n > 0) {
+ if (readBuffer.length < n) {
+ // The buffer wasn't big enough, make it huger
+ readBuffer = new char[readBuffer.length * 2];
+ }
+
+ int rc = input.read(readBuffer, 0, n);
+ // System.err.printf("read() %d", rc); System.err.flush();
+ if (rc == -1) {
+ // This is EOF
+ done = true;
+ } else {
+ for (int i = 0; i < rc; i++) {
+ int ch = readBuffer[i];
+ processChar(events, (char)ch);
+ if (events.size() > 0) {
+ // Add to the queue for the backend thread to
+ // be able to obtain.
+ synchronized (eventQueue) {
+ eventQueue.addAll(events);
+ }
+ // Now wake up the backend
+ synchronized (this) {
+ this.notifyAll();
+ }
+ events.clear();
+ }
+ }
+ }
+ } else {
+ // Wait 5 millis for more data
+ Thread.sleep(5);
+ }
+ // System.err.println("end while loop"); System.err.flush();
+ } catch (InterruptedException e) {
+ // SQUASH
+ } catch (IOException e) {
+ e.printStackTrace();
+ done = true;
+ }
+ } // while ((done == false) && (stopReaderThread == false))
+ // System.err.println("*** run() exiting..."); System.err.flush();
+ }
+
}