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