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 4073 - (show annotations) (download) (as text)
Tue Aug 31 10:15:14 2010 UTC (13 years, 7 months ago) by doda
File MIME type: text/x-csrc
File size: 45347 byte(s) 
ウィンドウメニューに、ウィンドウの状態を表す文字を表示するようにしてみた。

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