teraterm/teraterm/vtterm.c

/* Tera Term
 Copyright(C) 1994-1998 T. Teranishi
 All rights reserved. */

/* TERATERM.EXE, VT terminal emulation */
#include "teraterm.h"
#include "tttypes.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <mbstring.h>
#include <locale.h>
#include <ctype.h>

#include "buffer.h"
#include "ttwinman.h"
#include "ttcommon.h"
#include "commlib.h"
#include "vtdisp.h"
#include "keyboard.h"
#include "ttlib.h"
#include "ttftypes.h"
#include "filesys.h"
#include "teraprn.h"
#include "telnet.h"
#include "ttime.h"

#include "vtterm.h"

void ParseFirst(BYTE b);

#define MAPSIZE(x) (sizeof(x)/sizeof((x)[0]))
#define Accept8BitCtrl ((VTlevel >= 2) && (ts.TermFlag & TF_ACCEPT8BITCTRL))

  /* Parsing modes */
#define ModeFirst 0
#define ModeESC   1
#define ModeDCS   2
#define ModeDCUserKey 3
#define ModeSOS   4
#define ModeCSI   5
#define ModeXS    6
#define ModeDLE   7
#define ModeCAN   8

#define NParamMax 16
#define IntCharMax 5

/* DEC Locator Flag */
#define DecLocatorOneShot    1
#define DecLocatorPixel      2
#define DecLocatorButtonDown 4
#define DecLocatorButtonUp   8
#define DecLocatorFiltered   16

void VisualBell();
BOOL DecLocatorReport(int Event, int Button);

/* character attribute */
static TCharAttr CharAttr;

/* various modes of VT emulation */
static BOOL RelativeOrgMode;
static BOOL InsertMode;
static BOOL LFMode;
static BOOL AutoWrapMode;
static BOOL FocusReportMode;
static BOOL AltScr;
BOOL BracketedPaste;

static int VTlevel;

// save/restore cursor
typedef struct {
  int CursorX, CursorY;
  TCharAttr Attr;
  int Glr[2], Gn[4]; // G0-G3, GL & GR
  BOOL AutoWrapMode;
  BOOL RelativeOrgMode;
} TStatusBuff;
typedef TStatusBuff *PStatusBuff;

// status buffer for main screen & status line
static TStatusBuff SBuff1, SBuff2, SBuff3;

static BOOL ESCFlag, JustAfterESC;
static BOOL KanjiIn;
static BOOL EUCkanaIn, EUCsupIn;
static int  EUCcount;
static BOOL Special;

static int Param[NParamMax+1];
static int NParam;
static BOOL FirstPrm;
static BYTE IntChar[IntCharMax+1];
static int ICount;
static BYTE Prv;
static int ParseMode, SavedMode;
static int ChangeEmu;

/* user defined keys */
static BOOL WaitKeyId, WaitHi;

/* GL, GR code group */
static int Glr[2];
/* G0, G1, G2, G3 code group */
static int Gn[4];
/* GL for single shift 2/3 */
static int GLtmp;
/* single shift 2/3 flag */
static BOOL SSflag;
/* JIS -> SJIS conversion flag */
static BOOL ConvJIS;
static WORD Kanji;

// variables for status line mode
static int StatusX=0;
static BOOL StatusWrap=FALSE;
static BOOL StatusCursor=TRUE;
static int MainX, MainY; //cursor registers
static int MainTop, MainBottom; // scroll region registers
static BOOL MainWrap;
static BOOL MainCursor=TRUE;

/* status for printer escape sequences */
static BOOL PrintEX = TRUE;  // printing extent
                            // (TRUE: screen, FALSE: scroll region)
static BOOL AutoPrintMode = FALSE;
static BOOL PrinterMode = FALSE;
static BOOL DirectPrn = FALSE;

/* User key */
static BYTE NewKeyStr[FuncKeyStrMax];
static int NewKeyId, NewKeyLen;

/* Mouse Report */
int MouseReportMode;
unsigned int DecLocatorFlag;
int LastX, LastY;
int ButtonStat;
int FilterTop, FilterBottom, FilterLeft, FilterRight;

/* IME Status */
BOOL IMEstat;

static _locale_t CLocale = NULL;

void ResetSBuffer(PStatusBuff sbuff)
{
  sbuff->CursorX = 0;
  sbuff->CursorY = 0;
  sbuff->Attr = DefCharAttr;
  if (ts.Language==IdJapanese)
  {
    sbuff->Gn[0] = IdASCII;
    sbuff->Gn[1] = IdKatakana;
    sbuff->Gn[2] = IdKatakana;
    sbuff->Gn[3] = IdKanji;
    sbuff->Glr[0] = 0;
    if ((ts.KanjiCode==IdJIS) &&
        (ts.JIS7Katakana==0))
      sbuff->Glr[1] = 2;  // 8-bit katakana
    else
      sbuff->Glr[1] = 3;
  }
  else {
    sbuff->Gn[0] = IdASCII;
    sbuff->Gn[1] = IdSpecial;
    sbuff->Gn[2] = IdASCII;
    sbuff->Gn[3] = IdASCII;
    sbuff->Glr[0] = 0;
    sbuff->Glr[1] = 0;
  }
  sbuff->AutoWrapMode = TRUE;
  sbuff->RelativeOrgMode = FALSE;
}

void ResetAllSBuffers()
{
  ResetSBuffer(&SBuff1);
  // copy SBuff1 to SBuff2
  SBuff2 = SBuff1;
  SBuff3 = SBuff1;
}

void ResetCurSBuffer()
{
    PStatusBuff Buff;

    if (AltScr) {
        Buff = &SBuff3; // Alternate screen buffer
    }
    else {
        Buff = &SBuff1; // Normal screen buffer
    }
    ResetSBuffer(Buff);
    SBuff2 = *Buff;
}

void ResetTerminal() /*reset variables but don't update screen */
{
  DispReset();
  BuffReset();

  /* Attribute */
  CharAttr = DefCharAttr;
  Special = FALSE;
  BuffSetCurCharAttr(CharAttr);

  /* Various modes */
  InsertMode = FALSE;
  LFMode = (ts.CRSend == IdCRLF);
  AutoWrapMode = TRUE;
  AppliKeyMode = FALSE;
  AppliCursorMode = FALSE;
  AppliEscapeMode = FALSE;
  RelativeOrgMode = FALSE;
  ts.ColorFlag &= ~CF_REVERSEVIDEO;
  AutoRepeatMode = TRUE;
  FocusReportMode = FALSE;
  MouseReportMode = IdMouseTrackNone;
  DecLocatorFlag = 0;

  ChangeTerminalID();

  LastX = 0;
  LastY = 0;
  ButtonStat = 0;

  if (CLocale == NULL) {
    CLocale = _create_locale(LC_ALL, "C");
  }

  /* Character sets */
  ResetCharSet();

  /* ESC flag for device control sequence */
  ESCFlag = FALSE;
  /* for TEK sequence */
  JustAfterESC = FALSE;

  /* Parse mode */
  ParseMode = ModeFirst;

  /* Clear printer mode */
  PrinterMode = FALSE;

  // status buffers
  ResetAllSBuffers();

  // Alternate Screen Buffer
  AltScr = FALSE;

  // Bracketed Paste Mode
  BracketedPaste = FALSE;

  // Saved IME Status
  IMEstat = FALSE;
}

void ResetCharSet()
{
  if (ts.Language==IdJapanese)
  {
    Gn[0] = IdASCII;
    Gn[1] = IdKatakana;
    Gn[2] = IdKatakana;
    Gn[3] = IdKanji;
    Glr[0] = 0;
    if ((ts.KanjiCode==IdJIS) &&
        (ts.JIS7Katakana==0))
      Glr[1] = 2;  // 8-bit katakana
    else
      Glr[1] = 3;
  }
  else {
    Gn[0] = IdASCII;
    Gn[1] = IdSpecial;
    Gn[2] = IdASCII;
    Gn[3] = IdASCII;
    Glr[0] = 0;
    Glr[1] = 0;
    cv.SendCode = IdASCII;
    cv.SendKanjiFlag = FALSE;
    cv.EchoCode = IdASCII;
    cv.EchoKanjiFlag = FALSE;
  }
  /* Kanji flag */
  KanjiIn = FALSE;
  EUCkanaIn = FALSE;
  EUCsupIn = FALSE;
  SSflag = FALSE;

  cv.Language = ts.Language;
  cv.CRSend = ts.CRSend;
  cv.KanjiCodeEcho = ts.KanjiCode;
  cv.JIS7KatakanaEcho = ts.JIS7Katakana;
  cv.KanjiCodeSend = ts.KanjiCodeSend;
  cv.JIS7KatakanaSend = ts.JIS7KatakanaSend;
  cv.KanjiIn = ts.KanjiIn;
  cv.KanjiOut = ts.KanjiOut;
}

void ResetKeypadMode(BOOL DisabledModeOnly)
{
  if (!DisabledModeOnly || ts.DisableAppKeypad) AppliKeyMode = FALSE;
  if (!DisabledModeOnly || ts.DisableAppCursor) AppliCursorMode = FALSE;
}

void MoveToMainScreen()
{
  StatusX = CursorX;
  StatusWrap = Wrap;
  StatusCursor = IsCaretEnabled();

  CursorTop = MainTop;
  CursorBottom = MainBottom;
  Wrap = MainWrap;
  DispEnableCaret(MainCursor);
  MoveCursor(MainX,MainY); // move to main screen
}

void MoveToStatusLine()
{
  MainX = CursorX;
  MainY = CursorY;
  MainTop = CursorTop;
  MainBottom = CursorBottom;
  MainWrap = Wrap;
  MainCursor = IsCaretEnabled();

  DispEnableCaret(StatusCursor);
  MoveCursor(StatusX,NumOfLines-1); // move to status line
  CursorTop = NumOfLines-1;
  CursorBottom = CursorTop;
  Wrap = StatusWrap;
}

void HideStatusLine()
{
  if ((StatusLine>0) &&
      (CursorY==NumOfLines-1))
    MoveToMainScreen();
  StatusX = 0;
  StatusWrap = FALSE;
  StatusCursor = TRUE;
  ShowStatusLine(0); //hide
}

void ChangeTerminalSize(int Nx, int Ny)
{
  BuffChangeTerminalSize(Nx,Ny);
  StatusX = 0;
  MainX = 0;
  MainY = 0;
  MainTop = 0;
  MainBottom = NumOfColumns-1;
}

void SendCSIstr(char *str, int len) {
        int l;

        if (str == NULL || len < 0)
                return;

        if (len == 0) {
                l = strlen(str);
        }
        else {
                l = len;
        }

        if (Send8BitMode)
                CommBinaryOut(&cv,"\233", 1);
        else
                CommBinaryOut(&cv,"\033[", 2);

        CommBinaryOut(&cv, str, l);
}

void SendOSCstr(char *str, int len) {
        int l;

        if (str == NULL || len < 0)
                return;

        if (len == 0) {
                l = strlen(str);
        }
        else {
                l = len;
        }

        if (Send8BitMode) {
                CommBinaryOut(&cv,"\235", 1);
                CommBinaryOut(&cv, str, l);
                CommBinaryOut(&cv,"\234", 1);
        }
        else {
                CommBinaryOut(&cv,"\033]", 2);
                CommBinaryOut(&cv, str, l);
                CommBinaryOut(&cv,"\033\\", 2);
        }

}

void SendDCSstr(char *str, int len) {
        int l;

        if (str == NULL || len < 0)
                return;

        if (len == 0) {
                l = strlen(str);
        }
        else {
                l = len;
        }

        if (Send8BitMode) {
                CommBinaryOut(&cv,"\220", 1);
                CommBinaryOut(&cv, str, l);
                CommBinaryOut(&cv,"\234", 1);
        }
        else {
                CommBinaryOut(&cv,"\033P", 2);
                CommBinaryOut(&cv, str, l);
                CommBinaryOut(&cv,"\033\\", 2);
        }

}

void BackSpace()
{
  if (CursorX == 0)
  {
    if ((CursorY>0) &&
        ((ts.TermFlag & TF_BACKWRAP)!=0))
    {
      MoveCursor(NumOfColumns-1,CursorY-1);
//      if (cv.HLogBuf!=0) Log1Byte(BS);
// (2005.2.20 yutaka)
          if (cv.HLogBuf!=0 && !ts.LogTypePlainText) Log1Byte(BS);
    }
  }
  else if (CursorX > 0)
  {
    MoveCursor(CursorX-1,CursorY);
//    if (cv.HLogBuf!=0) Log1Byte(BS);
// (2005.2.20 yutaka)
          if (cv.HLogBuf!=0 && !ts.LogTypePlainText) Log1Byte(BS);
  }
}

