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 7278 - (show annotations) (download) (as text)
Wed Nov 21 09:13:01 2018 UTC (5 years, 4 months ago) by doda
File MIME type: text/x-csrc
File size: 138506 byte(s) 
DECCOLM で DECLRMM が off にならなくなったのを修正

ChangeTerminalSize() では LRMarginMode をクリアしなくなった為。

DECCOLM では DECLRMM を off にするのが仕様。

c.f. https://vt100.net/docs/vt510-rm/DECCOLM.html

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