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