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 8329 - (show annotations) (download) (as text)
Thu Oct 24 10:41:21 2019 UTC (4 years, 5 months ago) by doda
File MIME type: text/x-csrc
File size: 141281 byte(s) 
REP 制御シーケンスに対応した。

Ticket: #39451

問題:
  REP 制御シーケンスに対応していない。
  ncurses-6.1 付属の terminfo の xterm エントリでは rep が定義されて
  いる為、これを参照および使用するプログラムの表示が正しく行われない
  可能性がある。

対処:
  REP 制御シーケンスに対応した。

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