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