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