Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/branches/ttcomtester/teraterm/teraterm/vtterm.c

Annotation of /branches/ttcomtester/teraterm/teraterm/vtterm.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 3464 - (hide annotations) (download) (as text)
Wed Jun 10 14:22:14 2009 UTC (14 years, 10 months ago) by doda
Original Path: trunk/teraterm/teraterm/vtterm.c
File MIME type: text/x-csrc
File size: 79515 byte(s) 
ウィンドウサイズ変更シーケンス(ピクセル単位)に対応。
  <CSI> 4 ; H ; W t
     H: ウィンドウの高さ
     W: ウィンドウの横幅
1 maya 3227 /* Tera Term
2     Copyright(C) 1994-1998 T. Teranishi
3     All rights reserved. */
4    
5     /* TERATERM.EXE, VT terminal emulation */
6     #include "teraterm.h"
7     #include "tttypes.h"
8     #include <stdio.h>
9     #include <string.h>
10     #include <stdlib.h>
11     #include <mbstring.h>
12     #include <locale.h>
13    
14     #include "buffer.h"
15     #include "ttwinman.h"
16     #include "ttcommon.h"
17     #include "commlib.h"
18     #include "vtdisp.h"
19     #include "keyboard.h"
20     #include "ttlib.h"
21     #include "ttftypes.h"
22     #include "filesys.h"
23     #include "teraprn.h"
24     #include "telnet.h"
25    
26     #include "vtterm.h"
27    
28 doda 3443 #define MAPSIZE(x) (sizeof(x)/sizeof((x)[0]))
29    
30 maya 3227 /* Parsing modes */
31     #define ModeFirst 0
32     #define ModeESC 1
33     #define ModeDCS 2
34     #define ModeDCUserKey 3
35     #define ModeSOS 4
36     #define ModeCSI 5
37     #define ModeXS 6
38     #define ModeDLE 7
39     #define ModeCAN 8
40    
41     #define NParamMax 16
42     #define IntCharMax 5
43    
44     void VisualBell();
45    
46     /* character attribute */
47     static TCharAttr CharAttr;
48    
49     /* various modes of VT emulation */
50     static BOOL RelativeOrgMode;
51     static BOOL InsertMode;
52     static BOOL LFMode;
53     static BOOL AutoWrapMode;
54     static BOOL FocusReportMode;
55     int MouseReportMode;
56    
57     // save/restore cursor
58     typedef struct {
59     int CursorX, CursorY;
60     TCharAttr Attr;
61     int Glr[2], Gn[4]; // G0-G3, GL & GR
62     BOOL AutoWrapMode;
63     BOOL RelativeOrgMode;
64     } TStatusBuff;
65     typedef TStatusBuff *PStatusBuff;
66    
67     // status buffer for main screen & status line
68     static TStatusBuff SBuff1, SBuff2;
69    
70     static BOOL ESCFlag, JustAfterESC;
71     static BOOL KanjiIn;
72     static BOOL EUCkanaIn, EUCsupIn;
73     static int EUCcount;
74     static BOOL Special;
75    
76     static int Param[NParamMax+1];
77     static int NParam;
78     static BOOL FirstPrm;
79     static BYTE IntChar[IntCharMax+1];
80     static int ICount;
81     static BYTE Prv;
82     static int ParseMode, SavedMode;
83     static int ChangeEmu;
84    
85     /* user defined keys */
86     static BOOL WaitKeyId, WaitHi;
87    
88     /* GL, GR code group */
89     static int Glr[2];
90     /* G0, G1, G2, G3 code group */
91     static int Gn[4];
92     /* GL for single shift 2/3 */
93     static int GLtmp;
94     /* single shift 2/3 flag */
95     static BOOL SSflag;
96     /* JIS -> SJIS conversion flag */
97     static BOOL ConvJIS;
98     static WORD Kanji;
99    
100     // variables for status line mode
101     static int StatusX=0;
102     static BOOL StatusWrap=FALSE;
103     static BOOL StatusCursor=TRUE;
104     static int MainX, MainY; //cursor registers
105     static int MainTop, MainBottom; // scroll region registers
106     static BOOL MainWrap;
107     static BOOL MainCursor=TRUE;
108    
109     /* status for printer escape sequences */
110     static BOOL PrintEX = TRUE; // printing extent
111     // (TRUE: screen, FALSE: scroll region)
112     static BOOL AutoPrintMode = FALSE;
113     static BOOL PrinterMode = FALSE;
114     static BOOL DirectPrn = FALSE;
115    
116     /* User key */
117     static BYTE NewKeyStr[FuncKeyStrMax];
118     static int NewKeyId, NewKeyLen;
119    
120 doda 3450 static _locale_t CLocale = NULL;
121 maya 3227
122     void ResetSBuffers()
123     {
124     SBuff1.CursorX = 0;
125     SBuff1.CursorY = 0;
126     SBuff1.Attr = DefCharAttr;
127     if (ts.Language==IdJapanese)
128     {
129     SBuff1.Gn[0] = IdASCII;
130     SBuff1.Gn[1] = IdKatakana;
131     SBuff1.Gn[2] = IdKatakana;
132     SBuff1.Gn[3] = IdKanji;
133     SBuff1.Glr[0] = 0;
134     if ((ts.KanjiCode==IdJIS) &&
135     (ts.JIS7Katakana==0))
136     SBuff1.Glr[1] = 2; // 8-bit katakana
137     else
138     SBuff1.Glr[1] = 3;
139     }
140     else {
141     SBuff1.Gn[0] = IdASCII;
142     SBuff1.Gn[1] = IdSpecial;
143     SBuff1.Gn[2] = IdASCII;
144     SBuff1.Gn[3] = IdASCII;
145     SBuff1.Glr[0] = 0;
146     SBuff1.Glr[1] = 0;
147     }
148     SBuff1.AutoWrapMode = TRUE;
149     SBuff1.RelativeOrgMode = FALSE;
150     // copy SBuff1 to SBuff2
151     SBuff2 = SBuff1;
152     }
153    
154     void ResetTerminal() /*reset variables but don't update screen */
155     {
156     DispReset();
157     BuffReset();
158    
159     /* Attribute */
160     CharAttr = DefCharAttr;
161     Special = FALSE;
162     BuffSetCurCharAttr(CharAttr);
163    
164     /* Various modes */
165     InsertMode = FALSE;
166     LFMode = (ts.CRSend == IdCRLF);
167     AutoWrapMode = TRUE;
168     AppliKeyMode = FALSE;
169     AppliCursorMode = FALSE;
170     RelativeOrgMode = FALSE;
171     ts.ColorFlag &= ~CF_REVERSEVIDEO;
172     AutoRepeatMode = TRUE;
173     Send8BitMode = ts.Send8BitCtrl;
174     FocusReportMode = FALSE;
175     MouseReportMode = IdMouseTrackNone;
176    
177 doda 3450 if (CLocale == NULL) {
178     CLocale = _create_locale(LC_ALL, "C");
179     }
180 maya 3227
181     /* Character sets */
182     ResetCharSet();
183    
184     /* ESC flag for device control sequence */
185     ESCFlag = FALSE;
186     /* for TEK sequence */
187     JustAfterESC = FALSE;
188    
189     /* Parse mode */
190     ParseMode = ModeFirst;
191    
192     /* Clear printer mode */
193     PrinterMode = FALSE;
194    
195     // status buffers
196     ResetSBuffers();
197     }
198    
199     void ResetCharSet()
200     {
201     if (ts.Language==IdJapanese)
202     {
203     Gn[0] = IdASCII;
204     Gn[1] = IdKatakana;
205     Gn[2] = IdKatakana;
206     Gn[3] = IdKanji;
207     Glr[0] = 0;
208     if ((ts.KanjiCode==IdJIS) &&
209     (ts.JIS7Katakana==0))
210     Glr[1] = 2; // 8-bit katakana
211     else
212     Glr[1] = 3;
213     }
214     else {
215     Gn[0] = IdASCII;
216     Gn[1] = IdSpecial;
217     Gn[2] = IdASCII;
218     Gn[3] = IdASCII;
219     Glr[0] = 0;
220     Glr[1] = 0;
221     cv.SendCode = IdASCII;
222     cv.SendKanjiFlag = FALSE;
223     cv.EchoCode = IdASCII;
224     cv.EchoKanjiFlag = FALSE;
225     }
226     /* Kanji flag */
227     KanjiIn = FALSE;
228     EUCkanaIn = FALSE;
229     EUCsupIn = FALSE;
230     SSflag = FALSE;
231    
232     cv.Language = ts.Language;
233     cv.CRSend = ts.CRSend;
234     cv.KanjiCodeEcho = ts.KanjiCode;
235     cv.JIS7KatakanaEcho = ts.JIS7Katakana;
236     cv.KanjiCodeSend = ts.KanjiCodeSend;
237     cv.JIS7KatakanaSend = ts.JIS7KatakanaSend;
238     cv.KanjiIn = ts.KanjiIn;
239     cv.KanjiOut = ts.KanjiOut;
240     }
241    
242     void ResetKeypadMode(BOOL DisabledModeOnly)
243     {
244     if (!DisabledModeOnly || ts.DisableAppKeypad) AppliKeyMode = FALSE;
245     if (!DisabledModeOnly || ts.DisableAppCursor) AppliCursorMode = FALSE;
246     }
247    
248     void MoveToMainScreen()
249     {
250     StatusX = CursorX;
251     StatusWrap = Wrap;
252     StatusCursor = IsCaretEnabled();
253    
254     CursorTop = MainTop;
255     CursorBottom = MainBottom;
256     Wrap = MainWrap;
257     DispEnableCaret(MainCursor);
258     MoveCursor(MainX,MainY); // move to main screen
259     }
260    
261     void MoveToStatusLine()
262     {
263     MainX = CursorX;
264     MainY = CursorY;
265     MainTop = CursorTop;
266     MainBottom = CursorBottom;
267     MainWrap = Wrap;
268     MainCursor = IsCaretEnabled();
269    
270     DispEnableCaret(StatusCursor);
271     MoveCursor(StatusX,NumOfLines-1); // move to status line
272     CursorTop = NumOfLines-1;
273     CursorBottom = CursorTop;
274     Wrap = StatusWrap;
275     }
276    
277     void HideStatusLine()
278     {
279     if ((StatusLine>0) &&
280     (CursorY==NumOfLines-1))
281     MoveToMainScreen();
282     StatusX = 0;
283     StatusWrap = FALSE;
284     StatusCursor = TRUE;
285     ShowStatusLine(0); //hide
286     }
287    
288     void ChangeTerminalSize(int Nx, int Ny)
289     {
290     BuffChangeTerminalSize(Nx,Ny);
291     StatusX = 0;
292     MainX = 0;
293     MainY = 0;
294     MainTop = 0;
295     MainBottom = NumOfColumns-1;
296     }
297    
298     void BackSpace()
299     {
300     if (CursorX == 0)
301     {
302     if ((CursorY>0) &&
303     ((ts.TermFlag & TF_BACKWRAP)!=0))
304     {
305     MoveCursor(NumOfColumns-1,CursorY-1);
306     // if (cv.HLogBuf!=0) Log1Byte(BS);
307     // (2005.2.20 yutaka)
308     if (cv.HLogBuf!=0 && !ts.LogTypePlainText) Log1Byte(BS);
309     }
310     }
311     else if (CursorX > 0)
312     {
313     MoveCursor(CursorX-1,CursorY);
314     // if (cv.HLogBuf!=0) Log1Byte(BS);
315     // (2005.2.20 yutaka)
316     if (cv.HLogBuf!=0 && !ts.LogTypePlainText) Log1Byte(BS);
317     }
318     }
319    
320     void CarriageReturn(BOOL logFlag)
321     {
322     #ifndef NO_COPYLINE_FIX
323     if (!ts.EnableContinuedLineCopy || logFlag)
324     #endif /* NO_COPYLINE_FIX */
325     if (cv.HLogBuf!=0) Log1Byte(CR);
326    
327     if (CursorX>0)
328     MoveCursor(0,CursorY);
329     }
330    
331     void LineFeed(BYTE b, BOOL logFlag)
332     {
333     /* for auto print mode */
334     if ((AutoPrintMode) &&
335     (b>=LF) && (b<=FF))
336     BuffDumpCurrentLine(b);
337    
338     #ifndef NO_COPYLINE_FIX
339     if (!ts.EnableContinuedLineCopy || logFlag)
340     #endif /* NO_COPYLINE_FIX */
341     if (cv.HLogBuf!=0) Log1Byte(LF);
342    
343     if (CursorY < CursorBottom)
344     MoveCursor(CursorX,CursorY+1);
345     else if (CursorY == CursorBottom) BuffScrollNLines(1);
346     else if (CursorY < NumOfLines-StatusLine-1)
347     MoveCursor(CursorX,CursorY+1);
348    
349 doda 3312 #ifndef NO_COPYLINE_FIX
350     ClearLineContinued();
351     #endif /* NO_COPYLINE_FIX */
352    
353 maya 3227 if (LFMode) CarriageReturn(logFlag);
354     }
355    
356     void Tab()
357     {
358     if (Wrap && !ts.VTCompatTab) {
359     CarriageReturn(FALSE);
360     LineFeed(LF,FALSE);
361     #ifndef NO_COPYLINE_FIX
362     if (ts.EnableContinuedLineCopy) {
363     SetLineContinued();
364     }
365     #endif /* NO_COPYLINE_FIX */
366     Wrap = FALSE;
367     }
368     CursorForwardTab(1, AutoWrapMode);
369     if (cv.HLogBuf!=0) Log1Byte(HT);
370     }
371    
372     void PutChar(BYTE b)
373     {
374     BOOL SpecialNew;
375     TCharAttr CharAttrTmp;
376    
377     CharAttrTmp = CharAttr;
378    
379     if (PrinterMode) { // printer mode
380     WriteToPrnFile(b,TRUE);
381     return;
382     }
383    
384     if (Wrap)
385     {
386     CarriageReturn(FALSE);
387     LineFeed(LF,FALSE);
388     #ifndef NO_COPYLINE_FIX
389     CharAttrTmp.Attr |= ts.EnableContinuedLineCopy ? AttrLineContinued : 0;
390     #endif /* NO_COPYLINE_FIX */
391     }
392    
393     // if (cv.HLogBuf!=0) Log1Byte(b);
394     // (2005.2.20 yutaka)
395     if (ts.LogTypePlainText) {
396     if (__isascii(b) && !isprint(b)) {
397     // ASCII�������A���\�������������O�����������B
398     } else {
399     if (cv.HLogBuf!=0) Log1Byte(b);
400     }
401     } else {
402     if (cv.HLogBuf!=0) Log1Byte(b);
403     }
404    
405     Wrap = FALSE;
406    
407     SpecialNew = FALSE;
408     if ((b>0x5F) && (b<0x80))
409     {
410     if (SSflag)
411     SpecialNew = (Gn[GLtmp]==IdSpecial);
412     else
413     SpecialNew = (Gn[Glr[0]]==IdSpecial);
414     }
415     else if (b>0xDF)
416     {
417     if (SSflag)
418     SpecialNew = (Gn[GLtmp]==IdSpecial);
419     else
420     SpecialNew = (Gn[Glr[1]]==IdSpecial);
421     }
422    
423     if (SpecialNew != Special)
424     {
425     UpdateStr();
426     Special = SpecialNew;
427     }
428    
429     if (Special)
430     {
431     b = b & 0x7F;
432     CharAttrTmp.Attr |= AttrSpecial;
433     }
434     else
435     CharAttrTmp.Attr |= CharAttr.Attr;
436    
437     BuffPutChar(b, CharAttrTmp, InsertMode);
438    
439     if (CursorX < NumOfColumns-1)
440     MoveRight();
441     else {
442     UpdateStr();
443     Wrap = AutoWrapMode;
444     }
445     }
446    
447     void PutDecSp(BYTE b)
448     {
449     TCharAttr CharAttrTmp;
450    
451     CharAttrTmp = CharAttr;
452    
453     if (PrinterMode) { // printer mode
454     WriteToPrnFile(b, TRUE);
455     return;
456     }
457    
458     if (Wrap) {
459     CarriageReturn(FALSE);
460     LineFeed(LF, FALSE);
461     #ifndef NO_COPYLINE_FIX
462     CharAttrTmp.Attr |= ts.EnableContinuedLineCopy ? AttrLineContinued : 0;
463     #endif /* NO_COPYLINE_FIX */
464     }
465    
466     if (cv.HLogBuf!=0) Log1Byte(b);
467     /*
468     if (ts.LogTypePlainText && __isascii(b) && !isprint(b)) {
469     // ASCII�������A���\�������������O�����������B
470     } else {
471     if (cv.HLogBuf!=0) Log1Byte(b);
472     }
473     */
474    
475     Wrap = FALSE;
476    
477     if (!Special) {
478     UpdateStr();
479     Special = TRUE;
480     }
481    
482     CharAttrTmp.Attr |= AttrSpecial;
483     BuffPutChar(b, CharAttrTmp, InsertMode);
484    
485     if (CursorX < NumOfColumns-1)
486     MoveRight();
487     else {
488     UpdateStr();
489     Wrap = AutoWrapMode;
490     }
491     }
492    
493     void PutKanji(BYTE b)
494     {
495     #ifndef NO_COPYLINE_FIX
496     TCharAttr CharAttrTmp;
497    
498     CharAttrTmp = CharAttr;
499     #endif /* NO_COPYLINE_FIX */
500     Kanji = Kanji + b;
501    
502     if (PrinterMode && DirectPrn)
503     {
504     WriteToPrnFile(HIBYTE(Kanji),FALSE);
505     WriteToPrnFile(LOBYTE(Kanji),TRUE);
506     return;
507     }
508    
509     if (ConvJIS)
510     Kanji = JIS2SJIS((WORD)(Kanji & 0x7f7f));
511    
512     if (PrinterMode) { // printer mode
513     WriteToPrnFile(HIBYTE(Kanji),FALSE);
514     WriteToPrnFile(LOBYTE(Kanji),TRUE);
515     return;
516     }
517    
518     if (Wrap)
519     {
520     CarriageReturn(FALSE);
521     LineFeed(LF,FALSE);
522     #ifndef NO_COPYLINE_FIX
523     if (ts.EnableContinuedLineCopy)
524     CharAttrTmp.Attr |= AttrLineContinued;
525     #endif /* NO_COPYLINE_FIX */
526     }
527     else if (CursorX > NumOfColumns-2)
528     if (AutoWrapMode)
529     {
530     #ifndef NO_COPYLINE_FIX
531     if (ts.EnableContinuedLineCopy)
532     {
533     CharAttrTmp.Attr |= AttrLineContinued;
534     if (CursorX == NumOfColumns-1)
535     BuffPutChar(0x20, CharAttr, FALSE);
536     }
537     #endif /* NO_COPYLINE_FIX */
538     CarriageReturn(FALSE);
539     LineFeed(LF,FALSE);
540     }
541     else return;
542    
543     Wrap = FALSE;
544    
545     if (cv.HLogBuf!=0)
546     {
547     Log1Byte(HIBYTE(Kanji));
548     Log1Byte(LOBYTE(Kanji));
549     }
550    
551     if (Special)
552     {
553     UpdateStr();
554     Special = FALSE;
555     }
556    
557     #ifndef NO_COPYLINE_FIX
558     BuffPutKanji(Kanji, CharAttrTmp, InsertMode);
559     #else
560     BuffPutKanji(Kanji, CharAttr, InsertMode);
561     #endif /* NO_COPYLINE_FIX */
562    
563     if (CursorX < NumOfColumns-2)
564     {
565     MoveRight();
566     MoveRight();
567     }
568     else {
569     UpdateStr();
570     Wrap = AutoWrapMode;
571     }
572     }
573    
574     void PutDebugChar(BYTE b)
575     {
576     InsertMode = FALSE;
577     AutoWrapMode = TRUE;
578    
579     if ((b & 0x80) == 0x80)
580     {
581     UpdateStr();
582     CharAttr.Attr = AttrReverse;
583     b = b & 0x7f;
584     }
585    
586     if (b<=US)
587     {
588     PutChar('^');
589     PutChar((char)(b+0x40));
590     }
591     else if (b==DEL)
592     {
593     PutChar('<');
594     PutChar('D');
595     PutChar('E');
596     PutChar('L');
597     PutChar('>');
598     }
599     else
600     PutChar(b);
601    
602     if (CharAttr.Attr != AttrDefault)
603     {
604     UpdateStr();
605     CharAttr.Attr = AttrDefault;
606     }
607     }
608    
609     void PrnParseControl(BYTE b) // printer mode
610     {
611     switch (b) {
612     case NUL: return;
613     case SO:
614     if (! DirectPrn)
615     {
616     if ((ts.Language==IdJapanese) &&
617     (ts.KanjiCode==IdJIS) &&
618     (ts.JIS7Katakana==1) &&
619     ((ts.TermFlag & TF_FIXEDJIS)!=0))
620     Gn[1] = IdKatakana;
621     Glr[0] = 1; /* LS1 */
622     return;
623     }
624     break;
625     case SI:
626     if (! DirectPrn)
627     {
628     Glr[0] = 0; /* LS0 */
629     return;
630     }
631     break;
632     case DC1:
633     case DC3: return;
634     case ESC:
635     ICount = 0;
636     JustAfterESC = TRUE;
637     ParseMode = ModeESC;
638     WriteToPrnFile(0,TRUE); // flush prn buff
639     return;
640     case CSI:
641     if ((ts.TerminalID<IdVT220J) ||
642     ((ts.TermFlag & TF_ACCEPT8BITCTRL)==0))
643     {
644     PutChar(b); /* Disp C1 char in VT100 mode */
645     return;
646     }
647     ICount = 0;
648     FirstPrm = TRUE;
649     NParam = 1;
650     Param[1] = -1;
651     Prv = 0;
652     ParseMode = ModeCSI;
653     WriteToPrnFile(0,TRUE); // flush prn buff
654     WriteToPrnFile(b,FALSE);
655     return;
656     }
657     /* send the uninterpreted character to printer */
658     WriteToPrnFile(b,TRUE);
659     }
660    
661     void ParseControl(BYTE b)
662     {
663     if (PrinterMode) { // printer mode
664     PrnParseControl(b);
665     return;
666     }
667    
668     if (b>=0x80) /* C1 char */
669     {
670     /* English mode */
671     if (ts.Language==IdEnglish)
672     {
673     if ((ts.TerminalID<IdVT220J) ||
674     ((ts.TermFlag & TF_ACCEPT8BITCTRL)==0))
675     {
676     PutChar(b); /* Disp C1 char in VT100 mode */
677     return;
678     }
679     }
680     else { /* Japanese mode */
681     if ((ts.TermFlag & TF_ACCEPT8BITCTRL)==0)
682     return; /* ignore C1 char */
683     /* C1 chars are interpreted as C0 chars in VT100 mode */
684     if (ts.TerminalID<IdVT220J)
685     b = b & 0x7F;
686     }
687     }
688     switch (b) {
689     /* C0 group */
690     case ENQ:
691     CommBinaryOut(&cv,&(ts.Answerback[0]),ts.AnswerbackLen);
692     break;
693     case BEL:
694     switch (ts.Beep) {
695     case IdBeepOff:
696     /* nothing to do */
697     break;
698     case IdBeepOn:
699     MessageBeep(0);
700     break;
701     case IdBeepVisual:
702     VisualBell();
703     break;
704     }
705     break;
706     case BS: BackSpace(); break;
707     case HT: Tab(); break;
708    
709     case LF:
710     // ���M�������s�R�[�h�� LF ���������A�T�[�o���� LF ���������������������������A
711     // CR+LF���������������������B
712     // cf. http://www.neocom.ca/forum/viewtopic.php?t=216
713     // (2007.1.21 yutaka)
714     if (ts.CRReceive == IdLF) {
715     CarriageReturn(TRUE);
716     LineFeed(b, TRUE);
717     break;
718     }
719    
720     case VT: LineFeed(b,TRUE); break;
721    
722     case FF:
723     if ((ts.AutoWinSwitch>0) && JustAfterESC)
724     {
725     CommInsert1Byte(&cv,b);
726     CommInsert1Byte(&cv,ESC);
727     ChangeEmu = IdTEK; /* Enter TEK Mode */
728     }
729     else
730     LineFeed(b,TRUE);
731     break;
732     case CR:
733     CarriageReturn(TRUE);
734     if (ts.CRReceive==IdCRLF)
735     CommInsert1Byte(&cv,LF);
736     break;
737     case SO:
738     if ((ts.Language==IdJapanese) &&
739     (ts.KanjiCode==IdJIS) &&
740     (ts.JIS7Katakana==1) &&
741     ((ts.TermFlag & TF_FIXEDJIS)!=0))
742     Gn[1] = IdKatakana;
743    
744     Glr[0] = 1; /* LS1 */
745     break;
746     case SI: Glr[0] = 0; break; /* LS0 */
747     case DLE:
748     if ((ts.FTFlag & FT_BPAUTO)!=0)
749     ParseMode = ModeDLE; /* Auto B-Plus activation */
750     break;
751     case CAN:
752     if ((ts.FTFlag & FT_ZAUTO)!=0)
753     ParseMode = ModeCAN; /* Auto ZMODEM activation */
754     // else if (ts.AutoWinSwitch>0)
755     // ChangeEmu = IdTEK; /* Enter TEK Mode */
756     else
757     ParseMode = ModeFirst;
758     break;
759     case SUB: ParseMode = ModeFirst; break;
760     case ESC:
761     ICount = 0;
762     JustAfterESC = TRUE;
763     ParseMode = ModeESC;
764     break;
765     case FS:
766     case GS:
767     case RS:
768     case US:
769     if (ts.AutoWinSwitch>0)
770     {
771     CommInsert1Byte(&cv,b);
772     ChangeEmu = IdTEK; /* Enter TEK Mode */
773     }
774     break;
775    
776     /* C1 char */
777     case IND: LineFeed(0,TRUE); break;
778     case NEL:
779     LineFeed(0,TRUE);
780     CarriageReturn(TRUE);
781     break;
782     case HTS: SetTabStop(); break;
783     case RI: CursorUpWithScroll(); break;
784     case SS2:
785     GLtmp = 2;
786     SSflag = TRUE;
787     break;
788     case SS3:
789     GLtmp = 3;
790     SSflag = TRUE;
791     break;
792     case DCS:
793     SavedMode = ParseMode;
794     ESCFlag = FALSE;
795     NParam = 1;
796     Param[1] = -1;
797     ParseMode = ModeDCS;
798     break;
799     case SOS:
800     SavedMode = ParseMode;
801     ESCFlag = FALSE;
802     ParseMode = ModeSOS;
803     break;
804     case CSI:
805     ICount = 0;
806     FirstPrm = TRUE;
807     NParam = 1;
808     Param[1] = -1;
809     Prv = 0;
810     ParseMode = ModeCSI;
811     break;
812     case OSC:
813     Param[1] = 0;
814     ParseMode = ModeXS;
815     break;
816     case PM:
817     case APC:
818     SavedMode = ParseMode;
819     ESCFlag = FALSE;
820     ParseMode = ModeSOS;
821     break;
822     }
823     }
824    
825     void SaveCursor()
826     {
827     int i;
828     PStatusBuff Buff;
829    
830     if ((StatusLine>0) &&
831     (CursorY==NumOfLines-1))
832     Buff = &SBuff2; // for status line
833     else
834     Buff = &SBuff1; // for main screen
835    
836     Buff->CursorX = CursorX;
837     Buff->CursorY = CursorY;
838     Buff->Attr = CharAttr;
839     Buff->Glr[0] = Glr[0];
840     Buff->Glr[1] = Glr[1];
841     for (i=0 ; i<=3; i++)
842     Buff->Gn[i] = Gn[i];
843     Buff->AutoWrapMode = AutoWrapMode;
844     Buff->RelativeOrgMode = RelativeOrgMode;
845     }
846    
847     void RestoreCursor()
848     {
849     int i;
850     PStatusBuff Buff;
851     UpdateStr();
852    
853     if ((StatusLine>0) &&
854     (CursorY==NumOfLines-1))
855     Buff = &SBuff2; // for status line
856     else
857     Buff = &SBuff1; // for main screen
858    
859     if (Buff->CursorX > NumOfColumns-1)
860     Buff->CursorX = NumOfColumns-1;
861     if (Buff->CursorY > NumOfLines-1-StatusLine)
862     Buff->CursorY = NumOfLines-1-StatusLine;
863     MoveCursor(Buff->CursorX,Buff->CursorY);
864     CharAttr = Buff->Attr;
865     Glr[0] = Buff->Glr[0];
866     Glr[1] = Buff->Glr[1];
867     for (i=0 ; i<=3; i++)
868     Gn[i] = Buff->Gn[i];
869     AutoWrapMode = Buff->AutoWrapMode;
870     RelativeOrgMode = Buff->RelativeOrgMode;
871     }
872    
873     void AnswerTerminalType()
874     {
875     char Tmp[31];
876    
877     if (ts.TerminalID<IdVT320)
878     strncpy_s(Tmp, sizeof(Tmp),"\033[?", _TRUNCATE);
879     else
880     strncpy_s(Tmp, sizeof(Tmp),"\233?", _TRUNCATE);
881    
882     switch (ts.TerminalID) {
883     case IdVT100:
884     strncat_s(Tmp,sizeof(Tmp),"1;2",_TRUNCATE);
885     break;
886     case IdVT100J:
887     strncat_s(Tmp,sizeof(Tmp),"5;2",_TRUNCATE);
888     break;
889     case IdVT101:
890     strncat_s(Tmp,sizeof(Tmp),"1;0",_TRUNCATE);
891     break;
892     case IdVT102:
893     strncat_s(Tmp,sizeof(Tmp),"6",_TRUNCATE);
894     break;
895     case IdVT102J:
896     strncat_s(Tmp,sizeof(Tmp),"15",_TRUNCATE);
897     break;
898     case IdVT220J:
899     strncat_s(Tmp,sizeof(Tmp),"62;1;2;5;6;7;8",_TRUNCATE);
900     break;
901     case IdVT282:
902     strncat_s(Tmp,sizeof(Tmp),"62;1;2;4;5;6;7;8;10;11",_TRUNCATE);
903     break;
904     case IdVT320:
905     strncat_s(Tmp,sizeof(Tmp),"63;1;2;6;7;8",_TRUNCATE);
906     break;
907     case IdVT382:
908     strncat_s(Tmp,sizeof(Tmp),"63;1;2;4;5;6;7;8;10;15",_TRUNCATE);
909     break;
910     }
911     strncat_s(Tmp,sizeof(Tmp),"c",_TRUNCATE);
912    
913     CommBinaryOut(&cv,Tmp,strlen(Tmp)); /* Report terminal ID */
914     }
915    
916     void ESCSpace(BYTE b)
917     {
918     switch (b) {
919     case 'F': Send8BitMode = FALSE; break; // S7C1T
920     case 'G': Send8BitMode = TRUE; break; // S8C1T
921     }
922     }
923    
924     void ESCSharp(BYTE b)
925     {
926     switch (b) {
927     case '8': /* Fill screen with "E" */
928     BuffUpdateScroll();
929     BuffFillWithE();
930     MoveCursor(0,0);
931     ParseMode = ModeFirst;
932     break;
933     }
934     }
935    
936     /* select double byte code set */
937     void ESCDBCSSelect(BYTE b)
938     {
939     int Dist;
940    
941     if (ts.Language!=IdJapanese) return;
942    
943     switch (ICount) {
944     case 1:
945     if ((b=='@') || (b=='B'))
946     {
947     Gn[0] = IdKanji; /* Kanji -> G0 */
948     if ((ts.TermFlag & TF_AUTOINVOKE)!=0)
949     Glr[0] = 0; /* G0->GL */
950     }
951     break;
952     case 2:
953     /* Second intermediate char must be
954     '(' or ')' or '*' or '+'. */
955     Dist = (IntChar[2]-'(') & 3; /* G0 - G3 */
956     if ((b=='1') || (b=='3') ||
957     (b=='@') || (b=='B'))
958     {
959     Gn[Dist] = IdKanji; /* Kanji -> G0-3 */
960     if (((ts.TermFlag & TF_AUTOINVOKE)!=0) &&
961     (Dist==0))
962     Glr[0] = 0; /* G0->GL */
963     }
964     break;
965     }
966     }
967    
968     void ESCSelectCode(BYTE b)
969     {
970     switch (b) {
971     case '0':
972     if (ts.AutoWinSwitch>0)
973     ChangeEmu = IdTEK; /* enter TEK mode */
974     break;
975     }
976     }
977    
978     /* select single byte code set */
979     void ESCSBCSSelect(BYTE b)
980     {
981     int Dist;
982    
983     /* Intermediate char must be
984     '(' or ')' or '*' or '+'. */
985     Dist = (IntChar[1]-'(') & 3; /* G0 - G3 */
986    
987     switch (b) {
988     case '0': Gn[Dist] = IdSpecial; break;
989     case '<': Gn[Dist] = IdASCII; break;
990     case '>': Gn[Dist] = IdASCII; break;
991     case 'A': Gn[Dist] = IdASCII; break;
992     case 'B': Gn[Dist] = IdASCII; break;
993     case 'H': Gn[Dist] = IdASCII; break;
994     case 'I':
995     if (ts.Language==IdJapanese)
996     Gn[Dist] = IdKatakana;
997     break;
998     case 'J': Gn[Dist] = IdASCII; break;
999     }
1000    
1001     if (((ts.TermFlag & TF_AUTOINVOKE)!=0) &&
1002     (Dist==0))
1003     Glr[0] = 0; /* G0->GL */
1004     }
1005    
1006     void PrnParseEscape(BYTE b) // printer mode
1007     {
1008     int i;
1009    
1010     ParseMode = ModeFirst;
1011     switch (ICount) {
1012     /* no intermediate char */
1013     case 0:
1014     switch (b) {
1015     case '[': /* CSI */
1016     ICount = 0;
1017     FirstPrm = TRUE;
1018     NParam = 1;
1019     Param[1] = -1;
1020     Prv = 0;
1021     WriteToPrnFile(ESC,FALSE);
1022     WriteToPrnFile('[',FALSE);
1023     ParseMode = ModeCSI;
1024     return;
1025     } /* end of case Icount=0 */
1026     break;
1027     /* one intermediate char */
1028     case 1:
1029     switch (IntChar[1]) {
1030     case '$':
1031     if (! DirectPrn)
1032     {
1033     ESCDBCSSelect(b);
1034     return;
1035     }
1036     break;
1037     case '(':
1038     case ')':
1039     case '*':
1040     case '+':
1041     if (! DirectPrn)
1042     {
1043     ESCSBCSSelect(b);
1044     return;
1045     }
1046     break;
1047     }
1048     break;
1049     /* two intermediate char */
1050     case 2:
1051     if ((! DirectPrn) &&
1052     (IntChar[1]=='$') &&
1053     ('('<=IntChar[2]) &&
1054     (IntChar[2]<='+'))
1055     {
1056     ESCDBCSSelect(b);
1057     return;
1058     }
1059     break;
1060     }
1061     // send the uninterpreted sequence to printer
1062     WriteToPrnFile(ESC,FALSE);
1063     for (i=1; i<=ICount; i++)
1064     WriteToPrnFile(IntChar[i],FALSE);
1065     WriteToPrnFile(b,TRUE);
1066     }
1067    
1068     void ParseEscape(BYTE b) /* b is the final char */
1069     {
1070     if (PrinterMode) { // printer mode
1071     PrnParseEscape(b);
1072     return;
1073     }
1074    
1075     switch (ICount) {
1076     /* no intermediate char */
1077     case 0:
1078     switch (b) {
1079     case '7': SaveCursor(); break;
1080     case '8': RestoreCursor(); break;
1081     case '=': AppliKeyMode = TRUE; break;
1082     case '>': AppliKeyMode = FALSE; break;
1083     case 'D': /* IND */
1084     LineFeed(0,TRUE);
1085     break;
1086     case 'E': /* NEL */
1087     MoveCursor(0,CursorY);
1088     LineFeed(0,TRUE);
1089     break;
1090     case 'H': /* HTS */
1091     SetTabStop();
1092     break;
1093     case 'M': /* RI */
1094     CursorUpWithScroll();
1095     break;
1096     case 'N': /* SS2 */
1097     GLtmp = 2;
1098     SSflag = TRUE;
1099     break;
1100     case 'O': /* SS3 */
1101     GLtmp = 3;
1102     SSflag = TRUE;
1103     break;
1104     case 'P': /* DCS */
1105     SavedMode = ParseMode;
1106     ESCFlag = FALSE;
1107     NParam = 1;
1108     Param[1] = -1;
1109     ParseMode = ModeDCS;
1110     return;
1111     case 'X': /* SOS */
1112     SavedMode = ParseMode;
1113     ESCFlag = FALSE;
1114     ParseMode = ModeSOS;
1115     return;
1116     case 'Z': AnswerTerminalType(); break;
1117     case '[': /* CSI */
1118     ICount = 0;
1119     FirstPrm = TRUE;
1120     NParam = 1;
1121     Param[1] = -1;
1122     Prv = 0;
1123     ParseMode = ModeCSI;
1124     return;
1125     case '\\': break; /* ST */
1126     case ']': /* XTERM sequence (OSC) */
1127     NParam = 1;
1128     Param[1] = 0;
1129     ParseMode = ModeXS;
1130     return;
1131     case '^':
1132     case '_': /* PM, APC */
1133     SavedMode = ParseMode;
1134     ESCFlag = FALSE;
1135     ParseMode = ModeSOS;
1136     return;
1137     case 'c': /* Hardware reset */
1138     HideStatusLine();
1139     ResetTerminal();
1140     ClearUserKey();
1141     ClearBuffer();
1142     if (ts.PortType==IdSerial) // reset serial port
1143     CommResetSerial(&ts, &cv, TRUE);
1144     break;
1145     case 'g': /* Visual Bell (screen original?) */
1146     VisualBell();
1147     break;
1148     case 'n': Glr[0] = 2; break; /* LS2 */
1149     case 'o': Glr[0] = 3; break; /* LS3 */
1150     case '|': Glr[1] = 3; break; /* LS3R */
1151     case '}': Glr[1] = 2; break; /* LS2R */
1152     case '~': Glr[1] = 1; break; /* LS1R */
1153     } /* end of case Icount=0 */
1154     break;
1155     /* one intermediate char */
1156     case 1:
1157     switch (IntChar[1]) {
1158     case ' ': ESCSpace(b); break;
1159     case '#': ESCSharp(b); break;
1160     case '$': ESCDBCSSelect(b); break;
1161     case '%': break;
1162     case '(':
1163     case ')':
1164     case '*':
1165     case '+':
1166     ESCSBCSSelect(b);
1167     break;
1168     }
1169     break;
1170     /* two intermediate char */
1171     case 2:
1172     if ((IntChar[1]=='$') &&
1173     ('('<=IntChar[2]) &&
1174     (IntChar[2]<='+'))
1175     ESCDBCSSelect(b);
1176     else if ((IntChar[1]=='%') &&
1177     (IntChar[2]=='!'))
1178     ESCSelectCode(b);
1179     break;
1180     }
1181     ParseMode = ModeFirst;
1182     }
1183    
1184     void EscapeSequence(BYTE b)
1185     {
1186     if (b<=US)
1187     ParseControl(b);
1188     else if ((b>=0x20) && (b<=0x2F))
1189     {
1190     if (ICount<IntCharMax) ICount++;
1191     IntChar[ICount] = b;
1192     }
1193     else if ((b>=0x30) && (b<=0x7E))
1194     ParseEscape(b);
1195     else if ((b>=0x80) && (b<=0x9F))
1196     ParseControl(b);
1197    
1198     JustAfterESC = FALSE;
1199     }
1200    
1201     void CSInsertCharacter()
1202     {
1203     // Insert space characters at cursor
1204     int Count;
1205    
1206     BuffUpdateScroll();
1207     if (Param[1]<1) Param[1] = 1;
1208     Count = Param[1];
1209     BuffInsertSpace(Count);
1210     }
1211    
1212     void CSCursorUp()
1213     {
1214     if (Param[1]<1) Param[1] = 1;
1215    
1216     if (CursorY >= CursorTop)
1217     {
1218     if (CursorY-Param[1] > CursorTop)
1219     MoveCursor(CursorX,CursorY-Param[1]);
1220     else
1221     MoveCursor(CursorX,CursorTop);
1222     }
1223     else {
1224     if (CursorY > 0)
1225     MoveCursor(CursorX,CursorY-Param[1]);
1226     else
1227     MoveCursor(CursorX,0);
1228     }
1229     }
1230    
1231     void CSCursorUp1()
1232     {
1233     MoveCursor(0,CursorY);
1234     CSCursorUp();
1235     }
1236    
1237     void CSCursorDown()
1238     {
1239     if (Param[1]<1) Param[1] = 1;
1240    
1241     if (CursorY <= CursorBottom)
1242     {
1243     if (CursorY+Param[1] < CursorBottom)
1244     MoveCursor(CursorX,CursorY+Param[1]);
1245     else
1246     MoveCursor(CursorX,CursorBottom);
1247     }
1248     else {
1249     if (CursorY < NumOfLines-StatusLine-1)
1250     MoveCursor(CursorX,CursorY+Param[1]);
1251     else
1252     MoveCursor(CursorX,NumOfLines-StatusLine);
1253     }
1254     }
1255    
1256     void CSCursorDown1()
1257     {
1258     MoveCursor(0,CursorY);
1259     CSCursorDown();
1260     }
1261    
1262     void CSScreenErase()
1263     {
1264     if (Param[1] == -1) Param[1] = 0;
1265     BuffUpdateScroll();
1266     switch (Param[1]) {
1267     case 0:
1268     // <ESC>[H(Cursor in left upper corner)�������J�[�\�������������w�������������A
1269     // <ESC>[J��<ESC>[2J�����������������A�����������A���s�o�b�t�@���X�N���[���A�E�g
1270     // �����������������B(2005.5.29 yutaka)
1271     // �R���t�B�O���[�V�������������������������������B(2008.5.3 yutaka)
1272     if (ts.ScrollWindowClearScreen &&
1273     (CursorX == 0 && CursorY == 0)) {
1274     // Erase screen (scroll out)
1275     BuffClearScreen();
1276     UpdateWindow(HVTWin);
1277    
1278     } else {
1279     // Erase characters from cursor to the end of screen
1280     BuffEraseCurToEnd();
1281     }
1282     break;
1283    
1284     case 1:
1285     // Erase characters from home to cursor
1286     BuffEraseHomeToCur();
1287     break;
1288    
1289     case 2:
1290     // Erase screen (scroll out)
1291     BuffClearScreen();
1292     UpdateWindow(HVTWin);
1293     break;
1294     }
1295     }
1296    
1297     void CSInsertLine()
1298     {
1299     // Insert lines at current position
1300     int Count, YEnd;
1301    
1302     if (CursorY < CursorTop) return;
1303     if (CursorY > CursorBottom) return;
1304     if (Param[1]<1) Param[1] = 1;
1305     Count = Param[1];
1306    
1307     YEnd = CursorBottom;
1308     if (CursorY > YEnd) YEnd = NumOfLines-1-StatusLine;
1309     if (Count > YEnd+1 - CursorY) Count = YEnd+1 - CursorY;
1310    
1311     BuffInsertLines(Count,YEnd);
1312     }
1313    
1314     void CSLineErase()
1315     {
1316     if (Param[1] == -1) Param[1] = 0;
1317     BuffUpdateScroll();
1318     switch (Param[1]) {
1319     /* erase char from cursor to end of line */
1320     case 0:
1321     BuffEraseCharsInLine(CursorX,NumOfColumns-CursorX);
1322     break;
1323     /* erase char from start of line to cursor */
1324     case 1:
1325     BuffEraseCharsInLine(0,CursorX+1);
1326     break;
1327     /* erase entire line */
1328     case 2:
1329     BuffEraseCharsInLine(0,NumOfColumns);
1330     break;
1331     }
1332     }
1333    
1334     void CSDeleteNLines()
1335     // Delete lines from current line
1336     {
1337     int Count, YEnd;
1338    
1339     if (CursorY < CursorTop) return;
1340     if (CursorY > CursorBottom) return;
1341     Count = Param[1];
1342     if (Count<1) Count = 1;
1343    
1344     YEnd = CursorBottom;
1345     if (CursorY > YEnd) YEnd = NumOfLines-1-StatusLine;
1346     if (Count > YEnd+1-CursorY) Count = YEnd+1-CursorY;
1347     BuffDeleteLines(Count,YEnd);
1348     }
1349    
1350     void CSDeleteCharacter()
1351     {
1352     // Delete characters in current line from cursor
1353    
1354     if (Param[1]<1) Param[1] = 1;
1355     BuffUpdateScroll();
1356     BuffDeleteChars(Param[1]);
1357     }
1358    
1359     void CSEraseCharacter()
1360     {
1361     if (Param[1]<1) Param[1] = 1;
1362     BuffUpdateScroll();
1363     BuffEraseChars(Param[1]);
1364     }
1365    
1366     void CSScrollUP()
1367     {
1368     if (Param[1]<1) Param[1] = 1;
1369     BuffUpdateScroll();
1370     BuffRegionScrollUpNLines(Param[1]);
1371     }
1372    
1373     void CSScrollDown()
1374     {
1375     if (Param[1]<1) Param[1] = 1;
1376     BuffUpdateScroll();
1377     BuffRegionScrollDownNLines(Param[1]);
1378     }
1379    
1380     void CSForwardTab()
1381     {
1382     if (Param[1]<1) Param[1] = 1;
1383     CursorForwardTab(Param[1], AutoWrapMode);
1384     }
1385    
1386     void CSBackwardTab()
1387     {
1388     if (Param[1]<1) Param[1] = 1;
1389     CursorBackwardTab(Param[1]);
1390     }
1391    
1392     void CSMoveToColumnN()
1393     {
1394     if (Param[1]<1) Param[1] = 1;
1395     Param[1]--;
1396     if (Param[1] < 0) Param[1] = 0;
1397     if (Param[1] > NumOfColumns-1) Param[1] = NumOfColumns-1;
1398     MoveCursor(Param[1],CursorY);
1399     }
1400    
1401     void CSCursorRight()
1402     {
1403     if (Param[1]<1) Param[1] = 1;
1404     if (CursorX + Param[1] > NumOfColumns-1)
1405     MoveCursor(NumOfColumns-1,CursorY);
1406     else
1407     MoveCursor(CursorX+Param[1],CursorY);
1408     }
1409    
1410     void CSCursorLeft()
1411     {
1412     if (Param[1]<1) Param[1] = 1;
1413     if (CursorX-Param[1] < 0)
1414     MoveCursor(0,CursorY);
1415     else
1416     MoveCursor(CursorX-Param[1],CursorY);
1417     }
1418    
1419     void CSMoveToLineN()
1420     {
1421     if (Param[1]<1) Param[1] = 1;
1422     if (RelativeOrgMode)
1423     {
1424     if (CursorTop+Param[1]-1 > CursorBottom)
1425     MoveCursor(CursorX,CursorBottom);
1426     else
1427     MoveCursor(CursorX,CursorTop+Param[1]-1);
1428     }
1429     else {
1430     if (Param[1] > NumOfLines-StatusLine)
1431     MoveCursor(CursorX,NumOfLines-1-StatusLine);
1432     else
1433     MoveCursor(CursorX,Param[1]-1);
1434     }
1435     }
1436    
1437     void CSMoveToXY()
1438     {
1439     int NewX, NewY;
1440    
1441     if (Param[1]<1) Param[1] = 1;
1442     if ((NParam < 2) || (Param[2]<1)) Param[2] = 1;
1443     NewX = Param[2] - 1;
1444     if (NewX > NumOfColumns-1) NewX = NumOfColumns-1;
1445    
1446     if ((StatusLine>0) && (CursorY==NumOfLines-1))
1447     NewY = CursorY;
1448     else if (RelativeOrgMode)
1449     {
1450     NewY = CursorTop + Param[1] - 1;
1451     if (NewY > CursorBottom) NewY = CursorBottom;
1452     }
1453     else {
1454     NewY = Param[1] - 1;
1455     if (NewY > NumOfLines-1-StatusLine)
1456     NewY = NumOfLines-1-StatusLine;
1457     }
1458     MoveCursor(NewX,NewY);
1459     }
1460    
1461     void CSDeleteTabStop()
1462     {
1463     if (Param[1]==-1) Param[1] = 0;
1464     ClearTabStop(Param[1]);
1465     }
1466    
1467     void CS_h_Mode()
1468     {
1469     switch (Param[1]) {
1470 doda 3311 case 2: // KAM
1471     KeybEnabled = FALSE; break;
1472     case 4: // IRM
1473     InsertMode = TRUE; break;
1474     case 12: // SRM
1475 maya 3227 ts.LocalEcho = 0;
1476     if (cv.Ready && cv.TelFlag && (ts.TelEcho>0))
1477     TelChangeEcho();
1478     break;
1479 doda 3311 case 20: // LF/NL
1480 maya 3227 LFMode = TRUE;
1481     ts.CRSend = IdCRLF;
1482     cv.CRSend = IdCRLF;
1483     break;
1484 doda 3311 case 33: // WYSTCURM
1485 doda 3273 ts.NonblinkingCursor = TRUE;
1486     ChangeCaret();
1487     break;
1488 doda 3311 case 34: // WYULCURM
1489 doda 3273 ts.CursorShape = IdHCur;
1490     ChangeCaret();
1491     break;
1492 maya 3227 }
1493     }
1494    
1495     void CS_i_Mode()
1496     {
1497     if (Param[1]==-1) Param[1] = 0;
1498     switch (Param[1]) {
1499     /* print screen */
1500     // PrintEX -- TRUE: print screen
1501     // FALSE: scroll region
1502     case 0: BuffPrint(! PrintEX); break;
1503     /* printer controller mode off */
1504     case 4: break; /* See PrnParseCS() */
1505     /* printer controller mode on */
1506     case 5:
1507     if (! AutoPrintMode)
1508     OpenPrnFile();
1509     DirectPrn = (ts.PrnDev[0]!=0);
1510     PrinterMode = TRUE;
1511     break;
1512     }
1513     }
1514    
1515     void CS_l_Mode()
1516     {
1517     switch (Param[1]) {
1518 doda 3311 case 2: // KAM
1519     KeybEnabled = TRUE; break;
1520     case 4: // IRM
1521     InsertMode = FALSE; break;
1522     case 12: // SRM
1523 maya 3227 ts.LocalEcho = 1;
1524     if (cv.Ready && cv.TelFlag && (ts.TelEcho>0))
1525     TelChangeEcho();
1526     break;
1527 doda 3311 case 20: // LF/NL
1528 maya 3227 LFMode = FALSE;
1529     ts.CRSend = IdCR;
1530     cv.CRSend = IdCR;
1531     break;
1532 doda 3311 case 33: // WYSTCURM
1533 doda 3273 ts.NonblinkingCursor = FALSE;
1534     ChangeCaret();
1535     break;
1536 doda 3311 case 34: // WYULCURM
1537 doda 3273 ts.CursorShape = IdBlkCur;
1538     ChangeCaret();
1539     break;
1540 maya 3227 }
1541     }
1542    
1543     void CS_n_Mode()
1544     {
1545     char Report[16];
1546     int Y;
1547    
1548     switch (Param[1]) {
1549     case 5:
1550 doda 3311 /* Device Status Report -> Ready */
1551 maya 3227 if (Send8BitMode)
1552 doda 3311 CommBinaryOut(&cv,"\2330n",3);
1553 maya 3227 else
1554 doda 3311 CommBinaryOut(&cv,"\033[0n",4);
1555 maya 3227 break;
1556     case 6:
1557     /* Cursor Position Report */
1558     Y = CursorY+1;
1559     if ((StatusLine>0) &&
1560     (Y==NumOfLines))
1561     Y = 1;
1562     if (Send8BitMode)
1563     _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "\233%u;%uR", CLocale, Y, CursorX+1);
1564     else
1565     _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "\033[%u;%uR", CLocale, Y, CursorX+1);
1566     CommBinaryOut(&cv,Report,strlen(Report));
1567     break;
1568     }
1569     }
1570    
1571     void CSSetAttr()
1572     {
1573     int i, P;
1574    
1575     UpdateStr();
1576     for (i=1 ; i<=NParam ; i++)
1577     {
1578     P = Param[i];
1579     if (P<0) P = 0;
1580     switch (P) {
1581     case 0: /* Clear all */
1582     CharAttr = DefCharAttr;
1583     BuffSetCurCharAttr(CharAttr);
1584     break;
1585    
1586     case 1: /* Bold */
1587     CharAttr.Attr |= AttrBold;
1588     BuffSetCurCharAttr(CharAttr);
1589     break;
1590    
1591     case 4: /* Under line */
1592     CharAttr.Attr |= AttrUnder;
1593     BuffSetCurCharAttr(CharAttr);
1594     break;
1595    
1596     case 5: /* Blink */
1597     CharAttr.Attr |= AttrBlink;
1598     BuffSetCurCharAttr(CharAttr);
1599     break;
1600    
1601     case 7: /* Reverse */
1602     CharAttr.Attr |= AttrReverse;
1603     BuffSetCurCharAttr(CharAttr);
1604     break;
1605    
1606     case 22: /* Bold off */
1607     CharAttr.Attr &= ~ AttrBold;
1608     BuffSetCurCharAttr(CharAttr);
1609     break;
1610    
1611     case 24: /* Under line off */
1612     CharAttr.Attr &= ~ AttrUnder;
1613     BuffSetCurCharAttr(CharAttr);
1614     break;
1615    
1616     case 25: /* Blink off */
1617     CharAttr.Attr &= ~ AttrBlink;
1618     BuffSetCurCharAttr(CharAttr);
1619     break;
1620    
1621     case 27: /* Reverse off */
1622     CharAttr.Attr &= ~ AttrReverse;
1623     BuffSetCurCharAttr(CharAttr);
1624     break;
1625    
1626     case 30:
1627     case 31:
1628     case 32:
1629     case 33:
1630     case 34:
1631     case 35:
1632     case 36:
1633     case 37: /* text color */
1634     CharAttr.Attr2 |= Attr2Fore;
1635     CharAttr.Fore = P - 30;
1636     BuffSetCurCharAttr(CharAttr);
1637     break;
1638    
1639     case 38: /* text color (256color mode) */
1640     if ((ts.ColorFlag & CF_XTERM256) && i < NParam && Param[i+1] == 5) {
1641     i++;
1642     if (i < NParam) {
1643     P = Param[++i];
1644     if (P<0) {
1645     P = 0;
1646     }
1647     CharAttr.Attr2 |= Attr2Fore;
1648     CharAttr.Fore = P;
1649     BuffSetCurCharAttr(CharAttr);
1650     }
1651     }
1652     break;
1653    
1654     case 39: /* Reset text color */
1655     CharAttr.Attr2 &= ~ Attr2Fore;
1656     CharAttr.Fore = AttrDefaultFG;
1657     BuffSetCurCharAttr(CharAttr);
1658     break;
1659    
1660     case 40:
1661     case 41:
1662     case 42:
1663     case 43:
1664     case 44:
1665     case 45:
1666     case 46:
1667     case 47: /* Back color */
1668     CharAttr.Attr2 |= Attr2Back;
1669     CharAttr.Back = P - 40;
1670     BuffSetCurCharAttr(CharAttr);
1671     break;
1672    
1673     case 48: /* Back color (256color mode) */
1674     if ((ts.ColorFlag & CF_XTERM256) && i < NParam && Param[i+1] == 5) {
1675     i++;
1676     if (i < NParam) {
1677     P = Param[++i];
1678     if (P<0) {
1679     P = 0;
1680     }
1681     CharAttr.Attr2 |= Attr2Back;
1682     CharAttr.Back = P;
1683     BuffSetCurCharAttr(CharAttr);
1684     }
1685     }
1686     break;
1687    
1688     case 49: /* Reset back color */
1689     CharAttr.Attr2 &= ~ Attr2Back;
1690     CharAttr.Back = AttrDefaultBG;
1691     BuffSetCurCharAttr(CharAttr);
1692     break;
1693    
1694     case 90:
1695     case 91:
1696     case 92:
1697     case 93:
1698     case 94:
1699     case 95:
1700     case 96:
1701     case 97: /* aixterm style text color */
1702     if (ts.ColorFlag & CF_AIXTERM16) {
1703     CharAttr.Attr2 |= Attr2Fore;
1704     CharAttr.Fore = P - 90 + 8;
1705     BuffSetCurCharAttr(CharAttr);
1706     }
1707     break;
1708    
1709     case 100:
1710     if (! (ts.ColorFlag & CF_AIXTERM16)) {
1711     /* Reset text and back color */
1712     CharAttr.Attr2 &= ~ (Attr2Fore | Attr2Back);
1713     CharAttr.Fore = AttrDefaultFG;
1714     CharAttr.Back = AttrDefaultBG;
1715     BuffSetCurCharAttr(CharAttr);
1716     break;
1717     }
1718     /* fall through to aixterm style back color */
1719    
1720     case 101:
1721     case 102:
1722     case 103:
1723     case 104:
1724     case 105:
1725     case 106:
1726     case 107: /* aixterm style back color */
1727     if (ts.ColorFlag & CF_AIXTERM16) {
1728     CharAttr.Attr2 |= Attr2Back;
1729     CharAttr.Back = P - 100 + 8;
1730     BuffSetCurCharAttr(CharAttr);
1731     }
1732     break;
1733     }
1734     }
1735     }
1736    
1737     void CSSetScrollRegion()
1738     {
1739     if ((StatusLine>0) &&
1740     (CursorY==NumOfLines-1))
1741     {
1742     MoveCursor(0,CursorY);
1743     return;
1744     }
1745     if (Param[1]<1) Param[1] =1;
1746     if ((NParam < 2) | (Param[2]<1))
1747     Param[2] = NumOfLines-StatusLine;
1748     Param[1]--;
1749     Param[2]--;
1750     if (Param[1] > NumOfLines-1-StatusLine)
1751     Param[1] = NumOfLines-1-StatusLine;
1752     if (Param[2] > NumOfLines-1-StatusLine)
1753     Param[2] = NumOfLines-1-StatusLine;
1754     if (Param[1] >= Param[2]) return;
1755     CursorTop = Param[1];
1756     CursorBottom = Param[2];
1757     if (RelativeOrgMode) MoveCursor(0,CursorTop);
1758     else MoveCursor(0,0);
1759     }
1760    
1761     void CSSunSequence() /* Sun terminal private sequences */
1762     {
1763     char Report[16];
1764    
1765     switch (Param[1]) {
1766 doda 3302 case 1: // De-iconify window
1767 doda 3309 DispShowWindow(WINDOW_RESTORE);
1768 doda 3302 break;
1769     case 2: // Iconify window
1770 doda 3309 DispShowWindow(WINDOW_MINIMIZE);
1771 doda 3302 break;
1772     case 3: // set window position
1773 doda 3297 if (NParam < 2) Param[2] = 0;
1774     if (NParam < 3) Param[3] = 0;
1775     DispMoveWindow(Param[2], Param[3]);
1776     break;
1777 doda 3464 case 4: // set window size by pixel
1778     if (NParam < 2) Param[2] = 0;
1779     if (NParam < 3) Param[3] = 0;
1780     DispResizeWin(Param[3], Param[2]);
1781     break;
1782 doda 3311 case 5: // Raise window
1783 doda 3309 DispShowWindow(WINDOW_RAISE);
1784     break;
1785 doda 3311 case 6: // Lower window
1786 doda 3309 DispShowWindow(WINDOW_LOWER);
1787     break;
1788 doda 3311 case 7: // Refresh window
1789 doda 3310 DispShowWindow(WINDOW_REFRESH);
1790     break;
1791 maya 3227 case 8: /* set terminal size */
1792     if ((Param[2]<=1) || (NParam<2)) Param[2] = 24;
1793     if ((Param[3]<=1) || (NParam<3)) Param[3] = 80;
1794     ChangeTerminalSize(Param[3],Param[2]);
1795     break;
1796 doda 3302 case 9: // Maximize/Restore window
1797     if (NParam < 2 || Param[2] == 0) {
1798 doda 3309 DispShowWindow(WINDOW_RESTORE);
1799 doda 3302 }
1800     else {
1801 doda 3309 DispShowWindow(WINDOW_MAXIMIZE);
1802 doda 3302 }
1803     break;
1804 maya 3227 case 14: /* get window size??? */
1805     /* this is not actual window size */
1806     if (Send8BitMode)
1807     CommBinaryOut(&cv,"\2334;640;480t",11);
1808     else
1809     CommBinaryOut(&cv,"\033[4;640;480t",12);
1810     break;
1811     case 18: /* get terminal size */
1812     if (Send8BitMode)
1813     _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "\2338;%u;%u;t", CLocale, NumOfLines-StatusLine, NumOfColumns);
1814     else
1815     _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "\033[8;%u;%u;t", CLocale, NumOfLines-StatusLine, NumOfColumns);
1816     CommBinaryOut(&cv,Report,strlen(Report));
1817     break;
1818     }
1819     }
1820    
1821     void CSGT(BYTE b)
1822     {
1823     switch (b) {
1824 doda 3311 case 'c': /* second terminal report (Secondary DA) */
1825 maya 3227 if (Send8BitMode)
1826     CommBinaryOut(&cv,"\233>32;10;2c",11); /* VT382 */
1827     else
1828     CommBinaryOut(&cv,"\033[>32;10;2c",11); /* VT382 */
1829     break;
1830     case 'J':
1831     if (Param[1]==3) // IO-8256 terminal
1832     {
1833     if (Param[2]<1) Param[2]=1;
1834     if (Param[3]<1) Param[3]=1;
1835     if (Param[4]<1) Param[4]=1;
1836     if (Param[5]<1) Param[5]=1;
1837     BuffEraseBox(Param[3]-1,Param[2]-1,
1838     Param[5]-1,Param[4]-1);
1839     }
1840     break;
1841     case 'K':
1842     if ((NParam>=2) && (Param[1]==5))
1843     { // IO-8256 terminal
1844     switch (Param[2]) {
1845     case 3:
1846     case 4:
1847     case 5:
1848     case 6:
1849     BuffDrawLine(CharAttr, Param[2], Param[3]);
1850     break;
1851     case 12:
1852     /* Text color */
1853     if ((Param[3]>=0) && (Param[3]<=7))
1854     {
1855     switch (Param[3]) {
1856     case 3: CharAttr.Fore = IdBlue; break;
1857     case 4: CharAttr.Fore = IdCyan; break;
1858     case 5: CharAttr.Fore = IdYellow; break;
1859     case 6: CharAttr.Fore = IdMagenta; break;
1860     default: CharAttr.Fore = Param[3]; break;
1861     }
1862     CharAttr.Attr2 |= Attr2Fore;
1863     BuffSetCurCharAttr(CharAttr);
1864     }
1865     break;
1866     }
1867     }
1868     else if (Param[1]==3)
1869     {// IO-8256 terminal
1870     if (Param[2]<1) Param[2] = 1;
1871     if (Param[3]<1) Param[2] = 1;
1872     BuffEraseCharsInLine(Param[2]-1,Param[3]-Param[2]+1);
1873     }
1874     break;
1875     }
1876     }
1877    
1878     void CSQExchangeColor()
1879     {
1880     COLORREF ColorRef;
1881    
1882     BuffUpdateScroll();
1883    
1884     if (ts.ColorFlag & CF_REVERSECOLOR) {
1885     ColorRef = ts.VTColor[0];
1886     ts.VTColor[0] = ts.VTReverseColor[0];
1887     ts.VTReverseColor[0] = ColorRef;
1888     ColorRef = ts.VTColor[1];
1889     ts.VTColor[1] = ts.VTReverseColor[1];
1890     ts.VTReverseColor[1] = ColorRef;
1891     }
1892     else {
1893     ColorRef = ts.VTColor[0];
1894     ts.VTColor[0] = ts.VTColor[1];
1895     ts.VTColor[1] = ColorRef;
1896     }
1897    
1898     ColorRef = ts.VTBoldColor[0];
1899     ts.VTBoldColor[0] = ts.VTBoldColor[1];
1900     ts.VTBoldColor[1] = ColorRef;
1901    
1902     ColorRef = ts.VTBlinkColor[0];
1903     ts.VTBlinkColor[0] = ts.VTBlinkColor[1];
1904     ts.VTBlinkColor[1] = ColorRef;
1905    
1906     ColorRef = ts.URLColor[0];
1907     ts.URLColor[0] = ts.URLColor[1];
1908     ts.URLColor[1] = ColorRef;
1909    
1910     ts.ColorFlag ^= CF_REVERSEVIDEO;
1911    
1912     #ifdef ALPHABLEND_TYPE2
1913     BGInitialize();
1914     #endif
1915     DispChangeBackground();
1916     UpdateWindow(HVTWin);
1917     }
1918    
1919     void CSQ_h_Mode()
1920     {
1921     int i;
1922    
1923     for (i = 1 ; i<=NParam ; i++)
1924     switch (Param[i]) {
1925     case 1: AppliCursorMode = TRUE; break;
1926     case 3:
1927     ChangeTerminalSize(132,NumOfLines-StatusLine);
1928     break;
1929     case 5: /* Reverse Video */
1930     if (!(ts.ColorFlag & CF_REVERSEVIDEO))
1931     CSQExchangeColor(); /* Exchange text/back color */
1932     break;
1933     case 6:
1934     if ((StatusLine>0) &&
1935     (CursorY==NumOfLines-1))
1936     MoveCursor(0,CursorY);
1937     else {
1938     RelativeOrgMode = TRUE;
1939     MoveCursor(0,CursorTop);
1940     }
1941     break;
1942     case 7: AutoWrapMode = TRUE; break;
1943     case 8: AutoRepeatMode = TRUE; break;
1944     case 9:
1945     if (ts.MouseEventTracking)
1946     MouseReportMode = IdMouseTrackX10;
1947     break;
1948 doda 3296 case 12: ts.NonblinkingCursor = FALSE; ChangeCaret(); break;
1949 maya 3227 case 19: PrintEX = TRUE; break;
1950     case 25: DispEnableCaret(TRUE); break; // cursor on
1951     case 38:
1952     if (ts.AutoWinSwitch>0)
1953     ChangeEmu = IdTEK; /* Enter TEK Mode */
1954     break;
1955     case 59:
1956     if (ts.Language==IdJapanese)
1957     { /* kanji terminal */
1958     Gn[0] = IdASCII;
1959     Gn[1] = IdKatakana;
1960     Gn[2] = IdKatakana;
1961     Gn[3] = IdKanji;
1962     Glr[0] = 0;
1963     if ((ts.KanjiCode==IdJIS) &&
1964     (ts.JIS7Katakana==0))
1965     Glr[1] = 2; // 8-bit katakana
1966     else
1967     Glr[1] = 3;
1968     }
1969     break;
1970     case 66: AppliKeyMode = TRUE; break;
1971     case 67: ts.BSKey = IdBS; break;
1972     case 1000:
1973     if (ts.MouseEventTracking)
1974     MouseReportMode = IdMouseTrackVT200;
1975     break;
1976     case 1001:
1977     if (ts.MouseEventTracking)
1978     MouseReportMode = IdMouseTrackVT200Hl;
1979     break;
1980     case 1002:
1981     if (ts.MouseEventTracking)
1982     MouseReportMode = IdMouseTrackBtnEvent;
1983     break;
1984     case 1003:
1985     if (ts.MouseEventTracking)
1986     MouseReportMode = IdMouseTrackAllEvent;
1987     break;
1988     case 1004:
1989     if (ts.MouseEventTracking)
1990     FocusReportMode = TRUE;
1991     break;
1992     }
1993     }
1994    
1995     void CSQ_i_Mode()
1996     {
1997     if (Param[1]==-1) Param[1] = 0;
1998     switch (Param[1]) {
1999     case 1:
2000     OpenPrnFile();
2001     BuffDumpCurrentLine(LF);
2002     if (! AutoPrintMode)
2003     ClosePrnFile();
2004     break;
2005     /* auto print mode off */
2006     case 4:
2007     if (AutoPrintMode)
2008     {
2009     ClosePrnFile();
2010     AutoPrintMode = FALSE;
2011     }
2012     break;
2013     /* auto print mode on */
2014     case 5:
2015     if (! AutoPrintMode)
2016     {
2017     OpenPrnFile();
2018     AutoPrintMode = TRUE;
2019     }
2020     break;
2021     }
2022     }
2023    
2024     void CSQ_l_Mode()
2025     {
2026     int i;
2027    
2028     for (i = 1 ; i <= NParam ; i++)
2029     switch (Param[i]) {
2030     case 1: AppliCursorMode = FALSE; break;
2031     case 3:
2032     ChangeTerminalSize(80,NumOfLines-StatusLine);
2033     break;
2034     case 5: /* Normal Video */
2035     if (ts.ColorFlag & CF_REVERSEVIDEO)
2036     CSQExchangeColor(); /* Exchange text/back color */
2037     break;
2038     case 6:
2039     if ((StatusLine>0) &&
2040     (CursorY==NumOfLines-1))
2041     MoveCursor(0,CursorY);
2042     else {
2043     RelativeOrgMode = FALSE;
2044     MoveCursor(0,0);
2045     }
2046     break;
2047     case 7: AutoWrapMode = FALSE; break;
2048     case 8: AutoRepeatMode = FALSE; break;
2049     case 9: MouseReportMode = IdMouseTrackNone; break;
2050 doda 3296 case 12: ts.NonblinkingCursor = TRUE; ChangeCaret(); break;
2051 maya 3227 case 19: PrintEX = FALSE; break;
2052     case 25: DispEnableCaret(FALSE); break; // cursor off
2053     case 59:
2054     if (ts.Language==IdJapanese)
2055     { /* katakana terminal */
2056     Gn[0] = IdASCII;
2057     Gn[1] = IdKatakana;
2058     Gn[2] = IdKatakana;
2059     Gn[3] = IdKanji;
2060     Glr[0] = 0;
2061     if ((ts.KanjiCode==IdJIS) &&
2062     (ts.JIS7Katakana==0))
2063     Glr[1] = 2; // 8-bit katakana
2064     else
2065     Glr[1] = 3;
2066     }
2067     break;
2068     case 66: AppliKeyMode = FALSE; break;
2069     case 67: ts.BSKey = IdDEL; break;
2070     case 1000:
2071     case 1001:
2072     case 1002:
2073     case 1003: MouseReportMode = IdMouseTrackNone; break;
2074     case 1004: FocusReportMode = FALSE; break;
2075     }
2076     }
2077    
2078     void CSQ_n_Mode()
2079     {
2080     }
2081    
2082     void CSQuest(BYTE b)
2083     {
2084     switch (b) {
2085     case 'K': CSLineErase(); break;
2086     case 'h': CSQ_h_Mode(); break;
2087     case 'i': CSQ_i_Mode(); break;
2088     case 'l': CSQ_l_Mode(); break;
2089     case 'n': CSQ_n_Mode(); break;
2090     }
2091     }
2092    
2093     void SoftReset()
2094     // called by software-reset escape sequence handler
2095     {
2096     UpdateStr();
2097     AutoRepeatMode = TRUE;
2098     DispEnableCaret(TRUE); // cursor on
2099     InsertMode = FALSE;
2100     RelativeOrgMode = FALSE;
2101     AppliKeyMode = FALSE;
2102     AppliCursorMode = FALSE;
2103     if ((StatusLine>0) &&
2104     (CursorY == NumOfLines-1))
2105     MoveToMainScreen();
2106     CursorTop = 0;
2107     CursorBottom = NumOfLines-1-StatusLine;
2108     ResetCharSet();
2109    
2110     Send8BitMode = ts.Send8BitCtrl;
2111    
2112     /* Attribute */
2113     CharAttr = DefCharAttr;
2114     Special = FALSE;
2115     BuffSetCurCharAttr(CharAttr);
2116    
2117     // status buffers
2118     ResetSBuffers();
2119     }
2120    
2121     void CSExc(BYTE b)
2122     {
2123     switch (b) {
2124     case 'p':
2125     /* Software reset */
2126     SoftReset();
2127     break;
2128     }
2129     }
2130    
2131     void CSDouble(BYTE b)
2132     {
2133     switch (b) {
2134     case 'p':
2135     /* Select terminal mode (software reset) */
2136     SoftReset();
2137     if (NParam > 0) {
2138     switch (Param[1]) {
2139     case 61: // VT100 Mode
2140     Send8BitMode = FALSE; break;
2141     case 62: // VT200 Mode
2142     case 63: // VT300 Mode
2143     case 64: // VT400 Mode
2144     if (NParam > 1 && Param[2] == 1)
2145     Send8BitMode = FALSE;
2146     else
2147     Send8BitMode = TRUE;
2148     break;
2149     }
2150     }
2151     break;
2152     }
2153     }
2154    
2155     void CSDol(BYTE b)
2156     {
2157     switch (b) {
2158     case '}':
2159     if ((ts.TermFlag & TF_ENABLESLINE)==0) return;
2160     if (StatusLine==0) return;
2161     if ((Param[1]<1) && (CursorY==NumOfLines-1))
2162     MoveToMainScreen();
2163     else if ((Param[1]==1) && (CursorY<NumOfLines-1))
2164     MoveToStatusLine();
2165     break;
2166     case '~':
2167     if ((ts.TermFlag & TF_ENABLESLINE)==0) return;
2168     if (Param[1]<=1)
2169     HideStatusLine();
2170     else if ((StatusLine==0) && (Param[1]==2))
2171     ShowStatusLine(1); // show
2172     break;
2173     }
2174     }
2175    
2176 doda 3263 void CSSpace(BYTE b) {
2177     switch (b) {
2178     case 'q':
2179     if (NParam > 0) {
2180     if (Param[1] < 0) Param[1] = 0;
2181     switch (Param[1]) {
2182     case 0:
2183     case 1:
2184     ts.CursorShape = IdBlkCur;
2185     ts.NonblinkingCursor = FALSE;
2186     break;
2187     case 2:
2188     ts.CursorShape = IdBlkCur;
2189     ts.NonblinkingCursor = TRUE;
2190     break;
2191     case 3:
2192     ts.CursorShape = IdHCur;
2193     ts.NonblinkingCursor = FALSE;
2194     break;
2195     case 4:
2196     ts.CursorShape = IdHCur;
2197     ts.NonblinkingCursor = TRUE;
2198     break;
2199 doda 3265 case 5:
2200     ts.CursorShape = IdVCur;
2201     ts.NonblinkingCursor = FALSE;
2202     break;
2203     case 6:
2204     ts.CursorShape = IdVCur;
2205     ts.NonblinkingCursor = TRUE;
2206     break;
2207 doda 3263 default:
2208     return;
2209     }
2210     ChangeCaret();
2211     }
2212     break;
2213     }
2214     }
2215    
2216 maya 3227 void PrnParseCS(BYTE b) // printer mode
2217     {
2218     ParseMode = ModeFirst;
2219     switch (ICount) {
2220     /* no intermediate char */
2221     case 0:
2222     switch (Prv) {
2223     /* no private parameter */
2224     case 0:
2225     switch (b) {
2226     case 'i':
2227     if (Param[1]==4)
2228     {
2229     PrinterMode = FALSE;
2230     // clear prn buff
2231     WriteToPrnFile(0,FALSE);
2232     if (! AutoPrintMode)
2233     ClosePrnFile();
2234     return;
2235     }
2236     break;
2237     } /* of case Prv=0 */
2238     break;
2239     }
2240     break;
2241     /* one intermediate char */
2242     case 1: break;
2243     } /* of case Icount */
2244    
2245     WriteToPrnFile(b,TRUE);
2246     }
2247    
2248     void ParseCS(BYTE b) /* b is the final char */
2249     {
2250     if (PrinterMode) { // printer mode
2251     PrnParseCS(b);
2252     return;
2253     }
2254    
2255     switch (ICount) {
2256     /* no intermediate char */
2257     case 0:
2258     switch (Prv) {
2259     /* no private parameter */
2260     case 0:
2261     switch (b) {
2262 doda 3311 // ISO/IEC 6429 / ECMA-48 Sequence
2263     case '@': CSInsertCharacter(); break; // ICH
2264     case 'A': CSCursorUp(); break; // CUU
2265     case 'B': CSCursorDown(); break; // CUD
2266     case 'C': CSCursorRight(); break; // CUF
2267     case 'D': CSCursorLeft(); break; // CUB
2268     case 'E': CSCursorDown1(); break; // CNL
2269     case 'F': CSCursorUp1(); break; // CPL
2270     case 'G': CSMoveToColumnN(); break; // CHA
2271     case 'H': CSMoveToXY(); break; // CUP
2272     case 'I': CSForwardTab(); break; // CHT
2273     case 'J': CSScreenErase(); break; // ED
2274     case 'K': CSLineErase(); break; // EL
2275     case 'L': CSInsertLine(); break; // IL
2276     case 'M': CSDeleteNLines(); break; // DL
2277     // case 'N': break; // EF -- Not support
2278     // case 'O': break; // EA -- Not support
2279     case 'P': CSDeleteCharacter(); break; // DCH
2280     // case 'Q': break; // SEE -- Not support
2281     // case 'R': break; // CPR -- Not support
2282     case 'S': CSScrollUP(); break; // SU
2283     case 'T': CSScrollDown(); break; // SD
2284     // case 'U': break; // NP -- Not support
2285     // case 'V': break; // PP -- Not support
2286     // case 'W': break; // CTC -- Not support
2287     case 'X': CSEraseCharacter(); break; // ECH
2288     // case 'Y': break; // CVT -- Not support
2289     case 'Z': CSBackwardTab(); break; // CBT
2290     // caes '[': break; // SRS -- Not support
2291     // caes '\\': break; // PTX -- Not support
2292     // caes ']': break; // SDS -- Not support
2293     // caes '^': break; // SIMD -- Not support
2294     case '`': CSMoveToColumnN(); break; // HPA
2295     case 'a': CSCursorRight(); break; // HPR
2296     // caes 'b': break; // REP -- Not support
2297     case 'c': AnswerTerminalType(); break; // DA
2298     case 'd': CSMoveToLineN(); break; // VPA
2299     case 'e': CSCursorUp(); break; // VPR
2300     case 'f': CSMoveToXY(); break; // HVP
2301     case 'g': CSDeleteTabStop(); break; // TBC
2302     case 'h': CS_h_Mode(); break; // SM
2303     case 'i': CS_i_Mode(); break; // MC
2304     // caes 'b': break; // HPB -- Not support
2305     // caes 'b': break; // VPB -- Not support
2306     case 'l': CS_l_Mode(); break; // RM
2307     case 'm': CSSetAttr(); break; // SGR
2308     case 'n': CS_n_Mode(); break; // DSR
2309     // caes 'o': break; // DAQ -- Not support
2310    
2311     // Private Sequence
2312     case 'r': CSSetScrollRegion(); break; // DECSTBM
2313     case 's': SaveCursor(); break; // SCP (Save cursor (ANSI.SYS/SCO?))
2314     case 't': CSSunSequence(); break; // DECSLPP / Window manipulation(dtterm?)
2315     case 'u': RestoreCursor(); break; // RCP (Restore cursor (ANSI.SYS/SCO))
2316 maya 3227 } /* of case Prv=0 */
2317     break;
2318     /* private parameter = '>' */
2319     case '>': CSGT(b); break;
2320     /* private parameter = '?' */
2321     case '?': CSQuest(b); break;
2322 doda 3311 } /* end of siwtch (Prv) */
2323 maya 3227 break;
2324     /* one intermediate char */
2325     case 1:
2326     switch (IntChar[1]) {
2327 doda 3263 /* intermediate char = ' ' */
2328     case ' ': CSSpace(b); break;
2329 maya 3227 /* intermediate char = '!' */
2330     case '!': CSExc(b); break;
2331     /* intermediate char = '"' */
2332     case '"': CSDouble(b); break;
2333     /* intermediate char = '$' */
2334     case '$': CSDol(b); break;
2335     }
2336     break;
2337     } /* of case Icount */
2338    
2339     ParseMode = ModeFirst;
2340     }
2341    
2342     void ControlSequence(BYTE b)
2343     {
2344     if ((b<=US) || (b>=0x80) && (b<=0x9F))
2345     ParseControl(b); /* ctrl char */
2346     else if ((b>=0x40) && (b<=0x7E))
2347     ParseCS(b); /* terminate char */
2348     else {
2349     if (PrinterMode)
2350     WriteToPrnFile(b,FALSE);
2351    
2352     if ((b>=0x20) && (b<=0x2F))
2353     { /* intermediate char */
2354     if (ICount<IntCharMax) ICount++;
2355     IntChar[ICount] = b;
2356     }
2357     else if ((b>=0x30) && (b<=0x39))
2358     {
2359     if (Param[NParam] < 0)
2360     Param[NParam] = 0;
2361     if (Param[NParam]<1000)
2362     Param[NParam] = Param[NParam]*10 + b - 0x30;
2363     }
2364     else if (b==0x3B)
2365     {
2366     if (NParam < NParamMax)
2367     {
2368     NParam++;
2369     Param[NParam] = -1;
2370     }
2371     }
2372     else if ((b>=0x3C) && (b<=0x3F))
2373     { /* private char */
2374     if (FirstPrm) Prv = b;
2375     }
2376     }
2377     FirstPrm = FALSE;
2378     }
2379    
2380     void DeviceControl(BYTE b)
2381     {
2382     if (ESCFlag && (b=='\\') || (b==ST && ts.KanjiCode!=IdSJIS))
2383     {
2384     ESCFlag = FALSE;
2385     ParseMode = SavedMode;
2386     return;
2387     }
2388    
2389     if (b==ESC)
2390     {
2391     ESCFlag = TRUE;
2392     return;
2393     }
2394     else ESCFlag = FALSE;
2395    
2396     if (b<=US)
2397     ParseControl(b);
2398     else if ((b>=0x30) && (b<=0x39))
2399     {
2400     if (Param[NParam] < 0) Param[NParam] = 0;
2401     if (Param[NParam]<1000)
2402     Param[NParam] = Param[NParam]*10 + b - 0x30;
2403     }
2404     else if (b==0x3B)
2405     {
2406     if (NParam < NParamMax)
2407     {
2408     NParam++;
2409     Param[NParam] = -1;
2410     }
2411     }
2412     else if ((b>=0x40) && (b<=0x7E))
2413     {
2414     if (b=='|')
2415     {
2416     ParseMode = ModeDCUserKey;
2417     if (Param[1] < 1) ClearUserKey();
2418     WaitKeyId = TRUE;
2419     NewKeyId = 0;
2420     }
2421     else ParseMode = ModeSOS;
2422     }
2423     }
2424    
2425     void DCUserKey(BYTE b)
2426     {
2427     if (ESCFlag && (b=='\\') || (b==ST && ts.KanjiCode!=IdSJIS))
2428     {
2429     if (! WaitKeyId) DefineUserKey(NewKeyId,NewKeyStr,NewKeyLen);
2430     ESCFlag = FALSE;
2431     ParseMode = SavedMode;
2432     return;
2433     }
2434    
2435     if (b==ESC)
2436     {
2437     ESCFlag = TRUE;
2438     return;
2439     }
2440     else ESCFlag = FALSE;
2441    
2442     if (WaitKeyId)
2443     {
2444     if ((b>=0x30) && (b<=0x39))
2445     {
2446     if (NewKeyId<1000)
2447     NewKeyId = NewKeyId*10 + b - 0x30;
2448     }
2449     else if (b==0x2F)
2450     {
2451     WaitKeyId = FALSE;
2452     WaitHi = TRUE;
2453     NewKeyLen = 0;
2454     }
2455     }
2456     else {
2457     if (b==0x3B)
2458     {
2459     DefineUserKey(NewKeyId,NewKeyStr,NewKeyLen);
2460     WaitKeyId = TRUE;
2461     NewKeyId = 0;
2462     }
2463     else {
2464     if (NewKeyLen < FuncKeyStrMax)
2465     {
2466     if (WaitHi)
2467     {
2468     NewKeyStr[NewKeyLen] = ConvHexChar(b) << 4;
2469     WaitHi = FALSE;
2470     }
2471     else {
2472     NewKeyStr[NewKeyLen] = NewKeyStr[NewKeyLen] +
2473     ConvHexChar(b);
2474     WaitHi = TRUE;
2475     NewKeyLen++;
2476     }
2477     }
2478     }
2479     }
2480     }
2481    
2482     void IgnoreString(BYTE b)
2483     {
2484     if ((ESCFlag && (b=='\\')) ||
2485     (b<=US && b!=ESC && b!=HT) ||
2486     (b==ST && ts.KanjiCode!=IdSJIS))
2487     ParseMode = SavedMode;
2488    
2489     if (b==ESC) ESCFlag = TRUE;
2490     else ESCFlag = FALSE;
2491     }
2492    
2493     BOOL XsParseColor(char *colspec, COLORREF *color)
2494     {
2495     unsigned int r, g, b;
2496     // double dr, dg, db;
2497    
2498     r = g = b = 255;
2499    
2500     if (colspec == NULL || color == NULL) {
2501     return FALSE;
2502     }
2503    
2504     if (_strnicmp(colspec, "rgb:", 4) == 0) {
2505     switch (strlen(colspec)) {
2506     case 9: // rgb:R/G/B
2507     if (sscanf(colspec, "rgb:%1x/%1x/%1x", &r, &g, &b) != 3) {
2508     return FALSE;
2509     }
2510     r *= 17; g *= 17; b *= 17;
2511     break;
2512     case 12: // rgb:RR/GG/BB
2513     if (sscanf(colspec, "rgb:%2x/%2x/%2x", &r, &g, &b) != 3) {
2514     return FALSE;
2515     }
2516     break;
2517     case 15: // rgb:RRR/GGG/BBB
2518     if (sscanf(colspec, "rgb:%3x/%3x/%3x", &r, &g, &b) != 3) {
2519     return FALSE;
2520     }
2521     r >>= 4; g >>= 4; b >>= 4;
2522     break;
2523     case 18: // rgb:RRRR/GGGG/BBBB
2524     if (sscanf(colspec, "rgb:%4x/%4x/%4x", &r, &g, &b) != 3) {
2525     return FALSE;
2526     }
2527     r >>= 8; g >>= 8; b >>= 8;
2528     break;
2529     default:
2530     return FALSE;
2531     }
2532     }
2533     // else if (_strnicmp(colspec, "rgbi:", 5) == 0) {
2534     // ; /* nothing to do */
2535     // }
2536     else if (colspec[0] == '#') {
2537     switch (strlen(colspec)) {
2538     case 4: // #RGB
2539     if (sscanf(colspec, "#%1x%1x%1x", &r, &g, &b) != 3) {
2540     return FALSE;
2541     }
2542     r <<= 4; g <<= 4; b <<= 4;
2543     break;
2544     case 7: // #RRGGBB
2545     if (sscanf(colspec, "#%2x%2x%2x", &r, &g, &b) != 3) {
2546     return FALSE;
2547     }
2548     break;
2549     case 10: // #RRRGGGBBB
2550     if (sscanf(colspec, "#%3x%3x%3x", &r, &g, &b) != 3) {
2551     return FALSE;
2552     }
2553     r >>= 4; g >>= 4; b >>= 4;
2554     break;
2555     case 13: // #RRRRGGGGBBBB
2556     if (sscanf(colspec, "#%4x%4x%4x", &r, &g, &b) != 3) {
2557     return FALSE;
2558     }
2559     r >>= 8; g >>= 8; b >>= 8;
2560     break;
2561     default:
2562     return FALSE;
2563     }
2564     }
2565     else {
2566     return FALSE;
2567     }
2568    
2569     if (r > 255 || g > 255 || b > 255) {
2570     return FALSE;
2571     }
2572    
2573     *color = RGB(r, g, b);
2574     return TRUE;
2575     }
2576    
2577     #define ModeXsFirst 1
2578     #define ModeXsString 2
2579     #define ModeXsColorNum 3
2580     #define ModeXsColorSpec 4
2581     #define ModeXsEsc 5
2582     void XSequence(BYTE b)
2583     {
2584     static BYTE XsParseMode = ModeXsFirst, PrevMode;
2585     static char StrBuff[sizeof(ts.Title)];
2586     static unsigned int ColorNumber, StrLen;
2587     COLORREF color;
2588    
2589     switch (XsParseMode) {
2590     case ModeXsFirst:
2591     if (isdigit(b)) {
2592     if (Param[1] < 1000) {
2593     Param[1] = Param[1]*10 + b - '0';
2594     }
2595     }
2596     else if (b == ';') {
2597     StrBuff[0] = '\0';
2598     StrLen = 0;
2599     if (Param[1] == 4) {
2600     ColorNumber = 0;
2601     XsParseMode = ModeXsColorNum;
2602     }
2603     else {
2604     XsParseMode = ModeXsString;
2605     }
2606     }
2607     else {
2608     ParseMode = ModeFirst;
2609     }
2610     break;
2611     case ModeXsString:
2612     if ((b==ST && ts.KanjiCode!=IdSJIS) || b==BEL) { /* String Terminator */
2613     StrBuff[StrLen] = '\0';
2614     switch (Param[1]) {
2615     case 0: /* Change window title and icon name */
2616     case 1: /* Change icon name */
2617     case 2: /* Change window title */
2618     if (ts.AcceptTitleChangeRequest) {
2619     strncpy_s(cv.TitleRemote, sizeof(cv.TitleRemote), StrBuff, _TRUNCATE);
2620     // (2006.6.15 maya) �^�C�g�����n����������SJIS������
2621     ConvertToCP932(cv.TitleRemote, sizeof(cv.TitleRemote));
2622     ChangeTitle();
2623     }
2624     break;
2625