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