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 8766 - (show annotations) (download) (as text)
Wed May 6 14:52:04 2020 UTC (3 years, 11 months ago) by zmatsuo
File MIME type: text/x-csrc
File size: 151826 byte(s) 
CJK,2byte文字の入力をできるようにした

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