thinkberg.com

Commit Diff

Commit:: f4da90ffc0fa17ab863ca5ddbbec7c02e0458e06
From:: marcus <marcus@03d0f0ad-74f4-0310-ae7a-cf78699b6f6c>
Date:: Fri Feb 15 14:00:18 2002 UTC
Message:: - Added support for ESC [ ... " <letter> (VT conformance) - Added support for 8bit control output. - Rewrote parts of the Key input handling. - Fixed some bugs. - Added some vt52 support (incomplete).
Actions:: Patch | Tree
commit - de4154976cdc9b37862f87246b1a30991302d4d8
commit + f4da90ffc0fa17ab863ca5ddbbec7c02e0458e06
blob - 6f9aabefe34294ca8db22e8c61c72edc92db1e32
blob + 96d4daf424f25339f31924b4c9e124a13975c564
--- de/mud/terminal/vt320.java
+++ de/mud/terminal/vt320.java
@@ -241,7 +241,7 @@ public abstract class vt320 extends VDU implements Key
 	b[4] = (byte) (0x20 + pos.x + 1);
 	b[5] = (byte) (0x20 + pos.y + 1);
 
-	write(b);
+	write(b); // FIXME: writeSpecial here
       }
       public void mouseReleased(MouseEvent evt) {
         if (mouserpt==0)
@@ -268,7 +268,7 @@ public abstract class vt320 extends VDU implements Key
 	b[3] = (byte)mousecode;
 	b[4] = (byte) (0x20 + pos.x + 1);
 	b[5] = (byte) (0x20 + pos.y + 1);
-	write(b);
+	write(b); // FIXME: writeSpecial here
 	mousebut = 0;
       }
     });
@@ -436,6 +436,8 @@ public abstract class vt320 extends VDU implements Key
   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;
@@ -476,6 +478,7 @@ public abstract class vt320 extends VDU implements Key
   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;
 
   /* The graphics charsets
    * B - default ASCII
@@ -603,18 +606,25 @@ public abstract class vt320 extends VDU implements Key
 
   /**
    * A small conveniance method thar converts a 7bit string to the 8bit
-   * version if VT52 mode is not set.
+   * version depending on VT52/Output8Bit mode.
+   *
    * @param s the string to be sent
-   * @param doecho echo to terminal
    */
