diff src/de/mud/terminal/vt320.java @ 0:0ce5cc452d02

initial version
author Carl Byington <carl@five-ten-sg.com>
date Thu, 22 May 2014 10:41:19 -0700
parents
children 9621ac4dd5eb
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/de/mud/terminal/vt320.java	Thu May 22 10:41:19 2014 -0700
@@ -0,0 +1,3600 @@
+/*
+ * This file is part of "JTA - Telnet/SSH for the JAVA(tm) platform".
+ *
+ * (c) Matthias L. Jugel, Marcus Meiner 1996-2005. All Rights Reserved.
+ *
+ * Please visit http://javatelnet.org/ for updates and contact.
+ *
+ * --LICENSE NOTICE--
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * --LICENSE NOTICE--
+ *
+ */
+
+package de.mud.terminal;
+
+import android.text.AndroidCharacter;
+
+import java.util.Properties;
+
+/**
+ * Implementation of a VT terminal emulation plus ANSI compatible.
+ * <P>
+ * <B>Maintainer:</B> Marcus Meißner
+ *
+ * @version $Id: vt320.java 507 2005-10-25 10:14:52Z marcus $
+ * @author  Matthias L. Jugel, Marcus Meißner
+ */
+public abstract class vt320 extends VDUBuffer implements VDUInput {
+
+    /** The current version id tag.<P>
+     * $Id: vt320.java 507 2005-10-25 10:14:52Z marcus $
+     *
+     */
+    public final static String ID = "$Id: vt320.java 507 2005-10-25 10:14:52Z marcus $";
+
+    /** the debug level */
+    private final static int debug = 0;
+    private StringBuilder debugStr;
+    public abstract void debug(String notice);
+
+    /**
+     * Write an answer back to the remote host. This is needed to be able to
+     * send terminal answers requests like status and type information.
+     * @param b the array of bytes to be sent
+     */
+    public abstract void write(byte[] b);
+
+    /**
+     * Write an answer back to the remote host. This is needed to be able to
+     * send terminal answers requests like status and type information.
+     * @param b the byte to be sent
+     */
+    public abstract void write(int b);
+
+    /**
+     * No more bytes to read from the transport, hook here to test screen changes
+     */
+    public void testChanged() {
+        /* do nothing by default */
+    }
+
+    /**
+     * Play the beep sound ...
+     */
+    public void beep() {
+        /* do nothing by default */
+    }
+
+    /**
+     * Convenience function for putString(char[], int, int)
+     */
+    public void putString(String s) {
+        int len = s.length();
+        char[] tmp = new char[len];
+        s.getChars(0, len, tmp, 0);
+        putString(tmp, null, 0, len);
+    }
+
+    /**
+     * Put string at current cursor position. Moves cursor
+     * according to the String. Does NOT wrap.
+     * @param s character array
+     * @param start place to start in array
+     * @param len number of characters to process
+     */
+    public void putString(char[] s, byte[] fullwidths, int start, int len) {
+        if (len > 0) {
+            //markLine(R, 1);
+            int lastChar = -1;
+            char c;
+            boolean isWide = false;
+
+            for (int i = 0; i < len; i++) {
+                c = s[start + i];
+
+                // Shortcut for my favorite ASCII
+                if (c <= 0x7F) {
+                    if (lastChar != -1)
+                        putChar((char) lastChar, isWide, false);
+
+                    lastChar = c;
+                    isWide = false;
+                }
+                else if (!Character.isLowSurrogate(c) && !Character.isHighSurrogate(c)) {
+                    if (Character.getType(c) == Character.NON_SPACING_MARK) {
+                        if (lastChar != -1) {
+                            char nc = Precomposer.precompose((char) lastChar, c);
+                            putChar(nc, isWide, false);
+                            lastChar = -1;
+                        }
+                    }
+                    else {
+                        if (lastChar != -1)
+                            putChar((char) lastChar, isWide, false);
+
+                        lastChar = c;
+
+                        if (fullwidths != null) {
+                            final byte width = fullwidths[i];
+                            isWide = (width == AndroidCharacter.EAST_ASIAN_WIDTH_WIDE)
+                                     || (width == AndroidCharacter.EAST_ASIAN_WIDTH_FULL_WIDTH);
+                        }
+                    }
+                }
+            }
+
+            if (lastChar != -1)
+                putChar((char) lastChar, isWide, false);
+
+            setCursorPosition(C, R);
+            redraw();
+        }
+    }
+
+    protected void sendTelnetCommand(byte cmd) {
+        /* do nothing by default */
+    }
+
+    /**
+     * Sent the changed window size from the terminal to all listeners.
+     */
+    protected void setWindowSize(int c, int r) {
+        /* To be overridden by Terminal.java */
+    }
+
+    @Override
+    public void setScreenSize(int c, int r, boolean broadcast) {
+        int oldrows = height;
+
+        if (debug > 2) {
+            if (debugStr == null)
+                debugStr = new StringBuilder();
+
+            debugStr.append("setscreensize (")
+            .append(c)
+            .append(',')
+            .append(r)
+            .append(',')
+            .append(broadcast)
+            .append(')');
+            debug(debugStr.toString());
+            debugStr.setLength(0);
+        }
+
+        super.setScreenSize(c, r, false);
+        boolean cursorChanged = false;
+
+        // Don't let the cursor go off the screen.
+        if (C >= c) {
+            C = c - 1;
+            cursorChanged = true;
+        }
+
+        if (R >= r) {
+            R = r - 1;
+            cursorChanged = true;
+        }
+
+        if (cursorChanged) {
+            setCursorPosition(C, R);
+            redraw();
+        }
+
+        if (broadcast) {
+            setWindowSize(c, r);  /* broadcast up */
+        }
+    }
+
+
+    /**
+     * Create a new vt320 terminal and intialize it with useful settings.
+     */
+    public vt320(int width, int height) {
+        super(width, height);
+        debugStr = new StringBuilder();
+        setVMS(false);
+        setIBMCharset(false);
+        setTerminalID("vt320");
+        setBufferSize(100);
+        //setBorder(2, false);
+        gx = new char[4];
+        reset();
+        /* top row of numpad */
+        PF1 = "\u001bOP";
+        PF2 = "\u001bOQ";
+        PF3 = "\u001bOR";
+        PF4 = "\u001bOS";
+        /* the 3x2 keyblock on PC keyboards */
+        Insert = new String[4];
+        Remove = new String[4];
+        KeyHome = new String[4];
+        KeyEnd = new String[4];
+        NextScn = new String[4];
+        PrevScn = new String[4];
+        Escape = new String[4];
+        BackSpace = new String[4];
+        TabKey = new String[4];
+        Insert[0] = Insert[1] = Insert[2] = Insert[3] = "\u001b[2~";
+        Remove[0] = Remove[1] = Remove[2] = Remove[3] = "\u001b[3~";
+        PrevScn[0] = PrevScn[1] = PrevScn[2] = PrevScn[3] = "\u001b[5~";
+        NextScn[0] = NextScn[1] = NextScn[2] = NextScn[3] = "\u001b[6~";
+        KeyHome[0] = KeyHome[1] = KeyHome[2] = KeyHome[3] = "\u001b[H";
+        KeyEnd[0] = KeyEnd[1] = KeyEnd[2] = KeyEnd[3] = "\u001b[F";
+        Escape[0] = Escape[1] = Escape[2] = Escape[3] = "\u001b";
+
+        if (vms) {
+            BackSpace[1] = "" + (char) 10;    //  VMS shift deletes word back
+            BackSpace[2] = "\u0018";  //  VMS control deletes line back
+            BackSpace[0] = BackSpace[3] = "\u007f";   //  VMS other is delete
+        }
+        else {
+            //BackSpace[0] = BackSpace[1] = BackSpace[2] = BackSpace[3] = "\b";
+            // ConnectBot modifications.
+            BackSpace[0] = "\b";
+            BackSpace[1] = "\u007f";
+            BackSpace[2] = "\u001b[3~";
+            BackSpace[3] = "\u001b[2~";
+        }
+
+        /* some more VT100 keys */
+        Find = "\u001b[1~";
+        Select = "\u001b[4~";
+        Help = "\u001b[28~";
+        Do = "\u001b[29~";
+        FunctionKey = new String[21];
+        FunctionKey[0] = "";
+        FunctionKey[1] = PF1;
+        FunctionKey[2] = PF2;
+        FunctionKey[3] = PF3;
+        FunctionKey[4] = PF4;
+        /* following are defined differently for vt220 / vt132 ... */
+        FunctionKey[5] = "\u001b[15~";
+        FunctionKey[6] = "\u001b[17~";
+        FunctionKey[7] = "\u001b[18~";
+        FunctionKey[8] = "\u001b[19~";
+        FunctionKey[9] = "\u001b[20~";
+        FunctionKey[10] = "\u001b[21~";
+        FunctionKey[11] = "\u001b[23~";
+        FunctionKey[12] = "\u001b[24~";
+        FunctionKey[13] = "\u001b[25~";
+        FunctionKey[14] = "\u001b[26~";
+        FunctionKey[15] = Help;
+        FunctionKey[16] = Do;
+        FunctionKey[17] = "\u001b[31~";
+        FunctionKey[18] = "\u001b[32~";
+        FunctionKey[19] = "\u001b[33~";
+        FunctionKey[20] = "\u001b[34~";
+        FunctionKeyShift = new String[21];
+        FunctionKeyAlt = new String[21];
+        FunctionKeyCtrl = new String[21];
+
+        for (int i = 0; i < 20; i++) {
+            FunctionKeyShift[i] = "";
+            FunctionKeyAlt[i] = "";
+            FunctionKeyCtrl[i] = "";
+        }
+
+        FunctionKeyShift[15] = Find;
+        FunctionKeyShift[16] = Select;
+        TabKey[0] = "\u0009";
+        TabKey[1] = "\u001bOP\u0009";
+        TabKey[2] = TabKey[3] = "";
+        KeyUp = new String[4];
+        KeyUp[0] = "\u001b[A";
+        KeyDown = new String[4];
+        KeyDown[0] = "\u001b[B";
+        KeyRight = new String[4];
+        KeyRight[0] = "\u001b[C";
+        KeyLeft = new String[4];
+        KeyLeft[0] = "\u001b[D";
+        Numpad = new String[10];
+        Numpad[0] = "\u001bOp";
+        Numpad[1] = "\u001bOq";
+        Numpad[2] = "\u001bOr";
+        Numpad[3] = "\u001bOs";
+        Numpad[4] = "\u001bOt";
+        Numpad[5] = "\u001bOu";
+        Numpad[6] = "\u001bOv";
+        Numpad[7] = "\u001bOw";
+        Numpad[8] = "\u001bOx";
+        Numpad[9] = "\u001bOy";
+        KPMinus = PF4;
+        KPComma = "\u001bOl";
+        KPPeriod = "\u001bOn";
+        KPEnter = "\u001bOM";
+        NUMPlus = new String[4];
+        NUMPlus[0] = "+";
+        NUMDot = new String[4];
+        NUMDot[0] = ".";
+    }
+
+    public void setBackspace(int type) {
+        switch (type) {
+            case DELETE_IS_DEL:
+                BackSpace[0] = "\u007f";
+                BackSpace[1] = "\b";
+                break;
+
+            case DELETE_IS_BACKSPACE:
+                BackSpace[0] = "\b";
+                BackSpace[1] = "\u007f";
+                break;
+        }
+    }
+
+    /**
+     * Create a default vt320 terminal with 80 columns and 24 lines.
+     */
+    public vt320() {
+        this(80, 24);
+    }
+
+    /**
+     * Terminal is mouse-aware and requires (x,y) coordinates of
+     * on the terminal (character coordinates) and the button clicked.
+     * @param x
+     * @param y
+     * @param modifiers
+     */
+    public void mousePressed(int x, int y, int modifiers) {
+        if (mouserpt == 0)
+            return;
+
+        int mods = modifiers;
+        mousebut = 3;
+
+        if ((mods & 16) == 16) mousebut = 0;
+
+        if ((mods & 8) == 8) mousebut = 1;
+
+        if ((mods & 4) == 4) mousebut = 2;
+
+        int mousecode;
+
+        if (mouserpt == 9)  /* X10 Mouse */
+            mousecode = 0x20 | mousebut;
+        else            /* normal xterm mouse reporting */
+            mousecode = mousebut | 0x20 | ((mods & 7) << 2);
+
+        byte b[] = new byte[6];
+        b[0] = 27;
+        b[1] = (byte) '[';
+        b[2] = (byte) 'M';
+        b[3] = (byte) mousecode;
+        b[4] = (byte)(0x20 + x + 1);
+        b[5] = (byte)(0x20 + y + 1);
+        write(b);  // FIXME: writeSpecial here
+    }
+
+    /**
+     * Terminal is mouse-aware and requires the coordinates and button
+     * of the release.
+     * @param x
+     * @param y
+     * @param modifiers
+     */
+    public void mouseReleased(int x, int y, int modifiers) {
+        if (mouserpt == 0)
+            return;
+
+        /* problem is tht modifiers still have the released button set in them.
+        int mods = modifiers;
+        mousebut = 3;
+        if ((mods & 16)==16) mousebut=0;
+        if ((mods &  8)==8 ) mousebut=1;
+        if ((mods &  4)==4 ) mousebut=2;
+        */
+        int mousecode;
+
+        if (mouserpt == 9)
+            mousecode = 0x20 + mousebut;  /* same as press? appears so. */
+        else
+            mousecode = '#';
+
+        byte b[] = new byte[6];
+        b[0] = 27;
+        b[1] = (byte) '[';
+        b[2] = (byte) 'M';
+        b[3] = (byte) mousecode;
+        b[4] = (byte)(0x20 + x + 1);
+        b[5] = (byte)(0x20 + y + 1);
+        write(b);  // FIXME: writeSpecial here
+        mousebut = 0;
+    }
+
+
+    /** we should do localecho (passed from other modules). false is default */
+    private boolean localecho = false;
+
+    /**
+     * Enable or disable the local echo property of the terminal.
+     * @param echo true if the terminal should echo locally
+     */
+    public void setLocalEcho(boolean echo) {
+        localecho = echo;
+    }
+
+    /**
+     * Enable the VMS mode of the terminal to handle some things differently
+     * for VMS hosts.
+     * @param vms true for vms mode, false for normal mode
+     */
+    public void setVMS(boolean vms) {
+        this.vms = vms;
+    }
+
+    /**
+     * Enable the usage of the IBM character set used by some BBS's. Special
+     * graphical character are available in this mode.
+     * @param ibm true to use the ibm character set
+     */
+    public void setIBMCharset(boolean ibm) {
+        useibmcharset = ibm;
+    }
+
+    /**
+     * Override the standard key codes used by the terminal emulation.
+     * @param codes a properties object containing key code definitions
+     */
+    public void setKeyCodes(Properties codes) {
+        String res, prefixes[] = {"", "S", "C", "A"};
+        int i;
+
+        for (i = 0; i < 10; i++) {
+            res = codes.getProperty("NUMPAD" + i);
+
+            if (res != null) Numpad[i] = unEscape(res);
+        }
+
+        for (i = 1; i < 20; i++) {
+            res = codes.getProperty("F" + i);
+
+            if (res != null) FunctionKey[i] = unEscape(res);
+
+            res = codes.getProperty("SF" + i);
+
+            if (res != null) FunctionKeyShift[i] = unEscape(res);
+
+            res = codes.getProperty("CF" + i);
+
+            if (res != null) FunctionKeyCtrl[i] = unEscape(res);
+
+            res = codes.getProperty("AF" + i);
+
+            if (res != null) FunctionKeyAlt[i] = unEscape(res);
+        }
+
+        for (i = 0; i < 4; i++) {
+            res = codes.getProperty(prefixes[i] + "PGUP");
+
+            if (res != null) PrevScn[i] = unEscape(res);
+
+            res = codes.getProperty(prefixes[i] + "PGDOWN");
+
+            if (res != null) NextScn[i] = unEscape(res);
+
+            res = codes.getProperty(prefixes[i] + "END");
+
+            if (res != null) KeyEnd[i] = unEscape(res);
+
+            res = codes.getProperty(prefixes[i] + "HOME");
+
+            if (res != null) KeyHome[i] = unEscape(res);
+
+            res = codes.getProperty(prefixes[i] + "INSERT");
+
+            if (res != null) Insert[i] = unEscape(res);
+
+            res = codes.getProperty(prefixes[i] + "REMOVE");
+
+            if (res != null) Remove[i] = unEscape(res);
+
+            res = codes.getProperty(prefixes[i] + "UP");
+
+            if (res != null) KeyUp[i] = unEscape(res);
+
+            res = codes.getProperty(prefixes[i] + "DOWN");
+
+            if (res != null) KeyDown[i] = unEscape(res);
+
+            res = codes.getProperty(prefixes[i] + "LEFT");
+
+            if (res != null) KeyLeft[i] = unEscape(res);
+
+            res = codes.getProperty(prefixes[i] + "RIGHT");
+
+            if (res != null) KeyRight[i] = unEscape(res);
+
+            res = codes.getProperty(prefixes[i] + "ESCAPE");
+
+            if (res != null) Escape[i] = unEscape(res);
+
+            res = codes.getProperty(prefixes[i] + "BACKSPACE");
+
+            if (res != null) BackSpace[i] = unEscape(res);
+
+            res = codes.getProperty(prefixes[i] + "TAB");
+
+            if (res != null) TabKey[i] = unEscape(res);
+
+            res = codes.getProperty(prefixes[i] + "NUMPLUS");
+
+            if (res != null) NUMPlus[i] = unEscape(res);
+
+            res = codes.getProperty(prefixes[i] + "NUMDECIMAL");
+
+            if (res != null) NUMDot[i] = unEscape(res);
+        }
+    }
+
+    /**
+     * Set the terminal id used to identify this terminal.
+     * @param terminalID the id string
+     */
+    public void setTerminalID(String terminalID) {
+        this.terminalID = terminalID;
+
+        if (terminalID.equals("scoansi")) {
+            FunctionKey[1] = "\u001b[M";  FunctionKey[2] = "\u001b[N";
+            FunctionKey[3] = "\u001b[O";  FunctionKey[4] = "\u001b[P";
+            FunctionKey[5] = "\u001b[Q";  FunctionKey[6] = "\u001b[R";
+            FunctionKey[7] = "\u001b[S";  FunctionKey[8] = "\u001b[T";
+            FunctionKey[9] = "\u001b[U";  FunctionKey[10] = "\u001b[V";
+            FunctionKey[11] = "\u001b[W"; FunctionKey[12] = "\u001b[X";
+            FunctionKey[13] = "\u001b[Y"; FunctionKey[14] = "?";
+            FunctionKey[15] = "\u001b[a"; FunctionKey[16] = "\u001b[b";
+            FunctionKey[17] = "\u001b[c"; FunctionKey[18] = "\u001b[d";
+            FunctionKey[19] = "\u001b[e"; FunctionKey[20] = "\u001b[f";
+            PrevScn[0] = PrevScn[1] = PrevScn[2] = PrevScn[3] = "\u001b[I";
+            NextScn[0] = NextScn[1] = NextScn[2] = NextScn[3] = "\u001b[G";
+            // more theoretically.
+        }
+    }
+
+    public void setAnswerBack(String ab) {
+        this.answerBack = unEscape(ab);
+    }
+
+    /**
+     * Get the terminal id used to identify this terminal.
+     */
+    public String getTerminalID() {
+        return terminalID;
+    }
+
+    /**
+     * A small conveniance method thar converts the string to a byte array
+     * for sending.
+     * @param s the string to be sent
+     */
+    private boolean write(String s, boolean doecho) {
+        if (debug > 2) {
+            debugStr.append("write(|")
+            .append(s)
+            .append("|,")
+            .append(doecho);
+            debug(debugStr.toString());
+            debugStr.setLength(0);
+        }
+
+        if (s == null) // aka the empty string.
+            return true;
+
+        /* NOTE: getBytes() honours some locale, it *CONVERTS* the string.
+         * However, we output only 7bit stuff towards the target, and *some*
+         * 8 bit control codes. We must not mess up the latter, so we do hand
+         * by hand copy.
+         */
+        byte arr[] = new byte[s.length()];
+
+        for (int i = 0; i < s.length(); i++) {
+            arr[i] = (byte) s.charAt(i);
+        }
+
+        write(arr);
+
+        if (doecho)
+            putString(s);
+
+        return true;
+    }
+
+    private boolean write(int s, boolean doecho) {
+        if (debug > 2) {
+            debugStr.append("write(|")
+            .append(s)
+            .append("|,")
+            .append(doecho);
+            debug(debugStr.toString());
+            debugStr.setLength(0);
+        }
+
+        write(s);
+
+        // TODO check if character is wide
+        if (doecho)
+            putChar((char)s, false, false);
+
+        return true;
+    }
+
+    private boolean write(String s) {
+        return write(s, localecho);
+    }
+
+    // ===================================================================
+    // the actual terminal emulation code comes here:
+    // ===================================================================
+
+    private String terminalID = "vt320";
+    private String answerBack = "Use Terminal.answerback to set ...\n";
+
+    // X - COLUMNS, Y - ROWS
+    int R, C;
+    int attributes = 0;
+
+    int Sc, Sr, Sa, Stm, Sbm;
+    char Sgr, Sgl;
+    char Sgx[];
+
+    int insertmode = 0;
+    int statusmode = 0;
+    boolean vt52mode = false;
+    boolean keypadmode = false; /* false - numeric, true - application */
+    boolean output8bit = false;
+    int normalcursor = 0;
+    boolean moveoutsidemargins = true;
+    boolean wraparound = true;
+    boolean sendcrlf = true;
+    boolean capslock = false;
+    boolean numlock = false;
+    int mouserpt = 0;
+    byte mousebut = 0;
+
+    boolean useibmcharset = false;
+
+    int lastwaslf = 0;
+    boolean usedcharsets = false;
+
+    private final static char ESC = 27;
+    private final static char IND = 132;
+    private final static char NEL = 133;
+    private final static char RI = 141;
+    private final static char SS2 = 142;
+    private final static char SS3 = 143;
+    private final static char DCS = 144;
+    private final static char HTS = 136;
+    private final static char CSI = 155;
+    private final static char OSC = 157;
+    private final static int TSTATE_DATA = 0;
+    private final static int TSTATE_ESC = 1; /* ESC */
+    private final static int TSTATE_CSI = 2; /* ESC [ */
+    private final static int TSTATE_DCS = 3; /* ESC P */
+    private final static int TSTATE_DCEQ = 4; /* ESC [? */
+    private final static int TSTATE_ESCSQUARE = 5; /* ESC # */
+    private final static int TSTATE_OSC = 6;       /* ESC ] */
+    private final static int TSTATE_SETG0 = 7;     /* ESC (? */
+    private final static int TSTATE_SETG1 = 8;     /* ESC )? */
+    private final static int TSTATE_SETG2 = 9;     /* ESC *? */
+    private final static int TSTATE_SETG3 = 10;    /* ESC +? */
+    private final static int TSTATE_CSI_DOLLAR = 11; /* ESC [ Pn $ */
+    private final static int TSTATE_CSI_EX = 12; /* ESC [ ! */
+    private final static int TSTATE_ESCSPACE = 13; /* ESC <space> */
+    private final static int TSTATE_VT52X = 14;
+    private final static int TSTATE_VT52Y = 15;
+    private final static int TSTATE_CSI_TICKS = 16;
+    private final static int TSTATE_CSI_EQUAL = 17; /* ESC [ = */
+    private final static int TSTATE_TITLE = 18; /* xterm title */
+
+    /* Keys we support */
+    public final static int KEY_PAUSE = 1;
+    public final static int KEY_F1 = 2;
+    public final static int KEY_F2 = 3;
+    public final static int KEY_F3 = 4;
+    public final static int KEY_F4 = 5;
+    public final static int KEY_F5 = 6;
+    public final static int KEY_F6 = 7;
+    public final static int KEY_F7 = 8;
+    public final static int KEY_F8 = 9;
+    public final static int KEY_F9 = 10;
+    public final static int KEY_F10 = 11;
+    public final static int KEY_F11 = 12;
+    public final static int KEY_F12 = 13;
+    public final static int KEY_UP = 14;
+    public final static int KEY_DOWN = 15 ;
+    public final static int KEY_LEFT = 16;
+    public final static int KEY_RIGHT = 17;
+    public final static int KEY_PAGE_DOWN = 18;
+    public final static int KEY_PAGE_UP = 19;
+    public final static int KEY_INSERT = 20;
+    public final static int KEY_DELETE = 21;
+    public final static int KEY_BACK_SPACE = 22;
+    public final static int KEY_HOME = 23;
+    public final static int KEY_END = 24;
+    public final static int KEY_NUM_LOCK = 25;
+    public final static int KEY_CAPS_LOCK = 26;
+    public final static int KEY_SHIFT = 27;
+    public final static int KEY_CONTROL = 28;
+    public final static int KEY_ALT = 29;
+    public final static int KEY_ENTER = 30;
+    public final static int KEY_NUMPAD0 = 31;
+    public final static int KEY_NUMPAD1 = 32;
+    public final static int KEY_NUMPAD2 = 33;
+    public final static int KEY_NUMPAD3 = 34;
+    public final static int KEY_NUMPAD4 = 35;
+    public final static int KEY_NUMPAD5 = 36;
+    public final static int KEY_NUMPAD6 = 37;
+    public final static int KEY_NUMPAD7 = 38;
+    public final static int KEY_NUMPAD8 = 39;
+    public final static int KEY_NUMPAD9 = 40;
+    public final static int KEY_DECIMAL = 41;
+    public final static int KEY_ADD = 42;
+    public final static int KEY_ESCAPE = 43;
+
+    public final static int DELETE_IS_DEL = 0;
+    public final static int DELETE_IS_BACKSPACE = 1;
+
+    /* The graphics charsets
+     * B - default ASCII
+     * A - ISO Latin 1
+     * 0 - DEC SPECIAL
+     * < - User defined
+     * ....
+     */
+    char gx[];
+    char gl;      // GL (left charset)
+    char gr;      // GR (right charset)
+    int onegl;    // single shift override for GL.
+
+    // Map from scoansi linedrawing to DEC _and_ unicode (for the stuff which
+    // is not in linedrawing). Got from experimenting with scoadmin.
+    private final static String scoansi_acs = "Tm7k3x4u?kZl@mYjEnB\u2566DqCtAvM\u2550:\u2551N\u2557I\u2554;\u2557H\u255a0a<\u255d";
+    // array to store DEC Special -> Unicode mapping
+    //  Unicode   DEC  Unicode name    (DEC name)
+    private static char DECSPECIAL[] = {
+        '\u0040', //5f blank
+        '\u2666', //60 black diamond
+        '\u2592', //61 grey square
+        '\u2409', //62 Horizontal tab  (ht) pict. for control
+        '\u240c', //63 Form Feed       (ff) pict. for control
+        '\u240d', //64 Carriage Return (cr) pict. for control
+        '\u240a', //65 Line Feed       (lf) pict. for control
+        '\u00ba', //66 Masculine ordinal indicator
+        '\u00b1', //67 Plus or minus sign
+        '\u2424', //68 New Line        (nl) pict. for control
+        '\u240b', //69 Vertical Tab    (vt) pict. for control
+        '\u2518', //6a Forms light up   and left
+        '\u2510', //6b Forms light down and left
+        '\u250c', //6c Forms light down and right
+        '\u2514', //6d Forms light up   and right
+        '\u253c', //6e Forms light vertical and horizontal
+        '\u2594', //6f Upper 1/8 block                        (Scan 1)
+        '\u2580', //70 Upper 1/2 block                        (Scan 3)
+        '\u2500', //71 Forms light horizontal or ?em dash?    (Scan 5)
+        '\u25ac', //72 \u25ac black rect. or \u2582 lower 1/4 (Scan 7)
+        '\u005f', //73 \u005f underscore  or \u2581 lower 1/8 (Scan 9)
+        '\u251c', //74 Forms light vertical and right
+        '\u2524', //75 Forms light vertical and left
+        '\u2534', //76 Forms light up   and horizontal
+        '\u252c', //77 Forms light down and horizontal
+        '\u2502', //78 vertical bar
+        '\u2264', //79 less than or equal
+        '\u2265', //7a greater than or equal
+        '\u00b6', //7b paragraph
+        '\u2260', //7c not equal
+        '\u00a3', //7d Pound Sign (british)
+        '\u00b7'  //7e Middle Dot
+    };
+
+    /** Strings to send on function key pressing */
+    private String Numpad[];
+    private String FunctionKey[];
+    private String FunctionKeyShift[];
+    private String FunctionKeyCtrl[];
+    private String FunctionKeyAlt[];
+    private String TabKey[];
+    private String KeyUp[], KeyDown[], KeyLeft[], KeyRight[];
+    private String KPMinus, KPComma, KPPeriod, KPEnter;
+    private String PF1, PF2, PF3, PF4;
+    private String Help, Do, Find, Select;
+
+    private String KeyHome[], KeyEnd[], Insert[], Remove[], PrevScn[], NextScn[];
+    private String Escape[], BackSpace[], NUMDot[], NUMPlus[];
+
+    private String osc, dcs; /* to memorize OSC & DCS control sequence */
+
+    /** vt320 state variable (internal) */
+    private int term_state = TSTATE_DATA;
+    /** in vms mode, set by Terminal.VMS property */
+    private boolean vms = false;
+    /** Tabulators */
+    private byte[] Tabs;
+    /** The list of integers as used by CSI */
+    private int[] DCEvars = new int[30];
+    private int DCEvar;
+
+    /**
+     * Replace escape code characters (backslash + identifier) with their
+     * respective codes.
+     * @param tmp the string to be parsed
+     * @return a unescaped string
+     */
+    static String unEscape(String tmp) {
+        int idx = 0, oldidx = 0;
+        String cmd;
+        // f.println("unescape("+tmp+")");
+        cmd = "";
+
+        while ((idx = tmp.indexOf('\\', oldidx)) >= 0 &&
+                ++idx <= tmp.length()) {
+            cmd += tmp.substring(oldidx, idx - 1);
+
+            if (idx == tmp.length()) return cmd;
+
+            switch (tmp.charAt(idx)) {
+                case 'b':
+                    cmd += "\b";
+                    break;
+
+                case 'e':
+                    cmd += "\u001b";
+                    break;
+
+                case 'n':
+                    cmd += "\n";
+                    break;
+
+                case 'r':
+                    cmd += "\r";
+                    break;
+
+                case 't':
+                    cmd += "\t";
+                    break;
+
+                case 'v':
+                    cmd += "\u000b";
+                    break;
+
+                case 'a':
+                    cmd += "\u0012";
+                    break;
+
+                default :
+                    if ((tmp.charAt(idx) >= '0') && (tmp.charAt(idx) <= '9')) {
+                        int i;
+
+                        for (i = idx; i < tmp.length(); i++)
+                            if ((tmp.charAt(i) < '0') || (tmp.charAt(i) > '9'))
+                                break;
+
+                        cmd += (char) Integer.parseInt(tmp.substring(idx, i));
+                        idx = i - 1;
+                    }
+                    else
+                        cmd += tmp.substring(idx, ++idx);
+
+                    break;
+            }
+
+            oldidx = ++idx;
+        }
+
+        if (oldidx <= tmp.length()) cmd += tmp.substring(oldidx);
+
+        return cmd;
+    }
+
+    /**
+     * A small conveniance method thar converts a 7bit string to the 8bit
+     * version depending on VT52/Output8Bit mode.
+     *
+     * @param s the string to be sent
+     */
+    private boolean writeSpecial(String s) {
+        if (s == null)
+            return true;
+
+        if (((s.length() >= 3) && (s.charAt(0) == 27) && (s.charAt(1) == 'O'))) {
+            if (vt52mode) {
+                if ((s.charAt(2) >= 'P') && (s.charAt(2) <= 'S')) {
+                    s = "\u001b" + s.substring(2);  /* ESC x */
+                }
+                else {
+                    s = "\u001b?" + s.substring(2);  /* ESC ? x */
+                }
+            }
+            else {
+                if (output8bit) {
+                    s = "\u008f" + s.substring(2);  /* SS3 x */
+                } /* else keep string as it is */
+            }
+        }
+
+        if (((s.length() >= 3) && (s.charAt(0) == 27) && (s.charAt(1) == '['))) {
+            if (output8bit) {
+                s = "\u009b" + s.substring(2);  /* CSI ... */
+            } /* else keep */
+        }
+
+        return write(s, false);
+    }
+
+    /**
+     * main keytyping event handler...
+     */
+    public void keyPressed(int keyCode, char keyChar, int modifiers) {
+        boolean control = (modifiers & VDUInput.KEY_CONTROL) != 0;
+        boolean shift = (modifiers & VDUInput.KEY_SHIFT) != 0;
+        boolean alt = (modifiers & VDUInput.KEY_ALT) != 0;
+
+        if (debug > 1) {
+            debugStr.append("keyPressed(")
+            .append(keyCode)
+            .append(", ")
+            .append((int)keyChar)
+            .append(", ")
+            .append(modifiers)
+            .append(')');
+            debug(debugStr.toString());
+            debugStr.setLength(0);
+        }
+
+        int xind;
+        String fmap[];
+        xind = 0;
+        fmap = FunctionKey;
+
+        if (shift) {
+            fmap = FunctionKeyShift;
+            xind = 1;
+        }
+
+        if (control) {
+            fmap = FunctionKeyCtrl;
+            xind = 2;
+        }
+
+        if (alt) {
+            fmap = FunctionKeyAlt;
+            xind = 3;
+        }
+
+        switch (keyCode) {
+            case KEY_PAUSE:
+                if (shift || control)
+                    sendTelnetCommand((byte) 243);  // BREAK
+
+                break;
+
+            case KEY_F1:
+                writeSpecial(fmap[1]);
+                break;
+
+            case KEY_F2:
+                writeSpecial(fmap[2]);
+                break;
+
+            case KEY_F3:
+                writeSpecial(fmap[3]);
+                break;
+
+            case KEY_F4:
+                writeSpecial(fmap[4]);
+                break;
+
+            case KEY_F5:
+                writeSpecial(fmap[5]);
+                break;
+
+            case KEY_F6:
+                writeSpecial(fmap[6]);
+                break;
+
+            case KEY_F7:
+                writeSpecial(fmap[7]);
+                break;
+
+            case KEY_F8:
+                writeSpecial(fmap[8]);
+                break;
+
+            case KEY_F9:
+                writeSpecial(fmap[9]);
+                break;
+
+            case KEY_F10:
+                writeSpecial(fmap[10]);
+                break;
+
+            case KEY_F11:
+                writeSpecial(fmap[11]);
+                break;
+
+            case KEY_F12:
+                writeSpecial(fmap[12]);
+                break;
+
+            case KEY_UP:
+                writeSpecial(KeyUp[xind]);
+                break;
+
+            case KEY_DOWN:
+                writeSpecial(KeyDown[xind]);
+                break;
+
+            case KEY_LEFT:
+                writeSpecial(KeyLeft[xind]);
+                break;
+
+            case KEY_RIGHT:
+                writeSpecial(KeyRight[xind]);
+                break;
+
+            case KEY_PAGE_DOWN:
+                writeSpecial(NextScn[xind]);
+                break;
+
+            case KEY_PAGE_UP:
+                writeSpecial(PrevScn[xind]);
+                break;
+
+            case KEY_INSERT:
+                writeSpecial(Insert[xind]);
+                break;
+
+            case KEY_DELETE:
+                writeSpecial(Remove[xind]);
+                break;
+
+            case KEY_BACK_SPACE:
+                writeSpecial(BackSpace[xind]);
+
+                if (localecho) {
+                    if (BackSpace[xind] == "\b") {
+                        putString("\b \b");  // make the last char 'deleted'
+                    }
+                    else {
+                        putString(BackSpace[xind]);  // echo it
+                    }
+                }
+
+                break;
+
+            case KEY_HOME:
+                writeSpecial(KeyHome[xind]);
+                break;
+
+            case KEY_END:
+                writeSpecial(KeyEnd[xind]);
+                break;
+
+            case KEY_NUM_LOCK:
+                if (vms && control) {
+                    writeSpecial(PF1);
+                }
+
+                if (!control)
+                    numlock = !numlock;
+
+                break;
+
+            case KEY_CAPS_LOCK:
+                capslock = !capslock;
+                return;
+
+            case KEY_SHIFT:
+            case KEY_CONTROL:
+            case KEY_ALT:
+                return;
+
+            default:
+                break;
+        }
+    }
+    /*
+      public void keyReleased(KeyEvent evt) {
+        if (debug > 1) debug("keyReleased("+evt+")");
+        // ignore
+      }
+    */
+    /**
+     * Handle key Typed events for the terminal, this will get
+     * all normal key types, but no shift/alt/control/numlock.
+     */
+    public void keyTyped(int keyCode, char keyChar, int modifiers) {
+        boolean control = (modifiers & VDUInput.KEY_CONTROL) != 0;
+        boolean shift = (modifiers & VDUInput.KEY_SHIFT) != 0;
+        boolean alt = (modifiers & VDUInput.KEY_ALT) != 0;
+
+        if (debug > 1) debug("keyTyped(" + keyCode + ", " + (int)keyChar + ", " + modifiers + ")");
+
+        if (keyChar == '\t') {
+            if (shift) {
+                write(TabKey[1], false);
+            }
+            else {
+                if (control) {
+                    write(TabKey[2], false);
+                }
+                else {
+                    if (alt) {
+                        write(TabKey[3], false);
+                    }
+                    else {
+                        write(TabKey[0], false);
+                    }
+                }
+            }
+
+            return;
+        }
+
+        if (alt) {
+            write(((char)(keyChar | 0x80)));
+            return;
+        }
+
+        if (((keyCode == KEY_ENTER) || (keyChar == 10))
+                && !control) {
+            write('\r');
+
+            if (localecho) putString("\r\n");  // bad hack
+
+            return;
+        }
+
+        if ((keyCode == 10) && !control) {
+            debug("Sending \\r");
+            write('\r');
+            return;
+        }
+
+        // FIXME: on german PC keyboards you have to use Alt-Ctrl-q to get an @,
+        // so we can't just use it here... will probably break some other VMS
+        // codes.  -Marcus
+        // if(((!vms && keyChar == '2') || keyChar == '@' || keyChar == ' ')
+        //    && control)
+        if (((!vms && keyChar == '2') || keyChar == ' ') && control)
+            write(0);
+
+        if (vms) {
+            if (keyChar == 127 && !control) {
+                if (shift)
+                    writeSpecial(Insert[0]);        //  VMS shift delete = insert
+                else
+                    writeSpecial(Remove[0]);        //  VMS delete = remove
+
+                return;
+            }
+            else if (control)
+                switch (keyChar) {
+                    case '0':
+                        writeSpecial(Numpad[0]);
+                        return;
+
+                    case '1':
+                        writeSpecial(Numpad[1]);
+                        return;
+
+                    case '2':
+                        writeSpecial(Numpad[2]);
+                        return;
+
+                    case '3':
+                        writeSpecial(Numpad[3]);
+                        return;
+
+                    case '4':
+                        writeSpecial(Numpad[4]);
+                        return;
+
+                    case '5':
+                        writeSpecial(Numpad[5]);
+                        return;
+
+                    case '6':
+                        writeSpecial(Numpad[6]);
+                        return;
+
+                    case '7':
+                        writeSpecial(Numpad[7]);
+                        return;
+
+                    case '8':
+                        writeSpecial(Numpad[8]);
+                        return;
+
+                    case '9':
+                        writeSpecial(Numpad[9]);
+                        return;
+
+                    case '.':
+                        writeSpecial(KPPeriod);
+                        return;
+
+                    case '-':
+                    case 31:
+                        writeSpecial(KPMinus);
+                        return;
+
+                    case '+':
+                        writeSpecial(KPComma);
+                        return;
+
+                    case 10:
+                        writeSpecial(KPEnter);
+                        return;
+
+                    case '/':
+                        writeSpecial(PF2);
+                        return;
+
+                    case '*':
+                        writeSpecial(PF3);
+                        return;
+
+                    /* NUMLOCK handled in keyPressed */
+                    default:
+                        break;
+                }
+
+            /* Now what does this do and how did it get here. -Marcus
+            if (shift && keyChar < 32) {
+              write(PF1+(char)(keyChar + 64));
+              return;
+            }
+            */
+        }
+
+        // FIXME: not used?
+        //String fmap[];
+        int xind;
+        xind = 0;
+
+        //fmap = FunctionKey;
+        if (shift) {
+            //fmap = FunctionKeyShift;
+            xind = 1;
+        }
+
+        if (control) {
+            //fmap = FunctionKeyCtrl;
+            xind = 2;
+        }
+
+        if (alt) {
+            //fmap = FunctionKeyAlt;
+            xind = 3;
+        }
+
+        if (keyCode == KEY_ESCAPE) {
+            writeSpecial(Escape[xind]);
+            return;
+        }
+
+        if ((modifiers & VDUInput.KEY_ACTION) != 0)
+            switch (keyCode) {
+                case KEY_NUMPAD0:
+                    writeSpecial(Numpad[0]);
+                    return;
+
+                case KEY_NUMPAD1:
+                    writeSpecial(Numpad[1]);
+                    return;
+
+                case KEY_NUMPAD2:
+                    writeSpecial(Numpad[2]);
+                    return;
+
+                case KEY_NUMPAD3:
+                    writeSpecial(Numpad[3]);
+                    return;
+
+                case KEY_NUMPAD4:
+                    writeSpecial(Numpad[4]);
+                    return;
+
+                case KEY_NUMPAD5:
+                    writeSpecial(Numpad[5]);
+                    return;
+
+                case KEY_NUMPAD6:
+                    writeSpecial(Numpad[6]);
+                    return;
+
+                case KEY_NUMPAD7:
+                    writeSpecial(Numpad[7]);
+                    return;
+
+                case KEY_NUMPAD8:
+                    writeSpecial(Numpad[8]);
+                    return;
+
+                case KEY_NUMPAD9:
+                    writeSpecial(Numpad[9]);
+                    return;
+
+                case KEY_DECIMAL:
+                    writeSpecial(NUMDot[xind]);
+                    return;
+
+                case KEY_ADD:
+                    writeSpecial(NUMPlus[xind]);
+                    return;
+            }
+
+        if (!((keyChar == 8) || (keyChar == 127) || (keyChar == '\r') || (keyChar == '\n'))) {
+            write(keyChar);
+            return;
+        }
+    }
+
+    private void handle_dcs(String dcs) {
+        debugStr.append("DCS: ")
+        .append(dcs);
+        debug(debugStr.toString());
+        debugStr.setLength(0);
+    }
+
+    private void handle_osc(String osc) {
+        if (osc.length() > 2 && osc.substring(0, 2).equals("4;")) {
+            // Define color palette
+            String[] colorData = osc.split(";");
+
+            try {
+                int colorIndex = Integer.parseInt(colorData[1]);
+
+                if ("rgb:".equals(colorData[2].substring(0, 4))) {
+                    String[] rgb = colorData[2].substring(4).split("/");
+                    int red = Integer.parseInt(rgb[0].substring(0, 2), 16) & 0xFF;
+                    int green = Integer.parseInt(rgb[1].substring(0, 2), 16) & 0xFF;
+                    int blue = Integer.parseInt(rgb[2].substring(0, 2), 16) & 0xFF;
+                    display.setColor(colorIndex, red, green, blue);
+                }
+            }
+            catch (Exception e) {
+                debugStr.append("OSC: invalid color sequence encountered: ")
+                .append(osc);
+                debug(debugStr.toString());
+                debugStr.setLength(0);
+            }
+        }
+        else
+            debug("OSC: " + osc);
+    }
+
+    private final static char unimap[] = {
+        //#
+        //#    Name:     cp437_DOSLatinUS to Unicode table
+        //#    Unicode version: 1.1
+        //#    Table version: 1.1
+        //#    Table format:  Format A
+        //#    Date:          03/31/95
+        //#    Authors:       Michel Suignard <michelsu@microsoft.com>
+        //#                   Lori Hoerth <lorih@microsoft.com>
+        //#    General notes: none
+        //#
+        //#    Format: Three tab-separated columns
+        //#        Column #1 is the cp1255_WinHebrew code (in hex)
+        //#        Column #2 is the Unicode (in hex as 0xXXXX)
+        //#        Column #3 is the Unicode name (follows a comment sign, '#')
+        //#
+        //#    The entries are in cp437_DOSLatinUS order
+        //#
+
+        0x0000, // #NULL
+        0x0001, // #START OF HEADING
+        0x0002, // #START OF TEXT
+        0x0003, // #END OF TEXT
+        0x0004, // #END OF TRANSMISSION
+        0x0005, // #ENQUIRY
+        0x0006, // #ACKNOWLEDGE
+        0x0007, // #BELL
+        0x0008, // #BACKSPACE
+        0x0009, // #HORIZONTAL TABULATION
+        0x000a, // #LINE FEED
+        0x000b, // #VERTICAL TABULATION
+        0x000c, // #FORM FEED
+        0x000d, // #CARRIAGE RETURN
+        0x000e, // #SHIFT OUT
+        0x000f, // #SHIFT IN
+        0x0010, // #DATA LINK ESCAPE
+        0x0011, // #DEVICE CONTROL ONE
+        0x0012, // #DEVICE CONTROL TWO
+        0x0013, // #DEVICE CONTROL THREE
+        0x0014, // #DEVICE CONTROL FOUR
+        0x0015, // #NEGATIVE ACKNOWLEDGE
+        0x0016, // #SYNCHRONOUS IDLE
+        0x0017, // #END OF TRANSMISSION BLOCK
+        0x0018, // #CANCEL
+        0x0019, // #END OF MEDIUM
+        0x001a, // #SUBSTITUTE
+        0x001b, // #ESCAPE
+        0x001c, // #FILE SEPARATOR
+        0x001d, // #GROUP SEPARATOR
+        0x001e, // #RECORD SEPARATOR
+        0x001f, // #UNIT SEPARATOR
+        0x0020, // #SPACE
+        0x0021, // #EXCLAMATION MARK
+        0x0022, // #QUOTATION MARK
+        0x0023, // #NUMBER SIGN
+        0x0024, // #DOLLAR SIGN
+        0x0025, // #PERCENT SIGN
+        0x0026, // #AMPERSAND
+        0x0027, // #APOSTROPHE
+        0x0028, // #LEFT PARENTHESIS
+        0x0029, // #RIGHT PARENTHESIS
+        0x002a, // #ASTERISK
+        0x002b, // #PLUS SIGN
+        0x002c, // #COMMA
+        0x002d, // #HYPHEN-MINUS
+        0x002e, // #FULL STOP
+        0x002f, // #SOLIDUS
+        0x0030, // #DIGIT ZERO
+        0x0031, // #DIGIT ONE
+        0x0032, // #DIGIT TWO
+        0x0033, // #DIGIT THREE
+        0x0034, // #DIGIT FOUR
+        0x0035, // #DIGIT FIVE
+        0x0036, // #DIGIT SIX
+        0x0037, // #DIGIT SEVEN
+        0x0038, // #DIGIT EIGHT
+        0x0039, // #DIGIT NINE
+        0x003a, // #COLON
+        0x003b, // #SEMICOLON
+        0x003c, // #LESS-THAN SIGN
+        0x003d, // #EQUALS SIGN
+        0x003e, // #GREATER-THAN SIGN
+        0x003f, // #QUESTION MARK
+        0x0040, // #COMMERCIAL AT
+        0x0041, // #LATIN CAPITAL LETTER A
+        0x0042, // #LATIN CAPITAL LETTER B
+        0x0043, // #LATIN CAPITAL LETTER C
+        0x0044, // #LATIN CAPITAL LETTER D
+        0x0045, // #LATIN CAPITAL LETTER E
+        0x0046, // #LATIN CAPITAL LETTER F
+        0x0047, // #LATIN CAPITAL LETTER G
+        0x0048, // #LATIN CAPITAL LETTER H
+        0x0049, // #LATIN CAPITAL LETTER I
+        0x004a, // #LATIN CAPITAL LETTER J
+        0x004b, // #LATIN CAPITAL LETTER K
+        0x004c, // #LATIN CAPITAL LETTER L
+        0x004d, // #LATIN CAPITAL LETTER M
+        0x004e, // #LATIN CAPITAL LETTER N
+        0x004f, // #LATIN CAPITAL LETTER O
+        0x0050, // #LATIN CAPITAL LETTER P
+        0x0051, // #LATIN CAPITAL LETTER Q
+        0x0052, // #LATIN CAPITAL LETTER R
+        0x0053, // #LATIN CAPITAL LETTER S
+        0x0054, // #LATIN CAPITAL LETTER T
+        0x0055, // #LATIN CAPITAL LETTER U
+        0x0056, // #LATIN CAPITAL LETTER V
+        0x0057, // #LATIN CAPITAL LETTER W
+        0x0058, // #LATIN CAPITAL LETTER X
+        0x0059, // #LATIN CAPITAL LETTER Y
+        0x005a, // #LATIN CAPITAL LETTER Z
+        0x005b, // #LEFT SQUARE BRACKET
+        0x005c, // #REVERSE SOLIDUS
+        0x005d, // #RIGHT SQUARE BRACKET
+        0x005e, // #CIRCUMFLEX ACCENT
+        0x005f, // #LOW LINE
+        0x0060, // #GRAVE ACCENT
+        0x0061, // #LATIN SMALL LETTER A
+        0x0062, // #LATIN SMALL LETTER B
+        0x0063, // #LATIN SMALL LETTER C
+        0x0064, // #LATIN SMALL LETTER D
+        0x0065, // #LATIN SMALL LETTER E
+        0x0066, // #LATIN SMALL LETTER F
+        0x0067, // #LATIN SMALL LETTER G
+        0x0068, // #LATIN SMALL LETTER H
+        0x0069, // #LATIN SMALL LETTER I
+        0x006a, // #LATIN SMALL LETTER J
+        0x006b, // #LATIN SMALL LETTER K
+        0x006c, // #LATIN SMALL LETTER L
+        0x006d, // #LATIN SMALL LETTER M
+        0x006e, // #LATIN SMALL LETTER N
+        0x006f, // #LATIN SMALL LETTER O
+        0x0070, // #LATIN SMALL LETTER P
+        0x0071, // #LATIN SMALL LETTER Q
+        0x0072, // #LATIN SMALL LETTER R
+        0x0073, // #LATIN SMALL LETTER S
+        0x0074, // #LATIN SMALL LETTER T
+        0x0075, // #LATIN SMALL LETTER U
+        0x0076, // #LATIN SMALL LETTER V
+        0x0077, // #LATIN SMALL LETTER W
+        0x0078, // #LATIN SMALL LETTER X
+        0x0079, // #LATIN SMALL LETTER Y
+        0x007a, // #LATIN SMALL LETTER Z
+        0x007b, // #LEFT CURLY BRACKET
+        0x007c, // #VERTICAL LINE
+        0x007d, // #RIGHT CURLY BRACKET
+        0x007e, // #TILDE
+        0x007f, // #DELETE
+        0x00c7, // #LATIN CAPITAL LETTER C WITH CEDILLA
+        0x00fc, // #LATIN SMALL LETTER U WITH DIAERESIS
+        0x00e9, // #LATIN SMALL LETTER E WITH ACUTE
+        0x00e2, // #LATIN SMALL LETTER A WITH CIRCUMFLEX
+        0x00e4, // #LATIN SMALL LETTER A WITH DIAERESIS
+        0x00e0, // #LATIN SMALL LETTER A WITH GRAVE
+        0x00e5, // #LATIN SMALL LETTER A WITH RING ABOVE
+        0x00e7, // #LATIN SMALL LETTER C WITH CEDILLA
+        0x00ea, // #LATIN SMALL LETTER E WITH CIRCUMFLEX
+        0x00eb, // #LATIN SMALL LETTER E WITH DIAERESIS
+        0x00e8, // #LATIN SMALL LETTER E WITH GRAVE
+        0x00ef, // #LATIN SMALL LETTER I WITH DIAERESIS
+        0x00ee, // #LATIN SMALL LETTER I WITH CIRCUMFLEX
+        0x00ec, // #LATIN SMALL LETTER I WITH GRAVE
+        0x00c4, // #LATIN CAPITAL LETTER A WITH DIAERESIS
+        0x00c5, // #LATIN CAPITAL LETTER A WITH RING ABOVE
+        0x00c9, // #LATIN CAPITAL LETTER E WITH ACUTE
+        0x00e6, // #LATIN SMALL LIGATURE AE
+        0x00c6, // #LATIN CAPITAL LIGATURE AE
+        0x00f4, // #LATIN SMALL LETTER O WITH CIRCUMFLEX
+        0x00f6, // #LATIN SMALL LETTER O WITH DIAERESIS
+        0x00f2, // #LATIN SMALL LETTER O WITH GRAVE
+        0x00fb, // #LATIN SMALL LETTER U WITH CIRCUMFLEX
+        0x00f9, // #LATIN SMALL LETTER U WITH GRAVE
+        0x00ff, // #LATIN SMALL LETTER Y WITH DIAERESIS
+        0x00d6, // #LATIN CAPITAL LETTER O WITH DIAERESIS
+        0x00dc, // #LATIN CAPITAL LETTER U WITH DIAERESIS
+        0x00a2, // #CENT SIGN
+        0x00a3, // #POUND SIGN
+        0x00a5, // #YEN SIGN
+        0x20a7, // #PESETA SIGN
+        0x0192, // #LATIN SMALL LETTER F WITH HOOK
+        0x00e1, // #LATIN SMALL LETTER A WITH ACUTE
+        0x00ed, // #LATIN SMALL LETTER I WITH ACUTE
+        0x00f3, // #LATIN SMALL LETTER O WITH ACUTE
+        0x00fa, // #LATIN SMALL LETTER U WITH ACUTE
+        0x00f1, // #LATIN SMALL LETTER N WITH TILDE
+        0x00d1, // #LATIN CAPITAL LETTER N WITH TILDE
+        0x00aa, // #FEMININE ORDINAL INDICATOR
+        0x00ba, // #MASCULINE ORDINAL INDICATOR
+        0x00bf, // #INVERTED QUESTION MARK
+        0x2310, // #REVERSED NOT SIGN
+        0x00ac, // #NOT SIGN
+        0x00bd, // #VULGAR FRACTION ONE HALF
+        0x00bc, // #VULGAR FRACTION ONE QUARTER
+        0x00a1, // #INVERTED EXCLAMATION MARK
+        0x00ab, // #LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
+        0x00bb, // #RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+        0x2591, // #LIGHT SHADE
+        0x2592, // #MEDIUM SHADE
+        0x2593, // #DARK SHADE
+        0x2502, // #BOX DRAWINGS LIGHT VERTICAL
+        0x2524, // #BOX DRAWINGS LIGHT VERTICAL AND LEFT
+        0x2561, // #BOX DRAWINGS VERTICAL SINGLE AND LEFT DOUBLE
+        0x2562, // #BOX DRAWINGS VERTICAL DOUBLE AND LEFT SINGLE
+        0x2556, // #BOX DRAWINGS DOWN DOUBLE AND LEFT SINGLE
+        0x2555, // #BOX DRAWINGS DOWN SINGLE AND LEFT DOUBLE
+        0x2563, // #BOX DRAWINGS DOUBLE VERTICAL AND LEFT
+        0x2551, // #BOX DRAWINGS DOUBLE VERTICAL
+        0x2557, // #BOX DRAWINGS DOUBLE DOWN AND LEFT
+        0x255d, // #BOX DRAWINGS DOUBLE UP AND LEFT
+        0x255c, // #BOX DRAWINGS UP DOUBLE AND LEFT SINGLE
+        0x255b, // #BOX DRAWINGS UP SINGLE AND LEFT DOUBLE
+        0x2510, // #BOX DRAWINGS LIGHT DOWN AND LEFT
+        0x2514, // #BOX DRAWINGS LIGHT UP AND RIGHT
+        0x2534, // #BOX DRAWINGS LIGHT UP AND HORIZONTAL
+        0x252c, // #BOX DRAWINGS LIGHT DOWN AND HORIZONTAL
+        0x251c, // #BOX DRAWINGS LIGHT VERTICAL AND RIGHT
+        0x2500, // #BOX DRAWINGS LIGHT HORIZONTAL
+        0x253c, // #BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL
+        0x255e, // #BOX DRAWINGS VERTICAL SINGLE AND RIGHT DOUBLE
+        0x255f, // #BOX DRAWINGS VERTICAL DOUBLE AND RIGHT SINGLE
+        0x255a, // #BOX DRAWINGS DOUBLE UP AND RIGHT
+        0x2554, // #BOX DRAWINGS DOUBLE DOWN AND RIGHT
+        0x2569, // #BOX DRAWINGS DOUBLE UP AND HORIZONTAL
+        0x2566, // #BOX DRAWINGS DOUBLE DOWN AND HORIZONTAL
+        0x2560, // #BOX DRAWINGS DOUBLE VERTICAL AND RIGHT
+        0x2550, // #BOX DRAWINGS DOUBLE HORIZONTAL
+        0x256c, // #BOX DRAWINGS DOUBLE VERTICAL AND HORIZONTAL
+        0x2567, // #BOX DRAWINGS UP SINGLE AND HORIZONTAL DOUBLE
+        0x2568, // #BOX DRAWINGS UP DOUBLE AND HORIZONTAL SINGLE
+        0x2564, // #BOX DRAWINGS DOWN SINGLE AND HORIZONTAL DOUBLE
+        0x2565, // #BOX DRAWINGS DOWN DOUBLE AND HORIZONTAL SINGLE
+        0x2559, // #BOX DRAWINGS UP DOUBLE AND RIGHT SINGLE
+        0x2558, // #BOX DRAWINGS UP SINGLE AND RIGHT DOUBLE
+        0x2552, // #BOX DRAWINGS DOWN SINGLE AND RIGHT DOUBLE
+        0x2553, // #BOX DRAWINGS DOWN DOUBLE AND RIGHT SINGLE
+        0x256b, // #BOX DRAWINGS VERTICAL DOUBLE AND HORIZONTAL SINGLE
+        0x256a, // #BOX DRAWINGS VERTICAL SINGLE AND HORIZONTAL DOUBLE
+        0x2518, // #BOX DRAWINGS LIGHT UP AND LEFT
+        0x250c, // #BOX DRAWINGS LIGHT DOWN AND RIGHT
+        0x2588, // #FULL BLOCK
+        0x2584, // #LOWER HALF BLOCK
+        0x258c, // #LEFT HALF BLOCK
+        0x2590, // #RIGHT HALF BLOCK
+        0x2580, // #UPPER HALF BLOCK
+        0x03b1, // #GREEK SMALL LETTER ALPHA
+        0x00df, // #LATIN SMALL LETTER SHARP S
+        0x0393, // #GREEK CAPITAL LETTER GAMMA
+        0x03c0, // #GREEK SMALL LETTER PI
+        0x03a3, // #GREEK CAPITAL LETTER SIGMA
+        0x03c3, // #GREEK SMALL LETTER SIGMA
+        0x00b5, // #MICRO SIGN
+        0x03c4, // #GREEK SMALL LETTER TAU
+        0x03a6, // #GREEK CAPITAL LETTER PHI
+        0x0398, // #GREEK CAPITAL LETTER THETA
+        0x03a9, // #GREEK CAPITAL LETTER OMEGA
+        0x03b4, // #GREEK SMALL LETTER DELTA
+        0x221e, // #INFINITY
+        0x03c6, // #GREEK SMALL LETTER PHI
+        0x03b5, // #GREEK SMALL LETTER EPSILON
+        0x2229, // #INTERSECTION
+        0x2261, // #IDENTICAL TO
+        0x00b1, // #PLUS-MINUS SIGN
+        0x2265, // #GREATER-THAN OR EQUAL TO
+        0x2264, // #LESS-THAN OR EQUAL TO
+        0x2320, // #TOP HALF INTEGRAL
+        0x2321, // #BOTTOM HALF INTEGRAL
+        0x00f7, // #DIVISION SIGN
+        0x2248, // #ALMOST EQUAL TO
+        0x00b0, // #DEGREE SIGN
+        0x2219, // #BULLET OPERATOR
+        0x00b7, // #MIDDLE DOT
+        0x221a, // #SQUARE ROOT
+        0x207f, // #SUPERSCRIPT LATIN SMALL LETTER N
+        0x00b2, // #SUPERSCRIPT TWO
+        0x25a0, // #BLACK SQUARE
+        0x00a0, // #NO-BREAK SPACE
+    };
+
+    public char map_cp850_unicode(char x) {
+        if (x >= 0x100)
+            return x;
+
+        return unimap[x];
+    }
+
+    private void _SetCursor(int row, int col) {
+        int maxr = height - 1;
+        int tm = getTopMargin();
+        R = (row < 0) ? 0 : row;
+        C = (col < 0) ? 0 : (col >= width) ? width - 1 : col;
+
+        if (!moveoutsidemargins) {
+            R += tm;
+            maxr = getBottomMargin();
+        }
+
+        if (R > maxr) R = maxr;
+    }
+
+    private void putChar(char c, boolean isWide, boolean doshowcursor) {
+        int rows = this.height; //statusline
+        int columns = this.width;
+
+        // byte msg[];
+//    if (debug > 4) {
+//      debugStr.append("putChar(")
+//        .append(c)
+//        .append(" [")
+//        .append((int) c)
+//        .append("]) at R=")
+//        .append(R)
+//        .append(" , C=")
+//        .append(C)
+//        .append(", columns=")
+//        .append(columns)
+//        .append(", rows=")
+//        .append(rows);
+//      debug(debugStr.toString());
+//      debugStr.setLength(0);
+//    }
+//    markLine(R, 1);
+//    if (c > 255) {
+//      if (debug > 0)
+//        debug("char > 255:" + (int) c);
+//      //return;
+//    }
+        switch (term_state) {
+            case TSTATE_DATA:
+
+                /* FIXME: we shouldn't use chars with bit 8 set if ibmcharset.
+                 * probably... but some BBS do anyway...
+                 */
+                if (!useibmcharset) {
+                    boolean doneflag = true;
+
+                    switch (c) {
+                        case OSC:
+                            osc = "";
+                            term_state = TSTATE_OSC;
+                            break;
+
+                        case RI:
+                            if (R > getTopMargin())
+                                R--;
+                            else
+                                insertLine(R, 1, SCROLL_DOWN);
+
+                            if (debug > 1)
+                                debug("RI");
+
+                            break;
+
+                        case IND:
+                            if (debug > 2) {
+                                debugStr.append("IND at ")
+                                .append(R)
+                                .append(", tm is ")
+                                .append(getTopMargin())
+                                .append(", bm is ")
+                                .append(getBottomMargin());
+                                debug(debugStr.toString());
+                                debugStr.setLength(0);
+                            }
+
+                            if (R == getBottomMargin() || R == rows - 1)
+                                insertLine(R, 1, SCROLL_UP);
+                            else
+                                R++;
+
+                            if (debug > 1)
+                                debug("IND (at " + R + " )");
+
+                            break;
+
+                        case NEL:
+                            if (R == getBottomMargin() || R == rows - 1)
+                                insertLine(R, 1, SCROLL_UP);
+                            else
+                                R++;
+
+                            C = 0;
+
+                            if (debug > 1)
+                                debug("NEL (at " + R + " )");
+
+                            break;
+
+                        case HTS:
+                            Tabs[C] = 1;
+
+                            if (debug > 1)
+                                debug("HTS");
+
+                            break;
+
+                        case DCS:
+                            dcs = "";
+                            term_state = TSTATE_DCS;
+                            break;
+
+                        default:
+                            doneflag = false;
+                            break;
+                    }
+
+                    if (doneflag) break;
+                }
+
+                switch (c) {
+                    case SS3:
+                        onegl = 3;
+                        break;
+
+                    case SS2:
+                        onegl = 2;
+                        break;
+
+                    case CSI: // should be in the 8bit section, but some BBS use this
+                        DCEvar = 0;
+                        DCEvars[0] = 0;
+                        DCEvars[1] = 0;
+                        DCEvars[2] = 0;
+                        DCEvars[3] = 0;
+                        term_state = TSTATE_CSI;
+                        break;
+
+                    case ESC:
+                        term_state = TSTATE_ESC;
+                        lastwaslf = 0;
+                        break;
+
+                    case 5: /* ENQ */
+                        write(answerBack, false);
+                        break;
+
+                    case 12:
+                        /* FormFeed, Home for the BBS world */
+                        deleteArea(0, 0, columns, rows, attributes);
+                        C = R = 0;
+                        break;
+
+                    case '\b': /* 8 */
+                        C--;
+
+                        if (C < 0)
+                            C = 0;
+
+                        lastwaslf = 0;
+                        break;
+
+                    case '\t':
+                        do {
+                            // Don't overwrite or insert! TABS are not destructive, but movement!
+                            C++;
+                        }
+                        while (C < columns && (Tabs[C] == 0));
+
+                        lastwaslf = 0;
+                        break;
+
+                    case '\r': // 13 CR
+                        C = 0;
+                        break;
+
+                    case '\n': // 10 LF
+                        if (debug > 3)
+                            debug("R= " + R + ", bm " + getBottomMargin() + ", tm=" + getTopMargin() + ", rows=" + rows);
+
+                        if (!vms) {
+                            if (lastwaslf != 0 && lastwaslf != c)   //  Ray: I do not understand this logic.
+                                break;
+
+                            lastwaslf = c;
+                            /*C = 0;*/
+                        }
+
+                        if (R == getBottomMargin() || R >= rows - 1)
+                            insertLine(R, 1, SCROLL_UP);
+                        else
+                            R++;
+
+                        break;
+
+                    case 7:
+                        beep();
+                        break;
+
+                    case '\016': /* SMACS , as */
+                        /* ^N, Shift out - Put G1 into GL */
+                        gl = 1;
+                        usedcharsets = true;
+                        break;
+
+                    case '\017': /* RMACS , ae */
+                        /* ^O, Shift in - Put G0 into GL */
+                        gl = 0;
+                        usedcharsets = true;
+                        break;
+
+                    default: {
+                            int thisgl = gl;
+
+                            if (onegl >= 0) {
+                                thisgl = onegl;
+                                onegl = -1;
+                            }
+
+                            lastwaslf = 0;
+
+                            if (c < 32) {
+                                if (c != 0)
+                                    if (debug > 0)
+                                        debug("TSTATE_DATA char: " + ((int) c));
+
+                                /*break; some BBS really want those characters, like hearst etc. */
+                                if (c == 0) /* print 0 ... you bet */
+                                    break;
+                            }
+
+                            if (C >= columns) {
+                                if (wraparound) {
+                                    int bot = rows;
+
+                                    // If we're in the scroll region, check against the bottom margin
+                                    if (R <= getBottomMargin() && R >= getTopMargin())
+                                        bot = getBottomMargin() + 1;
+
+                                    if (R < bot - 1)
+                                        R++;
+                                    else {
+                                        if (debug > 3) debug("scrolling due to wrap at " + R);
+
+                                        insertLine(R, 1, SCROLL_UP);
+                                    }
+
+                                    C = 0;
+                                }
+                                else {
+                                    // cursor stays on last character.
+                                    C = columns - 1;
+                                }
+                            }
+
+                            boolean mapped = false;
+
+                            // Mapping if DEC Special is chosen charset
+                            if (usedcharsets) {
+                                if (c >= '\u0020' && c <= '\u007f') {
+                                    switch (gx[thisgl]) {
+                                        case '0':
+
+                                            // Remap SCOANSI line drawing to VT100 line drawing chars
+                                            // for our SCO using customers.
+                                            if (terminalID.equals("scoansi") || terminalID.equals("ansi")) {
+                                                for (int i = 0; i < scoansi_acs.length(); i += 2) {
+                                                    if (c == scoansi_acs.charAt(i)) {
+                                                        c = scoansi_acs.charAt(i + 1);
+                                                        break;
+                                                    }
+                                                }
+                                            }
+
+                                            if (c >= '\u005f' && c <= '\u007e') {
+                                                c = DECSPECIAL[(short) c - 0x5f];
+                                                mapped = true;
+                                            }
+
+                                            break;
+
+                                        case '<': // 'user preferred' is currently 'ISO Latin-1 suppl
+                                            c = (char)((c & 0x7f) | 0x80);
+                                            mapped = true;
+                                            break;
+
+                                        case 'A':
+                                        case 'B': // Latin-1 , ASCII -> fall through
+                                            mapped = true;
+                                            break;
+
+                                        default:
+                                            debug("Unsupported GL mapping: " + gx[thisgl]);
+                                            break;
+                                    }
+                                }
+
+                                if (!mapped && (c >= '\u0080' && c <= '\u00ff')) {
+                                    switch (gx[gr]) {
+                                        case '0':
+                                            if (c >= '\u00df' && c <= '\u00fe') {
+                                                c = DECSPECIAL[c - '\u00df'];
+                                                mapped = true;
+                                            }
+
+                                            break;
+
+                                        case '<':
+                                        case 'A':
+                                        case 'B':
+                                            mapped = true;
+                                            break;
+
+                                        default:
+                                            debug("Unsupported GR mapping: " + gx[gr]);
+                                            break;
+                                    }
+                                }
+                            }
+
+                            if (!mapped && useibmcharset)
+                                c = map_cp850_unicode(c);
+
+                            /*if(true || (statusmode == 0)) { */
+                            if (isWide) {
+                                if (C >= columns - 1) {
+                                    if (wraparound) {
+                                        int bot = rows;
+
+                                        // If we're in the scroll region, check against the bottom margin
+                                        if (R <= getBottomMargin() && R >= getTopMargin())
+                                            bot = getBottomMargin() + 1;
+
+                                        if (R < bot - 1)
+                                            R++;
+                                        else {
+                                            if (debug > 3) debug("scrolling due to wrap at " + R);
+
+                                            insertLine(R, 1, SCROLL_UP);
+                                        }
+
+                                        C = 0;
+                                    }
+                                    else {
+                                        // cursor stays on last wide character.
+                                        C = columns - 2;
+                                    }
+                                }
+                            }
+
+                            if (insertmode == 1) {
+                                if (isWide) {
+                                    insertChar(C++, R, c, attributes | FULLWIDTH);
+                                    insertChar(C, R, ' ', attributes | FULLWIDTH);
+                                }
+                                else
+                                    insertChar(C, R, c, attributes);
+                            }
+                            else {
+                                if (isWide) {
+                                    putChar(C++, R, c, attributes | FULLWIDTH);
+                                    putChar(C, R, ' ', attributes | FULLWIDTH);
+                                }
+                                else
+                                    putChar(C, R, c, attributes);
+                            }
+
+                            /*
+                              } else {
+                              if (insertmode==1) {
+                              insertChar(C, rows, c, attributes);
+                              } else {
+                              putChar(C, rows, c, attributes);
+                              }
+                              }
+                            */
+                            C++;
+                            break;
+                        }
+                } /* switch(c) */
+
+                break;
+
+            case TSTATE_OSC:
+                if ((c < 0x20) && (c != ESC)) {// NP - No printing character
+                    handle_osc(osc);
+                    term_state = TSTATE_DATA;
+                    break;
+                }
+
+                //but check for vt102 ESC \
+                if (c == '\\' && osc.charAt(osc.length() - 1) == ESC) {
+                    handle_osc(osc);
+                    term_state = TSTATE_DATA;
+                    break;
+                }
+
+                osc = osc + c;
+                break;
+
+            case TSTATE_ESCSPACE:
+                term_state = TSTATE_DATA;
+
+                switch (c) {
+                    case 'F': /* S7C1T, Disable output of 8-bit controls, use 7-bit */
+                        output8bit = false;
+                        break;
+
+                    case 'G': /* S8C1T, Enable output of 8-bit control codes*/
+                        output8bit = true;
+                        break;
+
+                    default:
+                        debug("ESC <space> " + c + " unhandled.");
+                }
+
+                break;
+
+            case TSTATE_ESC:
+                term_state = TSTATE_DATA;
+
+                switch (c) {
+                    case ' ':
+                        term_state = TSTATE_ESCSPACE;
+                        break;
+
+                    case '#':
+                        term_state = TSTATE_ESCSQUARE;
+                        break;
+
+                    case 'c':
+                        /* Hard terminal reset */
+                        reset();
+                        break;
+
+                    case '[':
+                        DCEvar = 0;
+                        DCEvars[0] = 0;
+                        DCEvars[1] = 0;
+                        DCEvars[2] = 0;
+                        DCEvars[3] = 0;
+                        term_state = TSTATE_CSI;
+                        break;
+
+                    case ']':
+                        osc = "";
+                        term_state = TSTATE_OSC;
+                        break;
+
+                    case 'P':
+                        dcs = "";
+                        term_state = TSTATE_DCS;
+                        break;
+
+                    case 'A': /* CUU */
+                        R--;
+
+                        if (R < 0) R = 0;
+
+                        break;
+
+                    case 'B': /* CUD */
+                        R++;
+
+                        if (R >= rows) R = rows - 1;
+
+                        break;
+
+                    case 'C':
+                        C++;
+
+                        if (C >= columns) C = columns - 1;
+
+                        break;
+
+                    case 'I': // RI
+                        insertLine(R, 1, SCROLL_DOWN);
+                        break;
+
+                    case 'E': /* NEL */
+                        if (R == getBottomMargin() || R == rows - 1)
+                            insertLine(R, 1, SCROLL_UP);
+                        else
+                            R++;
+
+                        C = 0;
+
+                        if (debug > 1)
+                            debug("ESC E (at " + R + ")");
+
+                        break;
+
+                    case 'D': /* IND */
+                        if (R == getBottomMargin() || R == rows - 1)
+                            insertLine(R, 1, SCROLL_UP);
+                        else
+                            R++;
+
+                        if (debug > 1)
+                            debug("ESC D (at " + R + " )");
+
+                        break;
+
+                    case 'J': /* erase to end of screen */
+                        if (R < rows - 1)
+                            deleteArea(0, R + 1, columns, rows - R - 1, attributes);
+
+                        if (C < columns - 1)
+                            deleteArea(C, R, columns - C, 1, attributes);
+
+                        break;
+
+                    case 'K':
+                        if (C < columns - 1)
+                            deleteArea(C, R, columns - C, 1, attributes);
+
+                        break;
+
+                    case 'M': // RI
+                        debug("ESC M : R is " + R + ", tm is " + getTopMargin() + ", bm is " + getBottomMargin());
+
+                        if (R > getTopMargin()) { // just go up 1 line.
+                            R--;
+                        }
+                        else {   // scroll down
+                            insertLine(R, 1, SCROLL_DOWN);
+                        }
+
+                        /* else do nothing ; */
+                        if (debug > 2)
+                            debug("ESC M ");
+
+                        break;
+
+                    case 'H':
+                        if (debug > 1)
+                            debug("ESC H at " + C);
+
+                        /* right border probably ...*/
+                        if (C >= columns)
+                            C = columns - 1;
+
+                        Tabs[C] = 1;
+                        break;
+
+                    case 'N': // SS2
+                        onegl = 2;
+                        break;
+
+                    case 'O': // SS3
+                        onegl = 3;
+                        break;
+
+                    case '=':
+
+                        /*application keypad*/
+                        if (debug > 0)
+                            debug("ESC =");
+
+                        keypadmode = true;
+                        break;
+
+                    case '<': /* vt52 mode off */
+                        vt52mode = false;
+                        break;
+
+                    case '>': /*normal keypad*/
+                        if (debug > 0)
+                            debug("ESC >");
+
+                        keypadmode = false;
+                        break;
+
+                    case '7': /* DECSC: save cursor, attributes */
+                        Sc = C;
+                        Sr = R;
+                        Sgl = gl;
+                        Sgr = gr;
+                        Sa = attributes;
+                        Sgx = new char[4];
+
+                        for (int i = 0; i < 4; i++) Sgx[i] = gx[i];
+
+                        if (debug > 1)
+                            debug("ESC 7");
+
+                        break;
+
+                    case '8': /* DECRC: restore cursor, attributes */
+                        C = Sc;
+                        R = Sr;
+                        gl = Sgl;
+                        gr = Sgr;
+
+                        if (Sgx != null)
+                            for (int i = 0; i < 4; i++) gx[i] = Sgx[i];
+
+                        attributes = Sa;
+
+                        if (debug > 1)
+                            debug("ESC 8");
+
+                        break;
+
+                    case '(': /* Designate G0 Character set (ISO 2022) */
+                        term_state = TSTATE_SETG0;
+                        usedcharsets = true;
+                        break;
+
+                    case ')': /* Designate G1 character set (ISO 2022) */
+                        term_state = TSTATE_SETG1;
+                        usedcharsets = true;
+                        break;
+
+                    case '*': /* Designate G2 Character set (ISO 2022) */
+                        term_state = TSTATE_SETG2;
+                        usedcharsets = true;
+                        break;
+
+                    case '+': /* Designate G3 Character set (ISO 2022) */
+                        term_state = TSTATE_SETG3;
+                        usedcharsets = true;
+                        break;
+
+                    case '~': /* Locking Shift 1, right */
+                        gr = 1;
+                        usedcharsets = true;
+                        break;
+
+                    case 'n': /* Locking Shift 2 */
+                        gl = 2;
+                        usedcharsets = true;
+                        break;
+
+                    case '}': /* Locking Shift 2, right */
+                        gr = 2;
+                        usedcharsets = true;
+                        break;
+
+                    case 'o': /* Locking Shift 3 */
+                        gl = 3;
+                        usedcharsets = true;
+                        break;
+
+                    case '|': /* Locking Shift 3, right */
+                        gr = 3;
+                        usedcharsets = true;
+                        break;
+
+                    case 'Y': /* vt52 cursor address mode , next chars are x,y */
+                        term_state = TSTATE_VT52Y;
+                        break;
+
+                    case '_':
+                        term_state = TSTATE_TITLE;
+                        break;
+
+                    case '\\':
+                        // TODO save title
+                        term_state = TSTATE_DATA;
+                        break;
+
+                    default:
+                        debug("ESC unknown letter: " + c + " (" + ((int) c) + ")");
+                        break;
+                }
+
+                break;
+
+            case TSTATE_VT52X:
+                C = c - 37;
+
+                if (C < 0)
+                    C = 0;
+                else if (C >= width)
+                    C = width - 1;
+
+                term_state = TSTATE_VT52Y;
+                break;
+
+            case TSTATE_VT52Y:
+                R = c - 37;
+
+                if (R < 0)
+                    R = 0;
+                else if (R >= height)
+                    R = height - 1;
+
+                term_state = TSTATE_DATA;
+                break;
+
+            case TSTATE_SETG0:
+                if (c != '0' && c != 'A' && c != 'B' && c != '<')
+                    debug("ESC ( " + c + ": G0 char set?  (" + ((int) c) + ")");
+                else {
+                    if (debug > 2) debug("ESC ( : G0 char set  (" + c + " " + ((int) c) + ")");
+
+                    gx[0] = c;
+                }
+
+                term_state = TSTATE_DATA;
+                break;
+
+            case TSTATE_SETG1:
+                if (c != '0' && c != 'A' && c != 'B' && c != '<') {
+                    debug("ESC ) " + c + " (" + ((int) c) + ") :G1 char set?");
+                }
+                else {
+                    if (debug > 2) debug("ESC ) :G1 char set  (" + c + " " + ((int) c) + ")");
+
+                    gx[1] = c;
+                }
+
+                term_state = TSTATE_DATA;
+                break;
+
+            case TSTATE_SETG2:
+                if (c != '0' && c != 'A' && c != 'B' && c != '<')
+                    debug("ESC*:G2 char set?  (" + ((int) c) + ")");
+                else {
+                    if (debug > 2) debug("ESC*:G2 char set  (" + c + " " + ((int) c) + ")");
+
+                    gx[2] = c;
+                }
+
+                term_state = TSTATE_DATA;
+                break;
+
+            case TSTATE_SETG3:
+                if (c != '0' && c != 'A' && c != 'B' && c != '<')
+                    debug("ESC+:G3 char set?  (" + ((int) c) + ")");
+                else {
+                    if (debug > 2) debug("ESC+:G3 char set  (" + c + " " + ((int) c) + ")");
+
+                    gx[3] = c;
+                }
+
+                term_state = TSTATE_DATA;
+                break;
+
+            case TSTATE_ESCSQUARE:
+                switch (c) {
+                    case '8':
+                        for (int i = 0; i < columns; i++)
+                            for (int j = 0; j < rows; j++)
+                                putChar(i, j, 'E', 0);
+
+                        break;
+
+                    default:
+                        debug("ESC # " + c + " not supported.");
+                        break;
+                }
+
+                term_state = TSTATE_DATA;
+                break;
+
+            case TSTATE_DCS:
+                if (c == '\\' && dcs.charAt(dcs.length() - 1) == ESC) {
+                    handle_dcs(dcs);
+                    term_state = TSTATE_DATA;
+                    break;
+                }
+
+                dcs = dcs + c;
+                break;
+
+            case TSTATE_DCEQ:
+                term_state = TSTATE_DATA;
+
+                switch (c) {
+                    case '0':
+                    case '1':
+                    case '2':
+                    case '3':
+                    case '4':
+                    case '5':
+                    case '6':
+                    case '7':
+                    case '8':
+                    case '9':
+                        DCEvars[DCEvar] = DCEvars[DCEvar] * 10 + (c) - 48;
+                        term_state = TSTATE_DCEQ;
+                        break;
+
+                    case ';':
+                        DCEvar++;
+                        DCEvars[DCEvar] = 0;
+                        term_state = TSTATE_DCEQ;
+                        break;
+
+                    case 's': // XTERM_SAVE missing!
+                        if (true || debug > 1)
+                            debug("ESC [ ? " + DCEvars[0] + " s unimplemented!");
+
+                        break;
+
+                    case 'r': // XTERM_RESTORE
+                        if (true || debug > 1)
+                            debug("ESC [ ? " + DCEvars[0] + " r");
+
+                        /* DEC Mode reset */
+                        for (int i = 0; i <= DCEvar; i++) {
+                            switch (DCEvars[i]) {
+                                case 3: /* 80 columns*/
+                                    setScreenSize(80, height, true);
+                                    break;
+
+                                case 4: /* scrolling mode, smooth */
+                                    break;
+
+                                case 5: /* light background */
+                                    break;
+
+                                case 6: /* DECOM (Origin Mode) move inside margins. */
+                                    moveoutsidemargins = true;
+                                    break;
+
+                                case 7: /* DECAWM: Autowrap Mode */
+                                    wraparound = false;
+                                    break;
+
+                                case 12:/* local echo off */
+                                    break;
+
+                                case 9:     /* X10 mouse */
+                                case 1000:  /* xterm style mouse report on */
+                                case 1001:
+                                case 1002:
+                                case 1003:
+                                    mouserpt = DCEvars[i];
+                                    break;
+
+                                default:
+                                    debug("ESC [ ? " + DCEvars[0] + " r, unimplemented!");
+                            }
+                        }
+
+                        break;
+
+                    case 'h': // DECSET
+                        if (debug > 0)
+                            debug("ESC [ ? " + DCEvars[0] + " h");
+
+                        /* DEC Mode set */
+                        for (int i = 0; i <= DCEvar; i++) {
+                            switch (DCEvars[i]) {
+                                case 1:  /* Application cursor keys */
+                                    KeyUp[0] = "\u001bOA";
+                                    KeyDown[0] = "\u001bOB";
+                                    KeyRight[0] = "\u001bOC";
+                                    KeyLeft[0] = "\u001bOD";
+                                    break;
+
+                                case 2: /* DECANM */
+                                    vt52mode = false;
+                                    break;
+
+                                case 3: /* 132 columns*/
+                                    setScreenSize(132, height, true);
+                                    break;
+
+                                case 6: /* DECOM: move inside margins. */
+                                    moveoutsidemargins = false;
+                                    break;
+
+                                case 7: /* DECAWM: Autowrap Mode */
+                                    wraparound = true;
+                                    break;
+
+                                case 25: /* turn cursor on */
+                                    showCursor(true);
+                                    break;
+
+                                case 9:     /* X10 mouse */
+                                case 1000:  /* xterm style mouse report on */
+                                case 1001:
+                                case 1002:
+                                case 1003:
+                                    mouserpt = DCEvars[i];
+                                    break;
+
+                                /* unimplemented stuff, fall through */
+                                /* 4  - scrolling mode, smooth */
+                                /* 5  - light background */
+                                /* 12 - local echo off */
+                                /* 18 - DECPFF - Printer Form Feed Mode -> On */
+                                /* 19 - DECPEX - Printer Extent Mode -> Screen */
+                                default:
+                                    debug("ESC [ ? " + DCEvars[0] + " h, unsupported.");
+                                    break;
+                            }
+                        }
+
+                        break;
+
+                    case 'i': // DEC Printer Control, autoprint, echo screenchars to printer
+
+                        // This is different to CSI i!
+                        // Also: "Autoprint prints a final display line only when the
+                        // cursor is moved off the line by an autowrap or LF, FF, or
+                        // VT (otherwise do not print the line)."
+                        switch (DCEvars[0]) {
+                            case 1:
+                                if (debug > 1)
+                                    debug("CSI ? 1 i : Print line containing cursor");
+
+                                break;
+
+                            case 4:
+                                if (debug > 1)
+                                    debug("CSI ? 4 i : Start passthrough printing");
+
+                                break;
+
+                            case 5:
+                                if (debug > 1)
+                                    debug("CSI ? 4 i : Stop passthrough printing");
+
+                                break;
+                        }
+
+                        break;
+
+                    case 'l': //DECRST
+
+                        /* DEC Mode reset */
+                        if (debug > 0)
+                            debug("ESC [ ? " + DCEvars[0] + " l");
+
+                        for (int i = 0; i <= DCEvar; i++) {
+                            switch (DCEvars[i]) {
+                                case 1:  /* Application cursor keys */
+                                    KeyUp[0] = "\u001b[A";
+                                    KeyDown[0] = "\u001b[B";
+                                    KeyRight[0] = "\u001b[C";
+                                    KeyLeft[0] = "\u001b[D";
+                                    break;
+
+                                case 2: /* DECANM */
+                                    vt52mode = true;
+                                    break;
+
+                                case 3: /* 80 columns*/
+                                    setScreenSize(80, height, true);
+                                    break;
+
+                                case 6: /* DECOM: move outside margins. */
+                                    moveoutsidemargins = true;
+                                    break;
+
+                                case 7: /* DECAWM: Autowrap Mode OFF */
+                                    wraparound = false;
+                                    break;
+
+                                case 25: /* turn cursor off */
+                                    showCursor(false);
+                                    break;
+
+                                /* Unimplemented stuff: */
+                                /* 4  - scrolling mode, jump */
+                                /* 5  - dark background */
+                                /* 7  - DECAWM - no wrap around mode */
+                                /* 12 - local echo on */
+                                /* 18 - DECPFF - Printer Form Feed Mode -> Off*/
+                                /* 19 - DECPEX - Printer Extent Mode -> Scrolling Region */
+                                case 9:     /* X10 mouse */
+                                case 1000:  /* xterm style mouse report OFF */
+                                case 1001:
+                                case 1002:
+                                case 1003:
+                                    mouserpt = 0;
+                                    break;
+
+                                default:
+                                    debug("ESC [ ? " + DCEvars[0] + " l, unsupported.");
+                                    break;
+                            }
+                        }
+
+                        break;
+
+                    case 'n':
+                        if (debug > 0)
+                            debug("ESC [ ? " + DCEvars[0] + " n");
+
+                        switch (DCEvars[0]) {
+                            case 15:
+                                /* printer? no printer. */
+                                write((ESC) + "[?13n", false);
+                                debug("ESC[5n");
+                                break;
+
+                            default:
+                                debug("ESC [ ? " + DCEvars[0] + " n, unsupported.");
+                                break;
+                        }
+
+                        break;
+
+                    default:
+                        debug("ESC [ ? " + DCEvars[0] + " " + c + ", unsupported.");
+                        break;
+                }
+
+                break;
+
+            case TSTATE_CSI_EX:
+                term_state = TSTATE_DATA;
+
+                switch (c) {
+                    case ESC:
+                        term_state = TSTATE_ESC;
+                        break;
+
+                    default:
+                        debug("Unknown character ESC[! character is " + (int) c);
+                        break;
+                }
+
+                break;
+
+            case TSTATE_CSI_TICKS:
+                term_state = TSTATE_DATA;
+
+                switch (c) {
+                    case 'p':
+                        debug("Conformance level: " + DCEvars[0] + " (unsupported)," + DCEvars[1]);
+
+                        if (DCEvars[0] == 61) {
+                            output8bit = false;
+                            break;
+                        }
+
+                        if (DCEvars[1] == 1) {
+                            output8bit = false;
+                        }
+                        else {
+                            output8bit = true; /* 0 or 2 */
+                        }
+
+                        break;
+
+                    default:
+                        debug("Unknown ESC [...  \"" + c);
+                        break;
+                }
+
+                break;
+
+            case TSTATE_CSI_EQUAL:
+                term_state = TSTATE_DATA;
+
+                switch (c) {
+                    case '0':
+                    case '1':
+                    case '2':
+                    case '3':
+                    case '4':
+                    case '5':
+                    case '6':
+                    case '7':
+                    case '8':
+                    case '9':
+                        DCEvars[DCEvar] = DCEvars[DCEvar] * 10 + (c) - 48;
+                        term_state = TSTATE_CSI_EQUAL;
+                        break;
+
+                    case ';':
+                        DCEvar++;
+                        DCEvars[DCEvar] = 0;
+                        term_state = TSTATE_CSI_EQUAL;
+                        break;
+
+                    case 'F': { /* SCO ANSI foreground */
+                            int newcolor;
+                            debug("ESC [ = " + DCEvars[0] + " F");
+                            attributes &= ~COLOR_FG;
+                            newcolor = ((DCEvars[0] & 1) << 2) |
+                                       (DCEvars[0] & 2)   |
+                                       ((DCEvars[0] & 4) >> 2) ;
+                            attributes |= (newcolor + 1) << COLOR_FG_SHIFT;
+                            break;
+                        }
+
+                    case 'G': { /* SCO ANSI background */
+                            int newcolor;
+                            debug("ESC [ = " + DCEvars[0] + " G");
+                            attributes &= ~COLOR_BG;
+                            newcolor = ((DCEvars[0] & 1) << 2) |
+                                       (DCEvars[0] & 2)   |
+                                       ((DCEvars[0] & 4) >> 2) ;
+                            attributes |= (newcolor + 1) << COLOR_BG_SHIFT;
+                            break;
+                        }
+
+                    default:
+                        debugStr.append("Unknown ESC [ = ");
+
+                        for (int i = 0; i <= DCEvar; i++) {
+                            debugStr.append(DCEvars[i])
+                            .append(',');
+                        }
+
+                        debugStr.append(c);
+                        debug(debugStr.toString());
+                        debugStr.setLength(0);
+                        break;
+                }
+
+                break;
+
+            case TSTATE_CSI_DOLLAR:
+                term_state = TSTATE_DATA;
+
+                switch (c) {
+                    case '}':
+                        debug("Active Status Display now " + DCEvars[0]);
+                        statusmode = DCEvars[0];
+                        break;
+
+                    /* bad documentation?
+                       case '-':
+                       debug("Set Status Display now "+DCEvars[0]);
+                       break;
+                    */
+                    case '~':
+                        debug("Status Line mode now " + DCEvars[0]);
+                        break;
+
+                    default:
+                        debug("UNKNOWN Status Display code " + c + ", with Pn=" + DCEvars[0]);
+                        break;
+                }
+
+                break;
+
+            case TSTATE_CSI:
+                term_state = TSTATE_DATA;
+
+                switch (c) {
+                    case '"':
+                        term_state = TSTATE_CSI_TICKS;
+                        break;
+
+                    case '$':
+                        term_state = TSTATE_CSI_DOLLAR;
+                        break;
+
+                    case '=':
+                        term_state = TSTATE_CSI_EQUAL;
+                        break;
+
+                    case '!':
+                        term_state = TSTATE_CSI_EX;
+                        break;
+
+                    case '?':
+                        DCEvar = 0;
+                        DCEvars[0] = 0;
+                        term_state = TSTATE_DCEQ;
+                        break;
+
+                    case '0':
+                    case '1':
+                    case '2':
+                    case '3':
+                    case '4':
+                    case '5':
+                    case '6':
+                    case '7':
+                    case '8':
+                    case '9':
+                        DCEvars[DCEvar] = DCEvars[DCEvar] * 10 + (c) - 48;
+                        term_state = TSTATE_CSI;
+                        break;
+
+                    case ';':
+                        DCEvar++;
+                        DCEvars[DCEvar] = 0;
+                        term_state = TSTATE_CSI;
+                        break;
+
+                    case 'c':/* send primary device attributes */
+                        /* send (ESC[?61c) */
+                        String subcode = "";
+
+                        if (terminalID.equals("vt320")) subcode = "63;";
+
+                        if (terminalID.equals("vt220")) subcode = "62;";
+
+                        if (terminalID.equals("vt100")) subcode = "61;";
+
+                        write((ESC) + "[?" + subcode + "1;2c", false);
+
+                        if (debug > 1)
+                            debug("ESC [ " + DCEvars[0] + " c");
+
+                        break;
+
+                    case 'q':
+                        if (debug > 1)
+                            debug("ESC [ " + DCEvars[0] + " q");
+
+                        break;
+
+                    case 'g':
+
+                        /* used for tabsets */
+                        switch (DCEvars[0]) {
+                            case 3:/* clear them */
+                                Tabs = new byte[width];
+                                break;
+
+                            case 0:
+                                Tabs[C] = 0;
+                                break;
+                        }
+
+                        if (debug > 1)
+                            debug("ESC [ " + DCEvars[0] + " g");
+
+                        break;
+
+                    case 'h':
+                        switch (DCEvars[0]) {
+                            case 4:
+                                insertmode = 1;
+                                break;
+
+                            case 20:
+                                debug("Setting CRLF to TRUE");
+                                sendcrlf = true;
+                                break;
+
+                            default:
+                                debug("unsupported: ESC [ " + DCEvars[0] + " h");
+                                break;
+                        }
+
+                        if (debug > 1)
+                            debug("ESC [ " + DCEvars[0] + " h");
+
+                        break;
+
+                    case 'i': // Printer Controller mode.
+
+                        // "Transparent printing sends all output, except the CSI 4 i
+                        //  termination string, to the printer and not the screen,
+                        //  uses an 8-bit channel if no parity so NUL and DEL will be
+                        //  seen by the printer and by the termination recognizer code,
+                        //  and all translation and character set selections are
+                        //  bypassed."
+                        switch (DCEvars[0]) {
+                            case 0:
+                                if (debug > 1)
+                                    debug("CSI 0 i:  Print Screen, not implemented.");
+
+                                break;
+
+                            case 4:
+                                if (debug > 1)
+                                    debug("CSI 4 i:  Enable Transparent Printing, not implemented.");
+
+                                break;
+
+                            case 5:
+                                if (debug > 1)
+                                    debug("CSI 4/5 i:  Disable Transparent Printing, not implemented.");
+
+                                break;
+
+                            default:
+                                debug("ESC [ " + DCEvars[0] + " i, unimplemented!");
+                        }
+
+                        break;
+
+                    case 'l':
+                        switch (DCEvars[0]) {
+                            case 4:
+                                insertmode = 0;
+                                break;
+
+                            case 20:
+                                debug("Setting CRLF to FALSE");
+                                sendcrlf = false;
+                                break;
+
+                            default:
+                                debug("ESC [ " + DCEvars[0] + " l, unimplemented!");
+                                break;
+                        }
+
+                        break;
+
+                    case 'A': { // CUU
+                            int limit;
+
+                            /* FIXME: xterm only cares about 0 and topmargin */
+                            if (R >= getTopMargin()) {
+                                limit = getTopMargin();
+                            }
+                            else
+                                limit = 0;
+
+                            if (DCEvars[0] == 0)
+                                R--;
+                            else
+                                R -= DCEvars[0];
+
+                            if (R < limit)
+                                R = limit;
+
+                            if (debug > 1)
+                                debug("ESC [ " + DCEvars[0] + " A");
+
+                            break;
+                        }
+
+                    case 'B': // CUD
+                        /* cursor down n (1) times */
+                        {
+                            int limit;
+
+                            if (R <= getBottomMargin()) {
+                                limit = getBottomMargin();
+                            }
+                            else
+                                limit = rows - 1;
+
+                            if (DCEvars[0] == 0)
+                                R++;
+                            else
+                                R += DCEvars[0];
+
+                            if (R > limit)
+                                R = limit;
+                            else {
+                                if (debug > 2) debug("Not limited.");
+                            }
+
+                            if (debug > 2) debug("to: " + R);
+
+                            if (debug > 1)
+                                debug("ESC [ " + DCEvars[0] + " B (at C=" + C + ")");
+
+                            break;
+                        }
+
+                    case 'C':
+                        if (DCEvars[0] == 0)
+                            DCEvars[0] = 1;
+
+                        while (DCEvars[0]-- > 0) {
+                            C++;
+                        }
+
+                        if (C >= columns)
+                            C = columns - 1;
+
+                        if (debug > 1)
+                            debug("ESC [ " + DCEvars[0] + " C");
+
+                        break;
+
+                    case 'd': // CVA
+                        R = DCEvars[0] - 1;
+
+                        if (R < 0)
+                            R = 0;
+                        else if (R >= height)
+                            R = height - 1;
+
+                        if (debug > 1)
+                            debug("ESC [ " + DCEvars[0] + " d");
+
+                        break;
+
+                    case 'D':
+                        if (DCEvars[0] == 0)
+                            DCEvars[0] = 1;
+
+                        while (DCEvars[0]-- > 0) {
+                            C--;
+                        }
+
+                        if (C < 0) C = 0;
+
+                        if (debug > 1)
+                            debug("ESC [ " + DCEvars[0] + " D");
+
+                        break;
+
+                    case 'r': // DECSTBM
+                        if (DCEvar > 0) { //  Ray:  Any argument is optional
+                            R = DCEvars[1] - 1;
+
+                            if (R < 0)
+                                R = rows - 1;
+                            else if (R >= rows) {
+                                R = rows - 1;
+                            }
+                        }
+                        else
+                            R = rows - 1;
+
+                        int bot = R;
+
+                        if (R >= DCEvars[0]) {
+                            R = DCEvars[0] - 1;
+
+                            if (R < 0)
+                                R = 0;
+                        }
+
+                        setMargins(R, bot);
+                        _SetCursor(0, 0);
+
+                        if (debug > 1)
+                            debug("ESC [" + DCEvars[0] + " ; " + DCEvars[1] + " r");
+
+                        break;
+
+                    case 'G':  /* CUP  / cursor absolute column */
+                        C = DCEvars[0];
+
+                        if (C < 0)
+                            C = 0;
+                        else if (C >= width)
+                            C = width - 1;
+
+                        if (debug > 1) debug("ESC [ " + DCEvars[0] + " G");
+
+                        break;
+
+                    case 'H':  /* CUP  / cursor position */
+                        /* gets 2 arguments */
+                        _SetCursor(DCEvars[0] - 1, DCEvars[1] - 1);
+
+                        if (debug > 2) {
+                            debug("ESC [ " + DCEvars[0] + ";" + DCEvars[1] + " H, moveoutsidemargins " + moveoutsidemargins);
+                            debug("	-> R now " + R + ", C now " + C);
+                        }
+
+                        break;
+
+                    case 'f':  /* move cursor 2 */
+                        /* gets 2 arguments */
+                        R = DCEvars[0] - 1;
+                        C = DCEvars[1] - 1;
+
+                        if (C < 0)
+                            C = 0;
+                        else if (C >= width)
+                            C = width - 1;
+
+                        if (R < 0)
+                            R = 0;
+                        else if (R >= height)
+                            R = height - 1;
+
+                        if (debug > 2)
+                            debug("ESC [ " + DCEvars[0] + ";" + DCEvars[1] + " f");
+
+                        break;
+
+                    case 'S': /* ind aka 'scroll forward' */
+                        if (DCEvars[0] == 0)
+                            insertLine(getBottomMargin(), SCROLL_UP);
+                        else
+                            insertLine(getBottomMargin(), DCEvars[0], SCROLL_UP);
+
+                        break;
+
+                    case 'L':
+
+                        /* insert n lines */
+                        if (DCEvars[0] == 0)
+                            insertLine(R, SCROLL_DOWN);
+                        else
+                            insertLine(R, DCEvars[0], SCROLL_DOWN);
+
+                        if (debug > 1)
+                            debug("ESC [ " + DCEvars[0] + "" + (c) + " (at R " + R + ")");
+
+                        break;
+
+                    case 'T': /* 'ri' aka scroll backward */
+                        if (DCEvars[0] == 0)
+                            insertLine(getTopMargin(), SCROLL_DOWN);
+                        else
+                            insertLine(getTopMargin(), DCEvars[0], SCROLL_DOWN);
+
+                        break;
+
+                    case 'M':
+                        if (debug > 1)
+                            debug("ESC [ " + DCEvars[0] + "" + (c) + " at R=" + R);
+
+                        if (DCEvars[0] == 0)
+                            deleteLine(R);
+                        else
+                            for (int i = 0; i < DCEvars[0]; i++)
+                                deleteLine(R);
+
+                        break;
+
+                    case 'K':
+                        if (debug > 1)
+                            debug("ESC [ " + DCEvars[0] + " K");
+
+                        /* clear in line */
+                        switch (DCEvars[0]) {
+                            case 6: /* 97801 uses ESC[6K for delete to end of line */
+                            case 0:/*clear to right*/
+                                if (C < columns - 1)
+                                    deleteArea(C, R, columns - C, 1, attributes);
+
+                                break;
+
+                            case 1:/*clear to the left, including this */
+                                if (C > 0)
+                                    deleteArea(0, R, C + 1, 1, attributes);
+
+                                break;
+
+                            case 2:/*clear whole line */
+                                deleteArea(0, R, columns, 1, attributes);
+                                break;
+                        }
+
+                        break;
+
+                    case 'J':
+
+                        /* clear below current line */
+                        switch (DCEvars[0]) {
+                            case 0:
+                                if (R < rows - 1)
+                                    deleteArea(0, R + 1, columns, rows - R - 1, attributes);
+
+                                if (C < columns - 1)
+                                    deleteArea(C, R, columns - C, 1, attributes);
+
+                                break;
+
+                            case 1:
+                                if (R > 0)
+                                    deleteArea(0, 0, columns, R, attributes);
+
+                                if (C > 0)
+                                    deleteArea(0, R, C + 1, 1, attributes);  // include up to and including current
+
+                                break;
+
+                            case 2:
+                                deleteArea(0, 0, columns, rows, attributes);
+                                break;
+                        }
+
+                        if (debug > 1)
+                            debug("ESC [ " + DCEvars[0] + " J");
+
+                        break;
+
+                    case '@':
+                        if (DCEvars[0] == 0) DCEvars[0] = 1;
+
+                        if (debug > 1)
+                            debug("ESC [ " + DCEvars[0] + " @");
+
+                        for (int i = 0; i < DCEvars[0]; i++)
+                            insertChar(C, R, ' ', attributes);
+
+                        break;
+
+                    case 'X': {
+                            int toerase = DCEvars[0];
+
+                            if (debug > 1)
+                                debug("ESC [ " + DCEvars[0] + " X, C=" + C + ",R=" + R);
+
+                            if (toerase == 0)
+                                toerase = 1;
+
+                            if (toerase + C > columns)
+                                toerase = columns - C;
+
+                            deleteArea(C, R, toerase, 1, attributes);
+                            // does not change cursor position
+                            break;
+                        }
+
+                    case 'P':
+                        if (debug > 1)
+                            debug("ESC [ " + DCEvars[0] + " P, C=" + C + ",R=" + R);
+
+                        if (DCEvars[0] == 0) DCEvars[0] = 1;
+
+                        for (int i = 0; i < DCEvars[0]; i++)
+                            deleteChar(C, R);
+
+                        break;
+
+                    case 'n':
+                        switch (DCEvars[0]) {
+                            case 5: /* malfunction? No malfunction. */
+                                writeSpecial((ESC) + "[0n");
+
+                                if (debug > 1)
+                                    debug("ESC[5n");
+
+                                break;
+
+                            case 6:
+                                // DO NOT offset R and C by 1! (checked against /usr/X11R6/bin/resize
+                                // FIXME check again.
+                                // FIXME: but vttest thinks different???
+                                writeSpecial((ESC) + "[" + R + ";" + C + "R");
+
+                                if (debug > 1)
+                                    debug("ESC[6n");
+
+                                break;
+
+                            default:
+                                if (debug > 0)
+                                    debug("ESC [ " + DCEvars[0] + " n??");
+
+                                break;
+                        }
+
+                        break;
+
+                    case 's':  /* DECSC - save cursor */
+                        Sc = C;
+                        Sr = R;
+                        Sa = attributes;
+
+                        if (debug > 3)
+                            debug("ESC[s");
+
+                        break;
+
+                    case 'u': /* DECRC - restore cursor */
+                        C = Sc;
+                        R = Sr;
+                        attributes = Sa;
+
+                        if (debug > 3)
+                            debug("ESC[u");
+
+                        break;
+
+                    case 'm':  /* attributes as color, bold , blink,*/
+                        if (debug > 3)
+                            debug("ESC [ ");
+
+                        if (DCEvar == 0 && DCEvars[0] == 0)
+                            attributes = 0;
+
+                        for (int i = 0; i <= DCEvar; i++) {
+                            switch (DCEvars[i]) {
+                                case 0:
+                                    if (DCEvar > 0) {
+                                        if (terminalID.equals("scoansi")) {
+                                            attributes &= COLOR; /* Keeps color. Strange but true. */
+                                        }
+                                        else {
+                                            attributes = 0;
+                                        }
+                                    }
+
+                                    break;
+
+                                case 1:
+                                    attributes |= BOLD;
+                                    attributes &= ~LOW;
+                                    break;
+
+                                case 2:
+
+                                    /* SCO color hack mode */
+                                    if (terminalID.equals("scoansi") && ((DCEvar - i) >= 2)) {
+                                        int ncolor;
+                                        attributes &= ~(COLOR | BOLD);
+                                        ncolor = DCEvars[i + 1];
+
+                                        if ((ncolor & 8) == 8)
+                                            attributes |= BOLD;
+
+                                        ncolor = ((ncolor & 1) << 2) | (ncolor & 2) | ((ncolor & 4) >> 2);
+                                        attributes |= ((ncolor) + 1) << COLOR_FG_SHIFT;
+                                        ncolor = DCEvars[i + 2];
+                                        ncolor = ((ncolor & 1) << 2) | (ncolor & 2) | ((ncolor & 4) >> 2);
+                                        attributes |= ((ncolor) + 1) << COLOR_BG_SHIFT;
+                                        i += 2;
+                                    }
+                                    else {
+                                        attributes |= LOW;
+                                    }
+
+                                    break;
+
+                                case 3: /* italics */
+                                    attributes |= INVERT;
+                                    break;
+
+                                case 4:
+                                    attributes |= UNDERLINE;
+                                    break;
+
+                                case 7:
+                                    attributes |= INVERT;
+                                    break;
+
+                                case 8:
+                                    attributes |= INVISIBLE;
+                                    break;
+
+                                case 5: /* blink on */
+                                    break;
+
+                                /* 10 - ANSI X3.64-1979, select primary font, don't display control
+                                 *      chars, don't set bit 8 on output */
+                                case 10:
+                                    gl = 0;
+                                    usedcharsets = true;
+                                    break;
+
+                                /* 11 - ANSI X3.64-1979, select second alt. font, display control
+                                 *      chars, set bit 8 on output */
+                                case 11: /* SMACS , as */
+                                case 12:
+                                    gl = 1;
+                                    usedcharsets = true;
+                                    break;
+
+                                case 21: /* normal intensity */
+                                    attributes &= ~(LOW | BOLD);
+                                    break;
+
+                                case 23: /* italics off */
+                                    attributes &= ~INVERT;
+                                    break;
+
+                                case 25: /* blinking off */
+                                    break;
+
+                                case 27:
+                                    attributes &= ~INVERT;
+                                    break;
+
+                                case 28:
+                                    attributes &= ~INVISIBLE;
+                                    break;
+
+                                case 24:
+                                    attributes &= ~UNDERLINE;
+                                    break;
+
+                                case 22:
+                                    attributes &= ~BOLD;
+                                    break;
+
+                                case 30:
+                                case 31:
+                                case 32:
+                                case 33:
+                                case 34:
+                                case 35:
+                                case 36:
+                                case 37:
+                                    attributes &= ~COLOR_FG;
+                                    attributes |= ((DCEvars[i] - 30) + 1) << COLOR_FG_SHIFT;
+                                    break;
+
+                                case 38:
+                                    if (DCEvars[i + 1] == 5) {
+                                        attributes &= ~COLOR_FG;
+                                        attributes |= ((DCEvars[i + 2]) + 1) << COLOR_FG_SHIFT;
+                                        i += 2;
+                                    }
+
+                                    break;
+
+                                case 39:
+                                    attributes &= ~COLOR_FG;
+                                    break;
+
+                                case 40:
+                                case 41:
+                                case 42:
+                                case 43:
+                                case 44:
+                                case 45:
+                                case 46:
+                                case 47:
+                                    attributes &= ~COLOR_BG;
+                                    attributes |= ((DCEvars[i] - 40) + 1) << COLOR_BG_SHIFT;
+                                    break;
+
+                                case 48:
+                                    if (DCEvars[i + 1] == 5) {
+                                        attributes &= ~COLOR_BG;
+                                        attributes |= (DCEvars[i + 2] + 1) << COLOR_BG_SHIFT;
+                                        i += 2;
+                                    }
+
+                                    break;
+
+                                case 49:
+                                    attributes &= ~COLOR_BG;
+                                    break;
+
+                                case 90:
+                                case 91:
+                                case 92:
+                                case 93:
+                                case 94:
+                                case 95:
+                                case 96:
+                                case 97:
+                                    attributes &= ~COLOR_FG;
+                                    attributes |= ((DCEvars[i] - 82) + 1) << COLOR_FG_SHIFT;
+                                    break;
+
+                                case 100:
+                                case 101:
+                                case 102:
+                                case 103:
+                                case 104:
+                                case 105:
+                                case 106:
+                                case 107:
+                                    attributes &= ~COLOR_BG;
+                                    attributes |= ((DCEvars[i] - 92) + 1) << COLOR_BG_SHIFT;
+                                    break;
+
+                                default:
+                                    debugStr.append("ESC [ ")
+                                    .append(DCEvars[i])
+                                    .append(" m unknown...");
+                                    debug(debugStr.toString());
+                                    debugStr.setLength(0);
+                                    break;
+                            }
+
+                            if (debug > 3) {
+                                debugStr.append(DCEvars[i])
+                                .append(';');
+                                debug(debugStr.toString());
+                                debugStr.setLength(0);
+                            }
+                        }
+
+                        if (debug > 3) {
+                            debugStr.append(" (attributes = ")
+                            .append(attributes)
+                            .append(")m");
+                            debug(debugStr.toString());
+                            debugStr.setLength(0);
+                        }
+
+                        break;
+
+                    default:
+                        debugStr.append("ESC [ unknown letter: ")
+                        .append(c)
+                        .append(" (")
+                        .append((int)c)
+                        .append(')');
+                        debug(debugStr.toString());
+                        debugStr.setLength(0);
+                        break;
+                }
+
+                break;
+
+            case TSTATE_TITLE:
+                switch (c) {
+                    case ESC:
+                        term_state = TSTATE_ESC;
+                        break;
+
+                    default:
+                        // TODO save title
+                        break;
+                }
+
+                break;
+
+            default:
+                term_state = TSTATE_DATA;
+                break;
+        }
+
+        setCursorPosition(C, R);
+    }
+
+    /* hard reset the terminal */
+    public void reset() {
+        gx[0] = 'B';
+        gx[1] = 'B';
+        gx[2] = 'B';
+        gx[3] = 'B';
+        gl = 0;  // default GL to G0
+        gr = 2;  // default GR to G2
+        onegl = -1; // Single shift override
+        /* reset tabs */
+        int nw = width;
+
+        if (nw < 132) nw = 132;
+
+        Tabs = new byte[nw];
+
+        for (int i = 0; i < nw; i += 8) {
+            Tabs[i] = 1;
+        }
+
+        deleteArea(0, 0, width, height, attributes);
+        setMargins(0, height);
+        C = R = 0;
+        _SetCursor(0, 0);
+
+        if (display != null)
+            display.resetColors();
+
+        showCursor(true);
+        /*FIXME:*/
+        term_state = TSTATE_DATA;
+    }
+}