Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/trunk/teraterm/ttpcmn/ttcmn.c

Contents of /trunk/teraterm/ttpcmn/ttcmn.c

Parent Directory Parent Directory | Revision Log Revision Log

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