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 2660 - (show annotations) (download) (as text)
Tue Feb 17 13:53:24 2009 UTC (15 years, 1 month ago) by maya
Original Path: teraterm/trunk/ttpcmn/ttcmn.c
File MIME type: text/x-csrc
File size: 42720 byte(s) 
* Windows 95
- Winsock2 が必須
- ttermpro の起動に IE4 以上が必須
- ヘルプの表示に IE5 以上が必須
- LogMeTTc は動かない
- TTLEdit はボタンの色がうまく出ない

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