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