X-Git-Url: http://git.nikiroo.be/?a=blobdiff_plain;f=src%2Fjexer%2Ftterminal%2FECMA48.java;h=80f0ffbefa12133d270add78fc1a04ae85153412;hb=ab215e38e98a76ad189ba537e37c420ae515e4c0;hp=9376828ee7689411ff7492de501d7109bc892445;hpb=051e29138b18fb4b731a72f8727475b10e4c74e4;p=fanfix.git diff --git a/src/jexer/tterminal/ECMA48.java b/src/jexer/tterminal/ECMA48.java index 9376828..80f0ffb 100644 --- a/src/jexer/tterminal/ECMA48.java +++ b/src/jexer/tterminal/ECMA48.java @@ -3,7 +3,7 @@ * * The MIT License (MIT) * - * Copyright (C) 2017 Kevin Lamonte + * Copyright (C) 2019 Kevin Lamonte * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), @@ -28,25 +28,33 @@ */ package jexer.tterminal; +import java.awt.Graphics2D; +import java.awt.image.BufferedImage; import java.io.BufferedOutputStream; +import java.io.CharArrayWriter; import java.io.InputStream; import java.io.InputStreamReader; import java.io.IOException; import java.io.OutputStream; import java.io.OutputStreamWriter; +import java.io.PrintWriter; import java.io.Reader; import java.io.UnsupportedEncodingException; import java.io.Writer; import java.util.ArrayList; import java.util.Collections; -import java.util.LinkedList; +import java.util.HashMap; import java.util.List; import jexer.TKeypress; -import jexer.event.TMouseEvent; +import jexer.backend.GlyphMaker; import jexer.bits.Color; import jexer.bits.Cell; import jexer.bits.CellAttributes; +import jexer.bits.StringUtils; +import jexer.event.TInputEvent; +import jexer.event.TKeypressEvent; +import jexer.event.TMouseEvent; import jexer.io.ReadTimeoutException; import jexer.io.TimeoutInputStream; import static jexer.TKeypress.*; @@ -135,6 +143,7 @@ public class ECMA48 implements Runnable { DCS_PARAM, DCS_PASSTHROUGH, DCS_IGNORE, + DCS_SIXEL, SOSPMAPC_STRING, OSC_STRING, VT52_DIRECT_CURSOR_ADDRESS @@ -208,7 +217,7 @@ public class ECMA48 implements Runnable { /** * XTERM mouse reporting protocols. */ - private enum MouseProtocol { + public enum MouseProtocol { OFF, X10, NORMAL, @@ -252,12 +261,17 @@ public class ECMA48 implements Runnable { /** * The scrollback buffer characters + attributes. */ - private volatile List scrollback; + private volatile ArrayList scrollback; /** * The raw display buffer characters + attributes. */ - private volatile List display; + private volatile ArrayList display; + + /** + * The maximum number of lines in the scrollback buffer. + */ + private int maxScrollback = 10000; /** * The terminal's input. For type == XTERM, this is an InputStreamReader @@ -296,6 +310,15 @@ public class ECMA48 implements Runnable { */ private MouseEncoding mouseEncoding = MouseEncoding.X10; + /** + * A terminal may request that the mouse pointer be hidden using a + * Privacy Message containing either "hideMousePointer" or + * "showMousePointer". This is currently only used within Jexer by + * TTerminalWindow so that only the bottom-most instance of nested + * Jexer's draws the mouse within its application window. + */ + private boolean hideMousePointer = false; + /** * Physical display width. We start at 80x24, but the user can resize us * bigger/smaller. @@ -443,6 +466,38 @@ public class ECMA48 implements Runnable { */ private List colors88; + /** + * Sixel collection buffer. + */ + private StringBuilder sixelParseBuffer; + + /** + * The width of a character cell in pixels. + */ + private int textWidth = 16; + + /** + * The height of a character cell in pixels. + */ + private int textHeight = 20; + + /** + * The last used height of a character cell in pixels, only used for + * full-width chars. + */ + private int lastTextHeight = -1; + + /** + * The glyph drawer for full-width chars. + */ + private GlyphMaker glyphMaker = null; + + /** + * Input queue for keystrokes and mouse events to send to the remote + * side. + */ + private ArrayList userQueue = new ArrayList(); + /** * DECSC/DECRC save/restore a subset of the total state. This class * encapsulates those specific flags/modes. @@ -585,8 +640,8 @@ public class ECMA48 implements Runnable { csiParams = new ArrayList(); tabStops = new ArrayList(); - scrollback = new LinkedList(); - display = new LinkedList(); + scrollback = new ArrayList(); + display = new ArrayList(); this.type = type; if (inputStream instanceof TimeoutInputStream) { @@ -641,6 +696,12 @@ public class ECMA48 implements Runnable { } while (!done && !stopReaderThread) { + synchronized (userQueue) { + while (userQueue.size() > 0) { + handleUserEvent(userQueue.remove(0)); + } + } + try { int n = inputStream.available(); @@ -697,7 +758,7 @@ public class ECMA48 implements Runnable { ch = readBuffer[i]; } - consume((char)ch); + consume((char) ch); } } // Permit my enclosing UI to know that I updated. @@ -707,8 +768,29 @@ public class ECMA48 implements Runnable { } // System.err.println("end while loop"); System.err.flush(); } catch (IOException e) { - e.printStackTrace(); done = true; + + // This is an unusual case. We want to see the stack trace, + // but it is related to the spawned process rather than the + // actual UI. We will generate the stack trace, and consume + // it as though it was emitted by the shell. + CharArrayWriter writer= new CharArrayWriter(); + // Send a ST and RIS to clear the emulator state. + try { + writer.write("\033\\\033c"); + writer.write("\n-----------------------------------\n"); + e.printStackTrace(new PrintWriter(writer)); + writer.write("\n-----------------------------------\n"); + } catch (IOException e2) { + // SQUASH + } + char [] stackTrace = writer.toCharArray(); + for (int i = 0; i < stackTrace.length; i++) { + if (stackTrace[i] == '\n') { + consume('\r'); + } + consume(stackTrace[i]); + } } } // while ((done == false) && (stopReaderThread == false)) @@ -742,6 +824,31 @@ public class ECMA48 implements Runnable { // ECMA48 ----------------------------------------------------------------- // ------------------------------------------------------------------------ + /** + * Process keyboard and mouse events from the user. + * + * @param event the input event to consume + */ + private void handleUserEvent(final TInputEvent event) { + if (event instanceof TKeypressEvent) { + keypress(((TKeypressEvent) event).getKey()); + } + if (event instanceof TMouseEvent) { + mouse((TMouseEvent) event); + } + } + + /** + * Add a keyboard and mouse event from the user to the queue. + * + * @param event the input event to consume + */ + public void addUserEvent(final TInputEvent event) { + synchronized (userQueue) { + userQueue.add(event); + } + } + /** * Return the proper primary Device Attributes string. * @@ -889,7 +996,7 @@ public class ECMA48 implements Runnable { try { readerThread.join(1000); } catch (InterruptedException e) { - e.printStackTrace(); + // SQUASH } } @@ -1078,7 +1185,7 @@ public class ECMA48 implements Runnable { private void resetTabStops() { tabStops.clear(); for (int i = 0; (i * 8) <= rightMargin; i++) { - tabStops.add(new Integer(i * 8)); + tabStops.add(Integer.valueOf(i * 8)); } } @@ -1234,7 +1341,12 @@ public class ECMA48 implements Runnable { private void newDisplayLine() { // Scroll the top line off into the scrollback buffer scrollback.add(display.get(0)); + if (scrollback.size() > maxScrollback) { + scrollback.remove(0); + scrollback.trimToSize(); + } display.remove(0); + display.trimToSize(); DisplayLine line = new DisplayLine(currentState.attr); line.setReverseColor(reverseVideo); display.add(line); @@ -1317,6 +1429,35 @@ public class ECMA48 implements Runnable { private void printCharacter(final char ch) { int rightMargin = this.rightMargin; + if (StringUtils.width(ch) == 2) { + // This is a full-width character. Save two spaces, and then + // draw the character as two image halves. + int x0 = currentState.cursorX; + int y0 = currentState.cursorY; + printCharacter(' '); + printCharacter(' '); + if ((currentState.cursorX == x0 + 2) + && (currentState.cursorY == y0) + ) { + // We can draw both halves of the character. + drawHalves(x0, y0, x0 + 1, y0, ch); + } else if ((currentState.cursorX == x0 + 1) + && (currentState.cursorY == y0) + ) { + // VT100 line wrap behavior: we should be at the right + // margin. We can draw both halves of the character. + drawHalves(x0, y0, x0 + 1, y0, ch); + } else { + // The character splits across the line. Draw the entire + // character on the new line, giving one more space for it. + x0 = currentState.cursorX - 1; + y0 = currentState.cursorY; + printCharacter(' '); + drawHalves(x0, y0, x0 + 1, y0, ch); + } + return; + } + // Check if we have double-width, and if so chop at 40/66 instead of // 80/132 if (display.get(currentState.cursorY).isDoubleWidth()) { @@ -1367,19 +1508,22 @@ public class ECMA48 implements Runnable { CellAttributes newCellAttributes = (CellAttributes) newCell; newCellAttributes.setTo(currentState.attr); DisplayLine line = display.get(currentState.cursorY); - // Insert mode special case - if (insertMode == true) { - line.insert(currentState.cursorX, newCell); - } else { - // Replace an existing character - line.replace(currentState.cursorX, newCell); - } - // Increment horizontal - if (wrapLineFlag == false) { - currentState.cursorX++; - if (currentState.cursorX > rightMargin) { - currentState.cursorX--; + if (StringUtils.width(ch) == 1) { + // Insert mode special case + if (insertMode == true) { + line.insert(currentState.cursorX, newCell); + } else { + // Replace an existing character + line.replace(currentState.cursorX, newCell); + } + + // Increment horizontal + if (wrapLineFlag == false) { + currentState.cursorX++; + if (currentState.cursorX > rightMargin) { + currentState.cursorX--; + } } } } @@ -1390,7 +1534,7 @@ public class ECMA48 implements Runnable { * * @param mouse mouse event received from the local user */ - public void mouse(final TMouseEvent mouse) { + private void mouse(final TMouseEvent mouse) { /* System.err.printf("mouse(): protocol %s encoding %s mouse %s\n", @@ -1538,7 +1682,7 @@ public class ECMA48 implements Runnable { * * @param keypress keypress received from the local user */ - public void keypress(final TKeypress keypress) { + private void keypress(final TKeypress keypress) { writeRemote(keypressToString(keypress)); } @@ -1588,6 +1732,7 @@ public class ECMA48 implements Runnable { * @param keypress keypress received from the local user * @return string to transmit to the remote side */ + @SuppressWarnings("fallthrough") private String keypressToString(final TKeypress keypress) { if ((fullDuplex == false) && (!keypress.isFnKey())) { @@ -2326,13 +2471,13 @@ public class ECMA48 implements Runnable { switch (currentState.glLockshift) { case G1_GR: - assert (false); + throw new IllegalArgumentException("programming bug"); case G2_GR: - assert (false); + throw new IllegalArgumentException("programming bug"); case G3_GR: - assert (false); + throw new IllegalArgumentException("programming bug"); case G2_GL: // LS2 @@ -2353,10 +2498,10 @@ public class ECMA48 implements Runnable { switch (currentState.grLockshift) { case G2_GL: - assert (false); + throw new IllegalArgumentException("programming bug"); case G3_GL: - assert (false); + throw new IllegalArgumentException("programming bug"); case G1_GR: // LS1R @@ -2415,7 +2560,7 @@ public class ECMA48 implements Runnable { display.size()); List displayMiddle = display.subList(regionBottom + 1 - remaining, regionBottom + 1); - display = new LinkedList(displayTop); + display = new ArrayList(displayTop); display.addAll(displayMiddle); for (int i = 0; i < n; i++) { DisplayLine line = new DisplayLine(currentState.attr); @@ -2456,7 +2601,7 @@ public class ECMA48 implements Runnable { display.size()); List displayMiddle = display.subList(regionTop, regionTop + remaining); - display = new LinkedList(displayTop); + display = new ArrayList(displayTop); for (int i = 0; i < n; i++) { DisplayLine line = new DisplayLine(currentState.attr); line.setReverseColor(reverseVideo); @@ -2611,7 +2756,7 @@ public class ECMA48 implements Runnable { */ private void param(final byte ch) { if (csiParams.size() == 0) { - csiParams.add(new Integer(0)); + csiParams.add(Integer.valueOf(0)); } Integer x = csiParams.get(csiParams.size() - 1); if ((ch >= '0') && (ch <= '9')) { @@ -2620,8 +2765,8 @@ public class ECMA48 implements Runnable { csiParams.set(csiParams.size() - 1, x); } - if (ch == ';') { - csiParams.add(new Integer(0)); + if ((ch == ';') && (csiParams.size() < 16)) { + csiParams.add(Integer.valueOf(0)); } } @@ -4053,12 +4198,12 @@ public class ECMA48 implements Runnable { if (collectBuffer.charAt(0) == '>') { extendedFlag = 1; if (collectBuffer.length() >= 2) { - i = Integer.parseInt(args.toString()); + i = Integer.parseInt(args); } } else if (collectBuffer.charAt(0) == '=') { extendedFlag = 2; if (collectBuffer.length() >= 2) { - i = Integer.parseInt(args.toString()); + i = Integer.parseInt(args); } } else { // Unknown code, bail out @@ -4500,7 +4645,7 @@ public class ECMA48 implements Runnable { args = collectBuffer.substring(0, collectBuffer.length() - 2); } - String [] p = args.toString().split(";"); + String [] p = args.split(";"); if (p.length > 0) { if ((p[0].equals("0")) || (p[0].equals("2"))) { if (p.length > 1) { @@ -4527,6 +4672,62 @@ public class ECMA48 implements Runnable { } } + /** + * Handle the SCAN_SOSPMAPC_STRING state. This is currently only used by + * Jexer ECMA48Terminal to talk to ECMA48. + * + * @param pmChar the character received from the remote side + */ + private void pmPut(final char pmChar) { + // System.err.println("pmPut: " + pmChar); + + // Collect first + collectBuffer.append(pmChar); + + // Xterm cases... + if (collectBuffer.toString().endsWith("\033\\")) { + String arg = null; + arg = collectBuffer.substring(0, collectBuffer.length() - 2); + + // System.err.println("arg: '" + arg + "'"); + + if (arg.equals("hideMousePointer")) { + hideMousePointer = true; + } + if (arg.equals("showMousePointer")) { + hideMousePointer = false; + } + + // Go to SCAN_GROUND state + toGround(); + return; + } + } + + /** + * Perform xterm window operations. + */ + private void xtermWindowOps() { + boolean xtermPrivateModeFlag = false; + + for (int i = 0; i < collectBuffer.length(); i++) { + if (collectBuffer.charAt(i) == '?') { + xtermPrivateModeFlag = true; + break; + } + } + + int i = getCsiParam(0, 0); + + if (!xtermPrivateModeFlag) { + if (i == 14) { + // Report xterm window in pixels as CSI 4 ; height ; width t + writeRemote(String.format("\033[4;%d;%dt", textHeight * height, + textWidth * width)); + } + } + } + /** * Run this input character through the ECMA48 state machine. * @@ -4535,7 +4736,7 @@ public class ECMA48 implements Runnable { private void consume(char ch) { // DEBUG - // System.err.printf("%c", ch); + // System.err.printf("%c STATE = %s\n", ch, scanState); // Special case for VT10x: 7-bit characters only if ((type == DeviceType.VT100) || (type == DeviceType.VT102)) { @@ -4556,16 +4757,19 @@ public class ECMA48 implements Runnable { // 0x1B == ESCAPE if (ch == 0x1B) { if ((type == DeviceType.XTERM) - && (scanState == ScanState.OSC_STRING) + && ((scanState == ScanState.OSC_STRING) + || (scanState == ScanState.DCS_SIXEL) + || (scanState == ScanState.SOSPMAPC_STRING)) ) { // Xterm can pass ESCAPE to its OSC sequence. + // Xterm can pass ESCAPE to its DCS sequence. + // Jexer can pass ESCAPE to its PM sequence. } else if ((scanState != ScanState.DCS_ENTRY) && (scanState != ScanState.DCS_INTERMEDIATE) && (scanState != ScanState.DCS_IGNORE) && (scanState != ScanState.DCS_PARAM) && (scanState != ScanState.DCS_PASSTHROUGH) ) { - scanState = ScanState.ESCAPE; return; } @@ -5810,6 +6014,10 @@ public class ECMA48 implements Runnable { } break; case 't': + if (type == DeviceType.XTERM) { + // Window operations + xtermWindowOps(); + } break; case 'u': // Restore cursor (ANSI.SYS) @@ -6073,7 +6281,13 @@ public class ECMA48 implements Runnable { decstbm(); break; case 's': + break; case 't': + if (type == DeviceType.XTERM) { + // Window operations + xtermWindowOps(); + } + break; case 'u': case 'v': case 'w': @@ -6277,8 +6491,12 @@ public class ECMA48 implements Runnable { scanState = ScanState.DCS_IGNORE; } - // 0x40-7E goes to DCS_PASSTHROUGH - if ((ch >= 0x40) && (ch <= 0x7E)) { + // 0x71 goes to DCS_SIXEL + if (ch == 0x71) { + sixelParseBuffer = new StringBuilder(); + scanState = ScanState.DCS_SIXEL; + } else if ((ch >= 0x40) && (ch <= 0x7E)) { + // 0x40-7E goes to DCS_PASSTHROUGH scanState = ScanState.DCS_PASSTHROUGH; } return; @@ -6358,8 +6576,12 @@ public class ECMA48 implements Runnable { scanState = ScanState.DCS_IGNORE; } - // 0x40-7E goes to DCS_PASSTHROUGH - if ((ch >= 0x40) && (ch <= 0x7E)) { + // 0x71 goes to DCS_SIXEL + if (ch == 0x71) { + sixelParseBuffer = new StringBuilder(); + scanState = ScanState.DCS_SIXEL; + } else if ((ch >= 0x40) && (ch <= 0x7E)) { + // 0x40-7E goes to DCS_PASSTHROUGH scanState = ScanState.DCS_PASSTHROUGH; } return; @@ -6411,9 +6633,60 @@ public class ECMA48 implements Runnable { return; + case DCS_SIXEL: + // 0x9C goes to GROUND + if (ch == 0x9C) { + parseSixel(); + toGround(); + } + + // 0x1B 0x5C goes to GROUND + if (ch == 0x1B) { + collect(ch); + } + if (ch == 0x5C) { + if ((collectBuffer.length() > 0) + && (collectBuffer.charAt(collectBuffer.length() - 1) == 0x1B) + ) { + parseSixel(); + toGround(); + } + } + + // 00-17, 19, 1C-1F, 20-7E --> put + if (ch <= 0x17) { + sixelParseBuffer.append(ch); + return; + } + if (ch == 0x19) { + sixelParseBuffer.append(ch); + return; + } + if ((ch >= 0x1C) && (ch <= 0x1F)) { + sixelParseBuffer.append(ch); + return; + } + if ((ch >= 0x20) && (ch <= 0x7E)) { + sixelParseBuffer.append(ch); + return; + } + + // 7F --> ignore + + return; + case SOSPMAPC_STRING: // 00-17, 19, 1C-1F, 20-7F --> ignore + // Special case for Jexer: PM can pass one control character + if (ch == 0x1B) { + pmPut(ch); + } + + if ((ch >= 0x20) && (ch <= 0x7F)) { + pmPut(ch); + } + // 0x9C goes to GROUND if (ch == 0x9C) { toGround(); @@ -6477,4 +6750,185 @@ public class ECMA48 implements Runnable { return currentState.cursorY; } + /** + * Returns true if this terminal has requested the mouse pointer be + * hidden. + * + * @return true if this terminal has requested the mouse pointer be + * hidden + */ + public final boolean hasHiddenMousePointer() { + return hideMousePointer; + } + + /** + * Get the mouse protocol. + * + * @return MouseProtocol.OFF, MouseProtocol.X10, etc. + */ + public MouseProtocol getMouseProtocol() { + return mouseProtocol; + } + + // ------------------------------------------------------------------------ + // Sixel support ---------------------------------------------------------- + // ------------------------------------------------------------------------ + + /** + * Set the width of a character cell in pixels. + * + * @param textWidth the width in pixels of a character cell + */ + public void setTextWidth(final int textWidth) { + this.textWidth = textWidth; + } + + /** + * Set the height of a character cell in pixels. + * + * @param textHeight the height in pixels of a character cell + */ + public void setTextHeight(final int textHeight) { + this.textHeight = textHeight; + } + + /** + * Parse a sixel string into a bitmap image, and overlay that image onto + * the text cells. + */ + private void parseSixel() { + + /* + System.err.println("parseSixel(): '" + sixelParseBuffer.toString() + + "'"); + */ + + Sixel sixel = new Sixel(sixelParseBuffer.toString()); + BufferedImage image = sixel.getImage(); + + // System.err.println("parseSixel(): image " + image); + + if (image == null) { + // Sixel data was malformed in some way, bail out. + return; + } + + /* + * Procedure: + * + * Break up the image into text cell sized pieces as a new array of + * Cells. + * + * Note original column position x0. + * + * For each cell: + * + * 1. Advance (printCharacter(' ')) for horizontal increment, or + * index (linefeed() + cursorPosition(y, x0)) for vertical + * increment. + * + * 2. Set (x, y) cell image data. + * + * 3. For the right and bottom edges: + * + * a. Render the text to pixels using Terminus font. + * + * b. Blit the image on top of the text, using alpha channel. + */ + int cellColumns = image.getWidth() / textWidth; + if (cellColumns * textWidth < image.getWidth()) { + cellColumns++; + } + int cellRows = image.getHeight() / textHeight; + if (cellRows * textHeight < image.getHeight()) { + cellRows++; + } + + // Break the image up into an array of cells. + Cell [][] cells = new Cell[cellColumns][cellRows]; + + for (int x = 0; x < cellColumns; x++) { + for (int y = 0; y < cellRows; y++) { + + int width = textWidth; + if ((x + 1) * textWidth > image.getWidth()) { + width = image.getWidth() - (x * textWidth); + } + int height = textHeight; + if ((y + 1) * textHeight > image.getHeight()) { + height = image.getHeight() - (y * textHeight); + } + + Cell cell = new Cell(); + cell.setImage(image.getSubimage(x * textWidth, + y * textHeight, width, height)); + + cells[x][y] = cell; + } + } + + int x0 = currentState.cursorX; + for (int y = 0; y < cellRows; y++) { + for (int x = 0; x < cellColumns; x++) { + printCharacter(' '); + cursorLeft(1, false); + if ((x == cellColumns - 1) || (y == cellRows - 1)) { + // TODO: render text of current cell first, then image + // over it. For now, just copy the cell. + DisplayLine line = display.get(currentState.cursorY); + line.replace(currentState.cursorX, cells[x][y]); + } else { + // Copy the image cell into the display. + DisplayLine line = display.get(currentState.cursorY); + line.replace(currentState.cursorX, cells[x][y]); + } + cursorRight(1, false); + } + linefeed(); + cursorPosition(currentState.cursorY, x0); + } + + } + + /** + * Draw the left and right cells of a two-cell-wide (full-width) glyph. + * + * @param leftX the x position to draw the left half to + * @param leftY the y position to draw the left half to + * @param rightX the x position to draw the right half to + * @param rightY the y position to draw the right half to + * @param ch the character to draw + */ + private void drawHalves(final int leftX, final int leftY, + final int rightX, final int rightY, final char ch) { + + // System.err.println("drawHalves(): " + Integer.toHexString(ch)); + + if (lastTextHeight != textHeight) { + glyphMaker = GlyphMaker.getInstance(textHeight); + lastTextHeight = textHeight; + } + + Cell cell = new Cell(ch); + cell.setAttr(currentState.attr); + BufferedImage image = glyphMaker.getImage(cell, textWidth * 2, + textHeight); + BufferedImage leftImage = image.getSubimage(0, 0, textWidth, + textHeight); + BufferedImage rightImage = image.getSubimage(textWidth, 0, textWidth, + textHeight); + + Cell left = new Cell(); + left.setTo(cell); + left.setImage(leftImage); + left.setWidth(Cell.Width.LEFT); + display.get(leftY).replace(leftX, left); + + Cell right = new Cell(); + right.setTo(cell); + right.setImage(rightImage); + right.setWidth(Cell.Width.RIGHT); + display.get(rightY).replace(rightX, right); + } + }