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