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 6841 - (hide annotations) (download) (as text)
Tue Jul 4 15:02:28 2017 UTC (6 years, 9 months ago) by doda
File MIME type: text/x-csrc
File size: 60182 byte(s) 
TeraTerm Project としてのライセンス表記を追加

・Tera Term 本体分を横 80 桁に収まるように改行位置を調整
・ttssh 関連の分を追加
1 doda 6806 /*
2     * Copyright (C) 1994-1998 T. Teranishi
3     * (C) 2004-2017 TeraTerm Project
4     * All rights reserved.
5     *
6 doda 6841 * Redistribution and use in source and binary forms, with or without
7     * modification, are permitted provided that the following conditions
8     * are met:
9 doda 6806 *
10 doda 6841 * 1. Redistributions of source code must retain the above copyright
11     * notice, this list of conditions and the following disclaimer.
12     * 2. Redistributions in binary form must reproduce the above copyright
13     * notice, this list of conditions and the following disclaimer in the
14     * documentation and/or other materials provided with the distribution.
15     * 3. The name of the author may not be used to endorse or promote products
16     * derived from this software without specific prior written permission.
17 doda 6806 *
18 doda 6841 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
19     * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20     * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21     * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
22     * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23     * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24     * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25     * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26     * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27     * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 doda 6806 */
29 maya 3227
30 doda 6662 #ifndef _WIN32_IE
31     #define _WIN32_IE 0x501
32     #endif
33    
34 maya 3227 /* TTCMN.DLL, main */
35     #include "teraterm.h"
36     #include "tttypes.h"
37     #include <direct.h>
38     #include <string.h>
39     #include "ttftypes.h"
40     #include "ttlib.h"
41     #include "language.h"
42     #include <stdio.h>
43     #include <windows.h>
44     #include <tchar.h>
45     #include <setupapi.h>
46 doda 3462 #include <locale.h>
47 maya 5308 #include <htmlhelp.h>
48 maya 3227
49     #include "compat_w95.h"
50 yutakapon 4915 #include "tt_res.h"
51 maya 3227
52     /* first instance flag */
53     static BOOL FirstInstance = TRUE;
54    
55     static HINSTANCE hInst;
56    
57     static PMap pm;
58    
59     static HANDLE HMap = NULL;
60     #define VTCLASSNAME "VTWin32"
61     #define TEKCLASSNAME "TEKWin32"
62    
63    
64 yutakapon 5299 enum window_style {
65     WIN_CASCADE,
66     WIN_STACKED,
67     WIN_SIDEBYSIDE,
68     };
69    
70    
71 maya 3227 void PASCAL CopyShmemToTTSet(PTTSet ts)
72     {
73     // ���������������L�����������R�s�[����
74     memcpy(ts, &pm->ts, sizeof(TTTSet));
75     }
76    
77     void PASCAL CopyTTSetToShmem(PTTSet ts)
78     {
79     // ���������������L���������R�s�[����
80     memcpy(&pm->ts, ts, sizeof(TTTSet));
81     }
82    
83    
84 doda 6801 BOOL PASCAL StartTeraTerm(PTTSet ts)
85 maya 3227 {
86 maya 4031 char Temp[MAX_PATH];
87 maya 3227
88     if (FirstInstance) {
89     // init window list
90     pm->NWin = 0;
91     }
92     else {
93     /* only the first instance uses saved position */
94     pm->ts.VTPos.x = CW_USEDEFAULT;
95     pm->ts.VTPos.y = CW_USEDEFAULT;
96     pm->ts.TEKPos.x = CW_USEDEFAULT;
97     pm->ts.TEKPos.y = CW_USEDEFAULT;
98     }
99    
100     memcpy(ts,&(pm->ts),sizeof(TTTSet));
101    
102     // if (FirstInstance) { �������������� (2008.3.13 maya)
103     // �N���������A���L�������� HomeDir �� SetupFName ����������
104     /* Get home directory */
105 maya 3623 if (GetModuleFileName(hInst,Temp,sizeof(Temp)) == 0) {
106     return TRUE;
107     }
108 maya 3227 ExtractDirName(Temp, ts->HomeDir);
109     _chdir(ts->HomeDir);
110     GetDefaultSetupFName(ts->HomeDir, ts->SetupFName, sizeof(ts->SetupFName));
111    
112 maya 5877 strncpy_s(ts->KeyCnfFN, sizeof(ts->KeyCnfFN), ts->HomeDir, _TRUNCATE);
113     AppendSlash(ts->KeyCnfFN, sizeof(ts->KeyCnfFN));
114     strncat_s(ts->KeyCnfFN, sizeof(ts->KeyCnfFN), "KEYBOARD.CNF", _TRUNCATE);
115    
116 maya 3227 if (FirstInstance) {
117     FirstInstance = FALSE;
118     return TRUE;
119     }
120 maya 3392 else {
121 maya 3227 return FALSE;
122 maya 3392 }
123 maya 3227 }
124    
125 yutakapon 4915 // �����t�@�C�����f�B�X�N���������ATera Term�{�������N�������B
126     // (2012.4.30 yutaka)
127 doda 6801 void PASCAL RestartTeraTerm(HWND hwnd, PTTSet ts)
128 yutakapon 4915 {
129     char path[1024];
130     STARTUPINFO si;
131     PROCESS_INFORMATION pi;
132 yutakapon 4916 char uimsg[MAX_UIMSG];
133     int ret;
134 yutakapon 4915
135 doda 6435 get_lang_msg("MSG_TT_TAKE_EFFECT", uimsg, sizeof(uimsg),
136 yutakapon 4916 "This option takes effect the next time a session is started.\n"
137     "Are you sure that you want to relaunch Tera Term?"
138     , ts->UILanguageFile);
139     ret = MessageBox(hwnd, uimsg, "Tera Term: Configuration Warning", MB_YESNO | MB_ICONEXCLAMATION | MB_DEFBUTTON2);
140 doda 6435 if (ret != IDYES)
141 yutakapon 4916 return;
142    
143 yutakapon 4915 SendMessage(hwnd, WM_COMMAND, ID_SETUP_SAVE, 0);
144 yutakapon 4919 // ID_FILE_EXIT ���b�Z�[�W�����A�v�������������������������AWM_QUIT ���|�X�g�����B
145     //PostMessage(hwnd, WM_COMMAND, ID_FILE_EXIT, 0);
146     PostQuitMessage(0);
147 yutakapon 4915
148 yutakapon 4919 // ���v���Z�X�����N���B
149 yutakapon 4915 if (GetModuleFileName(NULL, path, sizeof(path)) == 0) {
150     return;
151     }
152     memset(&si, 0, sizeof(si));
153     GetStartupInfo(&si);
154     memset(&pi, 0, sizeof(pi));
155     if (CreateProcess(NULL, path, NULL, NULL, FALSE, 0,
156     NULL, NULL, &si, &pi) == 0) {
157     }
158     }
159    
160 doda 6801 void PASCAL ChangeDefaultSet(PTTSet ts, PKeyMap km)
161 maya 3227 {
162     if ((ts!=NULL) &&
163 maya 3392 (_stricmp(ts->SetupFName, pm->ts.SetupFName) == 0)) {
164 maya 3227 memcpy(&(pm->ts),ts,sizeof(TTTSet));
165 maya 3392 }
166     if (km!=NULL) {
167 maya 3227 memcpy(&(pm->km),km,sizeof(TKeyMap));
168 maya 3392 }
169 maya 3227 }
170    
171 doda 6801 void PASCAL GetDefaultSet(PTTSet ts)
172 maya 3227 {
173     memcpy(ts,&(pm->ts),sizeof(TTTSet));
174     }
175    
176    
177     /* Key scan code -> Tera Term key code */
178 doda 6801 WORD PASCAL GetKeyCode(PKeyMap KeyMap, WORD Scan)
179 maya 3227 {
180     WORD Key;
181    
182 maya 3392 if (KeyMap==NULL) {
183 maya 3227 KeyMap = &(pm->km);
184 maya 3392 }
185 maya 3227 Key = IdKeyMax;
186 maya 3392 while ((Key>0) && (KeyMap->Map[Key-1] != Scan)) {
187 maya 3227 Key--;
188 maya 3392 }
189 maya 3227 return Key;
190     }
191    
192 doda 6801 void PASCAL GetKeyStr(HWND HWin, PKeyMap KeyMap, WORD KeyCode,
193 maya 3227 BOOL AppliKeyMode, BOOL AppliCursorMode,
194     BOOL Send8BitMode, PCHAR KeyStr, int destlen,
195     LPINT Len, LPWORD Type)
196     {
197     MSG Msg;
198     char Temp[201];
199    
200 maya 3392 if (KeyMap==NULL) {
201 maya 3227 KeyMap = &(pm->km);
202 maya 3392 }
203 maya 3227
204     *Type = IdBinary; // key type
205     *Len = 0;
206     switch (KeyCode) {
207     case IdUp:
208     if (Send8BitMode) {
209     *Len = 2;
210     if (AppliCursorMode)
211     strncpy_s(KeyStr,destlen,"\217A",_TRUNCATE);
212     else
213     strncpy_s(KeyStr,destlen,"\233A",_TRUNCATE);
214     } else {
215     *Len = 3;
216     if (AppliCursorMode)
217     strncpy_s(KeyStr,destlen,"\033OA",_TRUNCATE);
218     else
219     strncpy_s(KeyStr,destlen,"\033[A",_TRUNCATE);
220     }
221     break;
222     case IdDown:
223     if (Send8BitMode) {
224     *Len = 2;
225     if (AppliCursorMode)
226     strncpy_s(KeyStr,destlen,"\217B",_TRUNCATE);
227     else
228     strncpy_s(KeyStr,destlen,"\233B",_TRUNCATE);
229     } else {
230     *Len = 3;
231     if (AppliCursorMode)
232     strncpy_s(KeyStr,destlen,"\033OB",_TRUNCATE);
233     else
234     strncpy_s(KeyStr,destlen,"\033[B",_TRUNCATE);
235     }
236     break;
237     case IdRight:
238     if (Send8BitMode) {
239     *Len = 2;
240     if (AppliCursorMode)
241     strncpy_s(KeyStr,destlen,"\217C",_TRUNCATE);
242     else
243     strncpy_s(KeyStr,destlen,"\233C",_TRUNCATE);
244     } else {
245     *Len = 3;
246     if (AppliCursorMode)
247     strncpy_s(KeyStr,destlen,"\033OC",_TRUNCATE);
248     else
249     strncpy_s(KeyStr,destlen,"\033[C",_TRUNCATE);
250     }
251     break;
252     case IdLeft:
253     if (Send8BitMode) {
254     *Len = 2;
255     if (AppliCursorMode)
256     strncpy_s(KeyStr,destlen,"\217D",_TRUNCATE);
257     else
258     strncpy_s(KeyStr,destlen,"\233D",_TRUNCATE);
259     } else {
260     *Len = 3;
261     if (AppliCursorMode)
262     strncpy_s(KeyStr,destlen,"\033OD",_TRUNCATE);
263     else
264     strncpy_s(KeyStr,destlen,"\033[D",_TRUNCATE);
265     }
266     break;
267     case Id0:
268     if (AppliKeyMode) {
269     if (Send8BitMode) {
270     *Len = 2;
271     strncpy_s(KeyStr,destlen,"\217p",_TRUNCATE);
272     } else {
273     *Len = 3;
274     strncpy_s(KeyStr,destlen,"\033Op",_TRUNCATE);
275     }
276     }
277     else {
278     *Len = 1;
279     KeyStr[0] = '0';
280     }
281     break;
282     case Id1:
283     if (AppliKeyMode) {
284     if (Send8BitMode) {
285     *Len = 2;
286     strncpy_s(KeyStr,destlen,"\217q",_TRUNCATE);
287     } else {
288     *Len = 3;
289     strncpy_s(KeyStr,destlen,"\033Oq",_TRUNCATE);
290     }
291     }
292     else {
293     *Len = 1;
294     KeyStr[0] = '1';
295     }
296     break;
297     case Id2:
298     if (AppliKeyMode) {
299     if (Send8BitMode) {
300     *Len = 2;
301     strncpy_s(KeyStr,destlen,"\217r",_TRUNCATE);
302     } else {
303     *Len = 3;
304     strncpy_s(KeyStr,destlen,"\033Or",_TRUNCATE);
305     }
306     }
307     else {
308     *Len = 1;
309     KeyStr[0] = '2';
310     }
311     break;
312     case Id3:
313     if (AppliKeyMode) {
314     if (Send8BitMode) {
315     *Len = 2;
316     strncpy_s(KeyStr,destlen,"\217s",_TRUNCATE);
317     } else {
318     *Len = 3;
319     strncpy_s(KeyStr,destlen,"\033Os",_TRUNCATE);
320     }
321     }
322     else {
323     *Len = 1;
324     KeyStr[0] = '3';
325     }
326     break;
327     case Id4:
328     if (AppliKeyMode) {
329     if (Send8BitMode) {
330     *Len = 2;
331     strncpy_s(KeyStr,destlen,"\217t",_TRUNCATE);
332     } else {
333     *Len = 3;
334     strncpy_s(KeyStr,destlen,"\033Ot",_TRUNCATE);
335     }
336     }
337     else {
338     *Len = 1;
339     KeyStr[0] = '4';
340     }
341     break;
342     case Id5:
343     if (AppliKeyMode) {
344     if (Send8BitMode) {
345     *Len = 2;
346     strncpy_s(KeyStr,destlen,"\217u",_TRUNCATE);
347     } else {
348     *Len = 3;
349     strncpy_s(KeyStr,destlen,"\033Ou",_TRUNCATE);
350     }
351     }
352     else {
353     *Len = 1;
354     KeyStr[0] = '5';
355     }
356     break;
357     case Id6:
358     if (AppliKeyMode) {
359     if (Send8BitMode) {
360     *Len = 2;
361     strncpy_s(KeyStr,destlen,"\217v",_TRUNCATE);
362     } else {
363     *Len = 3;
364     strncpy_s(KeyStr,destlen,"\033Ov",_TRUNCATE);
365     }
366     }
367     else {
368     *Len = 1;
369     KeyStr[0] = '6';
370     }
371     break;
372     case Id7:
373     if (AppliKeyMode) {
374     if (Send8BitMode) {
375     *Len = 2;
376     strncpy_s(KeyStr,destlen,"\217w",_TRUNCATE);
377     } else {
378     *Len = 3;
379     strncpy_s(KeyStr,destlen,"\033Ow",_TRUNCATE);
380     }
381     }
382     else {
383     *Len = 1;
384     KeyStr[0] = '7';
385     }
386     break;
387     case Id8:
388     if (AppliKeyMode) {
389     if (Send8BitMode) {
390     *Len = 2;
391     strncpy_s(KeyStr,destlen,"\217x",_TRUNCATE);
392     } else {
393     *Len = 3;
394     strncpy_s(KeyStr,destlen,"\033Ox",_TRUNCATE);
395     }
396     }
397     else {
398     *Len = 1;
399     KeyStr[0] = '8';
400     }
401     break;
402     case Id9:
403     if (AppliKeyMode) {
404     if (Send8BitMode) {
405     *Len = 2;
406     strncpy_s(KeyStr,destlen,"\217y",_TRUNCATE);
407     } else {
408     *Len = 3;
409     strncpy_s(KeyStr,destlen,"\033Oy",_TRUNCATE);
410     }
411     }
412     else {
413     *Len = 1;
414     KeyStr[0] = '9';
415     }
416     break;
417     case IdMinus: /* numeric pad - key (DEC) */
418     if (AppliKeyMode) {
419     if (Send8BitMode) {
420     *Len = 2;
421     strncpy_s(KeyStr,destlen,"\217m",_TRUNCATE);
422     } else {
423     *Len = 3;
424     strncpy_s(KeyStr,destlen,"\033Om",_TRUNCATE);
425     }
426     }
427     else {
428     *Len = 1;
429     KeyStr[0] = '-';
430     }
431     break;
432     case IdComma: /* numeric pad , key (DEC) */
433     if (AppliKeyMode) {
434     if (Send8BitMode) {
435     *Len = 2;
436     strncpy_s(KeyStr,destlen,"\217l",_TRUNCATE);
437     } else {
438     *Len = 3;
439     strncpy_s(KeyStr,destlen,"\033Ol",_TRUNCATE);
440     }
441     }
442     else {
443     *Len = 1;
444     KeyStr[0] = ',';
445     }
446     break;
447     case IdPeriod: /* numeric pad . key */
448     if (AppliKeyMode) {
449     if (Send8BitMode) {
450     *Len = 2;
451     strncpy_s(KeyStr,destlen,"\217n",_TRUNCATE);
452     } else {
453     *Len = 3;
454     strncpy_s(KeyStr,destlen,"\033On",_TRUNCATE);
455     }
456     }
457     else {
458     *Len = 1;
459     KeyStr[0] = '.';
460     }
461     break;
462     case IdEnter: /* numeric pad enter key */
463     if (AppliKeyMode) {
464     if (Send8BitMode) {
465     *Len = 2;
466     strncpy_s(KeyStr,destlen,"\217M",_TRUNCATE);
467     } else {
468     *Len = 3;
469     strncpy_s(KeyStr,destlen,"\033OM",_TRUNCATE);
470     }
471     }
472     else {
473 doda 3900 *Type = IdText; // do new-line conversion
474 maya 3227 *Len = 1;
475     KeyStr[0] = 0x0D;
476     }
477     break;
478     case IdSlash: /* numeric pad slash key */
479     if (AppliKeyMode) {
480     if (Send8BitMode) {
481     *Len = 2;
482     strncpy_s(KeyStr,destlen,"\217o",_TRUNCATE);
483     } else {
484     *Len = 3;
485     strncpy_s(KeyStr,destlen,"\033Oo",_TRUNCATE);
486     }
487     }
488     else {
489     *Len = 1;
490     KeyStr[0] = '/';
491     }
492     break;
493     case IdAsterisk: /* numeric pad asterisk key */
494     if (AppliKeyMode) {
495     if (Send8BitMode) {
496     *Len = 2;
497     strncpy_s(KeyStr,destlen,"\217j",_TRUNCATE);
498     } else {
499     *Len = 3;
500     strncpy_s(KeyStr,destlen,"\033Oj",_TRUNCATE);
501     }
502     }
503     else {
504     *Len = 1;
505     KeyStr[0] = '*';
506     }
507     break;
508     case IdPlus: /* numeric pad plus key */
509     if (AppliKeyMode) {
510     if (Send8BitMode) {
511     *Len = 2;
512     strncpy_s(KeyStr,destlen,"\217k",_TRUNCATE);
513     } else {
514     *Len = 3;
515     strncpy_s(KeyStr,destlen,"\033Ok",_TRUNCATE);
516     }
517     }
518     else {
519     *Len = 1;
520     KeyStr[0] = '+';
521     }
522     break;
523     case IdPF1: /* DEC Key: PF1 */
524     if (Send8BitMode) {
525     *Len = 2;
526     strncpy_s(KeyStr,destlen,"\217P",_TRUNCATE);
527     } else {
528     *Len = 3;
529     strncpy_s(KeyStr,destlen,"\033OP",_TRUNCATE);
530     }
531     break;
532     case IdPF2: /* DEC Key: PF2 */
533     if (Send8BitMode) {
534     *Len = 2;
535     strncpy_s(KeyStr,destlen,"\217Q",_TRUNCATE);
536     } else {
537     *Len = 3;
538     strncpy_s(KeyStr,destlen,"\033OQ",_TRUNCATE);
539     }
540     break;
541     case IdPF3: /* DEC Key: PF3 */
542     if (Send8BitMode) {
543     *Len = 2;
544     strncpy_s(KeyStr,destlen,"\217R",_TRUNCATE);
545     } else {
546     *Len = 3;
547     strncpy_s(KeyStr,destlen,"\033OR",_TRUNCATE);
548     }
549     break;
550     case IdPF4: /* DEC Key: PF4 */
551     if (Send8BitMode) {
552     *Len = 2;
553     strncpy_s(KeyStr,destlen,"\217S",_TRUNCATE);
554     } else {
555     *Len = 3;
556     strncpy_s(KeyStr,destlen,"\033OS",_TRUNCATE);
557     }
558     break;
559     case IdFind: /* DEC Key: Find */
560     if (Send8BitMode) {
561     *Len = 3;
562     strncpy_s(KeyStr,destlen,"\2331~",_TRUNCATE);
563     } else {
564     *Len = 4;
565     strncpy_s(KeyStr,destlen,"\033[1~",_TRUNCATE);
566     }
567     break;
568     case IdInsert: /* DEC Key: Insert Here */
569     if (Send8BitMode) {
570     *Len = 3;
571     strncpy_s(KeyStr,destlen,"\2332~",_TRUNCATE);
572     } else {
573     *Len = 4;
574     strncpy_s(KeyStr,destlen,"\033[2~",_TRUNCATE);
575     }
576     break;
577     case IdRemove: /* DEC Key: Remove */
578     if (Send8BitMode) {
579     *Len = 3;
580     strncpy_s(KeyStr,destlen,"\2333~",_TRUNCATE);
581     } else {
582     *Len = 4;
583     strncpy_s(KeyStr,destlen,"\033[3~",_TRUNCATE);
584     }
585     break;
586     case IdSelect: /* DEC Key: Select */
587     if (Send8BitMode) {
588     *Len = 3;
589     strncpy_s(KeyStr,destlen,"\2334~",_TRUNCATE);
590     } else {
591     *Len = 4;
592     strncpy_s(KeyStr,destlen,"\033[4~",_TRUNCATE);
593     }
594     break;
595     case IdPrev: /* DEC Key: Prev */
596     if (Send8BitMode) {
597     *Len = 3;
598     strncpy_s(KeyStr,destlen,"\2335~",_TRUNCATE);
599     } else {
600     *Len = 4;
601     strncpy_s(KeyStr,destlen,"\033[5~",_TRUNCATE);
602     }
603     break;
604     case IdNext: /* DEC Key: Next */
605     if (Send8BitMode) {
606     *Len = 3;
607     strncpy_s(KeyStr,destlen,"\2336~",_TRUNCATE);
608     } else {
609     *Len = 4;
610     strncpy_s(KeyStr,destlen,"\033[6~",_TRUNCATE);
611     }
612     break;
613     case IdF6: /* DEC Key: F6 */
614     if (Send8BitMode) {
615     *Len = 4;
616     strncpy_s(KeyStr,destlen,"\23317~",_TRUNCATE);
617     } else {
618     *Len = 5;
619     strncpy_s(KeyStr,destlen,"\033[17~",_TRUNCATE);
620     }
621     break;
622     case IdF7: /* DEC Key: F7 */
623     if (Send8BitMode) {
624     *Len = 4;
625     strncpy_s(KeyStr,destlen,"\23318~",_TRUNCATE);
626     } else {
627     *Len = 5;
628     strncpy_s(KeyStr,destlen,"\033[18~",_TRUNCATE);
629     }
630     break;
631     case IdF8: /* DEC Key: F8 */
632     if (Send8BitMode) {
633     *Len = 4;
634     strncpy_s(KeyStr,destlen,"\23319~",_TRUNCATE);
635     } else {
636     *Len = 5;
637     strncpy_s(KeyStr,destlen,"\033[19~",_TRUNCATE);
638     }
639     break;
640     case IdF9: /* DEC Key: F9 */
641     if (Send8BitMode) {
642     *Len = 4;
643     strncpy_s(KeyStr,destlen,"\23320~",_TRUNCATE);
644     } else {
645     *Len = 5;
646     strncpy_s(KeyStr,destlen,"\033[20~",_TRUNCATE);
647     }
648     break;
649     case IdF10: /* DEC Key: F10 */
650     if (Send8BitMode) {
651     *Len = 4;
652     strncpy_s(KeyStr,destlen,"\23321~",_TRUNCATE);
653     } else {
654     *Len = 5;
655     strncpy_s(KeyStr,destlen,"\033[21~",_TRUNCATE);
656     }
657     break;
658     case IdF11: /* DEC Key: F11 */
659     if (Send8BitMode) {
660     *Len = 4;
661     strncpy_s(KeyStr,destlen,"\23323~",_TRUNCATE);
662     } else {
663     *Len = 5;
664     strncpy_s(KeyStr,destlen,"\033[23~",_TRUNCATE);
665     }
666     break;
667     case IdF12: /* DEC Key: F12 */
668     if (Send8BitMode) {
669     *Len = 4;
670     strncpy_s(KeyStr,destlen,"\23324~",_TRUNCATE);
671     } else {
672     *Len = 5;
673     strncpy_s(KeyStr,destlen,"\033[24~",_TRUNCATE);
674     }
675     break;
676     case IdF13: /* DEC Key: F13 */
677     if (Send8BitMode) {
678     *Len = 4;
679     strncpy_s(KeyStr,destlen,"\23325~",_TRUNCATE);
680     } else {
681     *Len = 5;
682     strncpy_s(KeyStr,destlen,"\033[25~",_TRUNCATE);
683     }
684     break;
685     case IdF14: /* DEC Key: F14 */
686     if (Send8BitMode) {
687     *Len = 4;
688     strncpy_s(KeyStr,destlen,"\23326~",_TRUNCATE);
689     } else {
690     *Len = 5;
691     strncpy_s(KeyStr,destlen,"\033[26~",_TRUNCATE);
692     }
693     break;
694     case IdHelp: /* DEC Key: Help */
695     if (Send8BitMode) {
696     *Len = 4;
697     strncpy_s(KeyStr,destlen,"\23328~",_TRUNCATE);
698     } else {
699     *Len = 5;
700     strncpy_s(KeyStr,destlen,"\033[28~",_TRUNCATE);
701     }
702     break;
703     case IdDo: /* DEC Key: Do */
704     if (Send8BitMode) {
705     *Len = 4;
706     strncpy_s(KeyStr,destlen,"\23329~",_TRUNCATE);
707     } else {
708     *Len = 5;
709     strncpy_s(KeyStr,destlen,"\033[29~",_TRUNCATE);
710     }
711     break;
712     case IdF17: /* DEC Key: F17 */
713     if (Send8BitMode) {
714     *Len = 4;
715     strncpy_s(KeyStr,destlen,"\23331~",_TRUNCATE);
716     } else {
717     *Len = 5;
718     strncpy_s(KeyStr,destlen,"\033[31~",_TRUNCATE);
719     }
720     break;
721     case IdF18: /* DEC Key: F18 */
722     if (Send8BitMode) {
723     *Len = 4;
724     strncpy_s(KeyStr,destlen,"\23332~",_TRUNCATE);
725     } else {
726     *Len = 5;
727     strncpy_s(KeyStr,destlen,"\033[32~",_TRUNCATE);
728     }
729     break;
730     case IdF19: /* DEC Key: F19 */
731     if (Send8BitMode) {
732     *Len = 4;
733     strncpy_s(KeyStr,destlen,"\23333~",_TRUNCATE);
734     } else {
735     *Len = 5;
736     strncpy_s(KeyStr,destlen,"\033[33~",_TRUNCATE);
737     }
738     break;
739     case IdF20: /* DEC Key: F20 */
740     if (Send8BitMode) {
741     *Len = 4;
742     strncpy_s(KeyStr,destlen,"\23334~",_TRUNCATE);
743     } else {
744     *Len = 5;
745     strncpy_s(KeyStr,destlen,"\033[34~",_TRUNCATE);
746     }
747     break;
748     case IdXF1: /* XTERM F1 */
749     if (Send8BitMode) {
750     *Len = 4;
751     strncpy_s(KeyStr,destlen,"\23311~",_TRUNCATE);
752     } else {
753     *Len = 5;
754     strncpy_s(KeyStr,destlen,"\033[11~",_TRUNCATE);
755     }
756     break;
757     case IdXF2: /* XTERM F2 */
758     if (Send8BitMode) {
759     *Len = 4;
760     strncpy_s(KeyStr,destlen,"\23312~",_TRUNCATE);
761     } else {
762     *Len = 5;
763     strncpy_s(KeyStr,destlen,"\033[12~",_TRUNCATE);
764     }
765     break;
766     case IdXF3: /* XTERM F3 */
767     if (Send8BitMode) {
768     *Len = 4;
769     strncpy_s(KeyStr,destlen,"\23313~",_TRUNCATE);
770     } else {
771     *Len = 5;
772     strncpy_s(KeyStr,destlen,"\033[13~",_TRUNCATE);
773     }
774     break;
775     case IdXF4: /* XTERM F4 */
776     if (Send8BitMode) {
777     *Len = 4;
778     strncpy_s(KeyStr,destlen,"\23314~",_TRUNCATE);
779     } else {
780     *Len = 5;
781     strncpy_s(KeyStr,destlen,"\033[14~",_TRUNCATE);
782     }
783     break;
784     case IdXF5: /* XTERM F5 */
785     if (Send8BitMode) {
786     *Len = 4;
787     strncpy_s(KeyStr,destlen,"\23315~",_TRUNCATE);
788     } else {
789     *Len = 5;
790     strncpy_s(KeyStr,destlen,"\033[15~",_TRUNCATE);
791     }
792     break;
793 doda 4710 case IdXBackTab: /* XTERM Back Tab */
794     if (Send8BitMode) {
795     *Len = 2;
796     strncpy_s(KeyStr,destlen,"\233Z",_TRUNCATE);
797     } else {
798     *Len = 3;
799     strncpy_s(KeyStr,destlen,"\033[Z",_TRUNCATE);
800     }
801     break;
802 maya 3227 case IdHold:
803     case IdPrint:
804     case IdBreak:
805     case IdCmdEditCopy:
806     case IdCmdEditPaste:
807     case IdCmdEditPasteCR:
808     case IdCmdEditCLS:
809     case IdCmdEditCLB:
810     case IdCmdCtrlOpenTEK:
811     case IdCmdCtrlCloseTEK:
812     case IdCmdLineUp:
813     case IdCmdLineDown:
814     case IdCmdPageUp:
815     case IdCmdPageDown:
816     case IdCmdBuffTop:
817     case IdCmdBuffBottom:
818     case IdCmdNextWin:
819     case IdCmdPrevWin:
820 doda 3950 case IdCmdNextSWin:
821     case IdCmdPrevSWin:
822 maya 3227 case IdCmdLocalEcho:
823 doda 4710 case IdCmdScrollLock:
824 maya 3227 PostMessage(HWin,WM_USER_ACCELCOMMAND,KeyCode,0);
825     break;
826     default:
827     if ((KeyCode >= IdUser1) && (KeyCode <= IdKeyMax)) {
828     *Type = (WORD)(*KeyMap).UserKeyType[KeyCode-IdUser1]; // key type
829     *Len = KeyMap->UserKeyLen[KeyCode-IdUser1];
830     memcpy(Temp,
831     &KeyMap->UserKeyStr[KeyMap->UserKeyPtr[KeyCode-IdUser1]],
832     *Len);
833     Temp[*Len] = 0;
834     if ((*Type==IdBinary) || (*Type==IdText))
835     *Len = Hex2Str(Temp,KeyStr,destlen);
836     else
837     strncpy_s(KeyStr,destlen,Temp,_TRUNCATE);
838     }
839     else
840     return;
841     }
842     /* remove WM_CHAR message for used keycode */
843     PeekMessage(&Msg,HWin, WM_CHAR, WM_CHAR,PM_REMOVE);
844     }
845    
846 doda 6801 void PASCAL SetCOMFlag(int Com)
847 maya 3227 {
848     pm->ComFlag[(Com-1)/CHAR_BIT] |= 1 << ((Com-1)%CHAR_BIT);
849     }
850    
851 doda 6801 void PASCAL ClearCOMFlag(int Com)
852 maya 3227 {
853     pm->ComFlag[(Com-1)/CHAR_BIT] &= ~(1 << ((Com-1)%CHAR_BIT));
854     }
855    
856 doda 6801 int PASCAL CheckCOMFlag(int Com)
857 maya 3227 {
858     return ((pm->ComFlag[(Com-1)/CHAR_BIT] & 1 << (Com-1)%CHAR_BIT) > 0);
859     }
860    
861 doda 6801 int PASCAL RegWin(HWND HWinVT, HWND HWinTEK)
862 maya 3227 {
863     int i, j;
864    
865     if (pm->NWin>=MAXNWIN)
866     return 0;
867     if (HWinVT==NULL)
868     return 0;
869     if (HWinTEK!=NULL) {
870     i = 0;
871     while ((i<pm->NWin) && (pm->WinList[i]!=HWinVT))
872     i++;
873     if (i>=pm->NWin)
874     return 0;
875     for (j=pm->NWin-1 ; j>i ; j--)
876     pm->WinList[j+1] = pm->WinList[j];
877     pm->WinList[i+1] = HWinTEK;
878     pm->NWin++;
879     return 0;
880     }
881     pm->WinList[pm->NWin++] = HWinVT;
882 yutakapon 5223 memset(&pm->WinPrevRect[pm->NWin - 1], 0, sizeof(pm->WinPrevRect[pm->NWin - 1])); // RECT clear
883 maya 3392 if (pm->NWin==1) {
884 maya 3227 return 1;
885 maya 3392 }
886     else {
887 maya 3227 return (int)(SendMessage(pm->WinList[pm->NWin-2],
888 maya 3392 WM_USER_GETSERIALNO,0,0)+1);
889     }
890 maya 3227 }
891    
892 doda 6801 void PASCAL UnregWin(HWND HWin)
893 maya 3227 {
894     int i, j;
895    
896     i = 0;
897 maya 3392 while ((i<pm->NWin) && (pm->WinList[i]!=HWin)) {
898 maya 3227 i++;
899 maya 3392 }
900     if (pm->WinList[i]!=HWin) {
901 maya 3227 return;
902 maya 3392 }
903     for (j=i ; j<pm->NWin-1 ; j++) {
904 maya 3227 pm->WinList[j] = pm->WinList[j+1];
905 yutakapon 5223 pm->WinPrevRect[j] = pm->WinPrevRect[j+1]; // RECT shift
906 maya 3392 }
907     if (pm->NWin>0) {
908 maya 3227 pm->NWin--;
909 maya 3392 }
910 maya 3227 }
911    
912 doda 6435 char GetWindowTypeChar(HWND Hw, HWND HWin)
913 doda 4073 {
914 doda 4076 #if 0
915 doda 4073 if (HWin == Hw)
916     return '*';
917     else if (!IsWindowVisible(Hw))
918 doda 4076 #else
919     if (!IsWindowVisible(Hw))
920     #endif
921 doda 4073 return '#';
922     else if (IsIconic(Hw))
923     return '-';
924     else if (IsZoomed(Hw))
925     return '@';
926     else
927     return '+';
928     }
929    
930 doda 6801 void PASCAL SetWinMenu(HMENU menu, PCHAR buf, int buflen, PCHAR langFile, int VTFlag)
931 maya 3227 {
932     int i;
933     char Temp[MAXPATHLEN];
934     HWND Hw;
935    
936     // delete all items in Window menu
937     i = GetMenuItemCount(menu);
938     if (i>0)
939     do {
940     i--;
941     RemoveMenu(menu,i,MF_BYPOSITION);
942     } while (i>0);
943    
944     i = 0;
945     while (i<pm->NWin) {
946     Hw = pm->WinList[i]; // get window handle
947     if ((GetClassName(Hw,Temp,sizeof(Temp))>0) &&
948     ((strcmp(Temp,VTCLASSNAME)==0) ||
949     (strcmp(Temp,TEKCLASSNAME)==0))) {
950     Temp[0] = '&';
951     Temp[1] = (char)(0x31 + i);
952     Temp[2] = ' ';
953 doda 4073 Temp[3] = GetWindowTypeChar(Hw, NULL);
954     Temp[4] = ' ';
955     GetWindowText(Hw,&Temp[5],sizeof(Temp)-6);
956 maya 3227 AppendMenu(menu,MF_ENABLED | MF_STRING,ID_WINDOW_1+i,Temp);
957     i++;
958 maya 3392 if (i>8) {
959 maya 3227 i = pm->NWin;
960 maya 3392 }
961 maya 3227 }
962 maya 3392 else {
963 maya 3227 UnregWin(Hw);
964 maya 3392 }
965 maya 3227 }
966     get_lang_msg("MENU_WINDOW_WINDOW", buf, buflen, "&Window", langFile);
967     if (VTFlag == 1) {
968 maya 4655 AppendMenu(menu, MF_SEPARATOR, 0, NULL);
969 maya 3227 AppendMenu(menu,MF_ENABLED | MF_STRING,ID_WINDOW_WINDOW, buf);
970 doda 4647
971     get_lang_msg("MENU_WINDOW_MINIMIZEALL", buf, buflen, "&Minimize All", langFile);
972     AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_MINIMIZEALL, buf);
973    
974 yutakapon 5252 get_lang_msg("MENU_WINDOW_RESTOREALL", buf, buflen, "&Restore All", langFile);
975     AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_RESTOREALL, buf);
976    
977 yutakapon 5224 get_lang_msg("MENU_WINDOW_CASCADE", buf, buflen, "&Cascade", langFile);
978     AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_CASCADEALL, buf);
979    
980     get_lang_msg("MENU_WINDOW_STACKED", buf, buflen, "&Stacked", langFile);
981     AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_STACKED, buf);
982    
983     get_lang_msg("MENU_WINDOW_SIDEBYSIDE", buf, buflen, "Side &by Side", langFile);
984     AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_SIDEBYSIDE, buf);
985    
986 yutakapon 5299 if (pm->WinUndoFlag) {
987     if (pm->WinUndoStyle == WIN_CASCADE)
988     get_lang_msg("MENU_WINDOW_CASCADE_UNDO", buf, buflen, "&Undo - Cascade", langFile);
989     else if (pm->WinUndoStyle == WIN_STACKED)
990     get_lang_msg("MENU_WINDOW_STACKED_UNDO", buf, buflen, "&Undo - Stacked", langFile);
991     else
992     get_lang_msg("MENU_WINDOW_SIDEBYSIDE_UNDO", buf, buflen, "&Undo - Side by Side", langFile);
993     AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_UNDO, buf);
994     }
995    
996 maya 3227 }
997     else {
998     AppendMenu(menu,MF_ENABLED | MF_STRING,ID_TEKWINDOW_WINDOW, buf);
999     }
1000     }
1001    
1002 doda 6801 void PASCAL SetWinList(HWND HWin, HWND HDlg, int IList)
1003 maya 3227 {
1004     int i;
1005     char Temp[MAXPATHLEN];
1006     HWND Hw;
1007    
1008     for (i=0; i<pm->NWin; i++) {
1009     Hw = pm->WinList[i]; // get window handle
1010     if ((GetClassName(Hw,Temp,sizeof(Temp))>0) &&
1011     ((strcmp(Temp,VTCLASSNAME)==0) ||
1012     (strcmp(Temp,TEKCLASSNAME)==0))) {
1013 doda 4073 Temp[0] = GetWindowTypeChar(Hw, HWin);
1014     Temp[1] = ' ';
1015     GetWindowText(Hw,&Temp[2],sizeof(Temp)-3);
1016 maya 3227 SendDlgItemMessage(HDlg, IList, LB_ADDSTRING,
1017     0, (LONG)Temp);
1018 maya 3392 if (Hw==HWin) {
1019     SendDlgItemMessage(HDlg, IList, LB_SETCURSEL, i,0);
1020     }
1021 maya 3227 }
1022 maya 3392 else {
1023 maya 3227 UnregWin(Hw);
1024 maya 3392 }
1025 maya 3227 }
1026     }
1027    
1028 doda 6801 void PASCAL SelectWin(int WinId)
1029 maya 3227 {
1030     if ((WinId>=0) && (WinId<pm->NWin)) {
1031 yutakapon 3673 /* �E�B���h�E�����������������������������������A���������������������������A
1032     * SW_SHOWNORMAL ���� SW_SHOW �����X�����B
1033     * (2009.11.8 yutaka)
1034 maya 3675 * �E�B���h�E�����������������������������T�C�Y������(SW_RESTORE)�����������B
1035     * (2009.11.9 maya)
1036 yutakapon 3673 */
1037 maya 3675 if (IsIconic(pm->WinList[WinId])) {
1038     ShowWindow(pm->WinList[WinId],SW_RESTORE);
1039     }
1040     else {
1041     ShowWindow(pm->WinList[WinId],SW_SHOW);
1042     }
1043 maya 3227 SetForegroundWindow(pm->WinList[WinId]);
1044     }
1045     }
1046    
1047 doda 6801 void PASCAL SelectNextWin(HWND HWin, int Next, BOOL SkipIconic)
1048 maya 3227 {
1049     int i;
1050    
1051     i = 0;
1052 doda 3950 while ((i < pm->NWin) && (pm->WinList[i]!=HWin)) {
1053     i++;
1054     }
1055     if (pm->WinList[i]!=HWin) {
1056     return;
1057     }
1058    
1059     do {
1060     i += Next;
1061     if (i >= pm->NWin) {
1062     i = 0;
1063     }
1064     else if (i < 0) {
1065     i = pm->NWin-1;
1066     }
1067    
1068     if (pm->WinList[i] == HWin) {
1069 doda 4030 break;
1070 doda 3950 }
1071 doda 4030 } while ((SkipIconic && IsIconic(pm->WinList[i])) || !IsWindowVisible(pm->WinList[i]));
1072 doda 3950
1073     SelectWin(i);
1074     }
1075    
1076 doda 6801 void PASCAL ShowAllWin(int stat) {
1077 doda 4647 int i;
1078 doda 5280
1079     for (i=0; i < pm->NWin; i++) {
1080     ShowWindow(pm->WinList[i], stat);
1081     }
1082     }
1083    
1084 doda 6801 void PASCAL UndoAllWin(void) {
1085 doda 5280 int i;
1086 yutakapon 5223 WINDOWPLACEMENT rc0;
1087     RECT rc;
1088     HMONITOR hMonitor;
1089     MONITORINFO mi;
1090 yutakapon 5299 int stat = SW_RESTORE;
1091 yutakapon 5407 int multi_mon = 0;
1092 doda 4647
1093 yutakapon 6286 if (HasMultiMonitorSupport()) {
1094 yutakapon 5407 multi_mon = 1;
1095     }
1096    
1097 yutakapon 5299 // ���x�A�����������t���O���������B
1098     pm->WinUndoFlag = FALSE;
1099    
1100 yutakapon 5223 memset(&rc0, 0, sizeof(rc0));
1101    
1102 doda 4647 for (i=0; i < pm->NWin; i++) {
1103 yutakapon 5223 // �����w�����A�O�����������c���������������A�E�B���h�E�����������������B
1104     if (stat == SW_RESTORE && memcmp(&pm->WinPrevRect[i], &rc0, sizeof(rc0)) != 0) {
1105     rc = pm->WinPrevRect[i].rcNormalPosition;
1106    
1107 yutakapon 5407 // NT4.0, 95 ���}���`���j�^API��������
1108     if (multi_mon) {
1109     // �������j�^������������
1110     hMonitor = MonitorFromRect(&rc, MONITOR_DEFAULTTONEAREST);
1111     mi.cbSize = sizeof(MONITORINFO);
1112     GetMonitorInfo(hMonitor, &mi);
1113 yutakapon 5223
1114 yutakapon 5407 // ���u�����i�����O���������x���������������������������j
1115     if (rc.right > mi.rcMonitor.right) {
1116     rc.left -= rc.right - mi.rcMonitor.right;
1117     rc.right = mi.rcMonitor.right;
1118     }
1119     if (rc.left < mi.rcMonitor.left) {
1120     rc.right += mi.rcMonitor.left - rc.left;
1121     rc.left = mi.rcMonitor.left;
1122     }
1123     if (rc.bottom > mi.rcMonitor.bottom) {
1124     rc.top -= rc.bottom - mi.rcMonitor.bottom;
1125     rc.bottom = mi.rcMonitor.bottom;
1126     }
1127     if (rc.top < mi.rcMonitor.top) {
1128     rc.bottom += mi.rcMonitor.top - rc.top;
1129     rc.top = mi.rcMonitor.top;
1130     }
1131 yutakapon 5223 }
1132    
1133     // �E�B���h�E���u����
1134     SetWindowPos(
1135 doda 6435 pm->WinList[i], NULL,
1136     rc.left,
1137 yutakapon 5223 rc.top,
1138 doda 6435 rc.right - rc.left,
1139 yutakapon 5223 rc.bottom - rc.top,
1140     SWP_NOZORDER);
1141    
1142 yutakapon 5230 // �E�B���h�E����������
1143     ShowWindow(pm->WinList[i], pm->WinPrevRect[i].showCmd);
1144 yutakapon 5223
1145     } else {
1146     ShowWindow(pm->WinList[i], stat);
1147     }
1148 doda 4647 }
1149     }
1150    
1151 doda 6801 void PASCAL OpenHelp(UINT Command, DWORD Data, char *UILanguageFile)
1152 maya 5308 {
1153     char HomeDir[MAX_PATH];
1154     char Temp[MAX_PATH];
1155     HWND HWin;
1156     char HelpFN[MAX_PATH];
1157 yutakapon 5636 // char UILanguageFile[MAX_PATH];
1158 maya 5308 char uimsg[MAX_UIMSG];
1159    
1160     /* Get home directory */
1161     if (GetModuleFileName(NULL,Temp,sizeof(Temp)) == 0) {
1162     return;
1163     }
1164     ExtractDirName(Temp, HomeDir);
1165 doda 6435
1166 yutakapon 5636 // GetUILanguageFile(UILanguageFile, sizeof(UILanguageFile));
1167 maya 5308 get_lang_msg("HELPFILE", uimsg, sizeof(uimsg), "teraterm.chm", UILanguageFile);
1168    
1169     // �w���v���I�[�i�[�������f�X�N�g�b�v������ (2007.5.12 maya)
1170     HWin = GetDesktopWindow();
1171     _snprintf_s(HelpFN, sizeof(HelpFN), _TRUNCATE, "%s\\%s", HomeDir, uimsg);
1172     if (HtmlHelp(HWin, HelpFN, Command, Data) == NULL && Command != HH_CLOSE_ALL) {
1173     char buf[MAX_PATH];
1174     get_lang_msg("MSG_OPENHELP_ERROR", uimsg, sizeof(uimsg), "Can't open HTML help file(%s).", UILanguageFile);
1175     _snprintf_s(buf, sizeof(buf), _TRUNCATE, uimsg, HelpFN);
1176     MessageBox(HWin, buf, "Tera Term: HTML help", MB_OK | MB_ICONERROR);
1177     }
1178     }
1179    
1180 doda 6801 HWND PASCAL GetNthWin(int n)
1181 maya 3227 {
1182 maya 3392 if (n<pm->NWin) {
1183 maya 3227 return pm->WinList[n];
1184 maya 3392 }
1185     else {
1186 maya 3227 return NULL;
1187 maya 3392 }
1188 maya 3227 }
1189    
1190 yutakapon 5222
1191 yutakapon 5223 // �L�����E�B���h�E���T���A�������u���L�������������B
1192 yutakapon 5299 static void get_valid_window_and_memorize_rect(HWND myhwnd, HWND hwnd[], int *num, int style)
1193 yutakapon 5222 {
1194 yutakapon 5223 int i, n;
1195     WINDOWPLACEMENT wndPlace;
1196 yutakapon 5222
1197 yutakapon 5299 // ��������(Undo)���j���[�����x�����\���������B
1198     if (pm->WinUndoFlag == FALSE) {
1199     pm->WinUndoFlag = TRUE;
1200     } else {
1201     // ���������j���[���\�������������A�������O�������X�^�C�����I�����������A
1202     // ���j���[�������B
1203     // Windows8�����A�������A�����������X�^�C�����I�����������j���[�����������������A
1204     // Tera Term�������j���[���\�������������A�������������B
1205     if (pm->WinUndoStyle == style)
1206     pm->WinUndoFlag = FALSE;
1207     }
1208     pm->WinUndoStyle = style;
1209    
1210 yutakapon 5222 n = 0;
1211     for (i = 0 ; i < pm->NWin ; i++) {
1212 yutakapon 5223 // �������u���o���������B
1213     wndPlace.length = sizeof(WINDOWPLACEMENT);
1214     GetWindowPlacement(pm->WinList[i], &wndPlace);
1215     pm->WinPrevRect[i] = wndPlace;
1216    
1217     // �������g�������������B
1218 yutakapon 5222 if (pm->WinList[i] == myhwnd) {
1219     hwnd[n] = hwnd[0];
1220     hwnd[0] = myhwnd;
1221     } else {
1222     hwnd[n] = pm->WinList[i];
1223     }
1224     n++;
1225     }
1226 yutakapon 5223 *num = n;
1227     }
1228 yutakapon 5222
1229 yutakapon 5223 // �E�B���h�E�����E���������\������(Show Windows Side by Side)
1230 doda 6801 void PASCAL ShowAllWinSidebySide(HWND myhwnd)
1231 yutakapon 5223 {
1232     int n;
1233     HWND hwnd[MAXNWIN];
1234    
1235 yutakapon 5299 get_valid_window_and_memorize_rect(myhwnd, hwnd, &n, WIN_SIDEBYSIDE);
1236 yutakapon 5251 TileWindows(NULL, MDITILE_VERTICAL, NULL, n, hwnd);
1237 yutakapon 5222 }
1238    
1239     // �E�B���h�E���������������\������(Show Windows Stacked)
1240 doda 6801 void PASCAL ShowAllWinStacked(HWND myhwnd)
1241 yutakapon 5222 {
1242 yutakapon 5223 int n;
1243 yutakapon 5222 HWND hwnd[MAXNWIN];
1244    
1245 yutakapon 5299 get_valid_window_and_memorize_rect(myhwnd, hwnd, &n, WIN_STACKED);
1246 yutakapon 5251 TileWindows(NULL, MDITILE_HORIZONTAL, NULL, n, hwnd);
1247 yutakapon 5222 }
1248    
1249     // �E�B���h�E���d�����\������(Cascade)
1250 doda 6801 void PASCAL ShowAllWinCascade(HWND myhwnd)
1251 yutakapon 5222 {
1252 yutakapon 5223 int n;
1253     HWND hwnd[MAXNWIN];
1254    
1255 yutakapon 5299 get_valid_window_and_memorize_rect(myhwnd, hwnd, &n, WIN_CASCADE);
1256 yutakapon 5251 CascadeWindows(NULL, MDITILE_SKIPDISABLED, NULL, n, hwnd);
1257 yutakapon 5222 }
1258    
1259 yutakapon 5232 // �STera Term���I���w�����o���B
1260 doda 6801 void PASCAL BroadcastClosingMessage(HWND myhwnd)
1261 yutakapon 5232 {
1262     int i, max;
1263     HWND hwnd[MAXNWIN];
1264    
1265     // Tera Term���I�����������A���L���������������������A
1266     // ���������o�b�t�@���R�s�[���������B
1267     max = pm->NWin;
1268     for (i = 0 ; i < pm->NWin ; i++) {
1269     hwnd[i] = pm->WinList[i];
1270     }
1271    
1272     for (i = 0 ; i < max ; i++) {
1273     // �������g�������������B
1274 doda 6435 if (hwnd[i] == myhwnd)
1275 yutakapon 5232 continue;
1276    
1277     PostMessage(hwnd[i], WM_USER_NONCONFIRM_CLOSE, 0, 0);
1278     }
1279     PostMessage(myhwnd, WM_USER_NONCONFIRM_CLOSE, 0, 0);
1280     }
1281    
1282    
1283 doda 6801 int PASCAL CommReadRawByte(PComVar cv, LPBYTE b)
1284 maya 3227 {
1285 maya 3392 if ( ! cv->Ready ) {
1286 maya 3227 return 0;
1287 maya 3392 }
1288 maya 3227
1289     if ( cv->InBuffCount>0 ) {
1290     *b = cv->InBuff[cv->InPtr];
1291     cv->InPtr++;
1292     cv->InBuffCount--;
1293 maya 3392 if ( cv->InBuffCount==0 ) {
1294 maya 3227 cv->InPtr = 0;
1295 maya 3392 }
1296 maya 3227 return 1;
1297     }
1298     else {
1299     cv->InPtr = 0;
1300     return 0;
1301     }
1302     }
1303    
1304 doda 6801 void PASCAL CommInsert1Byte(PComVar cv, BYTE b)
1305 maya 3227 {
1306 maya 3392 if ( ! cv->Ready ) {
1307 maya 3227 return;
1308 maya 3392 }
1309 maya 3227
1310 maya 3392 if (cv->InPtr == 0) {
1311 maya 3227 memmove(&(cv->InBuff[1]),&(cv->InBuff[0]),cv->InBuffCount);
1312 maya 3392 }
1313     else {
1314 maya 3227 cv->InPtr--;
1315 maya 3392 }
1316 maya 3227 cv->InBuff[cv->InPtr] = b;
1317     cv->InBuffCount++;
1318    
1319 maya 3392 if (cv->HBinBuf!=0 ) {
1320 maya 3227 cv->BinSkip++;
1321 maya 3392 }
1322 maya 3227 }
1323    
1324     void Log1Bin(PComVar cv, BYTE b)
1325     {
1326 maya 3392 if (((cv->FilePause & OpLog)!=0) || cv->ProtoFlag) {
1327 maya 3227 return;
1328 maya 3392 }
1329 maya 3227 if (cv->BinSkip > 0) {
1330     cv->BinSkip--;
1331     return;
1332     }
1333     cv->BinBuf[cv->BinPtr] = b;
1334     cv->BinPtr++;
1335 maya 3392 if (cv->BinPtr>=InBuffSize) {
1336 maya 3227 cv->BinPtr = cv->BinPtr-InBuffSize;
1337 maya 3392 }
1338 maya 3227 if (cv->BCount>=InBuffSize) {
1339     cv->BCount = InBuffSize;
1340     cv->BStart = cv->BinPtr;
1341     }
1342 maya 3392 else {
1343 maya 3227 cv->BCount++;
1344 maya 3392 }
1345 maya 3227 }
1346    
1347 doda 6801 int PASCAL CommRead1Byte(PComVar cv, LPBYTE b)
1348 maya 3227 {
1349     int c;
1350    
1351 maya 3392 if ( ! cv->Ready ) {
1352 maya 3227 return 0;
1353 maya 3392 }
1354 maya 3227
1355     if ((cv->HLogBuf!=NULL) &&
1356     ((cv->LCount>=InBuffSize-10) ||
1357     (cv->DCount>=InBuffSize-10))) {
1358     // �������o�b�t�@���]�T�������������ACPU�X�P�W���[�����O�����������A
1359     // CPU���X�g�[���������h���B
1360     // (2006.10.13 yutaka)
1361     Sleep(1);
1362     return 0;
1363     }
1364    
1365     if ((cv->HBinBuf!=NULL) &&
1366 maya 3392 (cv->BCount>=InBuffSize-10)) {
1367 maya 3227 return 0;
1368 maya 3392 }
1369 maya 3227
1370 maya 3392 if ( cv->TelMode ) {
1371 maya 3227 c = 0;
1372 maya 3392 }
1373     else {
1374 maya 3227 c = CommReadRawByte(cv,b);
1375 maya 3392 }
1376 maya 3227
1377     if ((c==1) && cv->TelCRFlag) {
1378     cv->TelCRFlag = FALSE;
1379 maya 3392 if (*b==0) {
1380     c = 0;
1381     }
1382 maya 3227 }
1383    
1384     if ( c==1 ) {
1385     if ( cv->IACFlag ) {
1386     cv->IACFlag = FALSE;
1387     if ( *b != 0xFF ) {
1388     cv->TelMode = TRUE;
1389     CommInsert1Byte(cv,*b);
1390 maya 3392 if ( cv->HBinBuf!=0 ) {
1391 maya 3227 cv->BinSkip--;
1392 maya 3392 }
1393 maya 3227 c = 0;
1394     }
1395     }
1396     else if ((cv->PortType==IdTCPIP) && (*b==0xFF)) {
1397 maya 3392 if (!cv->TelFlag && cv->TelAutoDetect) { /* TTPLUG */
1398 maya 3227 cv->TelFlag = TRUE;
1399 maya 3392 }
1400 maya 3227 if (cv->TelFlag) {
1401     cv->IACFlag = TRUE;
1402     c = 0;
1403     }
1404     }
1405 maya 3392 else if (cv->TelFlag && ! cv->TelBinRecv && (*b==0x0D)) {
1406 maya 3227 cv->TelCRFlag = TRUE;
1407 maya 3392 }
1408 maya 3227 }
1409    
1410 maya 3392 if ( (c==1) && (cv->HBinBuf!=0) ) {
1411 maya 3227 Log1Bin(cv, *b);
1412 maya 3392 }
1413 maya 3227
1414     return c;
1415     }
1416    
1417 doda 6801 int PASCAL CommRawOut(PComVar cv, PCHAR B, int C)
1418 maya 3227 {
1419     int a;
1420    
1421 maya 3392 if ( ! cv->Ready ) {
1422 maya 3227 return C;
1423 maya 3392 }
1424 maya 3227
1425 maya 3392 if (C > OutBuffSize - cv->OutBuffCount) {
1426 maya 3227 a = OutBuffSize - cv->OutBuffCount;
1427 maya 3392 }
1428     else {
1429 maya 3227 a = C;
1430 maya 3392 }
1431 maya 3227 if ( cv->OutPtr > 0 ) {
1432     memmove(&(cv->OutBuff[0]),&(cv->OutBuff[cv->OutPtr]),cv->OutBuffCount);
1433     cv->OutPtr = 0;
1434     }
1435     memcpy(&(cv->OutBuff[cv->OutBuffCount]),B,a);
1436     cv->OutBuffCount = cv->OutBuffCount + a;
1437     return a;
1438     }
1439    
1440 doda 6801 int PASCAL CommBinaryOut(PComVar cv, PCHAR B, int C)
1441 maya 3227 {
1442     int a, i, Len;
1443     char d[3];
1444    
1445 maya 3392 if ( ! cv->Ready ) {
1446 maya 3227 return C;
1447 maya 3392 }
1448 maya 3227
1449     i = 0;
1450     a = 1;
1451     while ((a>0) && (i<C)) {
1452     Len = 0;
1453    
1454     d[Len] = B[i];
1455     Len++;
1456    
1457 doda 3505 if ( cv->TelFlag && (B[i]=='\x0d') && ! cv->TelBinSend ) {
1458     d[Len++] = '\x00';
1459 maya 3227 }
1460 doda 3505 else if ( cv->TelFlag && (B[i]=='\xff') ) {
1461     d[Len++] = '\xff';
1462     }
1463 maya 3227
1464 doda 3505 if ( OutBuffSize - cv->OutBuffCount - Len >= 0 ) {
1465     CommRawOut(cv, d, Len);
1466 maya 3227 a = 1;
1467     }
1468 maya 3392 else {
1469 maya 3227 a = 0;
1470 maya 3392 }
1471 maya 3227
1472 doda 3505 i += a;
1473 maya 3227 }
1474     return i;
1475     }
1476    
1477 doda 6801 int PASCAL CommBinaryBuffOut(PComVar cv, PCHAR B, int C)
1478 doda 3505 {
1479     int a, i, Len, OutLen;
1480     char d[3];
1481    
1482     if ( ! cv->Ready ) {
1483     return C;
1484     }
1485    
1486     i = 0;
1487     a = 1;
1488     while ((a>0) && (i<C)) {
1489     Len = 0;
1490    
1491     d[Len] = B[i];
1492     Len++;
1493    
1494     if (B[i] == CR) {
1495     if ( cv->TelFlag && ! cv->TelBinSend ) {
1496     d[Len++] = '\x00';
1497     }
1498     if (cv->TelLineMode) {
1499     cv->Flush = TRUE;
1500     }
1501     }
1502     else if ( cv->TelFlag && (B[i]=='\xff') ) {
1503     d[Len++] = '\xff';
1504     }
1505    
1506     if (cv->TelLineMode) {
1507     if (OutBuffSize - cv->LineModeBuffCount - Len >= 0) {
1508     memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), d, Len);
1509     cv->LineModeBuffCount += Len;
1510     if (cv->Flush) {
1511     cv->FlushLen = cv->LineModeBuffCount;
1512     }
1513     a = 1;
1514     }
1515     else {
1516     a = 0;
1517     }
1518     if (cv->FlushLen > 0) {
1519     OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
1520     cv->FlushLen -= OutLen;
1521     cv->LineModeBuffCount -= OutLen;
1522     memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
1523     }
1524     cv->Flush = FALSE;
1525     }
1526     else {
1527     if ( OutBuffSize - cv->OutBuffCount - Len >= 0 ) {
1528     CommRawOut(cv, d, Len);
1529     a = 1;
1530     }
1531     else {
1532     a = 0;
1533     }
1534     }
1535    
1536     i += a;
1537     }
1538     return i;
1539     }
1540    
1541 doda 3442 static int OutputTextUTF8(WORD K, char *TempStr, PComVar cv)
1542 maya 3227 {
1543     unsigned int code;
1544 doda 3442 int outlen;
1545     int TempLen = 0;
1546 maya 3227
1547 doda 3442 code = SJIS2UTF8(K, &outlen, cv->Locale);
1548     switch (outlen) {
1549 doda 3457 case 4:
1550     TempStr[TempLen++] = (code >> 24) & 0xff;
1551 doda 3442 case 3:
1552 maya 3227 TempStr[TempLen++] = (code >> 16) & 0xff;
1553 doda 3442 case 2:
1554 maya 3227 TempStr[TempLen++] = (code >> 8) & 0xff;
1555 doda 3442 case 1:
1556 maya 3227 TempStr[TempLen++] = code & 0xff;
1557     }
1558    
1559 doda 3442 return TempLen;
1560 maya 3227 }
1561    
1562 doda 6435 //
1563 doda 3451 // MBCS�����e�������R�[�h�����������o�������B
1564 maya 3227 //
1565 doda 3451 int TextOutMBCS(PComVar cv, PCHAR B, int C)
1566 maya 3227 {
1567 doda 3494 int i, TempLen, OutLen;
1568 maya 3227 WORD K;
1569 doda 3442 char TempStr[12];
1570 maya 3227 int SendCodeNew;
1571     BYTE d;
1572     BOOL Full, KanjiFlagNew;
1573    
1574     Full = FALSE;
1575     i = 0;
1576     while (! Full && (i < C)) {
1577     TempLen = 0;
1578     d = (BYTE)B[i];
1579     SendCodeNew = cv->SendCode;
1580 doda 3442 KanjiFlagNew = FALSE;
1581 maya 3227
1582     if (cv->SendKanjiFlag) {
1583     SendCodeNew = IdKanji;
1584    
1585     K = (cv->SendKanjiFirst << 8) + d;
1586    
1587     // UTF-8�����������s���B1�`3�o�C�g���������������������B
1588 doda 3408 if (cv->KanjiCodeSend == IdUTF8 || cv->Language == IdUtf8) {
1589 doda 3442 TempLen += OutputTextUTF8(K, TempStr, cv);
1590     }
1591     else {
1592     switch (cv->Language) {
1593     case IdJapanese:
1594 doda 6435 switch (cv->KanjiCodeSend) {
1595 doda 3442 case IdEUC:
1596 doda 3419 K = SJIS2EUC(K);
1597 doda 3442 break;
1598     case IdJIS:
1599 doda 3419 K = SJIS2JIS(K);
1600 doda 3442 if ((cv->SendCode==IdKatakana) &&
1601     (cv->JIS7KatakanaSend==1)) {
1602     TempStr[TempLen++] = SI;
1603     }
1604     break;
1605     case IdSJIS:
1606     /* nothing to do */
1607     break;
1608 doda 3419 }
1609 doda 3442 break;
1610     case IdKorean:
1611 doda 6435 break;
1612 maya 3227 }
1613 doda 3442 TempStr[TempLen++] = HIBYTE(K);
1614     TempStr[TempLen++] = LOBYTE(K);
1615 maya 3227 }
1616     }
1617 doda 3932 else if (_isleadbyte_l(d, cv->locale)) {
1618 maya 3227 KanjiFlagNew = TRUE;
1619     cv->SendKanjiFirst = d;
1620     SendCodeNew = IdKanji;
1621    
1622 doda 3442 if (cv->Language == IdJapanese) {
1623     if ((cv->SendCode!=IdKanji) && (cv->KanjiCodeSend==IdJIS)) {
1624     TempStr[0] = 0x1B;
1625     TempStr[1] = '$';
1626     if (cv->KanjiIn == IdKanjiInB) {
1627     TempStr[2] = 'B';
1628     }
1629     else {
1630     TempStr[2] = '@';
1631     }
1632     TempLen = 3;
1633 maya 3392 }
1634 maya 3227 }
1635     }
1636     else {
1637 doda 3442 if (cv->Language == IdJapanese) {
1638     if ((cv->SendCode==IdKanji) && (cv->KanjiCodeSend==IdJIS)) {
1639     TempStr[0] = 0x1B;
1640     TempStr[1] = '(';
1641     switch (cv->KanjiOut) {
1642     case IdKanjiOutJ:
1643 maya 3409 TempStr[2] = 'J';
1644     break;
1645 doda 3442 case IdKanjiOutH:
1646 maya 3409 TempStr[2] = 'H';
1647     break;
1648 doda 3442 default:
1649 maya 3409 TempStr[2] = 'B';
1650 doda 3442 }
1651     TempLen = 3;
1652 maya 3227 }
1653    
1654 doda 3442 if ((0xa0<d) && (d<0xe0)) {
1655     SendCodeNew = IdKatakana;
1656     if ((cv->SendCode!=IdKatakana) &&
1657     (cv->KanjiCodeSend==IdJIS) &&
1658     (cv->JIS7KatakanaSend==1)) {
1659     TempStr[TempLen++] = SO;
1660     }
1661 maya 3227 }
1662 doda 3442 else {
1663     SendCodeNew = IdASCII;
1664     if ((cv->SendCode==IdKatakana) &&
1665     (cv->KanjiCodeSend==IdJIS) &&
1666     (cv->JIS7KatakanaSend==1)) {
1667     TempStr[TempLen++] = SI;
1668     }
1669 maya 3227 }
1670     }
1671    
1672 doda 3497 if (d==CR) {
1673 doda 3442 TempStr[TempLen++] = 0x0d;
1674 maya 3227 if (cv->CRSend==IdCRLF) {
1675 doda 3442 TempStr[TempLen++] = 0x0a;
1676 maya 3227 }
1677     else if ((cv->CRSend==IdCR) &&
1678 doda 3398 cv->TelFlag && ! cv->TelBinSend) {
1679 doda 3442 TempStr[TempLen++] = 0;
1680 maya 3227 }
1681 maya 6369 else if (cv->CRSend == IdLF) {
1682     TempStr[TempLen-1] = 0x0a;
1683     }
1684 doda 3494 if (cv->TelLineMode) {
1685     cv->Flush = TRUE;
1686     }
1687 maya 3227 }
1688 doda 3497 else if (d==BS) {
1689     if (cv->TelLineMode) {
1690     if (cv->FlushLen < cv->LineModeBuffCount) {
1691     cv->LineModeBuffCount--;
1692     }
1693     }
1694 maya 6369 else {
1695 doda 3497 TempStr[TempLen++] = d;
1696     }
1697     }
1698 doda 3498 else if (d==0x15) { // Ctrl-U
1699     if (cv->TelLineMode) {
1700     cv->LineModeBuffCount = cv->FlushLen;
1701     }
1702 maya 6369 else {
1703 doda 3498 TempStr[TempLen++] = d;
1704     }
1705     }
1706 doda 3442 else if ((d>=0x80) && (cv->KanjiCodeSend==IdUTF8 || cv->Language==IdUtf8)) {
1707     TempLen += OutputTextUTF8((WORD)d, TempStr, cv);
1708     }
1709     else if ((d>=0xa1) && (d<=0xe0) && (cv->Language == IdJapanese)) {
1710 doda 3452 /* Katakana */
1711 maya 3227 if (cv->KanjiCodeSend==IdEUC) {
1712 doda 3444 TempStr[TempLen++] = (char)SS2;
1713 maya 3227 }
1714     if ((cv->KanjiCodeSend==IdJIS) &&
1715 maya 3392 (cv->JIS7KatakanaSend==1)) {
1716 doda 3442 TempStr[TempLen++] = d & 0x7f;
1717 maya 3392 }
1718     else {
1719 doda 3442 TempStr[TempLen++] = d;
1720 maya 3392 }
1721 maya 3227 }
1722     else {
1723 doda 3442 TempStr[TempLen++] = d;
1724 maya 3227 if (cv->TelFlag && (d==0xff)) {
1725 doda 3442 TempStr[TempLen++] = (char)0xff;
1726 maya 3227 }
1727     }
1728     } // if (cv->SendKanjiFlag) else if ... else ... end
1729    
1730 doda 3494 if (cv->TelLineMode) {
1731     if (TempLen == 0) {
1732     i++;
1733     cv->SendCode = SendCodeNew;
1734     cv->SendKanjiFlag = KanjiFlagNew;
1735     }
1736     else {
1737     Full = OutBuffSize - cv->LineModeBuffCount - TempLen < 0;
1738     if (!Full) {
1739     i++;
1740     cv->SendCode = SendCodeNew;
1741     cv->SendKanjiFlag = KanjiFlagNew;
1742     memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), TempStr, TempLen);
1743     cv->LineModeBuffCount += TempLen;
1744     if (cv->Flush) {
1745     cv->FlushLen = cv->LineModeBuffCount;
1746     }
1747     }
1748     }
1749     if (cv->FlushLen > 0) {
1750     OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
1751     cv->FlushLen -= OutLen;
1752     cv->LineModeBuffCount -= OutLen;
1753     memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
1754     }
1755     cv->Flush = FALSE;
1756 maya 3227 }
1757     else {
1758 doda 3494 if (TempLen == 0) {
1759 maya 3227 i++;
1760     cv->SendCode = SendCodeNew;
1761     cv->SendKanjiFlag = KanjiFlagNew;
1762     }
1763 doda 3494 else {
1764     Full = OutBuffSize-cv->OutBuffCount-TempLen < 0;
1765     if (! Full) {
1766     i++;
1767     cv->SendCode = SendCodeNew;
1768     cv->SendKanjiFlag = KanjiFlagNew;
1769     CommRawOut(cv,TempStr,TempLen);
1770     }
1771     }
1772 maya 3227 }
1773    
1774     } // end of "while {}"
1775    
1776     return i;
1777     }
1778    
1779 doda 6801 int PASCAL CommTextOut(PComVar cv, PCHAR B, int C)
1780 maya 3227 {
1781 doda 3494 int i, TempLen, OutLen;
1782 doda 3442 char TempStr[12];
1783 maya 3227 BYTE d;
1784     BOOL Full;
1785    
1786 maya 3392 if (! cv->Ready ) {
1787 maya 3227 return C;
1788 maya 3392 }
1789 maya 3227
1790 maya 4009 switch (cv->Language) {
1791     case IdUtf8:
1792     case IdJapanese:
1793     case IdKorean:
1794     return TextOutMBCS(cv, B, C);
1795     break;
1796 maya 3392 }
1797 maya 3227
1798     Full = FALSE;
1799     i = 0;
1800     while (! Full && (i < C)) {
1801     TempLen = 0;
1802     d = (BYTE)B[i];
1803 doda 6435
1804 doda 3497 switch (d) {
1805     case CR:
1806 maya 3227 TempStr[TempLen] = 0x0d;
1807     TempLen++;
1808     if (cv->CRSend==IdCRLF) {
1809 doda 3452 TempStr[TempLen++] = 0x0a;
1810 maya 3227 }
1811 doda 3452 else if (cv->CRSend==IdCR && cv->TelFlag && ! cv->TelBinSend) {
1812     TempStr[TempLen++] = 0;
1813 maya 3227 }
1814 maya 6369 else if (cv->CRSend == IdLF) {
1815     TempStr[TempLen-1] = 0x0a;
1816     }
1817 doda 3494 if (cv->TelLineMode) {
1818     cv->Flush = TRUE;
1819     }
1820 doda 3497 break;
1821    
1822     case BS:
1823     if (cv->TelLineMode) {
1824     if (cv->FlushLen < cv->LineModeBuffCount) {
1825     cv->LineModeBuffCount--;
1826     }
1827     }
1828 doda 6435 else {
1829 doda 3497 TempStr[TempLen++] = d;
1830     }
1831     break;
1832    
1833 doda 3498 case 0x15: // Ctrl-U
1834     if (cv->TelLineMode) {
1835     cv->LineModeBuffCount = cv->FlushLen;
1836     }
1837     else {
1838     TempStr[TempLen++] = d;
1839     }
1840 doda 3504 break;
1841 doda 3498
1842 doda 3497 default:
1843 doda 3452 if ((cv->Language==IdRussian) && (d>=128)) {
1844 doda 3494 d = RussConv(cv->RussClient, cv->RussHost, d);
1845 doda 3452 }
1846     TempStr[TempLen++] = d;
1847 maya 3227 if (cv->TelFlag && (d==0xff)) {
1848 doda 3452 TempStr[TempLen++] = (char)0xff;
1849 maya 3227 }
1850     }
1851    
1852 doda 3494 if (cv->TelLineMode) {
1853     Full = OutBuffSize - cv->LineModeBuffCount - TempLen < 0;
1854     if (!Full) {
1855 doda 3888 i++;
1856 doda 3494 memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), TempStr, TempLen);
1857     cv->LineModeBuffCount += TempLen;
1858     if (cv->Flush) {
1859     cv->FlushLen = cv->LineModeBuffCount;
1860     }
1861     }
1862     if (cv->FlushLen > 0) {
1863     OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
1864     cv->FlushLen -= OutLen;
1865     cv->LineModeBuffCount -= OutLen;
1866     memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
1867     }
1868     cv->Flush = FALSE;
1869 maya 3227 }
1870 doda 3494 else {
1871     Full = OutBuffSize - cv->OutBuffCount - TempLen < 0;
1872     if (! Full) {
1873     i++;
1874     CommRawOut(cv,TempStr,TempLen);
1875     }
1876     }
1877 maya 3227 } // end of while {}
1878    
1879     return i;
1880     }
1881    
1882 doda 6801 int PASCAL CommBinaryEcho(PComVar cv, PCHAR B, int C)
1883 maya 3227 {
1884     int a, i, Len;
1885     char d[3];
1886    
1887     if ( ! cv->Ready )
1888     return C;
1889    
1890     if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
1891     memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
1892     cv->InPtr = 0;
1893     }
1894    
1895     i = 0;
1896     a = 1;
1897     while ((a>0) && (i<C)) {
1898     Len = 0;
1899    
1900     d[Len] = B[i];
1901     Len++;
1902    
1903     if ( cv->TelFlag && (B[i]=='\x0d') &&
1904     ! cv->TelBinSend ) {
1905     d[Len] = 0x00;
1906     Len++;
1907     }
1908    
1909     if ( cv->TelFlag && (B[i]=='\xff') ) {
1910     d[Len] = '\xff';
1911     Len++;
1912     }
1913    
1914     if ( InBuffSize-cv->InBuffCount-Len >=0 ) {
1915     memcpy(&(cv->InBuff[cv->InBuffCount]),d,Len);
1916     cv->InBuffCount = cv->InBuffCount + Len;
1917     a = 1;
1918     }
1919     else
1920     a = 0;
1921     i = i + a;
1922     }
1923     return i;
1924     }
1925    
1926 doda 6801 int PASCAL TextEchoMBCS(PComVar cv, PCHAR B, int C)
1927 maya 3227 {
1928     int i, TempLen;
1929     WORD K;
1930 doda 3452 char TempStr[12];
1931 maya 3227 int EchoCodeNew;
1932     BYTE d;
1933     BOOL Full, KanjiFlagNew;
1934    
1935     Full = FALSE;
1936     i = 0;
1937     while (! Full && (i < C)) {
1938     TempLen = 0;
1939     d = (BYTE)B[i];
1940     EchoCodeNew = cv->EchoCode;
1941 doda 3452 KanjiFlagNew = FALSE;
1942 maya 3227
1943     if (cv->EchoKanjiFlag) {
1944     EchoCodeNew = IdKanji;
1945    
1946     K = (cv->EchoKanjiFirst << 8) + d;
1947 doda 3452
1948 maya 3227 // UTF-8�����������s���B1�`3�o�C�g���������������������B
1949 doda 3452 if (cv->KanjiCodeEcho == IdUTF8 || cv->Language==IdUtf8) {
1950 doda 3442 TempLen += OutputTextUTF8(K, TempStr, cv);
1951 maya 3227 }
1952     else {
1953 doda 3452 switch (cv->Language) {
1954     case IdJapanese:
1955     switch (cv->KanjiCodeEcho) {
1956     case IdEUC:
1957     K = SJIS2EUC(K);
1958     break;
1959     case IdJIS:
1960     K = SJIS2JIS(K);
1961     if ((cv->EchoCode==IdKatakana) &&
1962     (cv->JIS7KatakanaEcho==1)) {
1963     TempStr[TempLen++] = SI;
1964     }
1965     break;
1966     case IdSJIS:
1967     /* nothing to do */
1968     break;
1969     }
1970     break;
1971     case IdKorean:
1972     break;
1973 maya 3392 }
1974 doda 3452 TempStr[TempLen++] = HIBYTE(K);
1975     TempStr[TempLen++] = LOBYTE(K);
1976 maya 3227 }
1977     }
1978 doda 3932 else if (_isleadbyte_l(d, cv->locale)) {
1979 maya 3227 KanjiFlagNew = TRUE;
1980     cv->EchoKanjiFirst = d;
1981     EchoCodeNew = IdKanji;
1982    
1983 doda 3452 if (cv->Language == IdJapanese) {
1984     if ((cv->EchoCode!=IdKanji) && (cv->KanjiCodeEcho==IdJIS)) {
1985     TempStr[0] = 0x1B;
1986     TempStr[1] = '$';
1987     if (cv->KanjiIn == IdKanjiInB) {
1988     TempStr[2] = 'B';
1989     }
1990     else {
1991     TempStr[2] = '@';
1992     }
1993     TempLen = 3;
1994 maya 3392 }
1995 maya 3227 }
1996     }
1997     else {
1998 doda 3452 if (cv->Language == IdJapanese) {
1999     if ((cv->EchoCode==IdKanji) && (cv->KanjiCodeEcho==IdJIS)) {
2000     TempStr[0] = 0x1B;
2001     TempStr[1] = '(';
2002     switch (cv->KanjiOut) {
2003     case IdKanjiOutJ:
2004 maya 3227 TempStr[2] = 'J';
2005     break;
2006 doda 3452 case IdKanjiOutH:
2007 maya 3227 TempStr[2] = 'H';
2008     break;
2009 doda 3452 default:
2010 maya 3227 TempStr[2] = 'B';
2011 doda 3452 }
2012     TempLen = 3;
2013 maya 3227 }
2014    
2015 doda 3452 if ((0xa0<d) && (d<0xe0)) {
2016     EchoCodeNew = IdKatakana;
2017     if ((cv->EchoCode!=IdKatakana) &&
2018     (cv->KanjiCodeEcho==IdJIS) &&
2019     (cv->JIS7KatakanaEcho==1)) {
2020     TempStr[TempLen++] = SO;
2021     }
2022 maya 3227 }
2023 doda 3452 else {
2024     EchoCodeNew = IdASCII;
2025     if ((cv->EchoCode==IdKatakana) &&
2026     (cv->KanjiCodeEcho==IdJIS) &&
2027     (cv->JIS7KatakanaEcho==1)) {
2028     TempStr[TempLen++] = SI;
2029     }
2030 maya 3227 }
2031     }
2032    
2033 doda 3503 if (d==CR) {
2034 doda 3452 TempStr[TempLen++] = 0x0d;
2035 maya 3227 if (cv->CRSend==IdCRLF) {
2036 doda 3452 TempStr[TempLen++] = 0x0a;
2037 maya 3227 }
2038     else if ((cv->CRSend==IdCR) &&
2039 maya 3392 cv->TelFlag && ! cv->TelBinSend) {
2040 doda 3452 TempStr[TempLen++] = 0;
2041 maya 3227 }
2042 maya 6369 else if (cv->CRSend == IdLF) {
2043     TempStr[TempLen-1] = 0x0a;
2044     }
2045 maya 3227 }
2046 doda 3503 else if (d==0x15) { // Ctrl-U
2047     if (cv->TelLineMode) {
2048     // Move to top of line (CHA "\033[G") and erase line (EL "\033[K")
2049     strncpy_s(TempStr, sizeof(TempStr), "\033[G\033[K", _TRUNCATE);
2050     TempLen += 6;
2051     }
2052     else {
2053     TempStr[TempLen++] = d;
2054     }
2055     }
2056 doda 3452 else if ((d>=0x80) && (cv->KanjiCodeEcho==IdUTF8 || cv->Language==IdUtf8)) {
2057     TempLen += OutputTextUTF8((WORD)d, TempStr, cv);
2058     }
2059     else if ((d>=0xa1) && (d<=0xe0) && (cv->Language == IdJapanese)) {
2060 maya 3227 /* Katakana */
2061     if (cv->KanjiCodeEcho==IdEUC) {
2062 doda 3452 TempStr[TempLen++] = (char)SS2;
2063 maya 3227 }
2064     if ((cv->KanjiCodeEcho==IdJIS) &&
2065 maya 3392 (cv->JIS7KatakanaEcho==1)) {
2066 doda 3452 TempStr[TempLen++] = d & 0x7f;
2067 maya 3392 }
2068     else {
2069 doda 3452 TempStr[TempLen++] = d;
2070 maya 3392 }
2071 maya 3227 }
2072     else {
2073 doda 3452 TempStr[TempLen++] = d;
2074 maya 3227 if (cv->TelFlag && (d==0xff)) {
2075 doda 3452 TempStr[TempLen++] = (char)0xff;
2076 maya 3227 }
2077     }
2078 doda 3452 } // if (cv->EchoKanjiFlag) else if ... else ... end
2079 maya 3227
2080     if (TempLen == 0) {
2081     i++;
2082     cv->EchoCode = EchoCodeNew;
2083     cv->EchoKanjiFlag = KanjiFlagNew;
2084     }
2085     else {
2086     Full = InBuffSize-cv->InBuffCount-TempLen < 0;
2087     if (! Full) {
2088     i++;
2089     cv->EchoCode = EchoCodeNew;
2090     cv->EchoKanjiFlag = KanjiFlagNew;
2091     memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
2092     cv->InBuffCount = cv->InBuffCount + TempLen;
2093     }
2094     }
2095    
2096     } // end of "while {}"
2097    
2098     return i;
2099     }
2100    
2101 doda 6801 int PASCAL CommTextEcho(PComVar cv, PCHAR B, int C)
2102 maya 3227 {
2103     int i, TempLen;
2104     char TempStr[11];
2105     BYTE d;
2106     BOOL Full;
2107    
2108 maya 3392 if ( ! cv->Ready ) {
2109 maya 3227 return C;
2110 maya 3392 }
2111 maya 3227
2112     if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
2113     memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
2114     cv->InPtr = 0;
2115     }
2116    
2117 doda 3452 switch (cv->Language) {
2118     case IdUtf8:
2119     case IdJapanese:
2120     case IdKorean:
2121 doda 3458 return TextEchoMBCS(cv,B,C);
2122 doda 3452 break;
2123 doda 3438 }
2124 maya 3227
2125     Full = FALSE;
2126     i = 0;
2127     while (! Full && (i < C)) {
2128     TempLen = 0;
2129     d = (BYTE)B[i];
2130    
2131 doda 3503 switch (d) {
2132     case CR:
2133 maya 3227 TempStr[TempLen] = 0x0d;
2134     TempLen++;
2135     if (cv->CRSend==IdCRLF) {
2136 doda 3452 TempStr[TempLen++] = 0x0a;
2137 maya 3227 }
2138 doda 3452 else if (cv->CRSend==IdCR && cv->TelFlag && ! cv->TelBinSend) {
2139     TempStr[TempLen++] = 0;
2140 maya 3227 }
2141 maya 6369 else if (cv->CRSend == IdLF) {
2142     TempStr[TempLen-1] = 0x0a;
2143     }
2144 doda 3503 break;
2145 doda 6435
2146 doda 3503 case 0x15: // Ctrl-U
2147     if (cv->TelLineMode) {
2148     // Move to top of line (CHA "\033[G") and erase line (EL "\033[K")
2149     strncpy_s(TempStr, sizeof(TempStr), "\033[G\033[K", _TRUNCATE);
2150     TempLen += 6;
2151     }
2152     else {
2153     TempStr[TempLen++] = d;
2154     }
2155     break;
2156    
2157     default:
2158 doda 3452 if ((cv->Language==IdRussian) && (d>=128)) {
2159 maya 3227 d = RussConv(cv->RussClient,cv->RussHost,d);
2160 maya 3392 }
2161 doda 3452 TempStr[TempLen++] = d;
2162 maya 3227 if (cv->TelFlag && (d==0xff)) {
2163 doda 3452 TempStr[TempLen++] = (char)0xff;
2164 maya 3227 }
2165     }
2166    
2167     Full = InBuffSize-cv->InBuffCount-TempLen < 0;
2168     if (! Full) {
2169     i++;
2170     memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
2171     cv->InBuffCount = cv->InBuffCount + TempLen;
2172     }
2173     } // end of while {}
2174    
2175     return i;
2176     }
2177    
2178 doda 6435 // listup serial port driver
2179 maya 3227 // cf. http://www.codeproject.com/system/setupdi.asp?df=100&forumid=4368&exp=0&select=479661
2180     // (2007.8.17 yutaka)
2181     static void ListupSerialPort(LPWORD ComPortTable, int comports, char **ComPortDesc, int ComPortMax)
2182     {
2183     GUID ClassGuid[1];
2184     DWORD dwRequiredSize;
2185     BOOL bRet;
2186     HDEVINFO DeviceInfoSet = NULL;
2187     SP_DEVINFO_DATA DeviceInfoData;
2188     DWORD dwMemberIndex = 0;
2189     int i;
2190    
2191     DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
2192    
2193     // ���O�����������t���[��������
2194     for (i = 0 ; i < ComPortMax ; i++) {
2195     free(ComPortDesc[i]);
2196     ComPortDesc[i] = NULL;
2197     }
2198    
2199     // Get ClassGuid from ClassName for PORTS class
2200     bRet =
2201     SetupDiClassGuidsFromName(_T("PORTS"), (LPGUID) & ClassGuid, 1,
2202     &dwRequiredSize);
2203 maya 3392 if (!bRet) {
2204 maya 3227 goto cleanup;
2205 maya 3392 }
2206 maya 3227
2207     // Get class devices
2208     // COM�|�[�g�����������t�����������������A�������������������A���W�X�g�����c��������
2209     // ����FriendlyName���\���������������������������B(2007.11.8 yutaka)
2210     DeviceInfoSet =
2211     SetupDiGetClassDevs(&ClassGuid[0], NULL, NULL, DIGCF_PRESENT | DIGCF_PROFILE);
2212    
2213     if (DeviceInfoSet) {
2214     // Enumerate devices
2215     dwMemberIndex = 0;
2216     while (SetupDiEnumDeviceInfo
2217 maya 3392 (DeviceInfoSet, dwMemberIndex++, &DeviceInfoData)) {
2218 maya 3227 TCHAR szFriendlyName[MAX_PATH];
2219     TCHAR szPortName[MAX_PATH];
2220     //TCHAR szMessage[MAX_PATH];
2221     DWORD dwReqSize = 0;
2222     DWORD dwPropType;
2223     DWORD dwType = REG_SZ;
2224     HKEY hKey = NULL;
2225    
2226     // Get friendlyname
2227     bRet = SetupDiGetDeviceRegistryProperty(DeviceInfoSet,
2228     &DeviceInfoData,
2229     SPDRP_FRIENDLYNAME,
2230     &dwPropType,
2231     (LPBYTE)
2232     szFriendlyName,
2233     sizeof(szFriendlyName),
2234     &dwReqSize);
2235    
2236     // Open device parameters reg key
2237     hKey = SetupDiOpenDevRegKey(DeviceInfoSet,
2238     &DeviceInfoData,
2239     DICS_FLAG_GLOBAL,
2240     0, DIREG_DEV, KEY_READ);
2241     if (hKey) {
2242     // Qurey for portname
2243     long lRet;
2244     dwReqSize = sizeof(szPortName);
2245     lRet = RegQueryValueEx(hKey,
2246     _T("PortName"),
2247     0,
2248     &dwType,
2249     (LPBYTE) & szPortName,
2250     &dwReqSize);
2251    
2252     // Close reg key
2253     RegCloseKey(hKey);
2254     }
2255    
2256     #if 0
2257     sprintf(szMessage, _T("Name: %s\nPort: %s\n"), szFriendlyName,
2258     szPortName);
2259     printf("%s\n", szMessage);
2260     #endif
2261    
2262     if (_strnicmp(szPortName, "COM", 3) == 0) { // COM�|�[�g�h���C�o������
2263     int port = atoi(&szPortName[3]);
2264     int i;
2265    
2266     for (i = 0 ; i < comports ; i++) {
2267     if (ComPortTable[i] == port) { // �������m�F
2268     ComPortDesc[i] = _strdup(szFriendlyName);
2269     break;
2270     }
2271     }
2272     }
2273    
2274     }
2275     }
2276    
2277 maya 3392 cleanup:
2278 maya 3227 // Destroy device info list
2279     SetupDiDestroyDeviceInfoList(DeviceInfoSet);
2280     }
2281    
2282    
2283     int PASCAL DetectComPorts(LPWORD ComPortTable, int ComPortMax, char **ComPortDesc)
2284     {
2285     HMODULE h;
2286     TCHAR devicesBuff[65535];
2287     TCHAR *p;
2288     int comports = 0;
2289     int i,