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