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