Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/trunk/teraterm/ttpcmn/ttcmn.c

Annotation of /trunk/teraterm/ttpcmn/ttcmn.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 6286 - (hide annotations) (download) (as text)
Mon Feb 1 15:14:14 2016 UTC (8 years, 2 months ago) by yutakapon
File MIME type: text/x-csrc
File size: 55591 byte(s) 
チケット #35744 VS2015の警告除去

下記ブランチからマージした。
svn+ssh://yutakapon@svn.sourceforge.jp/svnroot/ttssh2/branches/vs2015_warn
リビジョン6194 - 6260
1 maya 3227 /* Tera Term
2     Copyright(C) 1994-1998 T. Teranishi
3     All rights reserved. */
4    
5     /* TTCMN.DLL, main */
6     #include "teraterm.h"
7     #include "tttypes.h"
8     #include <direct.h>
9     #include <string.h>
10     #include "ttftypes.h"
11     #include "ttlib.h"
12     #include "language.h"
13     #include <stdio.h>
14     #include <windows.h>
15     #include <tchar.h>
16     #include <setupapi.h>
17 doda 3462 #include <locale.h>
18 maya 5308 #include <htmlhelp.h>
19 maya 3227
20     #include "compat_w95.h"
21 yutakapon 4915 #include "tt_res.h"
22 maya 3227
23     /* first instance flag */
24     static BOOL FirstInstance = TRUE;
25    
26     static HINSTANCE hInst;
27    
28     static PMap pm;
29    
30     static HANDLE HMap = NULL;
31     #define VTCLASSNAME "VTWin32"
32     #define TEKCLASSNAME "TEKWin32"
33    
34    
35 yutakapon 5299 enum window_style {
36     WIN_CASCADE,
37     WIN_STACKED,
38     WIN_SIDEBYSIDE,
39     };
40    
41    
42 maya 3227 void PASCAL CopyShmemToTTSet(PTTSet ts)
43     {
44     // 現在の設定を共有メモリからコピーする
45     memcpy(ts, &pm->ts, sizeof(TTTSet));
46     }
47    
48     void PASCAL CopyTTSetToShmem(PTTSet ts)
49     {
50     // 現在の設定を共有メモリへコピーする
51     memcpy(&pm->ts, ts, sizeof(TTTSet));
52     }
53    
54    
55     BOOL PASCAL FAR StartTeraTerm(PTTSet ts)
56     {
57 maya 4031 char Temp[MAX_PATH];
58 maya 3227
59     if (FirstInstance) {
60     // init window list
61     pm->NWin = 0;
62     }
63     else {
64     /* only the first instance uses saved position */
65     pm->ts.VTPos.x = CW_USEDEFAULT;
66     pm->ts.VTPos.y = CW_USEDEFAULT;
67     pm->ts.TEKPos.x = CW_USEDEFAULT;
68     pm->ts.TEKPos.y = CW_USEDEFAULT;
69     }
70    
71     memcpy(ts,&(pm->ts),sizeof(TTTSet));
72    
73     // if (FirstInstance) { の部分から移動 (2008.3.13 maya)
74     // 起動時には、共有メモリの HomeDir と SetupFName は空になる
75     /* Get home directory */
76 maya 3623 if (GetModuleFileName(hInst,Temp,sizeof(Temp)) == 0) {
77     return TRUE;
78     }
79 maya 3227 ExtractDirName(Temp, ts->HomeDir);
80     _chdir(ts->HomeDir);
81     GetDefaultSetupFName(ts->HomeDir, ts->SetupFName, sizeof(ts->SetupFName));
82    
83 maya 5877 strncpy_s(ts->KeyCnfFN, sizeof(ts->KeyCnfFN), ts->HomeDir, _TRUNCATE);
84     AppendSlash(ts->KeyCnfFN, sizeof(ts->KeyCnfFN));
85     strncat_s(ts->KeyCnfFN, sizeof(ts->KeyCnfFN), "KEYBOARD.CNF", _TRUNCATE);
86    
87 maya 3227 if (FirstInstance) {
88     FirstInstance = FALSE;
89     return TRUE;
90     }
91 maya 3392 else {
92 maya 3227 return FALSE;
93 maya 3392 }
94 maya 3227 }
95    
96 yutakapon 4915 // 設定ファイルをディスクに保存し、Tera Term本体を再起動する。
97     // (2012.4.30 yutaka)
98     void PASCAL FAR RestartTeraTerm(HWND hwnd, PTTSet ts)
99     {
100     char path[1024];
101     STARTUPINFO si;
102     PROCESS_INFORMATION pi;
103 yutakapon 4916 char uimsg[MAX_UIMSG];
104     int ret;
105 yutakapon 4915
106 yutakapon 4916 get_lang_msg("MSG_TT_TAKE_EFFECT", uimsg, sizeof(uimsg),
107     "This option takes effect the next time a session is started.\n"
108     "Are you sure that you want to relaunch Tera Term?"
109     , ts->UILanguageFile);
110     ret = MessageBox(hwnd, uimsg, "Tera Term: Configuration Warning", MB_YESNO | MB_ICONEXCLAMATION | MB_DEFBUTTON2);
111     if (ret != IDYES)
112     return;
113    
114 yutakapon 4915 SendMessage(hwnd, WM_COMMAND, ID_SETUP_SAVE, 0);
115 yutakapon 4919 // ID_FILE_EXIT メッセージではアプリが落ちることがあるため、WM_QUIT をポストする。
116     //PostMessage(hwnd, WM_COMMAND, ID_FILE_EXIT, 0);
117     PostQuitMessage(0);
118 yutakapon 4915
119 yutakapon 4919 // 自プロセスの再起動。
120 yutakapon 4915 if (GetModuleFileName(NULL, path, sizeof(path)) == 0) {
121     return;
122     }
123     memset(&si, 0, sizeof(si));
124     GetStartupInfo(&si);
125     memset(&pi, 0, sizeof(pi));
126     if (CreateProcess(NULL, path, NULL, NULL, FALSE, 0,
127     NULL, NULL, &si, &pi) == 0) {
128     }
129     }
130    
131 maya 3227 void PASCAL FAR ChangeDefaultSet(PTTSet ts, PKeyMap km)
132     {
133     if ((ts!=NULL) &&
134 maya 3392 (_stricmp(ts->SetupFName, pm->ts.SetupFName) == 0)) {
135 maya 3227 memcpy(&(pm->ts),ts,sizeof(TTTSet));
136 maya 3392 }
137     if (km!=NULL) {
138 maya 3227 memcpy(&(pm->km),km,sizeof(TKeyMap));
139 maya 3392 }
140 maya 3227 }
141    
142     void PASCAL FAR GetDefaultSet(PTTSet ts)
143     {
144     memcpy(ts,&(pm->ts),sizeof(TTTSet));
145     }
146    
147    
148     /* Key scan code -> Tera Term key code */
149     WORD PASCAL FAR GetKeyCode(PKeyMap KeyMap, WORD Scan)
150     {
151     WORD Key;
152    
153 maya 3392 if (KeyMap==NULL) {
154 maya 3227 KeyMap = &(pm->km);
155 maya 3392 }
156 maya 3227 Key = IdKeyMax;
157 maya 3392 while ((Key>0) && (KeyMap->Map[Key-1] != Scan)) {
158 maya 3227 Key--;
159 maya 3392 }
160 maya 3227 return Key;
161     }
162    
163     void PASCAL FAR GetKeyStr(HWND HWin, PKeyMap KeyMap, WORD KeyCode,
164     BOOL AppliKeyMode, BOOL AppliCursorMode,
165     BOOL Send8BitMode, PCHAR KeyStr, int destlen,
166     LPINT Len, LPWORD Type)
167     {
168     MSG Msg;
169     char Temp[201];
170    
171 maya 3392 if (KeyMap==NULL) {
172 maya 3227 KeyMap = &(pm->km);
173 maya 3392 }
174 maya 3227
175     *Type = IdBinary; // key type
176     *Len = 0;
177     switch (KeyCode) {
178     case IdUp:
179     if (Send8BitMode) {
180     *Len = 2;
181     if (AppliCursorMode)
182     strncpy_s(KeyStr,destlen,"\217A",_TRUNCATE);
183     else
184     strncpy_s(KeyStr,destlen,"\233A",_TRUNCATE);
185     } else {
186     *Len = 3;
187     if (AppliCursorMode)
188     strncpy_s(KeyStr,destlen,"\033OA",_TRUNCATE);
189     else
190     strncpy_s(KeyStr,destlen,"\033[A",_TRUNCATE);
191     }
192     break;
193     case IdDown:
194     if (Send8BitMode) {
195     *Len = 2;
196     if (AppliCursorMode)
197     strncpy_s(KeyStr,destlen,"\217B",_TRUNCATE);
198     else
199     strncpy_s(KeyStr,destlen,"\233B",_TRUNCATE);
200     } else {
201     *Len = 3;
202     if (AppliCursorMode)
203     strncpy_s(KeyStr,destlen,"\033OB",_TRUNCATE);
204     else
205     strncpy_s(KeyStr,destlen,"\033[B",_TRUNCATE);
206     }
207     break;
208     case IdRight:
209     if (Send8BitMode) {
210     *Len = 2;
211     if (AppliCursorMode)
212     strncpy_s(KeyStr,destlen,"\217C",_TRUNCATE);
213     else
214     strncpy_s(KeyStr,destlen,"\233C",_TRUNCATE);
215     } else {
216     *Len = 3;
217     if (AppliCursorMode)
218     strncpy_s(KeyStr,destlen,"\033OC",_TRUNCATE);
219     else
220     strncpy_s(KeyStr,destlen,"\033[C",_TRUNCATE);
221     }
222     break;
223     case IdLeft:
224     if (Send8BitMode) {
225     *Len = 2;
226     if (AppliCursorMode)
227     strncpy_s(KeyStr,destlen,"\217D",_TRUNCATE);
228     else
229     strncpy_s(KeyStr,destlen,"\233D",_TRUNCATE);
230     } else {
231     *Len = 3;
232     if (AppliCursorMode)
233     strncpy_s(KeyStr,destlen,"\033OD",_TRUNCATE);
234     else
235     strncpy_s(KeyStr,destlen,"\033[D",_TRUNCATE);
236     }
237     break;
238     case Id0:
239     if (AppliKeyMode) {
240     if (Send8BitMode) {
241     *Len = 2;
242     strncpy_s(KeyStr,destlen,"\217p",_TRUNCATE);
243     } else {
244     *Len = 3;
245     strncpy_s(KeyStr,destlen,"\033Op",_TRUNCATE);
246     }
247     }
248     else {
249     *Len = 1;
250     KeyStr[0] = '0';
251     }
252     break;
253     case Id1:
254     if (AppliKeyMode) {
255     if (Send8BitMode) {
256     *Len = 2;
257     strncpy_s(KeyStr,destlen,"\217q",_TRUNCATE);
258     } else {
259     *Len = 3;
260     strncpy_s(KeyStr,destlen,"\033Oq",_TRUNCATE);
261     }
262     }
263     else {
264     *Len = 1;
265     KeyStr[0] = '1';
266     }
267     break;
268     case Id2:
269     if (AppliKeyMode) {
270     if (Send8BitMode) {
271     *Len = 2;
272     strncpy_s(KeyStr,destlen,"\217r",_TRUNCATE);
273     } else {
274     *Len = 3;
275     strncpy_s(KeyStr,destlen,"\033Or",_TRUNCATE);
276     }
277     }
278     else {
279     *Len = 1;
280     KeyStr[0] = '2';
281     }
282     break;
283     case Id3:
284     if (AppliKeyMode) {
285     if (Send8BitMode) {
286     *Len = 2;
287     strncpy_s(KeyStr,destlen,"\217s",_TRUNCATE);
288     } else {
289     *Len = 3;
290     strncpy_s(KeyStr,destlen,"\033Os",_TRUNCATE);
291     }
292     }
293     else {
294     *Len = 1;
295     KeyStr[0] = '3';
296     }
297     break;
298     case Id4:
299     if (AppliKeyMode) {
300     if (Send8BitMode) {
301     *Len = 2;
302     strncpy_s(KeyStr,destlen,"\217t",_TRUNCATE);
303     } else {
304     *Len = 3;
305     strncpy_s(KeyStr,destlen,"\033Ot",_TRUNCATE);
306     }
307     }
308     else {
309     *Len = 1;
310     KeyStr[0] = '4';
311     }
312     break;
313     case Id5:
314     if (AppliKeyMode) {
315     if (Send8BitMode) {
316     *Len = 2;
317     strncpy_s(KeyStr,destlen,"\217u",_TRUNCATE);
318     } else {
319     *Len = 3;
320     strncpy_s(KeyStr,destlen,"\033Ou",_TRUNCATE);
321     }
322     }
323     else {
324     *Len = 1;
325     KeyStr[0] = '5';
326     }
327     break;
328     case Id6:
329     if (AppliKeyMode) {
330     if (Send8BitMode) {
331     *Len = 2;
332     strncpy_s(KeyStr,destlen,"\217v",_TRUNCATE);
333     } else {
334     *Len = 3;
335     strncpy_s(KeyStr,destlen,"\033Ov",_TRUNCATE);
336     }
337     }
338     else {
339     *Len = 1;
340     KeyStr[0] = '6';
341     }
342     break;
343     case Id7:
344     if (AppliKeyMode) {
345     if (Send8BitMode) {
346     *Len = 2;
347     strncpy_s(KeyStr,destlen,"\217w",_TRUNCATE);
348     } else {
349     *Len = 3;
350     strncpy_s(KeyStr,destlen,"\033Ow",_TRUNCATE);
351     }
352     }
353     else {
354     *Len = 1;
355     KeyStr[0] = '7';
356     }
357     break;
358     case Id8:
359     if (AppliKeyMode) {
360     if (Send8BitMode) {
361     *Len = 2;
362     strncpy_s(KeyStr,destlen,"\217x",_TRUNCATE);
363     } else {
364     *Len = 3;
365     strncpy_s(KeyStr,destlen,"\033Ox",_TRUNCATE);
366     }
367     }
368     else {
369     *Len = 1;
370     KeyStr[0] = '8';
371     }
372     break;
373     case Id9:
374     if (AppliKeyMode) {
375     if (Send8BitMode) {
376     *Len = 2;
377     strncpy_s(KeyStr,destlen,"\217y",_TRUNCATE);
378     } else {
379     *Len = 3;
380     strncpy_s(KeyStr,destlen,"\033Oy",_TRUNCATE);
381     }
382     }
383     else {
384     *Len = 1;
385     KeyStr[0] = '9';
386     }
387     break;
388     case IdMinus: /* numeric pad - key (DEC) */
389     if (AppliKeyMode) {
390     if (Send8BitMode) {
391     *Len = 2;
392     strncpy_s(KeyStr,destlen,"\217m",_TRUNCATE);
393     } else {
394     *Len = 3;
395     strncpy_s(KeyStr,destlen,"\033Om",_TRUNCATE);
396     }
397     }
398     else {
399     *Len = 1;
400     KeyStr[0] = '-';
401     }
402     break;
403     case IdComma: /* numeric pad , key (DEC) */
404     if (AppliKeyMode) {
405     if (Send8BitMode) {
406     *Len = 2;
407     strncpy_s(KeyStr,destlen,"\217l",_TRUNCATE);
408     } else {
409     *Len = 3;
410     strncpy_s(KeyStr,destlen,"\033Ol",_TRUNCATE);
411     }
412     }
413     else {
414     *Len = 1;
415     KeyStr[0] = ',';
416     }
417     break;
418     case IdPeriod: /* numeric pad . key */
419     if (AppliKeyMode) {
420     if (Send8BitMode) {
421     *Len = 2;
422     strncpy_s(KeyStr,destlen,"\217n",_TRUNCATE);
423     } else {
424     *Len = 3;
425     strncpy_s(KeyStr,destlen,"\033On",_TRUNCATE);
426     }
427     }
428     else {
429     *Len = 1;
430     KeyStr[0] = '.';
431     }
432     break;
433     case IdEnter: /* numeric pad enter key */
434     if (AppliKeyMode) {
435     if (Send8BitMode) {
436     *Len = 2;
437     strncpy_s(KeyStr,destlen,"\217M",_TRUNCATE);
438     } else {
439     *Len = 3;
440     strncpy_s(KeyStr,destlen,"\033OM",_TRUNCATE);
441     }
442     }
443     else {
444 doda 3900 *Type = IdText; // do new-line conversion
445 maya 3227 *Len = 1;
446     KeyStr[0] = 0x0D;
447     }
448     break;
449     case IdSlash: /* numeric pad slash key */
450     if (AppliKeyMode) {
451     if (Send8BitMode) {
452     *Len = 2;
453     strncpy_s(KeyStr,destlen,"\217o",_TRUNCATE);
454     } else {
455     *Len = 3;
456     strncpy_s(KeyStr,destlen,"\033Oo",_TRUNCATE);
457     }
458     }
459     else {
460     *Len = 1;
461     KeyStr[0] = '/';
462     }
463     break;
464     case IdAsterisk: /* numeric pad asterisk key */
465     if (AppliKeyMode) {
466     if (Send8BitMode) {
467     *Len = 2;
468     strncpy_s(KeyStr,destlen,"\217j",_TRUNCATE);
469     } else {
470     *Len = 3;
471     strncpy_s(KeyStr,destlen,"\033Oj",_TRUNCATE);
472     }
473     }
474     else {
475     *Len = 1;
476     KeyStr[0] = '*';
477     }
478     break;
479     case IdPlus: /* numeric pad plus key */
480     if (AppliKeyMode) {
481     if (Send8BitMode) {
482     *Len = 2;
483     strncpy_s(KeyStr,destlen,"\217k",_TRUNCATE);
484     } else {
485     *Len = 3;
486     strncpy_s(KeyStr,destlen,"\033Ok",_TRUNCATE);
487     }
488     }
489     else {
490     *Len = 1;
491     KeyStr[0] = '+';
492     }
493     break;
494     case IdPF1: /* DEC Key: PF1 */
495     if (Send8BitMode) {
496     *Len = 2;
497     strncpy_s(KeyStr,destlen,"\217P",_TRUNCATE);
498     } else {
499     *Len = 3;
500     strncpy_s(KeyStr,destlen,"\033OP",_TRUNCATE);
501     }
502     break;
503     case IdPF2: /* DEC Key: PF2 */
504     if (Send8BitMode) {
505     *Len = 2;
506     strncpy_s(KeyStr,destlen,"\217Q",_TRUNCATE);
507     } else {
508     *Len = 3;
509     strncpy_s(KeyStr,destlen,"\033OQ",_TRUNCATE);
510     }
511     break;
512     case IdPF3: /* DEC Key: PF3 */
513     if (Send8BitMode) {
514     *Len = 2;
515     strncpy_s(KeyStr,destlen,"\217R",_TRUNCATE);
516     } else {
517     *Len = 3;
518     strncpy_s(KeyStr,destlen,"\033OR",_TRUNCATE);
519     }
520     break;
521     case IdPF4: /* DEC Key: PF4 */
522     if (Send8BitMode) {
523     *Len = 2;
524     strncpy_s(KeyStr,destlen,"\217S",_TRUNCATE);
525     } else {
526     *Len = 3;
527     strncpy_s(KeyStr,destlen,"\033OS",_TRUNCATE);
528     }
529     break;
530     case IdFind: /* DEC Key: Find */
531     if (Send8BitMode) {
532     *Len = 3;
533     strncpy_s(KeyStr,destlen,"\2331~",_TRUNCATE);
534     } else {
535     *Len = 4;
536     strncpy_s(KeyStr,destlen,"\033[1~",_TRUNCATE);
537     }
538     break;
539     case IdInsert: /* DEC Key: Insert Here */
540     if (Send8BitMode) {
541     *Len = 3;
542     strncpy_s(KeyStr,destlen,"\2332~",_TRUNCATE);
543     } else {
544     *Len = 4;
545     strncpy_s(KeyStr,destlen,"\033[2~",_TRUNCATE);
546     }
547     break;
548     case IdRemove: /* DEC Key: Remove */
549     if (Send8BitMode) {
550     *Len = 3;
551     strncpy_s(KeyStr,destlen,"\2333~",_TRUNCATE);
552     } else {
553     *Len = 4;
554     strncpy_s(KeyStr,destlen,"\033[3~",_TRUNCATE);
555     }
556     break;
557     case IdSelect: /* DEC Key: Select */
558     if (Send8BitMode) {
559     *Len = 3;
560     strncpy_s(KeyStr,destlen,"\2334~",_TRUNCATE);
561     } else {
562     *Len = 4;
563     strncpy_s(KeyStr,destlen,"\033[4~",_TRUNCATE);
564     }
565     break;
566     case IdPrev: /* DEC Key: Prev */
567     if (Send8BitMode) {
568     *Len = 3;
569     strncpy_s(KeyStr,destlen,"\2335~",_TRUNCATE);
570     } else {
571     *Len = 4;
572     strncpy_s(KeyStr,destlen,"\033[5~",_TRUNCATE);
573     }
574     break;
575     case IdNext: /* DEC Key: Next */
576     if (Send8BitMode) {
577     *Len = 3;
578     strncpy_s(KeyStr,destlen,"\2336~",_TRUNCATE);
579     } else {
580     *Len = 4;
581     strncpy_s(KeyStr,destlen,"\033[6~",_TRUNCATE);
582     }
583     break;
584     case IdF6: /* DEC Key: F6 */
585     if (Send8BitMode) {
586     *Len = 4;
587     strncpy_s(KeyStr,destlen,"\23317~",_TRUNCATE);
588     } else {
589     *Len = 5;
590     strncpy_s(KeyStr,destlen,"\033[17~",_TRUNCATE);
591     }
592     break;
593     case IdF7: /* DEC Key: F7 */
594     if (Send8BitMode) {
595     *Len = 4;
596     strncpy_s(KeyStr,destlen,"\23318~",_TRUNCATE);
597     } else {
598     *Len = 5;
599     strncpy_s(KeyStr,destlen,"\033[18~",_TRUNCATE);
600     }
601     break;
602     case IdF8: /* DEC Key: F8 */
603     if (Send8BitMode) {
604     *Len = 4;
605     strncpy_s(KeyStr,destlen,"\23319~",_TRUNCATE);
606     } else {
607     *Len = 5;
608     strncpy_s(KeyStr,destlen,"\033[19~",_TRUNCATE);
609     }
610     break;
611     case IdF9: /* DEC Key: F9 */
612     if (Send8BitMode) {
613     *Len = 4;
614     strncpy_s(KeyStr,destlen,"\23320~",_TRUNCATE);
615     } else {
616     *Len = 5;
617     strncpy_s(KeyStr,destlen,"\033[20~",_TRUNCATE);
618     }
619     break;
620     case IdF10: /* DEC Key: F10 */
621     if (Send8BitMode) {
622     *Len = 4;
623     strncpy_s(KeyStr,destlen,"\23321~",_TRUNCATE);
624     } else {
625     *Len = 5;
626     strncpy_s(KeyStr,destlen,"\033[21~",_TRUNCATE);
627     }
628     break;
629     case IdF11: /* DEC Key: F11 */
630     if (Send8BitMode) {
631     *Len = 4;
632     strncpy_s(KeyStr,destlen,"\23323~",_TRUNCATE);
633     } else {
634     *Len = 5;
635     strncpy_s(KeyStr,destlen,"\033[23~",_TRUNCATE);
636     }
637     break;
638     case IdF12: /* DEC Key: F12 */
639     if (Send8BitMode) {
640     *Len = 4;
641     strncpy_s(KeyStr,destlen,"\23324~",_TRUNCATE);
642     } else {
643     *Len = 5;
644     strncpy_s(KeyStr,destlen,"\033[24~",_TRUNCATE);
645     }
646     break;
647     case IdF13: /* DEC Key: F13 */
648     if (Send8BitMode) {
649     *Len = 4;
650     strncpy_s(KeyStr,destlen,"\23325~",_TRUNCATE);
651     } else {
652     *Len = 5;
653     strncpy_s(KeyStr,destlen,"\033[25~",_TRUNCATE);
654     }
655     break;
656     case IdF14: /* DEC Key: F14 */
657     if (Send8BitMode) {
658     *Len = 4;
659     strncpy_s(KeyStr,destlen,"\23326~",_TRUNCATE);
660     } else {
661     *Len = 5;
662     strncpy_s(KeyStr,destlen,"\033[26~",_TRUNCATE);
663     }
664     break;
665     case IdHelp: /* DEC Key: Help */
666     if (Send8BitMode) {
667     *Len = 4;
668     strncpy_s(KeyStr,destlen,"\23328~",_TRUNCATE);
669     } else {
670     *Len = 5;
671     strncpy_s(KeyStr,destlen,"\033[28~",_TRUNCATE);
672     }
673     break;
674     case IdDo: /* DEC Key: Do */
675     if (Send8BitMode) {
676     *Len = 4;
677     strncpy_s(KeyStr,destlen,"\23329~",_TRUNCATE);
678     } else {
679     *Len = 5;
680     strncpy_s(KeyStr,destlen,"\033[29~",_TRUNCATE);
681     }
682     break;
683     case IdF17: /* DEC Key: F17 */
684     if (Send8BitMode) {
685     *Len = 4;
686     strncpy_s(KeyStr,destlen,"\23331~",_TRUNCATE);
687     } else {
688     *Len = 5;
689     strncpy_s(KeyStr,destlen,"\033[31~",_TRUNCATE);
690     }
691     break;
692     case IdF18: /* DEC Key: F18 */
693     if (Send8BitMode) {
694     *Len = 4;
695     strncpy_s(KeyStr,destlen,"\23332~",_TRUNCATE);
696     } else {
697     *Len = 5;
698     strncpy_s(KeyStr,destlen,"\033[32~",_TRUNCATE);
699     }
700     break;
701     case IdF19: /* DEC Key: F19 */
702     if (Send8BitMode) {
703     *Len = 4;
704     strncpy_s(KeyStr,destlen,"\23333~",_TRUNCATE);
705     } else {
706     *Len = 5;
707     strncpy_s(KeyStr,destlen,"\033[33~",_TRUNCATE);
708     }
709     break;
710     case IdF20: /* DEC Key: F20 */
711     if (Send8BitMode) {
712     *Len = 4;
713     strncpy_s(KeyStr,destlen,"\23334~",_TRUNCATE);
714     } else {
715     *Len = 5;
716     strncpy_s(KeyStr,destlen,"\033[34~",_TRUNCATE);
717     }
718     break;
719     case IdXF1: /* XTERM F1 */
720     if (Send8BitMode) {
721     *Len = 4;
722     strncpy_s(KeyStr,destlen,"\23311~",_TRUNCATE);
723     } else {
724     *Len = 5;
725     strncpy_s(KeyStr,destlen,"\033[11~",_TRUNCATE);
726     }
727     break;
728     case IdXF2: /* XTERM F2 */
729     if (Send8BitMode) {
730     *Len = 4;
731     strncpy_s(KeyStr,destlen,"\23312~",_TRUNCATE);
732     } else {
733     *Len = 5;
734     strncpy_s(KeyStr,destlen,"\033[12~",_TRUNCATE);
735     }
736     break;
737     case IdXF3: /* XTERM F3 */
738     if (Send8BitMode) {
739     *Len = 4;
740     strncpy_s(KeyStr,destlen,"\23313~",_TRUNCATE);
741     } else {
742     *Len = 5;
743     strncpy_s(KeyStr,destlen,"\033[13~",_TRUNCATE);
744     }
745     break;
746     case IdXF4: /* XTERM F4 */
747     if (Send8BitMode) {
748     *Len = 4;
749     strncpy_s(KeyStr,destlen,"\23314~",_TRUNCATE);
750     } else {
751     *Len = 5;
752     strncpy_s(KeyStr,destlen,"\033[14~",_TRUNCATE);
753     }
754     break;
755     case IdXF5: /* XTERM F5 */
756     if (Send8BitMode) {
757     *Len = 4;
758     strncpy_s(KeyStr,destlen,"\23315~",_TRUNCATE);
759     } else {
760     *Len = 5;
761     strncpy_s(KeyStr,destlen,"\033[15~",_TRUNCATE);
762     }
763     break;
764 doda 4710 case IdXBackTab: /* XTERM Back Tab */
765     if (Send8BitMode) {
766     *Len = 2;
767     strncpy_s(KeyStr,destlen,"\233Z",_TRUNCATE);
768     } else {
769     *Len = 3;
770     strncpy_s(KeyStr,destlen,"\033[Z",_TRUNCATE);
771     }
772     break;
773 maya 3227 case IdHold:
774     case IdPrint:
775     case IdBreak:
776     case IdCmdEditCopy:
777     case IdCmdEditPaste:
778     case IdCmdEditPasteCR:
779     case IdCmdEditCLS:
780     case IdCmdEditCLB:
781     case IdCmdCtrlOpenTEK:
782     case IdCmdCtrlCloseTEK:
783     case IdCmdLineUp:
784     case IdCmdLineDown:
785     case IdCmdPageUp:
786     case IdCmdPageDown:
787     case IdCmdBuffTop:
788     case IdCmdBuffBottom:
789     case IdCmdNextWin:
790     case IdCmdPrevWin:
791 doda 3950 case IdCmdNextSWin:
792     case IdCmdPrevSWin:
793 maya 3227 case IdCmdLocalEcho:
794 doda 4710 case IdCmdScrollLock:
795 maya 3227 PostMessage(HWin,WM_USER_ACCELCOMMAND,KeyCode,0);
796     break;
797     default:
798     if ((KeyCode >= IdUser1) && (KeyCode <= IdKeyMax)) {
799     *Type = (WORD)(*KeyMap).UserKeyType[KeyCode-IdUser1]; // key type
800     *Len = KeyMap->UserKeyLen[KeyCode-IdUser1];
801     memcpy(Temp,
802     &KeyMap->UserKeyStr[KeyMap->UserKeyPtr[KeyCode-IdUser1]],
803     *Len);
804     Temp[*Len] = 0;
805     if ((*Type==IdBinary) || (*Type==IdText))
806     *Len = Hex2Str(Temp,KeyStr,destlen);
807     else
808     strncpy_s(KeyStr,destlen,Temp,_TRUNCATE);
809     }
810     else
811     return;
812     }
813     /* remove WM_CHAR message for used keycode */
814     PeekMessage(&Msg,HWin, WM_CHAR, WM_CHAR,PM_REMOVE);
815     }
816    
817     void FAR PASCAL SetCOMFlag(int Com)
818     {
819     pm->ComFlag[(Com-1)/CHAR_BIT] |= 1 << ((Com-1)%CHAR_BIT);
820     }
821    
822     void FAR PASCAL ClearCOMFlag(int Com)
823     {
824     pm->ComFlag[(Com-1)/CHAR_BIT] &= ~(1 << ((Com-1)%CHAR_BIT));
825     }
826    
827     int FAR PASCAL CheckCOMFlag(int Com)
828     {
829     return ((pm->ComFlag[(Com-1)/CHAR_BIT] & 1 << (Com-1)%CHAR_BIT) > 0);
830     }
831    
832     int FAR PASCAL RegWin(HWND HWinVT, HWND HWinTEK)
833     {
834     int i, j;
835    
836     if (pm->NWin>=MAXNWIN)
837     return 0;
838     if (HWinVT==NULL)
839     return 0;
840     if (HWinTEK!=NULL) {
841     i = 0;
842     while ((i<pm->NWin) && (pm->WinList[i]!=HWinVT))
843     i++;
844     if (i>=pm->NWin)
845     return 0;
846     for (j=pm->NWin-1 ; j>i ; j--)
847     pm->WinList[j+1] = pm->WinList[j];
848     pm->WinList[i+1] = HWinTEK;
849     pm->NWin++;
850     return 0;
851     }
852     pm->WinList[pm->NWin++] = HWinVT;
853 yutakapon 5223 memset(&pm->WinPrevRect[pm->NWin - 1], 0, sizeof(pm->WinPrevRect[pm->NWin - 1])); // RECT clear
854 maya 3392 if (pm->NWin==1) {
855 maya 3227 return 1;
856 maya 3392 }
857     else {
858 maya 3227 return (int)(SendMessage(pm->WinList[pm->NWin-2],
859 maya 3392 WM_USER_GETSERIALNO,0,0)+1);
860     }
861 maya 3227 }
862    
863     void FAR PASCAL UnregWin(HWND HWin)
864     {
865     int i, j;
866    
867     i = 0;
868 maya 3392 while ((i<pm->NWin) && (pm->WinList[i]!=HWin)) {
869 maya 3227 i++;
870 maya 3392 }
871     if (pm->WinList[i]!=HWin) {
872 maya 3227 return;
873 maya 3392 }
874     for (j=i ; j<pm->NWin-1 ; j++) {
875 maya 3227 pm->WinList[j] = pm->WinList[j+1];
876 yutakapon 5223 pm->WinPrevRect[j] = pm->WinPrevRect[j+1]; // RECT shift
877 maya 3392 }
878     if (pm->NWin>0) {
879 maya 3227 pm->NWin--;
880 maya 3392 }
881 maya 3227 }
882    
883 doda 4073 char GetWindowTypeChar(HWND Hw, HWND HWin)
884     {
885 doda 4076 #if 0
886 doda 4073 if (HWin == Hw)
887     return '*';
888     else if (!IsWindowVisible(Hw))
889 doda 4076 #else
890     if (!IsWindowVisible(Hw))
891     #endif
892 doda 4073 return '#';
893     else if (IsIconic(Hw))
894     return '-';
895     else if (IsZoomed(Hw))
896     return '@';
897     else
898     return '+';
899     }
900    
901 yutakapon 5249 void FAR PASCAL SetWinMenu(HMENU menu, PCHAR buf, int buflen, PCHAR langFile, int VTFlag)
902 maya 3227 {
903     int i;
904     char Temp[MAXPATHLEN];
905     HWND Hw;
906    
907     // delete all items in Window menu
908     i = GetMenuItemCount(menu);
909     if (i>0)
910     do {
911     i--;
912     RemoveMenu(menu,i,MF_BYPOSITION);
913     } while (i>0);
914    
915     i = 0;
916     while (i<pm->NWin) {
917     Hw = pm->WinList[i]; // get window handle
918     if ((GetClassName(Hw,Temp,sizeof(Temp))>0) &&
919     ((strcmp(Temp,VTCLASSNAME)==0) ||
920     (strcmp(Temp,TEKCLASSNAME)==0))) {
921     Temp[0] = '&';
922     Temp[1] = (char)(0x31 + i);
923     Temp[2] = ' ';
924 doda 4073 Temp[3] = GetWindowTypeChar(Hw, NULL);
925     Temp[4] = ' ';
926     GetWindowText(Hw,&Temp[5],sizeof(Temp)-6);
927 maya 3227 AppendMenu(menu,MF_ENABLED | MF_STRING,ID_WINDOW_1+i,Temp);
928     i++;
929 maya 3392 if (i>8) {
930 maya 3227 i = pm->NWin;
931 maya 3392 }
932 maya 3227 }
933 maya 3392 else {
934 maya 3227 UnregWin(Hw);
935 maya 3392 }
936 maya 3227 }
937     get_lang_msg("MENU_WINDOW_WINDOW", buf, buflen, "&Window", langFile);
938     if (VTFlag == 1) {
939 maya 4655 AppendMenu(menu, MF_SEPARATOR, 0, NULL);
940 maya 3227 AppendMenu(menu,MF_ENABLED | MF_STRING,ID_WINDOW_WINDOW, buf);
941 doda 4647
942     get_lang_msg("MENU_WINDOW_MINIMIZEALL", buf, buflen, "&Minimize All", langFile);
943     AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_MINIMIZEALL, buf);
944    
945 yutakapon 5252 get_lang_msg("MENU_WINDOW_RESTOREALL", buf, buflen, "&Restore All", langFile);
946     AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_RESTOREALL, buf);
947    
948 yutakapon 5224 get_lang_msg("MENU_WINDOW_CASCADE", buf, buflen, "&Cascade", langFile);
949     AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_CASCADEALL, buf);
950    
951     get_lang_msg("MENU_WINDOW_STACKED", buf, buflen, "&Stacked", langFile);
952     AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_STACKED, buf);
953    
954     get_lang_msg("MENU_WINDOW_SIDEBYSIDE", buf, buflen, "Side &by Side", langFile);
955     AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_SIDEBYSIDE, buf);
956    
957 yutakapon 5299 if (pm->WinUndoFlag) {
958     if (pm->WinUndoStyle == WIN_CASCADE)
959     get_lang_msg("MENU_WINDOW_CASCADE_UNDO", buf, buflen, "&Undo - Cascade", langFile);
960     else if (pm->WinUndoStyle == WIN_STACKED)
961     get_lang_msg("MENU_WINDOW_STACKED_UNDO", buf, buflen, "&Undo - Stacked", langFile);
962     else
963     get_lang_msg("MENU_WINDOW_SIDEBYSIDE_UNDO", buf, buflen, "&Undo - Side by Side", langFile);
964     AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_UNDO, buf);
965     }
966    
967 maya 3227 }
968     else {
969     AppendMenu(menu,MF_ENABLED | MF_STRING,ID_TEKWINDOW_WINDOW, buf);
970     }
971     }
972    
973     void FAR PASCAL SetWinList(HWND HWin, HWND HDlg, int IList)
974     {
975     int i;
976     char Temp[MAXPATHLEN];
977     HWND Hw;
978    
979     for (i=0; i<pm->NWin; i++) {
980     Hw = pm->WinList[i]; // get window handle
981     if ((GetClassName(Hw,Temp,sizeof(Temp))>0) &&
982     ((strcmp(Temp,VTCLASSNAME)==0) ||
983     (strcmp(Temp,TEKCLASSNAME)==0))) {
984 doda 4073 Temp[0] = GetWindowTypeChar(Hw, HWin);
985     Temp[1] = ' ';
986     GetWindowText(Hw,&Temp[2],sizeof(Temp)-3);
987 maya 3227 SendDlgItemMessage(HDlg, IList, LB_ADDSTRING,
988     0, (LONG)Temp);
989 maya 3392 if (Hw==HWin) {
990     SendDlgItemMessage(HDlg, IList, LB_SETCURSEL, i,0);
991     }
992 maya 3227 }
993 maya 3392 else {
994 maya 3227 UnregWin(Hw);
995 maya 3392 }
996 maya 3227 }
997     }
998    
999     void FAR PASCAL SelectWin(int WinId)
1000     {
1001     if ((WinId>=0) && (WinId<pm->NWin)) {
1002 yutakapon 3673 /* ウィンドウが最大化および最小化されていた場合、その状態を維持できるように、
1003     * SW_SHOWNORMAL から SW_SHOW へ変更した。
1004     * (2009.11.8 yutaka)
1005 maya 3675 * ウィンドウが最小化されているときは元のサイズに戻す(SW_RESTORE)ようにした。
1006     * (2009.11.9 maya)
1007 yutakapon 3673 */
1008 maya 3675 if (IsIconic(pm->WinList[WinId])) {
1009     ShowWindow(pm->WinList[WinId],SW_RESTORE);
1010     }
1011     else {
1012     ShowWindow(pm->WinList[WinId],SW_SHOW);
1013     }
1014 maya 3227 SetForegroundWindow(pm->WinList[WinId]);
1015     }
1016     }
1017    
1018 doda 4030 void FAR PASCAL SelectNextWin(HWND HWin, int Next, BOOL SkipIconic)
1019 maya 3227 {
1020     int i;
1021    
1022     i = 0;
1023 doda 3950 while ((i < pm->NWin) && (pm->WinList[i]!=HWin)) {
1024     i++;
1025     }
1026     if (pm->WinList[i]!=HWin) {
1027     return;
1028     }
1029    
1030     do {
1031     i += Next;
1032     if (i >= pm->NWin) {
1033     i = 0;
1034     }
1035     else if (i < 0) {
1036     i = pm->NWin-1;
1037     }
1038    
1039     if (pm->WinList[i] == HWin) {
1040 doda 4030 break;
1041 doda 3950 }
1042 doda 4030 } while ((SkipIconic && IsIconic(pm->WinList[i])) || !IsWindowVisible(pm->WinList[i]));
1043 doda 3950
1044     SelectWin(i);
1045     }
1046    
1047 doda 4647 void FAR PASCAL ShowAllWin(int stat) {
1048     int i;
1049 doda 5280
1050     for (i=0; i < pm->NWin; i++) {
1051     ShowWindow(pm->WinList[i], stat);
1052     }
1053     }
1054    
1055 yutakapon 5299 void FAR PASCAL UndoAllWin(void) {
1056 doda 5280 int i;
1057 yutakapon 5223 WINDOWPLACEMENT rc0;
1058     RECT rc;
1059     HMONITOR hMonitor;
1060     MONITORINFO mi;
1061 yutakapon 5299 int stat = SW_RESTORE;
1062 yutakapon 5407 int multi_mon = 0;
1063 doda 4647
1064 yutakapon 6286 if (HasMultiMonitorSupport()) {
1065 yutakapon 5407 multi_mon = 1;
1066     }
1067    
1068 yutakapon 5299 // 一度、復元したらフラグは落とす。
1069     pm->WinUndoFlag = FALSE;
1070    
1071 yutakapon 5223 memset(&rc0, 0, sizeof(rc0));
1072    
1073 doda 4647 for (i=0; i < pm->NWin; i++) {
1074 yutakapon 5223 // 復元指定で、前回の状態が残っている場合は、ウィンドウの状態を元に戻す。
1075     if (stat == SW_RESTORE && memcmp(&pm->WinPrevRect[i], &rc0, sizeof(rc0)) != 0) {
1076     rc = pm->WinPrevRect[i].rcNormalPosition;
1077    
1078 yutakapon 5407 // NT4.0, 95 はマルチモニタAPIに非対応
1079     if (multi_mon) {
1080     // 対象モニタの情報を取得
1081     hMonitor = MonitorFromRect(&rc, MONITOR_DEFAULTTONEAREST);
1082     mi.cbSize = sizeof(MONITORINFO);
1083     GetMonitorInfo(hMonitor, &mi);
1084 yutakapon 5223
1085 yutakapon 5407 // 位置補正（復元前後で解像度が変わっている場合への対策）
1086     if (rc.right > mi.rcMonitor.right) {
1087     rc.left -= rc.right - mi.rcMonitor.right;
1088     rc.right = mi.rcMonitor.right;
1089     }
1090     if (rc.left < mi.rcMonitor.left) {
1091     rc.right += mi.rcMonitor.left - rc.left;
1092     rc.left = mi.rcMonitor.left;
1093     }
1094     if (rc.bottom > mi.rcMonitor.bottom) {
1095     rc.top -= rc.bottom - mi.rcMonitor.bottom;
1096     rc.bottom = mi.rcMonitor.bottom;
1097     }
1098     if (rc.top < mi.rcMonitor.top) {
1099     rc.bottom += mi.rcMonitor.top - rc.top;
1100     rc.top = mi.rcMonitor.top;
1101     }
1102 yutakapon 5223 }
1103    
1104     // ウィンドウ位置復元
1105     SetWindowPos(
1106     pm->WinList[i], NULL,
1107     rc.left,
1108     rc.top,
1109     rc.right - rc.left,
1110     rc.bottom - rc.top,
1111     SWP_NOZORDER);
1112    
1113 yutakapon 5230 // ウィンドウの状態復元
1114     ShowWindow(pm->WinList[i], pm->WinPrevRect[i].showCmd);
1115 yutakapon 5223
1116     } else {
1117     ShowWindow(pm->WinList[i], stat);
1118     }
1119 doda 4647 }
1120     }
1121    
1122 yutakapon 5636 void FAR PASCAL OpenHelp(UINT Command, DWORD Data, char *UILanguageFile)
1123 maya 5308 {
1124     char HomeDir[MAX_PATH];
1125     char Temp[MAX_PATH];
1126     HWND HWin;
1127     char HelpFN[MAX_PATH];
1128 yutakapon 5636 // char UILanguageFile[MAX_PATH];
1129 maya 5308 char uimsg[MAX_UIMSG];
1130    
1131     /* Get home directory */
1132     if (GetModuleFileName(NULL,Temp,sizeof(Temp)) == 0) {
1133     return;
1134     }
1135     ExtractDirName(Temp, HomeDir);
1136    
1137 yutakapon 5636 // GetUILanguageFile(UILanguageFile, sizeof(UILanguageFile));
1138 maya 5308 get_lang_msg("HELPFILE", uimsg, sizeof(uimsg), "teraterm.chm", UILanguageFile);
1139    
1140     // ヘルプのオーナーは常にデスクトップになる (2007.5.12 maya)
1141     HWin = GetDesktopWindow();
1142     _snprintf_s(HelpFN, sizeof(HelpFN), _TRUNCATE, "%s\\%s", HomeDir, uimsg);
1143     if (HtmlHelp(HWin, HelpFN, Command, Data) == NULL && Command != HH_CLOSE_ALL) {
1144     char buf[MAX_PATH];
1145     get_lang_msg("MSG_OPENHELP_ERROR", uimsg, sizeof(uimsg), "Can't open HTML help file(%s).", UILanguageFile);
1146     _snprintf_s(buf, sizeof(buf), _TRUNCATE, uimsg, HelpFN);
1147     MessageBox(HWin, buf, "Tera Term: HTML help", MB_OK | MB_ICONERROR);
1148     }
1149     }
1150    
1151 maya 3227 HWND FAR PASCAL GetNthWin(int n)
1152     {
1153 maya 3392 if (n<pm->NWin) {
1154 maya 3227 return pm->WinList[n];
1155 maya 3392 }
1156     else {
1157 maya 3227 return NULL;
1158 maya 3392 }
1159 maya 3227 }
1160    
1161 yutakapon 5222
1162 yutakapon 5223 // 有効なウィンドウを探し、現在位置を記憶させておく。
1163 yutakapon 5299 static void get_valid_window_and_memorize_rect(HWND myhwnd, HWND hwnd[], int *num, int style)
1164 yutakapon 5222 {
1165 yutakapon 5223 int i, n;
1166     WINDOWPLACEMENT wndPlace;
1167 yutakapon 5222
1168 yutakapon 5299 // 元に戻す(Undo)メニューは一度だけ表示させる。
1169     if (pm->WinUndoFlag == FALSE) {
1170     pm->WinUndoFlag = TRUE;
1171     } else {
1172     // すでにメニューが表示されていて、かつ以前と同じスタイルが選択されたら、
1173     // メニューを消す。
1174     // Windows8では、さらに連続して同じスタイルを選択してもメニューが消えたままだが、
1175     // Tera Termではメニューが表示されるため、動作が異なる。
1176     if (pm->WinUndoStyle == style)
1177     pm->WinUndoFlag = FALSE;
1178     }
1179     pm->WinUndoStyle = style;
1180    
1181 yutakapon 5222 n = 0;
1182     for (i = 0 ; i < pm->NWin ; i++) {
1183 yutakapon 5223 // 現在位置を覚えておく。
1184     wndPlace.length = sizeof(WINDOWPLACEMENT);
1185     GetWindowPlacement(pm->WinList[i], &wndPlace);
1186     pm->WinPrevRect[i] = wndPlace;
1187    
1188     // 自分自身は先頭にする。
1189 yutakapon 5222 if (pm->WinList[i] == myhwnd) {
1190     hwnd[n] = hwnd[0];
1191     hwnd[0] = myhwnd;
1192     } else {
1193     hwnd[n] = pm->WinList[i];
1194     }
1195     n++;
1196     }
1197 yutakapon 5223 *num = n;
1198     }
1199 yutakapon 5222
1200 yutakapon 5223 // ウィンドウを左右に並べて表示する(Show Windows Side by Side)
1201     void FAR PASCAL ShowAllWinSidebySide(HWND myhwnd)
1202     {
1203     int n;
1204     HWND hwnd[MAXNWIN];
1205    
1206 yutakapon 5299 get_valid_window_and_memorize_rect(myhwnd, hwnd, &n, WIN_SIDEBYSIDE);
1207 yutakapon 5251 TileWindows(NULL, MDITILE_VERTICAL, NULL, n, hwnd);
1208 yutakapon 5222 }
1209    
1210     // ウィンドウを上下に並べて表示する(Show Windows Stacked)
1211     void FAR PASCAL ShowAllWinStacked(HWND myhwnd)
1212     {
1213 yutakapon 5223 int n;
1214 yutakapon 5222 HWND hwnd[MAXNWIN];
1215    
1216 yutakapon 5299 get_valid_window_and_memorize_rect(myhwnd, hwnd, &n, WIN_STACKED);
1217 yutakapon 5251 TileWindows(NULL, MDITILE_HORIZONTAL, NULL, n, hwnd);
1218 yutakapon 5222 }
1219    
1220     // ウィンドウを重ねて表示する(Cascade)
1221     void FAR PASCAL ShowAllWinCascade(HWND myhwnd)
1222     {
1223 yutakapon 5223 int n;
1224     HWND hwnd[MAXNWIN];
1225    
1226 yutakapon 5299 get_valid_window_and_memorize_rect(myhwnd, hwnd, &n, WIN_CASCADE);
1227 yutakapon 5251 CascadeWindows(NULL, MDITILE_SKIPDISABLED, NULL, n, hwnd);
1228 yutakapon 5222 }
1229    
1230 yutakapon 5232 // 全Tera Termに終了指示を出す。
1231     void FAR PASCAL BroadcastClosingMessage(HWND myhwnd)
1232     {
1233     int i, max;
1234     HWND hwnd[MAXNWIN];
1235    
1236     // Tera Termを終了させると、共有メモリが変化するため、
1237     // いったんバッファにコピーしておく。
1238     max = pm->NWin;
1239     for (i = 0 ; i < pm->NWin ; i++) {
1240     hwnd[i] = pm->WinList[i];
1241     }
1242    
1243     for (i = 0 ; i < max ; i++) {
1244     // 自分自身は最後にする。
1245     if (hwnd[i] == myhwnd)
1246     continue;
1247    
1248     PostMessage(hwnd[i], WM_USER_NONCONFIRM_CLOSE, 0, 0);
1249     }
1250     PostMessage(myhwnd, WM_USER_NONCONFIRM_CLOSE, 0, 0);
1251     }
1252    
1253    
1254 maya 3227 int FAR PASCAL CommReadRawByte(PComVar cv, LPBYTE b)
1255     {
1256 maya 3392 if ( ! cv->Ready ) {
1257 maya 3227 return 0;
1258 maya 3392 }
1259 maya 3227
1260     if ( cv->InBuffCount>0 ) {
1261     *b = cv->InBuff[cv->InPtr];
1262     cv->InPtr++;
1263     cv->InBuffCount--;
1264 maya 3392 if ( cv->InBuffCount==0 ) {
1265 maya 3227 cv->InPtr = 0;
1266 maya 3392 }
1267 maya 3227 return 1;
1268     }
1269     else {
1270     cv->InPtr = 0;
1271     return 0;
1272     }
1273     }
1274    
1275     void PASCAL FAR CommInsert1Byte(PComVar cv, BYTE b)
1276     {
1277 maya 3392 if ( ! cv->Ready ) {
1278 maya 3227 return;
1279 maya 3392 }
1280 maya 3227
1281 maya 3392 if (cv->InPtr == 0) {
1282 maya 3227 memmove(&(cv->InBuff[1]),&(cv->InBuff[0]),cv->InBuffCount);
1283 maya 3392 }
1284     else {
1285 maya 3227 cv->InPtr--;
1286 maya 3392 }
1287 maya 3227 cv->InBuff[cv->InPtr] = b;
1288     cv->InBuffCount++;
1289    
1290 maya 3392 if (cv->HBinBuf!=0 ) {
1291 maya 3227 cv->BinSkip++;
1292 maya 3392 }
1293 maya 3227 }
1294    
1295     void Log1Bin(PComVar cv, BYTE b)
1296     {
1297 maya 3392 if (((cv->FilePause & OpLog)!=0) || cv->ProtoFlag) {
1298 maya 3227 return;
1299 maya 3392 }
1300 maya 3227 if (cv->BinSkip > 0) {
1301     cv->BinSkip--;
1302     return;
1303     }
1304     cv->BinBuf[cv->BinPtr] = b;
1305     cv->BinPtr++;
1306 maya 3392 if (cv->BinPtr>=InBuffSize) {
1307 maya 3227 cv->BinPtr = cv->BinPtr-InBuffSize;
1308 maya 3392 }
1309 maya 3227 if (cv->BCount>=InBuffSize) {
1310     cv->BCount = InBuffSize;
1311     cv->BStart = cv->BinPtr;
1312     }
1313 maya 3392 else {
1314 maya 3227 cv->BCount++;
1315 maya 3392 }
1316 maya 3227 }
1317    
1318     int FAR PASCAL CommRead1Byte(PComVar cv, LPBYTE b)
1319     {
1320     int c;
1321    
1322 maya 3392 if ( ! cv->Ready ) {
1323 maya 3227 return 0;
1324 maya 3392 }
1325 maya 3227
1326     if ((cv->HLogBuf!=NULL) &&
1327     ((cv->LCount>=InBuffSize-10) ||
1328     (cv->DCount>=InBuffSize-10))) {
1329     // 自分のバッファに余裕がない場合は、CPUスケジューリングを他に回し、
1330     // CPUがストールするの防ぐ。
1331     // (2006.10.13 yutaka)
1332     Sleep(1);
1333     return 0;
1334     }
1335    
1336     if ((cv->HBinBuf!=NULL) &&
1337 maya 3392 (cv->BCount>=InBuffSize-10)) {
1338 maya 3227 return 0;
1339 maya 3392 }
1340 maya 3227
1341 maya 3392 if ( cv->TelMode ) {
1342 maya 3227 c = 0;
1343 maya 3392 }
1344     else {
1345 maya 3227 c = CommReadRawByte(cv,b);
1346 maya 3392 }
1347 maya 3227
1348     if ((c==1) && cv->TelCRFlag) {
1349     cv->TelCRFlag = FALSE;
1350 maya 3392 if (*b==0) {
1351     c = 0;
1352     }
1353 maya 3227 }
1354    
1355     if ( c==1 ) {
1356     if ( cv->IACFlag ) {
1357     cv->IACFlag = FALSE;
1358     if ( *b != 0xFF ) {
1359     cv->TelMode = TRUE;
1360     CommInsert1Byte(cv,*b);
1361 maya 3392 if ( cv->HBinBuf!=0 ) {
1362 maya 3227 cv->BinSkip--;
1363 maya 3392 }
1364 maya 3227 c = 0;
1365     }
1366     }
1367     else if ((cv->PortType==IdTCPIP) && (*b==0xFF)) {
1368 maya 3392 if (!cv->TelFlag && cv->TelAutoDetect) { /* TTPLUG */
1369 maya 3227 cv->TelFlag = TRUE;
1370 maya 3392 }
1371 maya 3227 if (cv->TelFlag) {
1372     cv->IACFlag = TRUE;
1373     c = 0;
1374     }
1375     }
1376 maya 3392 else if (cv->TelFlag && ! cv->TelBinRecv && (*b==0x0D)) {
1377 maya 3227 cv->TelCRFlag = TRUE;
1378 maya 3392 }
1379 maya 3227 }
1380    
1381 maya 3392 if ( (c==1) && (cv->HBinBuf!=0) ) {
1382 maya 3227 Log1Bin(cv, *b);
1383 maya 3392 }
1384 maya 3227
1385     return c;
1386     }
1387    
1388     int FAR PASCAL CommRawOut(PComVar cv, PCHAR B, int C)
1389     {
1390     int a;
1391    
1392 maya 3392 if ( ! cv->Ready ) {
1393 maya 3227 return C;
1394 maya 3392 }
1395 maya 3227
1396 maya 3392 if (C > OutBuffSize - cv->OutBuffCount) {
1397 maya 3227 a = OutBuffSize - cv->OutBuffCount;
1398 maya 3392 }
1399     else {
1400 maya 3227 a = C;
1401 maya 3392 }
1402 maya 3227 if ( cv->OutPtr > 0 ) {
1403     memmove(&(cv->OutBuff[0]),&(cv->OutBuff[cv->OutPtr]),cv->OutBuffCount);
1404     cv->OutPtr = 0;
1405     }
1406     memcpy(&(cv->OutBuff[cv->OutBuffCount]),B,a);
1407     cv->OutBuffCount = cv->OutBuffCount + a;
1408     return a;
1409     }
1410    
1411     int FAR PASCAL CommBinaryOut(PComVar cv, PCHAR B, int C)
1412     {
1413     int a, i, Len;
1414     char d[3];
1415    
1416 maya 3392 if ( ! cv->Ready ) {
1417 maya 3227 return C;
1418 maya 3392 }
1419 maya 3227
1420     i = 0;
1421     a = 1;
1422     while ((a>0) && (i<C)) {
1423     Len = 0;
1424    
1425     d[Len] = B[i];
1426     Len++;
1427    
1428 doda 3505 if ( cv->TelFlag && (B[i]=='\x0d') && ! cv->TelBinSend ) {
1429     d[Len++] = '\x00';
1430 maya 3227 }
1431 doda 3505 else if ( cv->TelFlag && (B[i]=='\xff') ) {
1432     d[Len++] = '\xff';
1433     }
1434 maya 3227
1435 doda 3505 if ( OutBuffSize - cv->OutBuffCount - Len >= 0 ) {
1436     CommRawOut(cv, d, Len);
1437 maya 3227 a = 1;
1438     }
1439 maya 3392 else {
1440 maya 3227 a = 0;
1441 maya 3392 }
1442 maya 3227
1443 doda 3505 i += a;
1444 maya 3227 }
1445     return i;
1446     }
1447    
1448 doda 3505 int FAR PASCAL CommBinaryBuffOut(PComVar cv, PCHAR B, int C)
1449     {
1450     int a, i, Len, OutLen;
1451     char d[3];
1452    
1453     if ( ! cv->Ready ) {
1454     return C;
1455     }
1456    
1457     i = 0;
1458     a = 1;
1459     while ((a>0) && (i<C)) {
1460     Len = 0;
1461    
1462     d[Len] = B[i];
1463     Len++;
1464    
1465     if (B[i] == CR) {
1466     if ( cv->TelFlag && ! cv->TelBinSend ) {
1467     d[Len++] = '\x00';
1468     }
1469     if (cv->TelLineMode) {
1470     cv->Flush = TRUE;
1471     }
1472     }
1473     else if ( cv->TelFlag && (B[i]=='\xff') ) {
1474     d[Len++] = '\xff';
1475     }
1476    
1477     if (cv->TelLineMode) {
1478     if (OutBuffSize - cv->LineModeBuffCount - Len >= 0) {
1479     memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), d, Len);
1480     cv->LineModeBuffCount += Len;
1481     if (cv->Flush) {
1482     cv->FlushLen = cv->LineModeBuffCount;
1483     }
1484     a = 1;
1485     }
1486     else {
1487     a = 0;
1488     }
1489     if (cv->FlushLen > 0) {
1490     OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
1491     cv->FlushLen -= OutLen;
1492     cv->LineModeBuffCount -= OutLen;
1493     memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
1494     }
1495     cv->Flush = FALSE;
1496     }
1497     else {
1498     if ( OutBuffSize - cv->OutBuffCount - Len >= 0 ) {
1499     CommRawOut(cv, d, Len);
1500     a = 1;
1501     }
1502     else {
1503     a = 0;
1504     }
1505     }
1506    
1507     i += a;
1508     }
1509     return i;
1510     }
1511    
1512 doda 3442 static int OutputTextUTF8(WORD K, char *TempStr, PComVar cv)
1513 maya 3227 {
1514     unsigned int code;
1515 doda 3442 int outlen;
1516     int TempLen = 0;
1517 maya 3227
1518 doda 3442 code = SJIS2UTF8(K, &outlen, cv->Locale);
1519     switch (outlen) {
1520 doda 3457 case 4:
1521     TempStr[TempLen++] = (code >> 24) & 0xff;
1522 doda 3442 case 3:
1523 maya 3227 TempStr[TempLen++] = (code >> 16) & 0xff;
1524 doda 3442 case 2:
1525 maya 3227 TempStr[TempLen++] = (code >> 8) & 0xff;
1526 doda 3442 case 1:
1527 maya 3227 TempStr[TempLen++] = code & 0xff;
1528     }
1529    
1530 doda 3442 return TempLen;
1531 maya 3227 }
1532    
1533     //
1534 doda 3451 // MBCSから各種漢字コードへ変換して出力する。
1535 maya 3227 //
1536 doda 3451 int TextOutMBCS(PComVar cv, PCHAR B, int C)
1537 maya 3227 {
1538 doda 3494 int i, TempLen, OutLen;
1539 maya 3227 WORD K;
1540 doda 3442 char TempStr[12];
1541 maya 3227 int SendCodeNew;
1542     BYTE d;
1543     BOOL Full, KanjiFlagNew;
1544    
1545     Full = FALSE;
1546     i = 0;
1547     while (! Full && (i < C)) {
1548     TempLen = 0;
1549     d = (BYTE)B[i];
1550     SendCodeNew = cv->SendCode;
1551 doda 3442 KanjiFlagNew = FALSE;
1552 maya 3227
1553     if (cv->SendKanjiFlag) {
1554     SendCodeNew = IdKanji;
1555    
1556     K = (cv->SendKanjiFirst << 8) + d;
1557    
1558     // UTF-8への変換を行う。1〜3バイトまでの対応なので注意。
1559 doda 3408 if (cv->KanjiCodeSend == IdUTF8 || cv->Language == IdUtf8) {
1560 doda 3442 TempLen += OutputTextUTF8(K, TempStr, cv);
1561     }
1562     else {
1563     switch (cv->Language) {
1564     case IdJapanese:
1565     switch (cv->KanjiCodeSend) {
1566     case IdEUC:
1567 doda 3419 K = SJIS2EUC(K);
1568 doda 3442 break;
1569     case IdJIS:
1570 doda 3419 K = SJIS2JIS(K);
1571 doda 3442 if ((cv->SendCode==IdKatakana) &&
1572     (cv->JIS7KatakanaSend==1)) {
1573     TempStr[TempLen++] = SI;
1574     }
1575     break;
1576     case IdSJIS:
1577     /* nothing to do */
1578     break;
1579 doda 3419 }
1580 doda 3442 break;
1581     case IdKorean:
1582     break;
1583 maya 3227 }
1584 doda 3442 TempStr[TempLen++] = HIBYTE(K);
1585     TempStr[TempLen++] = LOBYTE(K);
1586 maya 3227 }
1587     }
1588 doda 3932 else if (_isleadbyte_l(d, cv->locale)) {
1589 maya 3227 KanjiFlagNew = TRUE;
1590     cv->SendKanjiFirst = d;
1591     SendCodeNew = IdKanji;
1592    
1593 doda 3442 if (cv->Language == IdJapanese) {
1594     if ((cv->SendCode!=IdKanji) && (cv->KanjiCodeSend==IdJIS)) {
1595     TempStr[0] = 0x1B;
1596     TempStr[1] = '$';
1597     if (cv->KanjiIn == IdKanjiInB) {
1598     TempStr[2] = 'B';
1599     }
1600     else {
1601     TempStr[2] = '@';
1602     }
1603     TempLen = 3;
1604 maya 3392 }
1605 maya 3227 }
1606     }
1607     else {
1608 doda 3442 if (cv->Language == IdJapanese) {
1609     if ((cv->SendCode==IdKanji) && (cv->KanjiCodeSend==IdJIS)) {
1610     TempStr[0] = 0x1B;
1611     TempStr[1] = '(';
1612     switch (cv->KanjiOut) {
1613     case IdKanjiOutJ:
1614 maya 3409 TempStr[2] = 'J';
1615     break;
1616 doda 3442 case IdKanjiOutH:
1617 maya 3409 TempStr[2] = 'H';
1618     break;
1619 doda 3442 default:
1620 maya 3409 TempStr[2] = 'B';
1621 doda 3442 }
1622     TempLen = 3;
1623 maya 3227 }
1624    
1625 doda 3442 if ((0xa0<d) && (d<0xe0)) {
1626     SendCodeNew = IdKatakana;
1627     if ((cv->SendCode!=IdKatakana) &&
1628     (cv->KanjiCodeSend==IdJIS) &&
1629     (cv->JIS7KatakanaSend==1)) {
1630     TempStr[TempLen++] = SO;
1631     }
1632 maya 3227 }
1633 doda 3442 else {
1634     SendCodeNew = IdASCII;
1635     if ((cv->SendCode==IdKatakana) &&
1636     (cv->KanjiCodeSend==IdJIS) &&
1637     (cv->JIS7KatakanaSend==1)) {
1638     TempStr[TempLen++] = SI;
1639     }
1640 maya 3227 }
1641     }
1642    
1643 doda 3497 if (d==CR) {
1644 doda 3442 TempStr[TempLen++] = 0x0d;
1645 maya 3227 if (cv->CRSend==IdCRLF) {
1646 doda 3442 TempStr[TempLen++] = 0x0a;
1647 maya 3227 }
1648     else if ((cv->CRSend==IdCR) &&
1649 doda 3398 cv->TelFlag && ! cv->TelBinSend) {
1650 doda 3442 TempStr[TempLen++] = 0;
1651 maya 3227 }
1652 doda 3494 if (cv->TelLineMode) {
1653     cv->Flush = TRUE;
1654     }
1655 maya 3227 }
1656 doda 3497 else if (d==BS) {
1657     if (cv->TelLineMode) {
1658     if (cv->FlushLen < cv->LineModeBuffCount) {
1659     cv->LineModeBuffCount--;
1660     }
1661     }
1662     else {
1663     TempStr[TempLen++] = d;
1664     }
1665     }
1666 doda 3498 else if (d==0x15) { // Ctrl-U
1667     if (cv->TelLineMode) {
1668     cv->LineModeBuffCount = cv->FlushLen;
1669     }
1670     else {
1671     TempStr[TempLen++] = d;
1672     }
1673     }
1674 doda 3442 else if ((d>=0x80) && (cv->KanjiCodeSend==IdUTF8 || cv->Language==IdUtf8)) {
1675     TempLen += OutputTextUTF8((WORD)d, TempStr, cv);
1676     }
1677     else if ((d>=0xa1) && (d<=0xe0) && (cv->Language == IdJapanese)) {
1678 doda 3452 /* Katakana */
1679 maya 3227 if (cv->KanjiCodeSend==IdEUC) {
1680 doda 3444 TempStr[TempLen++] = (char)SS2;
1681 maya 3227 }
1682     if ((cv->KanjiCodeSend==IdJIS) &&
1683 maya 3392 (cv->JIS7KatakanaSend==1)) {
1684 doda 3442 TempStr[TempLen++] = d & 0x7f;
1685 maya 3392 }
1686     else {
1687 doda 3442 TempStr[TempLen++] = d;
1688 maya 3392 }
1689 maya 3227 }
1690     else {
1691 doda 3442 TempStr[TempLen++] = d;
1692 maya 3227 if (cv->TelFlag && (d==0xff)) {
1693 doda 3442 TempStr[TempLen++] = (char)0xff;
1694 maya 3227 }
1695     }
1696     } // if (cv->SendKanjiFlag) else if ... else ... end
1697    
1698 doda 3494 if (cv->TelLineMode) {
1699     if (TempLen == 0) {
1700     i++;
1701     cv->SendCode = SendCodeNew;
1702     cv->SendKanjiFlag = KanjiFlagNew;
1703     }
1704     else {
1705     Full = OutBuffSize - cv->LineModeBuffCount - TempLen < 0;
1706     if (!Full) {
1707     i++;
1708     cv->SendCode = SendCodeNew;
1709     cv->SendKanjiFlag = KanjiFlagNew;
1710     memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), TempStr, TempLen);
1711     cv->LineModeBuffCount += TempLen;
1712     if (cv->Flush) {
1713     cv->FlushLen = cv->LineModeBuffCount;
1714     }
1715     }
1716     }
1717     if (cv->FlushLen > 0) {
1718     OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
1719     cv->FlushLen -= OutLen;
1720     cv->LineModeBuffCount -= OutLen;
1721     memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
1722     }
1723     cv->Flush = FALSE;
1724 maya 3227 }
1725     else {
1726 doda 3494 if (TempLen == 0) {
1727 maya 3227 i++;
1728     cv->SendCode = SendCodeNew;
1729     cv->SendKanjiFlag = KanjiFlagNew;
1730     }
1731 doda 3494 else {
1732     Full = OutBuffSize-cv->OutBuffCount-TempLen < 0;
1733     if (! Full) {
1734     i++;
1735     cv->SendCode = SendCodeNew;
1736     cv->SendKanjiFlag = KanjiFlagNew;
1737     CommRawOut(cv,TempStr,TempLen);
1738     }
1739     }
1740 maya 3227 }
1741    
1742     } // end of "while {}"
1743    
1744     return i;
1745     }
1746    
1747     int FAR PASCAL CommTextOut(PComVar cv, PCHAR B, int C)
1748     {
1749 doda 3494 int i, TempLen, OutLen;
1750 doda 3442 char TempStr[12];
1751 maya 3227 BYTE d;
1752     BOOL Full;
1753    
1754 maya 3392 if (! cv->Ready ) {
1755 maya 3227 return C;
1756 maya 3392 }
1757 maya 3227
1758 maya 4009 switch (cv->Language) {
1759     case IdUtf8:
1760     case IdJapanese:
1761     case IdKorean:
1762     return TextOutMBCS(cv, B, C);
1763     break;
1764 maya 3392 }
1765 maya 3227
1766     Full = FALSE;
1767     i = 0;
1768     while (! Full && (i < C)) {
1769     TempLen = 0;
1770     d = (BYTE)B[i];
1771    
1772 doda 3497 switch (d) {
1773     case CR:
1774 maya 3227 TempStr[TempLen] = 0x0d;
1775     TempLen++;
1776     if (cv->CRSend==IdCRLF) {
1777 doda 3452 TempStr[TempLen++] = 0x0a;
1778 maya 3227 }
1779 doda 3452 else if (cv->CRSend==IdCR && cv->TelFlag && ! cv->TelBinSend) {
1780     TempStr[TempLen++] = 0;
1781 maya 3227 }
1782 doda 3494 if (cv->TelLineMode) {
1783     cv->Flush = TRUE;
1784     }
1785 doda 3497 break;
1786    
1787     case BS:
1788     if (cv->TelLineMode) {
1789     if (cv->FlushLen < cv->LineModeBuffCount) {
1790     cv->LineModeBuffCount--;
1791     }
1792     }
1793     else {
1794     TempStr[TempLen++] = d;
1795     }
1796     break;
1797    
1798 doda 3498 case 0x15: // Ctrl-U
1799     if (cv->TelLineMode) {
1800     cv->LineModeBuffCount = cv->FlushLen;
1801     }
1802     else {
1803     TempStr[TempLen++] = d;
1804     }
1805 doda 3504 break;
1806 doda 3498
1807 doda 3497 default:
1808 doda 3452 if ((cv->Language==IdRussian) && (d>=128)) {
1809 doda 3494 d = RussConv(cv->RussClient, cv->RussHost, d);
1810 doda 3452 }
1811     TempStr[TempLen++] = d;
1812 maya 3227 if (cv->TelFlag && (d==0xff)) {
1813 doda 3452 TempStr[TempLen++] = (char)0xff;
1814 maya 3227 }
1815     }
1816    
1817 doda 3494 if (cv->TelLineMode) {
1818     Full = OutBuffSize - cv->LineModeBuffCount - TempLen < 0;
1819     if (!Full) {
1820 doda 3888 i++;
1821 doda 3494 memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), TempStr, TempLen);
1822     cv->LineModeBuffCount += TempLen;
1823     if (cv->Flush) {
1824     cv->FlushLen = cv->LineModeBuffCount;
1825     }
1826     }
1827     if (cv->FlushLen > 0) {
1828     OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
1829     cv->FlushLen -= OutLen;
1830     cv->LineModeBuffCount -= OutLen;
1831     memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
1832     }
1833     cv->Flush = FALSE;
1834 maya 3227 }
1835 doda 3494 else {
1836     Full = OutBuffSize - cv->OutBuffCount - TempLen < 0;
1837     if (! Full) {
1838     i++;
1839     CommRawOut(cv,TempStr,TempLen);
1840     }
1841     }
1842 maya 3227 } // end of while {}
1843    
1844     return i;
1845     }
1846    
1847     int FAR PASCAL CommBinaryEcho(PComVar cv, PCHAR B, int C)
1848     {
1849     int a, i, Len;
1850     char d[3];
1851    
1852     if ( ! cv->Ready )
1853     return C;
1854    
1855     if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
1856     memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
1857     cv->InPtr = 0;
1858     }
1859    
1860     i = 0;
1861     a = 1;
1862     while ((a>0) && (i<C)) {
1863     Len = 0;
1864    
1865     d[Len] = B[i];
1866     Len++;
1867    
1868     if ( cv->TelFlag && (B[i]=='\x0d') &&
1869     ! cv->TelBinSend ) {
1870     d[Len] = 0x00;
1871     Len++;
1872     }
1873    
1874     if ( cv->TelFlag && (B[i]=='\xff') ) {
1875     d[Len] = '\xff';
1876     Len++;
1877     }
1878    
1879     if ( InBuffSize-cv->InBuffCount-Len >=0 ) {
1880     memcpy(&(cv->InBuff[cv->InBuffCount]),d,Len);
1881     cv->InBuffCount = cv->InBuffCount + Len;
1882     a = 1;
1883     }
1884     else
1885     a = 0;
1886     i = i + a;
1887     }
1888     return i;
1889     }
1890    
1891 doda 3458 int FAR PASCAL TextEchoMBCS(PComVar cv, PCHAR B, int C)
1892 maya 3227 {
1893     int i, TempLen;
1894     WORD K;
1895 doda 3452 char TempStr[12];
1896 maya 3227 int EchoCodeNew;
1897     BYTE d;
1898     BOOL Full, KanjiFlagNew;
1899    
1900     Full = FALSE;
1901     i = 0;
1902     while (! Full && (i < C)) {
1903     TempLen = 0;
1904     d = (BYTE)B[i];
1905     EchoCodeNew = cv->EchoCode;
1906 doda 3452 KanjiFlagNew = FALSE;
1907 maya 3227
1908     if (cv->EchoKanjiFlag) {
1909     EchoCodeNew = IdKanji;
1910    
1911     K = (cv->EchoKanjiFirst << 8) + d;
1912 doda 3452
1913 maya 3227 // UTF-8への変換を行う。1〜3バイトまでの対応なので注意。
1914 doda 3452 if (cv->KanjiCodeEcho == IdUTF8 || cv->Language==IdUtf8) {
1915 doda 3442 TempLen += OutputTextUTF8(K, TempStr, cv);
1916 maya 3227 }
1917     else {
1918 doda 3452 switch (cv->Language) {
1919     case IdJapanese:
1920     switch (cv->KanjiCodeEcho) {
1921     case IdEUC:
1922     K = SJIS2EUC(K);
1923     break;
1924     case IdJIS:
1925     K = SJIS2JIS(K);
1926     if ((cv->EchoCode==IdKatakana) &&
1927     (cv->JIS7KatakanaEcho==1)) {
1928     TempStr[TempLen++] = SI;
1929     }
1930     break;
1931     case IdSJIS:
1932     /* nothing to do */
1933     break;
1934     }
1935     break;
1936     case IdKorean:
1937     break;
1938 maya 3392 }
1939 doda 3452 TempStr[TempLen++] = HIBYTE(K);
1940     TempStr[TempLen++] = LOBYTE(K);
1941 maya 3227 }
1942     }
1943 doda 3932 else if (_isleadbyte_l(d, cv->locale)) {
1944 maya 3227 KanjiFlagNew = TRUE;
1945     cv->EchoKanjiFirst = d;
1946     EchoCodeNew = IdKanji;
1947    
1948 doda 3452 if (cv->Language == IdJapanese) {
1949     if ((cv->EchoCode!=IdKanji) && (cv->KanjiCodeEcho==IdJIS)) {
1950     TempStr[0] = 0x1B;
1951     TempStr[1] = '$';
1952     if (cv->KanjiIn == IdKanjiInB) {
1953     TempStr[2] = 'B';
1954     }
1955     else {
1956     TempStr[2] = '@';
1957     }
1958     TempLen = 3;
1959 maya 3392 }
1960 maya 3227 }
1961     }
1962     else {
1963 doda 3452 if (cv->Language == IdJapanese) {
1964     if ((cv->EchoCode==IdKanji) && (cv->KanjiCodeEcho==IdJIS)) {
1965     TempStr[0] = 0x1B;
1966     TempStr[1] = '(';
1967     switch (cv->KanjiOut) {
1968     case IdKanjiOutJ:
1969 maya 3227 TempStr[2] = 'J';
1970     break;
1971 doda 3452 case IdKanjiOutH:
1972 maya 3227 TempStr[2] = 'H';
1973     break;
1974 doda 3452 default:
1975 maya 3227 TempStr[2] = 'B';
1976 doda 3452 }
1977     TempLen = 3;
1978 maya 3227 }
1979    
1980 doda 3452 if ((0xa0<d) && (d<0xe0)) {
1981     EchoCodeNew = IdKatakana;
1982     if ((cv->EchoCode!=IdKatakana) &&
1983     (cv->KanjiCodeEcho==IdJIS) &&
1984     (cv->JIS7KatakanaEcho==1)) {
1985     TempStr[TempLen++] = SO;
1986     }
1987 maya 3227 }
1988 doda 3452 else {
1989     EchoCodeNew = IdASCII;
1990     if ((cv->EchoCode==IdKatakana) &&
1991     (cv->KanjiCodeEcho==IdJIS) &&
1992     (cv->JIS7KatakanaEcho==1)) {
1993     TempStr[TempLen++] = SI;
1994     }
1995 maya 3227 }
1996     }
1997    
1998 doda 3503 if (d==CR) {
1999 doda 3452 TempStr[TempLen++] = 0x0d;
2000 maya 3227 if (cv->CRSend==IdCRLF) {
2001 doda 3452 TempStr[TempLen++] = 0x0a;
2002 maya 3227 }
2003     else if ((cv->CRSend==IdCR) &&
2004 maya 3392 cv->TelFlag && ! cv->TelBinSend) {
2005 doda 3452 TempStr[TempLen++] = 0;
2006 maya 3227 }
2007     }
2008 doda 3503 else if (d==0x15) { // Ctrl-U
2009     if (cv->TelLineMode) {
2010     // Move to top of line (CHA "\033[G") and erase line (EL "\033[K")
2011     strncpy_s(TempStr, sizeof(TempStr), "\033[G\033[K", _TRUNCATE);
2012     TempLen += 6;
2013     }
2014     else {
2015     TempStr[TempLen++] = d;
2016     }
2017     }
2018 doda 3452 else if ((d>=0x80) && (cv->KanjiCodeEcho==IdUTF8 || cv->Language==IdUtf8)) {
2019     TempLen += OutputTextUTF8((WORD)d, TempStr, cv);
2020     }
2021     else if ((d>=0xa1) && (d<=0xe0) && (cv->Language == IdJapanese)) {
2022 maya 3227 /* Katakana */
2023     if (cv->KanjiCodeEcho==IdEUC) {
2024 doda 3452 TempStr[TempLen++] = (char)SS2;
2025 maya 3227 }
2026     if ((cv->KanjiCodeEcho==IdJIS) &&
2027 maya 3392 (cv->JIS7KatakanaEcho==1)) {
2028 doda 3452 TempStr[TempLen++] = d & 0x7f;
2029 maya 3392 }
2030     else {
2031 doda 3452 TempStr[TempLen++] = d;
2032 maya 3392 }
2033 maya 3227 }
2034     else {
2035 doda 3452 TempStr[TempLen++] = d;
2036 maya 3227 if (cv->TelFlag && (d==0xff)) {
2037 doda 3452 TempStr[TempLen++] = (char)0xff;
2038 maya 3227 }
2039     }
2040 doda 3452 } // if (cv->EchoKanjiFlag) else if ... else ... end
2041 maya 3227
2042     if (TempLen == 0) {
2043     i++;
2044     cv->EchoCode = EchoCodeNew;
2045     cv->EchoKanjiFlag = KanjiFlagNew;
2046     }
2047     else {
2048     Full = InBuffSize-cv->InBuffCount-TempLen < 0;
2049     if (! Full) {
2050     i++;
2051     cv->EchoCode = EchoCodeNew;
2052     cv->EchoKanjiFlag = KanjiFlagNew;
2053     memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
2054     cv->InBuffCount = cv->InBuffCount + TempLen;
2055     }
2056     }
2057    
2058     } // end of "while {}"
2059    
2060     return i;
2061     }
2062    
2063     int FAR PASCAL CommTextEcho(PComVar cv, PCHAR B, int C)
2064     {
2065     int i, TempLen;
2066     char TempStr[11];
2067     BYTE d;
2068     BOOL Full;
2069    
2070 maya 3392 if ( ! cv->Ready ) {
2071 maya 3227 return C;
2072 maya 3392 }
2073 maya 3227
2074     if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
2075     memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
2076     cv->InPtr = 0;
2077     }
2078    
2079 doda 3452 switch (cv->Language) {
2080     case IdUtf8:
2081     case IdJapanese:
2082     case IdKorean:
2083 doda 3458 return TextEchoMBCS(cv,B,C);
2084 doda 3452 break;
2085 doda 3438 }
2086 maya 3227
2087     Full = FALSE;
2088     i = 0;
2089     while (! Full && (i < C)) {
2090     TempLen = 0;
2091     d = (BYTE)B[i];
2092    
2093 doda 3503 switch (d) {
2094     case CR:
2095 maya 3227 TempStr[TempLen] = 0x0d;
2096     TempLen++;
2097     if (cv->CRSend==IdCRLF) {
2098 doda 3452 TempStr[TempLen++] = 0x0a;
2099 maya 3227 }
2100 doda 3452 else if (cv->CRSend==IdCR && cv->TelFlag && ! cv->TelBinSend) {
2101     TempStr[TempLen++] = 0;
2102 maya 3227 }
2103 doda 3503 break;
2104    
2105     case 0x15: // Ctrl-U
2106     if (cv->TelLineMode) {
2107     // Move to top of line (CHA "\033[G") and erase line (EL "\033[K")
2108     strncpy_s(TempStr, sizeof(TempStr), "\033[G\033[K", _TRUNCATE);
2109     TempLen += 6;
2110     }
2111     else {
2112     TempStr[TempLen++] = d;
2113     }
2114     break;
2115    
2116     default:
2117 doda 3452 if ((cv->Language==IdRussian) && (d>=128)) {
2118 maya 3227 d = RussConv(cv->RussClient,cv->RussHost,d);
2119 maya 3392 }
2120 doda 3452 TempStr[TempLen++] = d;
2121 maya 3227 if (cv->TelFlag && (d==0xff)) {
2122 doda 3452 TempStr[TempLen++] = (char)0xff;
2123 maya 3227 }
2124     }
2125    
2126     Full = InBuffSize-cv->InBuffCount-TempLen < 0;
2127     if (! Full) {
2128     i++;
2129     memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
2130     cv->InBuffCount = cv->InBuffCount + TempLen;
2131     }
2132     } // end of while {}
2133    
2134     return i;
2135     }
2136    
2137     // listup serial port driver
2138     // cf. http://www.codeproject.com/system/setupdi.asp?df=100&forumid=4368&exp=0&select=479661
2139     // (2007.8.17 yutaka)
2140     static void ListupSerialPort(LPWORD ComPortTable, int comports, char **ComPortDesc, int ComPortMax)
2141     {
2142     GUID ClassGuid[1];
2143     DWORD dwRequiredSize;
2144     BOOL bRet;
2145     HDEVINFO DeviceInfoSet = NULL;
2146     SP_DEVINFO_DATA DeviceInfoData;
2147     DWORD dwMemberIndex = 0;
2148     int i;
2149    
2150     DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
2151    
2152     // 以前のメモリをフリーしておく
2153     for (i = 0 ; i < ComPortMax ; i++) {
2154     free(ComPortDesc[i]);
2155     ComPortDesc[i] = NULL;
2156     }
2157    
2158     // Get ClassGuid from ClassName for PORTS class
2159     bRet =
2160     SetupDiClassGuidsFromName(_T("PORTS"), (LPGUID) & ClassGuid, 1,
2161     &dwRequiredSize);
2162 maya 3392 if (!bRet) {
2163 maya 3227 goto cleanup;
2164 maya 3392 }
2165 maya 3227
2166     // Get class devices
2167     // COMポート番号を強制付け替えした場合に、現在のものではなく、レジストリに残っている
2168     // 古いFriendlyNameが表示されてしまう問題への対処。(2007.11.8 yutaka)
2169     DeviceInfoSet =
2170     SetupDiGetClassDevs(&ClassGuid[0], NULL, NULL, DIGCF_PRESENT | DIGCF_PROFILE);
2171    
2172     if (DeviceInfoSet) {
2173     // Enumerate devices
2174     dwMemberIndex = 0;
2175     while (SetupDiEnumDeviceInfo
2176 maya 3392 (DeviceInfoSet, dwMemberIndex++, &DeviceInfoData)) {
2177 maya 3227 TCHAR szFriendlyName[MAX_PATH];
2178     TCHAR szPortName[MAX_PATH];
2179     //TCHAR szMessage[MAX_PATH];
2180     DWORD dwReqSize = 0;
2181     DWORD dwPropType;
2182     DWORD dwType = REG_SZ;
2183     HKEY hKey = NULL;
2184    
2185     // Get friendlyname
2186     bRet = SetupDiGetDeviceRegistryProperty(DeviceInfoSet,
2187     &DeviceInfoData,
2188     SPDRP_FRIENDLYNAME,
2189     &dwPropType,
2190     (LPBYTE)
2191     szFriendlyName,
2192     sizeof(szFriendlyName),
2193     &dwReqSize);
2194    
2195     // Open device parameters reg key
2196     hKey = SetupDiOpenDevRegKey(DeviceInfoSet,
2197     &DeviceInfoData,
2198     DICS_FLAG_GLOBAL,
2199     0, DIREG_DEV, KEY_READ);
2200     if (hKey) {
2201     // Qurey for portname
2202     long lRet;
2203     dwReqSize = sizeof(szPortName);
2204     lRet = RegQueryValueEx(hKey,
2205     _T("PortName"),
2206     0,
2207     &dwType,
2208     (LPBYTE) & szPortName,
2209     &dwReqSize);
2210    
2211     // Close reg key
2212     RegCloseKey(hKey);
2213     }
2214    
2215     #if 0
2216     sprintf(szMessage, _T("Name: %s\nPort: %s\n"), szFriendlyName,
2217     szPortName);
2218     printf("%s\n", szMessage);
2219     #endif
2220    
2221     if (_strnicmp(szPortName, "COM", 3) == 0) { // COMポートドライバを発見
2222     int port = atoi(&szPortName[3]);
2223     int i;
2224    
2225     for (i = 0 ; i < comports ; i++) {
2226     if (ComPortTable[i] == port) { // 接続を確認
2227     ComPortDesc[i] = _strdup(szFriendlyName);
2228     break;
2229     }
2230     }
2231     }
2232    
2233     }
2234     }
2235    
2236 maya 3392 cleanup:
2237 maya 3227 // Destroy device info list
2238     SetupDiDestroyDeviceInfoList(DeviceInfoSet);
2239     }
2240    
2241    
2242     int PASCAL DetectComPorts(LPWORD ComPortTable, int ComPortMax, char **ComPortDesc)
2243     {
2244     HMODULE h;
2245     TCHAR devicesBuff[65535];
2246     TCHAR *p;
2247     int comports = 0;
2248     int i, j, min;
2249     WORD s;
2250    
2251     if (((h = GetModuleHandle("kernel32.dll")) != NULL) &&
2252     (GetProcAddress(h, "QueryDosDeviceA") != NULL) &&
2253     (QueryDosDevice(NULL, devicesBuff, 65535) != 0)) {
2254     p = devicesBuff;
2255     while (*p != '\0') {
2256     if (strncmp(p, "COM", 3) == 0 && p[3] != '\0') {
2257     ComPortTable[comports++] = atoi(p+3);
2258     if (comports >= ComPortMax)
2259     break;
2260     }
2261     p += (strlen(p)+1);
2262     }
2263    
2264     for (i=0; i<comports-1; i++) {
2265     min = i;
2266 maya 3392 for (j=i+1; j<comports; j++) {
2267     if (ComPortTable[min] > ComPortTable[j]) {
2268 maya 3227 min = j;
2269 maya 3392 }
2270     }
2271 maya 3227 if (min != i) {
2272     s = ComPortTable[i];
2273     ComPortTable[i] = ComPortTable[min];
2274     ComPortTable[min] = s;
2275     }
2276     }
2277     }
2278     else {
2279     #if 1
2280     for (i=1; i<=ComPortMax; i++) {
2281     FILE *fp;
2282 maya 3707 char buf[12]; // \\.\COMxxxx + NULL
2283 maya 3227 _snprintf_s(buf, sizeof(buf), _TRUNCATE, "\\\\.\\COM%d", i);
2284     if ((fp = fopen(buf, "r")) != NULL) {
2285     fclose(fp);
2286     ComPortTable[comports++] = i;
2287     }
2288     }
2289     #else
2290     comports = -1;
2291     #endif
2292     }
2293    
2294     ListupSerialPort(ComPortTable, comports, ComPortDesc, ComPortMax);
2295    
2296     return comports;
2297     }
2298    
2299 salarm 6076 int PASCAL CheckComPort(WORD ComPort)
2300     {
2301     HMODULE h;
2302     TCHAR devicesBuff[65535];
2303     char com_str[64];
2304 salarm 6100 BOOL bRet;
2305     GUID ClassGuid[1];
2306     DWORD dwRequiredSize;
2307     HDEVINFO DeviceInfoSet = NULL;