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 3888 - (show annotations) (download) (as text)
Fri May 14 12:28:55 2010 UTC (13 years, 11 months ago) by doda
File MIME type: text/x-csrc
File size: 44897 byte(s) 
英語モードおよびロシア語モードで、"Line at a time" モードが正しく働かないのを修正。
http://logmett.com/forum/viewtopic.php?f=8&t=1389

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