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