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 8743 - (show annotations) (download) (as text)
Sun Apr 26 14:34:30 2020 UTC (3 years, 11 months ago) by zmatsuo
File MIME type: text/x-csrc
File size: 150500 byte(s) 
AttrEx が不定になっていたので修正

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