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 6806 - (hide annotations) (download) (as text)
Thu Jun 15 00:37:01 2017 UTC (6 years, 9 months ago) by doda
File MIME type: text/x-csrc
File size: 60186 byte(s) 
TeraTerm Project としてのライセンス表記を追加

とりあえず Tera Term 本体分。
TeraTerm Project としての copyright 表記の年部分はコミットログを確認して書いたつもりだけど、ミスってたらすみません。

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