void CarriageReturn(BOOL logFlag)
{
#ifndef NO_COPYLINE_FIX
        if (!ts.EnableContinuedLineCopy || logFlag)
#endif /* NO_COPYLINE_FIX */
        if (cv.HLogBuf!=0) Log1Byte(CR);

        if (CursorX>0)
                MoveCursor(0,CursorY);
}

void LineFeed(BYTE b, BOOL logFlag)
{
        /* for auto print mode */
        if ((AutoPrintMode) &&
                (b>=LF) && (b<=FF))
                BuffDumpCurrentLine(b);

#ifndef NO_COPYLINE_FIX
        if (!ts.EnableContinuedLineCopy || logFlag)
#endif /* NO_COPYLINE_FIX */
        if (cv.HLogBuf!=0) Log1Byte(LF);

        if (CursorY < CursorBottom)
                MoveCursor(CursorX,CursorY+1);
        else if (CursorY == CursorBottom) BuffScrollNLines(1);
        else if (CursorY < NumOfLines-StatusLine-1)
                MoveCursor(CursorX,CursorY+1);

#ifndef NO_COPYLINE_FIX
        ClearLineContinued();
#endif /* NO_COPYLINE_FIX */

        if (LFMode) CarriageReturn(logFlag);
}

void Tab()
{
  if (Wrap && !ts.VTCompatTab) {
      CarriageReturn(FALSE);
      LineFeed(LF,FALSE);
#ifndef NO_COPYLINE_FIX
      if (ts.EnableContinuedLineCopy) {
        SetLineContinued();
      }
#endif /* NO_COPYLINE_FIX */
      Wrap = FALSE;
  }
  CursorForwardTab(1, AutoWrapMode);
  if (cv.HLogBuf!=0) Log1Byte(HT);
}

void PutChar(BYTE b)
{
  BOOL SpecialNew;
  TCharAttr CharAttrTmp;

  CharAttrTmp = CharAttr;

  if (PrinterMode) { // printer mode
    WriteToPrnFile(b,TRUE);
    return;
  }

  if (Wrap)
  {
    CarriageReturn(FALSE);
    LineFeed(LF,FALSE);
#ifndef NO_COPYLINE_FIX
    CharAttrTmp.Attr |= ts.EnableContinuedLineCopy ? AttrLineContinued : 0;
#endif /* NO_COPYLINE_FIX */
  }

//  if (cv.HLogBuf!=0) Log1Byte(b);
// (2005.2.20 yutaka)
  if (ts.LogTypePlainText) {
          if (__isascii(b) && !isprint(b)) {
                  // ASCII�������A���\�������������O�����������B
          } else {
                if (cv.HLogBuf!=0) Log1Byte(b);
          }
  } else {
          if (cv.HLogBuf!=0) Log1Byte(b);
  }

  Wrap = FALSE;

  SpecialNew = FALSE;
  if ((b>0x5F) && (b<0x80))
  {
    if (SSflag)
      SpecialNew = (Gn[GLtmp]==IdSpecial);
    else
      SpecialNew = (Gn[Glr[0]]==IdSpecial);
  }
  else if (b>0xDF)
  {
    if (SSflag)
      SpecialNew = (Gn[GLtmp]==IdSpecial);
    else
      SpecialNew = (Gn[Glr[1]]==IdSpecial);
  }

  if (SpecialNew != Special)
  {
    UpdateStr();
    Special = SpecialNew;
  }

  if (Special)
  {
    b = b & 0x7F;
    CharAttrTmp.Attr |= AttrSpecial;
  }
  else
    CharAttrTmp.Attr |= CharAttr.Attr;

  BuffPutChar(b, CharAttrTmp, InsertMode);

  if (CursorX < NumOfColumns-1)
    MoveRight();
  else {
    UpdateStr();
    Wrap = AutoWrapMode;
  }
}

void PutDecSp(BYTE b)
{
  TCharAttr CharAttrTmp;

  CharAttrTmp = CharAttr;

  if (PrinterMode) { // printer mode
    WriteToPrnFile(b, TRUE);
    return;
  }

  if (Wrap) {
    CarriageReturn(FALSE);
    LineFeed(LF, FALSE);
#ifndef NO_COPYLINE_FIX
    CharAttrTmp.Attr |= ts.EnableContinuedLineCopy ? AttrLineContinued : 0;
#endif /* NO_COPYLINE_FIX */
  }

  if (cv.HLogBuf!=0) Log1Byte(b);
/*
  if (ts.LogTypePlainText && __isascii(b) && !isprint(b)) {
    // ASCII�������A���\�������������O�����������B
  } else {
    if (cv.HLogBuf!=0) Log1Byte(b);
  }
 */

  Wrap = FALSE;

  if (!Special) {
    UpdateStr();
    Special = TRUE;
  }

  CharAttrTmp.Attr |= AttrSpecial;
  BuffPutChar(b, CharAttrTmp, InsertMode);

  if (CursorX < NumOfColumns-1)
    MoveRight();
  else {
    UpdateStr();
    Wrap = AutoWrapMode;
  }
}

void PutKanji(BYTE b)
{
#ifndef NO_COPYLINE_FIX
  TCharAttr CharAttrTmp;

  CharAttrTmp = CharAttr;
#endif /* NO_COPYLINE_FIX */
  Kanji = Kanji + b;

  if (PrinterMode && DirectPrn)
  {
    WriteToPrnFile(HIBYTE(Kanji),FALSE);
    WriteToPrnFile(LOBYTE(Kanji),TRUE);
    return;
  }

  if (ConvJIS)
    Kanji = JIS2SJIS((WORD)(Kanji & 0x7f7f));

  if (PrinterMode) { // printer mode
    WriteToPrnFile(HIBYTE(Kanji),FALSE);
    WriteToPrnFile(LOBYTE(Kanji),TRUE);
    return;
  }

  if (Wrap)
  {
    CarriageReturn(FALSE);
    LineFeed(LF,FALSE);
#ifndef NO_COPYLINE_FIX
    if (ts.EnableContinuedLineCopy)
      CharAttrTmp.Attr |= AttrLineContinued;
#endif /* NO_COPYLINE_FIX */
  }
  else if (CursorX > NumOfColumns-2)
    if (AutoWrapMode)
    {
#ifndef NO_COPYLINE_FIX
      if (ts.EnableContinuedLineCopy)
      {
      CharAttrTmp.Attr |= AttrLineContinued;
      if (CursorX == NumOfColumns-1)
        BuffPutChar(0x20, CharAttr, FALSE);
      }
#endif /* NO_COPYLINE_FIX */
      CarriageReturn(FALSE);
      LineFeed(LF,FALSE);
    }
    else return;

  Wrap = FALSE;

  if (cv.HLogBuf!=0)
  {
    Log1Byte(HIBYTE(Kanji));
    Log1Byte(LOBYTE(Kanji));
  }

  if (Special)
  {
    UpdateStr();
    Special = FALSE;
  }

#ifndef NO_COPYLINE_FIX
  BuffPutKanji(Kanji, CharAttrTmp, InsertMode);
#else
  BuffPutKanji(Kanji, CharAttr, InsertMode);
#endif /* NO_COPYLINE_FIX */

  if (CursorX < NumOfColumns-2)
  {
    MoveRight();
    MoveRight();
  }
  else {
    UpdateStr();
    Wrap = AutoWrapMode;
  }
}

void PutDebugChar(BYTE b)
{
        static BYTE buff[3];
        int i = 0;

        if (DebugFlag!=DEBUG_FLAG_NONE) {
  InsertMode = FALSE;
  AutoWrapMode = TRUE;

          if (DebugFlag==DEBUG_FLAG_HEXD) {
                _snprintf(buff,3,"%02X",(unsigned int) b);

                for (;i<2;i++)
                        PutChar(buff[i]);
                PutChar(' ');
          }
          else if (DebugFlag==DEBUG_FLAG_NORM) {

  if ((b & 0x80) == 0x80)
  {
    UpdateStr();
    CharAttr.Attr = AttrReverse;
    b = b & 0x7f;
  }

  if (b<=US)
  {
    PutChar('^');
    PutChar((char)(b+0x40));
  }
  else if (b==DEL)
  {
    PutChar('<');
    PutChar('D');
    PutChar('E');
    PutChar('L');
    PutChar('>');
  }
  else
    PutChar(b);
          }

  if (CharAttr.Attr != AttrDefault)
  {
    UpdateStr();
    CharAttr.Attr = AttrDefault;
  }
        }
}

void PrnParseControl(BYTE b) // printer mode
{
  switch (b) {
    case NUL: return;
    case SO:
      if (! DirectPrn)
      {
        if ((ts.Language==IdJapanese) &&
            (ts.KanjiCode==IdJIS) &&
            (ts.JIS7Katakana==1) &&
            ((ts.TermFlag & TF_FIXEDJIS)!=0))
          Gn[1] = IdKatakana;
        Glr[0] = 1; /* LS1 */
        return;
      }
      break;
    case SI:
      if (! DirectPrn)
      {
        Glr[0] = 0; /* LS0 */
        return;
      }
      break;
    case DC1:
    case DC3: return;
    case ESC:
      ICount = 0;
      JustAfterESC = TRUE;
      ParseMode = ModeESC;
      WriteToPrnFile(0,TRUE); // flush prn buff
      return;
    case CSI:
      if (! Accept8BitCtrl) {
        PutChar(b); /* Disp C1 char in VT100 mode */
        return;
      }
      ICount = 0;
      FirstPrm = TRUE;
      NParam = 1;
      Param[1] = -1;
      Prv = 0;
      ParseMode = ModeCSI;
      WriteToPrnFile(0,TRUE); // flush prn buff
      WriteToPrnFile(b,FALSE);
      return;
  }
  /* send the uninterpreted character to printer */
  WriteToPrnFile(b,TRUE);
}

void ParseControl(BYTE b)
{
  if (PrinterMode) { // printer mode
    PrnParseControl(b);
    return;
  }

  if (b>=0x80) /* C1 char */
  {
    /* English mode */
    if (ts.Language==IdEnglish)
    {
      if (!Accept8BitCtrl) {
        PutChar(b); /* Disp C1 char in VT100 mode */
        return;
      }
    }
    else { /* Japanese mode */
      if ((ts.TermFlag & TF_ACCEPT8BITCTRL)==0)
        return; /* ignore C1 char */
      /* C1 chars are interpreted as C0 chars in VT100 mode */
      if (VTlevel < 2)
        b = b & 0x7F;
    }
  }
  switch (b) {
    /* C0 group */
    case ENQ:
      CommBinaryOut(&cv,&(ts.Answerback[0]),ts.AnswerbackLen);
      break;
    case BEL:
      switch (ts.Beep) {
      case IdBeepOff:
        /* nothing to do */
        break;
      case IdBeepOn:
        MessageBeep(0);
        break;
      case IdBeepVisual:
        VisualBell();
        break;
      }
      break;
    case BS: BackSpace(); break;
    case HT: Tab(); break;

    case LF:
                // ���M�������s�R�[�h�� LF ���������A�T�[�o���� LF ���������������������������A
                // CR+LF���������������������B
                // cf. http://www.neocom.ca/forum/viewtopic.php?t=216
                // (2007.1.21 yutaka)
                if (ts.CRReceive == IdLF) {
                        CarriageReturn(TRUE);
                        LineFeed(b, TRUE);
                        break;
                }

    case VT: LineFeed(b,TRUE); break;

    case FF:
      if ((ts.AutoWinSwitch>0) && JustAfterESC)
      {
        CommInsert1Byte(&cv,b);
        CommInsert1Byte(&cv,ESC);
        ChangeEmu = IdTEK;  /* Enter TEK Mode */
      }
      else
        LineFeed(b,TRUE);
      break;
    case CR:
      CarriageReturn(TRUE);
      if (ts.CRReceive==IdCRLF)
        CommInsert1Byte(&cv,LF);
      break;
    case SO:
      if ((ts.Language==IdJapanese) &&
          (ts.KanjiCode==IdJIS) &&
          (ts.JIS7Katakana==1) &&
          ((ts.TermFlag & TF_FIXEDJIS)!=0))
        Gn[1] = IdKatakana;

      Glr[0] = 1; /* LS1 */
      break;
    case SI: Glr[0] = 0; break; /* LS0 */
    case DLE:
      if ((ts.FTFlag & FT_BPAUTO)!=0)
        ParseMode = ModeDLE; /* Auto B-Plus activation */
      break;
    case CAN:
      if ((ts.FTFlag & FT_ZAUTO)!=0)
        ParseMode = ModeCAN; /* Auto ZMODEM activation */
//      else if (ts.AutoWinSwitch>0)
//              ChangeEmu = IdTEK;  /* Enter TEK Mode */
      else
        ParseMode = ModeFirst;
      break;
    case SUB: ParseMode = ModeFirst; break;
    case ESC:
      ICount = 0;
      JustAfterESC = TRUE;
      ParseMode = ModeESC;
      break;
    case FS:
    case GS:
    case RS:
    case US:
      if (ts.AutoWinSwitch>0)
      {
        CommInsert1Byte(&cv,b);
        ChangeEmu = IdTEK;  /* Enter TEK Mode */
      }
      break;

    /* C1 char */
    case IND: LineFeed(0,TRUE); break;
    case NEL:
      LineFeed(0,TRUE);
      CarriageReturn(TRUE);
      break;
    case HTS: SetTabStop(); break;
    case RI: CursorUpWithScroll(); break;
    case SS2:
      GLtmp = 2;
      SSflag = TRUE;
      break;
    case SS3:
      GLtmp = 3;
      SSflag = TRUE;
      break;
    case DCS:
      SavedMode = ParseMode;
      ESCFlag = FALSE;
      ICount = 0;
      NParam = 1;
      Param[1] = -1;
      Prv = 0;
      ParseMode = ModeDCS;
      break;
    case SOS:
      SavedMode = ParseMode;
      ESCFlag = FALSE;
      ParseMode = ModeSOS;
      break;
    case CSI:
      ICount = 0;
      FirstPrm = TRUE;
      NParam = 1;
      Param[1] = -1;
      Prv = 0;
      ParseMode = ModeCSI;
      break;
    case OSC:
      Param[1] = 0;
      ParseMode = ModeXS;
      break;
    case PM:
    case APC:
      SavedMode = ParseMode;
      ESCFlag = FALSE;
      ParseMode = ModeSOS;
      break;
  }
}

