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