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