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