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