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 4770 - (show annotations) (download) (as text)
Tue Dec 6 10:20:48 2011 UTC (12 years, 4 months ago) by doda
File MIME type: text/x-csrc
File size: 108723 byte(s) 
OSC 5, 105, 110, 111, 115, 116 に対応

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