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