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 5249 - (hide annotations) (download) (as text)
Tue May 7 14:13:12 2013 UTC (10 years, 11 months ago) by yutakapon
File MIME type: text/x-csrc
File size: 51918 byte(s) 
revert SVN#5227
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 yutakapon 4915 #include "tt_res.h"
21 maya 3227
22     /* first instance flag */
23     static BOOL FirstInstance = TRUE;
24    
25     static HINSTANCE hInst;
26    
27     static PMap pm;
28    
29     static HANDLE HMap = NULL;
30     #define VTCLASSNAME "VTWin32"
31     #define TEKCLASSNAME "TEKWin32"
32    
33    
34     void PASCAL CopyShmemToTTSet(PTTSet ts)
35     {
36     // 現在の設定を共有メモリからコピーする
37     memcpy(ts, &pm->ts, sizeof(TTTSet));
38     }
39    
40     void PASCAL CopyTTSetToShmem(PTTSet ts)
41     {
42     // 現在の設定を共有メモリへコピーする
43     memcpy(&pm->ts, ts, sizeof(TTTSet));
44     }
45    
46    
47     BOOL PASCAL FAR StartTeraTerm(PTTSet ts)
48     {
49 maya 4031 char Temp[MAX_PATH];
50 maya 3227
51     if (FirstInstance) {
52     // init window list
53     pm->NWin = 0;
54     }
55     else {
56     /* only the first instance uses saved position */
57     pm->ts.VTPos.x = CW_USEDEFAULT;
58     pm->ts.VTPos.y = CW_USEDEFAULT;
59     pm->ts.TEKPos.x = CW_USEDEFAULT;
60     pm->ts.TEKPos.y = CW_USEDEFAULT;
61     }
62    
63     memcpy(ts,&(pm->ts),sizeof(TTTSet));
64    
65     // if (FirstInstance) { の部分から移動 (2008.3.13 maya)
66     // 起動時には、共有メモリの HomeDir と SetupFName は空になる
67     /* Get home directory */
68 maya 3623 if (GetModuleFileName(hInst,Temp,sizeof(Temp)) == 0) {
69     return TRUE;
70     }
71 maya 3227 ExtractDirName(Temp, ts->HomeDir);
72     _chdir(ts->HomeDir);
73     GetDefaultSetupFName(ts->HomeDir, ts->SetupFName, sizeof(ts->SetupFName));
74    
75     if (FirstInstance) {
76     FirstInstance = FALSE;
77     return TRUE;
78     }
79 maya 3392 else {
80 maya 3227 return FALSE;
81 maya 3392 }
82 maya 3227 }
83    
84 yutakapon 4915 // 設定ファイルをディスクに保存し、Tera Term本体を再起動する。
85     // (2012.4.30 yutaka)
86     void PASCAL FAR RestartTeraTerm(HWND hwnd, PTTSet ts)
87     {
88     char path[1024];
89     STARTUPINFO si;
90     PROCESS_INFORMATION pi;
91 yutakapon 4916 char uimsg[MAX_UIMSG];
92     int ret;
93 yutakapon 4915
94 yutakapon 4916 get_lang_msg("MSG_TT_TAKE_EFFECT", uimsg, sizeof(uimsg),
95     "This option takes effect the next time a session is started.\n"
96     "Are you sure that you want to relaunch Tera Term?"
97     , ts->UILanguageFile);
98     ret = MessageBox(hwnd, uimsg, "Tera Term: Configuration Warning", MB_YESNO | MB_ICONEXCLAMATION | MB_DEFBUTTON2);
99     if (ret != IDYES)
100     return;
101    
102 yutakapon 4915 SendMessage(hwnd, WM_COMMAND, ID_SETUP_SAVE, 0);
103 yutakapon 4919 // ID_FILE_EXIT メッセージではアプリが落ちることがあるため、WM_QUIT をポストする。
104     //PostMessage(hwnd, WM_COMMAND, ID_FILE_EXIT, 0);
105     PostQuitMessage(0);
106 yutakapon 4915
107 yutakapon 4919 // 自プロセスの再起動。
108 yutakapon 4915 if (GetModuleFileName(NULL, path, sizeof(path)) == 0) {
109     return;
110     }
111     memset(&si, 0, sizeof(si));
112     GetStartupInfo(&si);
113     memset(&pi, 0, sizeof(pi));
114     if (CreateProcess(NULL, path, NULL, NULL, FALSE, 0,
115     NULL, NULL, &si, &pi) == 0) {
116     }
117     }
118    
119 maya 3227 void PASCAL FAR ChangeDefaultSet(PTTSet ts, PKeyMap km)
120     {
121     if ((ts!=NULL) &&
122 maya 3392 (_stricmp(ts->SetupFName, pm->ts.SetupFName) == 0)) {
123 maya 3227 memcpy(&(pm->ts),ts,sizeof(TTTSet));
124 maya 3392 }
125     if (km!=NULL) {
126 maya 3227 memcpy(&(pm->km),km,sizeof(TKeyMap));
127 maya 3392 }
128 maya 3227 }
129    
130     void PASCAL FAR GetDefaultSet(PTTSet ts)
131     {
132     memcpy(ts,&(pm->ts),sizeof(TTTSet));
133     }
134    
135    
136     /* Key scan code -> Tera Term key code */
137     WORD PASCAL FAR GetKeyCode(PKeyMap KeyMap, WORD Scan)
138     {
139     WORD Key;
140    
141 maya 3392 if (KeyMap==NULL) {
142 maya 3227 KeyMap = &(pm->km);
143 maya 3392 }
144 maya 3227 Key = IdKeyMax;
145 maya 3392 while ((Key>0) && (KeyMap->Map[Key-1] != Scan)) {
146 maya 3227 Key--;
147 maya 3392 }
148 maya 3227 return Key;
149     }
150    
151     void PASCAL FAR GetKeyStr(HWND HWin, PKeyMap KeyMap, WORD KeyCode,
152     BOOL AppliKeyMode, BOOL AppliCursorMode,
153     BOOL Send8BitMode, PCHAR KeyStr, int destlen,
154     LPINT Len, LPWORD Type)
155     {
156     MSG Msg;
157     char Temp[201];
158    
159 maya 3392 if (KeyMap==NULL) {
160 maya 3227 KeyMap = &(pm->km);
161 maya 3392 }
162 maya 3227
163     *Type = IdBinary; // key type
164     *Len = 0;
165     switch (KeyCode) {
166     case IdUp:
167     if (Send8BitMode) {
168     *Len = 2;
169     if (AppliCursorMode)
170     strncpy_s(KeyStr,destlen,"\217A",_TRUNCATE);
171     else
172     strncpy_s(KeyStr,destlen,"\233A",_TRUNCATE);
173     } else {
174     *Len = 3;
175     if (AppliCursorMode)
176     strncpy_s(KeyStr,destlen,"\033OA",_TRUNCATE);
177     else
178     strncpy_s(KeyStr,destlen,"\033[A",_TRUNCATE);
179     }
180     break;
181     case IdDown:
182     if (Send8BitMode) {
183     *Len = 2;
184     if (AppliCursorMode)
185     strncpy_s(KeyStr,destlen,"\217B",_TRUNCATE);
186     else
187     strncpy_s(KeyStr,destlen,"\233B",_TRUNCATE);
188     } else {
189     *Len = 3;
190     if (AppliCursorMode)
191     strncpy_s(KeyStr,destlen,"\033OB",_TRUNCATE);
192     else
193     strncpy_s(KeyStr,destlen,"\033[B",_TRUNCATE);
194     }
195     break;
196     case IdRight:
197     if (Send8BitMode) {
198     *Len = 2;
199     if (AppliCursorMode)
200     strncpy_s(KeyStr,destlen,"\217C",_TRUNCATE);
201     else
202     strncpy_s(KeyStr,destlen,"\233C",_TRUNCATE);
203     } else {
204     *Len = 3;
205     if (AppliCursorMode)
206     strncpy_s(KeyStr,destlen,"\033OC",_TRUNCATE);
207     else
208     strncpy_s(KeyStr,destlen,"\033[C",_TRUNCATE);
209     }
210     break;
211     case IdLeft:
212     if (Send8BitMode) {
213     *Len = 2;
214     if (AppliCursorMode)
215     strncpy_s(KeyStr,destlen,"\217D",_TRUNCATE);
216     else
217     strncpy_s(KeyStr,destlen,"\233D",_TRUNCATE);
218     } else {
219     *Len = 3;
220     if (AppliCursorMode)
221     strncpy_s(KeyStr,destlen,"\033OD",_TRUNCATE);
222     else
223     strncpy_s(KeyStr,destlen,"\033[D",_TRUNCATE);
224     }
225     break;
226     case Id0:
227     if (AppliKeyMode) {
228     if (Send8BitMode) {
229     *Len = 2;
230     strncpy_s(KeyStr,destlen,"\217p",_TRUNCATE);
231     } else {
232     *Len = 3;
233     strncpy_s(KeyStr,destlen,"\033Op",_TRUNCATE);
234     }
235     }
236     else {
237     *Len = 1;
238     KeyStr[0] = '0';
239     }
240     break;
241     case Id1:
242     if (AppliKeyMode) {
243     if (Send8BitMode) {
244     *Len = 2;
245     strncpy_s(KeyStr,destlen,"\217q",_TRUNCATE);
246     } else {
247     *Len = 3;
248     strncpy_s(KeyStr,destlen,"\033Oq",_TRUNCATE);
249     }
250     }
251     else {
252     *Len = 1;
253     KeyStr[0] = '1';
254     }
255     break;
256     case Id2:
257     if (AppliKeyMode) {
258     if (Send8BitMode) {
259     *Len = 2;
260     strncpy_s(KeyStr,destlen,"\217r",_TRUNCATE);
261     } else {
262     *Len = 3;
263     strncpy_s(KeyStr,destlen,"\033Or",_TRUNCATE);
264     }
265     }
266     else {
267     *Len = 1;
268     KeyStr[0] = '2';
269     }
270     break;
271     case Id3:
272     if (AppliKeyMode) {
273     if (Send8BitMode) {
274     *Len = 2;
275     strncpy_s(KeyStr,destlen,"\217s",_TRUNCATE);
276     } else {
277     *Len = 3;
278     strncpy_s(KeyStr,destlen,"\033Os",_TRUNCATE);
279     }
280     }
281     else {
282     *Len = 1;
283     KeyStr[0] = '3';
284     }
285     break;
286     case Id4:
287     if (AppliKeyMode) {
288     if (Send8BitMode) {
289     *Len = 2;
290     strncpy_s(KeyStr,destlen,"\217t",_TRUNCATE);
291     } else {
292     *Len = 3;
293     strncpy_s(KeyStr,destlen,"\033Ot",_TRUNCATE);
294     }
295     }
296     else {
297     *Len = 1;
298     KeyStr[0] = '4';
299     }
300     break;
301     case Id5:
302     if (AppliKeyMode) {
303     if (Send8BitMode) {
304     *Len = 2;
305     strncpy_s(KeyStr,destlen,"\217u",_TRUNCATE);
306     } else {
307     *Len = 3;
308     strncpy_s(KeyStr,destlen,"\033Ou",_TRUNCATE);
309     }
310     }
311     else {
312     *Len = 1;
313     KeyStr[0] = '5';
314     }
315     break;
316     case Id6:
317     if (AppliKeyMode) {
318     if (Send8BitMode) {
319     *Len = 2;
320     strncpy_s(KeyStr,destlen,"\217v",_TRUNCATE);
321     } else {
322     *Len = 3;
323     strncpy_s(KeyStr,destlen,"\033Ov",_TRUNCATE);
324     }
325     }
326     else {
327     *Len = 1;
328     KeyStr[0] = '6';
329     }
330     break;
331     case Id7:
332     if (AppliKeyMode) {
333     if (Send8BitMode) {
334     *Len = 2;
335     strncpy_s(KeyStr,destlen,"\217w",_TRUNCATE);
336     } else {
337     *Len = 3;
338     strncpy_s(KeyStr,destlen,"\033Ow",_TRUNCATE);
339     }
340     }
341     else {
342     *Len = 1;
343     KeyStr[0] = '7';
344     }
345     break;
346     case Id8:
347     if (AppliKeyMode) {
348     if (Send8BitMode) {
349     *Len = 2;
350     strncpy_s(KeyStr,destlen,"\217x",_TRUNCATE);
351     } else {
352     *Len = 3;
353     strncpy_s(KeyStr,destlen,"\033Ox",_TRUNCATE);
354     }
355     }
356     else {
357     *Len = 1;
358     KeyStr[0] = '8';
359     }
360     break;
361     case Id9:
362     if (AppliKeyMode) {
363     if (Send8BitMode) {
364     *Len = 2;
365     strncpy_s(KeyStr,destlen,"\217y",_TRUNCATE);
366     } else {
367     *Len = 3;
368     strncpy_s(KeyStr,destlen,"\033Oy",_TRUNCATE);
369     }
370     }
371     else {
372     *Len = 1;
373     KeyStr[0] = '9';
374     }
375     break;
376     case IdMinus: /* numeric pad - key (DEC) */
377     if (AppliKeyMode) {
378     if (Send8BitMode) {
379     *Len = 2;
380     strncpy_s(KeyStr,destlen,"\217m",_TRUNCATE);
381     } else {
382     *Len = 3;
383     strncpy_s(KeyStr,destlen,"\033Om",_TRUNCATE);
384     }
385     }
386     else {
387     *Len = 1;
388     KeyStr[0] = '-';
389     }
390     break;
391     case IdComma: /* numeric pad , key (DEC) */
392     if (AppliKeyMode) {
393     if (Send8BitMode) {
394     *Len = 2;
395     strncpy_s(KeyStr,destlen,"\217l",_TRUNCATE);
396     } else {
397     *Len = 3;
398     strncpy_s(KeyStr,destlen,"\033Ol",_TRUNCATE);
399     }
400     }
401     else {
402     *Len = 1;
403     KeyStr[0] = ',';
404     }
405     break;
406     case IdPeriod: /* numeric pad . key */
407     if (AppliKeyMode) {
408     if (Send8BitMode) {
409     *Len = 2;
410     strncpy_s(KeyStr,destlen,"\217n",_TRUNCATE);
411     } else {
412     *Len = 3;
413     strncpy_s(KeyStr,destlen,"\033On",_TRUNCATE);
414     }
415     }
416     else {
417     *Len = 1;
418     KeyStr[0] = '.';
419     }
420     break;
421     case IdEnter: /* numeric pad enter key */
422     if (AppliKeyMode) {
423     if (Send8BitMode) {
424     *Len = 2;
425     strncpy_s(KeyStr,destlen,"\217M",_TRUNCATE);
426     } else {
427     *Len = 3;
428     strncpy_s(KeyStr,destlen,"\033OM",_TRUNCATE);
429     }
430     }
431     else {
432 doda 3900 *Type = IdText; // do new-line conversion
433 maya 3227 *Len = 1;
434     KeyStr[0] = 0x0D;
435     }
436     break;
437     case IdSlash: /* numeric pad slash key */
438     if (AppliKeyMode) {
439     if (Send8BitMode) {
440     *Len = 2;
441     strncpy_s(KeyStr,destlen,"\217o",_TRUNCATE);
442     } else {
443     *Len = 3;
444     strncpy_s(KeyStr,destlen,"\033Oo",_TRUNCATE);
445     }
446     }
447     else {
448     *Len = 1;
449     KeyStr[0] = '/';
450     }
451     break;
452     case IdAsterisk: /* numeric pad asterisk key */
453     if (AppliKeyMode) {
454     if (Send8BitMode) {
455     *Len = 2;
456     strncpy_s(KeyStr,destlen,"\217j",_TRUNCATE);
457     } else {
458     *Len = 3;
459     strncpy_s(KeyStr,destlen,"\033Oj",_TRUNCATE);
460     }
461     }
462     else {
463     *Len = 1;
464     KeyStr[0] = '*';
465     }
466     break;
467     case IdPlus: /* numeric pad plus key */
468     if (AppliKeyMode) {
469     if (Send8BitMode) {
470     *Len = 2;
471     strncpy_s(KeyStr,destlen,"\217k",_TRUNCATE);
472     } else {
473     *Len = 3;
474     strncpy_s(KeyStr,destlen,"\033Ok",_TRUNCATE);
475     }
476     }
477     else {
478     *Len = 1;
479     KeyStr[0] = '+';
480     }
481     break;
482     case IdPF1: /* DEC Key: PF1 */
483     if (Send8BitMode) {
484     *Len = 2;
485     strncpy_s(KeyStr,destlen,"\217P",_TRUNCATE);
486     } else {
487     *Len = 3;
488     strncpy_s(KeyStr,destlen,"\033OP",_TRUNCATE);
489     }
490     break;
491     case IdPF2: /* DEC Key: PF2 */
492     if (Send8BitMode) {
493     *Len = 2;
494     strncpy_s(KeyStr,destlen,"\217Q",_TRUNCATE);
495     } else {
496     *Len = 3;
497     strncpy_s(KeyStr,destlen,"\033OQ",_TRUNCATE);
498     }
499     break;
500     case IdPF3: /* DEC Key: PF3 */
501     if (Send8BitMode) {
502     *Len = 2;
503     strncpy_s(KeyStr,destlen,"\217R",_TRUNCATE);
504     } else {
505     *Len = 3;
506     strncpy_s(KeyStr,destlen,"\033OR",_TRUNCATE);
507     }
508     break;
509     case IdPF4: /* DEC Key: PF4 */
510     if (Send8BitMode) {
511     *Len = 2;
512     strncpy_s(KeyStr,destlen,"\217S",_TRUNCATE);
513     } else {
514     *Len = 3;
515     strncpy_s(KeyStr,destlen,"\033OS",_TRUNCATE);
516     }
517     break;
518     case IdFind: /* DEC Key: Find */
519     if (Send8BitMode) {
520     *Len = 3;
521     strncpy_s(KeyStr,destlen,"\2331~",_TRUNCATE);
522     } else {
523     *Len = 4;
524     strncpy_s(KeyStr,destlen,"\033[1~",_TRUNCATE);
525     }
526     break;
527     case IdInsert: /* DEC Key: Insert Here */
528     if (Send8BitMode) {
529     *Len = 3;
530     strncpy_s(KeyStr,destlen,"\2332~",_TRUNCATE);
531     } else {
532     *Len = 4;
533     strncpy_s(KeyStr,destlen,"\033[2~",_TRUNCATE);
534     }
535     break;
536     case IdRemove: /* DEC Key: Remove */
537     if (Send8BitMode) {
538     *Len = 3;
539     strncpy_s(KeyStr,destlen,"\2333~",_TRUNCATE);
540     } else {
541     *Len = 4;
542     strncpy_s(KeyStr,destlen,"\033[3~",_TRUNCATE);
543     }
544     break;
545     case IdSelect: /* DEC Key: Select */
546     if (Send8BitMode) {
547     *Len = 3;
548     strncpy_s(KeyStr,destlen,"\2334~",_TRUNCATE);
549     } else {
550     *Len = 4;
551     strncpy_s(KeyStr,destlen,"\033[4~",_TRUNCATE);
552     }
553     break;
554     case IdPrev: /* DEC Key: Prev */
555     if (Send8BitMode) {
556     *Len = 3;
557     strncpy_s(KeyStr,destlen,"\2335~",_TRUNCATE);
558     } else {
559     *Len = 4;
560     strncpy_s(KeyStr,destlen,"\033[5~",_TRUNCATE);
561     }
562     break;
563     case IdNext: /* DEC Key: Next */
564     if (Send8BitMode) {
565     *Len = 3;
566     strncpy_s(KeyStr,destlen,"\2336~",_TRUNCATE);
567     } else {
568     *Len = 4;
569     strncpy_s(KeyStr,destlen,"\033[6~",_TRUNCATE);
570     }
571     break;
572     case IdF6: /* DEC Key: F6 */
573     if (Send8BitMode) {
574     *Len = 4;
575     strncpy_s(KeyStr,destlen,"\23317~",_TRUNCATE);
576     } else {
577     *Len = 5;
578     strncpy_s(KeyStr,destlen,"\033[17~",_TRUNCATE);
579     }
580     break;
581     case IdF7: /* DEC Key: F7 */
582     if (Send8BitMode) {
583     *Len = 4;
584     strncpy_s(KeyStr,destlen,"\23318~",_TRUNCATE);
585     } else {
586     *Len = 5;
587     strncpy_s(KeyStr,destlen,"\033[18~",_TRUNCATE);
588     }
589     break;
590     case IdF8: /* DEC Key: F8 */
591     if (Send8BitMode) {
592     *Len = 4;
593     strncpy_s(KeyStr,destlen,"\23319~",_TRUNCATE);
594     } else {
595     *Len = 5;
596     strncpy_s(KeyStr,destlen,"\033[19~",_TRUNCATE);
597     }
598     break;
599     case IdF9: /* DEC Key: F9 */
600     if (Send8BitMode) {
601     *Len = 4;
602     strncpy_s(KeyStr,destlen,"\23320~",_TRUNCATE);
603     } else {
604     *Len = 5;
605     strncpy_s(KeyStr,destlen,"\033[20~",_TRUNCATE);
606     }
607     break;
608     case IdF10: /* DEC Key: F10 */
609     if (Send8BitMode) {
610     *Len = 4;
611     strncpy_s(KeyStr,destlen,"\23321~",_TRUNCATE);
612     } else {
613     *Len = 5;
614     strncpy_s(KeyStr,destlen,"\033[21~",_TRUNCATE);
615     }
616     break;
617     case IdF11: /* DEC Key: F11 */
618     if (Send8BitMode) {
619     *Len = 4;
620     strncpy_s(KeyStr,destlen,"\23323~",_TRUNCATE);
621     } else {
622     *Len = 5;
623     strncpy_s(KeyStr,destlen,"\033[23~",_TRUNCATE);
624     }
625     break;
626     case IdF12: /* DEC Key: F12 */
627     if (Send8BitMode) {
628     *Len = 4;
629     strncpy_s(KeyStr,destlen,"\23324~",_TRUNCATE);
630     } else {
631     *Len = 5;
632     strncpy_s(KeyStr,destlen,"\033[24~",_TRUNCATE);
633     }
634     break;
635     case IdF13: /* DEC Key: F13 */
636     if (Send8BitMode) {
637     *Len = 4;
638     strncpy_s(KeyStr,destlen,"\23325~",_TRUNCATE);
639     } else {
640     *Len = 5;
641     strncpy_s(KeyStr,destlen,"\033[25~",_TRUNCATE);
642     }
643     break;
644     case IdF14: /* DEC Key: F14 */
645     if (Send8BitMode) {
646     *Len = 4;
647     strncpy_s(KeyStr,destlen,"\23326~",_TRUNCATE);
648     } else {
649     *Len = 5;
650     strncpy_s(KeyStr,destlen,"\033[26~",_TRUNCATE);
651     }
652     break;
653     case IdHelp: /* DEC Key: Help */
654     if (Send8BitMode) {
655     *Len = 4;
656     strncpy_s(KeyStr,destlen,"\23328~",_TRUNCATE);
657     } else {
658     *Len = 5;
659     strncpy_s(KeyStr,destlen,"\033[28~",_TRUNCATE);
660     }
661     break;
662     case IdDo: /* DEC Key: Do */
663     if (Send8BitMode) {
664     *Len = 4;
665     strncpy_s(KeyStr,destlen,"\23329~",_TRUNCATE);
666     } else {
667     *Len = 5;
668     strncpy_s(KeyStr,destlen,"\033[29~",_TRUNCATE);
669     }
670     break;
671     case IdF17: /* DEC Key: F17 */
672     if (Send8BitMode) {
673     *Len = 4;
674     strncpy_s(KeyStr,destlen,"\23331~",_TRUNCATE);
675     } else {
676     *Len = 5;
677     strncpy_s(KeyStr,destlen,"\033[31~",_TRUNCATE);
678     }
679     break;
680     case IdF18: /* DEC Key: F18 */
681     if (Send8BitMode) {
682     *Len = 4;
683     strncpy_s(KeyStr,destlen,"\23332~",_TRUNCATE);
684     } else {
685     *Len = 5;
686     strncpy_s(KeyStr,destlen,"\033[32~",_TRUNCATE);
687     }
688     break;
689     case IdF19: /* DEC Key: F19 */
690     if (Send8BitMode) {
691     *Len = 4;
692     strncpy_s(KeyStr,destlen,"\23333~",_TRUNCATE);
693     } else {
694     *Len = 5;
695     strncpy_s(KeyStr,destlen,"\033[33~",_TRUNCATE);
696     }
697     break;
698     case IdF20: /* DEC Key: F20 */
699     if (Send8BitMode) {
700     *Len = 4;
701     strncpy_s(KeyStr,destlen,"\23334~",_TRUNCATE);
702     } else {
703     *Len = 5;
704     strncpy_s(KeyStr,destlen,"\033[34~",_TRUNCATE);
705     }
706     break;
707     case IdXF1: /* XTERM F1 */
708     if (Send8BitMode) {
709     *Len = 4;
710     strncpy_s(KeyStr,destlen,"\23311~",_TRUNCATE);
711     } else {
712     *Len = 5;
713     strncpy_s(KeyStr,destlen,"\033[11~",_TRUNCATE);
714     }
715     break;
716     case IdXF2: /* XTERM F2 */
717     if (Send8BitMode) {
718     *Len = 4;
719     strncpy_s(KeyStr,destlen,"\23312~",_TRUNCATE);
720     } else {
721     *Len = 5;
722     strncpy_s(KeyStr,destlen,"\033[12~",_TRUNCATE);
723     }
724     break;
725     case IdXF3: /* XTERM F3 */
726     if (Send8BitMode) {
727     *Len = 4;
728     strncpy_s(KeyStr,destlen,"\23313~",_TRUNCATE);
729     } else {
730     *Len = 5;
731     strncpy_s(KeyStr,destlen,"\033[13~",_TRUNCATE);
732     }
733     break;
734     case IdXF4: /* XTERM F4 */
735     if (Send8BitMode) {
736     *Len = 4;
737     strncpy_s(KeyStr,destlen,"\23314~",_TRUNCATE);
738     } else {
739     *Len = 5;
740     strncpy_s(KeyStr,destlen,"\033[14~",_TRUNCATE);
741     }
742     break;
743     case IdXF5: /* XTERM F5 */
744     if (Send8BitMode) {
745     *Len = 4;
746     strncpy_s(KeyStr,destlen,"\23315~",_TRUNCATE);
747     } else {
748     *Len = 5;
749     strncpy_s(KeyStr,destlen,"\033[15~",_TRUNCATE);
750     }
751     break;
752 doda 4710 case IdXBackTab: /* XTERM Back Tab */
753     if (Send8BitMode) {
754     *Len = 2;
755     strncpy_s(KeyStr,destlen,"\233Z",_TRUNCATE);
756     } else {
757     *Len = 3;
758     strncpy_s(KeyStr,destlen,"\033[Z",_TRUNCATE);
759     }
760     break;
761 maya 3227 case IdHold:
762     case IdPrint:
763     case IdBreak:
764     case IdCmdEditCopy:
765     case IdCmdEditPaste:
766     case IdCmdEditPasteCR:
767     case IdCmdEditCLS:
768     case IdCmdEditCLB:
769     case IdCmdCtrlOpenTEK:
770     case IdCmdCtrlCloseTEK:
771     case IdCmdLineUp:
772     case IdCmdLineDown:
773     case IdCmdPageUp:
774     case IdCmdPageDown:
775     case IdCmdBuffTop:
776     case IdCmdBuffBottom:
777     case IdCmdNextWin:
778     case IdCmdPrevWin:
779 doda 3950 case IdCmdNextSWin:
780     case IdCmdPrevSWin:
781 maya 3227 case IdCmdLocalEcho:
782 doda 4710 case IdCmdScrollLock:
783 maya 3227 PostMessage(HWin,WM_USER_ACCELCOMMAND,KeyCode,0);
784     break;
785     default:
786     if ((KeyCode >= IdUser1) && (KeyCode <= IdKeyMax)) {
787     *Type = (WORD)(*KeyMap).UserKeyType[KeyCode-IdUser1]; // key type
788     *Len = KeyMap->UserKeyLen[KeyCode-IdUser1];
789     memcpy(Temp,
790     &KeyMap->UserKeyStr[KeyMap->UserKeyPtr[KeyCode-IdUser1]],
791     *Len);
792     Temp[*Len] = 0;
793     if ((*Type==IdBinary) || (*Type==IdText))
794     *Len = Hex2Str(Temp,KeyStr,destlen);
795     else
796     strncpy_s(KeyStr,destlen,Temp,_TRUNCATE);
797     }
798     else
799     return;
800     }
801     /* remove WM_CHAR message for used keycode */
802     PeekMessage(&Msg,HWin, WM_CHAR, WM_CHAR,PM_REMOVE);
803     }
804    
805     void FAR PASCAL SetCOMFlag(int Com)
806     {
807     pm->ComFlag[(Com-1)/CHAR_BIT] |= 1 << ((Com-1)%CHAR_BIT);
808     }
809    
810     void FAR PASCAL ClearCOMFlag(int Com)
811     {
812     pm->ComFlag[(Com-1)/CHAR_BIT] &= ~(1 << ((Com-1)%CHAR_BIT));
813     }
814    
815     int FAR PASCAL CheckCOMFlag(int Com)
816     {
817     return ((pm->ComFlag[(Com-1)/CHAR_BIT] & 1 << (Com-1)%CHAR_BIT) > 0);
818     }
819    
820     int FAR PASCAL RegWin(HWND HWinVT, HWND HWinTEK)
821     {
822     int i, j;
823    
824     if (pm->NWin>=MAXNWIN)
825     return 0;
826     if (HWinVT==NULL)
827     return 0;
828     if (HWinTEK!=NULL) {
829     i = 0;
830     while ((i<pm->NWin) && (pm->WinList[i]!=HWinVT))
831     i++;
832     if (i>=pm->NWin)
833     return 0;
834     for (j=pm->NWin-1 ; j>i ; j--)
835     pm->WinList[j+1] = pm->WinList[j];
836     pm->WinList[i+1] = HWinTEK;
837     pm->NWin++;
838     return 0;
839     }
840     pm->WinList[pm->NWin++] = HWinVT;
841 yutakapon 5223 memset(&pm->WinPrevRect[pm->NWin - 1], 0, sizeof(pm->WinPrevRect[pm->NWin - 1])); // RECT clear
842 maya 3392 if (pm->NWin==1) {
843 maya 3227 return 1;
844 maya 3392 }
845     else {
846 maya 3227 return (int)(SendMessage(pm->WinList[pm->NWin-2],
847 maya 3392 WM_USER_GETSERIALNO,0,0)+1);
848     }
849 maya 3227 }
850    
851     void FAR PASCAL UnregWin(HWND HWin)
852     {
853     int i, j;
854    
855     i = 0;
856 maya 3392 while ((i<pm->NWin) && (pm->WinList[i]!=HWin)) {
857 maya 3227 i++;
858 maya 3392 }
859     if (pm->WinList[i]!=HWin) {
860 maya 3227 return;
861 maya 3392 }
862     for (j=i ; j<pm->NWin-1 ; j++) {
863 maya 3227 pm->WinList[j] = pm->WinList[j+1];
864 yutakapon 5223 pm->WinPrevRect[j] = pm->WinPrevRect[j+1]; // RECT shift
865 maya 3392 }
866     if (pm->NWin>0) {
867 maya 3227 pm->NWin--;
868 maya 3392 }
869 maya 3227 }
870    
871 doda 4073 char GetWindowTypeChar(HWND Hw, HWND HWin)
872     {
873 doda 4076 #if 0
874 doda 4073 if (HWin == Hw)
875     return '*';
876     else if (!IsWindowVisible(Hw))
877 doda 4076 #else
878     if (!IsWindowVisible(Hw))
879     #endif
880 doda 4073 return '#';
881     else if (IsIconic(Hw))
882     return '-';
883     else if (IsZoomed(Hw))
884     return '@';
885     else
886     return '+';
887     }
888    
889 yutakapon 5249 void FAR PASCAL SetWinMenu(HMENU menu, PCHAR buf, int buflen, PCHAR langFile, int VTFlag)
890 maya 3227 {
891     int i;
892     char Temp[MAXPATHLEN];
893     HWND Hw;
894    
895     // delete all items in Window menu
896     i = GetMenuItemCount(menu);
897     if (i>0)
898     do {
899     i--;
900     RemoveMenu(menu,i,MF_BYPOSITION);
901     } while (i>0);
902    
903     i = 0;
904     while (i<pm->NWin) {
905     Hw = pm->WinList[i]; // get window handle
906     if ((GetClassName(Hw,Temp,sizeof(Temp))>0) &&
907     ((strcmp(Temp,VTCLASSNAME)==0) ||
908     (strcmp(Temp,TEKCLASSNAME)==0))) {
909     Temp[0] = '&';
910     Temp[1] = (char)(0x31 + i);
911     Temp[2] = ' ';
912 doda 4073 Temp[3] = GetWindowTypeChar(Hw, NULL);
913     Temp[4] = ' ';
914     GetWindowText(Hw,&Temp[5],sizeof(Temp)-6);
915 maya 3227 AppendMenu(menu,MF_ENABLED | MF_STRING,ID_WINDOW_1+i,Temp);
916     i++;
917 maya 3392 if (i>8) {
918 maya 3227 i = pm->NWin;
919 maya 3392 }
920 maya 3227 }
921 maya 3392 else {
922 maya 3227 UnregWin(Hw);
923 maya 3392 }
924 maya 3227 }
925     get_lang_msg("MENU_WINDOW_WINDOW", buf, buflen, "&Window", langFile);
926     if (VTFlag == 1) {
927 maya 4655 AppendMenu(menu, MF_SEPARATOR, 0, NULL);
928 maya 3227 AppendMenu(menu,MF_ENABLED | MF_STRING,ID_WINDOW_WINDOW, buf);
929 doda 4647
930     get_lang_msg("MENU_WINDOW_MINIMIZEALL", buf, buflen, "&Minimize All", langFile);
931     AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_MINIMIZEALL, buf);
932    
933 yutakapon 5224 get_lang_msg("MENU_WINDOW_CASCADE", buf, buflen, "&Cascade", langFile);
934     AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_CASCADEALL, buf);
935    
936     get_lang_msg("MENU_WINDOW_STACKED", buf, buflen, "&Stacked", langFile);
937     AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_STACKED, buf);
938    
939     get_lang_msg("MENU_WINDOW_SIDEBYSIDE", buf, buflen, "Side &by Side", langFile);
940     AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_SIDEBYSIDE, buf);
941    
942 doda 4647 get_lang_msg("MENU_WINDOW_RESTOREALL", buf, buflen, "&Restore All", langFile);
943     AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_RESTOREALL, buf);
944 maya 3227 }
945     else {
946     AppendMenu(menu,MF_ENABLED | MF_STRING,ID_TEKWINDOW_WINDOW, buf);
947     }
948     }
949    
950     void FAR PASCAL SetWinList(HWND HWin, HWND HDlg, int IList)
951     {
952     int i;
953     char Temp[MAXPATHLEN];
954     HWND Hw;
955    
956     for (i=0; i<pm->NWin; i++) {
957     Hw = pm->WinList[i]; // get window handle
958     if ((GetClassName(Hw,Temp,sizeof(Temp))>0) &&
959     ((strcmp(Temp,VTCLASSNAME)==0) ||
960     (strcmp(Temp,TEKCLASSNAME)==0))) {
961 doda 4073 Temp[0] = GetWindowTypeChar(Hw, HWin);
962     Temp[1] = ' ';
963     GetWindowText(Hw,&Temp[2],sizeof(Temp)-3);
964 maya 3227 SendDlgItemMessage(HDlg, IList, LB_ADDSTRING,
965     0, (LONG)Temp);
966 maya 3392 if (Hw==HWin) {
967     SendDlgItemMessage(HDlg, IList, LB_SETCURSEL, i,0);
968     }
969 maya 3227 }
970 maya 3392 else {
971 maya 3227 UnregWin(Hw);
972 maya 3392 }
973 maya 3227 }
974     }
975    
976     void FAR PASCAL SelectWin(int WinId)
977     {
978     if ((WinId>=0) && (WinId<pm->NWin)) {
979 yutakapon 3673 /* ウィンドウが最大化および最小化されていた場合、その状態を維持できるように、
980     * SW_SHOWNORMAL から SW_SHOW へ変更した。
981     * (2009.11.8 yutaka)
982 maya 3675 * ウィンドウが最小化されているときは元のサイズに戻す(SW_RESTORE)ようにした。
983     * (2009.11.9 maya)
984 yutakapon 3673 */
985 maya 3675 if (IsIconic(pm->WinList[WinId])) {
986     ShowWindow(pm->WinList[WinId],SW_RESTORE);
987     }
988     else {
989     ShowWindow(pm->WinList[WinId],SW_SHOW);
990     }
991 maya 3227 SetForegroundWindow(pm->WinList[WinId]);
992     }
993     }
994    
995 doda 4030 void FAR PASCAL SelectNextWin(HWND HWin, int Next, BOOL SkipIconic)
996 maya 3227 {
997     int i;
998    
999     i = 0;
1000 doda 3950 while ((i < pm->NWin) && (pm->WinList[i]!=HWin)) {
1001     i++;
1002     }
1003     if (pm->WinList[i]!=HWin) {
1004     return;
1005     }
1006    
1007     do {
1008     i += Next;
1009     if (i >= pm->NWin) {
1010     i = 0;
1011     }
1012     else if (i < 0) {
1013     i = pm->NWin-1;
1014     }
1015    
1016     if (pm->WinList[i] == HWin) {
1017 doda 4030 break;
1018 doda 3950 }
1019 doda 4030 } while ((SkipIconic && IsIconic(pm->WinList[i])) || !IsWindowVisible(pm->WinList[i]));
1020 doda 3950
1021     SelectWin(i);
1022     }
1023    
1024 doda 4647 void FAR PASCAL ShowAllWin(int stat) {
1025     int i;
1026 yutakapon 5223 WINDOWPLACEMENT rc0;
1027     RECT rc;
1028     HMONITOR hMonitor;
1029     MONITORINFO mi;
1030 doda 4647
1031 yutakapon 5223 memset(&rc0, 0, sizeof(rc0));
1032    
1033 doda 4647 for (i=0; i < pm->NWin; i++) {
1034 yutakapon 5223 // 復元指定で、前回の状態が残っている場合は、ウィンドウの状態を元に戻す。
1035     if (stat == SW_RESTORE && memcmp(&pm->WinPrevRect[i], &rc0, sizeof(rc0)) != 0) {
1036     rc = pm->WinPrevRect[i].rcNormalPosition;
1037    
1038     // 対象モニタの情報を取得
1039     hMonitor = MonitorFromRect(&rc, MONITOR_DEFAULTTONEAREST);
1040     mi.cbSize = sizeof(MONITORINFO);
1041     GetMonitorInfo(hMonitor, &mi);
1042    
1043     // 位置補正（復元前後で解像度が変わっている場合への対策）
1044     if (rc.right > mi.rcMonitor.right) {
1045     rc.left -= rc.right - mi.rcMonitor.right;
1046     rc.right = mi.rcMonitor.right;
1047     }
1048     if (rc.left < mi.rcMonitor.left) {
1049     rc.right += mi.rcMonitor.left - rc.left;
1050     rc.left = mi.rcMonitor.left;
1051     }
1052     if (rc.bottom > mi.rcMonitor.bottom) {
1053     rc.top -= rc.bottom - mi.rcMonitor.bottom;
1054     rc.bottom = mi.rcMonitor.bottom;
1055     }
1056     if (rc.top < mi.rcMonitor.top) {
1057     rc.bottom += mi.rcMonitor.top - rc.top;
1058     rc.top = mi.rcMonitor.top;
1059     }
1060    
1061     // ウィンドウ位置復元
1062     SetWindowPos(
1063     pm->WinList[i], NULL,
1064     rc.left,
1065     rc.top,
1066     rc.right - rc.left,
1067     rc.bottom - rc.top,
1068     SWP_NOZORDER);
1069    
1070 yutakapon 5230 // ウィンドウの状態復元
1071     ShowWindow(pm->WinList[i], pm->WinPrevRect[i].showCmd);
1072 yutakapon 5223
1073     } else {
1074     ShowWindow(pm->WinList[i], stat);
1075     }
1076 doda 4647 }
1077     }
1078    
1079 maya 3227 HWND FAR PASCAL GetNthWin(int n)
1080     {
1081 maya 3392 if (n<pm->NWin) {
1082 maya 3227 return pm->WinList[n];
1083 maya 3392 }
1084     else {
1085 maya 3227 return NULL;
1086 maya 3392 }
1087 maya 3227 }
1088    
1089 yutakapon 5223 #if 0
1090 yutakapon 5222 // マルチモニターを考慮して、タスクバーを除いたディスプレイサイズを取得する。
1091     static void get_desktop_size_by_multi_monitor(HWND hwnd, RECT *rect)
1092     {
1093     HMONITOR hMon;
1094     MONITORINFO mi;
1095    
1096     // FIXME: Windows95では未定義の模様。
1097     hMon = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
1098    
1099     ZeroMemory( &mi, sizeof( mi ));
1100     mi.cbSize = sizeof( mi );
1101     GetMonitorInfo(hMon, &mi);
1102     *rect = mi.rcWork; // タスクバーを除いたディスプレイサイズ
1103     }
1104 yutakapon 5223 #endif
1105 yutakapon 5222
1106 yutakapon 5223 // 有効なウィンドウを探し、現在位置を記憶させておく。
1107     static void get_valid_window_and_memorize_rect(HWND myhwnd, HWND hwnd[], int *num)
1108 yutakapon 5222 {
1109 yutakapon 5223 int i, n;
1110     WINDOWPLACEMENT wndPlace;
1111 yutakapon 5222
1112     n = 0;
1113     for (i = 0 ; i < pm->NWin ; i++) {
1114 yutakapon 5223 // 現在位置を覚えておく。
1115     wndPlace.length = sizeof(WINDOWPLACEMENT);
1116     GetWindowPlacement(pm->WinList[i], &wndPlace);
1117     pm->WinPrevRect[i] = wndPlace;
1118    
1119     // 自分自身は先頭にする。
1120 yutakapon 5222 if (pm->WinList[i] == myhwnd) {
1121     hwnd[n] = hwnd[0];
1122     hwnd[0] = myhwnd;
1123     } else {
1124     hwnd[n] = pm->WinList[i];
1125     }
1126     n++;
1127     }
1128 yutakapon 5223 *num = n;
1129 yutakapon 5222
1130 yutakapon 5223 // 有効なウィンドウが2つ未満ならば、記憶をクリアする。
1131     if (n <= 1) {
1132     for (i = 0 ; i < pm->NWin ; i++) {
1133     memset(&pm->WinPrevRect[i], 0, sizeof(pm->WinPrevRect[i]));
1134     }
1135 yutakapon 5222 }
1136 yutakapon 5223 }
1137 yutakapon 5222
1138 yutakapon 5223 // ウィンドウを左右に並べて表示する(Show Windows Side by Side)
1139     void FAR PASCAL ShowAllWinSidebySide(HWND myhwnd)
1140     {
1141     int n;
1142     HWND hwnd[MAXNWIN];
1143    
1144     get_valid_window_and_memorize_rect(myhwnd, hwnd, &n);
1145     if (n >= 2) // 有効なウィンドウが2つ以上の場合に限る
1146 yutakapon 5237 TileWindows(NULL, MDITILE_VERTICAL, NULL, n, hwnd);
1147 yutakapon 5222 }
1148    
1149     // ウィンドウを上下に並べて表示する(Show Windows Stacked)
1150     void FAR PASCAL ShowAllWinStacked(HWND myhwnd)
1151     {
1152 yutakapon 5223 int n;
1153 yutakapon 5222 HWND hwnd[MAXNWIN];
1154    
1155 yutakapon 5223 get_valid_window_and_memorize_rect(myhwnd, hwnd, &n);
1156     if (n >= 2) // 有効なウィンドウが2つ以上の場合に限る
1157 yutakapon 5237 TileWindows(NULL, MDITILE_HORIZONTAL, NULL, n, hwnd);
1158 yutakapon 5222 }
1159    
1160     // ウィンドウを重ねて表示する(Cascade)
1161     void FAR PASCAL ShowAllWinCascade(HWND myhwnd)
1162     {
1163 yutakapon 5223 int n;
1164     HWND hwnd[MAXNWIN];
1165    
1166     get_valid_window_and_memorize_rect(myhwnd, hwnd, &n);
1167     if (n >= 2) // 有効なウィンドウが2つ以上の場合に限る
1168     CascadeWindows(NULL, MDITILE_SKIPDISABLED, NULL, n, hwnd);
1169 yutakapon 5222 }
1170    
1171 yutakapon 5232 // 全Tera Termに終了指示を出す。
1172     void FAR PASCAL BroadcastClosingMessage(HWND myhwnd)
1173     {
1174     int i, max;
1175     HWND hwnd[MAXNWIN];
1176    
1177     // Tera Termを終了させると、共有メモリが変化するため、
1178     // いったんバッファにコピーしておく。
1179     max = pm->NWin;
1180     for (i = 0 ; i < pm->NWin ; i++) {
1181     hwnd[i] = pm->WinList[i];
1182     }
1183    
1184     for (i = 0 ; i < max ; i++) {
1185     // 自分自身は最後にする。
1186     if (hwnd[i] == myhwnd)
1187     continue;
1188    
1189     PostMessage(hwnd[i], WM_USER_NONCONFIRM_CLOSE, 0, 0);
1190     }
1191     PostMessage(myhwnd, WM_USER_NONCONFIRM_CLOSE, 0, 0);
1192     }
1193    
1194    
1195 maya 3227 int FAR PASCAL CommReadRawByte(PComVar cv, LPBYTE b)
1196     {
1197 maya 3392 if ( ! cv->Ready ) {
1198 maya 3227 return 0;
1199 maya 3392 }
1200 maya 3227
1201     if ( cv->InBuffCount>0 ) {
1202     *b = cv->InBuff[cv->InPtr];
1203     cv->InPtr++;
1204     cv->InBuffCount--;
1205 maya 3392 if ( cv->InBuffCount==0 ) {
1206 maya 3227 cv->InPtr = 0;
1207 maya 3392 }
1208 maya 3227 return 1;
1209     }
1210     else {
1211     cv->InPtr = 0;
1212     return 0;
1213     }
1214     }
1215    
1216     void PASCAL FAR CommInsert1Byte(PComVar cv, BYTE b)
1217     {
1218 maya 3392 if ( ! cv->Ready ) {
1219 maya 3227 return;
1220 maya 3392 }
1221 maya 3227
1222 maya 3392 if (cv->InPtr == 0) {
1223 maya 3227 memmove(&(cv->InBuff[1]),&(cv->InBuff[0]),cv->InBuffCount);
1224 maya 3392 }
1225     else {
1226 maya 3227 cv->InPtr--;
1227 maya 3392 }
1228 maya 3227 cv->InBuff[cv->InPtr] = b;
1229     cv->InBuffCount++;
1230    
1231 maya 3392 if (cv->HBinBuf!=0 ) {
1232 maya 3227 cv->BinSkip++;
1233 maya 3392 }
1234 maya 3227 }
1235    
1236     void Log1Bin(PComVar cv, BYTE b)
1237     {
1238 maya 3392 if (((cv->FilePause & OpLog)!=0) || cv->ProtoFlag) {
1239 maya 3227 return;
1240 maya 3392 }
1241 maya 3227 if (cv->BinSkip > 0) {
1242     cv->BinSkip--;
1243     return;
1244     }
1245     cv->BinBuf[cv->BinPtr] = b;
1246     cv->BinPtr++;
1247 maya 3392 if (cv->BinPtr>=InBuffSize) {
1248 maya 3227 cv->BinPtr = cv->BinPtr-InBuffSize;
1249 maya 3392 }
1250 maya 3227 if (cv->BCount>=InBuffSize) {
1251     cv->BCount = InBuffSize;
1252     cv->BStart = cv->BinPtr;
1253     }
1254 maya 3392 else {
1255 maya 3227 cv->BCount++;
1256 maya 3392 }
1257 maya 3227 }
1258    
1259     int FAR PASCAL CommRead1Byte(PComVar cv, LPBYTE b)
1260     {
1261     int c;
1262    
1263 maya 3392 if ( ! cv->Ready ) {
1264 maya 3227 return 0;
1265 maya 3392 }
1266 maya 3227
1267     if ((cv->HLogBuf!=NULL) &&
1268     ((cv->LCount>=InBuffSize-10) ||
1269     (cv->DCount>=InBuffSize-10))) {
1270     // 自分のバッファに余裕がない場合は、CPUスケジューリングを他に回し、
1271     // CPUがストールするの防ぐ。
1272     // (2006.10.13 yutaka)
1273     Sleep(1);
1274     return 0;
1275     }
1276    
1277     if ((cv->HBinBuf!=NULL) &&
1278 maya 3392 (cv->BCount>=InBuffSize-10)) {
1279 maya 3227 return 0;
1280 maya 3392 }
1281 maya 3227
1282 maya 3392 if ( cv->TelMode ) {
1283 maya 3227 c = 0;
1284 maya 3392 }
1285     else {
1286 maya 3227 c = CommReadRawByte(cv,b);
1287 maya 3392 }
1288 maya 3227
1289     if ((c==1) && cv->TelCRFlag) {
1290     cv->TelCRFlag = FALSE;
1291 maya 3392 if (*b==0) {
1292     c = 0;
1293     }
1294 maya 3227 }
1295    
1296     if ( c==1 ) {
1297     if ( cv->IACFlag ) {
1298     cv->IACFlag = FALSE;
1299     if ( *b != 0xFF ) {
1300     cv->TelMode = TRUE;
1301     CommInsert1Byte(cv,*b);
1302 maya 3392 if ( cv->HBinBuf!=0 ) {
1303 maya 3227 cv->BinSkip--;
1304 maya 3392 }
1305 maya 3227 c = 0;
1306     }
1307     }
1308     else if ((cv->PortType==IdTCPIP) && (*b==0xFF)) {
1309 maya 3392 if (!cv->TelFlag && cv->TelAutoDetect) { /* TTPLUG */
1310 maya 3227 cv->TelFlag = TRUE;
1311 maya 3392 }
1312 maya 3227 if (cv->TelFlag) {
1313     cv->IACFlag = TRUE;
1314     c = 0;
1315     }
1316     }
1317 maya 3392 else if (cv->TelFlag && ! cv->TelBinRecv && (*b==0x0D)) {
1318 maya 3227 cv->TelCRFlag = TRUE;
1319 maya 3392 }
1320 maya 3227 }
1321    
1322 maya 3392 if ( (c==1) && (cv->HBinBuf!=0) ) {
1323 maya 3227 Log1Bin(cv, *b);
1324 maya 3392 }
1325 maya 3227
1326     return c;
1327     }
1328    
1329     int FAR PASCAL CommRawOut(PComVar cv, PCHAR B, int C)
1330     {
1331     int a;
1332    
1333 maya 3392 if ( ! cv->Ready ) {
1334 maya 3227 return C;
1335 maya 3392 }
1336 maya 3227
1337 maya 3392 if (C > OutBuffSize - cv->OutBuffCount) {
1338 maya 3227 a = OutBuffSize - cv->OutBuffCount;
1339 maya 3392 }
1340     else {
1341 maya 3227 a = C;
1342 maya 3392 }
1343 maya 3227 if ( cv->OutPtr > 0 ) {
1344     memmove(&(cv->OutBuff[0]),&(cv->OutBuff[cv->OutPtr]),cv->OutBuffCount);
1345     cv->OutPtr = 0;
1346     }
1347     memcpy(&(cv->OutBuff[cv->OutBuffCount]),B,a);
1348     cv->OutBuffCount = cv->OutBuffCount + a;
1349     return a;
1350     }
1351    
1352     int FAR PASCAL CommBinaryOut(PComVar cv, PCHAR B, int C)
1353     {
1354     int a, i, Len;
1355     char d[3];
1356    
1357 maya 3392 if ( ! cv->Ready ) {
1358 maya 3227 return C;
1359 maya 3392 }
1360 maya 3227
1361     i = 0;
1362     a = 1;
1363     while ((a>0) && (i<C)) {
1364     Len = 0;
1365    
1366     d[Len] = B[i];
1367     Len++;
1368    
1369 doda 3505 if ( cv->TelFlag && (B[i]=='\x0d') && ! cv->TelBinSend ) {
1370     d[Len++] = '\x00';
1371 maya 3227 }
1372 doda 3505 else if ( cv->TelFlag && (B[i]=='\xff') ) {
1373     d[Len++] = '\xff';
1374     }
1375 maya 3227
1376 doda 3505 if ( OutBuffSize - cv->OutBuffCount - Len >= 0 ) {
1377     CommRawOut(cv, d, Len);
1378 maya 3227 a = 1;
1379     }
1380 maya 3392 else {
1381 maya 3227 a = 0;
1382 maya 3392 }
1383 maya 3227
1384 doda 3505 i += a;
1385 maya 3227 }
1386     return i;
1387     }
1388    
1389 doda 3505 int FAR PASCAL CommBinaryBuffOut(PComVar cv, PCHAR B, int C)
1390     {
1391     int a, i, Len, OutLen;
1392     char d[3];
1393    
1394     if ( ! cv->Ready ) {
1395     return C;
1396     }
1397    
1398     i = 0;
1399     a = 1;
1400     while ((a>0) && (i<C)) {
1401     Len = 0;
1402    
1403     d[Len] = B[i];
1404     Len++;
1405    
1406     if (B[i] == CR) {
1407     if ( cv->TelFlag && ! cv->TelBinSend ) {
1408     d[Len++] = '\x00';
1409     }
1410     if (cv->TelLineMode) {
1411     cv->Flush = TRUE;
1412     }
1413     }
1414     else if ( cv->TelFlag && (B[i]=='\xff') ) {
1415     d[Len++] = '\xff';
1416     }
1417    
1418     if (cv->TelLineMode) {
1419     if (OutBuffSize - cv->LineModeBuffCount - Len >= 0) {
1420     memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), d, Len);
1421     cv->LineModeBuffCount += Len;
1422     if (cv->Flush) {
1423     cv->FlushLen = cv->LineModeBuffCount;
1424     }
1425     a = 1;
1426     }
1427     else {
1428     a = 0;
1429     }
1430     if (cv->FlushLen > 0) {
1431     OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
1432     cv->FlushLen -= OutLen;
1433     cv->LineModeBuffCount -= OutLen;
1434     memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
1435     }
1436     cv->Flush = FALSE;
1437     }
1438     else {
1439     if ( OutBuffSize - cv->OutBuffCount - Len >= 0 ) {
1440     CommRawOut(cv, d, Len);
1441     a = 1;
1442     }
1443     else {
1444     a = 0;
1445     }
1446     }
1447    
1448     i += a;
1449     }
1450     return i;
1451     }
1452    
1453 doda 3442 static int OutputTextUTF8(WORD K, char *TempStr, PComVar cv)
1454 maya 3227 {
1455     unsigned int code;
1456 doda 3442 int outlen;
1457     int TempLen = 0;
1458 maya 3227
1459 doda 3442 code = SJIS2UTF8(K, &outlen, cv->Locale);
1460     switch (outlen) {
1461 doda 3457 case 4:
1462     TempStr[TempLen++] = (code >> 24) & 0xff;
1463 doda 3442 case 3:
1464 maya 3227 TempStr[TempLen++] = (code >> 16) & 0xff;
1465 doda 3442 case 2:
1466 maya 3227 TempStr[TempLen++] = (code >> 8) & 0xff;
1467 doda 3442 case 1:
1468 maya 3227 TempStr[TempLen++] = code & 0xff;
1469     }
1470    
1471 doda 3442 return TempLen;
1472 maya 3227 }
1473    
1474     //
1475 doda 3451 // MBCSから各種漢字コードへ変換して出力する。
1476 maya 3227 //
1477 doda 3451 int TextOutMBCS(PComVar cv, PCHAR B, int C)
1478 maya 3227 {
1479 doda 3494 int i, TempLen, OutLen;
1480 maya 3227 WORD K;
1481 doda 3442 char TempStr[12];
1482 maya 3227 int SendCodeNew;
1483     BYTE d;
1484     BOOL Full, KanjiFlagNew;
1485    
1486     Full = FALSE;
1487     i = 0;
1488     while (! Full && (i < C)) {
1489     TempLen = 0;
1490     d = (BYTE)B[i];
1491     SendCodeNew = cv->SendCode;
1492 doda 3442 KanjiFlagNew = FALSE;
1493 maya 3227
1494     if (cv->SendKanjiFlag) {
1495     SendCodeNew = IdKanji;
1496    
1497     K = (cv->SendKanjiFirst << 8) + d;
1498    
1499     // UTF-8への変換を行う。1〜3バイトまでの対応なので注意。
1500 doda 3408 if (cv->KanjiCodeSend == IdUTF8 || cv->Language == IdUtf8) {
1501 doda 3442 TempLen += OutputTextUTF8(K, TempStr, cv);
1502     }
1503     else {
1504     switch (cv->Language) {
1505     case IdJapanese:
1506     switch (cv->KanjiCodeSend) {
1507     case IdEUC:
1508 doda 3419 K = SJIS2EUC(K);
1509 doda 3442 break;
1510     case IdJIS:
1511 doda 3419 K = SJIS2JIS(K);
1512 doda 3442 if ((cv->SendCode==IdKatakana) &&
1513     (cv->JIS7KatakanaSend==1)) {
1514     TempStr[TempLen++] = SI;
1515     }
1516     break;
1517     case IdSJIS:
1518     /* nothing to do */
1519     break;
1520 doda 3419 }
1521 doda 3442 break;
1522     case IdKorean:
1523     break;
1524 maya 3227 }
1525 doda 3442 TempStr[TempLen++] = HIBYTE(K);
1526     TempStr[TempLen++] = LOBYTE(K);
1527 maya 3227 }
1528     }
1529 doda 3932 else if (_isleadbyte_l(d, cv->locale)) {
1530 maya 3227 KanjiFlagNew = TRUE;
1531     cv->SendKanjiFirst = d;
1532     SendCodeNew = IdKanji;
1533    
1534 doda 3442 if (cv->Language == IdJapanese) {
1535     if ((cv->SendCode!=IdKanji) && (cv->KanjiCodeSend==IdJIS)) {
1536     TempStr[0] = 0x1B;
1537     TempStr[1] = '$';
1538     if (cv->KanjiIn == IdKanjiInB) {
1539     TempStr[2] = 'B';
1540     }
1541     else {
1542     TempStr[2] = '@';
1543     }
1544     TempLen = 3;
1545 maya 3392 }
1546 maya 3227 }
1547     }
1548     else {
1549 doda 3442 if (cv->Language == IdJapanese) {
1550     if ((cv->SendCode==IdKanji) && (cv->KanjiCodeSend==IdJIS)) {
1551     TempStr[0] = 0x1B;
1552     TempStr[1] = '(';
1553     switch (cv->KanjiOut) {
1554     case IdKanjiOutJ:
1555 maya 3409 TempStr[2] = 'J';
1556     break;
1557 doda 3442 case IdKanjiOutH:
1558 maya 3409 TempStr[2] = 'H';
1559     break;
1560 doda 3442 default:
1561 maya 3409 TempStr[2] = 'B';
1562 doda 3442 }
1563     TempLen = 3;
1564 maya 3227 }
1565    
1566 doda 3442 if ((0xa0<d) && (d<0xe0)) {
1567     SendCodeNew = IdKatakana;
1568     if ((cv->SendCode!=IdKatakana) &&
1569     (cv->KanjiCodeSend==IdJIS) &&
1570     (cv->JIS7KatakanaSend==1)) {
1571     TempStr[TempLen++] = SO;
1572     }
1573 maya 3227 }
1574 doda 3442 else {
1575     SendCodeNew = IdASCII;
1576     if ((cv->SendCode==IdKatakana) &&
1577     (cv->KanjiCodeSend==IdJIS) &&
1578     (cv->JIS7KatakanaSend==1)) {
1579     TempStr[TempLen++] = SI;
1580     }
1581 maya 3227 }
1582     }
1583    
1584 doda 3497 if (d==CR) {
1585 doda 3442 TempStr[TempLen++] = 0x0d;
1586 maya 3227 if (cv->CRSend==IdCRLF) {
1587 doda 3442 TempStr[TempLen++] = 0x0a;
1588 maya 3227 }
1589     else if ((cv->CRSend==IdCR) &&
1590 doda 3398 cv->TelFlag && ! cv->TelBinSend) {
1591 doda 3442 TempStr[TempLen++] = 0;
1592 maya 3227 }
1593 doda 3494 if (cv->TelLineMode) {
1594     cv->Flush = TRUE;
1595     }
1596 maya 3227 }
1597 doda 3497 else if (d==BS) {
1598     if (cv->TelLineMode) {
1599     if (cv->FlushLen < cv->LineModeBuffCount) {
1600     cv->LineModeBuffCount--;
1601     }
1602     }
1603     else {
1604     TempStr[TempLen++] = d;
1605     }
1606     }
1607 doda 3498 else if (d==0x15) { // Ctrl-U
1608     if (cv->TelLineMode) {
1609     cv->LineModeBuffCount = cv->FlushLen;
1610     }
1611     else {
1612     TempStr[TempLen++] = d;
1613     }
1614     }
1615 doda 3442 else if ((d>=0x80) && (cv->KanjiCodeSend==IdUTF8 || cv->Language==IdUtf8)) {
1616     TempLen += OutputTextUTF8((WORD)d, TempStr, cv);
1617     }
1618     else if ((d>=0xa1) && (d<=0xe0) && (cv->Language == IdJapanese)) {
1619 doda 3452 /* Katakana */
1620 maya 3227 if (cv->KanjiCodeSend==IdEUC) {
1621 doda 3444 TempStr[TempLen++] = (char)SS2;
1622 maya 3227 }
1623     if ((cv->KanjiCodeSend==IdJIS) &&
1624 maya 3392 (cv->JIS7KatakanaSend==1)) {
1625 doda 3442 TempStr[TempLen++] = d & 0x7f;
1626 maya 3392 }
1627     else {
1628 doda 3442 TempStr[TempLen++] = d;
1629 maya 3392 }
1630 maya 3227 }
1631     else {
1632 doda 3442 TempStr[TempLen++] = d;
1633 maya 3227 if (cv->TelFlag && (d==0xff)) {
1634 doda 3442 TempStr[TempLen++] = (char)0xff;
1635 maya 3227 }
1636     }
1637     } // if (cv->SendKanjiFlag) else if ... else ... end
1638    
1639 doda 3494 if (cv->TelLineMode) {
1640     if (TempLen == 0) {
1641     i++;
1642     cv->SendCode = SendCodeNew;
1643     cv->SendKanjiFlag = KanjiFlagNew;
1644     }
1645     else {
1646     Full = OutBuffSize - cv->LineModeBuffCount - TempLen < 0;
1647     if (!Full) {
1648     i++;
1649     cv->SendCode = SendCodeNew;
1650     cv->SendKanjiFlag = KanjiFlagNew;
1651     memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), TempStr, TempLen);
1652     cv->LineModeBuffCount += TempLen;
1653     if (cv->Flush) {
1654     cv->FlushLen = cv->LineModeBuffCount;
1655     }
1656     }
1657     }
1658     if (cv->FlushLen > 0) {
1659     OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
1660     cv->FlushLen -= OutLen;
1661     cv->LineModeBuffCount -= OutLen;
1662     memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
1663     }
1664     cv->Flush = FALSE;
1665 maya 3227 }
1666     else {
1667 doda 3494 if (TempLen == 0) {
1668 maya 3227 i++;
1669     cv->SendCode = SendCodeNew;
1670     cv->SendKanjiFlag = KanjiFlagNew;
1671     }
1672 doda 3494 else {
1673     Full = OutBuffSize-cv->OutBuffCount-TempLen < 0;
1674     if (! Full) {
1675     i++;
1676     cv->SendCode = SendCodeNew;
1677     cv->SendKanjiFlag = KanjiFlagNew;
1678     CommRawOut(cv,TempStr,TempLen);
1679     }
1680     }
1681 maya 3227 }
1682    
1683     } // end of "while {}"
1684    
1685     return i;
1686     }
1687    
1688     int FAR PASCAL CommTextOut(PComVar cv, PCHAR B, int C)
1689     {
1690 doda 3494 int i, TempLen, OutLen;
1691 doda 3442 char TempStr[12];
1692 maya 3227 BYTE d;
1693     BOOL Full;
1694    
1695 maya 3392 if (! cv->Ready ) {
1696 maya 3227 return C;
1697 maya 3392 }
1698 maya 3227
1699 maya 4009 switch (cv->Language) {
1700     case IdUtf8:
1701     case IdJapanese:
1702     case IdKorean:
1703     return TextOutMBCS(cv, B, C);
1704     break;
1705 maya 3392 }
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 3497 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 3494 if (cv->TelLineMode) {
1724     cv->Flush = TRUE;
1725     }
1726 doda 3497 break;
1727    
1728     case BS:
1729     if (cv->TelLineMode) {
1730     if (cv->FlushLen < cv->LineModeBuffCount) {
1731     cv->LineModeBuffCount--;
1732     }
1733     }
1734     else {
1735     TempStr[TempLen++] = d;
1736     }
1737     break;
1738    
1739 doda 3498 case 0x15: // Ctrl-U
1740     if (cv->TelLineMode) {
1741     cv->LineModeBuffCount = cv->FlushLen;
1742     }
1743     else {
1744     TempStr[TempLen++] = d;
1745     }
1746 doda 3504 break;
1747 doda 3498
1748 doda 3497 default:
1749 doda 3452 if ((cv->Language==IdRussian) && (d>=128)) {
1750 doda 3494 d = RussConv(cv->RussClient, cv->RussHost, d);
1751 doda 3452 }
1752     TempStr[TempLen++] = d;
1753 maya 3227 if (cv->TelFlag && (d==0xff)) {
1754 doda 3452 TempStr[TempLen++] = (char)0xff;
1755 maya 3227 }
1756     }
1757    
1758 doda 3494 if (cv->TelLineMode) {
1759     Full = OutBuffSize - cv->LineModeBuffCount - TempLen < 0;
1760     if (!Full) {
1761 doda 3888 i++;
1762 doda 3494 memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), TempStr, TempLen);
1763     cv->LineModeBuffCount += TempLen;
1764     if (cv->Flush) {
1765     cv->FlushLen = cv->LineModeBuffCount;
1766     }
1767     }
1768     if (cv->FlushLen > 0) {
1769     OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
1770     cv->FlushLen -= OutLen;
1771     cv->LineModeBuffCount -= OutLen;
1772     memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
1773     }
1774     cv->Flush = FALSE;
1775 maya 3227 }
1776 doda 3494 else {
1777     Full = OutBuffSize - cv->OutBuffCount - TempLen < 0;
1778     if (! Full) {
1779     i++;
1780     CommRawOut(cv,TempStr,TempLen);
1781     }
1782     }
1783 maya 3227 } // end of while {}
1784    
1785     return i;
1786     }
1787    
1788     int FAR PASCAL CommBinaryEcho(PComVar cv, PCHAR B, int C)
1789     {
1790     int a, i, Len;
1791     char d[3];
1792    
1793     if ( ! cv->Ready )
1794     return C;
1795    
1796     if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
1797     memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
1798     cv->InPtr = 0;
1799     }
1800    
1801     i = 0;
1802     a = 1;
1803     while ((a>0) && (i<C)) {
1804     Len = 0;
1805    
1806     d[Len] = B[i];
1807     Len++;
1808    
1809     if ( cv->TelFlag && (B[i]=='\x0d') &&
1810     ! cv->TelBinSend ) {
1811     d[Len] = 0x00;
1812     Len++;
1813     }
1814    
1815     if ( cv->TelFlag && (B[i]=='\xff') ) {
1816     d[Len] = '\xff';
1817     Len++;
1818     }
1819    
1820     if ( InBuffSize-cv->InBuffCount-Len >=0 ) {
1821     memcpy(&(cv->InBuff[cv->InBuffCount]),d,Len);
1822     cv->InBuffCount = cv->InBuffCount + Len;
1823     a = 1;
1824     }
1825     else
1826     a = 0;
1827     i = i + a;
1828     }
1829     return i;
1830     }
1831    
1832 doda 3458 int FAR PASCAL TextEchoMBCS(PComVar cv, PCHAR B, int C)
1833 maya 3227 {
1834     int i, TempLen;
1835     WORD K;
1836 doda 3452 char TempStr[12];
1837 maya 3227 int EchoCodeNew;
1838     BYTE d;
1839     BOOL Full, KanjiFlagNew;
1840    
1841     Full = FALSE;
1842     i = 0;
1843     while (! Full && (i < C)) {
1844     TempLen = 0;
1845     d = (BYTE)B[i];
1846     EchoCodeNew = cv->EchoCode;
1847 doda 3452 KanjiFlagNew = FALSE;
1848 maya 3227
1849     if (cv->EchoKanjiFlag) {
1850     EchoCodeNew = IdKanji;
1851    
1852     K = (cv->EchoKanjiFirst << 8) + d;
1853 doda 3452
1854 maya 3227 // UTF-8への変換を行う。1〜3バイトまでの対応なので注意。
1855 doda 3452 if (cv->KanjiCodeEcho == IdUTF8 || cv->Language==IdUtf8) {
1856 doda 3442 TempLen += OutputTextUTF8(K, TempStr, cv);
1857 maya 3227 }
1858     else {
1859 doda 3452 switch (cv->Language) {
1860     case IdJapanese:
1861     switch (cv->KanjiCodeEcho) {
1862     case IdEUC:
1863     K = SJIS2EUC(K);
1864     break;
1865     case IdJIS:
1866     K = SJIS2JIS(K);
1867     if ((cv->EchoCode==IdKatakana) &&
1868     (cv->JIS7KatakanaEcho==1)) {
1869     TempStr[TempLen++] = SI;
1870     }
1871     break;
1872     case IdSJIS:
1873     /* nothing to do */
1874     break;
1875     }
1876     break;
1877     case IdKorean:
1878     break;
1879 maya 3392 }
1880 doda 3452 TempStr[TempLen++] = HIBYTE(K);
1881     TempStr[TempLen++] = LOBYTE(K);
1882 maya 3227 }
1883     }
1884 doda 3932 else if (_isleadbyte_l(d, cv->locale)) {
1885 maya 3227 KanjiFlagNew = TRUE;
1886     cv->EchoKanjiFirst = d;
1887     EchoCodeNew = IdKanji;
1888    
1889 doda 3452 if (cv->Language == IdJapanese) {
1890     if ((cv->EchoCode!=IdKanji) && (cv->KanjiCodeEcho==IdJIS)) {
1891     TempStr[0] = 0x1B;
1892     TempStr[1] = '$';
1893     if (cv->KanjiIn == IdKanjiInB) {
1894     TempStr[2] = 'B';
1895     }
1896     else {
1897     TempStr[2] = '@';
1898     }
1899     TempLen = 3;
1900 maya 3392 }
1901 maya 3227 }
1902     }
1903     else {
1904 doda 3452 if (cv->Language == IdJapanese) {
1905     if ((cv->EchoCode==IdKanji) && (cv->KanjiCodeEcho==IdJIS)) {
1906     TempStr[0] = 0x1B;
1907     TempStr[1] = '(';
1908     switch (cv->KanjiOut) {
1909     case IdKanjiOutJ:
1910 maya 3227 TempStr[2] = 'J';
1911     break;
1912 doda 3452 case IdKanjiOutH:
1913 maya 3227 TempStr[2] = 'H';
1914     break;
1915 doda 3452 default:
1916 maya 3227 TempStr[2] = 'B';
1917 doda 3452 }
1918     TempLen = 3;
1919 maya 3227 }
1920    
1921 doda 3452 if ((0xa0<d) && (d<0xe0)) {
1922     EchoCodeNew = IdKatakana;
1923     if ((cv->EchoCode!=IdKatakana) &&
1924     (cv->KanjiCodeEcho==IdJIS) &&
1925     (cv->JIS7KatakanaEcho==1)) {
1926     TempStr[TempLen++] = SO;
1927     }
1928 maya 3227 }
1929 doda 3452 else {
1930     EchoCodeNew = IdASCII;
1931     if ((cv->EchoCode==IdKatakana) &&
1932     (cv->KanjiCodeEcho==IdJIS) &&
1933     (cv->JIS7KatakanaEcho==1)) {
1934     TempStr[TempLen++] = SI;
1935     }
1936 maya 3227 }
1937     }
1938    
1939 doda 3503 if (d==CR) {
1940 doda 3452 TempStr[TempLen++] = 0x0d;
1941 maya 3227 if (cv->CRSend==IdCRLF) {
1942 doda 3452 TempStr[TempLen++] = 0x0a;
1943 maya 3227 }
1944     else if ((cv->CRSend==IdCR) &&
1945 maya 3392 cv->TelFlag && ! cv->TelBinSend) {
1946 doda 3452 TempStr[TempLen++] = 0;
1947 maya 3227 }
1948     }
1949 doda 3503 else if (d==0x15) { // Ctrl-U
1950     if (cv->TelLineMode) {
1951     // Move to top of line (CHA "\033[G") and erase line (EL "\033[K")
1952     strncpy_s(TempStr, sizeof(TempStr), "\033[G\033[K", _TRUNCATE);
1953     TempLen += 6;
1954     }
1955     else {
1956     TempStr[TempLen++] = d;
1957     }
1958     }
1959 doda 3452 else if ((d>=0x80) && (cv->KanjiCodeEcho==IdUTF8 || cv->Language==IdUtf8)) {
1960     TempLen += OutputTextUTF8((WORD)d, TempStr, cv);
1961     }
1962     else if ((d>=0xa1) && (d<=0xe0) && (cv->Language == IdJapanese)) {
1963 maya 3227 /* Katakana */
1964     if (cv->KanjiCodeEcho==IdEUC) {
1965 doda 3452 TempStr[TempLen++] = (char)SS2;
1966 maya 3227 }
1967     if ((cv->KanjiCodeEcho==IdJIS) &&
1968 maya 3392 (cv->JIS7KatakanaEcho==1)) {
1969 doda 3452 TempStr[TempLen++] = d & 0x7f;
1970 maya 3392 }
1971     else {
1972 doda 3452 TempStr[TempLen++] = d;
1973 maya 3392 }
1974 maya 3227 }
1975     else {
1976 doda 3452 TempStr[TempLen++] = d;
1977 maya 3227 if (cv->TelFlag && (d==0xff)) {
1978 doda 3452 TempStr[TempLen++] = (char)0xff;
1979 maya 3227 }
1980     }
1981 doda 3452 } // if (cv->EchoKanjiFlag) else if ... else ... end
1982 maya 3227
1983     if (TempLen == 0) {
1984     i++;
1985     cv->EchoCode = EchoCodeNew;
1986     cv->EchoKanjiFlag = KanjiFlagNew;
1987     }
1988     else {
1989     Full = InBuffSize-cv->InBuffCount-TempLen < 0;
1990     if (! Full) {
1991     i++;
1992     cv->EchoCode = EchoCodeNew;
1993     cv->EchoKanjiFlag = KanjiFlagNew;
1994     memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
1995     cv->InBuffCount = cv->InBuffCount + TempLen;
1996     }
1997     }
1998    
1999     } // end of "while {}"
2000    
2001     return i;
2002     }
2003    
2004     int FAR PASCAL CommTextEcho(PComVar cv, PCHAR B, int C)
2005     {
2006     int i, TempLen;
2007     char TempStr[11];
2008     BYTE d;
2009     BOOL Full;
2010    
2011 maya 3392 if ( ! cv->Ready ) {
2012 maya 3227 return C;
2013 maya 3392 }
2014 maya 3227
2015     if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
2016     memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
2017     cv->InPtr = 0;
2018     }
2019    
2020 doda 3452 switch (cv->Language) {
2021     case IdUtf8:
2022     case IdJapanese:
2023     case IdKorean:
2024 doda 3458 return TextEchoMBCS(cv,B,C);
2025 doda 3452 break;
2026 doda 3438 }
2027 maya 3227
2028     Full = FALSE;
2029     i = 0;
2030     while (! Full && (i < C)) {
2031     TempLen = 0;
2032     d = (BYTE)B[i];
2033    
2034 doda 3503 switch (d) {
2035     case CR:
2036 maya 3227 TempStr[TempLen] = 0x0d;
2037     TempLen++;
2038     if (cv->CRSend==IdCRLF) {
2039 doda 3452 TempStr[TempLen++] = 0x0a;
2040 maya 3227 }
2041 doda 3452 else if (cv->CRSend==IdCR && cv->TelFlag && ! cv->TelBinSend) {
2042     TempStr[TempLen++] = 0;
2043 maya 3227 }
2044 doda 3503 break;
2045    
2046     case 0x15: // Ctrl-U
2047     if (cv->TelLineMode) {
2048     // Move to top of line (CHA "\033[G") and erase line (EL "\033[K")
2049     strncpy_s(TempStr, sizeof(TempStr), "\033[G\033[K", _TRUNCATE);
2050     TempLen += 6;
2051     }
2052     else {
2053     TempStr[TempLen++] = d;
2054     }
2055     break;
2056    
2057     default:
2058 doda 3452 if ((cv->Language==IdRussian) && (d>=128)) {
2059 maya 3227 d = RussConv(cv->RussClient,cv->RussHost,d);
2060 maya 3392 }
2061 doda 3452 TempStr[TempLen++] = d;
2062 maya 3227 if (cv->TelFlag && (d==0xff)) {
2063 doda 3452 TempStr[TempLen++] = (char)0xff;
2064 maya 3227 }
2065     }
2066    
2067     Full = InBuffSize-cv->InBuffCount-TempLen < 0;
2068     if (! Full) {
2069     i++;
2070     memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
2071     cv->InBuffCount = cv->InBuffCount + TempLen;
2072     }
2073     } // end of while {}
2074    
2075     return i;
2076     }
2077    
2078     // listup serial port driver
2079     // cf. http://www.codeproject.com/system/setupdi.asp?df=100&forumid=4368&exp=0&select=479661
2080     // (2007.8.17 yutaka)
2081     static void ListupSerialPort(LPWORD ComPortTable, int comports, char **ComPortDesc, int ComPortMax)
2082     {
2083     GUID ClassGuid[1];
2084     DWORD dwRequiredSize;
2085     BOOL bRet;
2086     HDEVINFO DeviceInfoSet = NULL;
2087     SP_DEVINFO_DATA DeviceInfoData;
2088     DWORD dwMemberIndex = 0;
2089     int i;
2090    
2091     DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
2092    
2093     // 以前のメモリをフリーしておく
2094     for (i = 0 ; i < ComPortMax ; i++) {
2095     free(ComPortDesc[i]);
2096     ComPortDesc[i] = NULL;
2097     }
2098    
2099     // Get ClassGuid from ClassName for PORTS class
2100     bRet =
2101     SetupDiClassGuidsFromName(_T("PORTS"), (LPGUID) & ClassGuid, 1,
2102     &dwRequiredSize);
2103 maya 3392 if (!bRet) {
2104 maya 3227 goto cleanup;
2105 maya 3392 }
2106 maya 3227
2107     // Get class devices
2108     // COMポート番号を強制付け替えした場合に、現在のものではなく、レジストリに残っている
2109     // 古いFriendlyNameが表示されてしまう問題への対処。(2007.11.8 yutaka)
2110     DeviceInfoSet =
2111     SetupDiGetClassDevs(&ClassGuid[0], NULL, NULL, DIGCF_PRESENT | DIGCF_PROFILE);
2112    
2113     if (DeviceInfoSet) {
2114     // Enumerate devices
2115     dwMemberIndex = 0;
2116     while (SetupDiEnumDeviceInfo
2117 maya 3392 (DeviceInfoSet, dwMemberIndex++, &DeviceInfoData)) {
2118 maya 3227 TCHAR szFriendlyName[MAX_PATH];
2119     TCHAR szPortName[MAX_PATH];
2120     //TCHAR szMessage[MAX_PATH];
2121     DWORD dwReqSize = 0;
2122     DWORD dwPropType;
2123     DWORD dwType = REG_SZ;
2124     HKEY hKey = NULL;
2125    
2126     // Get friendlyname
2127     bRet = SetupDiGetDeviceRegistryProperty(DeviceInfoSet,
2128     &DeviceInfoData,
2129     SPDRP_FRIENDLYNAME,
2130     &dwPropType,
2131     (LPBYTE)
2132     szFriendlyName,
2133     sizeof(szFriendlyName),
2134     &dwReqSize);
2135    
2136     // Open device parameters reg key
2137     hKey = SetupDiOpenDevRegKey(DeviceInfoSet,
2138     &DeviceInfoData,
2139     DICS_FLAG_GLOBAL,
2140     0, DIREG_DEV, KEY_READ);
2141     if (hKey) {
2142     // Qurey for portname
2143     long lRet;
2144     dwReqSize = sizeof(szPortName);
2145     lRet = RegQueryValueEx(hKey,
2146     _T("PortName"),
2147     0,
2148     &dwType,
2149     (LPBYTE) & szPortName,
2150     &dwReqSize);
2151    
2152     // Close reg key
2153     RegCloseKey(hKey);
2154     }
2155    
2156     #if 0
2157     sprintf(szMessage, _T("Name: %s\nPort: %s\n"), szFriendlyName,
2158     szPortName);
2159     printf("%s\n", szMessage);
2160     #endif
2161    
2162     if (_strnicmp(szPortName, "COM", 3) == 0) { // COMポートドライバを発見
2163     int port = atoi(&szPortName[3]);
2164     int i;
2165    
2166     for (i = 0 ; i < comports ; i++) {
2167     if (ComPortTable[i] == port) { // 接続を確認
2168     ComPortDesc[i] = _strdup(szFriendlyName);
2169     break;
2170     }
2171     }
2172     }
2173    
2174     }
2175     }
2176    
2177 maya 3392 cleanup:
2178 maya 3227 // Destroy device info list
2179     SetupDiDestroyDeviceInfoList(DeviceInfoSet);
2180     }
2181    
2182    
2183     int PASCAL DetectComPorts(LPWORD ComPortTable, int ComPortMax, char **ComPortDesc)
2184     {
2185     HMODULE h;
2186     TCHAR devicesBuff[65535];
2187     TCHAR *p;
2188     int comports = 0;
2189     int i, j, min;
2190     WORD s;
2191    
2192     if (((h = GetModuleHandle("kernel32.dll")) != NULL) &&
2193     (GetProcAddress(h, "QueryDosDeviceA") != NULL) &&
2194     (QueryDosDevice(NULL, devicesBuff, 65535) != 0)) {
2195     p = devicesBuff;
2196     while (*p != '\0') {
2197     if (strncmp(p, "COM", 3) == 0 && p[3] != '\0') {
2198     ComPortTable[comports++] = atoi(p+3);
2199     if (comports >= ComPortMax)
2200     break;
2201     }
2202     p += (strlen(p)+1);
2203     }
2204    
2205     for (i=0; i<comports-1; i++) {
2206     min = i;
2207 maya 3392 for (j=i+1; j<comports; j++) {
2208     if (ComPortTable[min] > ComPortTable[j]) {
2209 maya 3227 min = j;
2210 maya 3392 }
2211     }
2212 maya 3227 if (min != i) {
2213     s = ComPortTable[i];
2214     ComPortTable[i] = ComPortTable[min];
2215     ComPortTable[min] = s;
2216     }
2217     }
2218     }
2219     else {
2220     #if 1
2221     for (i=1; i<=ComPortMax; i++) {
2222     FILE *fp;
2223 maya 3707 char buf[12]; // \\.\COMxxxx + NULL
2224 maya 3227 _snprintf_s(buf, sizeof(buf), _TRUNCATE, "\\\\.\\COM%d", i);
2225     if ((fp = fopen(buf, "r")) != NULL) {
2226     fclose(fp);
2227     ComPortTable[comports++] = i;
2228     }
2229     }
2230     #else
2231     comports = -1;
2232     #endif
2233     }
2234    
2235     ListupSerialPort(ComPortTable, comports, ComPortDesc, ComPortMax);
2236    
2237     return comports;
2238     }
2239    
2240     BOOL WINAPI DllMain(HANDLE hInstance,
2241     ULONG ul_reason_for_call,
2242     LPVOID lpReserved)
2243     {
2244     switch( ul_reason_for_call ) {
2245     case DLL_THREAD_ATTACH:
2246     /* do thread initialization */
2247     break;
2248     case DLL_THREAD_DETACH:
2249     /* do thread cleanup */
2250     break;
2251     case DLL_PROCESS_ATTACH:
2252     /* do process initialization */
2253     DoCover_IsDebuggerPresent();
2254     hInst = hInstance;
2255 maya 3392 HMap = CreateFileMapping((HANDLE) 0xFFFFFFFF, NULL, PAGE_READWRITE,
2256     0, sizeof(TMap), TT_FILEMAPNAME);
2257     if (HMap == NULL) {
2258 maya 3227 return FALSE;
2259 maya 3392 }
2260 maya 3227 FirstInstance = (GetLastError() != ERROR_ALREADY_EXISTS);
2261    
2262     pm = (PMap)MapViewOfFile(HMap,FILE_MAP_WRITE,0,0,0);
2263 maya 3392 if (pm == NULL) {
2264 maya 3227 return FALSE;
2265 maya 3392 }
2266 maya 3227 break;
2267     case DLL_PROCESS_DETACH:
2268     /* do process cleanup */
2269     UnmapViewOfFile(pm);
2270     CloseHandle(HMap);
2271     break;
2272     }
2273     return TRUE;
2274     }
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help