void SaveCursor()
{
  int i;
  PStatusBuff Buff;

  if ((StatusLine>0) &&
      (CursorY==NumOfLines-1))
    Buff = &SBuff2; // for status line
  else if (AltScr) 
    Buff = &SBuff3; // for alternate screen
  else
    Buff = &SBuff1; // for main screen

  Buff->CursorX = CursorX;
  Buff->CursorY = CursorY;
  Buff->Attr = CharAttr;
  Buff->Glr[0] = Glr[0];
  Buff->Glr[1] = Glr[1];
  for (i=0 ; i<=3; i++)
    Buff->Gn[i] = Gn[i];
  Buff->AutoWrapMode = AutoWrapMode;
  Buff->RelativeOrgMode = RelativeOrgMode;
}

void  RestoreCursor()
{
  int i;
  PStatusBuff Buff;
  UpdateStr();

  if ((StatusLine>0) &&
      (CursorY==NumOfLines-1))
    Buff = &SBuff2; // for status line
  else if (AltScr) 
    Buff = &SBuff3; // for alternate screen
  else
    Buff = &SBuff1; // for main screen

  if (Buff->CursorX > NumOfColumns-1)
    Buff->CursorX = NumOfColumns-1;
  if (Buff->CursorY > NumOfLines-1-StatusLine)
    Buff->CursorY = NumOfLines-1-StatusLine;
  MoveCursor(Buff->CursorX,Buff->CursorY);
  CharAttr = Buff->Attr;
  Glr[0] = Buff->Glr[0];
  Glr[1] = Buff->Glr[1];
  for (i=0 ; i<=3; i++)
    Gn[i] = Buff->Gn[i];
  AutoWrapMode = Buff->AutoWrapMode;
  RelativeOrgMode = Buff->RelativeOrgMode;
}

void AnswerTerminalType()
{
  char Tmp[50];

  if (ts.TerminalID<IdVT320)
    strncpy_s(Tmp, sizeof(Tmp),"\033[?", _TRUNCATE);
  else
    strncpy_s(Tmp, sizeof(Tmp),"\233?", _TRUNCATE);

  switch (ts.TerminalID) {
    case IdVT100:
      strncat_s(Tmp,sizeof(Tmp),"1;2",_TRUNCATE);
      break;
    case IdVT100J:
      strncat_s(Tmp,sizeof(Tmp),"5;2",_TRUNCATE);
      break;
    case IdVT101:
      strncat_s(Tmp,sizeof(Tmp),"1;0",_TRUNCATE);
      break;
    case IdVT102:
      strncat_s(Tmp,sizeof(Tmp),"6",_TRUNCATE);
      break;
    case IdVT102J:
      strncat_s(Tmp,sizeof(Tmp),"15",_TRUNCATE);
      break;
    case IdVT220J:
      strncat_s(Tmp,sizeof(Tmp),"62;1;2;5;6;7;8",_TRUNCATE);
      break;
    case IdVT282:
      strncat_s(Tmp,sizeof(Tmp),"62;1;2;4;5;6;7;8;10;11",_TRUNCATE);
      break;
    case IdVT320:
      strncat_s(Tmp,sizeof(Tmp),"63;1;2;6;7;8",_TRUNCATE);
      break;
    case IdVT382:
      strncat_s(Tmp,sizeof(Tmp),"63;1;2;4;5;6;7;8;10;15",_TRUNCATE);
      break;
    case IdVT420:
      strncat_s(Tmp,sizeof(Tmp),"64;1;2;7;8;9;15;18;21",_TRUNCATE);
      break;
    case IdVT520:
      strncat_s(Tmp,sizeof(Tmp),"65;1;2;7;8;9;12;18;19;21;23;24;42;44;45;46",_TRUNCATE);
      break;
    case IdVT525:
      strncat_s(Tmp,sizeof(Tmp),"65;1;2;7;9;12;18;19;21;22;23;24;42;44;45;46",_TRUNCATE);
      break;
  }
  strncat_s(Tmp,sizeof(Tmp),"c",_TRUNCATE);

  CommBinaryOut(&cv,Tmp,strlen(Tmp)); /* Report terminal ID */
}

void ESCSpace(BYTE b)
{
  switch (b) {
    case 'F':   // S7C1T
      Send8BitMode = FALSE;
      break;
    case 'G':   // S8C1T
      if (VTlevel >= 2) {
        Send8BitMode = TRUE;
      }
      break;
  }
}

void ESCSharp(BYTE b)
{
  switch (b) {
    case '8':  /* Fill screen with "E" (DECALN) */
      BuffUpdateScroll();
      BuffFillWithE();
      CursorTop = 0;
      CursorBottom = NumOfLines-1-StatusLine;
      MoveCursor(0,0);
      ParseMode = ModeFirst;
      break;
  }
}

/* select double byte code set */
void ESCDBCSSelect(BYTE b)
{
  int Dist;

  if (ts.Language!=IdJapanese) return;

  switch (ICount) {
    case 1:
      if ((b=='@') || (b=='B'))
      {
        Gn[0] = IdKanji; /* Kanji -> G0 */
        if ((ts.TermFlag & TF_AUTOINVOKE)!=0)
          Glr[0] = 0; /* G0->GL */
      }
      break;
    case 2:
      /* Second intermediate char must be
         '(' or ')' or '*' or '+'. */
      Dist = (IntChar[2]-'(') & 3; /* G0 - G3 */
      if ((b=='1') || (b=='3') ||
          (b=='@') || (b=='B'))
      {
        Gn[Dist] = IdKanji; /* Kanji -> G0-3 */
        if (((ts.TermFlag & TF_AUTOINVOKE)!=0) &&
            (Dist==0))
          Glr[0] = 0; /* G0->GL */
      }
      break;
  }
}

void ESCSelectCode(BYTE b)
{
  switch (b) {
    case '0':
      if (ts.AutoWinSwitch>0)
        ChangeEmu = IdTEK; /* enter TEK mode */
      break;
  }
}

  /* select single byte code set */
void ESCSBCSSelect(BYTE b)
{
  int Dist;

  /* Intermediate char must be
     '(' or ')' or '*' or '+'.  */
  Dist = (IntChar[1]-'(') & 3; /* G0 - G3 */

  switch (b) {
    case '0': Gn[Dist] = IdSpecial; break;
    case '<': Gn[Dist] = IdASCII; break;
    case '>': Gn[Dist] = IdASCII; break;
    case 'A': Gn[Dist] = IdASCII; break;
    case 'B': Gn[Dist] = IdASCII; break;
    case 'H': Gn[Dist] = IdASCII; break;
    case 'I':
      if (ts.Language==IdJapanese)
        Gn[Dist] = IdKatakana;
      break;
    case 'J': Gn[Dist] = IdASCII; break;
  }

  if (((ts.TermFlag & TF_AUTOINVOKE)!=0) &&
      (Dist==0))
    Glr[0] = 0;  /* G0->GL */
}

void PrnParseEscape(BYTE b) // printer mode
{
  int i;

  ParseMode = ModeFirst;
  switch (ICount) {
    /* no intermediate char */
    case 0:
      switch (b) {
        case '[': /* CSI */
          ICount = 0;
          FirstPrm = TRUE;
          NParam = 1;
          Param[1] = -1;
          Prv = 0;
          WriteToPrnFile(ESC,FALSE);
          WriteToPrnFile('[',FALSE);
          ParseMode = ModeCSI;
          return;
      } /* end of case Icount=0 */
      break;
    /* one intermediate char */
    case 1:
      switch (IntChar[1]) {
        case '$':
          if (! DirectPrn)
          {
            ESCDBCSSelect(b);
            return;
          }
          break;
        case '(':
        case ')':
        case '*':
        case '+':
          if (! DirectPrn)
          {
            ESCSBCSSelect(b);
            return;
          }
          break;
      }
      break;
    /* two intermediate char */
    case 2:
      if ((! DirectPrn) &&
          (IntChar[1]=='$') &&
          ('('<=IntChar[2]) &&
          (IntChar[2]<='+'))
      {
        ESCDBCSSelect(b);
        return;
      }
      break;
  }
  // send the uninterpreted sequence to printer
  WriteToPrnFile(ESC,FALSE);
  for (i=1; i<=ICount; i++)
    WriteToPrnFile(IntChar[i],FALSE);
  WriteToPrnFile(b,TRUE);
}

void ParseEscape(BYTE b) /* b is the final char */
{
  if (PrinterMode) { // printer mode
    PrnParseEscape(b);
    return;
  }

  switch (ICount) {
    /* no intermediate char */
    case 0:
      switch (b) {
        case '6': // DECBI
          if (CursorX == 0) {
            BuffScrollRight(1);
          }
          else {
            CursorX--;
          }
        case '7': SaveCursor(); break;
        case '8': RestoreCursor(); break;
        case '9': // DECFI
          if (CursorX == NumOfColumns-1) {
            BuffScrollLeft(1);
          }
          else {
            CursorX++;
          }
        case '=': AppliKeyMode = TRUE; break;
        case '>': AppliKeyMode = FALSE; break;
        case 'D': /* IND */
          LineFeed(0,TRUE);
          break;
        case 'E': /* NEL */
          MoveCursor(0,CursorY);
          LineFeed(0,TRUE);
          break;
        case 'H': /* HTS */
          SetTabStop();
          break;
        case 'M': /* RI */
          CursorUpWithScroll();
          break;
        case 'N': /* SS2 */
          GLtmp = 2;
          SSflag = TRUE;
          break;
        case 'O': /* SS3 */
          GLtmp = 3;
          SSflag = TRUE;
          break;
        case 'P': /* DCS */
          SavedMode = ParseMode;
          ESCFlag = FALSE;
          NParam = 1;
          Param[1] = -1;
          ParseMode = ModeDCS;
          return;
        case 'X': /* SOS */
          SavedMode = ParseMode;
          ESCFlag = FALSE;
          ParseMode = ModeSOS;
          return;
        case 'Z': AnswerTerminalType(); break;
        case '[': /* CSI */
          ICount = 0;
          FirstPrm = TRUE;
          NParam = 1;
          Param[1] = -1;
          Prv = 0;
          ParseMode = ModeCSI;
          return;
        case '\\': break; /* ST */
        case ']': /* XTERM sequence (OSC) */
          NParam = 1;
          Param[1] = 0;
          ParseMode = ModeXS;
          return;
        case '^':
        case '_': /* PM, APC */
          SavedMode = ParseMode;
          ESCFlag = FALSE;
          ParseMode = ModeSOS;
          return;
        case 'c': /* Hardware reset */
          HideStatusLine();
          ResetTerminal();
          ClearUserKey();
          ClearBuffer();
          if (ts.PortType==IdSerial) // reset serial port
            CommResetSerial(&ts, &cv, TRUE);
          break;
        case 'g': /* Visual Bell (screen original?) */
          VisualBell();
          break;
        case 'n': Glr[0] = 2; break; /* LS2 */
        case 'o': Glr[0] = 3; break; /* LS3 */
        case '|': Glr[1] = 3; break; /* LS3R */
        case '}': Glr[1] = 2; break; /* LS2R */
        case '~': Glr[1] = 1; break; /* LS1R */
      } /* end of case Icount=0 */
      break;
    /* one intermediate char */
    case 1:
      switch (IntChar[1]) {
        case ' ': ESCSpace(b); break;
        case '#': ESCSharp(b); break;
        case '$': ESCDBCSSelect(b); break;
        case '%': break;
        case '(':
        case ')':
        case '*':
        case '+':
          ESCSBCSSelect(b);
          break;
      }
      break;
    /* two intermediate char */
    case 2:
      if ((IntChar[1]=='$') &&
          ('('<=IntChar[2]) &&
          (IntChar[2]<='+'))
        ESCDBCSSelect(b);
      else if ((IntChar[1]=='%') &&
               (IntChar[2]=='!'))
        ESCSelectCode(b);
      break;
  }
  ParseMode = ModeFirst;
}

