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