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