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