void EscapeSequence(BYTE b)
{
  if (b<=US)
    ParseControl(b);
  else if ((b>=0x20) && (b<=0x2F))
  {
    if (ICount<IntCharMax) ICount++;
    IntChar[ICount] = b;
  }
  else if ((b>=0x30) && (b<=0x7E))
    ParseEscape(b);
  else if ((b>=0x80) && (b<=0x9F))
    ParseControl(b);
  else if (b>=0xA0) {
    ParseMode=ModeFirst;
    ParseFirst(b);
  }

  JustAfterESC = FALSE;
}

  void CSInsertCharacter()
  {
  // Insert space characters at cursor
    int Count;

    BuffUpdateScroll();
    if (Param[1]<1) Param[1] = 1;
    Count = Param[1];
    BuffInsertSpace(Count);
  }

  void CSCursorUp()
  {
    if (Param[1]<1) Param[1] = 1;

    if (CursorY >= CursorTop)
    {
      if (CursorY-Param[1] > CursorTop)
        MoveCursor(CursorX,CursorY-Param[1]);
      else
        MoveCursor(CursorX,CursorTop);
    }
    else {
      if (CursorY > 0)
        MoveCursor(CursorX,CursorY-Param[1]);
      else
        MoveCursor(CursorX,0);
    }
  }

  void CSCursorUp1()
  {
    MoveCursor(0,CursorY);
    CSCursorUp();
  }

  void CSCursorDown()
  {
    if (Param[1]<1) Param[1] = 1;

    if (CursorY <= CursorBottom)
    {
      if (CursorY+Param[1] < CursorBottom)
        MoveCursor(CursorX,CursorY+Param[1]);
      else
        MoveCursor(CursorX,CursorBottom);
    }
    else {
      if (CursorY < NumOfLines-StatusLine-1)
        MoveCursor(CursorX,CursorY+Param[1]);
      else
        MoveCursor(CursorX,NumOfLines-StatusLine);
    }
  }

  void CSCursorDown1()
  {
    MoveCursor(0,CursorY);
    CSCursorDown();
  }

void CSScreenErase()
{
        if (Param[1] == -1) Param[1] = 0;
        BuffUpdateScroll();
        switch (Param[1]) {
        case 0:
                // <ESC>[H(Cursor in left upper corner)�������J�[�\�������������w�������������A
                // <ESC>[J��<ESC>[2J�����������������A�����������A���s�o�b�t�@���X�N���[���A�E�g
                // �����������������B(2005.5.29 yutaka)
                // �R���t�B�O���[�V�������������������������������B(2008.5.3 yutaka)
                if (ts.ScrollWindowClearScreen && 
                        (CursorX == 0 && CursorY == 0)) {
                        //      Erase screen (scroll out)
                        BuffClearScreen();
                        UpdateWindow(HVTWin);

                } else {
                        //      Erase characters from cursor to the end of screen
                        BuffEraseCurToEnd();
                }
                break;

        case 1:
                //      Erase characters from home to cursor
                BuffEraseHomeToCur();
                break;

        case 2:
                //      Erase screen (scroll out)
                BuffClearScreen();
                UpdateWindow(HVTWin);
                break;
        }
}

void CSQSelScreenErase()
{
        if (Param[1] == -1) Param[1] = 0;
        BuffUpdateScroll();
        switch (Param[1]) {
        case 0:
                //      Erase characters from cursor to end
                BuffSelectedEraseCurToEnd();
                break;

        case 1:
                //      Erase characters from home to cursor
                BuffSelectedEraseHomeToCur();
                break;

        case 2:
                //      Erase entire screen
                BuffSelectedEraseScreen();
                break;
        }
}

  void CSInsertLine()
  {
  // Insert lines at current position
    int Count, YEnd;

    if (CursorY < CursorTop) return;
    if (CursorY > CursorBottom) return;
    if (Param[1]<1) Param[1] = 1;
    Count = Param[1];

    YEnd = CursorBottom;
    if (CursorY > YEnd) YEnd = NumOfLines-1-StatusLine;
    if (Count > YEnd+1 - CursorY) Count = YEnd+1 - CursorY;

    BuffInsertLines(Count,YEnd);
  }

  void CSLineErase()
  {
    if (Param[1] == -1) Param[1] = 0;
    BuffUpdateScroll();
    switch (Param[1]) {
      /* erase char from cursor to end of line */
      case 0:
        BuffEraseCharsInLine(CursorX,NumOfColumns-CursorX);
        break;
      /* erase char from start of line to cursor */
      case 1:
        BuffEraseCharsInLine(0,CursorX+1);
        break;
      /* erase entire line */
      case 2:
        BuffEraseCharsInLine(0,NumOfColumns);
        break;
    }
  }

  void CSQSelLineErase()
  {
    if (Param[1] == -1) Param[1] = 0;
    BuffUpdateScroll();
    switch (Param[1]) {
      /* erase char from cursor to end of line */
      case 0:
        BuffSelectedEraseCharsInLine(CursorX,NumOfColumns-CursorX);
        break;
      /* erase char from start of line to cursor */
      case 1:
        BuffSelectedEraseCharsInLine(0,CursorX+1);
        break;
      /* erase entire line */
      case 2:
        BuffSelectedEraseCharsInLine(0,NumOfColumns);
        break;
    }
  }

  void CSDeleteNLines()
  // Delete lines from current line
  {
    int Count, YEnd;

    if (CursorY < CursorTop) return;
    if (CursorY > CursorBottom) return;
    Count = Param[1];
    if (Count<1) Count = 1;

    YEnd = CursorBottom;
    if (CursorY > YEnd) YEnd = NumOfLines-1-StatusLine;
    if (Count > YEnd+1-CursorY) Count = YEnd+1-CursorY;
    BuffDeleteLines(Count,YEnd);
  }

  void CSDeleteCharacter()
  {
  // Delete characters in current line from cursor

    if (Param[1]<1) Param[1] = 1;
    BuffUpdateScroll();
    BuffDeleteChars(Param[1]);
  }

  void CSEraseCharacter()
  {
    if (Param[1]<1) Param[1] = 1;
    BuffUpdateScroll();
    BuffEraseChars(Param[1]);
  }

  void CSScrollUP()
  {
    if (Param[1]<1) Param[1] = 1;
    BuffUpdateScroll();
    BuffRegionScrollUpNLines(Param[1]);
  }

  void CSScrollDown()
  {
    if (Param[1]<1) Param[1] = 1;
    BuffUpdateScroll();
    BuffRegionScrollDownNLines(Param[1]);
  }

  void CSForwardTab()
  {
    if (Param[1]<1) Param[1] = 1;
    CursorForwardTab(Param[1], AutoWrapMode);
  }

  void CSBackwardTab()
  {
    if (Param[1]<1) Param[1] = 1;
    CursorBackwardTab(Param[1]);
  }

  void CSMoveToColumnN()
  {
    if (Param[1]<1) Param[1] = 1;
    Param[1]--;
    if (Param[1] < 0) Param[1] = 0;
    if (Param[1] > NumOfColumns-1) Param[1] = NumOfColumns-1;
    MoveCursor(Param[1],CursorY);
  }

  void CSCursorRight()
  {
    if (Param[1]<1) Param[1] = 1;
    if (CursorX + Param[1] > NumOfColumns-1)
      MoveCursor(NumOfColumns-1,CursorY);
    else
      MoveCursor(CursorX+Param[1],CursorY);
  }

  void CSCursorLeft()
  {
    if (Param[1]<1) Param[1] = 1;
    if (CursorX-Param[1] < 0)
      MoveCursor(0,CursorY);
    else
      MoveCursor(CursorX-Param[1],CursorY);
  }

  void CSMoveToLineN()
  {
    if (Param[1]<1) Param[1] = 1;
    if (RelativeOrgMode)
    {
      if (CursorTop+Param[1]-1 > CursorBottom)
        MoveCursor(CursorX,CursorBottom);
      else
        MoveCursor(CursorX,CursorTop+Param[1]-1);
    }
    else {
      if (Param[1] > NumOfLines-StatusLine)
        MoveCursor(CursorX,NumOfLines-1-StatusLine);
      else
        MoveCursor(CursorX,Param[1]-1);
    }
  }

  void CSMoveToXY()
  {
    int NewX, NewY;

    if (Param[1]<1) Param[1] = 1;
    if ((NParam < 2) || (Param[2]<1)) Param[2] = 1;
    NewX = Param[2] - 1;
    if (NewX > NumOfColumns-1) NewX = NumOfColumns-1;

    if ((StatusLine>0) && (CursorY==NumOfLines-1))
      NewY = CursorY;
    else if (RelativeOrgMode)
    {
      NewY = CursorTop + Param[1] - 1;
      if (NewY > CursorBottom) NewY = CursorBottom;
    }
    else {
      NewY = Param[1] - 1;
      if (NewY > NumOfLines-1-StatusLine)
        NewY = NumOfLines-1-StatusLine;
    }
    MoveCursor(NewX,NewY);
  }

  void CSDeleteTabStop()
  {
    if (Param[1]==-1) Param[1] = 0;
    ClearTabStop(Param[1]);
  }

  void CS_h_Mode()              // SM
  {
    switch (Param[1]) {
      case 2:   // KAM
        KeybEnabled = FALSE; break;
      case 4:   // IRM
        InsertMode = TRUE; break;
      case 12:  // SRM
        ts.LocalEcho = 0;
        if (cv.Ready && cv.TelFlag && (ts.TelEcho>0))
          TelChangeEcho();
        break;
      case 20:  // LF/NL
        LFMode = TRUE;
        ts.CRSend = IdCRLF;
        cv.CRSend = IdCRLF;
        break;
      case 33:  // WYSTCURM
        if (ts.WindowFlag & WF_CURSORCHANGE) {
          ts.NonblinkingCursor = TRUE;
          ChangeCaret();
        }
        break;
      case 34:  // WYULCURM
        if (ts.WindowFlag & WF_CURSORCHANGE) {
          ts.CursorShape = IdHCur;
          ChangeCaret();
        }
        break;
    }
  }

  void CS_i_Mode()              // MC
  {
    if (Param[1]==-1) Param[1] = 0;
    switch (Param[1]) {
      /* print screen */
        //  PrintEX --  TRUE: print screen
        //              FALSE: scroll region
      case 0: BuffPrint(! PrintEX); break;
      /* printer controller mode off */
      case 4: break; /* See PrnParseCS() */
      /* printer controller mode on */
      case 5:
        if (! AutoPrintMode)
          OpenPrnFile();
        DirectPrn = (ts.PrnDev[0]!=0);
        PrinterMode = TRUE;
        break;
    }
  }

  void CS_l_Mode()              // RM
  {
    switch (Param[1]) {
      case 2:   // KAM
        KeybEnabled = TRUE; break;
      case 4:   // IRM
        InsertMode = FALSE; break;
      case 12:  // SRM
        ts.LocalEcho = 1;
        if (cv.Ready && cv.TelFlag && (ts.TelEcho>0))
          TelChangeEcho();
        break;
      case 20:  // LF/NL
        LFMode = FALSE;
        ts.CRSend = IdCR;
        cv.CRSend = IdCR;
        break;
      case 33:  // WYSTCURM
        if (ts.WindowFlag & WF_CURSORCHANGE) {
          ts.NonblinkingCursor = FALSE;
          ChangeCaret();
        }
        break;
      case 34:  // WYULCURM
        if (ts.WindowFlag & WF_CURSORCHANGE) {
          ts.CursorShape = IdBlkCur;
          ChangeCaret();
        }
        break;
    }
  }

  void CS_n_Mode()              // DSR
  {
    char Report[16];
    int Y, len;

    switch (Param[1]) {
      case 5:
        /* Device Status Report -> Ready */
        SendCSIstr("0n", 0);
        break;
      case 6:
        /* Cursor Position Report */
        Y = CursorY+1;
        if ((StatusLine>0) &&
            (Y==NumOfLines))
          Y = 1;
        len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "%u;%uR", CLocale, Y, CursorX+1);
        SendCSIstr(Report, len);
        break;
    }
  }

