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 8330 - (show annotations) (download) (as text)
Fri Oct 25 11:31:34 2019 UTC (4 years, 5 months ago) by doda
File MIME type: text/x-csrc
File size: 141357 byte(s) 
TTIMESV/TTIMERS が正しく働かないのを修正。

Ticket: #39702

問題:
  TTIMESV(IME状態保存)/TTIMERS(IME状態復元)制御シーケンスが働かない。

原因:
  IMEの現在の状態を記憶しておく変数と、制御シーケンス用にIMEの状態を
  保存しておく変数に同じ物を使っていた為。

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