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