void CSSetAttr()                // SGR
{
        int i, P;

        UpdateStr();
        for (i=1 ; i<=NParam ; i++)
        {
                P = Param[i];
                if (P<0) P = 0;
                switch (P) {
                case   0:       /* Clear all */
                        if (CharAttr.Attr2 & Attr2Protect) {
                                CharAttr = DefCharAttr;
                                CharAttr.Attr2 |= Attr2Protect;
                        }
                        else {
                                CharAttr = DefCharAttr;
                        }
                        BuffSetCurCharAttr(CharAttr);
                        break;

                case   1:       /* Bold */
                        CharAttr.Attr |= AttrBold;
                        BuffSetCurCharAttr(CharAttr);
                        break;

                case   4:       /* Under line */
                        CharAttr.Attr |= AttrUnder;
                        BuffSetCurCharAttr(CharAttr);
                        break;

                case   5:       /* Blink */
                        CharAttr.Attr |= AttrBlink;
                        BuffSetCurCharAttr(CharAttr);
                        break;

                case   7:       /* Reverse */
                        CharAttr.Attr |= AttrReverse;
                        BuffSetCurCharAttr(CharAttr);
                        break;

                case  22:       /* Bold off */
                        CharAttr.Attr &= ~ AttrBold;
                        BuffSetCurCharAttr(CharAttr);
                        break;

                case  24:       /* Under line off */
                        CharAttr.Attr &= ~ AttrUnder;
                        BuffSetCurCharAttr(CharAttr);
                        break;

                case  25:       /* Blink off */
                        CharAttr.Attr &= ~ AttrBlink;
                        BuffSetCurCharAttr(CharAttr);
                        break;

                case  27:       /* Reverse off */
                        CharAttr.Attr &= ~ AttrReverse;
                        BuffSetCurCharAttr(CharAttr);
                        break;

                case  30:
                case  31:
                case  32:
                case  33:
                case  34:
                case  35:
                case  36:
                case  37:       /* text color */
                        CharAttr.Attr2 |= Attr2Fore;
                        CharAttr.Fore = P - 30;
                        BuffSetCurCharAttr(CharAttr);
                        break;

                case  38:       /* text color (256color mode) */
                        if ((ts.ColorFlag & CF_XTERM256) && i < NParam && Param[i+1] == 5) {
                                i++;
                                if (i < NParam) {
                                        P = Param[++i];
                                        if (P<0) {
                                                P = 0;
                                        }
                                        CharAttr.Attr2 |= Attr2Fore;
                                        CharAttr.Fore = P;
                                        BuffSetCurCharAttr(CharAttr);
                                }
                        }
                        break;

                case  39:       /* Reset text color */
                        CharAttr.Attr2 &= ~ Attr2Fore;
                        CharAttr.Fore = AttrDefaultFG;
                        BuffSetCurCharAttr(CharAttr);
                        break;

                case  40:
                case  41:
                case  42:
                case  43:
                case  44:
                case  45:
                case  46:
                case  47:       /* Back color */
                        CharAttr.Attr2 |= Attr2Back;
                        CharAttr.Back = P - 40;
                        BuffSetCurCharAttr(CharAttr);
                        break;

                case  48:       /* Back color (256color mode) */
                        if ((ts.ColorFlag & CF_XTERM256) && i < NParam && Param[i+1] == 5) {
                                i++;
                                if (i < NParam) {
                                        P = Param[++i];
                                        if (P<0) {
                                                P = 0;
                                        }
                                        CharAttr.Attr2 |= Attr2Back;
                                        CharAttr.Back = P;
                                        BuffSetCurCharAttr(CharAttr);
                                }
                        }
                        break;

                case  49:       /* Reset back color */
                        CharAttr.Attr2 &= ~ Attr2Back;
                        CharAttr.Back = AttrDefaultBG;
                        BuffSetCurCharAttr(CharAttr);
                        break;

                case 90:
                case 91:
                case 92:
                case 93:
                case 94:
                case 95:
                case 96:
                case 97:        /* aixterm style text color */
                        if (ts.ColorFlag & CF_AIXTERM16) {
                                CharAttr.Attr2 |= Attr2Fore;
                                CharAttr.Fore = P - 90 + 8;
                                BuffSetCurCharAttr(CharAttr);
                        }
                        break;

                case 100:
                        if (! (ts.ColorFlag & CF_AIXTERM16)) {
                                /* Reset text and back color */
                                CharAttr.Attr2 &= ~ (Attr2Fore | Attr2Back);
                                CharAttr.Fore = AttrDefaultFG;
                                CharAttr.Back = AttrDefaultBG;
                                BuffSetCurCharAttr(CharAttr);
                                break;
                        }
                        /* fall through to aixterm style back color */

                case 101:
                case 102:
                case 103:
                case 104:
                case 105:
                case 106:
                case 107:       /* aixterm style back color */
                        if (ts.ColorFlag & CF_AIXTERM16) {
                                CharAttr.Attr2 |= Attr2Back;
                                CharAttr.Back = P - 100 + 8;
                                BuffSetCurCharAttr(CharAttr);
                        }
                        break;
                }
        }
}

  void CSSetScrollRegion()
  {
    if ((StatusLine>0) &&
        (CursorY==NumOfLines-1))
    {
      MoveCursor(0,CursorY);
      return;
    }
    if (Param[1]<1) Param[1] =1;
    if ((NParam < 2) | (Param[2]<1))
      Param[2] = NumOfLines-StatusLine;
    Param[1]--;
    Param[2]--;
    if (Param[1] > NumOfLines-1-StatusLine)
      Param[1] = NumOfLines-1-StatusLine;
    if (Param[2] > NumOfLines-1-StatusLine)
      Param[2] = NumOfLines-1-StatusLine;
    if (Param[1] >= Param[2]) return;
    CursorTop = Param[1];
    CursorBottom = Param[2];
    if (RelativeOrgMode) MoveCursor(0,CursorTop);
                    else MoveCursor(0,0);
  }

  void CSSunSequence() /* Sun terminal private sequences */
  {
    int x, y, len;
    char Report[TitleBuffSize*2+10];

    switch (Param[1]) {
      case 1: // De-iconify window
        if (ts.WindowFlag & WF_WINDOWCHANGE)
          DispShowWindow(WINDOW_RESTORE);
        break;
      case 2: // Iconify window
        if (ts.WindowFlag & WF_WINDOWCHANGE)
          DispShowWindow(WINDOW_MINIMIZE);
        break;
      case 3: // set window position
        if (ts.WindowFlag & WF_WINDOWCHANGE) {
          if (NParam < 2) Param[2] = 0;
          if (NParam < 3) Param[3] = 0;
          DispMoveWindow(Param[2], Param[3]);
        }
        break;
      case 4: // set window size
        if (ts.WindowFlag & WF_WINDOWCHANGE) {
          if (NParam < 2) Param[2] = 0;
          if (NParam < 3) Param[3] = 0;
          DispResizeWin(Param[3], Param[2]);
        }
        break;
      case 5: // Raise window
        if (ts.WindowFlag & WF_WINDOWCHANGE)
          DispShowWindow(WINDOW_RAISE);
        break;
      case 6: // Lower window
        if (ts.WindowFlag & WF_WINDOWCHANGE)
          DispShowWindow(WINDOW_LOWER);
        break;
      case 7: // Refresh window
        if (ts.WindowFlag & WF_WINDOWCHANGE)
          DispShowWindow(WINDOW_REFRESH);
        break;
      case 8: /* set terminal size */
        if (ts.WindowFlag & WF_WINDOWCHANGE) {
          if ((Param[2]<=1) || (NParam<2)) Param[2] = 24;
          if ((Param[3]<=1) || (NParam<3)) Param[3] = 80;
          ChangeTerminalSize(Param[3],Param[2]);
        }
        break;
      case 9: // Maximize/Restore window
        if (ts.WindowFlag & WF_WINDOWCHANGE) {
          if (NParam < 2 || Param[2] == 0) {
            DispShowWindow(WINDOW_RESTORE);
          }
          else if (Param[2] == 1) {
            DispShowWindow(WINDOW_MAXIMIZE);
          }
        }
        break;
      case 11: // Report window state
        if (ts.WindowFlag & WF_WINDOWREPORT) {
          len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "%dt", CLocale, DispWindowIconified()?2:1);
          SendCSIstr(Report, len);
        }
        break;
      case 13: // Report window position
        if (ts.WindowFlag & WF_WINDOWREPORT) {
          DispGetWindowPos(&x, &y);
          len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "3;%d;%dt", CLocale, x, y);
          SendCSIstr(Report, len);
        }
        break;
      case 14: /* get window size */
        if (ts.WindowFlag & WF_WINDOWREPORT) {
          DispGetWindowSize(&x, &y);
          len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "4;%d;%dt", CLocale, y, x);
          SendCSIstr(Report, len);
        }
        break;
      case 18: /* get terminal size */
        if (ts.WindowFlag & WF_WINDOWREPORT) {
          len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "8;%u;%u;t", CLocale,
                              NumOfLines-StatusLine, NumOfColumns);
          SendCSIstr(Report, len);
        }
        break;
      case 19: // Report display size (character)
        if (ts.WindowFlag & WF_WINDOWREPORT) {
          DispGetRootWinSize(&x, &y);
          len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "9;%d;%dt", CLocale, y, x);
          SendCSIstr(Report, len);
        }
        break;
      case 20: // Report icon label
        switch (ts.WindowFlag & WF_TITLEREPORT) {
          case IdTitleReportIgnore:
            // nothing to do
            break;
          case IdTitleReportAccept:
            switch (ts.AcceptTitleChangeRequest) {
              case IdTitleChangeRequestOff:
                len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s", CLocale, ts.Title);
                break;
              case IdTitleChangeRequestAhead:
                len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s %s", CLocale, cv.TitleRemote, ts.Title);
                break;
              case IdTitleChangeRequestLast:
                len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s %s", CLocale, ts.Title, cv.TitleRemote);
                break;
              default:
                if (cv.TitleRemote[0] == 0) {
                  len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s", CLocale, ts.Title);
                }
                else {
                  len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s", CLocale, cv.TitleRemote);
                }
            }
            SendOSCstr(Report, len);
            break;
          default: // IdTitleReportEmpty:
            SendOSCstr("L", 0);
            break;
        }
        break;
      case 21: // Report window title
        switch (ts.WindowFlag & WF_TITLEREPORT) {
          case IdTitleReportIgnore:
            // nothing to do
            break;
          case IdTitleReportAccept:
            switch (ts.AcceptTitleChangeRequest) {
              case IdTitleChangeRequestOff:
                len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s", CLocale, ts.Title);
                break;
              case IdTitleChangeRequestAhead:
                len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s %s", CLocale, cv.TitleRemote, ts.Title);
                break;
              case IdTitleChangeRequestLast:
                len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s %s", CLocale, ts.Title, cv.TitleRemote);
                break;
              default:
                if (cv.TitleRemote[0] == 0) {
                  len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s", CLocale, ts.Title);
                }
                else {
                  len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s", CLocale, cv.TitleRemote);
                }
            }
            SendOSCstr(Report, len);
            break;
          default: // IdTitleReportEmpty:
            SendOSCstr("l", 0);
            break;
        }
        break;
    }
  }

  void CSLT(BYTE b)
  {
    switch (b) {
      case 'r':
        if (CanUseIME()) {
          SetIMEOpenStatus(IMEstat);
        }
        break;

      case 's':
        if (CanUseIME()) {
          IMEstat = GetIMEOpenStatus();
        }
        break;

      case 't':
        if (CanUseIME()) {
          SetIMEOpenStatus(Param[1] == 1);
        }
        break;
    }
  }

  void CSEQ(BYTE b)
  {
    char Report[16];
    int len;

    switch (b) {
      case 'c': /* Tertiary terminal report (Tertiary DA) */
        if (Param[1] < 1) {
          len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "!|%8s", CLocale, ts.TerminalUID);
          SendDCSstr(Report, len);
        }
        break;
    }
  }

  void CSGT(BYTE b)
  {
    switch (b) {
      case 'c': /* second terminal report (Secondary DA) */
        if (Param[1] < 1) {
          SendCSIstr(">32;100;2c", 0); /* VT382 */
        }
        break;
      case 'J': // IO-8256 terminal
        if (Param[1]==3) {
          if (Param[2] < 1 || NParam < 2) Param[2] = 1;
          if (Param[3] < 1 || NParam < 3) Param[3] = 1;
          if (Param[4] < 1 || NParam < 4) Param[4] = NumOfLines-StatusLine;
          if (Param[5] < 1 || NParam < 5) Param[5] = NumOfColumns;
          BuffEraseBox(Param[3]-1, Param[2]-1, Param[5]-1, Param[4]-1);
        }
        break;
      case 'K': // IO-8256 terminal
        switch (Param[1]) {
          case 3:
            if (Param[2] < 1 || NParam < 2) Param[2] = 1;
            if (Param[3] < 1 || NParam < 3) Param[3] = 1;
            BuffEraseCharsInLine(Param[2]-1, Param[3]-Param[2]+1);
            break;
          case 5:
            if (NParam < 2) Param[2] = 0;
            if (NParam < 3) Param[3] = 0;
            switch (Param[2]) {
              case 3:
              case 4:
              case 5:
              case 6: // Draw Line
                BuffDrawLine(CharAttr, Param[2], Param[3]);
                break;

              case 12: // Text color
                if ((Param[3]>=0) && (Param[3]<=7)) {
                  switch (Param[3]) {
                    case 3: CharAttr.Fore = IdBlue; break;
                    case 4: CharAttr.Fore = IdCyan; break;
                    case 5: CharAttr.Fore = IdYellow; break;
                    case 6: CharAttr.Fore = IdMagenta; break;
                    default: CharAttr.Fore = Param[3]; break;
                  }
                  CharAttr.Attr2 |= Attr2Fore;
                  BuffSetCurCharAttr(CharAttr);
                }
                break;
            }
            break;
        }
        break;
    }
  }

    void CSQExchangeColor()             // DECSCNM / Visual Bell
    {
      COLORREF ColorRef;

      BuffUpdateScroll();

      if (ts.ColorFlag & CF_REVERSECOLOR) {
        ColorRef = ts.VTColor[0];
        ts.VTColor[0] = ts.VTReverseColor[0];
        ts.VTReverseColor[0] = ColorRef;
        ColorRef = ts.VTColor[1];
        ts.VTColor[1] = ts.VTReverseColor[1];
        ts.VTReverseColor[1] = ColorRef;
      }
      else {
        ColorRef = ts.VTColor[0];
        ts.VTColor[0] = ts.VTColor[1];
        ts.VTColor[1] = ColorRef;
      }

      ColorRef = ts.VTBoldColor[0];
      ts.VTBoldColor[0] = ts.VTBoldColor[1];
      ts.VTBoldColor[1] = ColorRef;

      ColorRef = ts.VTBlinkColor[0];
      ts.VTBlinkColor[0] = ts.VTBlinkColor[1];
      ts.VTBlinkColor[1] = ColorRef;

      ColorRef = ts.URLColor[0];
      ts.URLColor[0] = ts.URLColor[1];
      ts.URLColor[1] = ColorRef;

      ts.ColorFlag ^= CF_REVERSEVIDEO;

#ifdef ALPHABLEND_TYPE2
      BGExchangeColor();
#endif
      DispChangeBackground();
      UpdateWindow(HVTWin);
    }

    void CSQChangeColumnMode(int width)         // DECCOLM
    {
      ChangeTerminalSize(width, NumOfLines-StatusLine);
      if ((ts.TermFlag & TF_CLEARONRESIZE) == 0) {
        MoveCursor(0, 0);
        BuffClearScreen();
        UpdateWindow(HVTWin);
      }
    }

    void CSQ_h_Mode() // DECSET
    {
      int i;

      for (i = 1 ; i<=NParam ; i++)
        switch (Param[i]) {
          case 1: AppliCursorMode = TRUE; break;                // DECCKM
          case 3: CSQChangeColumnMode(132); break;              // DECCOLM
          case 5: /* Reverse Video (DECSCNM) */
            if (!(ts.ColorFlag & CF_REVERSEVIDEO))
              CSQExchangeColor(); /* Exchange text/back color */
            break;
          case 6: // DECOM
            if ((StatusLine>0) && (CursorY==NumOfLines-1))
              MoveCursor(0,CursorY);
            else {
              RelativeOrgMode = TRUE;
              MoveCursor(0,CursorTop);
            }
            break;
          case 7: AutoWrapMode = TRUE; break;           // DECAWM
          case 8: AutoRepeatMode = TRUE; break;         // DECARM
          case 9: /* X10 Mouse Tracking */
            if (ts.MouseEventTracking)
              MouseReportMode = IdMouseTrackX10;
            break;
          case 12: /* att610 cursor blinking */ 
            if (ts.WindowFlag & WF_CURSORCHANGE) {
              ts.NonblinkingCursor = FALSE;
              ChangeCaret();
            }
            break;
          case 19: PrintEX = TRUE; break;               // DECPEX
          case 25: DispEnableCaret(TRUE); break;        // cursor on (DECTCEM)
          case 38: // DECTEK
            if (ts.AutoWinSwitch>0)
              ChangeEmu = IdTEK; /* Enter TEK Mode */
            break;
          case 47: // Alternate Screen Buffer
            if ((ts.TermFlag & TF_ALTSCR) && !AltScr) {
              BuffSaveScreen();
              AltScr = TRUE;
            }
            break;
          case 59:
            if (ts.Language==IdJapanese)
            { /* kanji terminal */
              Gn[0] = IdASCII;
              Gn[1] = IdKatakana;
              Gn[2] = IdKatakana;
              Gn[3] = IdKanji;
              Glr[0] = 0;
              if ((ts.KanjiCode==IdJIS) &&
                  (ts.JIS7Katakana==0))
                Glr[1] = 2;  // 8-bit katakana
              else
                Glr[1] = 3;
            }
            break;
          case 66: AppliKeyMode = TRUE; break;          // DECNKM
          case 67: ts.BSKey = IdBS; break;              // DECBKM
          case 1000: // Mouse Tracking
            if (ts.MouseEventTracking)
              MouseReportMode = IdMouseTrackVT200;
            break;
          case 1001: // Hilite Mouse Tracking
            if (ts.MouseEventTracking)
              MouseReportMode = IdMouseTrackVT200Hl;
            break;
          case 1002: // Button-Event Mouse Tracking
            if (ts.MouseEventTracking)
              MouseReportMode = IdMouseTrackBtnEvent;
            break;
          case 1003: // Any-Event Mouse Tracking
            if (ts.MouseEventTracking)
              MouseReportMode = IdMouseTrackAllEvent;
            break;
          case 1004: // Focus Report
            if (ts.MouseEventTracking)
              FocusReportMode = TRUE;
            break;
          case 1047: // Alternate Screen Buffer
            if ((ts.TermFlag & TF_ALTSCR) && !AltScr) {
              BuffSaveScreen();
              AltScr = TRUE;
            }
            break;
          case 1048: // Save Cursor Position (Alternate Screen Buffer)
            if (ts.TermFlag & TF_ALTSCR) {
              SaveCursor();
            }
            break;
          case 1049: // Alternate Screen Buffer
            if ((ts.TermFlag & TF_ALTSCR) && !AltScr) {
              SaveCursor();
              BuffSaveScreen();
              BuffClearScreen();
              AltScr = TRUE;
            }
            break;
          case 2004: // Bracketed Paste Mode
            BracketedPaste = TRUE;
            break;
          case 7727: // mintty Application Escape Mode
            AppliEscapeMode = TRUE;
            break;
        }
    }

    void CSQ_i_Mode()           // DECMC
    {
      if (Param[1]==-1) Param[1] = 0;
      switch (Param[1]) {
        case 1:
          OpenPrnFile();
          BuffDumpCurrentLine(LF);
          if (! AutoPrintMode)
            ClosePrnFile();
          break;
        /* auto print mode off */
        case 4:
          if (AutoPrintMode)
          {
            ClosePrnFile();
            AutoPrintMode = FALSE;
          }
          break;
        /* auto print mode on */
        case 5:
          if (! AutoPrintMode)
          {
            OpenPrnFile();
            AutoPrintMode = TRUE;
          }
          break;
      }
    }

    void CSQ_l_Mode()           // DECRST
    {
      int i;

      for (i = 1 ; i <= NParam ; i++)
        switch (Param[i]) {
          case 1: AppliCursorMode = FALSE; break;               // DECCKM
          case 3: CSQChangeColumnMode(80); break;               // DECCOLM
          case 5: /* Normal Video (DECSCNM) */
            if (ts.ColorFlag & CF_REVERSEVIDEO)
              CSQExchangeColor(); /* Exchange text/back color */
            break;
          case 6: // DECOM
            if ((StatusLine>0) && (CursorY==NumOfLines-1))
              MoveCursor(0,CursorY);
            else {
              RelativeOrgMode = FALSE;
              MoveCursor(0,0);
            }
            break;
          case 7: AutoWrapMode = FALSE; break;          // DECAWM
          case 8: AutoRepeatMode = FALSE; break;        // DECARM
          case 9: MouseReportMode = IdMouseTrackNone; break; /* X10 Mouse Tracking */
          case 12: /* att610 cursor blinking */ 
            if (ts.WindowFlag & WF_CURSORCHANGE) {
              ts.NonblinkingCursor = TRUE;
              ChangeCaret();
            }
            break;
          case 19: PrintEX = FALSE; break;              // DECPEX
          case 25: DispEnableCaret(FALSE); break;       // cursor off (DECTCEM)
          case 47: // Alternate Screen Buffer
            if ((ts.TermFlag & TF_ALTSCR) && AltScr) {
              BuffRestoreScreen();
              AltScr = FALSE;
            }
            break;
          case 59:
            if (ts.Language==IdJapanese)
            { /* katakana terminal */
              Gn[0] = IdASCII;
              Gn[1] = IdKatakana;
              Gn[2] = IdKatakana;
              Gn[3] = IdKanji;
              Glr[0] = 0;
              if ((ts.KanjiCode==IdJIS) &&
                  (ts.JIS7Katakana==0))
                Glr[1] = 2;  // 8-bit katakana
              else
                Glr[1] = 3;
            }
            break;
          case 66: AppliKeyMode = FALSE; break;         // DECNKM
          case 67: ts.BSKey = IdDEL; break;             // DECBKM
          case 1000: // Mouse Tracking
          case 1001: // Hilite Mouse Tracking
          case 1002: // Button-Event Mouse Tracking
          case 1003: // Any-Event Mouse Tracking
            MouseReportMode = IdMouseTrackNone;
            break;
          case 1004: FocusReportMode = FALSE; break; // Focus Report
          case 1047: // Alternate Screen Buffer
            if ((ts.TermFlag & TF_ALTSCR) && AltScr) {
              BuffClearScreen();
              BuffRestoreScreen();
              AltScr = FALSE;
            }
            break;
          case 1048: // Save Cursor Position (Alternate Screen Buffer)
            if (ts.TermFlag & TF_ALTSCR) {
              RestoreCursor();
            }
            break;
          case 1049: // Alternate Screen Buffer
            if ((ts.TermFlag & TF_ALTSCR) && AltScr) {
              BuffClearScreen();
              BuffRestoreScreen();
              AltScr = FALSE;
              RestoreCursor();
            }
            break;
          case 2004: // Bracketed Paste Mode
            BracketedPaste = FALSE;
            break;
          case 7727: // mintty Application Escape Mode
            AppliEscapeMode = FALSE;
            break;
        }
    }

    void CSQ_n_Mode()           // DECDSR
    {
      switch (Param[1]) {
        case 53:
        case 55:
          /* Locator Device Status Report -> Ready */
          SendCSIstr("?50n", 0);
          break;
      }
    }

  void CSQuest(BYTE b)
  {
    switch (b) {
      case 'J': CSQSelScreenErase(); break;     // DECSED
      case 'K': CSQSelLineErase(); break;       // DECSEL
      case 'h': CSQ_h_Mode(); break;            // DECSET
      case 'i': CSQ_i_Mode(); break;            // DECMC
      case 'l': CSQ_l_Mode(); break;            // DECRST
      case 'n': CSQ_n_Mode(); break;            // DECDSR
    }
  }

  void SoftReset()
  // called by software-reset escape sequence handler
  {
    UpdateStr();
    AutoRepeatMode = TRUE;
    DispEnableCaret(TRUE); // cursor on
    InsertMode = FALSE;
    RelativeOrgMode = FALSE;
    AppliKeyMode = FALSE;
    AppliCursorMode = FALSE;
    AppliEscapeMode = FALSE;
    if ((StatusLine>0) &&
        (CursorY == NumOfLines-1))
      MoveToMainScreen();
    CursorTop = 0;
    CursorBottom = NumOfLines-1-StatusLine;
    ResetCharSet();

    /* Attribute */
    CharAttr = DefCharAttr;
    Special = FALSE;
    BuffSetCurCharAttr(CharAttr);

    // status buffers
    ResetCurSBuffer();

    // Saved IME status
    IMEstat = FALSE;
  }

  void CSExc(BYTE b)
  {
    switch (b) {
      case 'p':
        /* Software reset */
        SoftReset();
        break;
    }
  }

  void CSDouble(BYTE b)
  {
    switch (b) {
      case 'p': // DECSCL
        /* Select terminal mode (software reset) */
        SoftReset();
        if (NParam > 0) {
          ChangeTerminalID();
          if (Param[1] >= 61 && Param[1] <= 65) {
            if (VTlevel > Param[1] - 60) {
              VTlevel = Param[1] - 60;
            }
          }
          else {
            VTlevel = 1;
          }

          if (VTlevel < 2 || (NParam > 1 && Param[2] == 1))
            Send8BitMode = FALSE;
          else
            Send8BitMode = TRUE;
        }
        break;

      case 'q': // DECSCA
        if (Param[1] < 0) 
          Param[1] = 0;
        switch (Param[1]) {
          case 0:
          case 2:
            CharAttr.Attr2 &= ~Attr2Protect;
            BuffSetCurCharAttr(CharAttr);
            break;
          case 1:
            CharAttr.Attr2 |= Attr2Protect;
            BuffSetCurCharAttr(CharAttr);
            break;
          default:
            /* nothing to do */
            break;
        }
        break;
    }
  }

  void CSDol(BYTE b)
  {
    switch (b) {
      case 'z': // DECERA
      case '{': // DECSERA
        if (Param[1] < 1 || NParam < 1) Param[1]=1;
        if (Param[2] < 1 || NParam < 2) Param[2]=1;
        if (Param[3] < 1 || NParam < 3) Param[3]=NumOfLines-StatusLine;
        if (Param[4] < 1 || NParam < 4) Param[4]=NumOfColumns;
        if (RelativeOrgMode) {
          Param[1] += CursorTop;
          if (Param[1] > CursorBottom) {
            Param[1] = CursorBottom + 1;
          }
          Param[3] += CursorTop;
          if (Param[3] > CursorBottom) {
            Param[3] = CursorBottom + 1;
          }
        }
        if (b == 'z') {
          BuffEraseBox(Param[2]-1, Param[1]-1, Param[4]-1, Param[3]-1);
        }
        else {
          BuffSelectEraseBox(Param[2]-1, Param[1]-1, Param[4]-1, Param[3]-1);
        }
        break;

      case '}': // DECSASD
        if ((ts.TermFlag & TF_ENABLESLINE)==0) return;
        if (StatusLine==0) return;
        if ((Param[1]<1) && (CursorY==NumOfLines-1))
          MoveToMainScreen();
        else if ((Param[1]==1) && (CursorY<NumOfLines-1))
          MoveToStatusLine();
        break;
      case '~': // DECSSDT
        if ((ts.TermFlag & TF_ENABLESLINE)==0) return;
        if (Param[1]<=1)
          HideStatusLine();
        else if ((StatusLine==0) && (Param[1]==2))
          ShowStatusLine(1); // show
        break;
    }
  }

  void CSQuote(BYTE b)
  {
    int i, x, y;
    switch (b) {
      case 'w': // Enable Filter Rectangle (DECEFR)
        if (MouseReportMode == IdMouseTrackDECELR) {
          if (DecLocatorFlag & DecLocatorPixel) {
            x = LastX + 1;
            y = LastY + 1;
          }
          else {
            DispConvWinToScreen(LastX, LastY, &x, &y, NULL);
            x++;
            y++;
          }
          FilterTop    = (NParam<1 || Param[1]<1)? y : Param[1];
          FilterLeft   = (NParam<2 || Param[2]<1)? x : Param[2];
          FilterBottom = (NParam<3 || Param[3]<1)? y : Param[3];
          FilterRight  = (NParam<4 || Param[4]<1)? x : Param[4];
          if (FilterTop > FilterBottom) {
            i = FilterTop; FilterTop = FilterBottom; FilterBottom = i;
          }
          if (FilterLeft > FilterRight) {
            i = FilterLeft; FilterLeft = FilterRight; FilterRight = i;
          }
          DecLocatorFlag |= DecLocatorFiltered;
          DecLocatorReport(IdMouseEventMove, 0);
        }
        break;

      case 'z': // Enable DEC Locator reporting (DECELR)
        if (Param[1] < 0) {
          Param[1] = 0;
        }
        switch (Param[1]) {
        case 0:
          if (MouseReportMode == IdMouseTrackDECELR) {
            MouseReportMode = IdMouseTrackNone;
          }
          break;
        case 1:
          if (ts.MouseEventTracking) {
            MouseReportMode = IdMouseTrackDECELR;
            DecLocatorFlag &= ~DecLocatorOneShot;
          }
          break;
        case 2:
          if (ts.MouseEventTracking) {
            MouseReportMode = IdMouseTrackDECELR;
            DecLocatorFlag |= DecLocatorOneShot;
          }
          break;
        }
        if (NParam > 1 && Param[2] == 1) {
          DecLocatorFlag |= DecLocatorPixel;
        }
        else {
          DecLocatorFlag &= ~DecLocatorPixel;
        }
        break;

      case '{': // Select Locator Events (DECSLE)
        for (i=1; i<=NParam; i++) {
          if (Param[i] < 0) {
            Param[i] = 0;
          }
          switch (Param[i]) {
          case 0:
            DecLocatorFlag &= ~(DecLocatorButtonUp | DecLocatorButtonDown | DecLocatorFiltered);
            break;
          case 1:
            DecLocatorFlag |= DecLocatorButtonDown;
            break;
          case 2:
            DecLocatorFlag &= ~DecLocatorButtonDown;
            break;
          case 3:
            DecLocatorFlag |= DecLocatorButtonUp;
            break;
          case 4:
            DecLocatorFlag &= ~DecLocatorButtonUp;
            break;
          }
        }
        break;

      case '|': // Request Locator Position (DECRQLP)
        DecLocatorReport(IdMouseEventCurStat, 0);
        break;
    }
  }

  void CSSpace(BYTE b) {
    switch (b) {
      case 'q':
        if (ts.WindowFlag & WF_CURSORCHANGE) {
          if (NParam > 0) {
            if (Param[1] < 0) Param[1] = 0;
            switch (Param[1]) {
              case 0:
              case 1:
                ts.CursorShape = IdBlkCur;
                ts.NonblinkingCursor = FALSE;
                break;
              case 2:
                ts.CursorShape = IdBlkCur;
                ts.NonblinkingCursor = TRUE;
                break;
              case 3:
                ts.CursorShape = IdHCur;
                ts.NonblinkingCursor = FALSE;
                break;
              case 4:
                ts.CursorShape = IdHCur;
                ts.NonblinkingCursor = TRUE;
                break;
              case 5:
                ts.CursorShape = IdVCur;
                ts.NonblinkingCursor = FALSE;
                break;
              case 6:
                ts.CursorShape = IdVCur;
                ts.NonblinkingCursor = TRUE;
                break;
              default:
                return;
            }
            ChangeCaret();
          }
        }
        break;
    }
  }

