*/
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.Writer;
import java.util.ArrayList;
import java.util.Collections;
+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.*;
DCS_PARAM,
DCS_PASSTHROUGH,
DCS_IGNORE,
+ DCS_SIXEL,
SOSPMAPC_STRING,
OSC_STRING,
VT52_DIRECT_CURSOR_ADDRESS
/**
* XTERM mouse reporting protocols.
*/
- private enum MouseProtocol {
+ public enum MouseProtocol {
OFF,
X10,
NORMAL,
*/
private List<Integer> 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<TInputEvent> userQueue = new ArrayList<TInputEvent>();
+
/**
* DECSC/DECRC save/restore a subset of the total state. This class
* encapsulates those specific flags/modes.
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();
// 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.
*
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()) {
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--;
+ }
}
}
}
*
* @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",
*
* @param keypress keypress received from the local user
*/
- public void keypress(final TKeypress keypress) {
+ private void keypress(final TKeypress keypress) {
writeRemote(keypressToString(keypress));
}
* 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);
}
}
+ /**
+ * 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.
*
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)) {
if (ch == 0x1B) {
if ((type == DeviceType.XTERM)
&& ((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_PARAM)
&& (scanState != ScanState.DCS_PASSTHROUGH)
) {
-
scanState = ScanState.ESCAPE;
return;
}
}
break;
case 't':
+ if (type == DeviceType.XTERM) {
+ // Window operations
+ xtermWindowOps();
+ }
break;
case 'u':
// Restore cursor (ANSI.SYS)
decstbm();
break;
case 's':
+ break;
case 't':
+ if (type == DeviceType.XTERM) {
+ // Window operations
+ xtermWindowOps();
+ }
+ break;
case 'u':
case 'v':
case 'w':
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;
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;
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
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, 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);
+ }
+
}
git://git.nikiroo.be / fanfix.git / blobdiff