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