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 2556 - (hide annotations) (download) (as text)
Sun Jul 6 06:50:40 2008 UTC (15 years, 9 months ago) by yutakapon
Original Path: teraterm/trunk/ttpcmn/ttcmn.c
File MIME type: text/x-csrc
File size: 41259 byte(s) 
韓国語パッチを追加した。
http://sourceforge.jp/tracker/index.php?func=detail&aid=12957&group_id=1412&atid=5335
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 yutakapon 2556 int TextOutKR(PComVar cv, PCHAR B, int C) //HKS
1272     {
1273     int i, TempLen;
1274     WORD K;
1275     char TempStr[11];
1276     int SendCodeNew;
1277     BYTE d;
1278     BOOL Full, KanjiFlagNew;
1279    
1280     Full = FALSE;
1281     i = 0;
1282     while (! Full && (i < C))
1283     {
1284     TempLen = 0;
1285     d = (BYTE)B[i];
1286     SendCodeNew = cv->SendCode;
1287    
1288     if (cv->SendKanjiFlag)
1289     {
1290     KanjiFlagNew = FALSE;
1291     SendCodeNew = IdKanji;
1292    
1293     K = (cv->SendKanjiFirst << 8) + d;
1294    
1295     // UTF-8への変換を行う。1?3バイトまでの対応なので注意。
1296     if (cv->KanjiCodeSend == IdUTF8) {
1297     OutputTextUTF8(K, TempStr, &TempLen, cv);
1298    
1299     } else {
1300    
1301     if (cv->KanjiCodeSend == IdEUC) K = K;
1302     else if (cv->KanjiCodeSend != IdSJIS) K = K;
1303    
1304     if ((cv->SendCode==IdKatakana) &&
1305     (cv->KanjiCodeSend==IdJIS) &&
1306     (cv->JIS7KatakanaSend==1))
1307     {
1308     TempStr[TempLen] = SI;
1309     TempLen++;
1310     }
1311    
1312     TempStr[TempLen] = HIBYTE(K);
1313     TempStr[TempLen+1] = LOBYTE(K);
1314     TempLen = TempLen + 2;
1315     }
1316     }
1317     else if (IsDBCSLeadByteEx(*cv->CodePage, d))
1318     {
1319     KanjiFlagNew = TRUE;
1320     cv->SendKanjiFirst = d;
1321     SendCodeNew = IdKanji;
1322    
1323     if ((cv->SendCode!=IdKanji) &&
1324     (cv->KanjiCodeSend==IdJIS))
1325     {
1326     TempStr[0] = 0x1B;
1327     TempStr[1] = '$';
1328     if (cv->KanjiIn == IdKanjiInB)
1329     TempStr[2] = 'B';
1330     else
1331     TempStr[2] = '@';
1332     TempLen = 3;
1333     }
1334     else TempLen = 0;
1335     }
1336     else {
1337     KanjiFlagNew = FALSE;
1338    
1339     if ((cv->SendCode==IdKanji) &&
1340     (cv->KanjiCodeSend==IdJIS))
1341     {
1342     TempStr[0] = 0x1B;
1343     TempStr[1] = '(';
1344     switch (cv->KanjiOut) {
1345     case IdKanjiOutJ: TempStr[2] = 'J'; break;
1346     case IdKanjiOutH: TempStr[2] = 'H'; break;
1347     default:
1348     TempStr[2] = 'B';
1349     }
1350     TempLen = 3;
1351     }
1352     else TempLen = 0;
1353    
1354     if ((0xa0<d) && (d<0xe0))
1355     {
1356     SendCodeNew = IdKatakana;
1357     if ((cv->SendCode!=IdKatakana) &&
1358     (cv->KanjiCodeSend==IdJIS) &&
1359     (cv->JIS7KatakanaSend==1))
1360     {
1361     TempStr[TempLen] = SO;
1362     TempLen++;
1363     }
1364     }
1365     else {
1366     SendCodeNew = IdASCII;
1367     if ((cv->SendCode==IdKatakana) &&
1368     (cv->KanjiCodeSend==IdJIS) &&
1369     (cv->JIS7KatakanaSend==1))
1370     {
1371     TempStr[TempLen] = SI;
1372     TempLen++;
1373     }
1374     }
1375    
1376     if (d==0x0d)
1377     {
1378     TempStr[TempLen] = 0x0d;
1379     TempLen++;
1380     if (cv->CRSend==IdCRLF)
1381     {
1382     TempStr[TempLen] = 0x0a;
1383     TempLen++;
1384     }
1385     else if ((cv->CRSend==IdCR) &&
1386     cv->TelFlag && ! cv->TelBinSend)
1387     {
1388     TempStr[TempLen] = 0;
1389     TempLen++;
1390     }
1391     }
1392     else if ((d>=0xa1) && (d<=0xe0))
1393     {
1394     /* Katakana */
1395     if (cv->KanjiCodeSend==IdEUC)
1396     {
1397     TempStr[TempLen] = (char)0x8E;
1398     TempLen++;
1399     }
1400     if ((cv->KanjiCodeSend==IdJIS) &&
1401     (cv->JIS7KatakanaSend==1))
1402     TempStr[TempLen] = d & 0x7f;
1403     else
1404     TempStr[TempLen] = d;
1405     TempLen++;
1406    
1407     // 半角カナはUnicodeでは2バイトになる (2004.10.4 yutaka)
1408     if (cv->KanjiCodeSend==IdUTF8) {
1409     TempLen = 0;
1410     K = d;
1411     OutputTextUTF8(K, TempStr, &TempLen, cv);
1412     }
1413     }
1414     else {
1415     TempStr[TempLen] = d;
1416     TempLen++;
1417     if (cv->TelFlag && (d==0xff))
1418     {
1419     TempStr[TempLen] = (char)0xff;
1420     TempLen++;
1421     }
1422     }
1423     } // if (cv->SendKanjiFlag) else if ... else ... end
1424    
1425     if (TempLen == 0)
1426     {
1427     i++;
1428     cv->SendCode = SendCodeNew;
1429     cv->SendKanjiFlag = KanjiFlagNew;
1430     }
1431     else {
1432     Full = OutBuffSize-cv->OutBuffCount-TempLen < 0;
1433     if (! Full)
1434     {
1435     i++;
1436     cv->SendCode = SendCodeNew;
1437     cv->SendKanjiFlag = KanjiFlagNew;
1438     CommRawOut(cv,TempStr,TempLen);
1439     }
1440     }
1441    
1442     } // end of "while {}"
1443    
1444     return i;
1445     }
1446    
1447 maya 2476 int FAR PASCAL CommTextOut(PComVar cv, PCHAR B, int C)
1448     {
1449     int i, TempLen;
1450     char TempStr[11];
1451     BYTE d;
1452     BOOL Full;
1453    
1454     if (! cv->Ready )
1455     return C;
1456    
1457     if (cv->Language==IdJapanese)
1458     return TextOutJP(cv,B,C);
1459 yutakapon 2556 if (cv->Language==IdKorean) // HKS
1460     return TextOutKR(cv,B,C);
1461 maya 2476
1462 yutakapon 2556
1463 maya 2476 Full = FALSE;
1464     i = 0;
1465     while (! Full && (i < C)) {
1466     TempLen = 0;
1467     d = (BYTE)B[i];
1468    
1469     if (d==0x0d) {
1470     TempStr[TempLen] = 0x0d;
1471     TempLen++;
1472     if (cv->CRSend==IdCRLF) {
1473     TempStr[TempLen] = 0x0a;
1474     TempLen++;
1475     }
1476     else if ((cv->CRSend==IdCR) &&
1477     cv->TelFlag && ! cv->TelBinSend) {
1478     TempStr[TempLen] = 0;
1479     TempLen++;
1480     }
1481     }
1482     else {
1483     if ((cv->Language==IdRussian) &&
1484     (d>=128))
1485     d = RussConv(cv->RussClient,cv->RussHost,d);
1486     TempStr[TempLen] = d;
1487     TempLen++;
1488     if (cv->TelFlag && (d==0xff)) {
1489     TempStr[TempLen] = (char)0xff;
1490     TempLen++;
1491     }
1492     }
1493    
1494     Full = OutBuffSize-cv->OutBuffCount-TempLen < 0;
1495     if (! Full) {
1496     i++;
1497     CommRawOut(cv,TempStr,TempLen);
1498     }
1499     } // end of while {}
1500    
1501     return i;
1502     }
1503    
1504     int FAR PASCAL CommBinaryEcho(PComVar cv, PCHAR B, int C)
1505     {
1506     int a, i, Len;
1507     char d[3];
1508    
1509     if ( ! cv->Ready )
1510     return C;
1511    
1512     if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
1513     memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
1514     cv->InPtr = 0;
1515     }
1516    
1517     i = 0;
1518     a = 1;
1519     while ((a>0) && (i<C)) {
1520     Len = 0;
1521    
1522     d[Len] = B[i];
1523     Len++;
1524    
1525     if ( cv->TelFlag && (B[i]=='\x0d') &&
1526     ! cv->TelBinSend ) {
1527     d[Len] = 0x00;
1528     Len++;
1529     }
1530    
1531     if ( cv->TelFlag && (B[i]=='\xff') ) {
1532     d[Len] = '\xff';
1533     Len++;
1534     }
1535    
1536     if ( InBuffSize-cv->InBuffCount-Len >=0 ) {
1537     memcpy(&(cv->InBuff[cv->InBuffCount]),d,Len);
1538     cv->InBuffCount = cv->InBuffCount + Len;
1539     a = 1;
1540     }
1541     else
1542     a = 0;
1543     i = i + a;
1544     }
1545     return i;
1546     }
1547    
1548     int FAR PASCAL TextEchoJP(PComVar cv, PCHAR B, int C)
1549     {
1550     int i, TempLen;
1551     WORD K;
1552     char TempStr[11];
1553     int EchoCodeNew;
1554     BYTE d;
1555     BOOL Full, KanjiFlagNew;
1556    
1557     Full = FALSE;
1558     i = 0;
1559     while (! Full && (i < C)) {
1560     TempLen = 0;
1561     d = (BYTE)B[i];
1562     EchoCodeNew = cv->EchoCode;
1563    
1564     if (cv->EchoKanjiFlag) {
1565     KanjiFlagNew = FALSE;
1566     EchoCodeNew = IdKanji;
1567    
1568     K = (cv->EchoKanjiFirst << 8) + d;
1569     // UTF-8への変換を行う。1〜3バイトまでの対応なので注意。
1570     if (cv->KanjiCodeSend == IdUTF8) {
1571     OutputTextUTF8(K, TempStr, &TempLen, cv);
1572     }
1573     else {
1574     if (cv->KanjiCodeEcho == IdEUC)
1575     K = SJIS2EUC(K);
1576     else if (cv->KanjiCodeEcho != IdSJIS)
1577     K = SJIS2JIS(K);
1578    
1579     if ((cv->EchoCode==IdKatakana) &&
1580     (cv->KanjiCodeEcho==IdJIS) &&
1581     (cv->JIS7KatakanaEcho==1)) {
1582     TempStr[TempLen] = SI;
1583     TempLen++;
1584     }
1585    
1586     TempStr[TempLen] = HIBYTE(K);
1587     TempStr[TempLen+1] = LOBYTE(K);
1588     TempLen = TempLen + 2;
1589     }
1590     }
1591     else if (IsDBCSLeadByteEx(*cv->CodePage, d)) {
1592     KanjiFlagNew = TRUE;
1593     cv->EchoKanjiFirst = d;
1594     EchoCodeNew = IdKanji;
1595    
1596     if ((cv->EchoCode!=IdKanji) &&
1597     (cv->KanjiCodeEcho==IdJIS)) {
1598     TempStr[0] = 0x1B;
1599     TempStr[1] = '$';
1600     if (cv->KanjiIn == IdKanjiInB)
1601     TempStr[2] = 'B';
1602     else
1603     TempStr[2] = '@';
1604     TempLen = 3;
1605     }
1606     else
1607     TempLen = 0;
1608     }
1609     else {
1610     KanjiFlagNew = FALSE;
1611    
1612     if ((cv->EchoCode==IdKanji) &&
1613     (cv->KanjiCodeEcho==IdJIS)) {
1614     TempStr[0] = 0x1B;
1615     TempStr[1] = '(';
1616     switch (cv->KanjiOut) {
1617     case IdKanjiOutJ:
1618     TempStr[2] = 'J';
1619     break;
1620     case IdKanjiOutH:
1621     TempStr[2] = 'H';
1622     break;
1623     default:
1624     TempStr[2] = 'B';
1625     }
1626     TempLen = 3;
1627     }
1628     else
1629     TempLen = 0;
1630    
1631     if ((0xa0<d) && (d<0xe0)) {
1632     EchoCodeNew = IdKatakana;
1633     if ((cv->EchoCode!=IdKatakana) &&
1634     (cv->KanjiCodeEcho==IdJIS) &&
1635     (cv->JIS7KatakanaEcho==1)) {
1636     TempStr[TempLen] = SO;
1637     TempLen++;
1638     }
1639     }
1640     else {
1641     EchoCodeNew = IdASCII;
1642     if ((cv->EchoCode==IdKatakana) &&
1643     (cv->KanjiCodeEcho==IdJIS) &&
1644     (cv->JIS7KatakanaEcho==1)) {
1645     TempStr[TempLen] = SI;
1646     TempLen++;
1647     }
1648     }
1649    
1650     if (d==0x0d) {
1651     TempStr[TempLen] = 0x0d;
1652     TempLen++;
1653     if (cv->CRSend==IdCRLF) {
1654     TempStr[TempLen] = 0x0a;
1655     TempLen++;
1656     }
1657     else if ((cv->CRSend==IdCR) &&
1658     cv->TelFlag && ! cv->TelBinSend) {
1659     TempStr[TempLen] = 0;
1660     TempLen++;
1661     }
1662     }
1663     else if ((d>=0xa1) && (d<=0xe0)) {
1664     /* Katakana */
1665     if (cv->KanjiCodeEcho==IdEUC) {
1666     TempStr[TempLen] = (char)0x8E;
1667     TempLen++;
1668     }
1669     if ((cv->KanjiCodeEcho==IdJIS) &&
1670     (cv->JIS7KatakanaEcho==1))
1671     TempStr[TempLen] = d & 0x7f;
1672     else
1673     TempStr[TempLen] = d;
1674     TempLen++;
1675     }
1676     else {
1677     TempStr[TempLen] = d;
1678     TempLen++;
1679     if (cv->TelFlag && (d==0xff)) {
1680     TempStr[TempLen] = (char)0xff;
1681     TempLen++;
1682     }
1683     }
1684     } // if (cv->SendKanjiFlag) else if ... else ... end
1685    
1686     if (TempLen == 0) {
1687     i++;
1688     cv->EchoCode = EchoCodeNew;
1689     cv->EchoKanjiFlag = KanjiFlagNew;
1690     }
1691     else {
1692     Full = InBuffSize-cv->InBuffCount-TempLen < 0;
1693     if (! Full) {
1694     i++;
1695     cv->EchoCode = EchoCodeNew;
1696     cv->EchoKanjiFlag = KanjiFlagNew;
1697     memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
1698     cv->InBuffCount = cv->InBuffCount + TempLen;
1699     }
1700     }
1701    
1702     } // end of "while {}"
1703    
1704     return i;
1705     }
1706    
1707     int FAR PASCAL CommTextEcho(PComVar cv, PCHAR B, int C)
1708     {
1709     int i, TempLen;
1710     char TempStr[11];
1711     BYTE d;
1712     BOOL Full;
1713    
1714     if ( ! cv->Ready )
1715     return C;
1716    
1717     if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
1718     memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
1719     cv->InPtr = 0;
1720     }
1721    
1722     if (cv->Language==IdJapanese)
1723     return TextEchoJP(cv,B,C);
1724    
1725     Full = FALSE;
1726     i = 0;
1727     while (! Full && (i < C)) {
1728     TempLen = 0;
1729     d = (BYTE)B[i];
1730    
1731     if (d==0x0d) {
1732     TempStr[TempLen] = 0x0d;
1733     TempLen++;
1734     if (cv->CRSend==IdCRLF) {
1735     TempStr[TempLen] = 0x0a;
1736     TempLen++;
1737     }
1738     else if ((cv->CRSend==IdCR) &&
1739     cv->TelFlag && ! cv->TelBinSend) {
1740     TempStr[TempLen] = 0;
1741     TempLen++;
1742     }
1743     }
1744     else {
1745     if ((cv->Language==IdRussian) &&
1746     (d>=128))
1747     d = RussConv(cv->RussClient,cv->RussHost,d);
1748     TempStr[TempLen] = d;
1749     TempLen++;
1750     if (cv->TelFlag && (d==0xff)) {
1751     TempStr[TempLen] = (char)0xff;
1752     TempLen++;
1753     }
1754     }
1755    
1756     Full = InBuffSize-cv->InBuffCount-TempLen < 0;
1757     if (! Full) {
1758     i++;
1759     memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
1760     cv->InBuffCount = cv->InBuffCount + TempLen;
1761     }
1762     } // end of while {}
1763    
1764     return i;
1765     }
1766    
1767     // listup serial port driver
1768     // cf. http://www.codeproject.com/system/setupdi.asp?df=100&forumid=4368&exp=0&select=479661
1769     // (2007.8.17 yutaka)
1770     static void ListupSerialPort(LPWORD ComPortTable, int comports, char **ComPortDesc, int ComPortMax)
1771     {
1772     GUID ClassGuid[1];
1773     DWORD dwRequiredSize;
1774     BOOL bRet;
1775     HDEVINFO DeviceInfoSet = NULL;
1776     SP_DEVINFO_DATA DeviceInfoData;
1777     DWORD dwMemberIndex = 0;
1778     int i;
1779    
1780     DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
1781    
1782     // 以前のメモリをフリーしておく
1783     for (i = 0 ; i < ComPortMax ; i++) {
1784     free(ComPortDesc[i]);
1785     ComPortDesc[i] = NULL;
1786     }
1787    
1788     // Get ClassGuid from ClassName for PORTS class
1789     bRet =
1790     SetupDiClassGuidsFromName(_T("PORTS"), (LPGUID) & ClassGuid, 1,
1791     &dwRequiredSize);
1792     if (!bRet)
1793     goto cleanup;
1794    
1795     // Get class devices
1796     // COMポート番号を強制付け替えした場合に、現在のものではなく、レジストリに残っている
1797     // 古いFriendlyNameが表示されてしまう問題への対処。(2007.11.8 yutaka)
1798     DeviceInfoSet =
1799     SetupDiGetClassDevs(&ClassGuid[0], NULL, NULL, DIGCF_PRESENT | DIGCF_PROFILE);
1800    
1801     if (DeviceInfoSet) {
1802     // Enumerate devices
1803     dwMemberIndex = 0;
1804     while (SetupDiEnumDeviceInfo
1805     (DeviceInfoSet, dwMemberIndex++, &DeviceInfoData)) {
1806     TCHAR szFriendlyName[MAX_PATH];
1807     TCHAR szPortName[MAX_PATH];
1808     //TCHAR szMessage[MAX_PATH];
1809     DWORD dwReqSize = 0;
1810     DWORD dwPropType;
1811     DWORD dwType = REG_SZ;
1812     HKEY hKey = NULL;
1813    
1814     // Get friendlyname
1815     bRet = SetupDiGetDeviceRegistryProperty(DeviceInfoSet,
1816     &DeviceInfoData,
1817     SPDRP_FRIENDLYNAME,
1818     &dwPropType,
1819     (LPBYTE)
1820     szFriendlyName,
1821     sizeof(szFriendlyName),
1822     &dwReqSize);
1823    
1824     // Open device parameters reg key
1825     hKey = SetupDiOpenDevRegKey(DeviceInfoSet,
1826     &DeviceInfoData,
1827     DICS_FLAG_GLOBAL,
1828     0, DIREG_DEV, KEY_READ);
1829     if (hKey) {
1830     // Qurey for portname
1831     long lRet;
1832     dwReqSize = sizeof(szPortName);
1833     lRet = RegQueryValueEx(hKey,
1834     _T("PortName"),
1835     0,
1836     &dwType,
1837     (LPBYTE) & szPortName,
1838     &dwReqSize);
1839    
1840     // Close reg key
1841     RegCloseKey(hKey);
1842     }
1843    
1844     #if 0
1845     sprintf(szMessage, _T("Name: %s\nPort: %s\n"), szFriendlyName,
1846     szPortName);
1847     printf("%s\n", szMessage);
1848     #endif
1849    
1850     if (_strnicmp(szPortName, "COM", 3) == 0) { // COMポートドライバを発見
1851     int port = atoi(&szPortName[3]);
1852     int i;
1853    
1854     for (i = 0 ; i < comports ; i++) {
1855     if (ComPortTable[i] == port) { // 接続を確認
1856     ComPortDesc[i] = _strdup(szFriendlyName);
1857     break;
1858     }
1859     }
1860     }
1861    
1862     }
1863     }
1864    
1865     cleanup:
1866     // Destroy device info list
1867     SetupDiDestroyDeviceInfoList(DeviceInfoSet);
1868     }
1869    
1870    
1871     int PASCAL DetectComPorts(LPWORD ComPortTable, int ComPortMax, char **ComPortDesc)
1872     {
1873     HMODULE h;
1874     TCHAR devicesBuff[65535];
1875     TCHAR *p;
1876     int comports = 0;
1877     int i, j, min;
1878     WORD s;
1879    
1880     if (((h = GetModuleHandle("kernel32.dll")) != NULL) &&
1881     (GetProcAddress(h, "QueryDosDeviceA") != NULL) &&
1882     (QueryDosDevice(NULL, devicesBuff, 65535) != 0)) {
1883     p = devicesBuff;
1884     while (*p != '\0') {
1885     if (strncmp(p, "COM", 3) == 0 && p[3] != '\0') {
1886     ComPortTable[comports++] = atoi(p+3);
1887     if (comports >= ComPortMax)
1888     break;
1889     }
1890     p += (strlen(p)+1);
1891     }
1892    
1893     for (i=0; i<comports-1; i++) {
1894     min = i;
1895     for (j=i+1; j<comports; j++)
1896     if (ComPortTable[min] > ComPortTable[j])
1897     min = j;
1898     if (min != i) {
1899     s = ComPortTable[i];
1900     ComPortTable[i] = ComPortTable[min];
1901     ComPortTable[min] = s;
1902     }
1903     }
1904     }
1905     else {
1906     #if 1
1907     for (i=1; i<=ComPortMax; i++) {
1908     FILE *fp;
1909     char buf[11]; // \\.\COMxxx + NULL
1910     _snprintf_s(buf, sizeof(buf), _TRUNCATE, "\\\\.\\COM%d", i);
1911     if ((fp = fopen(buf, "r")) != NULL) {
1912     fclose(fp);
1913     ComPortTable[comports++] = i;
1914     }
1915     }
1916     #else
1917     comports = -1;
1918     #endif
1919     }
1920    
1921     ListupSerialPort(ComPortTable, comports, ComPortDesc, ComPortMax);
1922    
1923     return comports;
1924     }
1925    
1926     BOOL WINAPI DllMain(HANDLE hInstance,
1927     ULONG ul_reason_for_call,
1928     LPVOID lpReserved)
1929     {
1930     switch( ul_reason_for_call ) {
1931     case DLL_THREAD_ATTACH:
1932     /* do thread initialization */
1933     break;
1934     case DLL_THREAD_DETACH:
1935     /* do thread cleanup */
1936     break;
1937     case DLL_PROCESS_ATTACH:
1938     /* do process initialization */
1939     hInst = hInstance;
1940     HMap = CreateFileMapping(
1941     (HANDLE) 0xFFFFFFFF, NULL, PAGE_READWRITE,
1942     0, sizeof(TMap), TT_FILEMAPNAME);
1943     if (HMap == NULL)
1944     return FALSE;
1945     FirstInstance = (GetLastError() != ERROR_ALREADY_EXISTS);
1946    
1947     pm = (PMap)MapViewOfFile(HMap,FILE_MAP_WRITE,0,0,0);
1948     if (pm == NULL)
1949     return FALSE;
1950     break;
1951     case DLL_PROCESS_DETACH:
1952     /* do process cleanup */
1953     UnmapViewOfFile(pm);
1954     CloseHandle(HMap);
1955     break;
1956     }
1957     return TRUE;
1958     }
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help