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