Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/trunk/teraterm/teraterm/vtterm.c

Contents of /trunk/teraterm/teraterm/vtterm.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 4393 - (show annotations) (download) (as text)
Fri Mar 25 12:04:41 2011 UTC (13 years ago) by yutakapon
File MIME type: text/x-csrc
File size: 103239 byte(s) 
プリンタ制御コードが来ても無視することができるエントリを追加した。
デフォルトは下位互換性のため、オフ。

; Ignore printer control sequence(MC)
IgnorePrinterCtrl=off

ランニング試験中、ホストからプリンタ制御コードが届くと、印刷ダイアログが
表示され、Tera Termが一時停止し、試験が止まらないようにしたい。

メモ：
# echo -e '\x1b\x5b\x69'
とすれば、擬似的にテストできる。ESC [ 'i' でMC(Media Copy)を示す。
1 /* 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 #include <ctype.h>
14
15 #include "buffer.h"
16 #include "ttwinman.h"
17 #include "ttcommon.h"
18 #include "commlib.h"
19 #include "vtdisp.h"
20 #include "keyboard.h"
21 #include "ttlib.h"
22 #include "ttftypes.h"
23 #include "filesys.h"
24 #include "teraprn.h"
25 #include "telnet.h"
26 #include "ttime.h"
27
28 #include "vtterm.h"
29
30 void ParseFirst(BYTE b);
31
32 #define MAPSIZE(x) (sizeof(x)/sizeof((x)[0]))
33 #define Accept8BitCtrl ((VTlevel >= 2) && (ts.TermFlag & TF_ACCEPT8BITCTRL))
34
35 /* Parsing modes */
36 #define ModeFirst 0
37 #define ModeESC 1
38 #define ModeDCS 2
39 #define ModeDCUserKey 3
40 #define ModeSOS 4
41 #define ModeCSI 5
42 #define ModeXS 6
43 #define ModeDLE 7
44 #define ModeCAN 8
45
46 #define NParamMax 16
47 #define IntCharMax 5
48
49 /* DEC Locator Flag */
50 #define DecLocatorOneShot 1
51 #define DecLocatorPixel 2
52 #define DecLocatorButtonDown 4
53 #define DecLocatorButtonUp 8
54 #define DecLocatorFiltered 16
55
56 void VisualBell();
57 BOOL DecLocatorReport(int Event, int Button);
58
59 /* character attribute */
60 static TCharAttr CharAttr;
61
62 /* various modes of VT emulation */
63 static BOOL RelativeOrgMode;
64 static BOOL InsertMode;
65 static BOOL LFMode;
66 static BOOL AutoWrapMode;
67 static BOOL FocusReportMode;
68 static BOOL AltScr;
69 BOOL BracketedPaste;
70
71 static int VTlevel;
72
73 BOOL AcceptWheelToCursor;
74
75 // save/restore cursor
76 typedef struct {
77 int CursorX, CursorY;
78 TCharAttr Attr;
79 int Glr[2], Gn[4]; // G0-G3, GL & GR
80 BOOL AutoWrapMode;
81 BOOL RelativeOrgMode;
82 } TStatusBuff;
83 typedef TStatusBuff *PStatusBuff;
84
85 // status buffer for main screen & status line
86 static TStatusBuff SBuff1, SBuff2, SBuff3;
87
88 static BOOL ESCFlag, JustAfterESC;
89 static BOOL KanjiIn;
90 static BOOL EUCkanaIn, EUCsupIn;
91 static int EUCcount;
92 static BOOL Special;
93
94 static int Param[NParamMax+1];
95 static int NParam;
96 static BOOL FirstPrm;
97 static BYTE IntChar[IntCharMax+1];
98 static int ICount;
99 static BYTE Prv;
100 static int ParseMode;
101 static int ChangeEmu;
102
103 /* user defined keys */
104 static BOOL WaitKeyId, WaitHi;
105
106 /* GL, GR code group */
107 static int Glr[2];
108 /* G0, G1, G2, G3 code group */
109 static int Gn[4];
110 /* GL for single shift 2/3 */
111 static int GLtmp;
112 /* single shift 2/3 flag */
113 static BOOL SSflag;
114 /* JIS -> SJIS conversion flag */
115 static BOOL ConvJIS;
116 static WORD Kanji;
117
118 // variables for status line mode
119 static int StatusX=0;
120 static BOOL StatusWrap=FALSE;
121 static BOOL StatusCursor=TRUE;
122 static int MainX, MainY; //cursor registers
123 static int MainTop, MainBottom; // scroll region registers
124 static BOOL MainWrap;
125 static BOOL MainCursor=TRUE;
126
127 /* status for printer escape sequences */
128 static BOOL PrintEX = TRUE; // printing extent
129 // (TRUE: screen, FALSE: scroll region)
130 static BOOL AutoPrintMode = FALSE;
131 static BOOL PrinterMode = FALSE;
132 static BOOL DirectPrn = FALSE;
133
134 /* User key */
135 static BYTE NewKeyStr[FuncKeyStrMax];
136 static int NewKeyId, NewKeyLen;
137
138 /* Mouse Report */
139 int MouseReportMode;
140 unsigned int DecLocatorFlag;
141 int LastX, LastY;
142 int ButtonStat;
143 int FilterTop, FilterBottom, FilterLeft, FilterRight;
144
145 /* IME Status */
146 BOOL IMEstat;
147
148 static _locale_t CLocale = NULL;
149
150 void ResetSBuffer(PStatusBuff sbuff)
151 {
152 sbuff->CursorX = 0;
153 sbuff->CursorY = 0;
154 sbuff->Attr = DefCharAttr;
155 if (ts.Language==IdJapanese)
156 {
157 sbuff->Gn[0] = IdASCII;
158 sbuff->Gn[1] = IdKatakana;
159 sbuff->Gn[2] = IdKatakana;
160 sbuff->Gn[3] = IdKanji;
161 sbuff->Glr[0] = 0;
162 if ((ts.KanjiCode==IdJIS) &&
163 (ts.JIS7Katakana==0))
164 sbuff->Glr[1] = 2; // 8-bit katakana
165 else
166 sbuff->Glr[1] = 3;
167 }
168 else {
169 sbuff->Gn[0] = IdASCII;
170 sbuff->Gn[1] = IdSpecial;
171 sbuff->Gn[2] = IdASCII;
172 sbuff->Gn[3] = IdASCII;
173 sbuff->Glr[0] = 0;
174 sbuff->Glr[1] = 0;
175 }
176 sbuff->AutoWrapMode = TRUE;
177 sbuff->RelativeOrgMode = FALSE;
178 }
179
180 void ResetAllSBuffers()
181 {
182 ResetSBuffer(&SBuff1);
183 // copy SBuff1 to SBuff2
184 SBuff2 = SBuff1;
185 SBuff3 = SBuff1;
186 }
187
188 void ResetCurSBuffer()
189 {
190 PStatusBuff Buff;
191
192 if (AltScr) {
193 Buff = &SBuff3; // Alternate screen buffer
194 }
195 else {
196 Buff = &SBuff1; // Normal screen buffer
197 }
198 ResetSBuffer(Buff);
199 SBuff2 = *Buff;
200 }
201
202 void ResetTerminal() /*reset variables but don't update screen */
203 {
204 DispReset();
205 BuffReset();
206
207 /* Attribute */
208 CharAttr = DefCharAttr;
209 Special = FALSE;
210 BuffSetCurCharAttr(CharAttr);
211
212 /* Various modes */
213 InsertMode = FALSE;
214 LFMode = (ts.CRSend == IdCRLF);
215 AutoWrapMode = TRUE;
216 AppliKeyMode = FALSE;
217 AppliCursorMode = FALSE;
218 AppliEscapeMode = FALSE;
219 AcceptWheelToCursor = ts.TranslateWheelToCursor;
220 RelativeOrgMode = FALSE;
221 ts.ColorFlag &= ~CF_REVERSEVIDEO;
222 AutoRepeatMode = TRUE;
223 FocusReportMode = FALSE;
224 MouseReportMode = IdMouseTrackNone;
225 DecLocatorFlag = 0;
226
227 ChangeTerminalID();
228
229 LastX = 0;
230 LastY = 0;
231 ButtonStat = 0;
232
233 if (CLocale == NULL) {
234 CLocale = _create_locale(LC_ALL, "C");
235 }
236
237 /* Character sets */
238 ResetCharSet();
239
240 /* ESC flag for device control sequence */
241 ESCFlag = FALSE;
242 /* for TEK sequence */
243 JustAfterESC = FALSE;
244
245 /* Parse mode */
246 ParseMode = ModeFirst;
247
248 /* Clear printer mode */
249 PrinterMode = FALSE;
250
251 // status buffers
252 ResetAllSBuffers();
253
254 // Alternate Screen Buffer
255 AltScr = FALSE;
256
257 // Bracketed Paste Mode
258 BracketedPaste = FALSE;
259
260 // Saved IME Status
261 IMEstat = FALSE;
262 }
263
264 void ResetCharSet()
265 {
266 if (ts.Language==IdJapanese)
267 {
268 Gn[0] = IdASCII;
269 Gn[1] = IdKatakana;
270 Gn[2] = IdKatakana;
271 Gn[3] = IdKanji;
272 Glr[0] = 0;
273 if ((ts.KanjiCode==IdJIS) &&
274 (ts.JIS7Katakana==0))
275 Glr[1] = 2; // 8-bit katakana
276 else
277 Glr[1] = 3;
278 }
279 else {
280 Gn[0] = IdASCII;
281 Gn[1] = IdSpecial;
282 Gn[2] = IdASCII;
283 Gn[3] = IdASCII;
284 Glr[0] = 0;
285 Glr[1] = 0;
286 cv.SendCode = IdASCII;
287 cv.SendKanjiFlag = FALSE;
288 cv.EchoCode = IdASCII;
289 cv.EchoKanjiFlag = FALSE;
290 }
291 /* Kanji flag */
292 KanjiIn = FALSE;
293 EUCkanaIn = FALSE;
294 EUCsupIn = FALSE;
295 SSflag = FALSE;
296
297 cv.Language = ts.Language;
298 cv.CRSend = ts.CRSend;
299 cv.KanjiCodeEcho = ts.KanjiCode;
300 cv.JIS7KatakanaEcho = ts.JIS7Katakana;
301 cv.KanjiCodeSend = ts.KanjiCodeSend;
302 cv.JIS7KatakanaSend = ts.JIS7KatakanaSend;
303 cv.KanjiIn = ts.KanjiIn;
304 cv.KanjiOut = ts.KanjiOut;
305 }
306
307 void ResetKeypadMode(BOOL DisabledModeOnly)
308 {
309 if (!DisabledModeOnly || ts.DisableAppKeypad) AppliKeyMode = FALSE;
310 if (!DisabledModeOnly || ts.DisableAppCursor) AppliCursorMode = FALSE;
311 }
312
313 void MoveToMainScreen()
314 {
315 StatusX = CursorX;
316 StatusWrap = Wrap;
317 StatusCursor = IsCaretEnabled();
318
319 CursorTop = MainTop;
320 CursorBottom = MainBottom;
321 Wrap = MainWrap;
322 DispEnableCaret(MainCursor);
323 MoveCursor(MainX,MainY); // move to main screen
324 }
325
326 void MoveToStatusLine()
327 {
328 MainX = CursorX;
329 MainY = CursorY;
330 MainTop = CursorTop;
331 MainBottom = CursorBottom;
332 MainWrap = Wrap;
333 MainCursor = IsCaretEnabled();
334
335 DispEnableCaret(StatusCursor);
336 MoveCursor(StatusX,NumOfLines-1); // move to status line
337 CursorTop = NumOfLines-1;
338 CursorBottom = CursorTop;
339 Wrap = StatusWrap;
340 }
341
342 void HideStatusLine()
343 {
344 if ((StatusLine>0) &&
345 (CursorY==NumOfLines-1))
346 MoveToMainScreen();
347 StatusX = 0;
348 StatusWrap = FALSE;
349 StatusCursor = TRUE;
350 ShowStatusLine(0); //hide
351 }
352
353 void ChangeTerminalSize(int Nx, int Ny)
354 {
355 BuffChangeTerminalSize(Nx,Ny);
356 StatusX = 0;
357 MainX = 0;
358 MainY = 0;
359 MainTop = 0;
360 MainBottom = NumOfColumns-1;
361 }
362
363 void SendCSIstr(char *str, int len) {
364 int l;
365
366 if (str == NULL || len < 0)
367 return;
368
369 if (len == 0) {
370 l = strlen(str);
371 }
372 else {
373 l = len;
374 }
375
376 if (Send8BitMode)
377 CommBinaryOut(&cv,"\233", 1);
378 else
379 CommBinaryOut(&cv,"\033[", 2);
380
381 CommBinaryOut(&cv, str, l);
382 }
383
384 void SendOSCstr(char *str, int len) {
385 int l;
386
387 if (str == NULL || len < 0)
388 return;
389
390 if (len == 0) {
391 l = strlen(str);
392 }
393 else {
394 l = len;
395 }
396
397 if (Send8BitMode) {
398 CommBinaryOut(&cv,"\235", 1);
399 CommBinaryOut(&cv, str, l);
400 CommBinaryOut(&cv,"\234", 1);
401 }
402 else {
403 CommBinaryOut(&cv,"\033]", 2);
404 CommBinaryOut(&cv, str, l);
405 CommBinaryOut(&cv,"\033\\", 2);
406 }
407
408 }
409
410 void SendDCSstr(char *str, int len) {
411 int l;
412
413 if (str == NULL || len < 0)
414 return;
415
416 if (len == 0) {
417 l = strlen(str);
418 }
419 else {
420 l = len;
421 }
422
423 if (Send8BitMode) {
424 CommBinaryOut(&cv,"\220", 1);
425 CommBinaryOut(&cv, str, l);
426 CommBinaryOut(&cv,"\234", 1);
427 }
428 else {
429 CommBinaryOut(&cv,"\033P", 2);
430 CommBinaryOut(&cv, str, l);
431 CommBinaryOut(&cv,"\033\\", 2);
432 }
433
434 }
435
436 void BackSpace()
437 {
438 if (CursorX == 0)
439 {
440 if ((CursorY>0) &&
441 ((ts.TermFlag & TF_BACKWRAP)!=0))
442 {
443 MoveCursor(NumOfColumns-1,CursorY-1);
444 // if (cv.HLogBuf!=0) Log1Byte(BS);
445 // (2005.2.20 yutaka)
446 if (cv.HLogBuf!=0 && !ts.LogTypePlainText) Log1Byte(BS);
447 }
448 }
449 else if (CursorX > 0)
450 {
451 MoveCursor(CursorX-1,CursorY);
452 // if (cv.HLogBuf!=0) Log1Byte(BS);
453 // (2005.2.20 yutaka)
454 if (cv.HLogBuf!=0 && !ts.LogTypePlainText) Log1Byte(BS);
455 }
456 }
457
458 void CarriageReturn(BOOL logFlag)
459 {
460 #ifndef NO_COPYLINE_FIX
461 if (!ts.EnableContinuedLineCopy || logFlag)
462 #endif /* NO_COPYLINE_FIX */
463 if (cv.HLogBuf!=0) Log1Byte(CR);
464
465 if (CursorX>0)
466 MoveCursor(0,CursorY);
467 }
468
469 void LineFeed(BYTE b, BOOL logFlag)
470 {
471 /* for auto print mode */
472 if ((AutoPrintMode) &&
473 (b>=LF) && (b<=FF))
474 BuffDumpCurrentLine(b);
475
476 #ifndef NO_COPYLINE_FIX
477 if (!ts.EnableContinuedLineCopy || logFlag)
478 #endif /* NO_COPYLINE_FIX */
479 if (cv.HLogBuf!=0) Log1Byte(LF);
480
481 if (CursorY < CursorBottom)
482 MoveCursor(CursorX,CursorY+1);
483 else if (CursorY == CursorBottom) BuffScrollNLines(1);
484 else if (CursorY < NumOfLines-StatusLine-1)
485 MoveCursor(CursorX,CursorY+1);
486
487 #ifndef NO_COPYLINE_FIX
488 ClearLineContinued();
489 #endif /* NO_COPYLINE_FIX */
490
491 if (LFMode) CarriageReturn(logFlag);
492 }
493
494 void Tab()
495 {
496 if (Wrap && !ts.VTCompatTab) {
497 CarriageReturn(FALSE);
498 LineFeed(LF,FALSE);
499 #ifndef NO_COPYLINE_FIX
500 if (ts.EnableContinuedLineCopy) {
501 SetLineContinued();
502 }
503 #endif /* NO_COPYLINE_FIX */
504 Wrap = FALSE;
505 }
506 CursorForwardTab(1, AutoWrapMode);
507 if (cv.HLogBuf!=0) Log1Byte(HT);
508 }
509
510 void PutChar(BYTE b)
511 {
512 BOOL SpecialNew;
513 TCharAttr CharAttrTmp;
514
515 CharAttrTmp = CharAttr;
516
517 if (PrinterMode) { // printer mode
518 WriteToPrnFile(b,TRUE);
519 return;
520 }
521
522 if (Wrap)
523 {
524 CarriageReturn(FALSE);
525 LineFeed(LF,FALSE);
526 #ifndef NO_COPYLINE_FIX
527 CharAttrTmp.Attr |= ts.EnableContinuedLineCopy ? AttrLineContinued : 0;
528 #endif /* NO_COPYLINE_FIX */
529 }
530
531 // if (cv.HLogBuf!=0) Log1Byte(b);
532 // (2005.2.20 yutaka)
533 if (ts.LogTypePlainText) {
534 if (__isascii(b) && !isprint(b)) {
535 // ASCII�������A���\�������������O�����������B
536 } else {
537 if (cv.HLogBuf!=0) Log1Byte(b);
538 }
539 } else {
540 if (cv.HLogBuf!=0) Log1Byte(b);
541 }
542
543 Wrap = FALSE;
544
545 SpecialNew = FALSE;
546 if ((b>0x5F) && (b<0x80))
547 {
548 if (SSflag)
549 SpecialNew = (Gn[GLtmp]==IdSpecial);
550 else
551 SpecialNew = (Gn[Glr[0]]==IdSpecial);
552 }
553 else if (b>0xDF)
554 {
555 if (SSflag)
556 SpecialNew = (Gn[GLtmp]==IdSpecial);
557 else
558 SpecialNew = (Gn[Glr[1]]==IdSpecial);
559 }
560
561 if (SpecialNew != Special)
562 {
563 UpdateStr();
564 Special = SpecialNew;
565 }
566
567 if (Special)
568 {
569 b = b & 0x7F;
570 CharAttrTmp.Attr |= AttrSpecial;
571 }
572 else
573 CharAttrTmp.Attr |= CharAttr.Attr;
574
575 BuffPutChar(b, CharAttrTmp, InsertMode);
576
577 if (CursorX < NumOfColumns-1)
578 MoveRight();
579 else {
580 UpdateStr();
581 Wrap = AutoWrapMode;
582 }
583 }
584
585 void PutDecSp(BYTE b)
586 {
587 TCharAttr CharAttrTmp;
588
589 CharAttrTmp = CharAttr;
590
591 if (PrinterMode) { // printer mode
592 WriteToPrnFile(b, TRUE);
593 return;
594 }
595
596 if (Wrap) {
597 CarriageReturn(FALSE);
598 LineFeed(LF, FALSE);
599 #ifndef NO_COPYLINE_FIX
600 CharAttrTmp.Attr |= ts.EnableContinuedLineCopy ? AttrLineContinued : 0;
601 #endif /* NO_COPYLINE_FIX */
602 }
603
604 if (cv.HLogBuf!=0) Log1Byte(b);
605 /*
606 if (ts.LogTypePlainText && __isascii(b) && !isprint(b)) {
607 // ASCII�������A���\�������������O�����������B
608 } else {
609 if (cv.HLogBuf!=0) Log1Byte(b);
610 }
611 */
612
613 Wrap = FALSE;
614
615 if (!Special) {
616 UpdateStr();
617 Special = TRUE;
618 }
619
620 CharAttrTmp.Attr |= AttrSpecial;
621 BuffPutChar(b, CharAttrTmp, InsertMode);
622
623 if (CursorX < NumOfColumns-1)
624 MoveRight();
625 else {
626 UpdateStr();
627 Wrap = AutoWrapMode;
628 }
629 }
630
631 void PutKanji(BYTE b)
632 {
633 #ifndef NO_COPYLINE_FIX
634 TCharAttr CharAttrTmp;
635
636 CharAttrTmp = CharAttr;
637 #endif /* NO_COPYLINE_FIX */
638 Kanji = Kanji + b;
639
640 if (PrinterMode && DirectPrn)
641 {
642 WriteToPrnFile(HIBYTE(Kanji),FALSE);
643 WriteToPrnFile(LOBYTE(Kanji),TRUE);
644 return;
645 }
646
647 if (ConvJIS)
648 Kanji = JIS2SJIS((WORD)(Kanji & 0x7f7f));
649
650 if (PrinterMode) { // printer mode
651 WriteToPrnFile(HIBYTE(Kanji),FALSE);
652 WriteToPrnFile(LOBYTE(Kanji),TRUE);
653 return;
654 }
655
656 if (Wrap)
657 {
658 CarriageReturn(FALSE);
659 LineFeed(LF,FALSE);
660 #ifndef NO_COPYLINE_FIX
661 if (ts.EnableContinuedLineCopy)
662 CharAttrTmp.Attr |= AttrLineContinued;
663 #endif /* NO_COPYLINE_FIX */
664 }
665 else if (CursorX > NumOfColumns-2)
666 if (AutoWrapMode)
667 {
668 #ifndef NO_COPYLINE_FIX
669 if (ts.EnableContinuedLineCopy)
670 {
671 CharAttrTmp.Attr |= AttrLineContinued;
672 if (CursorX == NumOfColumns-1)
673 BuffPutChar(0x20, CharAttr, FALSE);
674 }
675 #endif /* NO_COPYLINE_FIX */
676 CarriageReturn(FALSE);
677 LineFeed(LF,FALSE);
678 }
679 else return;
680
681 Wrap = FALSE;
682
683 if (cv.HLogBuf!=0)
684 {
685 Log1Byte(HIBYTE(Kanji));
686 Log1Byte(LOBYTE(Kanji));
687 }
688
689 if (Special)
690 {
691 UpdateStr();
692 Special = FALSE;
693 }
694
695 #ifndef NO_COPYLINE_FIX
696 BuffPutKanji(Kanji, CharAttrTmp, InsertMode);
697 #else
698 BuffPutKanji(Kanji, CharAttr, InsertMode);
699 #endif /* NO_COPYLINE_FIX */
700
701 if (CursorX < NumOfColumns-2)
702 {
703 MoveRight();
704 MoveRight();
705 }
706 else {
707 UpdateStr();
708 Wrap = AutoWrapMode;
709 }
710 }
711
712 void PutDebugChar(BYTE b)
713 {
714 static BYTE buff[3];
715 int i = 0;
716
717 if (DebugFlag!=DEBUG_FLAG_NONE) {
718 InsertMode = FALSE;
719 AutoWrapMode = TRUE;
720
721 if (DebugFlag==DEBUG_FLAG_HEXD) {
722 _snprintf(buff,3,"%02X",(unsigned int) b);
723
724 for (;i<2;i++)
725 PutChar(buff[i]);
726 PutChar(' ');
727 }
728 else if (DebugFlag==DEBUG_FLAG_NORM) {
729
730 if ((b & 0x80) == 0x80)
731 {
732 UpdateStr();
733 CharAttr.Attr = AttrReverse;
734 b = b & 0x7f;
735 }
736
737 if (b<=US)
738 {
739 PutChar('^');
740 PutChar((char)(b+0x40));
741 }
742 else if (b==DEL)
743 {
744 PutChar('<');
745 PutChar('D');
746 PutChar('E');
747 PutChar('L');
748 PutChar('>');
749 }
750 else
751 PutChar(b);
752 }
753
754 if (CharAttr.Attr != AttrDefault)
755 {
756 UpdateStr();
757 CharAttr.Attr = AttrDefault;
758 }
759 }
760 }
761
762 void PrnParseControl(BYTE b) // printer mode
763 {
764 switch (b) {
765 case NUL: return;
766 case SO:
767 if (! DirectPrn)
768 {
769 if ((ts.Language==IdJapanese) &&
770 (ts.KanjiCode==IdJIS) &&
771 (ts.JIS7Katakana==1) &&
772 ((ts.TermFlag & TF_FIXEDJIS)!=0))
773 Gn[1] = IdKatakana;
774 Glr[0] = 1; /* LS1 */
775 return;
776 }
777 break;
778 case SI:
779 if (! DirectPrn)
780 {
781 Glr[0] = 0; /* LS0 */
782 return;
783 }
784 break;
785 case DC1:
786 case DC3: return;
787 case ESC:
788 ICount = 0;
789 JustAfterESC = TRUE;
790 ParseMode = ModeESC;
791 WriteToPrnFile(0,TRUE); // flush prn buff
792 return;
793 case CSI:
794 if (! Accept8BitCtrl) {
795 PutChar(b); /* Disp C1 char in VT100 mode */
796 return;
797 }
798 ICount = 0;
799 FirstPrm = TRUE;
800 NParam = 1;
801 Param[1] = -1;
802 Prv = 0;
803 ParseMode = ModeCSI;
804 WriteToPrnFile(0,TRUE); // flush prn buff
805 WriteToPrnFile(b,FALSE);
806 return;
807 }
808 /* send the uninterpreted character to printer */
809 WriteToPrnFile(b,TRUE);
810 }
811
812 void ParseControl(BYTE b)
813 {
814 if (PrinterMode) { // printer mode
815 PrnParseControl(b);
816 return;
817 }
818
819 if (b>=0x80) /* C1 char */
820 {
821 /* English mode */
822 if (ts.Language==IdEnglish)
823 {
824 if (!Accept8BitCtrl) {
825 PutChar(b); /* Disp C1 char in VT100 mode */
826 return;
827 }
828 }
829 else { /* Japanese mode */
830 if ((ts.TermFlag & TF_ACCEPT8BITCTRL)==0)
831 return; /* ignore C1 char */
832 /* C1 chars are interpreted as C0 chars in VT100 mode */
833 if (VTlevel < 2)
834 b = b & 0x7F;
835 }
836 }
837 switch (b) {
838 /* C0 group */
839 case ENQ:
840 CommBinaryOut(&cv,&(ts.Answerback[0]),ts.AnswerbackLen);
841 break;
842 case BEL:
843 switch (ts.Beep) {
844 case IdBeepOff:
845 /* nothing to do */
846 break;
847 case IdBeepOn:
848 MessageBeep(0);
849 break;
850 case IdBeepVisual:
851 VisualBell();
852 break;
853 }
854 break;
855 case BS: BackSpace(); break;
856 case HT: Tab(); break;
857
858 case LF:
859 // ���M�������s�R�[�h�� LF ���������A�T�[�o���� LF ���������������������������A
860 // CR+LF���������������������B
861 // cf. http://www.neocom.ca/forum/viewtopic.php?t=216
862 // (2007.1.21 yutaka)
863 if (ts.CRReceive == IdLF) {
864 CarriageReturn(TRUE);
865 LineFeed(b, TRUE);
866 break;
867 }
868
869 case VT: LineFeed(b,TRUE); break;
870
871 case FF:
872 if ((ts.AutoWinSwitch>0) && JustAfterESC)
873 {
874 CommInsert1Byte(&cv,b);
875 CommInsert1Byte(&cv,ESC);
876 ChangeEmu = IdTEK; /* Enter TEK Mode */
877 }
878 else
879 LineFeed(b,TRUE);
880 break;
881 case CR:
882 CarriageReturn(TRUE);
883 if (ts.CRReceive==IdCRLF)
884 CommInsert1Byte(&cv,LF);
885 break;
886 case SO:
887 if ((ts.Language==IdJapanese) &&
888 (ts.KanjiCode==IdJIS) &&
889 (ts.JIS7Katakana==1) &&
890 ((ts.TermFlag & TF_FIXEDJIS)!=0))
891 Gn[1] = IdKatakana;
892
893 Glr[0] = 1; /* LS1 */
894 break;
895 case SI: Glr[0] = 0; break; /* LS0 */
896 case DLE:
897 if ((ts.FTFlag & FT_BPAUTO)!=0)
898 ParseMode = ModeDLE; /* Auto B-Plus activation */
899 break;
900 case CAN:
901 if ((ts.FTFlag & FT_ZAUTO)!=0)
902 ParseMode = ModeCAN; /* Auto ZMODEM activation */
903 // else if (ts.AutoWinSwitch>0)
904 // ChangeEmu = IdTEK; /* Enter TEK Mode */
905 else
906 ParseMode = ModeFirst;
907 break;
908 case SUB: ParseMode = ModeFirst; break;
909 case ESC:
910 ICount = 0;
911 JustAfterESC = TRUE;
912 ParseMode = ModeESC;
913 break;
914 case FS:
915 case GS:
916 case RS:
917 case US:
918 if (ts.AutoWinSwitch>0)
919 {
920 CommInsert1Byte(&cv,b);
921 ChangeEmu = IdTEK; /* Enter TEK Mode */
922 }
923 break;
924
925 /* C1 char */
926 case IND: LineFeed(0,TRUE); break;
927 case NEL:
928 LineFeed(0,TRUE);
929 CarriageReturn(TRUE);
930 break;
931 case HTS: SetTabStop(); break;
932 case RI: CursorUpWithScroll(); break;
933 case SS2:
934 GLtmp = 2;
935 SSflag = TRUE;
936 break;
937 case SS3:
938 GLtmp = 3;
939 SSflag = TRUE;
940 break;
941 case DCS:
942 ESCFlag = FALSE;
943 ICount = 0;
944 NParam = 1;
945 Param[1] = -1;
946 Prv = 0;
947 ParseMode = ModeDCS;
948 break;
949 case SOS:
950 ESCFlag = FALSE;
951 ParseMode = ModeSOS;
952 break;
953 case CSI:
954 ICount = 0;
955 FirstPrm = TRUE;
956 NParam = 1;
957 Param[1] = -1;
958 Prv = 0;
959 ParseMode = ModeCSI;
960 break;
961 case OSC:
962 Param[1] = 0;
963 ParseMode = ModeXS;
964 break;
965 case PM:
966 case APC:
967 ESCFlag = FALSE;
968 ParseMode = ModeSOS;
969 break;
970 }
971 }
972
973 void SaveCursor()
974 {
975 int i;
976 PStatusBuff Buff;
977
978 if ((StatusLine>0) &&
979 (CursorY==NumOfLines-1))
980 Buff = &SBuff2; // for status line
981 else if (AltScr)
982 Buff = &SBuff3; // for alternate screen
983 else
984 Buff = &SBuff1; // for main screen
985
986 Buff->CursorX = CursorX;
987 Buff->CursorY = CursorY;
988 Buff->Attr = CharAttr;
989 Buff->Glr[0] = Glr[0];
990 Buff->Glr[1] = Glr[1];
991 for (i=0 ; i<=3; i++)
992 Buff->Gn[i] = Gn[i];
993 Buff->AutoWrapMode = AutoWrapMode;
994 Buff->RelativeOrgMode = RelativeOrgMode;
995 }
996
997 void RestoreCursor()
998 {
999 int i;
1000 PStatusBuff Buff;
1001 UpdateStr();
1002
1003 if ((StatusLine>0) &&
1004 (CursorY==NumOfLines-1))
1005 Buff = &SBuff2; // for status line
1006 else if (AltScr)
1007 Buff = &SBuff3; // for alternate screen
1008 else
1009 Buff = &SBuff1; // for main screen
1010
1011 if (Buff->CursorX > NumOfColumns-1)
1012 Buff->CursorX = NumOfColumns-1;
1013 if (Buff->CursorY > NumOfLines-1-StatusLine)
1014 Buff->CursorY = NumOfLines-1-StatusLine;
1015 MoveCursor(Buff->CursorX,Buff->CursorY);
1016 CharAttr = Buff->Attr;
1017 Glr[0] = Buff->Glr[0];
1018 Glr[1] = Buff->Glr[1];
1019 for (i=0 ; i<=3; i++)
1020 Gn[i] = Buff->Gn[i];
1021 AutoWrapMode = Buff->AutoWrapMode;
1022 RelativeOrgMode = Buff->RelativeOrgMode;
1023 }
1024
1025 void AnswerTerminalType()
1026 {
1027 char Tmp[50];
1028
1029 if (ts.TerminalID<IdVT320)
1030 strncpy_s(Tmp, sizeof(Tmp),"\033[?", _TRUNCATE);
1031 else
1032 strncpy_s(Tmp, sizeof(Tmp),"\233?", _TRUNCATE);
1033
1034 switch (ts.TerminalID) {
1035 case IdVT100:
1036 strncat_s(Tmp,sizeof(Tmp),"1;2",_TRUNCATE);
1037 break;
1038 case IdVT100J:
1039 strncat_s(Tmp,sizeof(Tmp),"5;2",_TRUNCATE);
1040 break;
1041 case IdVT101:
1042 strncat_s(Tmp,sizeof(Tmp),"1;0",_TRUNCATE);
1043 break;
1044 case IdVT102:
1045 strncat_s(Tmp,sizeof(Tmp),"6",_TRUNCATE);
1046 break;
1047 case IdVT102J:
1048 strncat_s(Tmp,sizeof(Tmp),"15",_TRUNCATE);
1049 break;
1050 case IdVT220J:
1051 strncat_s(Tmp,sizeof(Tmp),"62;1;2;5;6;7;8",_TRUNCATE);
1052 break;
1053 case IdVT282:
1054 strncat_s(Tmp,sizeof(Tmp),"62;1;2;4;5;6;7;8;10;11",_TRUNCATE);
1055 break;
1056 case IdVT320:
1057 strncat_s(Tmp,sizeof(Tmp),"63;1;2;6;7;8",_TRUNCATE);
1058 break;
1059 case IdVT382:
1060 strncat_s(Tmp,sizeof(Tmp),"63;1;2;4;5;6;7;8;10;15",_TRUNCATE);
1061 break;
1062 case IdVT420:
1063 strncat_s(Tmp,sizeof(Tmp),"64;1;2;7;8;9;15;18;21",_TRUNCATE);
1064 break;
1065 case IdVT520:
1066 strncat_s(Tmp,sizeof(Tmp),"65;1;2;7;8;9;12;18;19;21;23;24;42;44;45;46",_TRUNCATE);
1067 break;
1068 case IdVT525:
1069 strncat_s(Tmp,sizeof(Tmp),"65;1;2;7;9;12;18;19;21;22;23;24;42;44;45;46",_TRUNCATE);
1070 break;
1071 }
1072 strncat_s(Tmp,sizeof(Tmp),"c",_TRUNCATE);
1073
1074 CommBinaryOut(&cv,Tmp,strlen(Tmp)); /* Report terminal ID */
1075 }
1076
1077 void ESCSpace(BYTE b)
1078 {
1079 switch (b) {
1080 case 'F': // S7C1T
1081 Send8BitMode = FALSE;
1082 break;
1083 case 'G': // S8C1T
1084 if (VTlevel >= 2) {
1085 Send8BitMode = TRUE;
1086 }
1087 break;
1088 }
1089 }
1090
1091 void ESCSharp(BYTE b)
1092 {
1093 switch (b) {
1094 case '8': /* Fill screen with "E" (DECALN) */
1095 BuffUpdateScroll();
1096 BuffFillWithE();
1097 CursorTop = 0;
1098 CursorBottom = NumOfLines-1-StatusLine;
1099 MoveCursor(0,0);
1100 ParseMode = ModeFirst;
1101 break;
1102 }
1103 }
1104
1105 /* select double byte code set */
1106 void ESCDBCSSelect(BYTE b)
1107 {
1108 int Dist;
1109
1110 if (ts.Language!=IdJapanese) return;
1111
1112 switch (ICount) {
1113 case 1:
1114 if ((b=='@') || (b=='B'))
1115 {
1116 Gn[0] = IdKanji; /* Kanji -> G0 */
1117 if ((ts.TermFlag & TF_AUTOINVOKE)!=0)
1118 Glr[0] = 0; /* G0->GL */
1119 }
1120 break;
1121 case 2:
1122 /* Second intermediate char must be
1123 '(' or ')' or '*' or '+'. */
1124 Dist = (IntChar[2]-'(') & 3; /* G0 - G3 */
1125 if ((b=='1') || (b=='3') ||
1126 (b=='@') || (b=='B'))
1127 {
1128 Gn[Dist] = IdKanji; /* Kanji -> G0-3 */
1129 if (((ts.TermFlag & TF_AUTOINVOKE)!=0) &&
1130 (Dist==0))
1131 Glr[0] = 0; /* G0->GL */
1132 }
1133 break;
1134 }
1135 }
1136
1137 void ESCSelectCode(BYTE b)
1138 {
1139 switch (b) {
1140 case '0':
1141 if (ts.AutoWinSwitch>0)
1142 ChangeEmu = IdTEK; /* enter TEK mode */
1143 break;
1144 }
1145 }
1146
1147 /* select single byte code set */
1148 void ESCSBCSSelect(BYTE b)
1149 {
1150 int Dist;
1151
1152 /* Intermediate char must be
1153 '(' or ')' or '*' or '+'. */
1154 Dist = (IntChar[1]-'(') & 3; /* G0 - G3 */
1155
1156 switch (b) {
1157 case '0': Gn[Dist] = IdSpecial; break;
1158 case '<': Gn[Dist] = IdASCII; break;
1159 case '>': Gn[Dist] = IdASCII; break;
1160 case 'A': Gn[Dist] = IdASCII; break;
1161 case 'B': Gn[Dist] = IdASCII; break;
1162 case 'H': Gn[Dist] = IdASCII; break;
1163 case 'I':
1164 if (ts.Language==IdJapanese)
1165 Gn[Dist] = IdKatakana;
1166 break;
1167 case 'J': Gn[Dist] = IdASCII; break;
1168 }
1169
1170 if (((ts.TermFlag & TF_AUTOINVOKE)!=0) &&
1171 (Dist==0))
1172 Glr[0] = 0; /* G0->GL */
1173 }
1174
1175 void PrnParseEscape(BYTE b) // printer mode
1176 {
1177 int i;
1178
1179 ParseMode = ModeFirst;
1180 switch (ICount) {
1181 /* no intermediate char */
1182 case 0:
1183 switch (b) {
1184 case '[': /* CSI */
1185 ICount = 0;
1186 FirstPrm = TRUE;
1187 NParam = 1;
1188 Param[1] = -1;
1189 Prv = 0;
1190 WriteToPrnFile(ESC,FALSE);
1191 WriteToPrnFile('[',FALSE);
1192 ParseMode = ModeCSI;
1193 return;
1194 } /* end of case Icount=0 */
1195 break;
1196 /* one intermediate char */
1197 case 1:
1198 switch (IntChar[1]) {
1199 case '$':
1200 if (! DirectPrn)
1201 {
1202 ESCDBCSSelect(b);
1203 return;
1204 }
1205 break;
1206 case '(':
1207 case ')':
1208 case '*':
1209 case '+':
1210 if (! DirectPrn)
1211 {
1212 ESCSBCSSelect(b);
1213 return;
1214 }
1215 break;
1216 }
1217 break;
1218 /* two intermediate char */
1219 case 2:
1220 if ((! DirectPrn) &&
1221 (IntChar[1]=='$') &&
1222 ('('<=IntChar[2]) &&
1223 (IntChar[2]<='+'))
1224 {
1225 ESCDBCSSelect(b);
1226 return;
1227 }
1228 break;
1229 }
1230 // send the uninterpreted sequence to printer
1231 WriteToPrnFile(ESC,FALSE);
1232 for (i=1; i<=ICount; i++)
1233 WriteToPrnFile(IntChar[i],FALSE);
1234 WriteToPrnFile(b,TRUE);
1235 }
1236
1237 void ParseEscape(BYTE b) /* b is the final char */
1238 {
1239 if (PrinterMode) { // printer mode
1240 PrnParseEscape(b);
1241 return;
1242 }
1243
1244 switch (ICount) {
1245 /* no intermediate char */
1246 case 0:
1247 switch (b) {
1248 case '6': // DECBI
1249 if (CursorX == 0) {
1250 BuffScrollRight(1);
1251 }
1252 else {
1253 CursorX--;
1254 }
1255 case '7': SaveCursor(); break;
1256 case '8': RestoreCursor(); break;
1257 case '9': // DECFI
1258 if (CursorX == NumOfColumns-1) {
1259 BuffScrollLeft(1);
1260 }
1261 else {
1262 CursorX++;
1263 }
1264 case '=': AppliKeyMode = TRUE; break;
1265 case '>': AppliKeyMode = FALSE; break;
1266 case 'D': /* IND */
1267 LineFeed(0,TRUE);
1268 break;
1269 case 'E': /* NEL */
1270 MoveCursor(0,CursorY);
1271 LineFeed(0,TRUE);
1272 break;
1273 case 'H': /* HTS */
1274 SetTabStop();
1275 break;
1276 case 'M': /* RI */
1277 CursorUpWithScroll();
1278 break;
1279 case 'N': /* SS2 */
1280 GLtmp = 2;
1281 SSflag = TRUE;
1282 break;
1283 case 'O': /* SS3 */
1284 GLtmp = 3;
1285 SSflag = TRUE;
1286 break;
1287 case 'P': /* DCS */
1288 ESCFlag = FALSE;
1289 NParam = 1;
1290 Param[1] = -1;
1291 ParseMode = ModeDCS;
1292 return;
1293 case 'X': /* SOS */
1294 ESCFlag = FALSE;
1295 ParseMode = ModeSOS;
1296 return;
1297 case 'Z': AnswerTerminalType(); break;
1298 case '[': /* CSI */
1299 ICount = 0;
1300 FirstPrm = TRUE;
1301 NParam = 1;
1302 Param[1] = -1;
1303 Prv = 0;
1304 ParseMode = ModeCSI;
1305 return;
1306 case '\\': break; /* ST */
1307 case ']': /* XTERM sequence (OSC) */
1308 NParam = 1;
1309 Param[1] = 0;
1310 ParseMode = ModeXS;
1311 return;
1312 case '^':
1313 case '_': /* PM, APC */
1314 ESCFlag = FALSE;
1315 ParseMode = ModeSOS;
1316 return;
1317 case 'c': /* Hardware reset */
1318 HideStatusLine();
1319 ResetTerminal();
1320 ClearUserKey();
1321 ClearBuffer();
1322 if (ts.PortType==IdSerial) // reset serial port
1323 CommResetSerial(&ts, &cv, TRUE);
1324 break;
1325 case 'g': /* Visual Bell (screen original?) */
1326 VisualBell();
1327 break;
1328 case 'n': Glr[0] = 2; break; /* LS2 */
1329 case 'o': Glr[0] = 3; break; /* LS3 */
1330 case '|': Glr[1] = 3; break; /* LS3R */
1331 case '}': Glr[1] = 2; break; /* LS2R */
1332 case '~': Glr[1] = 1; break; /* LS1R */
1333 } /* end of case Icount=0 */
1334 break;
1335 /* one intermediate char */
1336 case 1:
1337 switch (IntChar[1]) {
1338 case ' ': ESCSpace(b); break;
1339 case '#': ESCSharp(b); break;
1340 case '$': ESCDBCSSelect(b); break;
1341 case '%': break;
1342 case '(':
1343 case ')':
1344 case '*':
1345 case '+':
1346 ESCSBCSSelect(b);
1347 break;
1348 }
1349 break;
1350 /* two intermediate char */
1351 case 2:
1352 if ((IntChar[1]=='$') &&
1353 ('('<=IntChar[2]) &&
1354 (IntChar[2]<='+'))
1355 ESCDBCSSelect(b);
1356 else if ((IntChar[1]=='%') &&
1357 (IntChar[2]=='!'))
1358 ESCSelectCode(b);
1359 break;
1360 }
1361 ParseMode = ModeFirst;
1362 }
1363
1364 void EscapeSequence(BYTE b)
1365 {
1366 if (b<=US)
1367 ParseControl(b);
1368 else if ((b>=0x20) && (b<=0x2F))
1369 {
1370 if (ICount<IntCharMax) ICount++;
1371 IntChar[ICount] = b;
1372 }
1373 else if ((b>=0x30) && (b<=0x7E))
1374 ParseEscape(b);
1375 else if ((b>=0x80) && (b<=0x9F))
1376 ParseControl(b);
1377 else if (b>=0xA0) {
1378 ParseMode=ModeFirst;
1379 ParseFirst(b);
1380 }
1381
1382 JustAfterESC = FALSE;
1383 }
1384
1385 void CSInsertCharacter()
1386 {
1387 // Insert space characters at cursor
1388 int Count;
1389
1390 BuffUpdateScroll();
1391 if (Param[1]<1) Param[1] = 1;
1392 Count = Param[1];
1393 BuffInsertSpace(Count);
1394 }
1395
1396 void CSCursorUp()
1397 {
1398 if (Param[1]<1) Param[1] = 1;
1399
1400 if (CursorY >= CursorTop)
1401 {
1402 if (CursorY-Param[1] > CursorTop)
1403 MoveCursor(CursorX,CursorY-Param[1]);
1404 else
1405 MoveCursor(CursorX,CursorTop);
1406 }
1407 else {
1408 if (CursorY > 0)
1409 MoveCursor(CursorX,CursorY-Param[1]);
1410 else
1411 MoveCursor(CursorX,0);
1412 }
1413 }
1414
1415 void CSCursorUp1()
1416 {
1417 MoveCursor(0,CursorY);
1418 CSCursorUp();
1419 }
1420
1421 void CSCursorDown()
1422 {
1423 if (Param[1]<1) Param[1] = 1;
1424
1425 if (CursorY <= CursorBottom)
1426 {
1427 if (CursorY+Param[1] < CursorBottom)
1428 MoveCursor(CursorX,CursorY+Param[1]);
1429 else
1430 MoveCursor(CursorX,CursorBottom);
1431 }
1432 else {
1433 if (CursorY < NumOfLines-StatusLine-1)
1434 MoveCursor(CursorX,CursorY+Param[1]);
1435 else
1436 MoveCursor(CursorX,NumOfLines-StatusLine);
1437 }
1438 }
1439
1440 void CSCursorDown1()
1441 {
1442 MoveCursor(0,CursorY);
1443 CSCursorDown();
1444 }
1445
1446 void CSScreenErase()
1447 {
1448 if (Param[1] == -1) Param[1] = 0;
1449 BuffUpdateScroll();
1450 switch (Param[1]) {
1451 case 0:
1452 // <ESC>[H(Cursor in left upper corner)�������J�[�\�������������w�������������A
1453 // <ESC>[J��<ESC>[2J�����������������A�����������A���s�o�b�t�@���X�N���[���A�E�g
1454 // �����������������B(2005.5.29 yutaka)
1455 // �R���t�B�O���[�V�������������������������������B(2008.5.3 yutaka)
1456 if (ts.ScrollWindowClearScreen &&
1457 (CursorX == 0 && CursorY == 0)) {
1458 // Erase screen (scroll out)
1459 BuffClearScreen();
1460 UpdateWindow(HVTWin);
1461
1462 } else {
1463 // Erase characters from cursor to the end of screen
1464 BuffEraseCurToEnd();
1465 }
1466 break;
1467
1468 case 1:
1469 // Erase characters from home to cursor
1470 BuffEraseHomeToCur();
1471 break;
1472
1473 case 2:
1474 // Erase screen (scroll out)
1475 BuffClearScreen();
1476 UpdateWindow(HVTWin);
1477 break;
1478 }
1479 }
1480
1481 void CSQSelScreenErase()
1482 {
1483 if (Param[1] == -1) Param[1] = 0;
1484 BuffUpdateScroll();
1485 switch (Param[1]) {
1486 case 0:
1487 // Erase characters from cursor to end
1488 BuffSelectedEraseCurToEnd();
1489 break;
1490
1491 case 1:
1492 // Erase characters from home to cursor
1493 BuffSelectedEraseHomeToCur();
1494 break;
1495
1496 case 2:
1497 // Erase entire screen
1498 BuffSelectedEraseScreen();
1499 break;
1500 }
1501 }
1502
1503 void CSInsertLine()
1504 {
1505 // Insert lines at current position
1506 int Count, YEnd;
1507
1508 if (CursorY < CursorTop) return;
1509 if (CursorY > CursorBottom) return;
1510 if (Param[1]<1) Param[1] = 1;
1511 Count = Param[1];
1512
1513 YEnd = CursorBottom;
1514 if (CursorY > YEnd) YEnd = NumOfLines-1-StatusLine;
1515 if (Count > YEnd+1 - CursorY) Count = YEnd+1 - CursorY;
1516
1517 BuffInsertLines(Count,YEnd);
1518 }
1519
1520 void CSLineErase()
1521 {
1522 if (Param[1] == -1) Param[1] = 0;
1523 BuffUpdateScroll();
1524 switch (Param[1]) {
1525 /* erase char from cursor to end of line */
1526 case 0:
1527 BuffEraseCharsInLine(CursorX,NumOfColumns-CursorX);
1528 break;
1529 /* erase char from start of line to cursor */
1530 case 1:
1531 BuffEraseCharsInLine(0,CursorX+1);
1532 break;
1533 /* erase entire line */
1534 case 2:
1535 BuffEraseCharsInLine(0,NumOfColumns);
1536 break;
1537 }
1538 }
1539
1540 void CSQSelLineErase()
1541 {
1542 if (Param[1] == -1) Param[1] = 0;
1543 BuffUpdateScroll();
1544 switch (Param[1]) {
1545 /* erase char from cursor to end of line */
1546 case 0:
1547 BuffSelectedEraseCharsInLine(CursorX,NumOfColumns-CursorX);
1548 break;
1549 /* erase char from start of line to cursor */
1550 case 1:
1551 BuffSelectedEraseCharsInLine(0,CursorX+1);
1552 break;
1553 /* erase entire line */
1554 case 2:
1555 BuffSelectedEraseCharsInLine(0,NumOfColumns);
1556 break;
1557 }
1558 }
1559
1560 void CSDeleteNLines()
1561 // Delete lines from current line
1562 {
1563 int Count, YEnd;
1564
1565 if (CursorY < CursorTop) return;
1566 if (CursorY > CursorBottom) return;
1567 Count = Param[1];
1568 if (Count<1) Count = 1;
1569
1570 YEnd = CursorBottom;
1571 if (CursorY > YEnd) YEnd = NumOfLines-1-StatusLine;
1572 if (Count > YEnd+1-CursorY) Count = YEnd+1-CursorY;
1573 BuffDeleteLines(Count,YEnd);
1574 }
1575
1576 void CSDeleteCharacter()
1577 {
1578 // Delete characters in current line from cursor
1579
1580 if (Param[1]<1) Param[1] = 1;
1581 BuffUpdateScroll();
1582 BuffDeleteChars(Param[1]);
1583 }
1584
1585 void CSEraseCharacter()
1586 {
1587 if (Param[1]<1) Param[1] = 1;
1588 BuffUpdateScroll();
1589 BuffEraseChars(Param[1]);
1590 }
1591
1592 void CSScrollUP()
1593 {
1594 if (Param[1]<1) Param[1] = 1;
1595 BuffUpdateScroll();
1596 BuffRegionScrollUpNLines(Param[1]);
1597 }
1598
1599 void CSScrollDown()
1600 {
1601 if (Param[1]<1) Param[1] = 1;
1602 BuffUpdateScroll();
1603 BuffRegionScrollDownNLines(Param[1]);
1604 }
1605
1606 void CSForwardTab()
1607 {
1608 if (Param[1]<1) Param[1] = 1;
1609 CursorForwardTab(Param[1], AutoWrapMode);
1610 }
1611
1612 void CSBackwardTab()
1613 {
1614 if (Param[1]<1) Param[1] = 1;
1615 CursorBackwardTab(Param[1]);
1616 }
1617
1618 void CSMoveToColumnN()
1619 {
1620 if (Param[1]<1) Param[1] = 1;
1621 Param[1]--;
1622 if (Param[1] < 0) Param[1] = 0;
1623 if (Param[1] > NumOfColumns-1) Param[1] = NumOfColumns-1;
1624 MoveCursor(Param[1],CursorY);
1625 }
1626
1627 void CSCursorRight()
1628 {
1629 if (Param[1]<1) Param[1] = 1;
1630 if (CursorX + Param[1] > NumOfColumns-1)
1631 MoveCursor(NumOfColumns-1,CursorY);
1632 else
1633 MoveCursor(CursorX+Param[1],CursorY);
1634 }
1635
1636 void CSCursorLeft()
1637 {
1638 if (Param[1]<1) Param[1] = 1;
1639 if (CursorX-Param[1] < 0)
1640 MoveCursor(0,CursorY);
1641 else
1642 MoveCursor(CursorX-Param[1],CursorY);
1643 }
1644
1645 void CSMoveToLineN()
1646 {
1647 if (Param[1]<1) Param[1] = 1;
1648 if (RelativeOrgMode)
1649 {
1650 if (CursorTop+Param[1]-1 > CursorBottom)
1651 MoveCursor(CursorX,CursorBottom);
1652 else
1653 MoveCursor(CursorX,CursorTop+Param[1]-1);
1654 }
1655 else {
1656 if (Param[1] > NumOfLines-StatusLine)
1657 MoveCursor(CursorX,NumOfLines-1-StatusLine);
1658 else
1659 MoveCursor(CursorX,Param[1]-1);
1660 }
1661 }
1662
1663 void CSMoveToXY()
1664 {
1665 int NewX, NewY;
1666
1667 if (Param[1]<1) Param[1] = 1;
1668 if ((NParam < 2) || (Param[2]<1)) Param[2] = 1;
1669 NewX = Param[2] - 1;
1670 if (NewX > NumOfColumns-1) NewX = NumOfColumns-1;
1671
1672 if ((StatusLine>0) && (CursorY==NumOfLines-1))
1673 NewY = CursorY;
1674 else if (RelativeOrgMode)
1675 {
1676 NewY = CursorTop + Param[1] - 1;
1677 if (NewY > CursorBottom) NewY = CursorBottom;
1678 }
1679 else {
1680 NewY = Param[1] - 1;
1681 if (NewY > NumOfLines-1-StatusLine)
1682 NewY = NumOfLines-1-StatusLine;
1683 }
1684 MoveCursor(NewX,NewY);
1685 }
1686
1687 void CSDeleteTabStop()
1688 {
1689 if (Param[1]==-1) Param[1] = 0;
1690 ClearTabStop(Param[1]);
1691 }
1692
1693 void CS_h_Mode() // SM
1694 {
1695 switch (Param[1]) {
1696 case 2: // KAM
1697 KeybEnabled = FALSE; break;
1698 case 4: // IRM
1699 InsertMode = TRUE; break;
1700 case 12: // SRM
1701 ts.LocalEcho = 0;
1702 if (cv.Ready && cv.TelFlag && (ts.TelEcho>0))
1703 TelChangeEcho();
1704 break;
1705 case 20: // LF/NL
1706 LFMode = TRUE;
1707 ts.CRSend = IdCRLF;
1708 cv.CRSend = IdCRLF;
1709 break;
1710 case 33: // WYSTCURM
1711 if (ts.WindowFlag & WF_CURSORCHANGE) {
1712 ts.NonblinkingCursor = TRUE;
1713 ChangeCaret();
1714 }
1715 break;
1716 case 34: // WYULCURM
1717 if (ts.WindowFlag & WF_CURSORCHANGE) {
1718 ts.CursorShape = IdHCur;
1719 ChangeCaret();
1720 }
1721 break;
1722 }
1723 }
1724
1725 void CS_i_Mode() // MC
1726 {
1727 /* �v�����^�����R�[�h�����������������B
1728 * �����j���O�������A�z�X�g�����v�����^�����R�[�h���������A�����_�C�A���O��
1729 * �\�������ATera Term���������~���A�������~���������������������B
1730 * (2011.3.25 yutaka)
1731 */
1732 if (ts.IgnorePrinterCtrl)
1733 return;
1734
1735
1736 if (Param[1]==-1) Param[1] = 0;
1737 switch (Param[1]) {
1738 /* print screen */
1739 // PrintEX -- TRUE: print screen
1740 // FALSE: scroll region
1741 case 0: BuffPrint(! PrintEX); break;
1742 /* printer controller mode off */
1743 case 4: break; /* See PrnParseCS() */
1744 /* printer controller mode on */
1745 case 5:
1746 if (! AutoPrintMode)
1747 OpenPrnFile();
1748 DirectPrn = (ts.PrnDev[0]!=0);
1749 PrinterMode = TRUE;
1750 break;
1751 }
1752 }
1753
1754 void CS_l_Mode() // RM
1755 {
1756 switch (Param[1]) {
1757 case 2: // KAM
1758 KeybEnabled = TRUE; break;
1759 case 4: // IRM
1760 InsertMode = FALSE; break;
1761 case 12: // SRM
1762 ts.LocalEcho = 1;
1763 if (cv.Ready && cv.TelFlag && (ts.TelEcho>0))
1764 TelChangeEcho();
1765 break;
1766 case 20: // LF/NL
1767 LFMode = FALSE;
1768 ts.CRSend = IdCR;
1769 cv.CRSend = IdCR;
1770 break;
1771 case 33: // WYSTCURM
1772 if (ts.WindowFlag & WF_CURSORCHANGE) {
1773 ts.NonblinkingCursor = FALSE;
1774 ChangeCaret();
1775 }
1776 break;
1777 case 34: // WYULCURM
1778 if (ts.WindowFlag & WF_CURSORCHANGE) {
1779 ts.CursorShape = IdBlkCur;
1780 ChangeCaret();
1781 }
1782 break;
1783 }
1784 }
1785
1786 void CS_n_Mode() // DSR
1787 {
1788 char Report[16];
1789 int Y, len;
1790
1791 switch (Param[1]) {
1792 case 5:
1793 /* Device Status Report -> Ready */
1794 SendCSIstr("0n", 0);
1795 break;
1796 case 6:
1797 /* Cursor Position Report */
1798 Y = CursorY+1;
1799 if ((StatusLine>0) &&
1800 (Y==NumOfLines))
1801 Y = 1;
1802 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "%u;%uR", CLocale, Y, CursorX+1);
1803 SendCSIstr(Report, len);
1804 break;
1805 }
1806 }
1807
1808 void CSSetAttr() // SGR
1809 {
1810 int i, P;
1811
1812 UpdateStr();
1813 for (i=1 ; i<=NParam ; i++)
1814 {
1815 P = Param[i];
1816 if (P<0) P = 0;
1817 switch (P) {
1818 case 0: /* Clear all */
1819 if (CharAttr.Attr2 & Attr2Protect) {
1820 CharAttr = DefCharAttr;
1821 CharAttr.Attr2 |= Attr2Protect;
1822 }
1823 else {
1824 CharAttr = DefCharAttr;
1825 }
1826 BuffSetCurCharAttr(CharAttr);
1827 break;
1828
1829 case 1: /* Bold */
1830 CharAttr.Attr |= AttrBold;
1831 BuffSetCurCharAttr(CharAttr);
1832 break;
1833
1834 case 4: /* Under line */
1835 CharAttr.Attr |= AttrUnder;
1836 BuffSetCurCharAttr(CharAttr);
1837 break;
1838
1839 case 5: /* Blink */
1840 CharAttr.Attr |= AttrBlink;
1841 BuffSetCurCharAttr(CharAttr);
1842 break;
1843
1844 case 7: /* Reverse */
1845 CharAttr.Attr |= AttrReverse;
1846 BuffSetCurCharAttr(CharAttr);
1847 break;
1848
1849 case 22: /* Bold off */
1850 CharAttr.Attr &= ~ AttrBold;
1851 BuffSetCurCharAttr(CharAttr);
1852 break;
1853
1854 case 24: /* Under line off */
1855 CharAttr.Attr &= ~ AttrUnder;
1856 BuffSetCurCharAttr(CharAttr);
1857 break;
1858
1859 case 25: /* Blink off */
1860 CharAttr.Attr &= ~ AttrBlink;
1861 BuffSetCurCharAttr(CharAttr);
1862 break;
1863
1864 case 27: /* Reverse off */
1865 CharAttr.Attr &= ~ AttrReverse;
1866 BuffSetCurCharAttr(CharAttr);
1867 break;
1868
1869 case 30:
1870 case 31:
1871 case 32:
1872 case 33:
1873 case 34:
1874 case 35:
1875 case 36:
1876 case 37: /* text color */
1877 CharAttr.Attr2 |= Attr2Fore;
1878 CharAttr.Fore = P - 30;
1879 BuffSetCurCharAttr(CharAttr);
1880 break;
1881
1882 case 38: /* text color (256color mode) */
1883 if ((ts.ColorFlag & CF_XTERM256) && i < NParam && Param[i+1] == 5) {
1884 i++;
1885 if (i < NParam) {
1886 P = Param[++i];
1887 if (P<0) {
1888 P = 0;
1889 }
1890 CharAttr.Attr2 |= Attr2Fore;
1891 CharAttr.Fore = P;
1892 BuffSetCurCharAttr(CharAttr);
1893 }
1894 }
1895 break;
1896
1897 case 39: /* Reset text color */
1898 CharAttr.Attr2 &= ~ Attr2Fore;
1899 CharAttr.Fore = AttrDefaultFG;
1900 BuffSetCurCharAttr(CharAttr);
1901 break;
1902
1903 case 40:
1904 case 41:
1905 case 42:
1906 case 43:
1907 case 44:
1908 case 45:
1909 case 46:
1910 case 47: /* Back color */
1911 CharAttr.Attr2 |= Attr2Back;
1912 CharAttr.Back = P - 40;
1913 BuffSetCurCharAttr(CharAttr);
1914 break;
1915
1916 case 48: /* Back color (256color mode) */
1917 if ((ts.ColorFlag & CF_XTERM256) && i < NParam && Param[i+1] == 5) {
1918 i++;
1919 if (i < NParam) {
1920 P = Param[++i];
1921 if (P<0) {
1922 P = 0;
1923 }
1924 CharAttr.Attr2 |= Attr2Back;
1925 CharAttr.Back = P;
1926 BuffSetCurCharAttr(CharAttr);
1927 }
1928 }
1929 break;
1930
1931 case 49: /* Reset back color */
1932 CharAttr.Attr2 &= ~ Attr2Back;
1933 CharAttr.Back = AttrDefaultBG;
1934 BuffSetCurCharAttr(CharAttr);
1935 break;
1936
1937 case 90:
1938 case 91:
1939 case 92:
1940 case 93:
1941 case 94:
1942 case 95:
1943 case 96:
1944 case 97: /* aixterm style text color */
1945 if (ts.ColorFlag & CF_AIXTERM16) {
1946 CharAttr.Attr2 |= Attr2Fore;
1947 CharAttr.Fore = P - 90 + 8;
1948 BuffSetCurCharAttr(CharAttr);
1949 }
1950 break;
1951
1952 case 100:
1953 if (! (ts.ColorFlag & CF_AIXTERM16)) {
1954 /* Reset text and back color */
1955 CharAttr.Attr2 &= ~ (Attr2Fore | Attr2Back);
1956 CharAttr.Fore = AttrDefaultFG;
1957 CharAttr.Back = AttrDefaultBG;
1958 BuffSetCurCharAttr(CharAttr);
1959 break;
1960 }
1961 /* fall through to aixterm style back color */
1962
1963 case 101:
1964 case 102:
1965 case 103:
1966 case 104:
1967 case 105:
1968 case 106:
1969 case 107: /* aixterm style back color */
1970 if (ts.ColorFlag & CF_AIXTERM16) {
1971 CharAttr.Attr2 |= Attr2Back;
1972 CharAttr.Back = P - 100 + 8;
1973 BuffSetCurCharAttr(CharAttr);
1974 }
1975 break;
1976 }
1977 }
1978 }
1979
1980 void CSSetScrollRegion()
1981 {
1982 if ((StatusLine>0) &&
1983 (CursorY==NumOfLines-1))
1984 {
1985 MoveCursor(0,CursorY);
1986 return;
1987 }
1988 if (Param[1]<1) Param[1] =1;
1989 if ((NParam < 2) | (Param[2]<1))
1990 Param[2] = NumOfLines-StatusLine;
1991 Param[1]--;
1992 Param[2]--;
1993 if (Param[1] > NumOfLines-1-StatusLine)
1994 Param[1] = NumOfLines-1-StatusLine;
1995 if (Param[2] > NumOfLines-1-StatusLine)
1996 Param[2] = NumOfLines-1-StatusLine;
1997 if (Param[1] >= Param[2]) return;
1998 CursorTop = Param[1];
1999 CursorBottom = Param[2];
2000 if (RelativeOrgMode) MoveCursor(0,CursorTop);
2001 else MoveCursor(0,0);
2002 }
2003
2004 void CSSunSequence() /* Sun terminal private sequences */
2005 {
2006 int x, y, len;
2007 char Report[TitleBuffSize*2+10];
2008
2009 switch (Param[1]) {
2010 case 1: // De-iconify window
2011 if (ts.WindowFlag & WF_WINDOWCHANGE)
2012 DispShowWindow(WINDOW_RESTORE);
2013 break;
2014 case 2: // Iconify window
2015 if (ts.WindowFlag & WF_WINDOWCHANGE)
2016 DispShowWindow(WINDOW_MINIMIZE);
2017 break;
2018 case 3: // set window position
2019 if (ts.WindowFlag & WF_WINDOWCHANGE) {
2020 if (NParam < 2) Param[2] = 0;
2021 if (NParam < 3) Param[3] = 0;
2022 DispMoveWindow(Param[2], Param[3]);
2023 }
2024 break;
2025 case 4: // set window size
2026 if (ts.WindowFlag & WF_WINDOWCHANGE) {
2027 if (NParam < 2) Param[2] = 0;
2028 if (NParam < 3) Param[3] = 0;
2029 DispResizeWin(Param[3], Param[2]);
2030 }
2031 break;
2032 case 5: // Raise window
2033 if (ts.WindowFlag & WF_WINDOWCHANGE)
2034 DispShowWindow(WINDOW_RAISE);
2035 break;
2036 case 6: // Lower window
2037 if (ts.WindowFlag & WF_WINDOWCHANGE)
2038 DispShowWindow(WINDOW_LOWER);
2039 break;
2040 case 7: // Refresh window
2041 if (ts.WindowFlag & WF_WINDOWCHANGE)
2042 DispShowWindow(WINDOW_REFRESH);
2043 break;
2044 case 8: /* set terminal size */
2045 if (ts.WindowFlag & WF_WINDOWCHANGE) {
2046 if ((Param[2]<=1) || (NParam<2)) Param[2] = 24;
2047 if ((Param[3]<=1) || (NParam<3)) Param[3] = 80;
2048 ChangeTerminalSize(Param[3],Param[2]);
2049 }
2050 break;
2051 case 9: // Maximize/Restore window
2052 if (ts.WindowFlag & WF_WINDOWCHANGE) {
2053 if (NParam < 2 || Param[2] == 0) {
2054 DispShowWindow(WINDOW_RESTORE);
2055 }
2056 else if (Param[2] == 1) {
2057 DispShowWindow(WINDOW_MAXIMIZE);
2058 }
2059 }
2060 break;
2061 case 11: // Report window state
2062 if (ts.WindowFlag & WF_WINDOWREPORT) {
2063 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "%dt", CLocale, DispWindowIconified()?2:1);
2064 SendCSIstr(Report, len);
2065 }
2066 break;
2067 case 13: // Report window position
2068 if (ts.WindowFlag & WF_WINDOWREPORT) {
2069 DispGetWindowPos(&x, &y);
2070 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "3;%d;%dt", CLocale, x, y);
2071 SendCSIstr(Report, len);
2072 }
2073 break;
2074 case 14: /* get window size */
2075 if (ts.WindowFlag & WF_WINDOWREPORT) {
2076 DispGetWindowSize(&x, &y);
2077 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "4;%d;%dt", CLocale, y, x);
2078 SendCSIstr(Report, len);
2079 }
2080 break;
2081 case 18: /* get terminal size */
2082 if (ts.WindowFlag & WF_WINDOWREPORT) {
2083 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "8;%u;%u;t", CLocale,
2084 NumOfLines-StatusLine, NumOfColumns);
2085 SendCSIstr(Report, len);
2086 }
2087 break;
2088 case 19: // Report display size (character)
2089 if (ts.WindowFlag & WF_WINDOWREPORT) {
2090 DispGetRootWinSize(&x, &y);
2091 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "9;%d;%dt", CLocale, y, x);
2092 SendCSIstr(Report, len);
2093 }
2094 break;
2095 case 20: // Report icon label
2096 switch (ts.WindowFlag & WF_TITLEREPORT) {
2097 case IdTitleReportIgnore:
2098 // nothing to do
2099 break;
2100 case IdTitleReportAccept:
2101 switch (ts.AcceptTitleChangeRequest) {
2102 case IdTitleChangeRequestOff:
2103 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s", CLocale, ts.Title);
2104 break;
2105 case IdTitleChangeRequestAhead:
2106 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s %s", CLocale, cv.TitleRemote, ts.Title);
2107 break;
2108 case IdTitleChangeRequestLast:
2109 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s %s", CLocale, ts.Title, cv.TitleRemote);
2110 break;
2111 default:
2112 if (cv.TitleRemote[0] == 0) {
2113 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s", CLocale, ts.Title);
2114 }
2115 else {
2116 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s", CLocale, cv.TitleRemote);
2117 }
2118 }
2119 SendOSCstr(Report, len);
2120 break;
2121 default: // IdTitleReportEmpty:
2122 SendOSCstr("L", 0);
2123 break;
2124 }
2125 break;
2126 case 21: // Report window title
2127 switch (ts.WindowFlag & WF_TITLEREPORT) {
2128 case IdTitleReportIgnore:
2129 // nothing to do
2130 break;
2131 case IdTitleReportAccept:
2132 switch (ts.AcceptTitleChangeRequest) {
2133 case IdTitleChangeRequestOff:
2134 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s", CLocale, ts.Title);
2135 break;
2136 case IdTitleChangeRequestAhead:
2137 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s %s", CLocale, cv.TitleRemote, ts.Title);
2138 break;
2139 case IdTitleChangeRequestLast:
2140 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s %s", CLocale, ts.Title, cv.TitleRemote);
2141 break;
2142 default:
2143 if (cv.TitleRemote[0] == 0) {
2144 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s", CLocale, ts.Title);
2145 }
2146 else {
2147 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s", CLocale, cv.TitleRemote);
2148 }
2149 }
2150 SendOSCstr(Report, len);
2151 break;
2152 default: // IdTitleReportEmpty:
2153 SendOSCstr("l", 0);
2154 break;
2155 }
2156 break;
2157 }
2158 }
2159
2160 void CSLT(BYTE b)
2161 {
2162 switch (b) {
2163 case 'r':
2164 if (CanUseIME()) {
2165 SetIMEOpenStatus(IMEstat);
2166 }
2167 break;
2168
2169 case 's':
2170 if (CanUseIME()) {
2171 IMEstat = GetIMEOpenStatus();
2172 }
2173 break;
2174
2175 case 't':
2176 if (CanUseIME()) {
2177 SetIMEOpenStatus(Param[1] == 1);
2178 }
2179 break;
2180 }
2181 }
2182
2183 void CSEQ(BYTE b)
2184 {
2185 char Report[16];
2186 int len;
2187
2188 switch (b) {
2189 case 'c': /* Tertiary terminal report (Tertiary DA) */
2190 if (Param[1] < 1) {
2191 len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "!|%8s", CLocale, ts.TerminalUID);
2192 SendDCSstr(Report, len);
2193 }
2194 break;
2195 }
2196 }
2197
2198 void CSGT(BYTE b)
2199 {
2200 switch (b) {
2201 case 'c': /* second terminal report (Secondary DA) */
2202 if (Param[1] < 1) {
2203 SendCSIstr(">32;100;2c", 0); /* VT382 */
2204 }
2205 break;
2206 case 'J': // IO-8256 terminal
2207 if (Param[1]==3) {
2208 if (Param[2] < 1 || NParam < 2) Param[2] = 1;
2209 if (Param[3] < 1 || NParam < 3) Param[3] = 1;
2210 if (Param[4] < 1 || NParam < 4) Param[4] = NumOfLines-StatusLine;
2211 if (Param[5] < 1 || NParam < 5) Param[5] = NumOfColumns;
2212 BuffEraseBox(Param[3]-1, Param[2]-1, Param[5]-1, Param[4]-1);
2213 }
2214 break;
2215 case 'K': // IO-8256 terminal
2216 switch (Param[1]) {
2217 case 3:
2218 if (Param[2] < 1 || NParam < 2) Param[2] = 1;
2219 if (Param[3] < 1 || NParam < 3) Param[3] = 1;
2220 BuffEraseCharsInLine(Param[2]-1, Param[3]-Param[2]+1);
2221 break;
2222 case 5:
2223 if (NParam < 2) Param[2] = 0;
2224 if (NParam < 3) Param[3] = 0;
2225 switch (Param[2]) {
2226 case 3:
2227 case 4:
2228 case 5:
2229 case 6: // Draw Line
2230 BuffDrawLine(CharAttr, Param[2], Param[3]);
2231 break;
2232
2233 case 12: // Text color
2234 if ((Param[3]>=0) && (Param[3]<=7)) {
2235 switch (Param[3]) {
2236 case 3: CharAttr.Fore = IdBlue; break;
2237 case 4: CharAttr.Fore = IdCyan; break;
2238 case 5: CharAttr.Fore = IdYellow; break;
2239 case 6: CharAttr.Fore = IdMagenta; break;
2240 default: CharAttr.Fore = Param[3]; break;
2241 }
2242 CharAttr.Attr2 |= Attr2Fore;
2243 BuffSetCurCharAttr(CharAttr);
2244 }
2245 break;
2246 }
2247 break;
2248 }
2249 break;
2250 }
2251 }
2252
2253 void CSQExchangeColor() // DECSCNM / Visual Bell
2254 {
2255 COLORREF ColorRef;
2256
2257 BuffUpdateScroll();
2258
2259 if (ts.ColorFlag & CF_REVERSECOLOR) {
2260 ColorRef = ts.VTColor[0];
2261 ts.VTColor[0] = ts.VTReverseColor[0];
2262 ts.VTReverseColor[0] = ColorRef;
2263 ColorRef = ts.VTColor[1];
2264 ts.VTColor[1] = ts.VTReverseColor[1];
2265 ts.VTReverseColor[1] = ColorRef;
2266 }
2267 else {
2268 ColorRef = ts.VTColor[0];
2269 ts.VTColor[0] = ts.VTColor[1];
2270 ts.VTColor[1] = ColorRef;
2271 }
2272
2273 ColorRef = ts.VTBoldColor[0];
2274 ts.VTBoldColor[0] = ts.VTBoldColor[1];
2275 ts.VTBoldColor[1] = ColorRef;
2276
2277 ColorRef = ts.VTBlinkColor[0];
2278 ts.VTBlinkColor[0] = ts.VTBlinkColor[1];
2279 ts.VTBlinkColor[1] = ColorRef;
2280
2281 ColorRef = ts.URLColor[0];
2282 ts.URLColor[0] = ts.URLColor[1];
2283 ts.URLColor[1] = ColorRef;
2284
2285 ts.ColorFlag ^= CF_REVERSEVIDEO;
2286
2287 #ifdef ALPHABLEND_TYPE2
2288 BGExchangeColor();
2289 #endif
2290 DispChangeBackground();
2291 UpdateWindow(HVTWin);
2292 }
2293
2294 void CSQChangeColumnMode(int width) // DECCOLM
2295 {
2296 ChangeTerminalSize(width, NumOfLines-StatusLine);
2297 if ((ts.TermFlag & TF_CLEARONRESIZE) == 0) {
2298 MoveCursor(0, 0);
2299 BuffClearScreen();
2300 UpdateWindow(HVTWin);
2301 }
2302 }
2303
2304 void CSQ_h_Mode() // DECSET
2305 {
2306 int i;
2307
2308 for (i = 1 ; i<=NParam ; i++)
2309 switch (Param[i]) {
2310 case 1: AppliCursorMode = TRUE; break; // DECCKM
2311 case 3: CSQChangeColumnMode(132); break; // DECCOLM
2312 case 5: /* Reverse Video (DECSCNM) */
2313 if (!(ts.ColorFlag & CF_REVERSEVIDEO))
2314 CSQExchangeColor(); /* Exchange text/back color */
2315 break;
2316 case 6: // DECOM
2317 if ((StatusLine>0) && (CursorY==NumOfLines-1))
2318 MoveCursor(0,CursorY);
2319 else {
2320 RelativeOrgMode = TRUE;
2321 MoveCursor(0,CursorTop);
2322 }
2323 break;
2324 case 7: AutoWrapMode = TRUE; break; // DECAWM
2325 case 8: AutoRepeatMode = TRUE; break; // DECARM
2326 case 9: /* X10 Mouse Tracking */
2327 if (ts.MouseEventTracking)
2328 MouseReportMode = IdMouseTrackX10;
2329 break;
2330 case 12: /* att610 cursor blinking */
2331 if (ts.WindowFlag & WF_CURSORCHANGE) {
2332 ts.NonblinkingCursor = FALSE;
2333 ChangeCaret();
2334 }
2335 break;
2336 case 19: PrintEX = TRUE; break; // DECPEX
2337 case 25: DispEnableCaret(TRUE); break; // cursor on (DECTCEM)
2338 case 38: // DECTEK
2339 if (ts.AutoWinSwitch>0)
2340 ChangeEmu = IdTEK; /* Enter TEK Mode */
2341 break;
2342 case 47: // Alternate Screen Buffer
2343 if ((ts.TermFlag & TF_ALTSCR) && !AltScr) {
2344 BuffSaveScreen();
2345 AltScr = TRUE;
2346 }
2347 break;
2348 case 59:
2349 if (ts.Language==IdJapanese)
2350 { /* kanji terminal */
2351 Gn[0] = IdASCII;
2352 Gn[1] = IdKatakana;
2353 Gn[2] = IdKatakana;
2354 Gn[3] = IdKanji;
2355 Glr[0] = 0;
2356 if ((ts.KanjiCode==IdJIS) &&
2357 (ts.JIS7Katakana==0))
2358 Glr[1] = 2; // 8-bit katakana
2359 else
2360 Glr[1] = 3;
2361 }
2362 break;
2363 case 66: AppliKeyMode = TRUE; break; // DECNKM
2364 case 67: ts.BSKey = IdBS; break; // DECBKM
2365 case 1000: // Mouse Tracking
2366 if (ts.MouseEventTracking)
2367 MouseReportMode = IdMouseTrackVT200;
2368 break;
2369 case 1001: // Hilite Mouse Tracking
2370 if (ts.MouseEventTracking)
2371 MouseReportMode = IdMouseTrackVT200Hl;
2372 break;
2373 case 1002: // Button-Event Mouse Tracking
2374 if (ts.MouseEventTracking)
2375 MouseReportMode = IdMouseTrackBtnEvent;
2376 break;
2377 case 1003: // Any-Event Mouse Tracking
2378 if (ts.MouseEventTracking)
2379 MouseReportMode = IdMouseTrackAllEvent;
2380 break;
2381 case 1004: // Focus Report
2382 if (ts.MouseEventTracking)
2383 FocusReportMode = TRUE;
2384 break;
2385 case 1047: // Alternate Screen Buffer
2386 if ((ts.TermFlag & TF_ALTSCR) && !AltScr) {
2387 BuffSaveScreen();
2388 AltScr = TRUE;
2389 }
2390 break;
2391 case 1048: // Save Cursor Position (Alternate Screen Buffer)
2392 if (ts.TermFlag & TF_ALTSCR) {
2393 SaveCursor();
2394 }
2395 break;
2396 case 1049: // Alternate Screen Buffer
2397 if ((ts.TermFlag & TF_ALTSCR) && !AltScr) {
2398 SaveCursor();
2399 BuffSaveScreen();
2400 BuffClearScreen();
2401 AltScr = TRUE;
2402 }
2403 break;
2404 case 2004: // Bracketed Paste Mode
2405 BracketedPaste = TRUE;
2406 break;
2407 case 7727: // mintty Application Escape Mode
2408 AppliEscapeMode = TRUE;
2409 break;
2410 case 7786: // Wheel to Cursor translation
2411 if (ts.TranslateWheelToCursor) {
2412 AcceptWheelToCursor = TRUE;
2413 }
2414 break;
2415 }
2416 }
2417
2418 void CSQ_i_Mode() // DECMC
2419 {
2420 if (Param[1]==-1) Param[1] = 0;
2421 switch (Param[1]) {
2422 case 1:
2423 OpenPrnFile();
2424 BuffDumpCurrentLine(LF);
2425 if (! AutoPrintMode)
2426 ClosePrnFile();
2427 break;
2428 /* auto print mode off */
2429 case 4:
2430 if (AutoPrintMode)
2431 {
2432 ClosePrnFile();
2433 AutoPrintMode = FALSE;
2434 }
2435 break;
2436 /* auto print mode on */
2437 case 5:
2438 if (! AutoPrintMode)
2439 {
2440 OpenPrnFile();
2441 AutoPrintMode = TRUE;
2442 }
2443 break;
2444 }
2445 }
2446
2447 void CSQ_l_Mode() // DECRST
2448 {
2449 int i;
2450
2451 for (i = 1 ; i <= NParam ; i++)
2452 switch (Param[i]) {
2453 case 1: AppliCursorMode = FALSE; break; // DECCKM
2454 case 3: CSQChangeColumnMode(80); break; // DECCOLM
2455 case 5: /* Normal Video (DECSCNM) */
2456 if (ts.ColorFlag & CF_REVERSEVIDEO)
2457 CSQExchangeColor(); /* Exchange text/back color */
2458 break;
2459 case 6: // DECOM
2460 if ((StatusLine>0) && (CursorY==NumOfLines-1))
2461 MoveCursor(0,CursorY);
2462 else {
2463 RelativeOrgMode = FALSE;
2464 MoveCursor(0,0);
2465 }
2466 break;
2467 case 7: AutoWrapMode = FALSE; break; // DECAWM
2468 case 8: AutoRepeatMode = FALSE; break; // DECARM
2469 case 9: MouseReportMode = IdMouseTrackNone; break; /* X10 Mouse Tracking */
2470 case 12: /* att610 cursor blinking */
2471 if (ts.WindowFlag & WF_CURSORCHANGE) {
2472 ts.NonblinkingCursor = TRUE;
2473 ChangeCaret();
2474 }
2475 break;
2476 case 19: PrintEX = FALSE; break; // DECPEX
2477 case 25: DispEnableCaret(FALSE); break; // cursor off (DECTCEM)
2478 case 47: // Alternate Screen Buffer
2479 if ((ts.TermFlag & TF_ALTSCR) && AltScr) {
2480 BuffRestoreScreen();
2481 AltScr = FALSE;
2482 }
2483 break;
2484 case 59:
2485 if (ts.Language==IdJapanese)
2486 { /* katakana terminal */
2487 Gn[0] = IdASCII;
2488 Gn[1] = IdKatakana;
2489 Gn[2] = IdKatakana;
2490 Gn[3] = IdKanji;
2491 Glr[0] = 0;
2492 if ((ts.KanjiCode==IdJIS) &&
2493 (ts.JIS7Katakana==0))
2494 Glr[1] = 2; // 8-bit katakana
2495 else
2496 Glr[1] = 3;
2497 }
2498 break;
2499 case 66: AppliKeyMode = FALSE; break; // DECNKM
2500 case 67: ts.BSKey = IdDEL; break; // DECBKM
2501 case 1000: // Mouse Tracking
2502 case 1001: // Hilite Mouse Tracking
2503 case 1002: // Button-Event Mouse Tracking
2504 case 1003: // Any-Event Mouse Tracking
2505 MouseReportMode = IdMouseTrackNone;
2506 break;
2507 case 1004: FocusReportMode = FALSE; break; // Focus Report
2508 case 1047: // Alternate Screen Buffer
2509 if ((ts.TermFlag & TF_ALTSCR) && AltScr) {
2510 BuffClearScreen();
2511 BuffRestoreScreen();
2512 AltScr = FALSE;
2513 }
2514 break;
2515 case 1048: // Save Cursor Position (Alternate Screen Buffer)
2516 if (ts.TermFlag & TF_ALTSCR) {
2517 RestoreCursor();
2518 }
2519 break;
2520 case 1049: // Alternate Screen Buffer
2521 if ((ts.TermFlag & TF_ALTSCR) && AltScr) {
2522 BuffClearScreen();
2523 BuffRestoreScreen();
2524 AltScr = FALSE;
2525 RestoreCursor();
2526 }
2527 break;
2528 case 2004: // Bracketed Paste Mode
2529 BracketedPaste = FALSE;
2530 break;
2531 case 7727: // mintty Application Escape Mode
2532 AppliEscapeMode = FALSE;
2533 break;
2534 case 7786: // Wheel to Cursor translation
2535 AcceptWheelToCursor = FALSE;
2536 break;
2537 }
2538 }
2539
2540 void CSQ_n_Mode() // DECDSR
2541 {
2542 switch (Param[1]) {
2543 case 53:
2544 case 55:
2545 /* Locator Device Status Report -> Ready */
2546 SendCSIstr("?50n", 0);
2547 break;
2548 }
2549 }
2550
2551 void CSQuest(BYTE b)
2552 {
2553 switch (b) {
2554 case 'J': CSQSelScreenErase(); break; // DECSED
2555 case 'K': CSQSelLineErase(); break; // DECSEL
2556 case 'h': CSQ_h_Mode(); break; // DECSET
2557 case 'i': CSQ_i_Mode(); break; // DECMC
2558 case 'l': CSQ_l_Mode(); break; // DECRST
2559 case 'n': CSQ_n_Mode(); break; // DECDSR
2560 }
2561 }
2562
2563 void SoftReset()
2564 // called by software-reset escape sequence handler
2565 {
2566 UpdateStr();
2567 AutoRepeatMode = TRUE;
2568 DispEnableCaret(TRUE); // cursor on
2569 InsertMode = FALSE;
2570 RelativeOrgMode = FALSE;
2571 AppliKeyMode = FALSE;
2572 AppliCursorMode = FALSE;
2573 AppliEscapeMode = FALSE;
2574 AcceptWheelToCursor = ts.TranslateWheelToCursor;
2575 if ((StatusLine>0) &&
2576 (CursorY == NumOfLines-1))
2577 MoveToMainScreen();
2578 CursorTop = 0;
2579 CursorBottom = NumOfLines-1-StatusLine;
2580 ResetCharSet();
2581
2582 /* Attribute */
2583 CharAttr = DefCharAttr;
2584 Special = FALSE;
2585 BuffSetCurCharAttr(CharAttr);
2586
2587 // status buffers
2588 ResetCurSBuffer();
2589
2590 // Saved IME status
2591 IMEstat = FALSE;
2592 }
2593
2594 void CSExc(BYTE b)
2595 {
2596 switch (b) {
2597 case 'p':
2598 /* Software reset */
2599 SoftReset();
2600 break;
2601 }
2602 }
2603
2604 void CSDouble(BYTE b)
2605 {
2606 switch (b) {
2607 case 'p': // DECSCL
2608 /* Select terminal mode (software reset) */
2609 SoftReset();
2610 if (NParam > 0) {
2611 ChangeTerminalID();
2612 if (Param[1] >= 61 && Param[1] <= 65) {
2613 if (VTlevel > Param[1] - 60) {
2614 VTlevel = Param[1] - 60;
2615 }
2616 }
2617 else {
2618 VTlevel = 1;
2619 }
2620
2621 if (VTlevel < 2 || (NParam > 1 && Param[2] == 1))
2622 Send8BitMode = FALSE;
2623 else
2624 Send8BitMode = TRUE;
2625 }
2626 break;
2627
2628 case 'q': // DECSCA
2629 if (Param[1] < 0)
2630 Param[1] = 0;
2631 switch (Param[1]) {
2632 case 0:
2633 case 2:
2634 CharAttr.Attr2 &= ~Attr2Protect;
2635 BuffSetCurCharAttr(CharAttr);
2636 break;
2637 case 1:
2638 CharAttr.Attr2 |= Attr2Protect;
2639 BuffSetCurCharAttr(CharAttr);
2640 break;
2641 default:
2642 /* nothing to do */
2643 break;
2644 }
2645 break;
2646 }
2647 }
2648
2649 void CSDol(BYTE b)
2650 {
2651 switch (b) {
2652 case 'z': // DECERA
2653 case '{': // DECSERA
2654 if (Param[1] < 1 || NParam < 1) Param[1]=1;
2655 if (Param[2] < 1 || NParam < 2) Param[2]=1;
2656 if (Param[3] < 1 || NParam < 3) Param[3]=NumOfLines-StatusLine;
2657 if (Param[4] < 1 || NParam < 4) Param[4]=NumOfColumns;
2658 if (RelativeOrgMode) {
2659 Param[1] += CursorTop;
2660 if (Param[1] > CursorBottom) {
2661 Param[1] = CursorBottom + 1;
2662 }
2663 Param[3] += CursorTop;
2664 if (Param[3] > CursorBottom) {
2665 Param[3] = CursorBottom + 1;
2666 }
2667 }
2668 if (b == 'z') {
2669 BuffEraseBox(Param[2]-1, Param[1]-1, Param[4]-1, Param[3]-1);
2670 }
2671 else {
2672 BuffSelectEraseBox(Param[2]-1, Param[1]-1, Param[4]-1, Param[3]-1);
2673 }
2674 break;
2675
2676 case '}': // DECSASD
2677 if ((ts.TermFlag & TF_ENABLESLINE)==0) return;
2678 if (StatusLine==0) return;
2679 if ((Param[1]<1) && (CursorY==NumOfLines-1))
2680 MoveToMainScreen();
2681 else if ((Param[1]==1) && (CursorY<NumOfLines-1))
2682 MoveToStatusLine();
2683 break;
2684 case '~': // DECSSDT
2685 if ((ts.TermFlag & TF_ENABLESLINE)==0) return;
2686 if (Param[1]<=1)
2687 HideStatusLine();
2688 else if ((StatusLine==0) && (Param[1]==2))
2689 ShowStatusLine(1); // show
2690 break;
2691 }
2692 }
2693
2694 void CSQuote(BYTE b)
2695 {
2696 int i, x, y;
2697 switch (b) {
2698 case 'w': // Enable Filter Rectangle (DECEFR)
2699 if (MouseReportMode == IdMouseTrackDECELR) {
2700 if (DecLocatorFlag & DecLocatorPixel) {
2701 x = LastX + 1;
2702 y = LastY + 1;
2703 }
2704 else {
2705 DispConvWinToScreen(LastX, LastY, &x, &y, NULL);
2706 x++;
2707 y++;
2708 }
2709 FilterTop = (NParam<1 || Param[1]<1)? y : Param[1];
2710 FilterLeft = (NParam<2 || Param[2]<1)? x : Param[2];
2711 FilterBottom = (NParam<3 || Param[3]<1)? y : Param[3];
2712 FilterRight = (NParam<4 || Param[4]<1)? x : Param[4];
2713 if (FilterTop > FilterBottom) {
2714 i = FilterTop; FilterTop = FilterBottom; FilterBottom = i;
2715 }
2716 if (FilterLeft > FilterRight) {
2717 i = FilterLeft; FilterLeft = FilterRight; FilterRight = i;
2718 }
2719 DecLocatorFlag |= DecLocatorFiltered;
2720 DecLocatorReport(IdMouseEventMove, 0);
2721 }
2722 break;
2723
2724 case 'z': // Enable DEC Locator reporting (DECELR)
2725 if (Param[1] < 0) {
2726 Param[1] = 0;
2727 }
2728 switch (Param[1]) {
2729 case 0:
2730 if (MouseReportMode == IdMouseTrackDECELR) {
2731 MouseReportMode = IdMouseTrackNone;
2732 }
2733 break;
2734 case 1:
2735 if (ts.MouseEventTracking) {
2736 MouseReportMode = IdMouseTrackDECELR;
2737 DecLocatorFlag &= ~DecLocatorOneShot;
2738 }
2739 break;
2740 case 2:
2741 if (ts.MouseEventTracking) {
2742 MouseReportMode = IdMouseTrackDECELR;
2743 DecLocatorFlag |= DecLocatorOneShot;
2744 }
2745 break;
2746 }
2747 if (NParam > 1 && Param[2] == 1) {
2748 DecLocatorFlag |= DecLocatorPixel;
2749 }
2750 else {
2751 DecLocatorFlag &= ~DecLocatorPixel;
2752 }
2753 break;
2754
2755 case '{': // Select Locator Events (DECSLE)
2756 for (i=1; i<=NParam; i++) {
2757 if (Param[i] < 0) {
2758 Param[i] = 0;
2759 }
2760 switch (Param[i]) {
2761 case 0:
2762 DecLocatorFlag &= ~(DecLocatorButtonUp | DecLocatorButtonDown | DecLocatorFiltered);
2763 break;
2764 case 1:
2765 DecLocatorFlag |= DecLocatorButtonDown;
2766 break;
2767 case 2:
2768 DecLocatorFlag &= ~DecLocatorButtonDown;
2769 break;
2770 case 3:
2771 DecLocatorFlag |= DecLocatorButtonUp;
2772 break;
2773 case 4:
2774 DecLocatorFlag &= ~DecLocatorButtonUp;
2775 break;
2776 }
2777 }
2778 break;
2779
2780 case '|': // Request Locator Position (DECRQLP)
2781 DecLocatorReport(IdMouseEventCurStat, 0);
2782 break;
2783 }
2784 }
2785
2786 void CSSpace(BYTE b) {
2787 switch (b) {
2788 case 'q':
2789 if (ts.WindowFlag & WF_CURSORCHANGE) {
2790 if (NParam > 0) {
2791 if (Param[1] < 0) Param[1] = 0;
2792 switch (Param[1]) {
2793 case 0:
2794 case 1:
2795 ts.CursorShape = IdBlkCur;
2796 ts.NonblinkingCursor = FALSE;
2797 break;
2798 case 2:
2799 ts.CursorShape = IdBlkCur;
2800 ts.NonblinkingCursor = TRUE;
2801 break;
2802 case 3:
2803 ts.CursorShape = IdHCur;
2804 ts.NonblinkingCursor = FALSE;
2805 break;
2806 case 4:
2807 ts.CursorShape = IdHCur;
2808 ts.NonblinkingCursor = TRUE;
2809 break;
2810 case 5:
2811 ts.CursorShape = IdVCur;
2812 ts.NonblinkingCursor = FALSE;
2813 break;
2814 case 6:
2815 ts.CursorShape = IdVCur;
2816 ts.NonblinkingCursor = TRUE;
2817 break;
2818 default:
2819 return;
2820 }
2821 ChangeCaret();
2822 }
2823 }
2824 break;
2825 }
2826 }
2827
2828 void PrnParseCS(BYTE b) // printer mode
2829 {
2830 ParseMode = ModeFirst;
2831 switch (ICount) {
2832 /* no intermediate char */
2833 case 0:
2834 switch (Prv) {
2835 /* no private parameter */
2836 case 0:
2837 switch (b) {
2838 case 'i':
2839 if (Param[1]==4)
2840 {
2841 PrinterMode = FALSE;
2842 // clear prn buff
2843 WriteToPrnFile(0,FALSE);
2844 if (! AutoPrintMode)
2845 ClosePrnFile();
2846 return;
2847 }
2848 break;
2849 } /* of case Prv=0 */
2850 break;
2851 }
2852 break;
2853 /* one intermediate char */
2854 case 1: break;
2855 } /* of case Icount */
2856
2857 WriteToPrnFile(b,TRUE);
2858 }
2859
2860 void ParseCS(BYTE b) /* b is the final char */
2861 {
2862 if (PrinterMode) { // printer mode
2863 PrnParseCS(b);
2864 return;
2865 }
2866
2867 switch (ICount) {
2868 /* no intermediate char */
2869 case 0:
2870 switch (Prv) {
2871 /* no private parameter */
2872 case 0:
2873 switch (b) {
2874 // ISO/IEC 6429 / ECMA-48 Sequence
2875 case '@': CSInsertCharacter(); break; // ICH
2876 case 'A': CSCursorUp(); break; // CUU
2877 case 'B': CSCursorDown(); break; // CUD
2878 case 'C': CSCursorRight(); break; // CUF
2879 case 'D': CSCursorLeft(); break; // CUB
2880 case 'E': CSCursorDown1(); break; // CNL
2881 case 'F': CSCursorUp1(); break; // CPL
2882 case 'G': CSMoveToColumnN(); break; // CHA
2883 case 'H': CSMoveToXY(); break; // CUP
2884 case 'I': CSForwardTab(); break; // CHT
2885 case 'J': CSScreenErase(); break; // ED
2886 case 'K': CSLineErase(); break; // EL
2887 case 'L': CSInsertLine(); break; // IL
2888 case 'M': CSDeleteNLines(); break; // DL
2889 // case 'N': break; // EF -- Not support
2890 // case 'O': break; // EA -- Not support
2891 case 'P': CSDeleteCharacter(); break; // DCH
2892 // case 'Q': break; // SEE -- Not support
2893 // case 'R': break; // CPR -- Report only, ignore.
2894 case 'S': CSScrollUP(); break; // SU
2895 case 'T': CSScrollDown(); break; // SD
2896 // case 'U': break; // NP -- Not support
2897 // case 'V': break; // PP -- Not support
2898 // case 'W': break; // CTC -- Not support
2899 case 'X': CSEraseCharacter(); break; // ECH
2900 // case 'Y': break; // CVT -- Not support
2901 case 'Z': CSBackwardTab(); break; // CBT
2902 // case '[': break; // SRS -- Not support
2903 // case '\\': break; // PTX -- Not support
2904 // case ']': break; // SDS -- Not support
2905 // case '^': break; // SIMD -- Not support
2906 case '`': CSMoveToColumnN(); break; // HPA
2907 case 'a': CSCursorRight(); break; // HPR
2908 // case 'b': break; // REP -- Not support
2909 case 'c': AnswerTerminalType(); break; // DA
2910 case 'd': CSMoveToLineN(); break; // VPA
2911 case 'e': CSCursorDown(); break; // VPR
2912 case 'f': CSMoveToXY(); break; // HVP
2913 case 'g': CSDeleteTabStop(); break; // TBC
2914 case 'h': CS_h_Mode(); break; // SM
2915 case 'i': CS_i_Mode(); break; // MC
2916 case 'j': CSCursorLeft(); break; // HPB
2917 case 'k': CSCursorUp(); // VPB
2918 case 'l': CS_l_Mode(); break; // RM
2919 case 'm': CSSetAttr(); break; // SGR
2920 case 'n': CS_n_Mode(); break; // DSR
2921 // case 'o': break; // DAQ -- Not support
2922
2923 // Private Sequence
2924 case 'r': CSSetScrollRegion(); break; // DECSTBM
2925 case 's': SaveCursor(); break; // SCP (Save cursor (ANSI.SYS/SCO?))
2926 case 't': CSSunSequence(); break; // DECSLPP / Window manipulation(dtterm?)
2927 case 'u': RestoreCursor(); break; // RCP (Restore cursor (ANSI.SYS/SCO))
2928 } /* of case Prv=0 */
2929 break;
2930 /* private parameter = '<' */
2931 case '<': CSLT(b); break;
2932 /* private parameter = '=' */
2933 case '=': CSEQ(b); break;
2934 /* private parameter = '>' */
2935 case '>': CSGT(b); break;
2936 /* private parameter = '?' */
2937 case '?': CSQuest(b); break;
2938 } /* end of siwtch (Prv) */
2939 break;
2940 /* one intermediate char */
2941 case 1:
2942 switch (IntChar[1]) {
2943 /* intermediate char = ' ' */
2944 case ' ': CSSpace(b); break;
2945 /* intermediate char = '!' */
2946 case '!': CSExc(b); break;
2947 /* intermediate char = '"' */
2948 case '"': CSDouble(b); break;
2949 /* intermediate char = '$' */
2950 case '$': CSDol(b); break;
2951 /* intermediate char = '\'' */
2952 case '\'': CSQuote(b); break;
2953 }
2954 break;
2955 } /* of case Icount */
2956
2957 ParseMode = ModeFirst;
2958 }
2959
2960 void ControlSequence(BYTE b)
2961 {
2962 if ((b<=US) || (b>=0x80) && (b<=0x9F))
2963 ParseControl(b); /* ctrl char */
2964 else if ((b>=0x40) && (b<=0x7E))
2965 ParseCS(b); /* terminate char */
2966 else {
2967 if (PrinterMode)
2968 WriteToPrnFile(b,FALSE);
2969
2970 if ((b>=0x20) && (b<=0x2F))
2971 { /* intermediate char */
2972 if (ICount<IntCharMax) ICount++;
2973 IntChar[ICount] = b;
2974 }
2975 else if ((b>=0x30) && (b<=0x39))
2976 {
2977 if (Param[NParam] < 0)
2978 Param[NParam] = 0;
2979 if (Param[NParam]<1000)
2980 Param[NParam] = Param[NParam]*10 + b - 0x30;
2981 }
2982 else if (b==0x3B)
2983 {
2984 if (NParam < NParamMax)
2985 {
2986 NParam++;
2987 Param[NParam] = -1;
2988 }
2989 }
2990 else if ((b>=0x3C) && (b<=0x3F))
2991 { /* private char */
2992 if (FirstPrm) Prv = b;
2993 }
2994 else if (b>0xA0) {
2995 ParseMode=ModeFirst;
2996 ParseFirst(b);
2997 }
2998 }
2999 FirstPrm = FALSE;
3000 }
3001
3002 void RequestStatusString(unsigned char *StrBuff, int StrLen) // DECRQSS
3003 {
3004 unsigned char RepStr[256];
3005 int len = 0;
3006
3007 switch (StrBuff[0]) {
3008 case '"':
3009 switch (StrBuff[1]) {
3010 case 'p': // DECSCL
3011 if (VTlevel > 1 && Send8BitMode) {
3012 len = _snprintf_s_l(RepStr, sizeof(RepStr), _TRUNCATE, "0$r6%d;0\"p", CLocale, VTlevel);
3013 }
3014 else {
3015 len = _snprintf_s_l(RepStr, sizeof(RepStr), _TRUNCATE, "0$r6%d;1\"p", CLocale, VTlevel);
3016 }
3017 break;
3018
3019 case 'q': // DECSCA
3020 if (CharAttr.Attr2 & Attr2Protect) {
3021 len = _snprintf_s_l(RepStr, sizeof(RepStr), _TRUNCATE, "0$r1\"q", CLocale);
3022 }
3023 else {
3024 len = _snprintf_s_l(RepStr, sizeof(RepStr), _TRUNCATE, "0$r0\"q", CLocale);
3025 }
3026 break;
3027 }
3028 break;
3029 case 'm': // SGR
3030 if (StrBuff[1] == 0) {
3031 RepStr[0] = '0';
3032 RepStr[1] = '$';
3033 RepStr[2] = 'r';
3034 len = 3;
3035 if (CharAttr.Attr & AttrBold) {
3036 RepStr[len++] = '1';
3037 RepStr[len++] = ';';
3038 }
3039 if (CharAttr.Attr & AttrUnder) {
3040 RepStr[len++] = '4';
3041 RepStr[len++] = ';';
3042 }
3043 if (CharAttr.Attr & AttrBlink) {
3044 RepStr[len++] = '5';
3045 RepStr[len++] = ';';
3046 }
3047 if (CharAttr.Attr & AttrReverse) {
3048 RepStr[len++] = '7';
3049 RepStr[len++] = ';';
3050 }
3051 if (CharAttr.Attr2 & Attr2Fore) {
3052 int color = CharAttr.Fore;
3053 if (color <= 7 && (CharAttr.Attr & AttrBold) && (ts.ColorFlag & CF_PCBOLD16)) {
3054 color += 8;
3055 }
3056
3057 if (color <= 7) {
3058 RepStr[len++] = '3';
3059 RepStr[len++] = '0' + color;
3060 RepStr[len++] = ';';
3061 }
3062 else if (color <= 15) {
3063 if (ts.ColorFlag & CF_AIXTERM16) {
3064 RepStr[len++] = '9';
3065 RepStr[len++] = '0' + color - 8;
3066 RepStr[len++] = ';';
3067 }
3068 else if (ts.ColorFlag & CF_XTERM256) {
3069 len += _snprintf_s_l(&RepStr[len], sizeof(RepStr) - len, _TRUNCATE, "38;5;%d;", CLocale, color);
3070 }
3071 else if (ts.ColorFlag & CF_PCBOLD16) {
3072 RepStr[len++] = '3';
3073 RepStr[len++] = '0' + color - 8;
3074 RepStr[len++] = ';';
3075 }
3076 }
3077 else if (ts.ColorFlag & CF_XTERM256) {
3078 len += _snprintf_s_l(&RepStr[len], sizeof(RepStr) - len, _TRUNCATE, "38;5;%d;", CLocale, color);
3079 }
3080 }
3081 if (CharAttr.Attr2 & Attr2Back) {
3082 int color = CharAttr.Back;
3083 if (color <= 7 && (CharAttr.Attr & AttrBlink) && (ts.ColorFlag & CF_PCBOLD16)) {
3084 color += 8;
3085 }
3086 if (color <= 7) {
3087 RepStr[len++] = '4';
3088 RepStr[len++] = '0' + color;
3089 RepStr[len++] = ';';
3090 }
3091 else if (color <= 15) {
3092 if (ts.ColorFlag & CF_AIXTERM16) {
3093 RepStr[len++] = '1';
3094 RepStr[len++] = '0';
3095 RepStr[len++] = '0' + color - 8;
3096 RepStr[len++] = ';';
3097 }
3098 else if (ts.ColorFlag & CF_XTERM256) {
3099 len += _snprintf_s_l(&RepStr[len], sizeof(RepStr) - len, _TRUNCATE, "48;5;%d;", CLocale, color);
3100 }
3101 else if (ts.ColorFlag & CF_PCBOLD16) {
3102 RepStr[len++] = '4';
3103 RepStr[len++] = '0' + color - 8;
3104 RepStr[len++] = ';';
3105 }
3106 }
3107 else if (ts.ColorFlag & CF_XTERM256) {
3108 len += _snprintf_s_l(&RepStr[len], sizeof(RepStr) - len, _TRUNCATE, "48;5;%d;", CLocale, color);
3109 }
3110 }
3111 if (len == 3) {
3112 RepStr[len++] = '0';
3113 }
3114 else {
3115 len--;
3116 }
3117 RepStr[len++] = 'm';
3118 RepStr[len] = 0;
3119 }
3120 break;
3121 case 'r': // DECSTBM
3122 if (StrBuff[1] == 0) {
3123 len = _snprintf_s_l(RepStr, sizeof(RepStr), _TRUNCATE, "0$r%d;%dr", CLocale, CursorTop+1, CursorBottom+1);
3124 }
3125 break;
3126 }
3127 if (len > 0) {
3128 if (ts.TermFlag & TF_INVALIDDECRPSS) {
3129 RepStr[0] = '1';
3130 }
3131 SendDCSstr(RepStr, len);
3132 }
3133 else {
3134 if (ts.TermFlag & TF_INVALIDDECRPSS) {
3135 SendDCSstr("0$r", 0);
3136 }
3137 else {
3138 SendDCSstr("1$r", 0);
3139 }
3140 }
3141 }
3142
3143 void ParseDCS(BYTE Cmd, unsigned char *StrBuff, int len) {
3144 switch (ICount) {
3145 case 0:
3146 break;
3147 case 1:
3148 switch (IntChar[1]) {
3149 case '!':
3150 if (Cmd == '{') { // DECSTUI
3151 if (! (ts.TermFlag & TF_LOCKTUID)) {
3152 int i;
3153 for (i=0; i<8 && isxdigit(StrBuff[i]); i++) {
3154 if (islower(StrBuff[i])) {
3155 StrBuff[i] = toupper(StrBuff[i]);
3156 }
3157 }
3158 if (len == 8 && i == 8) {
3159 strncpy_s(ts.TerminalUID, sizeof(ts.TerminalUID), StrBuff, _TRUNCATE);
3160 }
3161 }
3162 }
3163 break;
3164 case '$':
3165 if (Cmd == 'q') { // DECRQSS
3166 RequestStatusString(StrBuff, len);
3167 }
3168 break;
3169 default:
3170 break;
3171 }
3172 break;
3173 default:
3174 break;
3175 }
3176 }
3177
3178 #define ModeDcsFirst 1
3179 #define ModeDcsString 2
3180 void DeviceControl(BYTE b)
3181 {
3182 static unsigned char StrBuff[256];
3183 static int DcsParseMode = ModeDcsFirst;
3184 static int StrLen;
3185 static BYTE Cmd;
3186
3187 if ((ESCFlag && (b=='\\')) || (b==ST && ts.KanjiCode!=IdSJIS)) {
3188 if (DcsParseMode == ModeDcsString) {
3189 StrBuff[StrLen] = 0;
3190 ParseDCS(Cmd, StrBuff, StrLen);
3191 }
3192 ESCFlag = FALSE;
3193 ParseMode = ModeFirst;
3194 DcsParseMode = ModeDcsFirst;
3195 StrLen = 0;
3196 return;
3197 }
3198
3199 if (b==ESC) {
3200 ESCFlag = TRUE;
3201 return;
3202 }
3203 else {
3204 ESCFlag = FALSE;
3205 }
3206
3207 switch (DcsParseMode) {
3208 case ModeDcsFirst:
3209 if (b<=US) {
3210 ParseControl(b);
3211 }
3212 else if ((b>=0x20) && (b<=0x2F)) {
3213 if (ICount<IntCharMax) ICount++;
3214 IntChar[ICount] = b;
3215 }
3216 else if ((b>=0x30) && (b<=0x39)) {
3217 if (Param[NParam] < 0) Param[NParam] = 0;
3218 if (Param[NParam]<1000)
3219 Param[NParam] = Param[NParam]*10 + b - 0x30;
3220 }
3221 else if (b==0x3B) {
3222 if (NParam < NParamMax) {
3223 NParam++;
3224 Param[NParam] = -1;
3225 }
3226 }
3227 else if ((b>=0x40) && (b<=0x7E)) {
3228 if (ICount == 0 && b=='|') {
3229 ParseMode = ModeDCUserKey;
3230 if (Param[1] < 1) ClearUserKey();
3231 WaitKeyId = TRUE;
3232 NewKeyId = 0;
3233 }
3234 else {
3235 Cmd = b;
3236 DcsParseMode = ModeDcsString;
3237 }
3238 }
3239 else {
3240 ParseMode = ModeSOS;
3241 }
3242 break;
3243
3244 case ModeDcsString:
3245 if (b <= US && b != HT && b != CR) {
3246 ESCFlag = FALSE;
3247 ParseMode = ModeFirst;
3248 DcsParseMode = ModeDcsFirst;
3249 StrLen = 0;
3250 }
3251 else if (StrLen < sizeof(StrBuff)-1) {
3252 StrBuff[StrLen++] = b;
3253 }
3254 break;
3255 }
3256 }
3257
3258 void DCUserKey(BYTE b)
3259 {
3260 if (ESCFlag && (b=='\\') || (b==ST && ts.KanjiCode!=IdSJIS))
3261 {
3262 if (! WaitKeyId) DefineUserKey(NewKeyId,NewKeyStr,NewKeyLen);
3263 ESCFlag = FALSE;
3264 ParseMode = ModeFirst;
3265 return;
3266 }
3267
3268 if (b==ESC)
3269 {
3270 ESCFlag = TRUE;
3271 return;
3272 }
3273 else ESCFlag = FALSE;
3274
3275 if (WaitKeyId)
3276 {
3277 if ((b>=0x30) && (b<=0x39))
3278 {
3279 if (NewKeyId<1000)
3280 NewKeyId = NewKeyId*10 + b - 0x30;
3281 }
3282 else if (b==0x2F)
3283 {
3284 WaitKeyId = FALSE;
3285 WaitHi = TRUE;
3286 NewKeyLen = 0;
3287 }
3288 }
3289 else {
3290 if (b==0x3B)
3291 {
3292 DefineUserKey(NewKeyId,NewKeyStr,NewKeyLen);
3293 WaitKeyId = TRUE;
3294 NewKeyId = 0;
3295 }
3296 else {
3297 if (NewKeyLen < FuncKeyStrMax)
3298 {
3299 if (WaitHi)
3300 {
3301 NewKeyStr[NewKeyLen] = ConvHexChar(b) << 4;
3302 WaitHi = FALSE;
3303 }
3304 else {
3305 NewKeyStr[NewKeyLen] = NewKeyStr[NewKeyLen] +
3306 ConvHexChar(b);
3307 WaitHi = TRUE;
3308 NewKeyLen++;
3309 }
3310 }
3311 }
3312 }
3313 }
3314
3315 void IgnoreString(BYTE b)
3316 {
3317 if ((ESCFlag && (b=='\\')) ||
3318 (b<=US && b!=ESC && b!=HT) ||
3319 (b==ST && ts.KanjiCode!=IdSJIS))
3320 ParseMode = ModeFirst;
3321
3322 if (b==ESC) ESCFlag