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