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 5230 - (hide annotations) (download) (as text)
Fri May 3 11:47:56 2013 UTC (10 years, 11 months ago) by yutakapon
File MIME type: text/x-csrc
File size: 52315 byte(s) 
最大化だけではなく、最小化状態も復元できるようにした。
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 yutakapon 5230 // ウィンドウの状態復元
1081     ShowWindow(pm->WinList[i], pm->WinPrevRect[i].showCmd);
1082 yutakapon 5223
1083     } else {
1084     ShowWindow(pm->WinList[i], stat);
1085     }
1086 doda 4647 }
1087     }
1088    
1089 maya 3227 HWND FAR PASCAL GetNthWin(int n)
1090     {
1091 maya 3392 if (n<pm->NWin) {
1092 maya 3227 return pm->WinList[n];
1093 maya 3392 }
1094     else {
1095 maya 3227 return NULL;
1096 maya 3392 }
1097 maya 3227 }
1098    
1099 yutakapon 5223 #if 0
1100 yutakapon 5222 // マルチモニターを考慮して、タスクバーを除いたディスプレイサイズを取得する。
1101     static void get_desktop_size_by_multi_monitor(HWND hwnd, RECT *rect)
1102     {
1103     HMONITOR hMon;
1104     MONITORINFO mi;
1105    
1106     // FIXME: Windows95では未定義の模様。
1107     hMon = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
1108    
1109     ZeroMemory( &mi, sizeof( mi ));
1110     mi.cbSize = sizeof( mi );
1111     GetMonitorInfo(hMon, &mi);
1112     *rect = mi.rcWork; // タスクバーを除いたディスプレイサイズ
1113     }
1114 yutakapon 5223 #endif
1115 yutakapon 5222
1116 yutakapon 5223 // 有効なウィンドウを探し、現在位置を記憶させておく。
1117     static void get_valid_window_and_memorize_rect(HWND myhwnd, HWND hwnd[], int *num)
1118 yutakapon 5222 {
1119 yutakapon 5223 int i, n;
1120     WINDOWPLACEMENT wndPlace;
1121 yutakapon 5222
1122     n = 0;
1123     for (i = 0 ; i < pm->NWin ; i++) {
1124 yutakapon 5223 // 現在位置を覚えておく。
1125     wndPlace.length = sizeof(WINDOWPLACEMENT);
1126     GetWindowPlacement(pm->WinList[i], &wndPlace);
1127     pm->WinPrevRect[i] = wndPlace;
1128    
1129     // 自分自身は先頭にする。
1130 yutakapon 5222 if (pm->WinList[i] == myhwnd) {
1131     hwnd[n] = hwnd[0];
1132     hwnd[0] = myhwnd;
1133     } else {
1134     hwnd[n] = pm->WinList[i];
1135     }
1136     n++;
1137     }
1138 yutakapon 5223 *num = n;
1139 yutakapon 5222
1140 yutakapon 5223 // 有効なウィンドウが2つ未満ならば、記憶をクリアする。
1141     if (n <= 1) {
1142     for (i = 0 ; i < pm->NWin ; i++) {
1143     memset(&pm->WinPrevRect[i], 0, sizeof(pm->WinPrevRect[i]));
1144     }
1145 yutakapon 5222 }
1146 yutakapon 5223 }
1147 yutakapon 5222
1148 yutakapon 5223 // ウィンドウを左右に並べて表示する(Show Windows Side by Side)
1149     void FAR PASCAL ShowAllWinSidebySide(HWND myhwnd)
1150     {
1151     int n;
1152     HWND hwnd[MAXNWIN];
1153    
1154     get_valid_window_and_memorize_rect(myhwnd, hwnd, &n);
1155     if (n >= 2) // 有効なウィンドウが2つ以上の場合に限る
1156     TileWindows(NULL, MDITILE_HORIZONTAL, NULL, n, hwnd);
1157 yutakapon 5222 }
1158    
1159     // ウィンドウを上下に並べて表示する(Show Windows Stacked)
1160     void FAR PASCAL ShowAllWinStacked(HWND myhwnd)
1161     {
1162 yutakapon 5223 int n;
1163 yutakapon 5222 HWND hwnd[MAXNWIN];
1164    
1165 yutakapon 5223 get_valid_window_and_memorize_rect(myhwnd, hwnd, &n);
1166     if (n >= 2) // 有効なウィンドウが2つ以上の場合に限る
1167     TileWindows(NULL, MDITILE_VERTICAL, NULL, n, hwnd);
1168 yutakapon 5222 }
1169    
1170     // ウィンドウを重ねて表示する(Cascade)
1171     void FAR PASCAL ShowAllWinCascade(HWND myhwnd)
1172     {
1173 yutakapon 5223 int n;
1174     HWND hwnd[MAXNWIN];
1175    
1176     get_valid_window_and_memorize_rect(myhwnd, hwnd, &n);
1177     if (n >= 2) // 有効なウィンドウが2つ以上の場合に限る
1178     CascadeWindows(NULL, MDITILE_SKIPDISABLED, NULL, n, hwnd);
1179 yutakapon 5222 }
1180    
1181 yutakapon 5227 // ウィンドウが「常に手前に表示」であるか？
1182     static BOOL GetWindowTopMost(HWND myhwnd)
1183     {
1184     DWORD val;
1185    
1186     val = (DWORD)GetWindowLongPtr(myhwnd, GWL_EXSTYLE);
1187     if (val & WS_EX_TOPMOST)
1188     return TRUE;
1189     else
1190     return FALSE;
1191     }
1192    
1193     // ウィンドウを「常に手前に表示」にするかをトグルで切り替える。
1194     void FAR PASCAL SwitchWindowTopMost(HWND myhwnd)
1195     {
1196     HWND style;
1197    
1198     if (GetWindowTopMost(myhwnd) == TRUE)
1199     style = HWND_NOTOPMOST;
1200     else
1201     style = HWND_TOPMOST;
1202    
1203     SetWindowPos(myhwnd, style, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE );
1204     }
1205    
1206    
1207 maya 3227 int FAR PASCAL CommReadRawByte(PComVar cv, LPBYTE b)
1208     {
1209 maya 3392 if ( ! cv->Ready ) {
1210 maya 3227 return 0;
1211 maya 3392 }
1212 maya 3227
1213     if ( cv->InBuffCount>0 ) {
1214     *b = cv->InBuff[cv->InPtr];
1215     cv->InPtr++;
1216     cv->InBuffCount--;
1217 maya 3392 if ( cv->InBuffCount==0 ) {
1218 maya 3227 cv->InPtr = 0;
1219 maya 3392 }
1220 maya 3227 return 1;
1221     }
1222     else {
1223     cv->InPtr = 0;
1224     return 0;
1225     }
1226     }
1227    
1228     void PASCAL FAR CommInsert1Byte(PComVar cv, BYTE b)
1229     {
1230 maya 3392 if ( ! cv->Ready ) {
1231 maya 3227 return;
1232 maya 3392 }
1233 maya 3227
1234 maya 3392 if (cv->InPtr == 0) {
1235 maya 3227 memmove(&(cv->InBuff[1]),&(cv->InBuff[0]),cv->InBuffCount);
1236 maya 3392 }
1237     else {
1238 maya 3227 cv->InPtr--;
1239 maya 3392 }
1240 maya 3227 cv->InBuff[cv->InPtr] = b;
1241     cv->InBuffCount++;
1242    
1243 maya 3392 if (cv->HBinBuf!=0 ) {
1244 maya 3227 cv->BinSkip++;
1245 maya 3392 }
1246 maya 3227 }
1247    
1248     void Log1Bin(PComVar cv, BYTE b)
1249     {
1250 maya 3392 if (((cv->FilePause & OpLog)!=0) || cv->ProtoFlag) {
1251 maya 3227 return;
1252 maya 3392 }
1253 maya 3227 if (cv->BinSkip > 0) {
1254     cv->BinSkip--;
1255     return;
1256     }
1257     cv->BinBuf[cv->BinPtr] = b;
1258     cv->BinPtr++;
1259 maya 3392 if (cv->BinPtr>=InBuffSize) {
1260 maya 3227 cv->BinPtr = cv->BinPtr-InBuffSize;
1261 maya 3392 }
1262 maya 3227 if (cv->BCount>=InBuffSize) {
1263     cv->BCount = InBuffSize;
1264     cv->BStart = cv->BinPtr;
1265     }
1266 maya 3392 else {
1267 maya 3227 cv->BCount++;
1268 maya 3392 }
1269 maya 3227 }
1270    
1271     int FAR PASCAL CommRead1Byte(PComVar cv, LPBYTE b)
1272     {
1273     int c;
1274    
1275 maya 3392 if ( ! cv->Ready ) {
1276 maya 3227 return 0;
1277 maya 3392 }
1278 maya 3227
1279     if ((cv->HLogBuf!=NULL) &&
1280     ((cv->LCount>=InBuffSize-10) ||
1281     (cv->DCount>=InBuffSize-10))) {
1282     // 自分のバッファに余裕がない場合は、CPUスケジューリングを他に回し、
1283     // CPUがストールするの防ぐ。
1284     // (2006.10.13 yutaka)
1285     Sleep(1);
1286     return 0;
1287     }
1288    
1289     if ((cv->HBinBuf!=NULL) &&
1290 maya 3392 (cv->BCount>=InBuffSize-10)) {
1291 maya 3227 return 0;
1292 maya 3392 }
1293 maya 3227
1294 maya 3392 if ( cv->TelMode ) {
1295 maya 3227 c = 0;
1296 maya 3392 }
1297     else {
1298 maya 3227 c = CommReadRawByte(cv,b);
1299 maya 3392 }
1300 maya 3227
1301     if ((c==1) && cv->TelCRFlag) {
1302     cv->TelCRFlag = FALSE;
1303 maya 3392 if (*b==0) {
1304     c = 0;
1305     }
1306 maya 3227 }
1307    
1308     if ( c==1 ) {
1309     if ( cv->IACFlag ) {
1310     cv->IACFlag = FALSE;
1311     if ( *b != 0xFF ) {
1312     cv->TelMode = TRUE;
1313     CommInsert1Byte(cv,*b);
1314 maya 3392 if ( cv->HBinBuf!=0 ) {
1315 maya 3227 cv->BinSkip--;
1316 maya 3392 }
1317 maya 3227 c = 0;
1318     }
1319     }
1320     else if ((cv->PortType==IdTCPIP) && (*b==0xFF)) {
1321 maya 3392 if (!cv->TelFlag && cv->TelAutoDetect) { /* TTPLUG */
1322 maya 3227 cv->TelFlag = TRUE;
1323 maya 3392 }
1324 maya 3227 if (cv->TelFlag) {
1325     cv->IACFlag = TRUE;
1326     c = 0;
1327     }
1328     }
1329 maya 3392 else if (cv->TelFlag && ! cv->TelBinRecv && (*b==0x0D)) {
1330 maya 3227 cv->TelCRFlag = TRUE;
1331 maya 3392 }
1332 maya 3227 }
1333    
1334 maya 3392 if ( (c==1) && (cv->HBinBuf!=0) ) {
1335 maya 3227 Log1Bin(cv, *b);
1336 maya 3392 }
1337 maya 3227
1338     return c;
1339     }
1340    
1341     int FAR PASCAL CommRawOut(PComVar cv, PCHAR B, int C)
1342     {
1343     int a;
1344    
1345 maya 3392 if ( ! cv->Ready ) {
1346 maya 3227 return C;
1347 maya 3392 }
1348 maya 3227
1349 maya 3392 if (C > OutBuffSize - cv->OutBuffCount) {
1350 maya 3227 a = OutBuffSize - cv->OutBuffCount;
1351 maya 3392 }
1352     else {
1353 maya 3227 a = C;
1354 maya 3392 }
1355 maya 3227 if ( cv->OutPtr > 0 ) {
1356     memmove(&(cv->OutBuff[0]),&(cv->OutBuff[cv->OutPtr]),cv->OutBuffCount);
1357     cv->OutPtr = 0;
1358     }
1359     memcpy(&(cv->OutBuff[cv->OutBuffCount]),B,a);
1360     cv->OutBuffCount = cv->OutBuffCount + a;
1361     return a;
1362     }
1363    
1364     int FAR PASCAL CommBinaryOut(PComVar cv, PCHAR B, int C)
1365     {
1366     int a, i, Len;
1367     char d[3];
1368    
1369 maya 3392 if ( ! cv->Ready ) {
1370 maya 3227 return C;
1371 maya 3392 }
1372 maya 3227
1373     i = 0;
1374     a = 1;
1375     while ((a>0) && (i<C)) {
1376     Len = 0;
1377    
1378     d[Len] = B[i];
1379     Len++;
1380    
1381 doda 3505 if ( cv->TelFlag && (B[i]=='\x0d') && ! cv->TelBinSend ) {
1382     d[Len++] = '\x00';
1383 maya 3227 }
1384 doda 3505 else if ( cv->TelFlag && (B[i]=='\xff') ) {
1385     d[Len++] = '\xff';
1386     }
1387 maya 3227
1388 doda 3505 if ( OutBuffSize - cv->OutBuffCount - Len >= 0 ) {
1389     CommRawOut(cv, d, Len);
1390 maya 3227 a = 1;
1391     }
1392 maya 3392 else {
1393 maya 3227 a = 0;
1394 maya 3392 }
1395 maya 3227
1396 doda 3505 i += a;
1397 maya 3227 }
1398     return i;
1399     }
1400    
1401 doda 3505 int FAR PASCAL CommBinaryBuffOut(PComVar cv, PCHAR B, int C)
1402     {
1403     int a, i, Len, OutLen;
1404     char d[3];
1405    
1406     if ( ! cv->Ready ) {
1407     return C;
1408     }
1409    
1410     i = 0;
1411     a = 1;
1412     while ((a>0) && (i<C)) {
1413     Len = 0;
1414    
1415     d[Len] = B[i];
1416     Len++;
1417    
1418     if (B[i] == CR) {
1419     if ( cv->TelFlag && ! cv->TelBinSend ) {
1420     d[Len++] = '\x00';
1421     }
1422     if (cv->TelLineMode) {
1423     cv->Flush = TRUE;
1424     }
1425     }
1426     else if ( cv->TelFlag && (B[i]=='\xff') ) {
1427     d[Len++] = '\xff';
1428     }
1429    
1430     if (cv->TelLineMode) {
1431     if (OutBuffSize - cv->LineModeBuffCount - Len >= 0) {
1432     memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), d, Len);
1433     cv->LineModeBuffCount += Len;
1434     if (cv->Flush) {
1435     cv->FlushLen = cv->LineModeBuffCount;
1436     }
1437     a = 1;
1438     }
1439     else {
1440     a = 0;
1441     }
1442     if (cv->FlushLen > 0) {
1443     OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
1444     cv->FlushLen -= OutLen;
1445     cv->LineModeBuffCount -= OutLen;
1446     memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
1447     }
1448     cv->Flush = FALSE;
1449     }
1450     else {
1451     if ( OutBuffSize - cv->OutBuffCount - Len >= 0 ) {
1452     CommRawOut(cv, d, Len);
1453     a = 1;
1454     }
1455     else {
1456     a = 0;
1457     }
1458     }
1459    
1460     i += a;
1461     }
1462     return i;
1463     }
1464    
1465 doda 3442 static int OutputTextUTF8(WORD K, char *TempStr, PComVar cv)
1466 maya 3227 {
1467     unsigned int code;
1468 doda 3442 int outlen;
1469     int TempLen = 0;
1470 maya 3227
1471 doda 3442 code = SJIS2UTF8(K, &outlen, cv->Locale);
1472     switch (outlen) {
1473 doda 3457 case 4:
1474     TempStr[TempLen++] = (code >> 24) & 0xff;
1475 doda 3442 case 3:
1476 maya 3227 TempStr[TempLen++] = (code >> 16) & 0xff;
1477 doda 3442 case 2:
1478 maya 3227 TempStr[TempLen++] = (code >> 8) & 0xff;
1479 doda 3442 case 1:
1480 maya 3227 TempStr[TempLen++] = code & 0xff;
1481     }
1482    
1483 doda 3442 return TempLen;
1484 maya 3227 }
1485    
1486     //
1487 doda 3451 // MBCSから各種漢字コードへ変換して出力する。
1488 maya 3227 //
1489 doda 3451 int TextOutMBCS(PComVar cv, PCHAR B, int C)
1490 maya 3227 {
1491 doda 3494 int i, TempLen, OutLen;
1492 maya 3227 WORD K;
1493 doda 3442 char TempStr[12];
1494 maya 3227 int SendCodeNew;
1495     BYTE d;
1496     BOOL Full, KanjiFlagNew;
1497    
1498     Full = FALSE;
1499     i = 0;
1500     while (! Full && (i < C)) {
1501     TempLen = 0;
1502     d = (BYTE)B[i];
1503     SendCodeNew = cv->SendCode;
1504 doda 3442 KanjiFlagNew = FALSE;
1505 maya 3227
1506     if (cv->SendKanjiFlag) {
1507     SendCodeNew = IdKanji;
1508    
1509     K = (cv->SendKanjiFirst << 8) + d;
1510    
1511     // UTF-8への変換を行う。1〜3バイトまでの対応なので注意。
1512 doda 3408 if (cv->KanjiCodeSend == IdUTF8 || cv->Language == IdUtf8) {
1513 doda 3442 TempLen += OutputTextUTF8(K, TempStr, cv);
1514     }
1515     else {
1516     switch (cv->Language) {
1517     case IdJapanese:
1518     switch (cv->KanjiCodeSend) {
1519     case IdEUC:
1520 doda 3419 K = SJIS2EUC(K);
1521 doda 3442 break;
1522     case IdJIS:
1523 doda 3419 K = SJIS2JIS(K);
1524 doda 3442 if ((cv->SendCode==IdKatakana) &&
1525     (cv->JIS7KatakanaSend==1)) {
1526     TempStr[TempLen++] = SI;
1527     }
1528     break;
1529     case IdSJIS:
1530     /* nothing to do */
1531     break;
1532 doda 3419 }
1533 doda 3442 break;
1534     case IdKorean:
1535     break;
1536 maya 3227 }
1537 doda 3442 TempStr[TempLen++] = HIBYTE(K);
1538     TempStr[TempLen++] = LOBYTE(K);
1539 maya 3227 }
1540     }
1541 doda 3932 else if (_isleadbyte_l(d, cv->locale)) {
1542 maya 3227 KanjiFlagNew = TRUE;
1543     cv->SendKanjiFirst = d;
1544     SendCodeNew = IdKanji;
1545    
1546 doda 3442 if (cv->Language == IdJapanese) {
1547     if ((cv->SendCode!=IdKanji) && (cv->KanjiCodeSend==IdJIS)) {
1548     TempStr[0] = 0x1B;
1549     TempStr[1] = '$';
1550     if (cv->KanjiIn == IdKanjiInB) {
1551     TempStr[2] = 'B';
1552     }
1553     else {
1554     TempStr[2] = '@';
1555     }
1556     TempLen = 3;
1557 maya 3392 }
1558 maya 3227 }
1559     }
1560     else {
1561 doda 3442 if (cv->Language == IdJapanese) {
1562     if ((cv->SendCode==IdKanji) && (cv->KanjiCodeSend==IdJIS)) {
1563     TempStr[0] = 0x1B;
1564     TempStr[1] = '(';
1565     switch (cv->KanjiOut) {
1566     case IdKanjiOutJ:
1567 maya 3409 TempStr[2] = 'J';
1568     break;
1569 doda 3442 case IdKanjiOutH:
1570 maya 3409 TempStr[2] = 'H';
1571     break;
1572 doda 3442 default:
1573 maya 3409 TempStr[2] = 'B';
1574 doda 3442 }
1575     TempLen = 3;
1576 maya 3227 }
1577    
1578 doda 3442 if ((0xa0<d) && (d<0xe0)) {
1579     SendCodeNew = IdKatakana;
1580     if ((cv->SendCode!=IdKatakana) &&
1581     (cv->KanjiCodeSend==IdJIS) &&
1582     (cv->JIS7KatakanaSend==1)) {
1583     TempStr[TempLen++] = SO;
1584     }
1585 maya 3227 }
1586 doda 3442 else {
1587     SendCodeNew = IdASCII;
1588     if ((cv->SendCode==IdKatakana) &&
1589     (cv->KanjiCodeSend==IdJIS) &&
1590     (cv->JIS7KatakanaSend==1)) {
1591     TempStr[TempLen++] = SI;
1592     }
1593 maya 3227 }
1594     }
1595    
1596 doda 3497 if (d==CR) {
1597 doda 3442 TempStr[TempLen++] = 0x0d;
1598 maya 3227 if (cv->CRSend==IdCRLF) {
1599 doda 3442 TempStr[TempLen++] = 0x0a;
1600 maya 3227 }
1601     else if ((cv->CRSend==IdCR) &&
1602 doda 3398 cv->TelFlag && ! cv->TelBinSend) {
1603 doda 3442 TempStr[TempLen++] = 0;
1604 maya 3227 }
1605 doda 3494 if (cv->TelLineMode) {
1606     cv->Flush = TRUE;
1607     }
1608 maya 3227 }
1609 doda 3497 else if (d==BS) {
1610     if (cv->TelLineMode) {
1611     if (cv->FlushLen < cv->LineModeBuffCount) {
1612     cv->LineModeBuffCount--;
1613     }
1614     }
1615     else {
1616     TempStr[TempLen++] = d;
1617     }
1618     }
1619 doda 3498 else if (d==0x15) { // Ctrl-U
1620     if (cv->TelLineMode) {
1621     cv->LineModeBuffCount = cv->FlushLen;
1622     }
1623     else {
1624     TempStr[TempLen++] = d;
1625     }
1626     }
1627 doda 3442 else if ((d>=0x80) && (cv->KanjiCodeSend==IdUTF8 || cv->Language==IdUtf8)) {
1628     TempLen += OutputTextUTF8((WORD)d, TempStr, cv);
1629     }
1630     else if ((d>=0xa1) && (d<=0xe0) && (cv->Language == IdJapanese)) {
1631 doda 3452 /* Katakana */
1632 maya 3227 if (cv->KanjiCodeSend==IdEUC) {
1633 doda 3444 TempStr[TempLen++] = (char)SS2;
1634 maya 3227 }
1635     if ((cv->KanjiCodeSend==IdJIS) &&
1636 maya 3392 (cv->JIS7KatakanaSend==1)) {
1637 doda 3442 TempStr[TempLen++] = d & 0x7f;
1638 maya 3392 }
1639     else {
1640 doda 3442 TempStr[TempLen++] = d;
1641 maya 3392 }
1642 maya 3227 }
1643     else {
1644 doda 3442 TempStr[TempLen++] = d;
1645 maya 3227 if (cv->TelFlag && (d==0xff)) {
1646 doda 3442 TempStr[TempLen++] = (char)0xff;
1647 maya 3227 }
1648     }
1649     } // if (cv->SendKanjiFlag) else if ... else ... end
1650    
1651 doda 3494 if (cv->TelLineMode) {
1652     if (TempLen == 0) {
1653     i++;
1654     cv->SendCode = SendCodeNew;
1655     cv->SendKanjiFlag = KanjiFlagNew;
1656     }
1657     else {
1658     Full = OutBuffSize - cv->LineModeBuffCount - TempLen < 0;
1659     if (!Full) {
1660     i++;
1661     cv->SendCode = SendCodeNew;
1662     cv->SendKanjiFlag = KanjiFlagNew;
1663     memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), TempStr, TempLen);
1664     cv->LineModeBuffCount += TempLen;
1665     if (cv->Flush) {
1666     cv->FlushLen = cv->LineModeBuffCount;
1667     }
1668     }
1669     }
1670     if (cv->FlushLen > 0) {
1671     OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
1672     cv->FlushLen -= OutLen;
1673     cv->LineModeBuffCount -= OutLen;
1674     memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
1675     }
1676     cv->Flush = FALSE;
1677 maya 3227 }
1678     else {
1679 doda 3494 if (TempLen == 0) {
1680 maya 3227 i++;
1681     cv->SendCode = SendCodeNew;
1682     cv->SendKanjiFlag = KanjiFlagNew;
1683     }
1684 doda 3494 else {
1685     Full = OutBuffSize-cv->OutBuffCount-TempLen < 0;
1686     if (! Full) {
1687     i++;
1688     cv->SendCode = SendCodeNew;
1689     cv->SendKanjiFlag = KanjiFlagNew;
1690     CommRawOut(cv,TempStr,TempLen);
1691     }
1692     }
1693 maya 3227 }
1694    
1695     } // end of "while {}"
1696    
1697     return i;
1698     }
1699    
1700     int FAR PASCAL CommTextOut(PComVar cv, PCHAR B, int C)
1701     {
1702 doda 3494 int i, TempLen, OutLen;
1703 doda 3442 char TempStr[12];
1704 maya 3227 BYTE d;
1705     BOOL Full;
1706    
1707 maya 3392 if (! cv->Ready ) {
1708 maya 3227 return C;
1709 maya 3392 }
1710 maya 3227
1711 maya 4009 switch (cv->Language) {
1712     case IdUtf8:
1713     case IdJapanese:
1714     case IdKorean:
1715     return TextOutMBCS(cv, B, C);
1716     break;
1717 maya 3392 }
1718 maya 3227
1719     Full = FALSE;
1720     i = 0;
1721     while (! Full && (i < C)) {
1722     TempLen = 0;
1723     d = (BYTE)B[i];
1724    
1725 doda 3497 switch (d) {
1726     case CR:
1727 maya 3227 TempStr[TempLen] = 0x0d;
1728     TempLen++;
1729     if (cv->CRSend==IdCRLF) {
1730 doda 3452 TempStr[TempLen++] = 0x0a;
1731 maya 3227 }
1732 doda 3452 else if (cv->CRSend==IdCR && cv->TelFlag && ! cv->TelBinSend) {
1733     TempStr[TempLen++] = 0;
1734 maya 3227 }
1735 doda 3494 if (cv->TelLineMode) {
1736     cv->Flush = TRUE;
1737     }
1738 doda 3497 break;
1739    
1740     case BS:
1741     if (cv->TelLineMode) {
1742     if (cv->FlushLen < cv->LineModeBuffCount) {
1743     cv->LineModeBuffCount--;
1744     }
1745     }
1746     else {
1747     TempStr[TempLen++] = d;
1748     }
1749     break;
1750    
1751 doda 3498 case 0x15: // Ctrl-U
1752     if (cv->TelLineMode) {
1753     cv->LineModeBuffCount = cv->FlushLen;
1754     }
1755     else {
1756     TempStr[TempLen++] = d;
1757     }
1758 doda 3504 break;
1759 doda 3498
1760 doda 3497 default:
1761 doda 3452 if ((cv->Language==IdRussian) && (d>=128)) {
1762 doda 3494 d = RussConv(cv->RussClient, cv->RussHost, d);
1763 doda 3452 }
1764     TempStr[TempLen++] = d;
1765 maya 3227 if (cv->TelFlag && (d==0xff)) {
1766 doda 3452 TempStr[TempLen++] = (char)0xff;
1767 maya 3227 }
1768     }
1769    
1770 doda 3494 if (cv->TelLineMode) {
1771     Full = OutBuffSize - cv->LineModeBuffCount - TempLen < 0;
1772     if (!Full) {
1773 doda 3888 i++;
1774 doda 3494 memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), TempStr, TempLen);
1775     cv->LineModeBuffCount += TempLen;
1776     if (cv->Flush) {
1777     cv->FlushLen = cv->LineModeBuffCount;
1778     }
1779     }
1780     if (cv->FlushLen > 0) {
1781     OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
1782     cv->FlushLen -= OutLen;
1783     cv->LineModeBuffCount -= OutLen;
1784     memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
1785     }
1786     cv->Flush = FALSE;
1787 maya 3227 }
1788 doda 3494 else {
1789     Full = OutBuffSize - cv->OutBuffCount - TempLen < 0;
1790     if (! Full) {
1791     i++;
1792     CommRawOut(cv,TempStr,TempLen);
1793     }
1794     }
1795 maya 3227 } // end of while {}
1796    
1797     return i;
1798     }
1799    
1800     int FAR PASCAL CommBinaryEcho(PComVar cv, PCHAR B, int C)
1801     {
1802     int a, i, Len;
1803     char d[3];
1804    
1805     if ( ! cv->Ready )
1806     return C;
1807    
1808     if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
1809     memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
1810     cv->InPtr = 0;
1811     }
1812    
1813     i = 0;
1814     a = 1;
1815     while ((a>0) && (i<C)) {
1816     Len = 0;
1817    
1818     d[Len] = B[i];
1819     Len++;
1820    
1821     if ( cv->TelFlag && (B[i]=='\x0d') &&
1822     ! cv->TelBinSend ) {
1823     d[Len] = 0x00;
1824     Len++;
1825     }
1826    
1827     if ( cv->TelFlag && (B[i]=='\xff') ) {
1828     d[Len] = '\xff';
1829     Len++;
1830     }
1831    
1832     if ( InBuffSize-cv->InBuffCount-Len >=0 ) {
1833     memcpy(&(cv->InBuff[cv->InBuffCount]),d,Len);
1834     cv->InBuffCount = cv->InBuffCount + Len;
1835     a = 1;
1836     }
1837     else
1838     a = 0;
1839     i = i + a;
1840     }
1841     return i;
1842     }
1843    
1844 doda 3458 int FAR PASCAL TextEchoMBCS(PComVar cv, PCHAR B, int C)
1845 maya 3227 {
1846     int i, TempLen;
1847     WORD K;
1848 doda 3452 char TempStr[12];
1849 maya 3227 int EchoCodeNew;
1850     BYTE d;
1851     BOOL Full, KanjiFlagNew;
1852    
1853     Full = FALSE;
1854     i = 0;
1855     while (! Full && (i < C)) {
1856     TempLen = 0;
1857     d = (BYTE)B[i];
1858     EchoCodeNew = cv->EchoCode;
1859 doda 3452 KanjiFlagNew = FALSE;
1860 maya 3227
1861     if (cv->EchoKanjiFlag) {
1862     EchoCodeNew = IdKanji;
1863    
1864     K = (cv->EchoKanjiFirst << 8) + d;
1865 doda 3452
1866 maya 3227 // UTF-8への変換を行う。1〜3バイトまでの対応なので注意。
1867 doda 3452 if (cv->KanjiCodeEcho == IdUTF8 || cv->Language==IdUtf8) {
1868 doda 3442 TempLen += OutputTextUTF8(K, TempStr, cv);
1869 maya 3227 }
1870     else {
1871 doda 3452 switch (cv->Language) {
1872     case IdJapanese:
1873     switch (cv->KanjiCodeEcho) {
1874     case IdEUC:
1875     K = SJIS2EUC(K);
1876     break;
1877     case IdJIS:
1878     K = SJIS2JIS(K);
1879     if ((cv->EchoCode==IdKatakana) &&
1880     (cv->JIS7KatakanaEcho==1)) {
1881     TempStr[TempLen++] = SI;
1882     }
1883     break;
1884     case IdSJIS:
1885     /* nothing to do */
1886     break;
1887     }
1888     break;
1889     case IdKorean:
1890     break;
1891 maya 3392 }
1892 doda 3452 TempStr[TempLen++] = HIBYTE(K);
1893     TempStr[TempLen++] = LOBYTE(K);
1894 maya 3227 }
1895     }
1896 doda 3932 else if (_isleadbyte_l(d, cv->locale)) {
1897 maya 3227 KanjiFlagNew = TRUE;
1898     cv->EchoKanjiFirst = d;
1899     EchoCodeNew = IdKanji;
1900    
1901 doda 3452 if (cv->Language == IdJapanese) {
1902     if ((cv->EchoCode!=IdKanji) && (cv->KanjiCodeEcho==IdJIS)) {
1903     TempStr[0] = 0x1B;
1904     TempStr[1] = '$';
1905     if (cv->KanjiIn == IdKanjiInB) {
1906     TempStr[2] = 'B';
1907     }
1908     else {
1909     TempStr[2] = '@';
1910     }
1911     TempLen = 3;
1912 maya 3392 }
1913 maya 3227 }
1914     }
1915     else {
1916 doda 3452 if (cv->Language == IdJapanese) {
1917     if ((cv->EchoCode==IdKanji) && (cv->KanjiCodeEcho==IdJIS)) {
1918     TempStr[0] = 0x1B;
1919     TempStr[1] = '(';
1920     switch (cv->KanjiOut) {
1921     case IdKanjiOutJ:
1922 maya 3227 TempStr[2] = 'J';
1923     break;
1924 doda 3452 case IdKanjiOutH:
1925 maya 3227 TempStr[2] = 'H';
1926     break;
1927 doda 3452 default:
1928 maya 3227 TempStr[2] = 'B';
1929 doda 3452 }
1930     TempLen = 3;
1931 maya 3227 }
1932    
1933 doda 3452 if ((0xa0<d) && (d<0xe0)) {
1934     EchoCodeNew = IdKatakana;
1935     if ((cv->EchoCode!=IdKatakana) &&
1936     (cv->KanjiCodeEcho==IdJIS) &&
1937     (cv->JIS7KatakanaEcho==1)) {
1938     TempStr[TempLen++] = SO;
1939     }
1940 maya 3227 }
1941 doda 3452 else {
1942     EchoCodeNew = IdASCII;
1943     if ((cv->EchoCode==IdKatakana) &&
1944     (cv->KanjiCodeEcho==IdJIS) &&
1945     (cv->JIS7KatakanaEcho==1)) {
1946     TempStr[TempLen++] = SI;
1947     }
1948 maya 3227 }
1949     }
1950    
1951 doda 3503 if (d==CR) {
1952 doda 3452 TempStr[TempLen++] = 0x0d;
1953 maya 3227 if (cv->CRSend==IdCRLF) {
1954 doda 3452 TempStr[TempLen++] = 0x0a;
1955 maya 3227 }
1956     else if ((cv->CRSend==IdCR) &&
1957 maya 3392 cv->TelFlag && ! cv->TelBinSend) {
1958 doda 3452 TempStr[TempLen++] = 0;
1959 maya 3227 }
1960     }
1961 doda 3503 else if (d==0x15) { // Ctrl-U
1962     if (cv->TelLineMode) {
1963     // Move to top of line (CHA "\033[G") and erase line (EL "\033[K")
1964     strncpy_s(TempStr, sizeof(TempStr), "\033[G\033[K", _TRUNCATE);
1965     TempLen += 6;
1966     }
1967     else {
1968     TempStr[TempLen++] = d;
1969     }
1970     }
1971 doda 3452 else if ((d>=0x80) && (cv->KanjiCodeEcho==IdUTF8 || cv->Language==IdUtf8)) {
1972     TempLen += OutputTextUTF8((WORD)d, TempStr, cv);
1973     }
1974     else if ((d>=0xa1) && (d<=0xe0) && (cv->Language == IdJapanese)) {
1975 maya 3227 /* Katakana */
1976     if (cv->KanjiCodeEcho==IdEUC) {
1977 doda 3452 TempStr[TempLen++] = (char)SS2;
1978 maya 3227 }
1979     if ((cv->KanjiCodeEcho==IdJIS) &&
1980 maya 3392 (cv->JIS7KatakanaEcho==1)) {
1981 doda 3452 TempStr[TempLen++] = d & 0x7f;
1982 maya 3392 }
1983     else {
1984 doda 3452 TempStr[TempLen++] = d;
1985 maya 3392 }
1986 maya 3227 }
1987     else {
1988 doda 3452 TempStr[TempLen++] = d;
1989 maya 3227 if (cv->TelFlag && (d==0xff)) {
1990 doda 3452 TempStr[TempLen++] = (char)0xff;
1991 maya 3227 }
1992     }
1993 doda 3452 } // if (cv->EchoKanjiFlag) else if ... else ... end
1994 maya 3227
1995     if (TempLen == 0) {
1996     i++;
1997     cv->EchoCode = EchoCodeNew;
1998     cv->EchoKanjiFlag = KanjiFlagNew;
1999     }
2000     else {
2001     Full = InBuffSize-cv->InBuffCount-TempLen < 0;
2002     if (! Full) {
2003     i++;
2004     cv->EchoCode = EchoCodeNew;
2005     cv->EchoKanjiFlag = KanjiFlagNew;
2006     memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
2007     cv->InBuffCount = cv->InBuffCount + TempLen;
2008     }
2009     }
2010    
2011     } // end of "while {}"
2012    
2013     return i;
2014     }
2015    
2016     int FAR PASCAL CommTextEcho(PComVar cv, PCHAR B, int C)
2017     {
2018     int i, TempLen;
2019     char TempStr[11];
2020     BYTE d;
2021     BOOL Full;
2022    
2023 maya 3392 if ( ! cv->Ready ) {
2024 maya 3227 return C;
2025 maya 3392 }
2026 maya 3227
2027     if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
2028     memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
2029     cv->InPtr = 0;
2030     }
2031    
2032 doda 3452 switch (cv->Language) {
2033     case IdUtf8:
2034     case IdJapanese:
2035     case IdKorean:
2036 doda 3458 return TextEchoMBCS(cv,B,C);
2037 doda 3452 break;
2038 doda 3438 }
2039 maya 3227
2040     Full = FALSE;
2041     i = 0;
2042     while (! Full && (i < C)) {
2043     TempLen = 0;
2044     d = (BYTE)B[i];
2045    
2046 doda 3503 switch (d) {
2047     case CR:
2048 maya 3227 TempStr[TempLen] = 0x0d;
2049     TempLen++;
2050     if (cv->CRSend==IdCRLF) {
2051 doda 3452 TempStr[TempLen++] = 0x0a;
2052 maya 3227 }
2053 doda 3452 else if (cv->CRSend==IdCR && cv->TelFlag && ! cv->TelBinSend) {
2054     TempStr[TempLen++] = 0;
2055 maya 3227 }
2056 doda 3503 break;
2057    
2058     case 0x15: // Ctrl-U
2059     if (cv->TelLineMode) {
2060     // Move to top of line (CHA "\033[G") and erase line (EL "\033[K")
2061     strncpy_s(TempStr, sizeof(TempStr), "\033[G\033[K", _TRUNCATE);
2062     TempLen += 6;
2063     }
2064     else {
2065     TempStr[TempLen++] = d;
2066     }
2067     break;
2068    
2069     default:
2070 doda 3452 if ((cv->Language==IdRussian) && (d>=128)) {
2071 maya 3227 d = RussConv(cv->RussClient,cv->RussHost,d);
2072 maya 3392 }
2073 doda 3452 TempStr[TempLen++] = d;
2074 maya 3227 if (cv->TelFlag && (d==0xff)) {
2075 doda 3452 TempStr[TempLen++] = (char)0xff;
2076 maya 3227 }
2077     }
2078    
2079     Full = InBuffSize-cv->InBuffCount-TempLen < 0;
2080     if (! Full) {
2081     i++;
2082     memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
2083     cv->InBuffCount = cv->InBuffCount + TempLen;
2084     }
2085     } // end of while {}
2086    
2087     return i;
2088     }
2089    
2090     // listup serial port driver
2091     // cf. http://www.codeproject.com/system/setupdi.asp?df=100&forumid=4368&exp=0&select=479661
2092     // (2007.8.17 yutaka)
2093     static void ListupSerialPort(LPWORD ComPortTable, int comports, char **ComPortDesc, int ComPortMax)
2094     {
2095     GUID ClassGuid[1];
2096     DWORD dwRequiredSize;
2097     BOOL bRet;
2098     HDEVINFO DeviceInfoSet = NULL;
2099     SP_DEVINFO_DATA DeviceInfoData;
2100     DWORD dwMemberIndex = 0;
2101     int i;
2102    
2103     DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
2104    
2105     // 以前のメモリをフリーしておく
2106     for (i = 0 ; i < ComPortMax ; i++) {
2107     free(ComPortDesc[i]);
2108     ComPortDesc[i] = NULL;
2109     }
2110    
2111     // Get ClassGuid from ClassName for PORTS class
2112     bRet =
2113     SetupDiClassGuidsFromName(_T("PORTS"), (LPGUID) & ClassGuid, 1,
2114     &dwRequiredSize);
2115 maya 3392 if (!bRet) {
2116 maya 3227 goto cleanup;
2117 maya 3392 }
2118 maya 3227
2119     // Get class devices
2120     // COMポート番号を強制付け替えした場合に、現在のものではなく、レジストリに残っている
2121     // 古いFriendlyNameが表示されてしまう問題への対処。(2007.11.8 yutaka)
2122     DeviceInfoSet =
2123     SetupDiGetClassDevs(&ClassGuid[0], NULL, NULL, DIGCF_PRESENT | DIGCF_PROFILE);
2124    
2125     if (DeviceInfoSet) {
2126     // Enumerate devices
2127     dwMemberIndex = 0;
2128     while (SetupDiEnumDeviceInfo
2129 maya 3392 (DeviceInfoSet, dwMemberIndex++, &DeviceInfoData)) {
2130 maya 3227 TCHAR szFriendlyName[MAX_PATH];
2131     TCHAR szPortName[MAX_PATH];
2132     //TCHAR szMessage[MAX_PATH];
2133     DWORD dwReqSize = 0;
2134     DWORD dwPropType;
2135     DWORD dwType = REG_SZ;
2136     HKEY hKey = NULL;
2137    
2138     // Get friendlyname
2139     bRet = SetupDiGetDeviceRegistryProperty(DeviceInfoSet,
2140     &DeviceInfoData,
2141     SPDRP_FRIENDLYNAME,
2142     &dwPropType,
2143     (LPBYTE)
2144     szFriendlyName,
2145     sizeof(szFriendlyName),
2146     &dwReqSize);
2147    
2148     // Open device parameters reg key
2149     hKey = SetupDiOpenDevRegKey(DeviceInfoSet,
2150     &DeviceInfoData,
2151     DICS_FLAG_GLOBAL,
2152     0, DIREG_DEV, KEY_READ);
2153     if (hKey) {
2154     // Qurey for portname
2155     long lRet;
2156     dwReqSize = sizeof(szPortName);
2157     lRet = RegQueryValueEx(hKey,
2158     _T("PortName"),
2159     0,
2160     &dwType,
2161     (LPBYTE) & szPortName,
2162     &dwReqSize);
2163    
2164     // Close reg key
2165     RegCloseKey(hKey);
2166     }
2167    
2168     #if 0
2169     sprintf(szMessage, _T("Name: %s\nPort: %s\n"), szFriendlyName,
2170     szPortName);
2171     printf("%s\n", szMessage);
2172     #endif
2173    
2174     if (_strnicmp(szPortName, "COM", 3) == 0) { // COMポートドライバを発見
2175     int port = atoi(&szPortName[3]);
2176     int i;
2177    
2178     for (i = 0 ; i < comports ; i++) {
2179     if (ComPortTable[i] == port) { // 接続を確認
2180     ComPortDesc[i] = _strdup(szFriendlyName);
2181     break;
2182     }
2183     }
2184     }
2185    
2186     }
2187     }
2188    
2189 maya 3392 cleanup:
2190 maya 3227 // Destroy device info list
2191     SetupDiDestroyDeviceInfoList(DeviceInfoSet);
2192     }
2193    
2194    
2195     int PASCAL DetectComPorts(LPWORD ComPortTable, int ComPortMax, char **ComPortDesc)
2196     {
2197     HMODULE h;
2198     TCHAR devicesBuff[65535];
2199     TCHAR *p;
2200     int comports = 0;
2201     int i, j, min;
2202     WORD s;
2203    
2204     if (((h = GetModuleHandle("kernel32.dll")) != NULL) &&
2205     (GetProcAddress(h, "QueryDosDeviceA") != NULL) &&
2206     (QueryDosDevice(NULL, devicesBuff, 65535) != 0)) {
2207     p = devicesBuff;
2208     while (*p != '\0') {
2209     if (strncmp(p, "COM", 3) == 0 && p[3] != '\0') {
2210     ComPortTable[comports++] = atoi(p+3);
2211     if (comports >= ComPortMax)
2212     break;
2213     }
2214     p += (strlen(p)+1);
2215     }
2216    
2217     for (i=0; i<comports-1; i++) {
2218     min = i;
2219 maya 3392 for (j=i+1; j<comports; j++) {
2220     if (ComPortTable[min] > ComPortTable[j]) {
2221 maya 3227 min = j;
2222 maya 3392 }
2223     }
2224 maya 3227 if (min != i) {
2225     s = ComPortTable[i];
2226     ComPortTable[i] = ComPortTable[min];
2227     ComPortTable[min] = s;
2228     }
2229     }
2230     }
2231     else {
2232     #if 1
2233     for (i=1; i<=ComPortMax; i++) {
2234     FILE *fp;
2235 maya 3707 char buf[12]; // \\.\COMxxxx + NULL
2236 maya 3227 _snprintf_s(buf, sizeof(buf), _TRUNCATE, "\\\\.\\COM%d", i);
2237     if ((fp = fopen(buf, "r")) != NULL) {
2238     fclose(fp);
2239     ComPortTable[comports++] = i;
2240     }
2241     }
2242     #else
2243     comports = -1;
2244     #endif
2245     }
2246    
2247     ListupSerialPort(ComPortTable, comports, ComPortDesc, ComPortMax);
2248    
2249     return comports;
2250     }
2251    
2252     BOOL WINAPI DllMain(HANDLE hInstance,
2253     ULONG ul_reason_for_call,
2254     LPVOID lpReserved)
2255     {
2256     switch( ul_reason_for_call ) {
2257     case DLL_THREAD_ATTACH:
2258     /* do thread initialization */
2259     break;
2260     case DLL_THREAD_DETACH:
2261     /* do thread cleanup */
2262     break;
2263     case DLL_PROCESS_ATTACH:
2264     /* do process initialization */
2265     DoCover_IsDebuggerPresent();
2266     hInst = hInstance;
2267 maya 3392 HMap = CreateFileMapping((HANDLE) 0xFFFFFFFF, NULL, PAGE_READWRITE,
2268     0, sizeof(TMap), TT_FILEMAPNAME);
2269     if (HMap == NULL) {
2270 maya 3227 return FALSE;
2271 maya 3392 }
2272 maya 3227 FirstInstance = (GetLastError() != ERROR_ALREADY_EXISTS);
2273    
2274     pm = (PMap)MapViewOfFile(HMap,FILE_MAP_WRITE,0,0,0);
2275 maya 3392 if (pm == NULL) {
2276 maya 3227 return FALSE;
2277 maya 3392 }
2278 maya 3227 break;
2279     case DLL_PROCESS_DETACH:
2280     /* do process cleanup */
2281     UnmapViewOfFile(pm);
2282     CloseHandle(HMap);
2283     break;
2284     }
2285     return TRUE;
2286     }
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help