Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/trunk/teraterm/ttpcmn/ttcmn.c

Annotation of /trunk/teraterm/ttpcmn/ttcmn.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 2660 - (hide 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 maya 2476 /* 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 maya 2660 // 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 maya 2476 /* 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 yutakapon 2556 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 maya 2476 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 yutakapon 2556 if (cv->Language==IdKorean) // HKS
1496     return TextOutKR(cv,B,C);
1497 maya 2476
1498 yutakapon 2556
1499 maya 2476 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