X-Git-Url: http://git.nikiroo.be/?a=blobdiff_plain;f=src%2Fjexer%2Ftterminal%2FECMA48.java;h=5ff3518f3e3fb29785d55580e9377ba2855bb1fe;hb=34bb6e525628111b87a36556bbdd2719c6d7925f;hp=f2b485eca078e949b75868575b6869a05e01b4c6;hpb=5fc7bf09f3c9987287f34f9035b522b0e5e9de13;p=fanfix.git diff --git a/src/jexer/tterminal/ECMA48.java b/src/jexer/tterminal/ECMA48.java index f2b485e..5ff3518 100644 --- a/src/jexer/tterminal/ECMA48.java +++ b/src/jexer/tterminal/ECMA48.java @@ -30,7 +30,9 @@ package jexer.tterminal; import java.awt.Graphics2D; import java.awt.image.BufferedImage; +import java.io.BufferedInputStream; import java.io.BufferedOutputStream; +import java.io.ByteArrayInputStream; import java.io.CharArrayWriter; import java.io.InputStream; import java.io.InputStreamReader; @@ -45,12 +47,17 @@ import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.List; +import javax.imageio.ImageIO; 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.*; @@ -213,7 +220,7 @@ public class ECMA48 implements Runnable { /** * XTERM mouse reporting protocols. */ - private enum MouseProtocol { + public enum MouseProtocol { OFF, X10, NORMAL, @@ -252,7 +259,7 @@ public class ECMA48 implements Runnable { /** * The type of emulator to be. */ - private DeviceType type = DeviceType.VT102; + private final DeviceType type; /** * The scrollback buffer characters + attributes. @@ -319,41 +326,41 @@ public class ECMA48 implements Runnable { * Physical display width. We start at 80x24, but the user can resize us * bigger/smaller. */ - private int width; + private int width = 80; /** * Physical display height. We start at 80x24, but the user can resize * us bigger/smaller. */ - private int height; + private int height = 24; /** * Top margin of the scrolling region. */ - private int scrollRegionTop; + private int scrollRegionTop = 0; /** * Bottom margin of the scrolling region. */ - private int scrollRegionBottom; + private int scrollRegionBottom = height - 1; /** * Right margin column number. This can be selected by the remote side * to be 80/132 (rightMargin values 79/131), or it can be (width - 1). */ - private int rightMargin; + private int rightMargin = 79; /** * Last character printed. */ - private char repCh; + private int repCh; /** * VT100-style line wrapping: a character is placed in column 80 (or * 132), but the line does NOT wrap until another character is written to * column 1 of the next line, after which the cursor moves to column 2. */ - private boolean wrapLineFlag; + private boolean wrapLineFlag = false; /** * VT220 single shift flag. @@ -390,7 +397,7 @@ public class ECMA48 implements Runnable { /** * Non-csi collect buffer. */ - private StringBuilder collectBuffer; + private StringBuilder collectBuffer = new StringBuilder(128); /** * When true, use the G1 character set. @@ -465,7 +472,12 @@ public class ECMA48 implements Runnable { /** * Sixel collection buffer. */ - private StringBuilder sixelParseBuffer; + private StringBuilder sixelParseBuffer = new StringBuilder(2048); + + /** + * Sixel shared palette. + */ + private HashMap sixelPalette; /** * The width of a character cell in pixels. @@ -477,6 +489,23 @@ public class ECMA48 implements Runnable { */ 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. @@ -629,7 +658,8 @@ public class ECMA48 implements Runnable { this.inputStream = new TimeoutInputStream(inputStream, 2000); } if (type == DeviceType.XTERM) { - this.input = new InputStreamReader(this.inputStream, "UTF-8"); + this.input = new InputStreamReader(new BufferedInputStream( + this.inputStream, 1024 * 128), "UTF-8"); this.output = new OutputStreamWriter(new BufferedOutputStream(outputStream), "UTF-8"); this.outputStream = null; @@ -643,6 +673,8 @@ public class ECMA48 implements Runnable { for (int i = 0; i < height; i++) { display.add(new DisplayLine(currentState.attr)); } + assert (currentState.cursorY < height); + assert (currentState.cursorX < width); // Spin up the input reader readerThread = new Thread(this); @@ -669,12 +701,18 @@ public class ECMA48 implements Runnable { char [] readBufferUTF8 = null; byte [] readBuffer = null; if (utf8) { - readBufferUTF8 = new char[128]; + readBufferUTF8 = new char[2048]; } else { - readBuffer = new byte[128]; + readBuffer = new byte[2048]; } while (!done && !stopReaderThread) { + synchronized (userQueue) { + while (userQueue.size() > 0) { + handleUserEvent(userQueue.remove(0)); + } + } + try { int n = inputStream.available(); @@ -696,7 +734,7 @@ public class ECMA48 implements Runnable { } if (n == 0) { try { - Thread.sleep(2); + Thread.sleep(10); } catch (InterruptedException e) { // SQUASH } @@ -723,15 +761,34 @@ public class ECMA48 implements Runnable { } else { // Don't step on UI events synchronized (this) { - for (int i = 0; i < rc; i++) { - int ch = 0; - if (utf8) { - ch = readBufferUTF8[i]; - } else { - ch = readBuffer[i]; + if (utf8) { + for (int i = 0; i < rc;) { + int ch = Character.codePointAt(readBufferUTF8, + i); + i += Character.charCount(ch); + + // Special case for VT10x: 7-bit characters + // only. + if ((type == DeviceType.VT100) + || (type == DeviceType.VT102) + ) { + consume(ch & 0x7F); + } else { + consume(ch); + } + } + } else { + for (int i = 0; i < rc; i++) { + // Special case for VT10x: 7-bit characters + // only. + if ((type == DeviceType.VT100) + || (type == DeviceType.VT102) + ) { + consume(readBuffer[i] & 0x7F); + } else { + consume(readBuffer[i]); + } } - - consume((char) ch); } } // Permit my enclosing UI to know that I updated. @@ -797,6 +854,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. * @@ -815,12 +897,14 @@ public class ECMA48 implements Runnable { case VT220: case XTERM: - // "I am a VT220" - 7 bit version + // "I am a VT220" - 7 bit version, with sixel and Jexer image + // support. if (!s8c1t) { - return "\033[?62;1;6c"; + return "\033[?62;1;6;9;4;22;444c"; } - // "I am a VT220" - 8 bit version - return "\u009b?62;1;6c"; + // "I am a VT220" - 8 bit version, with sixel and Jexer image + // support. + return "\u009b?62;1;6;9;4;22;444c"; default: throw new IllegalArgumentException("Invalid device type: " + type); } @@ -1024,6 +1108,64 @@ public class ECMA48 implements Runnable { return display; } + /** + * Get the visible display + scrollback buffer, offset by a specified + * number of rows from the bottom. + * + * @param visibleHeight the total height of the display to show + * @param scrollBottom the number of rows from the bottom to scroll back + * @return a copy of the display + scrollback buffers + */ + public final List getVisibleDisplay(final int visibleHeight, + final int scrollBottom) { + + assert (visibleHeight >= 0); + assert (scrollBottom >= 0); + + int visibleBottom = scrollback.size() + display.size() - scrollBottom; + + List preceedingBlankLines = new ArrayList(); + int visibleTop = visibleBottom - visibleHeight; + if (visibleTop < 0) { + for (int i = visibleTop; i < 0; i++) { + preceedingBlankLines.add(getBlankDisplayLine()); + } + visibleTop = 0; + } + assert (visibleTop >= 0); + + List displayLines = new ArrayList(); + displayLines.addAll(scrollback); + displayLines.addAll(display); + + List visibleLines = new ArrayList(); + visibleLines.addAll(preceedingBlankLines); + visibleLines.addAll(displayLines.subList(visibleTop, visibleBottom)); + + // Fill in the blank lines on bottom + int bottomBlankLines = visibleHeight - visibleLines.size(); + assert (bottomBlankLines >= 0); + for (int i = 0; i < bottomBlankLines; i++) { + visibleLines.add(getBlankDisplayLine()); + } + + return copyBuffer(visibleLines); + } + + /** + * Copy a display buffer. + * + * @param buffer the buffer to copy + * @return a deep copy of the buffer's data + */ + private List copyBuffer(final List buffer) { + ArrayList result = new ArrayList(buffer.size()); + for (DisplayLine line: buffer) { + result.add(new DisplayLine(line)); + } + return result; + } + /** * Get the display width. * @@ -1038,7 +1180,7 @@ public class ECMA48 implements Runnable { * * @param width the new width */ - public final void setWidth(final int width) { + public final synchronized void setWidth(final int width) { this.width = width; rightMargin = width - 1; if (currentState.cursorX >= width) { @@ -1063,12 +1205,12 @@ public class ECMA48 implements Runnable { * * @param height the new height */ - public final void setHeight(final int height) { + public final synchronized void setHeight(final int height) { int delta = height - this.height; this.height = height; scrollRegionBottom += delta; - if (scrollRegionBottom < 0) { - scrollRegionBottom = height; + if ((scrollRegionBottom < 0) || (scrollRegionTop > height - 1)) { + scrollRegionBottom = height - 1; } if (scrollRegionTop >= scrollRegionBottom) { scrollRegionTop = 0; @@ -1123,7 +1265,7 @@ public class ECMA48 implements Runnable { */ private void toGround() { csiParams.clear(); - collectBuffer = new StringBuilder(8); + collectBuffer.setLength(0); scanState = ScanState.GROUND; } @@ -1238,8 +1380,13 @@ public class ECMA48 implements Runnable { currentState = new SaveableState(); savedState = new SaveableState(); scanState = ScanState.GROUND; - width = 80; - height = 24; + if (displayListener != null) { + width = displayListener.getDisplayWidth(); + height = displayListener.getDisplayHeight(); + } else { + width = 80; + height = 24; + } scrollRegionTop = 0; scrollRegionBottom = height - 1; rightMargin = width - 1; @@ -1247,11 +1394,6 @@ public class ECMA48 implements Runnable { arrowKeyMode = ArrowKeyMode.ANSI; keypadMode = KeypadMode.Numeric; wrapLineFlag = false; - if (displayListener != null) { - width = displayListener.getDisplayWidth(); - height = displayListener.getDisplayHeight(); - rightMargin = width - 1; - } // Flags shiftOut = false; @@ -1334,7 +1476,6 @@ public class ECMA48 implements Runnable { * Handle a linefeed. */ private void linefeed() { - if (currentState.cursorY < scrollRegionBottom) { // Increment screen y currentState.cursorY++; @@ -1374,9 +1515,38 @@ public class ECMA48 implements Runnable { * * @param ch character to display */ - private void printCharacter(final char ch) { + private void printCharacter(final int 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()) { @@ -1427,19 +1597,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--; + } } } } @@ -1450,7 +1623,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", @@ -1598,7 +1771,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)); } @@ -1657,11 +1830,14 @@ public class ECMA48 implements Runnable { * the remote side. */ if (keypress.getChar() < 0x20) { - handleControlChar(keypress.getChar()); + handleControlChar((char) keypress.getChar()); } else { // Local echo for everything else printCharacter(keypress.getChar()); } + if (displayListener != null) { + displayListener.displayChanged(); + } } if ((newLineMode == true) && (keypress.equals(kbEnter))) { @@ -1672,17 +1848,17 @@ public class ECMA48 implements Runnable { // Handle control characters if ((keypress.isCtrl()) && (!keypress.isFnKey())) { StringBuilder sb = new StringBuilder(); - char ch = keypress.getChar(); + int ch = keypress.getChar(); ch -= 0x40; - sb.append(ch); + sb.append(Character.toChars(ch)); return sb.toString(); } // Handle alt characters if ((keypress.isAlt()) && (!keypress.isFnKey())) { StringBuilder sb = new StringBuilder("\033"); - char ch = keypress.getChar(); - sb.append(ch); + int ch = keypress.getChar(); + sb.append(Character.toChars(ch)); return sb.toString(); } @@ -2234,7 +2410,7 @@ public class ECMA48 implements Runnable { // Non-alt, non-ctrl characters if (!keypress.isFnKey()) { StringBuilder sb = new StringBuilder(); - sb.append(keypress.getChar()); + sb.append(Character.toChars(keypress.getChar())); return sb.toString(); } return ""; @@ -2249,7 +2425,7 @@ public class ECMA48 implements Runnable { * @param charsetGr character set defined for GR * @return character to display on the screen */ - private char mapCharacterCharset(final char ch, + private char mapCharacterCharset(final int ch, final CharacterSet charsetGl, final CharacterSet charsetGr) { @@ -2327,7 +2503,7 @@ public class ECMA48 implements Runnable { * @param ch either 8-bit or Unicode character from the remote side * @return character to display on the screen */ - private char mapCharacter(final char ch) { + private int mapCharacter(final int ch) { if (ch >= 0x100) { // Unicode character, just return it return ch; @@ -2730,6 +2906,7 @@ public class ECMA48 implements Runnable { */ private void setToggle(final boolean value) { boolean decPrivateModeFlag = false; + for (int i = 0; i < collectBuffer.length(); i++) { if (collectBuffer.charAt(i) == '?') { decPrivateModeFlag = true; @@ -2996,6 +3173,21 @@ public class ECMA48 implements Runnable { break; + case 80: + if (type == DeviceType.XTERM) { + if (decPrivateModeFlag == true) { + if (value == true) { + // Enable sixel scrolling (default). + // TODO + } else { + // Disable sixel scrolling. + // TODO + } + } + } + + break; + case 1000: if ((type == DeviceType.XTERM) && (decPrivateModeFlag == true) @@ -3061,6 +3253,22 @@ public class ECMA48 implements Runnable { } break; + case 1070: + if (type == DeviceType.XTERM) { + if (decPrivateModeFlag == true) { + if (value == true) { + // Use private color registers for each sixel + // graphic (default). + sixelPalette = null; + } else { + // Use shared color registers for each sixel + // graphic. + sixelPalette = new HashMap(); + } + } + } + break; + default: break; @@ -3374,8 +3582,7 @@ public class ECMA48 implements Runnable { * DECALN - Screen alignment display. */ private void decaln() { - Cell newCell = new Cell(); - newCell.setChar('E'); + Cell newCell = new Cell('E'); for (DisplayLine line: display) { for (int i = 0; i < line.length(); i++) { line.replace(i, newCell); @@ -4194,6 +4401,9 @@ public class ECMA48 implements Runnable { // DECSTBM int top = getCsiParam(0, 1, 1, height) - 1; int bottom = getCsiParam(1, height, 1, height) - 1; + if (bottom > height - 1) { + bottom = height - 1; + } if (top > bottom) { top = bottom; @@ -4580,6 +4790,45 @@ public class ECMA48 implements Runnable { } } } + + if (p[0].equals("10")) { + if (p[1].equals("?")) { + // Respond with foreground color. + java.awt.Color color = jexer.backend.SwingTerminal.attrToForegroundColor(currentState.attr); + + writeRemote(String.format( + "\033]10;rgb:%04x/%04x/%04x\033\\", + color.getRed() << 8, + color.getGreen() << 8, + color.getBlue() << 8)); + } + } + + if (p[0].equals("11")) { + if (p[1].equals("?")) { + // Respond with background color. + java.awt.Color color = jexer.backend.SwingTerminal.attrToBackgroundColor(currentState.attr); + + writeRemote(String.format( + "\033]11;rgb:%04x/%04x/%04x\033\\", + color.getRed() << 8, + color.getGreen() << 8, + color.getBlue() << 8)); + } + } + + if (p[0].equals("444")) { + if (p[1].equals("0") && (p.length == 6)) { + // Jexer image - RGB + parseJexerImageRGB(p[2], p[3], p[4], p[5]); + } else if (p[1].equals("1") && (p.length == 4)) { + // Jexer image - PNG + parseJexerImageFile(1, p[2], p[3]); + } else if (p[1].equals("2") && (p.length == 4)) { + // Jexer image - JPG + parseJexerImageFile(2, p[2], p[3]); + } + } } // Go to SCAN_GROUND state @@ -4620,21 +4869,79 @@ public class ECMA48 implements Runnable { } } + /** + * 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) { + switch (i) { + case 14: + // Report xterm text area size in pixels as CSI 4 ; height ; + // width t + writeRemote(String.format("\033[4;%d;%dt", textHeight * height, + textWidth * width)); + break; + case 16: + // Report character size in pixels as CSI 6 ; height ; width + // t + writeRemote(String.format("\033[6;%d;%dt", textHeight, + textWidth)); + break; + case 18: + // Report the text are size in characters as CSI 8 ; height ; + // width t + writeRemote(String.format("\033[8;%d;%dt", height, width)); + break; + default: + break; + } + } + } + + /** + * Respond to xterm sixel query. + */ + private void xtermSixelQuery() { + int item = getCsiParam(0, 0); + int action = getCsiParam(1, 0); + int value = getCsiParam(2, 0); + + switch (item) { + case 1: + if (action == 1) { + // Report number of color registers. + writeRemote(String.format("\033[?%d;%d;%dS", item, 0, 1024)); + return; + } + break; + default: + break; + } + // We will not support this option. + writeRemote(String.format("\033[?%d;%dS", item, action)); + } + /** * Run this input character through the ECMA48 state machine. * * @param ch character from the remote side */ - private void consume(char ch) { + private void consume(final int ch) { // DEBUG // System.err.printf("%c STATE = %s\n", ch, scanState); - // Special case for VT10x: 7-bit characters only - if ((type == DeviceType.VT100) || (type == DeviceType.VT102)) { - ch = (char)(ch & 0x7F); - } - // Special "anywhere" states // 18, 1A --> execute, then switch to SCAN_GROUND @@ -4702,7 +5009,7 @@ public class ECMA48 implements Runnable { // 00-17, 19, 1C-1F --> execute // 80-8F, 91-9A, 9C --> execute if ((ch <= 0x1F) || ((ch >= 0x80) && (ch <= 0x9F))) { - handleControlChar(ch); + handleControlChar((char) ch); } // 20-7F --> print @@ -4729,13 +5036,13 @@ public class ECMA48 implements Runnable { case ESCAPE: // 00-17, 19, 1C-1F --> execute if (ch <= 0x1F) { - handleControlChar(ch); + handleControlChar((char) ch); return; } // 20-2F --> collect, then switch to ESCAPE_INTERMEDIATE if ((ch >= 0x20) && (ch <= 0x2F)) { - collect(ch); + collect((char) ch); scanState = ScanState.ESCAPE_INTERMEDIATE; return; } @@ -5071,12 +5378,12 @@ public class ECMA48 implements Runnable { case ESCAPE_INTERMEDIATE: // 00-17, 19, 1C-1F --> execute if (ch <= 0x1F) { - handleControlChar(ch); + handleControlChar((char) ch); } // 20-2F --> collect if ((ch >= 0x20) && (ch <= 0x2F)) { - collect(ch); + collect((char) ch); } // 30-7E --> dispatch, then switch to GROUND @@ -5678,12 +5985,12 @@ public class ECMA48 implements Runnable { case CSI_ENTRY: // 00-17, 19, 1C-1F --> execute if (ch <= 0x1F) { - handleControlChar(ch); + handleControlChar((char) ch); } // 20-2F --> collect, then switch to CSI_INTERMEDIATE if ((ch >= 0x20) && (ch <= 0x2F)) { - collect(ch); + collect((char) ch); scanState = ScanState.CSI_INTERMEDIATE; } @@ -5699,7 +6006,7 @@ public class ECMA48 implements Runnable { // 3C-3F --> collect, then switch to CSI_PARAM if ((ch >= 0x3C) && (ch <= 0x3F)) { - collect(ch); + collect((char) ch); scanState = ScanState.CSI_PARAM; } @@ -5783,7 +6090,18 @@ public class ECMA48 implements Runnable { case 'S': // Scroll up X lines (default 1) if (type == DeviceType.XTERM) { - su(); + boolean xtermPrivateModeFlag = false; + for (int i = 0; i < collectBuffer.length(); i++) { + if (collectBuffer.charAt(i) == '?') { + xtermPrivateModeFlag = true; + break; + } + } + if (xtermPrivateModeFlag) { + xtermSixelQuery(); + } else { + su(); + } } break; case 'T': @@ -5906,6 +6224,10 @@ public class ECMA48 implements Runnable { } break; case 't': + if (type == DeviceType.XTERM) { + // Window operations + xtermWindowOps(); + } break; case 'u': // Restore cursor (ANSI.SYS) @@ -5947,12 +6269,12 @@ public class ECMA48 implements Runnable { case CSI_PARAM: // 00-17, 19, 1C-1F --> execute if (ch <= 0x1F) { - handleControlChar(ch); + handleControlChar((char) ch); } // 20-2F --> collect, then switch to CSI_INTERMEDIATE if ((ch >= 0x20) && (ch <= 0x2F)) { - collect(ch); + collect((char) ch); scanState = ScanState.CSI_INTERMEDIATE; } @@ -6053,7 +6375,18 @@ public class ECMA48 implements Runnable { case 'S': // Scroll up X lines (default 1) if (type == DeviceType.XTERM) { - su(); + boolean xtermPrivateModeFlag = false; + for (int i = 0; i < collectBuffer.length(); i++) { + if (collectBuffer.charAt(i) == '?') { + xtermPrivateModeFlag = true; + break; + } + } + if (xtermPrivateModeFlag) { + xtermSixelQuery(); + } else { + su(); + } } break; case 'T': @@ -6169,7 +6502,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': @@ -6195,12 +6534,12 @@ public class ECMA48 implements Runnable { case CSI_INTERMEDIATE: // 00-17, 19, 1C-1F --> execute if (ch <= 0x1F) { - handleControlChar(ch); + handleControlChar((char) ch); } // 20-2F --> collect if ((ch >= 0x20) && (ch <= 0x2F)) { - collect(ch); + collect((char) ch); } // 0x30-3F goes to CSI_IGNORE @@ -6308,12 +6647,12 @@ public class ECMA48 implements Runnable { case CSI_IGNORE: // 00-17, 19, 1C-1F --> execute if (ch <= 0x1F) { - handleControlChar(ch); + handleControlChar((char) ch); } // 20-2F --> collect if ((ch >= 0x20) && (ch <= 0x2F)) { - collect(ch); + collect((char) ch); } // 40-7E --> ignore, then switch to GROUND @@ -6334,7 +6673,7 @@ public class ECMA48 implements Runnable { // 0x1B 0x5C goes to GROUND if (ch == 0x1B) { - collect(ch); + collect((char) ch); } if (ch == 0x5C) { if ((collectBuffer.length() > 0) @@ -6346,7 +6685,7 @@ public class ECMA48 implements Runnable { // 20-2F --> collect, then switch to DCS_INTERMEDIATE if ((ch >= 0x20) && (ch <= 0x2F)) { - collect(ch); + collect((char) ch); scanState = ScanState.DCS_INTERMEDIATE; } @@ -6362,7 +6701,7 @@ public class ECMA48 implements Runnable { // 3C-3F --> collect, then switch to DCS_PARAM if ((ch >= 0x3C) && (ch <= 0x3F)) { - collect(ch); + collect((char) ch); scanState = ScanState.DCS_PARAM; } @@ -6375,7 +6714,7 @@ public class ECMA48 implements Runnable { // 0x71 goes to DCS_SIXEL if (ch == 0x71) { - sixelParseBuffer = new StringBuilder(); + sixelParseBuffer.setLength(0); scanState = ScanState.DCS_SIXEL; } else if ((ch >= 0x40) && (ch <= 0x7E)) { // 0x40-7E goes to DCS_PASSTHROUGH @@ -6392,7 +6731,7 @@ public class ECMA48 implements Runnable { // 0x1B 0x5C goes to GROUND if (ch == 0x1B) { - collect(ch); + collect((char) ch); } if (ch == 0x5C) { if ((collectBuffer.length() > 0) @@ -6424,7 +6763,7 @@ public class ECMA48 implements Runnable { // 0x1B 0x5C goes to GROUND if (ch == 0x1B) { - collect(ch); + collect((char) ch); } if (ch == 0x5C) { if ((collectBuffer.length() > 0) @@ -6436,7 +6775,7 @@ public class ECMA48 implements Runnable { // 20-2F --> collect, then switch to DCS_INTERMEDIATE if ((ch >= 0x20) && (ch <= 0x2F)) { - collect(ch); + collect((char) ch); scanState = ScanState.DCS_INTERMEDIATE; } @@ -6460,7 +6799,7 @@ public class ECMA48 implements Runnable { // 0x71 goes to DCS_SIXEL if (ch == 0x71) { - sixelParseBuffer = new StringBuilder(); + sixelParseBuffer.setLength(0); scanState = ScanState.DCS_SIXEL; } else if ((ch >= 0x40) && (ch <= 0x7E)) { // 0x40-7E goes to DCS_PASSTHROUGH @@ -6476,7 +6815,7 @@ public class ECMA48 implements Runnable { // 0x1B 0x5C goes to GROUND if (ch == 0x1B) { - collect(ch); + collect((char) ch); } if (ch == 0x5C) { if ((collectBuffer.length() > 0) @@ -6487,17 +6826,20 @@ public class ECMA48 implements Runnable { } // 00-17, 19, 1C-1F, 20-7E --> put - // TODO if (ch <= 0x17) { + // We ignore all DCS except sixel. return; } if (ch == 0x19) { + // We ignore all DCS except sixel. return; } if ((ch >= 0x1C) && (ch <= 0x1F)) { + // We ignore all DCS except sixel. return; } if ((ch >= 0x20) && (ch <= 0x7E)) { + // We ignore all DCS except sixel. return; } @@ -6520,11 +6862,13 @@ public class ECMA48 implements Runnable { if (ch == 0x9C) { parseSixel(); toGround(); + return; } // 0x1B 0x5C goes to GROUND if (ch == 0x1B) { - collect(ch); + collect((char) ch); + return; } if (ch == 0x5C) { if ((collectBuffer.length() > 0) @@ -6532,29 +6876,20 @@ public class ECMA48 implements Runnable { ) { parseSixel(); toGround(); + return; } } // 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; + if ((ch <= 0x17) + || (ch == 0x19) + || ((ch >= 0x1C) && (ch <= 0x1F)) + || ((ch >= 0x20) && (ch <= 0x7E)) + ) { + sixelParseBuffer.append((char) ch); } // 7F --> ignore - return; case SOSPMAPC_STRING: @@ -6562,11 +6897,11 @@ public class ECMA48 implements Runnable { // Special case for Jexer: PM can pass one control character if (ch == 0x1B) { - pmPut(ch); + pmPut((char) ch); } if ((ch >= 0x20) && (ch <= 0x7F)) { - pmPut(ch); + pmPut((char) ch); } // 0x9C goes to GROUND @@ -6579,14 +6914,14 @@ public class ECMA48 implements Runnable { case OSC_STRING: // Special case for Xterm: OSC can pass control characters if ((ch == 0x9C) || (ch == 0x07) || (ch == 0x1B)) { - oscPut(ch); + oscPut((char) ch); } // 00-17, 19, 1C-1F --> ignore // 20-7F --> osc_put if ((ch >= 0x20) && (ch <= 0x7F)) { - oscPut(ch); + oscPut((char) ch); } // 0x9C goes to GROUND @@ -6599,7 +6934,7 @@ public class ECMA48 implements Runnable { case VT52_DIRECT_CURSOR_ADDRESS: // This is a special case for the VT52 sequence "ESC Y l c" if (collectBuffer.length() == 0) { - collect(ch); + collect((char) ch); } else if (collectBuffer.length() == 1) { // We've got the two characters, one in the buffer and the // other in ch. @@ -6643,9 +6978,52 @@ public class ECMA48 implements Runnable { return hideMousePointer; } - // ------------------------------------------------------------------------ - // Sixel support ---------------------------------------------------------- - // ------------------------------------------------------------------------ + /** + * Get the mouse protocol. + * + * @return MouseProtocol.OFF, MouseProtocol.X10, etc. + */ + public MouseProtocol getMouseProtocol() { + return mouseProtocol; + } + + /** + * 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 int ch) { + + // System.err.println("drawHalves(): " + Integer.toHexString(ch)); + + if (lastTextHeight != textHeight) { + glyphMaker = GlyphMaker.getInstance(textHeight); + lastTextHeight = textHeight; + } + + Cell cell = new Cell(ch, 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(cell); + left.setImage(leftImage); + left.setWidth(Cell.Width.LEFT); + display.get(leftY).replace(leftX, left); + + Cell right = new Cell(cell); + right.setImage(rightImage); + right.setWidth(Cell.Width.RIGHT); + display.get(rightY).replace(rightX, right); + } /** * Set the width of a character cell in pixels. @@ -6670,18 +7048,182 @@ public class ECMA48 implements Runnable { * the text cells. */ private void parseSixel() { - System.err.println("parseSixel(): '" + sixelParseBuffer.toString() + - "'"); - Sixel sixel = new Sixel(sixelParseBuffer.toString()); + /* + System.err.println("parseSixel(): '" + sixelParseBuffer.toString() + + "'"); + */ + + Sixel sixel = new Sixel(sixelParseBuffer.toString(), sixelPalette); BufferedImage image = sixel.getImage(); - System.err.println("parseSixel(): image " + image); + // System.err.println("parseSixel(): image " + image); if (image == null) { // Sixel data was malformed in some way, bail out. return; } + if ((image.getWidth() < 1) + || (image.getWidth() > 10000) + || (image.getHeight() < 1) + || (image.getHeight() > 10000) + ) { + return; + } + + imageToCells(image, true); + } + + /** + * Parse a "Jexer" RGB image string into a bitmap image, and overlay that + * image onto the text cells. + * + * @param pw width token + * @param ph height token + * @param ps scroll token + * @param data pixel data + */ + private void parseJexerImageRGB(final String pw, final String ph, + final String ps, final String data) { + + int imageWidth = 0; + int imageHeight = 0; + boolean scroll = false; + try { + imageWidth = Integer.parseInt(pw); + imageHeight = Integer.parseInt(ph); + } catch (NumberFormatException e) { + // SQUASH + return; + } + if ((imageWidth < 1) + || (imageWidth > 10000) + || (imageHeight < 1) + || (imageHeight > 10000) + ) { + return; + } + if (ps.equals("1")) { + scroll = true; + } else if (ps.equals("0")) { + scroll = false; + } else { + return; + } + + byte [] bytes = StringUtils.fromBase64(data.getBytes()); + if (bytes.length != (imageWidth * imageHeight * 3)) { + return; + } + + BufferedImage image = new BufferedImage(imageWidth, imageHeight, + BufferedImage.TYPE_INT_ARGB); + + for (int x = 0; x < imageWidth; x++) { + for (int y = 0; y < imageHeight; y++) { + int red = bytes[(y * imageWidth * 3) + (x * 3) ]; + if (red < 0) { + red += 256; + } + int green = bytes[(y * imageWidth * 3) + (x * 3) + 1]; + if (green < 0) { + green += 256; + } + int blue = bytes[(y * imageWidth * 3) + (x * 3) + 2]; + if (blue < 0) { + blue += 256; + } + int rgb = 0xFF000000 | (red << 16) | (green << 8) | blue; + image.setRGB(x, y, rgb); + } + } + + imageToCells(image, scroll); + } + + /** + * Parse a "Jexer" PNG or JPG image string into a bitmap image, and + * overlay that image onto the text cells. + * + * @param type 1 for PNG, 2 for JPG + * @param ps scroll token + * @param data pixel data + */ + private void parseJexerImageFile(final int type, final String ps, + final String data) { + + int imageWidth = 0; + int imageHeight = 0; + boolean scroll = false; + BufferedImage image = null; + try { + byte [] bytes = StringUtils.fromBase64(data.getBytes()); + + switch (type) { + case 1: + if ((bytes[0] != (byte) 0x89) + || (bytes[1] != 'P') + || (bytes[2] != 'N') + || (bytes[3] != 'G') + || (bytes[4] != (byte) 0x0D) + || (bytes[5] != (byte) 0x0A) + || (bytes[6] != (byte) 0x1A) + || (bytes[7] != (byte) 0x0A) + ) { + // File does not have PNG header, bail out. + return; + } + break; + + case 2: + if ((bytes[0] != (byte) 0XFF) + || (bytes[1] != (byte) 0xD8) + || (bytes[2] != (byte) 0xFF) + ) { + // File does not have JPG header, bail out. + return; + } + break; + + default: + // Unsupported type, bail out. + return; + } + + image = ImageIO.read(new ByteArrayInputStream(bytes)); + } catch (IOException e) { + // SQUASH + return; + } + assert (image != null); + imageWidth = image.getWidth(); + imageHeight = image.getHeight(); + if ((imageWidth < 1) + || (imageWidth > 10000) + || (imageHeight < 1) + || (imageHeight > 10000) + ) { + return; + } + if (ps.equals("1")) { + scroll = true; + } else if (ps.equals("0")) { + scroll = false; + } else { + return; + } + + imageToCells(image, scroll); + } + + /** + * Break up an image into the cells at the current cursor. + * + * @param image the image to display + * @param scroll if true, scroll the image and move the cursor + */ + private void imageToCells(final BufferedImage image, final boolean scroll) { + assert (image != null); /* * Procedure: @@ -6738,26 +7280,42 @@ public class ECMA48 implements Runnable { } int x0 = currentState.cursorX; + int y0 = currentState.cursorY; 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]); + assert (currentState.cursorX <= rightMargin); + + // TODO: Render text of current cell first, then image over + // it (accounting for blank pixels). For now, just copy the + // cell. + DisplayLine line = display.get(currentState.cursorY); + line.replace(currentState.cursorX, cells[x][y]); + + // If at the end of the visible screen, stop. + if (currentState.cursorX == rightMargin) { + break; } - cursorRight(1, false); + // Room for more image on the visible screen. + currentState.cursorX++; } - linefeed(); + if (currentState.cursorY < scrollRegionBottom - 1) { + // Not at the bottom, down a line. + linefeed(); + } else if (scroll == true) { + // At the bottom, scroll as needed. + linefeed(); + } else { + // At the bottom, no more scrolling, done. + break; + } + cursorPosition(currentState.cursorY, x0); } + if (scroll == false) { + cursorPosition(y0, x0); + } + } }