Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/trunk/teraterm/teraterm/vtterm.c

Annotation of /trunk/teraterm/teraterm/vtterm.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 6803 - (hide annotations) (download) (as text)
Tue Jun 13 10:42:58 2017 UTC (6 years, 9 months ago) by doda
File MIME type: text/x-csrc
File size: 133039 byte(s) 
NO_COPYLINE_FIX マクロを廃止。常に有効。
1 maya 3227 /* Tera Term
2     Copyright(C) 1994-1998 T. Teranishi
3     All rights reserved. */
4    
5     /* TERATERM.EXE, VT terminal emulation */
6     #include "teraterm.h"
7     #include "tttypes.h"
8     #include <stdio.h>
9     #include <string.h>
10     #include <stdlib.h>
11     #include <mbstring.h>
12     #include <locale.h>
13 doda 4225 #include <ctype.h>
14 maya 3227
15     #include "buffer.h"
16     #include "ttwinman.h"
17     #include "ttcommon.h"
18     #include "commlib.h"
19     #include "vtdisp.h"
20     #include "keyboard.h"
21     #include "ttlib.h"
22     #include "ttftypes.h"
23     #include "filesys.h"
24     #include "teraprn.h"
25     #include "telnet.h"
26 doda 4278 #include "ttime.h"
27 doda 4769 #include "clipboar.h"
28 maya 3227
29     #include "vtterm.h"
30    
31 doda 4256 void ParseFirst(BYTE b);
32    
33 doda 3443 #define MAPSIZE(x) (sizeof(x)/sizeof((x)[0]))
34 doda 4246 #define Accept8BitCtrl ((VTlevel >= 2) && (ts.TermFlag & TF_ACCEPT8BITCTRL))
35 doda 3443
36 maya 3227 /* Parsing modes */
37     #define ModeFirst 0
38     #define ModeESC 1
39     #define ModeDCS 2
40     #define ModeDCUserKey 3
41     #define ModeSOS 4
42     #define ModeCSI 5
43     #define ModeXS 6
44     #define ModeDLE 7
45     #define ModeCAN 8
46 doda 5911 #define ModeIgnore 9
47 maya 3227
48 doda 5073 #define NParamMax 16
49     #define NSParamMax 16
50     #define IntCharMax 5
51 maya 3227
52 doda 3997 /* DEC Locator Flag */
53     #define DecLocatorOneShot 1
54     #define DecLocatorPixel 2
55     #define DecLocatorButtonDown 4
56     #define DecLocatorButtonUp 8
57     #define DecLocatorFiltered 16
58    
59 doda 5316 void RingBell(int type);
60 maya 3227 void VisualBell();
61 doda 3999 BOOL DecLocatorReport(int Event, int Button);
62 maya 3227
63     /* character attribute */
64     static TCharAttr CharAttr;
65    
66     /* various modes of VT emulation */
67     static BOOL RelativeOrgMode;
68     static BOOL InsertMode;
69     static BOOL LFMode;
70 doda 5564 static BOOL ClearThenHome;
71 maya 3227 static BOOL AutoWrapMode;
72     static BOOL FocusReportMode;
73 doda 3743 static BOOL AltScr;
74 doda 5324 static BOOL LRMarginMode;
75 doda 3872 BOOL BracketedPaste;
76 maya 3227
77 doda 4246 static int VTlevel;
78    
79 doda 4293 BOOL AcceptWheelToCursor;
80    
81 maya 3227 // save/restore cursor
82     typedef struct {
83 doda 6802 int CursorX, CursorY;
84     TCharAttr Attr;
85     int Glr[2], Gn[4]; // G0-G3, GL & GR
86     BOOL AutoWrapMode;
87     BOOL RelativeOrgMode;
88 maya 3227 } TStatusBuff;
89     typedef TStatusBuff *PStatusBuff;
90    
91 maya 4893 // currently only used for AUTO CR/LF receive mode
92     BYTE PrevCharacter;
93     BOOL PrevCRorLFGeneratedCRLF; // indicates that previous CR or LF really generated a CR+LF
94    
95 maya 3227 // status buffer for main screen & status line
96 doda 3797 static TStatusBuff SBuff1, SBuff2, SBuff3;
97 maya 3227
98     static BOOL ESCFlag, JustAfterESC;
99     static BOOL KanjiIn;
100     static BOOL EUCkanaIn, EUCsupIn;
101     static int EUCcount;
102     static BOOL Special;
103    
104     static int Param[NParamMax+1];
105 doda 5073 static int SubParam[NParamMax+1][NSParamMax+1];
106     static int NParam, NSParam[NParamMax+1];
107 maya 3227 static BOOL FirstPrm;
108     static BYTE IntChar[IntCharMax+1];
109     static int ICount;
110     static BYTE Prv;
111 doda 4291 static int ParseMode;
112 maya 3227 static int ChangeEmu;
113    
114 doda 5096 typedef struct tstack {
115 doda 6802 char *title;
116     struct tstack *next;
117 doda 5096 } TStack;
118     typedef TStack *PTStack;
119     PTStack TitleStack = NULL;
120    
121 maya 3227 /* user defined keys */
122     static BOOL WaitKeyId, WaitHi;
123    
124     /* GL, GR code group */
125     static int Glr[2];
126     /* G0, G1, G2, G3 code group */
127     static int Gn[4];
128     /* GL for single shift 2/3 */
129     static int GLtmp;
130     /* single shift 2/3 flag */
131     static BOOL SSflag;
132     /* JIS -> SJIS conversion flag */
133     static BOOL ConvJIS;
134     static WORD Kanji;
135 doda 6602 static BOOL Fallbacked;
136 maya 3227
137     // variables for status line mode
138     static int StatusX=0;
139     static BOOL StatusWrap=FALSE;
140     static BOOL StatusCursor=TRUE;
141     static int MainX, MainY; //cursor registers
142     static int MainTop, MainBottom; // scroll region registers
143     static BOOL MainWrap;
144     static BOOL MainCursor=TRUE;
145    
146     /* status for printer escape sequences */
147 doda 6802 static BOOL PrintEX = TRUE; // printing extent
148 maya 3227 // (TRUE: screen, FALSE: scroll region)
149     static BOOL AutoPrintMode = FALSE;
150     static BOOL PrinterMode = FALSE;
151     static BOOL DirectPrn = FALSE;
152    
153     /* User key */
154     static BYTE NewKeyStr[FuncKeyStrMax];
155     static int NewKeyId, NewKeyLen;
156    
157 doda 3997 /* Mouse Report */
158     int MouseReportMode;
159 doda 4813 int MouseReportExtMode;
160 doda 3997 unsigned int DecLocatorFlag;
161     int LastX, LastY;
162     int ButtonStat;
163 doda 3999 int FilterTop, FilterBottom, FilterLeft, FilterRight;
164 doda 3997
165 doda 4278 /* IME Status */
166     BOOL IMEstat;
167    
168 doda 5316 /* Beep over-used */
169     static DWORD BeepStartTime = 0;
170     static DWORD BeepSuppressTime = 0;
171     static DWORD BeepOverUsedCount = 0;
172    
173 doda 3450 static _locale_t CLocale = NULL;
174 maya 3227
175 doda 5073 void ClearParams()
176     {
177 doda 6802 ICount = 0;
178     NParam = 1;
179     NSParam[1] = 0;
180     Param[1] = 0;
181     Prv = 0;
182 doda 5073 }
183    
184 doda 3916 void ResetSBuffer(PStatusBuff sbuff)
185 maya 3227 {
186 doda 6802 sbuff->CursorX = 0;
187     sbuff->CursorY = 0;
188     sbuff->Attr = DefCharAttr;
189     if (ts.Language==IdJapanese) {
190     sbuff->Gn[0] = IdASCII;
191     sbuff->Gn[1] = IdKatakana;
192     sbuff->Gn[2] = IdKatakana;
193     sbuff->Gn[3] = IdKanji;
194     sbuff->Glr[0] = 0;
195     if ((ts.KanjiCode==IdJIS) && (ts.JIS7Katakana==0))
196     sbuff->Glr[1] = 2; // 8-bit katakana
197     else
198     sbuff->Glr[1] = 3;
199     }
200     else {
201     sbuff->Gn[0] = IdASCII;
202     sbuff->Gn[1] = IdSpecial;
203     sbuff->Gn[2] = IdASCII;
204     sbuff->Gn[3] = IdASCII;
205     sbuff->Glr[0] = 0;
206     sbuff->Glr[1] = 0;
207     }
208     sbuff->AutoWrapMode = TRUE;
209     sbuff->RelativeOrgMode = FALSE;
210 doda 3916 }
211    
212     void ResetAllSBuffers()
213     {
214 doda 6802 ResetSBuffer(&SBuff1);
215     // copy SBuff1 to SBuff2
216     SBuff2 = SBuff1;
217     SBuff3 = SBuff1;
218 maya 3227 }
219    
220 doda 3916 void ResetCurSBuffer()
221     {
222 doda 6802 PStatusBuff Buff;
223 doda 3916
224 doda 6802 if (AltScr) {
225     Buff = &SBuff3; // Alternate screen buffer
226     }
227     else {
228     Buff = &SBuff1; // Normal screen buffer
229     }
230     ResetSBuffer(Buff);
231     SBuff2 = *Buff;
232 doda 3916 }
233    
234 maya 3227 void ResetTerminal() /*reset variables but don't update screen */
235     {
236 doda 6802 DispReset();
237     BuffReset();
238 maya 3227
239 doda 6802 /* Attribute */
240     CharAttr = DefCharAttr;
241     Special = FALSE;
242     BuffSetCurCharAttr(CharAttr);
243 maya 3227
244 doda 6802 /* Various modes */
245     InsertMode = FALSE;
246     LFMode = (ts.CRSend == IdCRLF);
247     AutoWrapMode = TRUE;
248     AppliKeyMode = FALSE;
249     AppliCursorMode = FALSE;
250     AppliEscapeMode = FALSE;
251     AcceptWheelToCursor = ts.TranslateWheelToCursor;
252     RelativeOrgMode = FALSE;
253     ts.ColorFlag &= ~CF_REVERSEVIDEO;
254     AutoRepeatMode = TRUE;
255     FocusReportMode = FALSE;
256     MouseReportMode = IdMouseTrackNone;
257     MouseReportExtMode = IdMouseTrackExtNone;
258     DecLocatorFlag = 0;
259     ClearThenHome = FALSE;
260 maya 3227
261 doda 6802 ChangeTerminalID();
262 doda 4246
263 doda 6802 LastX = 0;
264     LastY = 0;
265     ButtonStat = 0;
266 doda 3997
267 doda 6802 if (CLocale == NULL) {
268     CLocale = _create_locale(LC_ALL, "C");
269     }
270 maya 3227
271 doda 6802 /* Character sets */
272     ResetCharSet();
273 maya 3227
274 doda 6802 /* ESC flag for device control sequence */
275     ESCFlag = FALSE;
276     /* for TEK sequence */
277     JustAfterESC = FALSE;
278 maya 3227
279 doda 6802 /* Parse mode */
280     ParseMode = ModeFirst;
281 maya 3227
282 doda 6802 /* Clear printer mode */
283     PrinterMode = FALSE;
284 maya 3227
285 doda 6802 // status buffers
286     ResetAllSBuffers();
287 doda 3745
288 doda 6802 // Alternate Screen Buffer
289     AltScr = FALSE;
290 doda 3872
291 doda 6802 // Left/Right Margin Mode
292     LRMarginMode = FALSE;
293 doda 5324
294 doda 6802 // Bracketed Paste Mode
295     BracketedPaste = FALSE;
296 doda 4278
297 doda 6802 // Saved IME Status
298     IMEstat = FALSE;
299 maya 4893
300 doda 6802 // previous received character
301     PrevCharacter = -1; // none
302     PrevCRorLFGeneratedCRLF = FALSE;
303 doda 5316
304 doda 6802 // Beep over-used
305     BeepStartTime = GetTickCount();
306     BeepSuppressTime = BeepStartTime - ts.BeepSuppressTime * 1000;
307     BeepStartTime -= (ts.BeepOverUsedTime * 1000);
308     BeepOverUsedCount = ts.BeepOverUsedCount;
309 maya 3227 }
310    
311     void ResetCharSet()
312     {
313 doda 6802 if (ts.Language==IdJapanese) {
314     Gn[0] = IdASCII;
315     Gn[1] = IdKatakana;
316     Gn[2] = IdKatakana;
317     Gn[3] = IdKanji;
318     Glr[0] = 0;
319     if ((ts.KanjiCode==IdJIS) && (ts.JIS7Katakana==0))
320     Glr[1] = 2; // 8-bit katakana
321     else
322     Glr[1] = 3;
323     }
324     else {
325     Gn[0] = IdASCII;
326     Gn[1] = IdSpecial;
327     Gn[2] = IdASCII;
328     Gn[3] = IdASCII;
329     Glr[0] = 0;
330     Glr[1] = 0;
331     cv.SendCode = IdASCII;
332     cv.SendKanjiFlag = FALSE;
333     cv.EchoCode = IdASCII;
334     cv.EchoKanjiFlag = FALSE;
335     }
336     /* Kanji flag */
337     KanjiIn = FALSE;
338     EUCkanaIn = FALSE;
339     EUCsupIn = FALSE;
340     SSflag = FALSE;
341     ConvJIS = FALSE;
342     Fallbacked = FALSE;
343 maya 3227
344 doda 6802 cv.Language = ts.Language;
345     cv.CRSend = ts.CRSend;
346     cv.KanjiCodeEcho = ts.KanjiCode;
347     cv.JIS7KatakanaEcho = ts.JIS7Katakana;
348     cv.KanjiCodeSend = ts.KanjiCodeSend;
349     cv.JIS7KatakanaSend = ts.JIS7KatakanaSend;
350     cv.KanjiIn = ts.KanjiIn;
351     cv.KanjiOut = ts.KanjiOut;
352 maya 3227 }
353    
354     void ResetKeypadMode(BOOL DisabledModeOnly)
355     {
356 doda 6802 if (!DisabledModeOnly || ts.DisableAppKeypad)
357     AppliKeyMode = FALSE;
358     if (!DisabledModeOnly || ts.DisableAppCursor)
359     AppliCursorMode = FALSE;
360 maya 3227 }
361    
362     void MoveToMainScreen()
363     {
364 doda 6802 StatusX = CursorX;
365     StatusWrap = Wrap;
366     StatusCursor = IsCaretEnabled();
367 maya 3227
368 doda 6802 CursorTop = MainTop;
369     CursorBottom = MainBottom;
370     Wrap = MainWrap;
371     DispEnableCaret(MainCursor);
372     MoveCursor(MainX, MainY); // move to main screen
373 maya 3227 }
374    
375     void MoveToStatusLine()
376     {
377 doda 6802 MainX = CursorX;
378     MainY = CursorY;
379     MainTop = CursorTop;
380     MainBottom = CursorBottom;
381     MainWrap = Wrap;
382     MainCursor = IsCaretEnabled();
383 maya 3227
384 doda 6802 DispEnableCaret(StatusCursor);
385     MoveCursor(StatusX, NumOfLines-1); // move to status line
386     CursorTop = NumOfLines-1;
387     CursorBottom = CursorTop;
388     Wrap = StatusWrap;
389 maya 3227 }
390    
391     void HideStatusLine()
392     {
393 doda 6802 if (isCursorOnStatusLine)
394     MoveToMainScreen();
395     StatusX = 0;
396     StatusWrap = FALSE;
397     StatusCursor = TRUE;
398     ShowStatusLine(0); //hide
399 maya 3227 }
400    
401     void ChangeTerminalSize(int Nx, int Ny)
402     {
403 doda 6802 BuffChangeTerminalSize(Nx, Ny);
404     StatusX = 0;
405     MainX = 0;
406     MainY = 0;
407     MainTop = 0;
408     MainBottom = NumOfColumns-1;
409     LRMarginMode = FALSE;
410 maya 3227 }
411    
412 doda 3471 void SendCSIstr(char *str, int len) {
413 doda 4024 int l;
414    
415     if (str == NULL || len < 0)
416 doda 3471 return;
417    
418 doda 4024 if (len == 0) {
419     l = strlen(str);
420     }
421     else {
422     l = len;
423     }
424    
425 doda 3471 if (Send8BitMode)
426     CommBinaryOut(&cv,"\233", 1);
427     else
428     CommBinaryOut(&cv,"\033[", 2);
429    
430 doda 4024 CommBinaryOut(&cv, str, l);
431 doda 3471 }
432    
433 doda 5911 void SendOSCstr(char *str, int len, char TermChar) {
434 doda 4024 int l;
435    
436 doda 4104 if (str == NULL || len < 0)
437 doda 3471 return;
438    
439 doda 4024 if (len == 0) {
440     l = strlen(str);
441     }
442     else {
443     l = len;
444     }
445    
446 doda 5911 if (TermChar == BEL) {
447     CommBinaryOut(&cv,"\033]", 2);
448     CommBinaryOut(&cv, str, l);
449     CommBinaryOut(&cv,"\007", 1);
450     }
451     else if (Send8BitMode) {
452 doda 3471 CommBinaryOut(&cv,"\235", 1);
453 doda 4024 CommBinaryOut(&cv, str, l);
454 doda 3486 CommBinaryOut(&cv,"\234", 1);
455     }
456     else {
457 doda 3471 CommBinaryOut(&cv,"\033]", 2);
458 doda 4024 CommBinaryOut(&cv, str, l);
459 doda 3486 CommBinaryOut(&cv,"\033\\", 2);
460     }
461 doda 3471
462     }
463    
464 doda 4162 void SendDCSstr(char *str, int len) {
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 (Send8BitMode) {
478     CommBinaryOut(&cv,"\220", 1);
479     CommBinaryOut(&cv, str, l);
480     CommBinaryOut(&cv,"\234", 1);
481     }
482     else {
483     CommBinaryOut(&cv,"\033P", 2);
484     CommBinaryOut(&cv, str, l);
485     CommBinaryOut(&cv,"\033\\", 2);
486     }
487    
488     }
489    
490 maya 3227 void BackSpace()
491     {
492 doda 5324 if (CursorX == CursorLeftM || CursorX == 0) {
493     if (CursorY > 0 && (ts.TermFlag & TF_BACKWRAP)) {
494     MoveCursor(CursorRightM, CursorY-1);
495     if (cv.HLogBuf!=0 && !ts.LogTypePlainText) Log1Byte(BS);
496     }
497     }
498     else if (CursorX > 0) {
499     MoveCursor(CursorX-1, CursorY);
500     if (cv.HLogBuf!=0 && !ts.LogTypePlainText) Log1Byte(BS);
501     }
502 maya 3227 }
503    
504     void CarriageReturn(BOOL logFlag)
505     {
506     if (!ts.EnableContinuedLineCopy || logFlag)
507 doda 6803 if (cv.HLogBuf!=0) Log1Byte(CR);
508 maya 3227
509 doda 5324 if (RelativeOrgMode || CursorX > CursorLeftM)
510     MoveCursor(CursorLeftM, CursorY);
511     else if (CursorX < CursorLeftM)
512     MoveCursor(0, CursorY);
513 doda 6602
514     Fallbacked = FALSE;
515 maya 3227 }
516    
517     void LineFeed(BYTE b, BOOL logFlag)
518     {
519     /* for auto print mode */
520     if ((AutoPrintMode) &&
521     (b>=LF) && (b<=FF))
522     BuffDumpCurrentLine(b);
523    
524     if (!ts.EnableContinuedLineCopy || logFlag)
525 doda 6803 if (cv.HLogBuf!=0) Log1Byte(LF);
526 maya 3227
527     if (CursorY < CursorBottom)
528     MoveCursor(CursorX,CursorY+1);
529     else if (CursorY == CursorBottom) BuffScrollNLines(1);
530     else if (CursorY < NumOfLines-StatusLine-1)
531     MoveCursor(CursorX,CursorY+1);
532    
533 doda 3312 ClearLineContinued();
534    
535 maya 3227 if (LFMode) CarriageReturn(logFlag);
536 doda 6602
537     Fallbacked = FALSE;
538 maya 3227 }
539    
540     void Tab()
541     {
542 doda 6802 if (Wrap && !ts.VTCompatTab) {
543     CarriageReturn(FALSE);
544     LineFeed(LF,FALSE);
545     if (ts.EnableContinuedLineCopy) {
546     SetLineContinued();
547     }
548     Wrap = FALSE;
549     }
550     CursorForwardTab(1, AutoWrapMode);
551     if (cv.HLogBuf!=0) Log1Byte(HT);
552 maya 3227 }
553    
554     void PutChar(BYTE b)
555     {
556 doda 6802 BOOL SpecialNew;
557     TCharAttr CharAttrTmp;
558 maya 3227
559 doda 6802 CharAttrTmp = CharAttr;
560 maya 3227
561 doda 6802 if (PrinterMode) { // printer mode
562     WriteToPrnFile(b,TRUE);
563     return;
564     }
565 maya 3227
566 doda 6802 if (Wrap) {
567     CarriageReturn(FALSE);
568     LineFeed(LF,FALSE);
569     CharAttrTmp.Attr |= ts.EnableContinuedLineCopy ? AttrLineContinued : 0;
570     }
571 maya 3227
572 doda 6802 // if (cv.HLogBuf!=0) Log1Byte(b);
573 maya 3227 // (2005.2.20 yutaka)
574 doda 6802 if (ts.LogTypePlainText) {
575     if (__isascii(b) && !isprint(b)) {
576     // ASCII�������A���\�������������O�����������B
577     } else {
578     if (cv.HLogBuf!=0) Log1Byte(b);
579     }
580     } else {
581 maya 3227 if (cv.HLogBuf!=0) Log1Byte(b);
582 doda 6802 }
583 maya 3227
584 doda 6802 Wrap = FALSE;
585 maya 3227
586 doda 6802 SpecialNew = FALSE;
587     if ((b>0x5F) && (b<0x80)) {
588     if (SSflag)
589     SpecialNew = (Gn[GLtmp]==IdSpecial);
590     else
591     SpecialNew = (Gn[Glr[0]]==IdSpecial);
592     }
593     else if (b>0xDF) {
594     if (SSflag)
595     SpecialNew = (Gn[GLtmp]==IdSpecial);
596     else
597     SpecialNew = (Gn[Glr[1]]==IdSpecial);
598     }
599 maya 3227
600 doda 6802 if (SpecialNew != Special) {
601     UpdateStr();
602     Special = SpecialNew;
603     }
604 maya 3227
605 doda 6802 if (Special) {
606     b = b & 0x7F;
607     CharAttrTmp.Attr |= AttrSpecial;
608     }
609     else
610     CharAttrTmp.Attr |= CharAttr.Attr;
611 maya 3227
612 doda 6802 BuffPutChar(b, CharAttrTmp, InsertMode);
613 maya 3227
614 doda 6802 if (CursorX == CursorRightM || CursorX >= NumOfColumns-1) {
615     UpdateStr();
616     Wrap = AutoWrapMode;
617     }
618     else {
619     MoveRight();
620     }
621 maya 3227 }
622    
623     void PutDecSp(BYTE b)
624     {
625 doda 6802 TCharAttr CharAttrTmp;
626 maya 3227
627 doda 6802 CharAttrTmp = CharAttr;
628 maya 3227
629 doda 6802 if (PrinterMode) { // printer mode
630     WriteToPrnFile(b, TRUE);
631     return;
632     }
633 maya 3227
634 doda 6802 if (Wrap) {
635     CarriageReturn(FALSE);
636     LineFeed(LF, FALSE);
637     CharAttrTmp.Attr |= ts.EnableContinuedLineCopy ? AttrLineContinued : 0;
638     }
639 maya 3227
640 doda 6802 if (cv.HLogBuf!=0) Log1Byte(b);
641 maya 3227 /*
642 doda 6802 if (ts.LogTypePlainText && __isascii(b) && !isprint(b)) {
643     // ASCII�������A���\�������������O�����������B
644     } else {
645     if (cv.HLogBuf!=0) Log1Byte(b);
646     }
647 maya 3227 */
648    
649 doda 6802 Wrap = FALSE;
650 maya 3227
651 doda 6802 if (!Special) {
652     UpdateStr();
653     Special = TRUE;
654     }
655 maya 3227
656 doda 6802 CharAttrTmp.Attr |= AttrSpecial;
657     BuffPutChar(b, CharAttrTmp, InsertMode);
658 maya 3227
659 doda 6802 if (CursorX == CursorRightM || CursorX >= NumOfColumns-1) {
660     UpdateStr();
661     Wrap = AutoWrapMode;
662     }
663     else {
664     MoveRight();
665     }
666 maya 3227 }
667    
668     void PutKanji(BYTE b)
669     {
670 doda 6802 int LineEnd;
671     TCharAttr CharAttrTmp;
672 doda 6803 CharAttrTmp = CharAttr;
673 maya 3227
674 doda 6802 Kanji = Kanji + b;
675 maya 3227
676 doda 6802 if (PrinterMode && DirectPrn) {
677     WriteToPrnFile(HIBYTE(Kanji),FALSE);
678     WriteToPrnFile(LOBYTE(Kanji),TRUE);
679     return;
680     }
681 maya 3227
682 doda 6802 if (ConvJIS)
683     Kanji = JIS2SJIS((WORD)(Kanji & 0x7f7f));
684 maya 3227
685 doda 6802 if (PrinterMode) { // printer mode
686     WriteToPrnFile(HIBYTE(Kanji),FALSE);
687     WriteToPrnFile(LOBYTE(Kanji),TRUE);
688     return;
689     }
690 maya 3227
691 doda 6802 if (CursorX > CursorRightM)
692     LineEnd = NumOfColumns - 1;
693     else
694     LineEnd = CursorRightM;
695 doda 5324
696 doda 6802 if (Wrap) {
697     CarriageReturn(FALSE);
698     LineFeed(LF,FALSE);
699     if (ts.EnableContinuedLineCopy)
700     CharAttrTmp.Attr |= AttrLineContinued;
701     }
702     else if (CursorX > LineEnd - 1) {
703     if (AutoWrapMode) {
704     if (ts.EnableContinuedLineCopy) {
705     CharAttrTmp.Attr |= AttrLineContinued;
706     if (CursorX == LineEnd)
707     BuffPutChar(0x20, CharAttr, FALSE);
708     }
709     CarriageReturn(FALSE);
710     LineFeed(LF,FALSE);
711     }
712     else {
713     return;
714     }
715     }
716 maya 3227
717 doda 6802 Wrap = FALSE;
718 maya 3227
719 doda 6802 if (cv.HLogBuf!=0) {
720     Log1Byte(HIBYTE(Kanji));
721     Log1Byte(LOBYTE(Kanji));
722     }
723 maya 3227
724 doda 6802 if (Special) {
725     UpdateStr();
726     Special = FALSE;
727     }
728 maya 3227
729 doda 6802 BuffPutKanji(Kanji, CharAttrTmp, InsertMode);
730 maya 3227
731 doda 6802 if (CursorX < LineEnd - 1) {
732     MoveRight();
733     MoveRight();
734     }
735     else {
736     UpdateStr();
737     Wrap = AutoWrapMode;
738     }
739 maya 3227 }
740    
741     void PutDebugChar(BYTE b)
742     {
743 yutakapon 3637 static BYTE buff[3];
744 doda 5589 int i;
745     BOOL svInsertMode, svAutoWrapMode;
746     BYTE svCharAttr;
747 yutakapon 3637
748 doda 5589 if (DebugFlag!=DEBUG_FLAG_NOUT) {
749     svInsertMode = InsertMode;
750     svAutoWrapMode = AutoWrapMode;
751 doda 5588 InsertMode = FALSE;
752     AutoWrapMode = TRUE;
753 maya 3227
754 doda 5589 svCharAttr = CharAttr.Attr;
755     if (CharAttr.Attr != AttrDefault) {
756     UpdateStr();
757     CharAttr.Attr = AttrDefault;
758     }
759    
760 doda 5588 if (DebugFlag==DEBUG_FLAG_HEXD) {
761     _snprintf(buff, 3, "%02X", (unsigned int) b);
762 yutakapon 3637
763 doda 5589 for (i=0; i<2; i++)
764 doda 5588 PutChar(buff[i]);
765     PutChar(' ');
766     }
767     else if (DebugFlag==DEBUG_FLAG_NORM) {
768 yutakapon 3637
769 doda 5588 if ((b & 0x80) == 0x80) {
770     UpdateStr();
771     CharAttr.Attr = AttrReverse;
772     b = b & 0x7f;
773     }
774 maya 3227
775 doda 5588 if (b<=US) {
776     PutChar('^');
777     PutChar((char)(b+0x40));
778     }
779     else if (b==DEL) {
780     PutChar('<');
781     PutChar('D');
782     PutChar('E');
783     PutChar('L');
784     PutChar('>');
785     }
786     else
787     PutChar(b);
788     }
789 maya 3227
790 doda 5589 if (CharAttr.Attr != svCharAttr) {
791 doda 5588 UpdateStr();
792 doda 5589 CharAttr.Attr = svCharAttr;
793 doda 5588 }
794 doda 5589 InsertMode = svInsertMode;
795     AutoWrapMode = svAutoWrapMode;
796 yutakapon 3637 }
797 maya 3227 }
798    
799     void PrnParseControl(BYTE b) // printer mode
800     {
801 doda 6802 switch (b) {
802     case NUL:
803     return;
804     case SO:
805     if (! DirectPrn) {
806     if ((ts.Language==IdJapanese) &&
807     (ts.KanjiCode==IdJIS) &&
808     (ts.JIS7Katakana==1) &&
809     ((ts.TermFlag & TF_FIXEDJIS)!=0))
810     {
811     Gn[1] = IdKatakana;
812     }
813     Glr[0] = 1; /* LS1 */
814     return;
815     }
816     break;
817     case SI:
818     if (! DirectPrn) {
819     Glr[0] = 0; /* LS0 */
820     return;
821     }
822     break;
823     case DC1:
824     case DC3:
825     return;
826     case ESC:
827     ICount = 0;
828     JustAfterESC = TRUE;
829     ParseMode = ModeESC;
830     WriteToPrnFile(0, TRUE); // flush prn buff
831     return;
832     case CSI:
833     if (! Accept8BitCtrl) {
834     PutChar(b); /* Disp C1 char in VT100 mode */
835     return;
836     }
837     ClearParams();
838     FirstPrm = TRUE;
839     ParseMode = ModeCSI;
840     WriteToPrnFile(0, TRUE); // flush prn buff
841     WriteToPrnFile(b, FALSE);
842     return;
843     }
844     /* send the uninterpreted character to printer */
845     WriteToPrnFile(b, TRUE);
846 maya 3227 }
847    
848     void ParseControl(BYTE b)
849     {
850 doda 6802 if (PrinterMode) { // printer mode
851     PrnParseControl(b);
852     return;
853     }
854 maya 3227
855 doda 6802 if (b>=0x80) { /* C1 char */
856     if (ts.Language==IdEnglish) { /* English mode */
857     if (!Accept8BitCtrl) {
858     PutChar(b); /* Disp C1 char in VT100 mode */
859     return;
860     }
861     }
862     else { /* Japanese mode */
863     if ((ts.TermFlag & TF_ACCEPT8BITCTRL)==0) {
864     return; /* ignore C1 char */
865     }
866     /* C1 chars are interpreted as C0 chars in VT100 mode */
867     if (VTlevel < 2) {
868     b = b & 0x7F;
869     }
870     }
871     }
872     switch (b) {
873     /* C0 group */
874     case ENQ:
875     CommBinaryOut(&cv, &(ts.Answerback[0]), ts.AnswerbackLen);
876     break;
877     case BEL:
878     if (ts.Beep != IdBeepOff)
879     RingBell(ts.Beep);
880     break;
881     case BS:
882     BackSpace();
883     break;
884     case HT:
885     Tab();
886     break;
887     case LF:
888 maya 3227 if (ts.CRReceive == IdLF) {
889 maya 4893 // ���M�������s�R�[�h�� LF ���������A�T�[�o���� LF ���������������������������A
890     // CR+LF���������������������B
891     // cf. http://www.neocom.ca/forum/viewtopic.php?t=216
892     // (2007.1.21 yutaka)
893 maya 3227 CarriageReturn(TRUE);
894     LineFeed(b, TRUE);
895     break;
896     }
897 maya 4893 else if (ts.CRReceive == IdAUTO) {
898     // 9th Apr 2012: AUTO CR/LF mode (tentner)
899     // a CR or LF will generated a CR+LF, if the next character is the opposite, it will be ignored
900     if(PrevCharacter != CR || !PrevCRorLFGeneratedCRLF) {
901     CarriageReturn(TRUE);
902     LineFeed(b, TRUE);
903     PrevCRorLFGeneratedCRLF = TRUE;
904     }
905     else {
906     PrevCRorLFGeneratedCRLF = FALSE;
907     }
908     break;
909     }
910 maya 3227
911 doda 6802 case VT:
912     LineFeed(b, TRUE);
913     break;
914 maya 3227
915 doda 6802 case FF:
916     if ((ts.AutoWinSwitch>0) && JustAfterESC) {
917     CommInsert1Byte(&cv, b);
918     CommInsert1Byte(&cv, ESC);
919     ChangeEmu = IdTEK; /* Enter TEK Mode */
920     }
921     else
922     LineFeed(b, TRUE);
923     break;
924     case CR:
925     if (ts.CRReceive == IdAUTO) {
926     // 9th Apr 2012: AUTO CR/LF mode (tentner)
927     // a CR or LF will generated a CR+LF, if the next character is the opposite, it will be ignored
928     if(PrevCharacter != LF || !PrevCRorLFGeneratedCRLF) {
929     CarriageReturn(TRUE);
930     LineFeed(b, TRUE);
931     PrevCRorLFGeneratedCRLF = TRUE;
932     }
933     else {
934     PrevCRorLFGeneratedCRLF = FALSE;
935     }
936     }
937     else {
938     CarriageReturn(TRUE);
939     if (ts.CRReceive==IdCRLF) {
940     CommInsert1Byte(&cv, LF);
941     }
942     }
943     break;
944     case SO: /* LS1 */
945     if ((ts.Language==IdJapanese) &&
946     (ts.KanjiCode==IdJIS) &&
947     (ts.JIS7Katakana==1) &&
948     ((ts.TermFlag & TF_FIXEDJIS)!=0))
949     Gn[1] = IdKatakana;
950 maya 3227
951 doda 6802 Glr[0] = 1;
952     break;
953     case SI: /* LS0 */
954     Glr[0] = 0;
955     break;
956     case DLE:
957     if ((ts.FTFlag & FT_BPAUTO)!=0)
958     ParseMode = ModeDLE; /* Auto B-Plus activation */
959     break;
960     case CAN:
961     if ((ts.FTFlag & FT_ZAUTO)!=0)
962     ParseMode = ModeCAN; /* Auto ZMODEM activation */
963     // else if (ts.AutoWinSwitch>0)
964     // ChangeEmu = IdTEK; /* Enter TEK Mode */
965     else
966     ParseMode = ModeFirst;
967     break;
968     case SUB:
969     ParseMode = ModeFirst;
970     break;
971     case ESC:
972     ICount = 0;
973     JustAfterESC = TRUE;
974     ParseMode = ModeESC;
975     break;
976     case FS:
977     case GS:
978     case RS:
979     case US:
980     if (ts.AutoWinSwitch>0) {
981     CommInsert1Byte(&cv, b);
982     ChangeEmu = IdTEK; /* Enter TEK Mode */
983     }
984     break;
985 maya 3227
986 doda 6802 /* C1 char */
987     case IND:
988     LineFeed(0, TRUE);
989     break;
990     case NEL:
991     LineFeed(0, TRUE);
992     CarriageReturn(TRUE);
993     break;
994     case HTS:
995     if (ts.TabStopFlag & TABF_HTS8)
996     SetTabStop();
997     break;
998     case RI:
999     CursorUpWithScroll();
1000     break;
1001     case SS2:
1002     GLtmp = 2;
1003     SSflag = TRUE;
1004     break;
1005     case SS3:
1006     GLtmp = 3;
1007     SSflag = TRUE;
1008     break;
1009     case DCS:
1010     ClearParams();
1011     ESCFlag = FALSE;
1012     ParseMode = ModeDCS;
1013     break;
1014     case SOS:
1015     ESCFlag = FALSE;
1016     ParseMode = ModeIgnore;
1017     break;
1018     case CSI:
1019     ClearParams();
1020     FirstPrm = TRUE;
1021     ParseMode = ModeCSI;
1022     break;
1023     case OSC:
1024     ClearParams();
1025     ParseMode = ModeXS;
1026     break;
1027     case PM:
1028     case APC:
1029     ESCFlag = FALSE;
1030     ParseMode = ModeIgnore;
1031     break;
1032     }
1033 maya 3227 }
1034    
1035     void SaveCursor()
1036     {
1037 doda 6802 int i;
1038     PStatusBuff Buff;
1039 maya 3227
1040 doda 6802 if (isCursorOnStatusLine)
1041     Buff = &SBuff2; // for status line
1042     else if (AltScr)
1043     Buff = &SBuff3; // for alternate screen
1044     else
1045     Buff = &SBuff1; // for main screen
1046 maya 3227
1047 doda 6802 Buff->CursorX = CursorX;
1048     Buff->CursorY = CursorY;
1049     Buff->Attr = CharAttr;
1050    
1051     Buff->Glr[0] = Glr[0];
1052     Buff->Glr[1] = Glr[1];
1053     for (i=0 ; i<=3; i++)
1054     Buff->Gn[i] = Gn[i];
1055    
1056     Buff->AutoWrapMode = AutoWrapMode;
1057     Buff->RelativeOrgMode = RelativeOrgMode;
1058 maya 3227 }
1059    
1060 doda 6802 void RestoreCursor()
1061 maya 3227 {
1062 doda 6802 int i;
1063     PStatusBuff Buff;
1064 maya 3227
1065 doda 6802 UpdateStr();
1066 maya 3227
1067 doda 6802 if (isCursorOnStatusLine)
1068     Buff = &SBuff2; // for status line
1069     else if (AltScr)
1070     Buff = &SBuff3; // for alternate screen
1071     else
1072     Buff = &SBuff1; // for main screen
1073    
1074     if (Buff->CursorX > NumOfColumns-1)
1075     Buff->CursorX = NumOfColumns-1;
1076     if (Buff->CursorY > NumOfLines-1-StatusLine)
1077     Buff->CursorY = NumOfLines-1-StatusLine;
1078     MoveCursor(Buff->CursorX, Buff->CursorY);
1079    
1080     CharAttr = Buff->Attr;
1081     BuffSetCurCharAttr(CharAttr);
1082    
1083     Glr[0] = Buff->Glr[0];
1084     Glr[1] = Buff->Glr[1];
1085     for (i=0 ; i<=3; i++)
1086     Gn[i] = Buff->Gn[i];
1087    
1088     AutoWrapMode = Buff->AutoWrapMode;
1089     RelativeOrgMode = Buff->RelativeOrgMode;
1090 maya 3227 }
1091    
1092     void AnswerTerminalType()
1093     {
1094 doda 6802 char Tmp[50];
1095 maya 3227
1096 doda 6802 if (ts.TerminalID<IdVT320 || !Send8BitMode)
1097     strncpy_s(Tmp, sizeof(Tmp),"\033[?", _TRUNCATE);
1098     else
1099     strncpy_s(Tmp, sizeof(Tmp),"\233?", _TRUNCATE);
1100 maya 3227
1101 doda 6802 switch (ts.TerminalID) {
1102     case IdVT100:
1103     strncat_s(Tmp,sizeof(Tmp),"1;2",_TRUNCATE);
1104     break;
1105     case IdVT100J:
1106     strncat_s(Tmp,sizeof(Tmp),"5;2",_TRUNCATE);
1107     break;
1108     case IdVT101:
1109     strncat_s(Tmp,sizeof(Tmp),"1;0",_TRUNCATE);
1110     break;
1111     case IdVT102:
1112     strncat_s(Tmp,sizeof(Tmp),"6",_TRUNCATE);
1113     break;
1114     case IdVT102J:
1115     strncat_s(Tmp,sizeof(Tmp),"15",_TRUNCATE);
1116     break;
1117     case IdVT220J:
1118     strncat_s(Tmp,sizeof(Tmp),"62;1;2;5;6;7;8",_TRUNCATE);
1119     break;
1120     case IdVT282:
1121     strncat_s(Tmp,sizeof(Tmp),"62;1;2;4;5;6;7;8;10;11",_TRUNCATE);
1122     break;
1123     case IdVT320:
1124     strncat_s(Tmp,sizeof(Tmp),"63;1;2;6;7;8",_TRUNCATE);
1125     break;
1126     case IdVT382:
1127     strncat_s(Tmp,sizeof(Tmp),"63;1;2;4;5;6;7;8;10;15",_TRUNCATE);
1128     break;
1129     case IdVT420:
1130     strncat_s(Tmp,sizeof(Tmp),"64;1;2;7;8;9;15;18;21",_TRUNCATE);
1131     break;
1132     case IdVT520:
1133     strncat_s(Tmp,sizeof(Tmp),"65;1;2;7;8;9;12;18;19;21;23;24;42;44;45;46",_TRUNCATE);
1134     break;
1135     case IdVT525:
1136     strncat_s(Tmp,sizeof(Tmp),"65;1;2;7;9;12;18;19;21;22;23;24;42;44;45;46",_TRUNCATE);
1137     break;
1138     }
1139     strncat_s(Tmp,sizeof(Tmp),"c",_TRUNCATE);
1140 maya 3227
1141 doda 6802 CommBinaryOut(&cv,Tmp,strlen(Tmp)); /* Report terminal ID */
1142 maya 3227 }
1143    
1144     void ESCSpace(BYTE b)
1145     {
1146 doda 6802 switch (b) {
1147     case 'F': // S7C1T
1148     Send8BitMode = FALSE;
1149     break;
1150     case 'G': // S8C1T
1151     if (VTlevel >= 2) {
1152     Send8BitMode = TRUE;
1153     }
1154     break;
1155     }
1156 maya 3227 }
1157    
1158     void ESCSharp(BYTE b)
1159     {
1160 doda 6802 switch (b) {
1161     case '8': /* Fill screen with "E" (DECALN) */
1162     BuffUpdateScroll();
1163     BuffFillWithE();
1164     CursorTop = 0;
1165     CursorBottom = NumOfLines-1-StatusLine;
1166     CursorLeftM = 0;
1167     CursorRightM = NumOfColumns - 1;
1168     MoveCursor(0, 0);
1169     ParseMode = ModeFirst;
1170     break;
1171     }
1172 maya 3227 }
1173    
1174     /* select double byte code set */
1175     void ESCDBCSSelect(BYTE b)
1176     {
1177 doda 6802 int Dist;
1178 maya 3227
1179 doda 6802 if (ts.Language!=IdJapanese) return;
1180 maya 3227
1181 doda 6802 switch (ICount) {
1182     case 1:
1183     if ((b=='@') || (b=='B'))
1184     {
1185     Gn[0] = IdKanji; /* Kanji -> G0 */
1186     if ((ts.TermFlag & TF_AUTOINVOKE)!=0)
1187     Glr[0] = 0; /* G0->GL */
1188     }
1189     break;
1190     case 2:
1191     /* Second intermediate char must be
1192     '(' or ')' or '*' or '+'. */
1193     Dist = (IntChar[2]-'(') & 3; /* G0 - G3 */
1194     if ((b=='1') || (b=='3') ||
1195     (b=='@') || (b=='B'))
1196     {
1197     Gn[Dist] = IdKanji; /* Kanji -> G0-3 */
1198     if (((ts.TermFlag & TF_AUTOINVOKE)!=0) &&
1199     (Dist==0))
1200     Glr[0] = 0; /* G0->GL */
1201     }
1202     break;
1203     }
1204 maya 3227 }
1205    
1206     void ESCSelectCode(BYTE b)
1207     {
1208 doda 6802 switch (b) {
1209     case '0':
1210     if (ts.AutoWinSwitch>0)
1211     ChangeEmu = IdTEK; /* enter TEK mode */
1212     break;
1213     }
1214 maya 3227 }
1215    
1216 doda 6802 /* select single byte code set */
1217 maya 3227 void ESCSBCSSelect(BYTE b)
1218     {
1219 doda 6802 int Dist;
1220 maya 3227
1221 doda 6802 /* Intermediate char must be '(' or ')' or '*' or '+'. */
1222     Dist = (IntChar[1]-'(') & 3; /* G0 - G3 */
1223 maya 3227
1224 doda 6802 switch (b) {
1225     case '0': Gn[Dist] = IdSpecial; break;
1226     case '<': Gn[Dist] = IdASCII; break;
1227     case '>': Gn[Dist] = IdASCII; break;
1228     case 'A': Gn[Dist] = IdASCII; break;
1229     case 'B': Gn[Dist] = IdASCII; break;
1230     case 'H': Gn[Dist] = IdASCII; break;
1231     case 'I':
1232     if (ts.Language==IdJapanese)
1233     Gn[Dist] = IdKatakana;
1234     break;
1235     case 'J': Gn[Dist] = IdASCII; break;
1236     }
1237 maya 3227
1238 doda 6802 if (((ts.TermFlag & TF_AUTOINVOKE)!=0) && (Dist==0))
1239     Glr[0] = 0; /* G0->GL */
1240 maya 3227 }
1241    
1242     void PrnParseEscape(BYTE b) // printer mode
1243     {
1244 doda 6802 int i;
1245 maya 3227
1246 doda 6802 ParseMode = ModeFirst;
1247     switch (ICount) {
1248     /* no intermediate char */
1249     case 0:
1250     switch (b) {
1251     case '[': /* CSI */
1252     ClearParams();
1253     FirstPrm = TRUE;
1254     WriteToPrnFile(ESC,FALSE);
1255     WriteToPrnFile('[',FALSE);
1256     ParseMode = ModeCSI;
1257     return;
1258     } /* end of case Icount=0 */
1259     break;
1260     /* one intermediate char */
1261     case 1:
1262     switch (IntChar[1]) {
1263     case '$':
1264     if (! DirectPrn) {
1265     ESCDBCSSelect(b);
1266     return;
1267     }
1268     break;
1269     case '(':
1270     case ')':
1271     case '*':
1272     case '+':
1273     if (! DirectPrn) {
1274     ESCSBCSSelect(b);
1275     return;
1276     }
1277     break;
1278     }
1279     break;
1280     /* two intermediate char */
1281     case 2:
1282     if ((! DirectPrn) &&
1283     (IntChar[1]=='$') &&
1284     ('('<=IntChar[2]) &&
1285     (IntChar[2]<='+'))
1286     {
1287     ESCDBCSSelect(b);
1288     return;
1289     }
1290     break;
1291     }
1292     // send the uninterpreted sequence to printer
1293     WriteToPrnFile(ESC,FALSE);
1294     for (i=1; i<=ICount; i++)
1295     WriteToPrnFile(IntChar[i],FALSE);
1296     WriteToPrnFile(b,TRUE);
1297 maya 3227 }
1298    
1299     void ParseEscape(BYTE b) /* b is the final char */
1300     {
1301 doda 6802 if (PrinterMode) { // printer mode
1302     PrnParseEscape(b);
1303     return;
1304     }
1305 maya 3227
1306 doda 6802 switch (ICount) {
1307     case 0: /* no intermediate char */
1308     switch (b) {
1309     case '6': // DECBI
1310     if (CursorY >= CursorTop && CursorY <= CursorBottom &&
1311     CursorX >= CursorLeftM && CursorX <= CursorRightM) {
1312     if (CursorX == CursorLeftM)
1313     BuffScrollRight(1);
1314     else
1315     MoveCursor(CursorX-1, CursorY);
1316     }
1317     break;
1318     case '7': SaveCursor(); break;
1319     case '8': RestoreCursor(); break;
1320     case '9': // DECFI
1321     if (CursorY >= CursorTop && CursorY <= CursorBottom &&
1322     CursorX >= CursorLeftM && CursorX <= CursorRightM) {
1323     if (CursorX == CursorRightM)
1324     BuffScrollLeft(1);
1325     else
1326     MoveCursor(CursorX+1, CursorY);
1327     }
1328     break;
1329     case '=': AppliKeyMode = TRUE; break;
1330     case '>': AppliKeyMode = FALSE; break;
1331     case 'D': /* IND */
1332     LineFeed(0,TRUE);
1333     break;
1334     case 'E': /* NEL */
1335     MoveCursor(0,CursorY);
1336     LineFeed(0,TRUE);
1337     break;
1338     case 'H': /* HTS */
1339     if (ts.TabStopFlag & TABF_HTS7)
1340     SetTabStop();
1341     break;
1342     case 'M': /* RI */
1343     CursorUpWithScroll();
1344     break;
1345     case 'N': /* SS2 */
1346     GLtmp = 2;
1347     SSflag = TRUE;
1348     break;
1349     case 'O': /* SS3 */
1350     GLtmp = 3;
1351     SSflag = TRUE;
1352     break;
1353     case 'P': /* DCS */
1354     ClearParams();
1355     ESCFlag = FALSE;
1356     ParseMode = ModeDCS;
1357     return;
1358     case 'X': /* SOS */
1359     case '^': /* APC */
1360     case '_': /* PM */
1361     ESCFlag = FALSE;
1362     ParseMode = ModeIgnore;
1363     return;
1364     case 'Z': /* DECID */
1365     AnswerTerminalType();
1366     break;
1367     case '[': /* CSI */
1368     ClearParams();
1369     FirstPrm = TRUE;
1370     ParseMode = ModeCSI;
1371     return;
1372     case '\\': break; /* ST */
1373     case ']': /* XTERM sequence (OSC) */
1374     ClearParams();
1375     ParseMode = ModeXS;
1376     return;
1377     case 'c': /* Hardware reset */
1378     HideStatusLine();
1379     ResetTerminal();
1380     ClearUserKey();
1381     ClearBuffer();
1382     if (ts.PortType==IdSerial) // reset serial port
1383     CommResetSerial(&ts, &cv, TRUE);
1384     break;
1385     case 'g': /* Visual Bell (screen original?) */
1386     RingBell(IdBeepVisual);
1387     break;
1388     case 'n': Glr[0] = 2; break; /* LS2 */
1389     case 'o': Glr[0] = 3; break; /* LS3 */
1390     case '|': Glr[1] = 3; break; /* LS3R */
1391     case '}': Glr[1] = 2; break; /* LS2R */
1392     case '~': Glr[1] = 1; break; /* LS1R */
1393     }
1394     break;
1395     /* end of case Icount=0 */
1396    
1397     case 1: /* one intermediate char */
1398     switch (IntChar[1]) {
1399     case ' ': ESCSpace(b); break;
1400     case '#': ESCSharp(b); break;
1401     case '$': ESCDBCSSelect(b); break;
1402     case '%': break;
1403     case '(':
1404     case ')':
1405     case '*':
1406     case '+':
1407     ESCSBCSSelect(b);
1408     break;
1409     }
1410     break;
1411    
1412     case 2: /* two intermediate char */
1413     if ((IntChar[1]=='$') && ('('<=IntChar[2]) && (IntChar[2]<='+'))
1414     ESCDBCSSelect(b);
1415     else if ((IntChar[1]=='%') && (IntChar[2]=='!'))
1416     ESCSelectCode(b);
1417     break;
1418     }
1419     ParseMode = ModeFirst;
1420 maya 3227 }
1421    
1422     void EscapeSequence(BYTE b)
1423     {
1424 doda 6173 if (b<=US)
1425     ParseControl(b);
1426     else if ((b>=0x20) && (b<=0x2F)) {
1427 doda 6174 // TODO: ICount �� IntCharMax ���B�������A������ IntChar ���u����������������?
1428 doda 6173 if (ICount<IntCharMax)
1429     ICount++;
1430     IntChar[ICount] = b;
1431     }
1432     else if ((b>=0x30) && (b<=0x7E))
1433     ParseEscape(b);
1434     else if ((b>=0x80) && (b<=0x9F))
1435     ParseControl(b);
1436     else if (b>=0xA0) {
1437     ParseMode=ModeFirst;
1438     ParseFirst(b);
1439     }
1440 maya 3227
1441 doda 6173 JustAfterESC = FALSE;
1442 maya 3227 }
1443    
1444 doda 6174 #define CheckParamVal(p,m) \
1445     if ((p) == 0) { \
1446     (p) = 1; \
1447     } \
1448     else if ((p) > (m) || p < 0) { \
1449     (p) = (m); \
1450     }
1451    
1452     #define CheckParamValMax(p,m) \
1453     if ((p) > (m) || p <= 0) { \
1454     (p) = (m); \
1455     }
1456    
1457     #define RequiredParams(n) \
1458     if ((n) > 1) { \
1459     while (NParam < n) { \
1460     NParam++; \
1461     Param[NParam] = 0; \
1462     NSParam[NParam] = 0; \
1463     } \
1464     }
1465    
1466 doda 6173 void CSInsertCharacter() // ICH
1467     {
1468     // Insert space characters at cursor
1469 doda 6174 CheckParamVal(Param[1], NumOfColumns);
1470 maya 3227
1471 doda 6173 BuffUpdateScroll();
1472 doda 6174 BuffInsertSpace(Param[1]);
1473 doda 6173 }
1474 maya 3227
1475 doda 5429 void CSCursorUp(BOOL AffectMargin) // CUU / VPB
1476     {
1477     int topMargin, NewY;
1478 maya 3227
1479 doda 6174 CheckParamVal(Param[1], CursorY);
1480 maya 3227
1481 doda 5429 if (AffectMargin && CursorY >= CursorTop)
1482     topMargin = CursorTop;
1483     else
1484     topMargin = 0;
1485 maya 3227
1486 doda 5429 NewY = CursorY - Param[1];
1487     if (NewY < topMargin)
1488     NewY = topMargin;
1489 maya 3227
1490 doda 5429 MoveCursor(CursorX, NewY);
1491     }
1492 maya 3227
1493 doda 5429 void CSCursorUp1() // CPL
1494     {
1495     MoveCursor(CursorLeftM, CursorY);
1496     CSCursorUp(TRUE);
1497     }
1498 maya 3227
1499 doda 5429 void CSCursorDown(BOOL AffectMargin) // CUD / VPR
1500     {
1501     int bottomMargin, NewY;
1502    
1503     if (AffectMargin && CursorY <= CursorBottom)
1504     bottomMargin = CursorBottom;
1505     else
1506     bottomMargin = NumOfLines-StatusLine-1;
1507    
1508 doda 6174 CheckParamVal(Param[1], bottomMargin);
1509    
1510 doda 5429 NewY = CursorY + Param[1];
1511     if (NewY > bottomMargin)
1512     NewY = bottomMargin;
1513    
1514     MoveCursor(CursorX, NewY);
1515     }
1516    
1517     void CSCursorDown1() // CNL
1518     {
1519     MoveCursor(CursorLeftM, CursorY);
1520     CSCursorDown(TRUE);
1521     }
1522    
1523 maya 3227 void CSScreenErase()
1524     {
1525     BuffUpdateScroll();
1526     switch (Param[1]) {
1527 doda 6173 case 0:
1528 maya 3227 // <ESC>[H(Cursor in left upper corner)�������J�[�\�������������w�������������A
1529     // <ESC>[J��<ESC>[2J�����������������A�����������A���s�o�b�t�@���X�N���[���A�E�g
1530     // �����������������B(2005.5.29 yutaka)
1531     // �R���t�B�O���[�V�������������������������������B(2008.5.3 yutaka)
1532 doda 6435 if (ts.ScrollWindowClearScreen &&
1533 maya 3227 (CursorX == 0 && CursorY == 0)) {
1534 doda 6173 // Erase screen (scroll out)
1535 maya 3227 BuffClearScreen();
1536     UpdateWindow(HVTWin);
1537    
1538     } else {
1539 doda 6173 // Erase characters from cursor to the end of screen
1540 maya 3227 BuffEraseCurToEnd();
1541     }
1542     break;
1543    
1544 doda 6173 case 1:
1545     // Erase characters from home to cursor
1546 maya 3227 BuffEraseHomeToCur();
1547     break;
1548    
1549 doda 6173 case 2:
1550     // Erase screen (scroll out)
1551 maya 3227 BuffClearScreen();
1552     UpdateWindow(HVTWin);
1553 doda 5564 if (ClearThenHome && !isCursorOnStatusLine) {
1554     if (RelativeOrgMode) {
1555     MoveCursor(0, 0);
1556     }
1557     else {
1558     MoveCursor(CursorLeftM, CursorTop);
1559     }
1560     }
1561 maya 3227 break;
1562     }
1563     }
1564    
1565 doda 4070 void CSQSelScreenErase()
1566     {
1567     BuffUpdateScroll();
1568     switch (Param[1]) {
1569 doda 6173 case 0:
1570     // Erase characters from cursor to end
1571 doda 4070 BuffSelectedEraseCurToEnd();
1572     break;
1573    
1574 doda 6173 case 1:
1575     // Erase characters from home to cursor
1576 doda 4070 BuffSelectedEraseHomeToCur();
1577     break;
1578    
1579 doda 6173 case 2:
1580     // Erase entire screen
1581 doda 4070 BuffSelectedEraseScreen();
1582     break;
1583     }
1584     }
1585    
1586 doda 6173 void CSInsertLine()
1587     {
1588     // Insert lines at current position
1589     int Count, YEnd;
1590 maya 3227
1591 doda 6174 if (CursorY < CursorTop || CursorY > CursorBottom) {
1592 doda 6173 return;
1593 doda 6174 }
1594 maya 3227
1595 doda 6174 CheckParamVal(Param[1], NumOfLines);
1596    
1597 doda 6173 Count = Param[1];
1598 maya 3227
1599 doda 6173 YEnd = CursorBottom;
1600     if (CursorY > YEnd)
1601     YEnd = NumOfLines-1-StatusLine;
1602 doda 6174
1603 doda 6173 if (Count > YEnd+1 - CursorY)
1604     Count = YEnd+1 - CursorY;
1605 maya 3227
1606 doda 6173 BuffInsertLines(Count,YEnd);
1607     }
1608 maya 3227
1609 doda 6173 void CSLineErase()
1610     {
1611     BuffUpdateScroll();
1612     switch (Param[1]) {
1613     case 0: /* erase char from cursor to end of line */
1614     BuffEraseCharsInLine(CursorX,NumOfColumns-CursorX);
1615     break;
1616 doda 4070
1617 doda 6173 case 1: /* erase char from start of line to cursor */
1618     BuffEraseCharsInLine(0,CursorX+1);
1619     break;
1620 maya 3227
1621 doda 6173 case 2: /* erase entire line */
1622     BuffEraseCharsInLine(0,NumOfColumns);
1623     break;
1624     }
1625     }
1626 maya 3227
1627 doda 6173 void CSQSelLineErase()
1628     {
1629     BuffUpdateScroll();
1630     switch (Param[1]) {
1631     case 0: /* erase char from cursor to end of line */
1632     BuffSelectedEraseCharsInLine(CursorX,NumOfColumns-CursorX);
1633     break;
1634 maya 3227
1635 doda 6173 case 1: /* erase char from start of line to cursor */
1636     BuffSelectedEraseCharsInLine(0,CursorX+1);
1637     break;
1638 maya 3227
1639 doda 6173 case 2: /* erase entire line */
1640     BuffSelectedEraseCharsInLine(0,NumOfColumns);
1641     break;
1642     }
1643     }
1644 maya 3227
1645 doda 6173 void CSDeleteNLines()
1646     // Delete lines from current line
1647     {
1648     int Count, YEnd;
1649 maya 3227
1650 doda 6174 if (CursorY < CursorTop || CursorY > CursorBottom) {
1651 doda 6173 return;
1652 doda 6174 }
1653    
1654     CheckParamVal(Param[1], NumOfLines);
1655 doda 6173 Count = Param[1];
1656 maya 3227
1657 doda 6173 YEnd = CursorBottom;
1658     if (CursorY > YEnd)
1659     YEnd = NumOfLines-1-StatusLine;
1660 doda 6174
1661 doda 6173 if (Count > YEnd+1-CursorY)
1662     Count = YEnd+1-CursorY;
1663 doda 6174
1664 doda 6173 BuffDeleteLines(Count,YEnd);
1665     }
1666 maya 3227
1667 doda 6173 void CSDeleteCharacter() // DCH
1668     {
1669     // Delete characters in current line from cursor
1670 doda 6174 CheckParamVal(Param[1], NumOfColumns);
1671 maya 3227
1672 doda 6173 BuffUpdateScroll();
1673     BuffDeleteChars(Param[1]);
1674     }
1675 maya 3227
1676 doda 6173 void CSEraseCharacter() // ECH
1677     {
1678 doda 6174 CheckParamVal(Param[1], NumOfColumns);
1679    
1680 doda 6173 BuffUpdateScroll();
1681     BuffEraseChars(Param[1]);
1682     }
1683    
1684     void CSScrollUp()
1685     {
1686 doda 6174 // TODO: �X�N���[���������l���[���s�����������������v����
1687     CheckParamVal(Param[1], INT_MAX);
1688    
1689 doda 6173 BuffUpdateScroll();
1690     BuffRegionScrollUpNLines(Param[1]);
1691     }
1692    
1693     void CSScrollDown()
1694     {
1695 doda 6174 CheckParamVal(Param[1], NumOfLines);
1696    
1697 doda 6173 BuffUpdateScroll();
1698     BuffRegionScrollDownNLines(Param[1]);
1699     }
1700    
1701     void CSForwardTab()
1702     {
1703 doda 6174 CheckParamVal(Param[1], NumOfColumns);
1704 doda 6173 CursorForwardTab(Param[1], AutoWrapMode);
1705     }
1706    
1707     void CSBackwardTab()
1708     {
1709 doda 6174 CheckParamVal(Param[1], NumOfColumns);
1710 doda 6173 CursorBackwardTab(Param[1]);
1711     }
1712    
1713 doda 5324 void CSMoveToColumnN() // CHA / HPA
1714     {
1715 doda 6174 CheckParamVal(Param[1], NumOfColumns);
1716 maya 3227
1717 doda 5324 Param[1]--;
1718 maya 3227
1719 doda 5324 if (RelativeOrgMode) {
1720     if (CursorLeftM + Param[1] > CursorRightM )
1721     MoveCursor(CursorRightM, CursorY);
1722     else
1723     MoveCursor(CursorLeftM + Param[1], CursorY);
1724     }
1725     else {
1726     MoveCursor(Param[1], CursorY);
1727     }
1728     }
1729 maya 3227
1730 doda 5429 void CSCursorRight(BOOL AffectMargin) // CUF / HPR
1731 doda 5324 {
1732 doda 5429 int NewX, rightMargin;
1733 doda 5324
1734 doda 6174 CheckParamVal(Param[1], NumOfColumns);
1735 doda 5324
1736 doda 6174 if (AffectMargin && CursorX <= CursorRightM) {
1737 doda 5429 rightMargin = CursorRightM;
1738 doda 6174 }
1739     else {
1740 doda 5429 rightMargin = NumOfColumns-1;
1741 doda 6174 }
1742 doda 5429
1743 doda 5324 NewX = CursorX + Param[1];
1744 doda 5429 if (NewX > rightMargin)
1745     NewX = rightMargin;
1746 doda 5324
1747     MoveCursor(NewX, CursorY);
1748     }
1749    
1750 doda 5429 void CSCursorLeft(BOOL AffectMargin) // CUB / HPB
1751 doda 5324 {
1752 doda 5429 int NewX, leftMargin;
1753 doda 5324
1754 doda 6174 CheckParamVal(Param[1], NumOfColumns);
1755 doda 5324
1756 doda 6174 if (AffectMargin && CursorX >= CursorLeftM) {
1757 doda 5429 leftMargin = CursorLeftM;
1758 doda 6174 }
1759     else {
1760 doda 5429 leftMargin = 0;
1761 doda 6174 }
1762 doda 5324
1763 doda 5429 NewX = CursorX - Param[1];
1764 doda 6174 if (NewX < leftMargin) {
1765 doda 5429 NewX = leftMargin;
1766 doda 6174 }
1767 doda 5324
1768     MoveCursor(NewX, CursorY);
1769     }
1770    
1771 doda 6174 void CSMoveToLineN() // VPA
1772 doda 6173 {
1773 doda 6174 CheckParamVal(Param[1], NumOfLines-StatusLine);
1774    
1775 doda 6173 if (RelativeOrgMode) {
1776     if (CursorTop+Param[1]-1 > CursorBottom)
1777     MoveCursor(CursorX,CursorBottom);
1778     else
1779     MoveCursor(CursorX,CursorTop+Param[1]-1);
1780     }
1781     else {
1782     if (Param[1] > NumOfLines-StatusLine)
1783     MoveCursor(CursorX,NumOfLines-1-StatusLine);
1784     else
1785     MoveCursor(CursorX,Param[1]-1);
1786     }
1787 doda 6602 Fallbacked = FALSE;
1788 doda 6173 }
1789 maya 3227
1790 doda 5324 void CSMoveToXY() // CUP / HVP
1791     {
1792     int NewX, NewY;
1793 maya 3227
1794 doda 6174 RequiredParams(2);
1795     CheckParamVal(Param[1], NumOfLines-StatusLine);
1796     CheckParamVal(Param[2], NumOfColumns);
1797 maya 3227
1798 doda 5324 NewY = Param[1] - 1;
1799     NewX = Param[2] - 1;
1800    
1801     if (isCursorOnStatusLine)
1802     NewY = CursorY;
1803     else if (RelativeOrgMode) {
1804     NewX += CursorLeftM;
1805     if (NewX > CursorRightM)
1806     NewX = CursorRightM;
1807    
1808     NewY += CursorTop;
1809     if (NewY > CursorBottom)
1810     NewY = CursorBottom;
1811     }
1812     else {
1813     if (NewY > NumOfLines-1-StatusLine)
1814     NewY = NumOfLines-1-StatusLine;
1815     }
1816    
1817     MoveCursor(NewX, NewY);
1818 doda 6602 Fallbacked = FALSE;
1819 doda 5324 }
1820    
1821 doda 6173 void CSDeleteTabStop()
1822     {
1823     ClearTabStop(Param[1]);
1824     }
1825 maya 3227
1826 doda 6173 void CS_h_Mode() // SM
1827     {
1828     switch (Param[1]) {
1829     case 2: // KAM
1830     KeybEnabled = FALSE; break;
1831     case 4: // IRM
1832     InsertMode = TRUE; break;
1833     case 12: // SRM
1834     ts.LocalEcho = 0;
1835     if (cv.Ready && cv.TelFlag && (ts.TelEcho>0))
1836     TelChangeEcho();
1837     break;
1838     case 20: // LF/NL
1839     LFMode = TRUE;
1840     ts.CRSend = IdCRLF;
1841     cv.CRSend = IdCRLF;
1842     break;
1843     case 33: // WYSTCURM
1844     if (ts.WindowFlag & WF_CURSORCHANGE) {
1845     ts.NonblinkingCursor = TRUE;
1846     ChangeCaret();
1847     }
1848     break;
1849     case 34: // WYULCURM
1850     if (ts.WindowFlag & WF_CURSORCHANGE) {
1851     ts.CursorShape = IdHCur;
1852     ChangeCaret();
1853     }
1854     break;
1855     }
1856     }
1857 maya 3227
1858 doda 6173 void CS_i_Mode() // MC
1859     {
1860     switch (Param[1]) {
1861     /* print screen */
1862     // PrintEX -- TRUE: print screen
1863     // FALSE: scroll region
1864     case 0:
1865     if (ts.TermFlag&TF_PRINTERCTRL) {
1866     BuffPrint(! PrintEX);
1867     }
1868     break;
1869     /* printer controller mode off */
1870     case 4: break; /* See PrnParseCS() */
1871     /* printer controller mode on */
1872     case 5:
1873     if (ts.TermFlag&TF_PRINTERCTRL) {
1874     if (! AutoPrintMode)
1875     OpenPrnFile();
1876     DirectPrn = (ts.PrnDev[0]!=0);
1877     PrinterMode = TRUE;
1878     }
1879     break;
1880 doda 4397 }
1881 doda 6173 }
1882    
1883     void CS_l_Mode() // RM
1884     {
1885     switch (Param[1]) {
1886     case 2: // KAM
1887     KeybEnabled = TRUE; break;
1888     case 4: // IRM
1889     InsertMode = FALSE; break;
1890     case 12: // SRM
1891     ts.LocalEcho = 1;
1892     if (cv.Ready && cv.TelFlag && (ts.TelEcho>0))
1893     TelChangeEcho();
1894     break;
1895     case 20: // LF/NL
1896     LFMode = FALSE;
1897     ts.CRSend = IdCR;
1898     cv.CRSend = IdCR;
1899     break;
1900     case 33: // WYSTCURM
1901     if (ts.WindowFlag & WF_CURSORCHANGE) {
1902     ts.NonblinkingCursor = FALSE;
1903     ChangeCaret();
1904     }
1905     break;
1906     case 34: // WYULCURM
1907     if (ts.WindowFlag & WF_CURSORCHANGE) {
1908     ts.CursorShape = IdBlkCur;
1909     ChangeCaret();
1910     }
1911     break;
1912 doda 4397 }
1913 doda 6173 }
1914 maya 3227
1915 doda 6173 void CS_n_Mode() // DSR
1916     {
1917     char Report[16];
1918     int X, Y, len;
1919 maya 3227
1920 doda 6173 switch (Param[1]) {
1921     case 5:
1922     /* Device Status Report -> Ready */
1923     SendCSIstr("0n", 0);
1924     break;
1925     case 6:
1926     /* Cursor Position Report */
1927     if (isCursorOnStatusLine) {
1928     X = CursorX + 1;
1929     Y = 1;
1930     }
1931     else if (RelativeOrgMode) {
1932     X = CursorX - CursorLeftM + 1;
1933     Y = CursorY - CursorTop + 1;
1934     }
1935     else {
1936     X = CursorX + 1;
1937     Y = CursorY+1;
1938     }
1939     len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "%u;%uR", CLocale, Y, X);
1940     SendCSIstr(Report, len);
1941     break;
1942 doda 5336 }
1943 doda 6173 }
1944 maya 3227
1945 doda 5095 void ParseSGRParams(PCharAttr attr, PCharAttr mask, int start)
1946 maya 3227 {
1947 doda 5073 int i, j, P, r, g, b, color;
1948 doda 5095 TCharAttr dummy;
1949 maya 3227
1950 doda 5095 if (mask == NULL) {
1951     mask = &dummy;
1952     }
1953    
1954 doda 6173 for (i=start ; i<=NParam ; i++) {
1955 maya 3227 P = Param[i];
1956     switch (P) {
1957 doda 6173 case 0: /* Clear all */
1958 doda 5095 attr->Attr = DefCharAttr.Attr;
1959     attr->Attr2 = DefCharAttr.Attr2 | (attr->Attr2&Attr2Protect);
1960     attr->Fore = DefCharAttr.Fore;
1961     attr->Back = DefCharAttr.Back;
1962     mask->Attr = AttrSgrMask;
1963     mask->Attr2 = Attr2ColorMask;
1964 maya 3227 break;
1965    
1966 doda 6173 case 1: /* Bold */
1967 doda 5095 attr->Attr |= AttrBold;
1968     mask->Attr |= AttrBold;
1969 maya 3227 break;
1970    
1971 doda 6173 case 4: /* Under line */
1972 doda 5095 attr->Attr |= AttrUnder;
1973     mask->Attr |= AttrUnder;
1974 maya 3227 break;
1975    
1976 doda 6173 case 5: /* Blink */
1977 doda 5095 attr->Attr |= AttrBlink;
1978     mask->Attr |= AttrBlink;
1979 maya 3227 break;
1980    
1981 doda 6173 case 7: /* Reverse */
1982 doda 5095 attr->Attr |= AttrReverse;
1983     mask->Attr |= AttrReverse;
1984 maya 3227 break;
1985    
1986 doda 6173 case 22: /* Bold off */
1987 doda 5095 attr->Attr &= ~ AttrBold;
1988     mask->Attr |= AttrBold;
1989 maya 3227 break;
1990    
1991 doda 6173 case 24: /* Under line off */
1992 doda 5095 attr->Attr &= ~ AttrUnder;
1993     mask->Attr |= AttrUnder;
1994 maya 3227 break;
1995    
1996 doda 6173 case 25: /* Blink off */
1997 doda 5095 attr->Attr &= ~ AttrBlink;
1998     mask->Attr |= AttrBlink;
1999 maya 3227 break;
2000    
2001 doda 6173 case 27: /* Reverse off */
2002 doda 5095 attr->Attr &= ~ AttrReverse;
2003     mask->Attr |= AttrReverse;
2004 maya 3227 break;
2005    
2006 doda 6173 case 30:
2007     case 31:
2008     case 32:
2009     case 33:
2010     case 34:
2011     case 35:
2012     case 36:
2013     case 37: /* text color */
2014 doda 5095 attr->Attr2 |= Attr2Fore;
2015     mask->Attr2 |= Attr2Fore;
2016     attr->Fore = P - 30;
2017 maya 3227 break;
2018    
2019 doda 6173 case 38: /* text color (256color mode) */
2020 doda 5073 if (ts.ColorFlag & CF_XTERM256) {
2021     /*
2022     * Change foreground color. accept following formats.
2023     *
2024     * 38 ; 2 ; r ; g ; b
2025     * 38 ; 2 : r : g : b
2026     * 38 : 2 : r : g : b
2027     * 38 ; 5 ; idx
2028     * 38 ; 5 : idx
2029     * 38 : 5 : idx
2030     *
2031     */
2032     color = -1;
2033     j = 0;
2034     if (NSParam[i] > 0) {
2035     P = SubParam[i][1];
2036     j++;
2037     }
2038     else if (i < NParam) {
2039     P = Param[i+1];
2040     if (P == 2 || P == 5) {
2041     i++;
2042     }
2043     }
2044     switch (P) {
2045 doda 6173 case 2:
2046 doda 5073 r = g = b = 0;
2047     if (NSParam[i] > 0) {
2048     if (j < NSParam[i]) {
2049     r = SubParam[i][++j];
2050     if (j < NSParam[i]) {
2051     g = SubParam[i][++j];
2052     }
2053     if (j < NSParam[i]) {
2054     b = SubParam[i][++j];
2055     }
2056     color = DispFindClosestColor(r, g, b);
2057     }
2058     }
2059     else if (i < NParam && NSParam[i+1] > 0) {
2060     r = Param[++i];
2061     g = SubParam[i][1];
2062     if (NSParam[i] > 1) {
2063     b = SubParam[i][2];
2064     }
2065     color = DispFindClosestColor(r, g, b);
2066     }
2067     else if (i+2 < NParam) {
2068     r = Param[++i];
2069     g = Param[++i];
2070     b = Param[++i];
2071     color = DispFindClosestColor(r, g, b);
2072     }
2073     break;
2074 doda 6173 case 5:
2075 doda 5073 if (NSParam[i] > 0) {
2076     if (j < NSParam[i]) {
2077     color = SubParam[i][++j];
2078     }
2079     }
2080     else if (i < NParam) {
2081     color = Param[++i];
2082     }
2083     break;
2084     }
2085 doda 5077 if (color >= 0 && color < 256) {
2086 doda 5095 attr->Attr2 |= Attr2Fore;
2087     mask->Attr2 |= Attr2Fore;
2088     attr->Fore = color;
2089 maya 3227 }
2090     }
2091     break;
2092    
2093 doda 6173 case 39: /* Reset text color */
2094 doda 5095 attr->Attr2 &= ~ Attr2Fore;
2095     mask->Attr2 |= Attr2Fore;
2096     attr->Fore = AttrDefaultFG;
2097 maya 3227 break;
2098    
2099 doda 6173 case 40:
2100     case 41:
2101     case 42:
2102     case 43:
2103     case 44:
2104     case 45:
2105     case 46:
2106     case 47: /* Back color */
2107 doda 5095 attr->Attr2 |= Attr2Back;
2108     mask->Attr2 |= Attr2Back;
2109     attr->Back = P - 40;
2110 maya 3227 break;
2111    
2112 doda 6173 case 48: /* Back color (256color mode) */
2113 doda 5073 if (ts.ColorFlag & CF_XTERM256) {
2114     color = -1;
2115     j = 0;
2116     if (NSParam[i] > 0) {
2117     P = SubParam[i][1];
2118     j++;
2119     }
2120     else if (i < NParam) {
2121     P = Param[i+1];
2122     if (P == 2 || P == 5) {
2123     i++;
2124     }
2125     }
2126     switch (P) {
2127 doda 6173 case 2:
2128 doda 5073 r = g = b = 0;
2129     if (NSParam[i] > 0) {
2130     if (j < NSParam[i]) {
2131     r = SubParam[i][++j];
2132     if (j < NSParam[i]) {
2133     g = SubParam[i][++j];
2134     }
2135     if (j < NSParam[i]) {
2136     b = SubParam[i][++j];
2137     }
2138     color = DispFindClosestColor(r, g, b);
2139     }
2140     }
2141     else if (i < NParam && NSParam[i+1] > 0) {
2142     r = Param[++i];
2143     g = SubParam[i][1];
2144     if (NSParam[i] > 1) {
2145     b = SubParam[i][2];
2146     }
2147     color = DispFindClosestColor(r, g, b);
2148     }
2149     else if (i+2 < NParam) {
2150     r = Param[++i];
2151     g = Param[++i];
2152     b = Param[++i];
2153     color = DispFindClosestColor(r, g, b);
2154     }
2155     break;
2156 doda 6173 case 5:
2157 doda 5073 if (NSParam[i] > 0) {
2158     if (j < NSParam[i]) {
2159     color = SubParam[i][++j];
2160     }
2161     }
2162     else if (i < NParam) {
2163     color = Param[++i];
2164     }
2165     break;
2166     }
2167 doda 5077 if (color >= 0 && color < 256) {
2168 doda 5095 attr->Attr2 |= Attr2Back;
2169     mask->Attr2 |= Attr2Back;
2170     attr->Back = color;
2171 maya 3227 }
2172     }
2173     break;
2174    
2175 doda 6173 case 49: /* Reset back color */
2176 doda 5095 attr->Attr2 &= ~ Attr2Back;
2177     mask->Attr2 |= Attr2Back;
2178     attr->Back = AttrDefaultBG;
2179 maya 3227 break;
2180    
2181 doda 6173 case 90:
2182     case 91:
2183     case 92:
2184     case 93:
2185     case 94:
2186     case 95:
2187     case 96:
2188     case 97: /* aixterm style text color */
2189 maya 3227 if (ts.ColorFlag & CF_AIXTERM16) {
2190 doda 5095 attr->Attr2 |= Attr2Fore;
2191     mask->Attr2 |= Attr2Fore;
2192     attr->Fore = P - 90 + 8;
2193 maya 3227 }
2194     break;
2195    
2196 doda 6173 case 100:
2197 maya 3227 if (! (ts.ColorFlag & CF_AIXTERM16)) {
2198     /* Reset text and back color */
2199 doda 5095 attr->Attr2 &= ~ (Attr2Fore | Attr2Back);
2200     mask->Attr2 |= Attr2ColorMask;
2201     attr->Fore = AttrDefaultFG;
2202     attr->Back = AttrDefaultBG;
2203 maya 3227 break;
2204     }
2205     /* fall through to aixterm style back color */
2206    
2207 doda 6173 case 101:
2208     case 102:
2209     case 103:
2210     case 104:
2211     case 105:
2212     case 106:
2213     case 107: /* aixterm style back color */
2214 maya 3227 if (ts.ColorFlag & CF_AIXTERM16) {
2215 doda 5095 attr->Attr2 |= Attr2Back;
2216     mask->Attr2 |= Attr2Back;
2217     attr->Back = P - 100 + 8;
2218 maya 3227 }
2219     break;
2220     }
2221     }
2222     }
2223    
2224 doda 5095 void CSSetAttr() // SGR
2225     {
2226     UpdateStr();
2227     ParseSGRParams(&CharAttr, NULL, 1);
2228     BuffSetCurCharAttr(CharAttr);
2229     }
2230    
2231 doda 6173 void CSSetScrollRegion() // DECSTBM
2232     {
2233     if (isCursorOnStatusLine) {
2234     MoveCursor(0,CursorY);
2235     return;
2236     }
2237 doda 6174
2238     RequiredParams(2);
2239     CheckParamVal(Param[1], NumOfLines-StatusLine);
2240     CheckParamValMax(Param[2], NumOfLines-StatusLine);
2241    
2242     if (Param[1] >= Param[2])
2243     return;
2244    
2245     CursorTop = Param[1] - 1;
2246     CursorBottom = Param[2] - 1;
2247    
2248     if (RelativeOrgMode)
2249     // TODO: ���}�[�W���������������B�v���@�m�F�B
2250     MoveCursor(0, CursorTop);
2251     else
2252     MoveCursor(0, 0);
2253 doda 6173 }
2254 maya 3227
2255 doda 5502 void CSSetLRScrollRegion() // DECSLRM
2256 doda 5324 {
2257 doda 6174 // TODO: �X�e�[�^�X���C�������������m�F�B
2258 doda 5324 // if (isCursorOnStatusLine) {
2259     // MoveCursor(0,CursorY);
2260     // return;
2261     // }
2262    
2263 doda 6174 RequiredParams(2);
2264     CheckParamVal(Param[1], NumOfColumns);
2265     CheckParamValMax(Param[2], NumOfColumns);
2266 doda 5324
2267     if (Param[1] >= Param[2])
2268     return;
2269    
2270 doda 6174 CursorLeftM = Param[1] - 1;
2271     CursorRightM = Param[2] - 1;
2272 doda 5324
2273     if (RelativeOrgMode)
2274     MoveCursor(CursorLeftM, CursorTop);
2275     else
2276     MoveCursor(0, 0);
2277     }
2278    
2279 doda 6173 void CSSunSequence() /* Sun terminal private sequences */
2280     {
2281     int x, y, len;
2282     char Report[TitleBuffSize*2+10];
2283     PTStack t;
2284 maya 3227
2285 doda 6173 switch (Param[1]) {
2286     case 1: // De-iconify window
2287     if (ts.WindowFlag & WF_WINDOWCHANGE)
2288     DispShowWindow(WINDOW_RESTORE);
2289     break;
2290 doda 6174
2291 doda 6173 case 2: // Iconify window
2292     if (ts.WindowFlag & WF_WINDOWCHANGE)
2293     DispShowWindow(WINDOW_MINIMIZE);
2294     break;
2295 doda 6174
2296 doda 6173 case 3: // set window position
2297     if (ts.WindowFlag & WF_WINDOWCHANGE) {
2298 doda 6174 RequiredParams(3);
2299 doda 6173 DispMoveWindow(Param[2], Param[3]);
2300     }
2301     break;
2302 doda 6174
2303 doda 6173 case 4: // set window size
2304     if (ts.WindowFlag & WF_WINDOWCHANGE) {
2305 doda 6174 RequiredParams(3);
2306 doda 6173 DispResizeWin(Param[3], Param[2]);
2307     }
2308     break;
2309 doda 6174
2310 doda 6173 case 5: // Raise window
2311     if (ts.WindowFlag & WF_WINDOWCHANGE)
2312     DispShowWindow(WINDOW_RAISE);
2313     break;
2314 doda 6174
2315 doda 6173 case 6: // Lower window
2316     if (ts.WindowFlag & WF_WINDOWCHANGE)
2317     DispShowWindow(WINDOW_LOWER);
2318     break;
2319 doda 6174
2320 doda 6173 case 7: // Refresh window
2321     if (ts.WindowFlag & WF_WINDOWCHANGE)
2322     DispShowWindow(WINDOW_REFRESH);
2323     break;
2324 doda 6174
2325 doda 6173 case 8: /* set terminal size */
2326     if (ts.WindowFlag & WF_WINDOWCHANGE) {
2327 doda 6174 RequiredParams(3);
2328     if (Param[2] <= 1) Param[2] = 24;
2329     if (Param[3] <= 1) Param[3] = 80;
2330     ChangeTerminalSize(Param[3], Param[2]);
2331 doda 6173 }
2332     break;
2333 doda 6174
2334 doda 6173 case 9: // Maximize/Restore window
2335     if (ts.WindowFlag & WF_WINDOWCHANGE) {
2336 doda 6174 RequiredParams(2);
2337     if (Param[2] == 0) {
2338 doda 6173 DispShowWindow(WINDOW_RESTORE);
2339     }
2340     else if (Param[2] == 1) {
2341     DispShowWindow(WINDOW_MAXIMIZE);
2342     }
2343     }
2344     break;
2345 doda 6174
2346 doda 6173 case 11: // Report window state
2347     if (ts.WindowFlag & WF_WINDOWREPORT) {
2348     len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "%dt", CLocale, DispWindowIconified()?2:1);
2349     SendCSIstr(Report, len);
2350     }
2351     break;
2352 doda 6174
2353 doda 6173 case 13: // Report window position
2354     if (ts.WindowFlag & WF_WINDOWREPORT) {
2355     DispGetWindowPos(&x, &y);
2356     len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "3;%u;%ut", CLocale, (unsigned int)x, (unsigned int)y);
2357     SendCSIstr(Report, len);
2358     }
2359     break;
2360 doda 6174
2361 doda 6173 case 14: /* get window size */
2362     if (ts.WindowFlag & WF_WINDOWREPORT) {
2363     DispGetWindowSize(&x, &y);
2364     len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "4;%d;%dt", CLocale, y, x);
2365     SendCSIstr(Report, len);
2366     }
2367     break;
2368 doda 6174
2369 doda 6173 case 18: /* get terminal size */
2370     if (ts.WindowFlag & WF_WINDOWREPORT) {
2371     len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "8;%u;%ut", CLocale,
2372     NumOfLines-StatusLine, NumOfColumns);
2373     SendCSIstr(Report, len);
2374     }
2375     break;
2376 doda 6174
2377 doda 6173 case 19: // Report display size (character)
2378     if (ts.WindowFlag & WF_WINDOWREPORT) {
2379     DispGetRootWinSize(&x, &y);
2380     len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "9;%d;%dt", CLocale, y, x);
2381     SendCSIstr(Report, len);
2382     }
2383     break;
2384 doda 6174
2385 doda 6173 case 20: // Report icon label
2386     switch (ts.WindowFlag & WF_TITLEREPORT) {
2387     case IdTitleReportIgnore:
2388     // nothing to do
2389     break;
2390 doda 6174
2391 doda 6173 case IdTitleReportAccept:
2392     switch (ts.AcceptTitleChangeRequest) {
2393     case IdTitleChangeRequestOff:
2394     len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s", CLocale, ts.Title);
2395     break;
2396 doda 6174
2397 doda 6173 case IdTitleChangeRequestAhead:
2398     len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s %s", CLocale, cv.TitleRemote, ts.Title);
2399     break;
2400 doda 6174
2401 doda 6173 case IdTitleChangeRequestLast:
2402     len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s %s", CLocale, ts.Title, cv.TitleRemote);
2403     break;
2404 doda 6174
2405 doda 6173 default:
2406     if (cv.TitleRemote[0] == 0) {
2407     len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s", CLocale, ts.Title);
2408     }
2409     else {
2410     len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "L%s", CLocale, cv.TitleRemote);
2411     }
2412     }
2413     SendOSCstr(Report, len, ST);
2414     break;
2415 doda 6174
2416 doda 6173 default: // IdTitleReportEmpty:
2417     SendOSCstr("L", 0, ST);
2418     break;
2419     }
2420     break;
2421 doda 6174
2422 doda 6173 case 21: // Report window title
2423     switch (ts.WindowFlag & WF_TITLEREPORT) {
2424     case IdTitleReportIgnore:
2425     // nothing to do
2426     break;
2427 doda 6174
2428 doda 6173 case IdTitleReportAccept:
2429     switch (ts.AcceptTitleChangeRequest) {
2430     case IdTitleChangeRequestOff:
2431     len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s", CLocale, ts.Title);
2432     break;
2433 doda 6174
2434 doda 6173 case IdTitleChangeRequestAhead:
2435     len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s %s", CLocale, cv.TitleRemote, ts.Title);
2436     break;
2437 doda 6174
2438 doda 6173 case IdTitleChangeRequestLast:
2439     len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s %s", CLocale, ts.Title, cv.TitleRemote);
2440     break;
2441 doda 6174
2442 doda 6173 default:
2443     if (cv.TitleRemote[0] == 0) {
2444     len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s", CLocale, ts.Title);
2445     }
2446     else {
2447     len = _snprintf_s_l(Report, sizeof(Report), _TRUNCATE, "l%s", CLocale, cv.TitleRemote);
2448     }
2449     }
2450     SendOSCstr(Report, len, ST);
2451     break;
2452 doda 6174
2453 doda 6173 default: // IdTitleReportEmpty:
2454     SendOSCstr("l", 0, ST);
2455     break;
2456     }
2457     break;
2458 doda 6174
2459 doda