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