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