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