Refactor glyph code out
[fanfix.git] / src / jexer / TTerminalWindow.java
index a624e6c50574709fe4acd969184c62a5d6dc76ae..c7456358df7193db8d8be27481ecac6133e863a5 100644 (file)
  */
 package jexer;
 
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.Graphics2D;
+import java.awt.image.BufferedImage;
+
+import java.io.InputStream;
 import java.io.IOException;
 import java.lang.reflect.Field;
 import java.text.MessageFormat;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.ResourceBundle;
 
+import jexer.backend.ECMA48Terminal;
+import jexer.backend.GlyphMaker;
+import jexer.backend.MultiScreen;
+import jexer.backend.SwingTerminal;
 import jexer.bits.Cell;
 import jexer.bits.CellAttributes;
 import jexer.event.TKeypressEvent;
@@ -54,7 +65,6 @@ import static jexer.TKeypress.*;
 public class TTerminalWindow extends TScrollableWindow
                              implements DisplayListener {
 
-
     /**
      * Translated strings.
      */
@@ -86,6 +96,33 @@ public class TTerminalWindow extends TScrollableWindow
      */
     private boolean closeOnExit = false;
 
+    /**
+     * Double-height font.
+     */
+    private GlyphMaker doubleFont;
+
+    /**
+     * Last text width value.
+     */
+    private int lastTextWidth = -1;
+
+    /**
+     * Last text height value.
+     */
+    private int lastTextHeight = -1;
+
+    /**
+     * The blink state, used only by ECMA48 backend and when double-width
+     * chars must be drawn.
+     */
+    private boolean blinkState = true;
+
+    /**
+     * Timer flag, used only by ECMA48 backend and when double-width chars
+     * must be drawn.
+     */
+    private boolean haveTimer = false;
+
     // ------------------------------------------------------------------------
     // Constructors -----------------------------------------------------------
     // ------------------------------------------------------------------------
@@ -101,7 +138,7 @@ public class TTerminalWindow extends TScrollableWindow
     public TTerminalWindow(final TApplication application, final int x,
         final int y, final String commandLine) {
 
-        this(application, x, y, RESIZABLE, commandLine.split("\\s"),
+        this(application, x, y, RESIZABLE, commandLine.split("\\s+"),
             System.getProperty("jexer.TTerminal.closeOnExit",
                 "false").equals("true"));
     }
@@ -118,7 +155,7 @@ public class TTerminalWindow extends TScrollableWindow
     public TTerminalWindow(final TApplication application, final int x,
         final int y, final String commandLine, final boolean closeOnExit) {
 
-        this(application, x, y, RESIZABLE, commandLine.split("\\s"),
+        this(application, x, y, RESIZABLE, commandLine.split("\\s+"),
             closeOnExit);
     }
 
@@ -247,16 +284,16 @@ public class TTerminalWindow extends TScrollableWindow
                 equals("true"))
         ) {
             ptypipe = true;
-            spawnShell(cmdShellPtypipe.split("\\s"));
+            spawnShell(cmdShellPtypipe.split("\\s+"));
         } else if (System.getProperty("os.name").startsWith("Windows")) {
-            spawnShell(cmdShellWindows.split("\\s"));
+            spawnShell(cmdShellWindows.split("\\s+"));
         } else if (System.getProperty("os.name").startsWith("Mac")) {
-            spawnShell(cmdShellBSD.split("\\s"));
+            spawnShell(cmdShellBSD.split("\\s+"));
         } else if (System.getProperty("os.name").startsWith("Linux")) {
-            spawnShell(cmdShellGNU.split("\\s"));
+            spawnShell(cmdShellGNU.split("\\s+"));
         } else {
             // When all else fails, assume GNU.
-            spawnShell(cmdShellGNU.split("\\s"));
+            spawnShell(cmdShellGNU.split("\\s+"));
         }
     }
 
@@ -341,8 +378,7 @@ public class TTerminalWindow extends TScrollableWindow
                         }
                     }
                     if (line.isDoubleWidth()) {
-                        putCharXY((i * 2) + 1, row, newCell);
-                        putCharXY((i * 2) + 2, row, ' ', newCell);
+                        putDoubleWidthCharXY(line, (i * 2) + 1, row, newCell);
                     } else {
                         putCharXY(i + 1, row, newCell);
                     }
@@ -493,13 +529,17 @@ public class TTerminalWindow extends TScrollableWindow
             return;
         }
 