void PrnParseCS(BYTE b) // printer mode
{
  ParseMode = ModeFirst;
  switch (ICount) {
    /* no intermediate char */
    case 0:
      switch (Prv) {
        /* no private parameter */
        case 0:
          switch (b) {
            case 'i':
              if (Param[1]==4)
              {
                PrinterMode = FALSE;
                // clear prn buff
                WriteToPrnFile(0,FALSE);
                if (! AutoPrintMode)
                  ClosePrnFile();
                return;
              }
              break;
          } /* of case Prv=0 */
          break;
      }
      break;
    /* one intermediate char */
    case 1: break;
  } /* of case Icount */

  WriteToPrnFile(b,TRUE);
}

void ParseCS(BYTE b) /* b is the final char */
{
  if (PrinterMode) { // printer mode
    PrnParseCS(b);
    return;
  }

  switch (ICount) {
    /* no intermediate char */
    case 0:
      switch (Prv) {
        /* no private parameter */
        case 0:
          switch (b) {
            // ISO/IEC 6429 / ECMA-48 Sequence
            case '@': CSInsertCharacter(); break;       // ICH
            case 'A': CSCursorUp(); break;              // CUU
            case 'B': CSCursorDown(); break;            // CUD
            case 'C': CSCursorRight(); break;           // CUF
            case 'D': CSCursorLeft(); break;            // CUB
            case 'E': CSCursorDown1(); break;           // CNL
            case 'F': CSCursorUp1(); break;             // CPL
            case 'G': CSMoveToColumnN(); break;         // CHA
            case 'H': CSMoveToXY(); break;              // CUP
            case 'I': CSForwardTab(); break;            // CHT
            case 'J': CSScreenErase(); break;           // ED
            case 'K': CSLineErase(); break;             // EL
            case 'L': CSInsertLine(); break;            // IL
            case 'M': CSDeleteNLines(); break;          // DL
//          case 'N': break;                            // EF   -- Not support
//          case 'O': break;                            // EA   -- Not support
            case 'P': CSDeleteCharacter(); break;       // DCH
//          case 'Q': break;                            // SEE  -- Not support
//          case 'R': break;                            // CPR  -- Report only, ignore.
            case 'S': CSScrollUP(); break;              // SU
            case 'T': CSScrollDown(); break;            // SD
//          case 'U': break;                            // NP   -- Not support
//          case 'V': break;                            // PP   -- Not support
//          case 'W': break;                            // CTC  -- Not support
            case 'X': CSEraseCharacter(); break;        // ECH
//          case 'Y': break;                            // CVT  -- Not support
            case 'Z': CSBackwardTab(); break;           // CBT
//          case '[': break;                            // SRS  -- Not support
//          case '\\': break;                           // PTX  -- Not support
//          case ']': break;                            // SDS  -- Not support
//          case '^': break;                            // SIMD -- Not support
            case '`': CSMoveToColumnN(); break;         // HPA
            case 'a': CSCursorRight(); break;           // HPR
//          case 'b': break;                            // REP  -- Not support
            case 'c': AnswerTerminalType(); break;      // DA
            case 'd': CSMoveToLineN(); break;           // VPA
            case 'e': CSCursorDown(); break;            // VPR
            case 'f': CSMoveToXY(); break;              // HVP
            case 'g': CSDeleteTabStop(); break;         // TBC
            case 'h': CS_h_Mode(); break;               // SM
            case 'i': CS_i_Mode(); break;               // MC
            case 'j': CSCursorLeft(); break;            // HPB
            case 'k': CSCursorUp();                     // VPB
            case 'l': CS_l_Mode(); break;               // RM
            case 'm': CSSetAttr(); break;               // SGR
            case 'n': CS_n_Mode(); break;               // DSR
//          case 'o': break;                            // DAQ  -- Not support

            // Private Sequence
            case 'r': CSSetScrollRegion(); break;       // DECSTBM
            case 's': SaveCursor(); break;              // SCP (Save cursor (ANSI.SYS/SCO?))
            case 't': CSSunSequence(); break;           // DECSLPP / Window manipulation(dtterm?)
            case 'u': RestoreCursor(); break;           // RCP (Restore cursor (ANSI.SYS/SCO))
          } /* of case Prv=0 */
          break;
        /* private parameter = '<' */
        case '<': CSLT(b); break;
        /* private parameter = '=' */
        case '=': CSEQ(b); break;
        /* private parameter = '>' */
        case '>': CSGT(b); break;
        /* private parameter = '?' */
        case '?': CSQuest(b); break;
      } /* end of siwtch (Prv) */
      break;
    /* one intermediate char */
    case 1:
      switch (IntChar[1]) {
        /* intermediate char = ' ' */
        case ' ': CSSpace(b); break;
        /* intermediate char = '!' */
        case '!': CSExc(b); break;
        /* intermediate char = '"' */
        case '"': CSDouble(b); break;
        /* intermediate char = '$' */
        case '$': CSDol(b); break;
        /* intermediate char = '\'' */
        case '\'': CSQuote(b); break;
      }
      break;
  } /* of case Icount */

  ParseMode = ModeFirst;
}