-  private boolean writeNumpad(String s) {
-    if (((s.length() == 3) && (s.charAt(0) == 27) && (s.charAt(1)=='O'))) {
+  private boolean writeSpecial(String s) {
+    if (((s.length() >= 3) && (s.charAt(0) == 27) && (s.charAt(1)=='O'))) {
       if (vt52mode) {
       	s="\u001b?"+s.substring(2); /* ESC ? x */
       } else {
-	s="\u008f"+s.substring(2);  /* SS3 ? x */
+        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);
   }
 
@@ -643,33 +653,33 @@ public abstract class vt320 extends VDU implements Key
         if (shift || control)
 	   sendTelnetCommand((byte)243); // BREAK
 	break;
-      case KeyEvent.VK_F1: write(fmap[1],false); break;
-      case KeyEvent.VK_F2: write(fmap[2],false); break;
-      case KeyEvent.VK_F3: write(fmap[3],false); break;
-      case KeyEvent.VK_F4: write(fmap[4],false); break;
-      case KeyEvent.VK_F5: write(fmap[5],false); break;
-      case KeyEvent.VK_F6: write(fmap[6],false); break;
-      case KeyEvent.VK_F7: write(fmap[7],false); break;
-      case KeyEvent.VK_F8: write(fmap[8],false); break;
-      case KeyEvent.VK_F9: write(fmap[9],false); break;
-	  case KeyEvent.VK_F10: write(fmap[10],false); break;
-	  case KeyEvent.VK_F11: write(fmap[11],false); break;
-      case KeyEvent.VK_F12: write(fmap[12],false); break;
-      case KeyEvent.VK_UP: write(KeyUp[xind],false); break;
-      case KeyEvent.VK_DOWN: write(KeyDown[xind],false); break;
-      case KeyEvent.VK_LEFT: write(KeyLeft[xind],false); break;
-      case KeyEvent.VK_RIGHT: write(KeyRight[xind],false); break;
-      case KeyEvent.VK_PAGE_DOWN: write(NextScn[xind],false); break;
-      case KeyEvent.VK_PAGE_UP: write(PrevScn[xind],false); break;
-      case KeyEvent.VK_INSERT: write(Insert[xind],false); break;
-      case KeyEvent.VK_DELETE: write(Remove[xind],false); break;
-      case KeyEvent.VK_ESCAPE: write(Escape[xind],false); break;
-      case KeyEvent.VK_BACK_SPACE: write(BackSpace[xind]); break;
-      case KeyEvent.VK_HOME: write(KeyHome[xind],false); break;
-      case KeyEvent.VK_END: write(KeyEnd[xind],false); break;
+      case KeyEvent.VK_F1: writeSpecial(fmap[1]); break;
+      case KeyEvent.VK_F2: writeSpecial(fmap[2]); break;
+      case KeyEvent.VK_F3: writeSpecial(fmap[3]); break;
+      case KeyEvent.VK_F4: writeSpecial(fmap[4]); break;
+      case KeyEvent.VK_F5: writeSpecial(fmap[5]); break;
+      case KeyEvent.VK_F6: writeSpecial(fmap[6]); break;
+      case KeyEvent.VK_F7: writeSpecial(fmap[7]); break;
+      case KeyEvent.VK_F8: writeSpecial(fmap[8]); break;
+      case KeyEvent.VK_F9: writeSpecial(fmap[9]); break;
+	  case KeyEvent.VK_F10: writeSpecial(fmap[10]); break;
+	  case KeyEvent.VK_F11: writeSpecial(fmap[11]); break;
+      case KeyEvent.VK_F12: writeSpecial(fmap[12]); break;
+      case KeyEvent.VK_UP: writeSpecial(KeyUp[xind]); break;
+      case KeyEvent.VK_DOWN: writeSpecial(KeyDown[xind]); break;
+      case KeyEvent.VK_LEFT: writeSpecial(KeyLeft[xind]); break;
+      case KeyEvent.VK_RIGHT: writeSpecial(KeyRight[xind]); break;
+      case KeyEvent.VK_PAGE_DOWN: writeSpecial(NextScn[xind]); break;
+      case KeyEvent.VK_PAGE_UP: writeSpecial(PrevScn[xind]); break;
+      case KeyEvent.VK_INSERT: writeSpecial(Insert[xind]); break;
+      case KeyEvent.VK_DELETE: writeSpecial(Remove[xind]); break;
+      case KeyEvent.VK_ESCAPE: writeSpecial(Escape[xind]); break;
+      case KeyEvent.VK_BACK_SPACE: writeSpecial(BackSpace[xind]); break;
+      case KeyEvent.VK_HOME: writeSpecial(KeyHome[xind]); break;
+      case KeyEvent.VK_END: writeSpecial(KeyEnd[xind]); break;
       case KeyEvent.VK_NUM_LOCK:
         if(vms && control) {
-	  writeNumpad(PF1);
+	  writeSpecial(PF1);
 	}
 	if(!control)
 	  numlock = !numlock;
@@ -741,29 +751,29 @@ public abstract class vt320 extends VDU implements Key
     if(vms) {
       if(keyChar == 127 && !control) {
 	if (shift) 
-	  writeNumpad(Insert[0]);        //  VMS shift delete = insert
+	  writeSpecial(Insert[0]);        //  VMS shift delete = insert
 	else
-	  writeNumpad(Remove[0]);        //  VMS delete = remove
+	  writeSpecial(Remove[0]);        //  VMS delete = remove
 	return;
       } else if(control)
 	switch(keyChar) {
-	case '0': writeNumpad(Numpad[0]); return;
-	case '1': writeNumpad(Numpad[1]); return;
-	case '2': writeNumpad(Numpad[2]); return;
-	case '3': writeNumpad(Numpad[3]); return;
-	case '4': writeNumpad(Numpad[4]); return;
-	case '5': writeNumpad(Numpad[5]); return;
-	case '6': writeNumpad(Numpad[6]); return;
-	case '7': writeNumpad(Numpad[7]); return;
-	case '8': writeNumpad(Numpad[8]); return;
-	case '9': writeNumpad(Numpad[9]); return;
-	case '.': writeNumpad(KPPeriod); return;
+	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:  writeNumpad(KPMinus); return;
-	case '+': writeNumpad(KPComma); return;
-	case 10:  writeNumpad(KPEnter); return;
-	case '/': writeNumpad(PF2); return;
-	case '*': writeNumpad(PF3); return;
+	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;
@@ -787,18 +797,18 @@ public abstract class vt320 extends VDU implements Key
     if(alt) { fmap = FunctionKeyAlt; xind=3; }
 
     if(evt.isActionKey()) switch(keyCode) {
-      case KeyEvent.VK_NUMPAD0: write(Numpad[0],false); return;
-      case KeyEvent.VK_NUMPAD1: write(Numpad[1],false); return;
-      case KeyEvent.VK_NUMPAD2: write(Numpad[2],false); return;
-      case KeyEvent.VK_NUMPAD3: write(Numpad[3],false); return;
-      case KeyEvent.VK_NUMPAD4: write(Numpad[4],false); return;
-      case KeyEvent.VK_NUMPAD5: write(Numpad[5],false); return;
-      case KeyEvent.VK_NUMPAD6: write(Numpad[6],false); return;
-      case KeyEvent.VK_NUMPAD7: write(Numpad[7],false); return;
-      case KeyEvent.VK_NUMPAD8: write(Numpad[8],false); return;
-      case KeyEvent.VK_NUMPAD9: write(Numpad[9],false); return;
-      case KeyEvent.VK_DECIMAL:	write(NUMDot[xind],false); return;
-      case KeyEvent.VK_ADD: 	write(NUMPlus[xind],false); return;
+      case KeyEvent.VK_NUMPAD0: writeSpecial(Numpad[0]); return;
+      case KeyEvent.VK_NUMPAD1: writeSpecial(Numpad[1]); return;
+      case KeyEvent.VK_NUMPAD2: writeSpecial(Numpad[2]); return;
+      case KeyEvent.VK_NUMPAD3: writeSpecial(Numpad[3]); return;
+      case KeyEvent.VK_NUMPAD4: writeSpecial(Numpad[4]); return;
+      case KeyEvent.VK_NUMPAD5: writeSpecial(Numpad[5]); return;
+      case KeyEvent.VK_NUMPAD6: writeSpecial(Numpad[6]); return;
+      case KeyEvent.VK_NUMPAD7: writeSpecial(Numpad[7]); return;
+      case KeyEvent.VK_NUMPAD8: writeSpecial(Numpad[8]); return;
+      case KeyEvent.VK_NUMPAD9: writeSpecial(Numpad[9]); return;
+      case KeyEvent.VK_DECIMAL:	writeSpecial(NUMDot[xind]); return;
+      case KeyEvent.VK_ADD: 	writeSpecial(NUMPlus[xind]); return;
     }
 
     if (!((keyChar == 8) || (keyChar == 127) || (keyChar =='\r') || (keyChar == '\n'))) {
@@ -1308,7 +1318,7 @@ public abstract class vt320 extends VDU implements Key
 	        mapped = true;
 	        break;
 	      default:
-		System.out.println("Unsupported GL mapping: "+gx[thisgl]+"\n");
+		System.out.println("Unsupported GL mapping: "+gx[thisgl]);
 		break;
 	      }
 	    }
@@ -1322,7 +1332,7 @@ public abstract class vt320 extends VDU implements Key
 		break;
 	      case 'A':case 'B': mapped = true; break;
 	      default:
-		System.out.println("Unsupported GR mapping: "+gx[thisgl]+"\n");
+		System.out.println("Unsupported GR mapping: "+gx[gr]);
 		break;
 	      }
 	    }
@@ -1367,7 +1377,14 @@ public abstract class vt320 extends VDU implements Key
     case TSTATE_ESCSPACE:
       term_state = TSTATE_DATA;
       switch (c) {
-      default: System.out.println("ESC <space> "+c+" unhandled.");
+      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:
+      	System.out.println("ESC <space> "+c+" unhandled.");
       }
       break;
     case TSTATE_ESC:
@@ -1485,10 +1502,12 @@ public abstract class vt320 extends VDU implements Key
         /*application keypad*/
         if (debug>0)
           System.out.println("ESC =");
+	keypadmode = true;
         break;
       case '>': /*normal keypad*/
         if (debug>0)
           System.out.println("ESC >");
+	keypadmode = false;
         break;
       case '7': /*save cursor, attributes, margins */
         Sc = C;		Sr = R;
@@ -1692,7 +1711,7 @@ public abstract class vt320 extends VDU implements Key
 	    break;
 	  case 2: /* DECANM */
 	    vt52mode = true;
-            System.out.println("vt52 mode enabled");
+            //System.out.println("vt52 mode enabled");
 	    break;
 	  case 3: /* 132 columns*/
 	    size = getSize();
@@ -1762,7 +1781,7 @@ public abstract class vt320 extends VDU implements Key
 	    break;
 	  case 2: /* DECANM */
 	    vt52mode = false;
-            System.out.println("vt52 mode disabled");
+            //System.out.println("vt52 mode disabled");
 	    break;
 	  case 3: /* 80 columns*/
 	    size = getSize();
@@ -1828,6 +1847,21 @@ public abstract class vt320 extends VDU implements Key
 	break;
       }
       break;
+    case TSTATE_CSI_TICKS:
+      term_state = TSTATE_DATA;
+      switch (c) {
+      case 'p':
+      	System.out.println("Conformance level: "+DCEvars[0]+" (unsupported),"+DCEvars[1]);
+	if (DCEvars[1]==1)
+	  output8bit = false;
+	else
+	  output8bit = true; /* 0 or 2 */
+      	break;
+      default:
+        System.out.println("Unknown ESC [...  \""+c);
+	break;
+      }
+      break;
     case TSTATE_CSI_DOLLAR:
       term_state = TSTATE_DATA;
       switch (c) {
@@ -1851,6 +1885,9 @@ public abstract class vt320 extends VDU implements Key
     case TSTATE_CSI:
       term_state = TSTATE_DATA;
       switch (c) {
+      case '"':
+      	term_state = TSTATE_CSI_TICKS;
+        break;
       case '$':
 	term_state=TSTATE_CSI_DOLLAR;
 	break;
@@ -2174,13 +2211,15 @@ public abstract class vt320 extends VDU implements Key
       case 'n':
         switch (DCEvars[0]){
         case 5: /* malfunction? No malfunction. */
-          write(((char)ESC)+"[0n",false);
+          writeSpecial(((char)ESC)+"[0n");
           if(debug > 1)
             System.out.println("ESC[5n");
           break;
         case 6:
 	  // DO NOT offset R and C by 1! (checked against /usr/X11R6/bin/resize
-          write(((char)ESC)+"["+R+";"+C+"R",false);
+	  // FIXME check again.
+	  // FIXME: but vttest thinks different???
+          writeSpecial(((char)ESC)+"["+R+";"+C+"R");
           if(debug > 1)
             System.out.println("ESC[6n");
           break;