-        if (mouse.isMouseWheelUp()) {
-            verticalDecrement();
-            return;
-        }
-        if (mouse.isMouseWheelDown()) {
-            verticalIncrement();
-            return;
+        // If the emulator is tracking mouse buttons, it needs to see wheel
+        // events.
+        if (emulator.getMouseProtocol() == ECMA48.MouseProtocol.OFF) {
+            if (mouse.isMouseWheelUp()) {
+                verticalDecrement();
+                return;
+            }
+            if (mouse.isMouseWheelDown()) {
+                verticalIncrement();
+                return;
+            }
         }
         if (mouseOnEmulator(mouse)) {
             synchronized (emulator) {
@@ -704,6 +744,10 @@ public class TTerminalWindow extends TScrollableWindow
 
         // Add shortcut text
         newStatusBar(i18n.getString("statusBarRunning"));
+
+        // Pass the correct text cell width/height to the emulator
+        emulator.setTextWidth(getScreen().getTextWidth());
+        emulator.setTextHeight(getScreen().getTextHeight());
     }
 
     /**
@@ -788,6 +832,7 @@ public class TTerminalWindow extends TScrollableWindow
         // Synchronize against the emulator so we don't stomp on its reader
         // thread.
         synchronized (emulator) {
+            setHiddenMouse(emulator.hasHiddenMousePointer());
 
             setCursorX(emulator.getCursorX() + 1);
             setCursorY(emulator.getCursorY() + 1
@@ -853,7 +898,7 @@ public class TTerminalWindow extends TScrollableWindow
      * @param mouse a mouse-based event
      * @return whether or not the mouse is on the emulator
      */
-    private final boolean mouseOnEmulator(final TMouseEvent mouse) {
+    private boolean mouseOnEmulator(final TMouseEvent mouse) {
 
         synchronized (emulator) {
             if (!emulator.isReading()) {
@@ -871,4 +916,141 @@ public class TTerminalWindow extends TScrollableWindow
         return false;
     }
 
+    /**
+     * Draw glyphs for a double-width or double-height VT100 cell to two
+     * screen cells.
+     *
+     * @param line the line this VT100 cell is in
+     * @param x the X position to draw the left half to
+     * @param y the Y position to draw to
+     * @param cell the cell to draw
+     */
+    private void putDoubleWidthCharXY(final DisplayLine line, final int x,
+        final int y, final Cell cell) {
+
+        int textWidth = getScreen().getTextWidth();
+        int textHeight = getScreen().getTextHeight();
+        boolean cursorBlinkVisible = true;
+
+        if (getScreen() instanceof SwingTerminal) {
+            SwingTerminal terminal = (SwingTerminal) getScreen();
+            cursorBlinkVisible = terminal.getCursorBlinkVisible();
+        } else if (getScreen() instanceof ECMA48Terminal) {
+            ECMA48Terminal terminal = (ECMA48Terminal) getScreen();
+
+            if (!terminal.hasSixel()) {
+                // The backend does not have sixel support, draw this as text
+                // and bail out.
+                putCharXY(x, y, cell);
+                putCharXY(x + 1, y, ' ', cell);
+                return;
+            }
+            cursorBlinkVisible = blinkState;
+        } else {
+            // We don't know how to dray glyphs to this screen, draw them as
+            // text and bail out.
+            putCharXY(x, y, cell);
+            putCharXY(x + 1, y, ' ', cell);
+            return;
+        }
+
+        if ((textWidth != lastTextWidth) || (textHeight != lastTextHeight)) {
+            // Screen size has changed, reset the font.
+            setupFont(textHeight);
+            lastTextWidth = textWidth;
+            lastTextHeight = textHeight;
+        }
+        assert (doubleFont != null);
+
+        BufferedImage image;
+        if (line.getDoubleHeight() == 1) {
+            // Double-height top half: don't draw the underline.
+            Cell newCell = new Cell();
+            newCell.setTo(cell);
+            newCell.setUnderline(false);
+            image = doubleFont.getImage(newCell, textWidth * 2, textHeight * 2,
+                cursorBlinkVisible);
+        } else {
+            image = doubleFont.getImage(cell,  textWidth * 2, textHeight * 2,
+                cursorBlinkVisible);
+        }
+
+        // Now that we have the double-wide glyph drawn, copy the right
+        // pieces of it to the cells.
+        Cell left = new Cell();
+        Cell right = new Cell();
+        left.setTo(cell);
+        right.setTo(cell);
+        right.setChar(' ');
+        BufferedImage leftImage = null;
+        BufferedImage rightImage = null;
+        /*
+        System.err.println("image " + image + " textWidth " + textWidth +
+            " textHeight " + textHeight);
+         */
+
+        switch (line.getDoubleHeight()) {
+        case 1:
+            // Top half double height
+            leftImage = image.getSubimage(0, 0, textWidth, textHeight);
+            rightImage = image.getSubimage(textWidth, 0, textWidth, textHeight);
+            break;
+        case 2:
+            // Bottom half double height
+            leftImage = image.getSubimage(0, textHeight, textWidth, textHeight);
+            rightImage = image.getSubimage(textWidth, textHeight,
+                textWidth, textHeight);
+            break;
+        default:
+            // Either single height double-width, or error fallback
+            BufferedImage wideImage = new BufferedImage(textWidth * 2,
+                textHeight, BufferedImage.TYPE_INT_ARGB);
+            Graphics2D grWide = wideImage.createGraphics();
+            grWide.drawImage(image, 0, 0, wideImage.getWidth(),
+                wideImage.getHeight(), null);
+            grWide.dispose();
+            leftImage = wideImage.getSubimage(0, 0, textWidth, textHeight);
+            rightImage = wideImage.getSubimage(textWidth, 0, textWidth,
+                textHeight);
+            break;
+        }
+        left.setImage(leftImage);
+        right.setImage(rightImage);
+        // Since we have image data, ditch the character here.  Otherwise, a
+        // drawBoxShadow() over the terminal window will show the characters
+        // which looks wrong.
+        left.setChar(' ');
+        right.setChar(' ');
+        putCharXY(x, y, left);
+        putCharXY(x + 1, y, right);
+    }
+
+    /**
+     * Set up the double-width font.
+     *
+     * @param fontSize the size of font to request for the single-width font.
+     * The double-width font will be 2x this value.
+     */
+    private void setupFont(final int fontSize) {
+        doubleFont = GlyphMaker.getDefault().size(fontSize * 2);
+
+        // Special case: the ECMA48 backend needs to have a timer to drive
+        // its blink state.
+        if (getScreen() instanceof jexer.backend.ECMA48Terminal) {
+            if (!haveTimer) {
+                // Blink every 500 millis.
+                long millis = 500;
+                getApplication().addTimer(millis, true,
+                    new TAction() {
+                        public void DO() {
+                            blinkState = !blinkState;
+                            getApplication().doRepaint();
+                        }
+                    }
+                );
+                haveTimer = true;
+            }
+        }
+    }
+
 }