void ControlSequence(BYTE b)
{
  if ((b<=US) || (b>=0x80) && (b<=0x9F))
    ParseControl(b); /* ctrl char */
  else if ((b>=0x40) && (b<=0x7E))
    ParseCS(b); /* terminate char */
  else {
    if (PrinterMode)
      WriteToPrnFile(b,FALSE);

    if ((b>=0x20) && (b<=0x2F))
    { /* intermediate char */
      if (ICount<IntCharMax) ICount++;
      IntChar[ICount] = b;
    }
    else if ((b>=0x30) && (b<=0x39))
    {
      if (Param[NParam] < 0)
        Param[NParam] = 0;
      if (Param[NParam]<1000)
       Param[NParam] = Param[NParam]*10 + b - 0x30;
    }
    else if (b==0x3B)
    {
      if (NParam < NParamMax)
      {
        NParam++;
        Param[NParam] = -1;
      }
    }
    else if ((b>=0x3C) && (b<=0x3F))
    { /* private char */
      if (FirstPrm) Prv = b;
    }
    else if (b>0xA0) {
      ParseMode=ModeFirst;
      ParseFirst(b);
    }
  }
  FirstPrm = FALSE;
}

void RequestStatusString(unsigned char *StrBuff, int StrLen)    // DECRQSS
{
        unsigned char RepStr[256];
        int len = 0;

        switch (StrBuff[0]) {
        case '"':
                switch (StrBuff[1]) {
                case 'p': // DECSCL
                        if (VTlevel > 1 && Send8BitMode) {
                                len = _snprintf_s_l(RepStr, sizeof(RepStr), _TRUNCATE, "0$r6%d;0\"p", CLocale, VTlevel);
                        }
                        else {
                                len = _snprintf_s_l(RepStr, sizeof(RepStr), _TRUNCATE, "0$r6%d;1\"p", CLocale, VTlevel);
                        }
                        break;

                case 'q': // DECSCA
                        if (CharAttr.Attr2 & Attr2Protect) {
                                len = _snprintf_s_l(RepStr, sizeof(RepStr), _TRUNCATE, "0$r1\"q", CLocale);
                        }
                        else {
                                len = _snprintf_s_l(RepStr, sizeof(RepStr), _TRUNCATE, "0$r0\"q", CLocale);
                        }
                        break;
                }
                break;
        case 'm':       // SGR
                if (StrBuff[1] == 0) {
                        RepStr[0] = '0';
                        RepStr[1] = '$';
                        RepStr[2] = 'r';
                        len = 3;
                        if (CharAttr.Attr & AttrBold) {
                                RepStr[len++] = '1';
                                RepStr[len++] = ';';
                        }
                        if (CharAttr.Attr & AttrUnder) {
                                RepStr[len++] = '4';
                                RepStr[len++] = ';';
                        }
                        if (CharAttr.Attr & AttrBlink) {
                                RepStr[len++] = '5';
                                RepStr[len++] = ';';
                        }
                        if (CharAttr.Attr & AttrReverse) {
                                RepStr[len++] = '7';
                                RepStr[len++] = ';';
                        }
                        if (CharAttr.Attr2 & Attr2Fore) {
                                if (CharAttr.Fore <= 7) {
                                        RepStr[len++] = '3';
                                        RepStr[len++] = '0' + CharAttr.Fore;
                                        RepStr[len++] = ';';
                                }
                                else if (CharAttr.Fore <= 15) {
                                        RepStr[len++] = '9';
                                        RepStr[len++] = '0' + CharAttr.Fore - 8;
                                        RepStr[len++] = ';';
                                }
                                else {
                                        len += _snprintf_s_l(&RepStr[len], sizeof(RepStr) - len, _TRUNCATE, "38;5;%d;", CLocale, CharAttr.Fore);
                                }
                        }
                        if (CharAttr.Attr2 & Attr2Back) {
                                if (CharAttr.Back <= 7) {
                                        RepStr[len++] = '4';
                                        RepStr[len++] = '0' + CharAttr.Back;
                                        RepStr[len++] = ';';
                                }
                                else if (CharAttr.Back <= 15) {
                                        RepStr[len++] = '1';
                                        RepStr[len++] = '0';
                                        RepStr[len++] = '0' + CharAttr.Back - 8;
                                        RepStr[len++] = ';';
                                }
                                else {
                                        len += _snprintf_s_l(&RepStr[len], sizeof(RepStr) - len, _TRUNCATE, "48;5;%d;", CLocale, CharAttr.Back);
                                }
                        }
                        if (len == 3) {
                                RepStr[len++] = '0';
                        }
                        else {
                                len--;
                        }
                        RepStr[len++] = 'm';
                        RepStr[len] = 0;
                }
                break;
        case 'r':       // DECSTBM
                if (StrBuff[1] == 0) {
                        len = _snprintf_s_l(RepStr, sizeof(RepStr), _TRUNCATE, "0$r%d;%dr", CLocale, CursorTop+1, CursorBottom+1);
                }
                break;
        }
        if (len > 0) {
                if (ts.TermFlag & TF_INVALIDDECRPSS) {
                        RepStr[0] = '1';
                }
                SendDCSstr(RepStr, len);
        }
        else {
                if (ts.TermFlag & TF_INVALIDDECRPSS) {
                        SendDCSstr("0$r", 0);
                }
                else {
                        SendDCSstr("1$r", 0);
                }
        }
}

