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 3926 - (show annotations) (download) (as text)
Mon Jun 7 14:01:51 2010 UTC (13 years, 10 months ago) by yutakapon
File MIME type: text/x-csrc
File size: 45058 byte(s) 
以下に示す UTF-8 送信処理を、純粋なUnicodeとして処理するようにした。

　・IME入力
　・クリップボードの貼り付け

teraterm.iniに PureUTF8 エントリを追加。当該処理の on/off を切り替えられる。
デフォルトはまだ off とする。

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