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