void ParseDCS(BYTE Cmd, unsigned char *StrBuff, int len) {
        switch (ICount) {
        case 0:
                break;
        case 1:
                switch (IntChar[1]) {
                case '!':
                        if (Cmd == '{') { // DECSTUI
                                if (! (ts.TermFlag & TF_LOCKTUID)) {
                                        int i;
                                        for (i=0; i<8 && isxdigit(StrBuff[i]); i++) {
                                                if (islower(StrBuff[i])) {
                                                        StrBuff[i] = toupper(StrBuff[i]);
                                                }
                                        }
                                        if (len == 8 && i == 8) {
                                                strncpy_s(ts.TerminalUID, sizeof(ts.TerminalUID), StrBuff, _TRUNCATE);
                                        }
                                }
                        }
                        break;
                case '$':
                        if (Cmd == 'q')  { // DECRQSS
                                RequestStatusString(StrBuff, len);
                        }
                        break;
                default:
                        break;
                }
                break;
        default:
                break;
        }
}

#define ModeDcsFirst     1
#define ModeDcsString    2
void DeviceControl(BYTE b)
{
        static unsigned char StrBuff[256];
        static int DcsParseMode = ModeDcsFirst;
        static int StrLen;
        static BYTE Cmd;

        if ((ESCFlag && (b=='\\')) || (b==ST && ts.KanjiCode!=IdSJIS)) {
                if (DcsParseMode == ModeDcsString) {
                        StrBuff[StrLen] = 0;
                        ParseDCS(Cmd, StrBuff, StrLen);
                }
                ESCFlag = FALSE;
                ParseMode = SavedMode;
                DcsParseMode = ModeDcsFirst;
                StrLen = 0;
                return;
        }

        if (b==ESC) {
                ESCFlag = TRUE;
                return;
        }
        else {
                ESCFlag = FALSE;
        }

        switch (DcsParseMode) {
        case ModeDcsFirst:
                if (b<=US) {
                        ParseControl(b);
                }
                else if ((b>=0x20) && (b<=0x2F)) {
                        if (ICount<IntCharMax) ICount++;
                        IntChar[ICount] = b;
                }
                else if ((b>=0x30) && (b<=0x39)) {
                        if (Param[NParam] < 0) Param[NParam] = 0;
                        if (Param[NParam]<1000)
                                Param[NParam] = Param[NParam]*10 + b - 0x30;
                }
                else if (b==0x3B) {
                        if (NParam < NParamMax) {
                                NParam++;
                                Param[NParam] = -1;
                        }
                }
                else if ((b>=0x40) && (b<=0x7E)) {
                        if (ICount == 0 && b=='|') {
                                ParseMode = ModeDCUserKey;
                                if (Param[1] < 1) ClearUserKey();
                                WaitKeyId = TRUE;
                                NewKeyId = 0;
                        }
                        else {
                                Cmd = b;
                                DcsParseMode = ModeDcsString;
                        }
                }
                else {
                        ParseMode = ModeSOS;
                }
                break;

        case ModeDcsString:
                if (b <= US && b != HT && b != CR) {
                        ESCFlag = FALSE;
                        ParseMode = SavedMode;
                        DcsParseMode = ModeDcsFirst;
                        StrLen = 0;
                }
                else if (StrLen < sizeof(StrBuff)-1) {
                        StrBuff[StrLen++] = b;
                }
                break;
        }
}

void DCUserKey(BYTE b)
{
  if (ESCFlag && (b=='\\') || (b==ST && ts.KanjiCode!=IdSJIS))
  {
    if (! WaitKeyId) DefineUserKey(NewKeyId,NewKeyStr,NewKeyLen);
    ESCFlag = FALSE;
    ParseMode = SavedMode;
    return;
  }

  if (b==ESC)
  {
    ESCFlag = TRUE;
    return;
  }
  else ESCFlag = FALSE;

  if (WaitKeyId)
  {
    if ((b>=0x30) && (b<=0x39))
    {
      if (NewKeyId<1000)
        NewKeyId = NewKeyId*10 + b - 0x30;
    }
    else if (b==0x2F)
    {
      WaitKeyId = FALSE;
      WaitHi = TRUE;
      NewKeyLen = 0;
    }
  }
  else {
    if (b==0x3B)
    {
      DefineUserKey(NewKeyId,NewKeyStr,NewKeyLen);
      WaitKeyId = TRUE;
      NewKeyId = 0;
    }
    else {
      if (NewKeyLen < FuncKeyStrMax)
      {
        if (WaitHi)
        {
          NewKeyStr[NewKeyLen] = ConvHexChar(b) << 4;
          WaitHi = FALSE;
        }
        else {
          NewKeyStr[NewKeyLen] = NewKeyStr[NewKeyLen] +
                                 ConvHexChar(b);
          WaitHi = TRUE;
          NewKeyLen++;
        }
      }
    }
  }
}

void IgnoreString(BYTE b)
{
  if ((ESCFlag && (b=='\\')) ||
      (b<=US && b!=ESC && b!=HT) ||
      (b==ST && ts.KanjiCode!=IdSJIS))
    ParseMode = SavedMode;

  if (b==ESC) ESCFlag = TRUE;
         else ESCFlag = FALSE;
}

BOOL XsParseColor(char *colspec, COLORREF *color)
{
        unsigned int r, g, b;
//      double dr, dg, db;

        r = g = b = 255;

        if (colspec == NULL || color == NULL) {
                return FALSE;
        }

        if (_strnicmp(colspec, "rgb:", 4) == 0) {
                switch (strlen(colspec)) {
                  case  9:      // rgb:R/G/B
                        if (sscanf(colspec, "rgb:%1x/%1x/%1x", &r, &g, &b) != 3) {
                                return FALSE;
                        }
                        r *= 17; g *= 17; b *= 17;
                        break;
                  case 12:      // rgb:RR/GG/BB
                        if (sscanf(colspec, "rgb:%2x/%2x/%2x", &r, &g, &b) != 3) {
                                return FALSE;
                        }
                        break;
                  case 15:      // rgb:RRR/GGG/BBB
                        if (sscanf(colspec, "rgb:%3x/%3x/%3x", &r, &g, &b) != 3) {
                                return FALSE;
                        }
                        r >>= 4; g >>= 4; b >>= 4;
                        break;
                  case 18:      // rgb:RRRR/GGGG/BBBB
                        if (sscanf(colspec, "rgb:%4x/%4x/%4x", &r, &g, &b) != 3) {
                                return FALSE;
                        }
                        r >>= 8; g >>= 8; b >>= 8;
                        break;
                  default:
                        return FALSE;
                }
        }
//      else if (_strnicmp(colspec, "rgbi:", 5) == 0) {
//              ; /* nothing to do */
//      }
        else if (colspec[0] == '#') {
                switch (strlen(colspec)) {
                  case  4:      // #RGB
                        if (sscanf(colspec, "#%1x%1x%1x", &r, &g, &b) != 3) {
                                return<