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 6888 - (hide annotations) (download) (as text)
Wed Jul 26 03:47:58 2017 UTC (6 years, 8 months ago) by doda
File MIME type: text/x-csrc
File size: 60248 byte(s) 
現在のウィンドウ数を返す関数を作り、vtwin.cpp ではそれを使うように変更。

ループで無理やり数えるくらいならば、pm->NWin を見せるようにする方がいいと思う。
本当は各ウィンドウに対して処理を行うようなイテレータを ttpcmn.dll が提供する方がいいのかもしれないけれど。
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 doda 6888 int PASCAL GetRegisteredWindowCount()
1191     {
1192     return (pm->NWin);
1193     }
1194 yutakapon 5222
1195 yutakapon 5223 // �L�����E�B���h�E���T���A�������u���L�������������B
1196 yutakapon 5299 static void get_valid_window_and_memorize_rect(HWND myhwnd, HWND hwnd[], int *num, int style)
1197 yutakapon 5222 {
1198 yutakapon 5223 int i, n;
1199     WINDOWPLACEMENT wndPlace;
1200 yutakapon 5222
1201 yutakapon 5299 // ��������(Undo)���j���[�����x�����\���������B
1202     if (pm->WinUndoFlag == FALSE) {
1203     pm->WinUndoFlag = TRUE;
1204     } else {
1205     // ���������j���[���\�������������A�������O�������X�^�C�����I�����������A
1206     // ���j���[�������B
1207     // Windows8�����A�������A�����������X�^�C�����I�����������j���[�����������������A
1208     // Tera Term�������j���[���\�������������A�������������B
1209     if (pm->WinUndoStyle == style)
1210     pm->WinUndoFlag = FALSE;
1211     }
1212     pm->WinUndoStyle = style;
1213    
1214 yutakapon 5222 n = 0;
1215     for (i = 0 ; i < pm->NWin ; i++) {
1216 yutakapon 5223 // �������u���o���������B
1217     wndPlace.length = sizeof(WINDOWPLACEMENT);
1218     GetWindowPlacement(pm->WinList[i], &wndPlace);
1219     pm->WinPrevRect[i] = wndPlace;
1220    
1221     // �������g�������������B
1222 yutakapon 5222 if (pm->WinList[i] == myhwnd) {
1223     hwnd[n] = hwnd[0];
1224     hwnd[0] = myhwnd;
1225     } else {
1226     hwnd[n] = pm->WinList[i];
1227     }
1228     n++;
1229     }
1230 yutakapon 5223 *num = n;
1231     }
1232 yutakapon 5222
1233 yutakapon 5223 // �E�B���h�E�����E���������\������(Show Windows Side by Side)
1234 doda 6801 void PASCAL ShowAllWinSidebySide(HWND myhwnd)
1235 yutakapon 5223 {
1236     int n;
1237     HWND hwnd[MAXNWIN];
1238    
1239 yutakapon 5299 get_valid_window_and_memorize_rect(myhwnd, hwnd, &n, WIN_SIDEBYSIDE);
1240 yutakapon 5251 TileWindows(NULL, MDITILE_VERTICAL, NULL, n, hwnd);
1241 yutakapon 5222 }
1242    
1243     // �E�B���h�E���������������\������(Show Windows Stacked)
1244 doda 6801 void PASCAL ShowAllWinStacked(HWND myhwnd)
1245 yutakapon 5222 {
1246 yutakapon 5223 int n;
1247 yutakapon 5222 HWND hwnd[MAXNWIN];
1248    
1249 yutakapon 5299 get_valid_window_and_memorize_rect(myhwnd, hwnd, &n, WIN_STACKED);
1250 yutakapon 5251 TileWindows(NULL, MDITILE_HORIZONTAL, NULL, n, hwnd);
1251 yutakapon 5222 }
1252    
1253     // �E�B���h�E���d�����\������(Cascade)
1254 doda 6801 void PASCAL ShowAllWinCascade(HWND myhwnd)
1255 yutakapon 5222 {
1256 yutakapon 5223 int n;
1257     HWND hwnd[MAXNWIN];
1258    
1259 yutakapon 5299 get_valid_window_and_memorize_rect(myhwnd, hwnd, &n, WIN_CASCADE);
1260 yutakapon 5251 CascadeWindows(NULL, MDITILE_SKIPDISABLED, NULL, n, hwnd);
1261 yutakapon 5222 }
1262    
1263 yutakapon 5232 // �STera Term���I���w�����o���B
1264 doda 6801 void PASCAL BroadcastClosingMessage(HWND myhwnd)
1265 yutakapon 5232 {
1266     int i, max;
1267     HWND hwnd[MAXNWIN];
1268    
1269     // Tera Term���I�����������A���L���������������������A
1270     // ���������o�b�t�@���R�s�[���������B
1271     max = pm->NWin;
1272     for (i = 0 ; i < pm->NWin ; i++) {
1273     hwnd[i] = pm->WinList[i];
1274     }
1275    
1276     for (i = 0 ; i < max ; i++) {
1277     // �������g�������������B
1278 doda 6435 if (hwnd[i] == myhwnd)
1279 yutakapon 5232 continue;
1280    
1281     PostMessage(hwnd[i], WM_USER_NONCONFIRM_CLOSE, 0, 0);
1282     }
1283     PostMessage(myhwnd, WM_USER_NONCONFIRM_CLOSE, 0, 0);
1284     }
1285    
1286    
1287 doda 6801 int PASCAL CommReadRawByte(PComVar cv, LPBYTE b)
1288 maya 3227 {
1289 maya 3392 if ( ! cv->Ready ) {
1290 maya 3227 return 0;
1291 maya 3392 }
1292 maya 3227
1293     if ( cv->InBuffCount>0 ) {
1294     *b = cv->InBuff[cv->InPtr];
1295     cv->InPtr++;
1296     cv->InBuffCount--;
1297 maya 3392 if ( cv->InBuffCount==0 ) {
1298 maya 3227 cv->InPtr = 0;
1299 maya 3392 }
1300 maya 3227 return 1;
1301     }
1302     else {
1303     cv->InPtr = 0;
1304     return 0;
1305     }
1306     }
1307    
1308 doda 6801 void PASCAL CommInsert1Byte(PComVar cv, BYTE b)
1309 maya 3227 {
1310 maya 3392 if ( ! cv->Ready ) {
1311 maya 3227 return;
1312 maya 3392 }
1313 maya 3227
1314 maya 3392 if (cv->InPtr == 0) {
1315 maya 3227 memmove(&(cv->InBuff[1]),&(cv->InBuff[0]),cv->InBuffCount);
1316 maya 3392 }
1317     else {
1318 maya 3227 cv->InPtr--;
1319 maya 3392 }
1320 maya 3227 cv->InBuff[cv->InPtr] = b;
1321     cv->InBuffCount++;
1322    
1323 maya 3392 if (cv->HBinBuf!=0 ) {
1324 maya 3227 cv->BinSkip++;
1325 maya 3392 }
1326 maya 3227 }
1327    
1328     void Log1Bin(PComVar cv, BYTE b)
1329     {
1330 maya 3392 if (((cv->FilePause & OpLog)!=0) || cv->ProtoFlag) {
1331 maya 3227 return;
1332 maya 3392 }
1333 maya 3227 if (cv->BinSkip > 0) {
1334     cv->BinSkip--;
1335     return;
1336     }
1337     cv->BinBuf[cv->BinPtr] = b;
1338     cv->BinPtr++;
1339 maya 3392 if (cv->BinPtr>=InBuffSize) {
1340 maya 3227 cv->BinPtr = cv->BinPtr-InBuffSize;
1341 maya 3392 }
1342 maya 3227 if (cv->BCount>=InBuffSize) {
1343     cv->BCount = InBuffSize;
1344     cv->BStart = cv->BinPtr;
1345     }
1346 maya 3392 else {
1347 maya 3227 cv->BCount++;
1348 maya 3392 }
1349 maya 3227 }
1350    
1351 doda 6801 int PASCAL CommRead1Byte(PComVar cv, LPBYTE b)
1352 maya 3227 {
1353     int c;
1354    
1355 maya 3392 if ( ! cv->Ready ) {
1356 maya 3227 return 0;
1357 maya 3392 }
1358 maya 3227
1359     if ((cv->HLogBuf!=NULL) &&
1360     ((cv->LCount>=InBuffSize-10) ||
1361     (cv->DCount>=InBuffSize-10))) {
1362     // �������o�b�t�@���]�T�������������ACPU�X�P�W���[�����O�����������A
1363     // CPU���X�g�[���������h���B
1364     // (2006.10.13 yutaka)
1365     Sleep(1);
1366     return 0;
1367     }
1368    
1369     if ((cv->HBinBuf!=NULL) &&
1370 maya 3392 (cv->BCount>=InBuffSize-10)) {
1371 maya 3227 return 0;
1372 maya 3392 }
1373 maya 3227
1374 maya 3392 if ( cv->TelMode ) {
1375 maya 3227 c = 0;
1376 maya 3392 }
1377     else {
1378 maya 3227 c = CommReadRawByte(cv,b);
1379 maya 3392 }
1380 maya 3227
1381     if ((c==1) && cv->TelCRFlag) {
1382     cv->TelCRFlag = FALSE;
1383 maya 3392 if (*b==0) {
1384     c = 0;
1385     }
1386 maya 3227 }
1387    
1388     if ( c==1 ) {
1389     if ( cv->IACFlag ) {
1390     cv->IACFlag = FALSE;
1391     if ( *b != 0xFF ) {
1392     cv->TelMode = TRUE;
1393     CommInsert1Byte(cv,*b);
1394 maya 3392 if ( cv->HBinBuf!=0 ) {
1395 maya 3227 cv->BinSkip--;
1396 maya 3392 }
1397 maya 3227 c = 0;
1398     }
1399     }
1400     else if ((cv->PortType==IdTCPIP) && (*b==0xFF)) {
1401 maya 3392 if (!cv->TelFlag && cv->TelAutoDetect) { /* TTPLUG */
1402 maya 3227 cv->TelFlag = TRUE;
1403 maya 3392 }
1404 maya 3227 if (cv->TelFlag) {
1405     cv->IACFlag = TRUE;
1406     c = 0;
1407     }
1408     }
1409 maya 3392 else if (cv->TelFlag && ! cv->TelBinRecv && (*b==0x0D)) {
1410 maya 3227 cv->TelCRFlag = TRUE;
1411 maya 3392 }
1412 maya 3227 }
1413    
1414 maya 3392 if ( (c==1) && (cv->HBinBuf!=0) ) {
1415 maya 3227 Log1Bin(cv, *b);
1416 maya 3392 }
1417 maya 3227
1418     return c;
1419     }
1420    
1421 doda 6801 int PASCAL CommRawOut(PComVar cv, PCHAR B, int C)
1422 maya 3227 {
1423     int a;
1424    
1425 maya 3392 if ( ! cv->Ready ) {
1426 maya 3227 return C;
1427 maya 3392 }
1428 maya 3227
1429 maya 3392 if (C > OutBuffSize - cv->OutBuffCount) {
1430 maya 3227 a = OutBuffSize - cv->OutBuffCount;
1431 maya 3392 }
1432     else {
1433 maya 3227 a = C;
1434 maya 3392 }
1435 maya 3227 if ( cv->OutPtr > 0 ) {
1436     memmove(&(cv->OutBuff[0]),&(cv->OutBuff[cv->OutPtr]),cv->OutBuffCount);
1437     cv->OutPtr = 0;
1438     }
1439     memcpy(&(cv->OutBuff[cv->OutBuffCount]),B,a);
1440     cv->OutBuffCount = cv->OutBuffCount + a;
1441     return a;
1442     }
1443    
1444 doda 6801 int PASCAL CommBinaryOut(PComVar cv, PCHAR B, int C)
1445 maya 3227 {
1446     int a, i, Len;
1447     char d[3];
1448    
1449 maya 3392 if ( ! cv->Ready ) {
1450 maya 3227 return C;
1451 maya 3392 }
1452 maya 3227
1453     i = 0;
1454     a = 1;
1455     while ((a>0) && (i<C)) {
1456     Len = 0;
1457    
1458     d[Len] = B[i];
1459     Len++;
1460    
1461 doda 3505 if ( cv->TelFlag && (B[i]=='\x0d') && ! cv->TelBinSend ) {
1462     d[Len++] = '\x00';
1463 maya 3227 }
1464 doda 3505 else if ( cv->TelFlag && (B[i]=='\xff') ) {
1465     d[Len++] = '\xff';
1466     }
1467 maya 3227
1468 doda 3505 if ( OutBuffSize - cv->OutBuffCount - Len >= 0 ) {
1469     CommRawOut(cv, d, Len);
1470 maya 3227 a = 1;
1471     }
1472 maya 3392 else {
1473 maya 3227 a = 0;
1474 maya 3392 }
1475 maya 3227
1476 doda 3505 i += a;
1477 maya 3227 }
1478     return i;
1479     }
1480    
1481 doda 6801 int PASCAL CommBinaryBuffOut(PComVar cv, PCHAR B, int C)
1482 doda 3505 {
1483     int a, i, Len, OutLen;
1484     char d[3];
1485    
1486     if ( ! cv->Ready ) {
1487     return C;
1488     }
1489    
1490     i = 0;
1491     a = 1;
1492     while ((a>0) && (i<C)) {
1493     Len = 0;
1494    
1495     d[Len] = B[i];
1496     Len++;
1497    
1498     if (B[i] == CR) {
1499     if ( cv->TelFlag && ! cv->TelBinSend ) {
1500     d[Len++] = '\x00';
1501     }
1502     if (cv->TelLineMode) {
1503     cv->Flush = TRUE;
1504     }
1505     }
1506     else if ( cv->TelFlag && (B[i]=='\xff') ) {
1507     d[Len++] = '\xff';
1508     }
1509    
1510     if (cv->TelLineMode) {
1511     if (OutBuffSize - cv->LineModeBuffCount - Len >= 0) {
1512     memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), d, Len);
1513     cv->LineModeBuffCount += Len;
1514     if (cv->Flush) {
1515     cv->FlushLen = cv->LineModeBuffCount;
1516     }
1517     a = 1;
1518     }
1519     else {
1520     a = 0;
1521     }
1522     if (cv->FlushLen > 0) {
1523     OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
1524     cv->FlushLen -= OutLen;
1525     cv->LineModeBuffCount -= OutLen;
1526     memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
1527     }
1528     cv->Flush = FALSE;
1529     }
1530     else {
1531     if ( OutBuffSize - cv->OutBuffCount - Len >= 0 ) {
1532     CommRawOut(cv, d, Len);
1533     a = 1;
1534     }
1535     else {
1536     a = 0;
1537     }
1538     }
1539    
1540     i += a;
1541     }
1542     return i;
1543     }
1544    
1545 doda 3442 static int OutputTextUTF8(WORD K, char *TempStr, PComVar cv)
1546 maya 3227 {
1547     unsigned int code;
1548 doda 3442 int outlen;
1549     int TempLen = 0;
1550 maya 3227
1551 doda 3442 code = SJIS2UTF8(K, &outlen, cv->Locale);
1552     switch (outlen) {
1553 doda 3457 case 4:
1554     TempStr[TempLen++] = (code >> 24) & 0xff;
1555 doda 3442 case 3:
1556 maya 3227 TempStr[TempLen++] = (code >> 16) & 0xff;
1557 doda 3442 case 2:
1558 maya 3227 TempStr[TempLen++] = (code >> 8) & 0xff;
1559 doda 3442 case 1:
1560 maya 3227 TempStr[TempLen++] = code & 0xff;
1561     }
1562    
1563 doda 3442 return TempLen;
1564 maya 3227 }
1565    
1566 doda 6435 //
1567 doda 3451 // MBCS�����e�������R�[�h�����������o�������B
1568 maya 3227 //
1569 doda 3451 int TextOutMBCS(PComVar cv, PCHAR B, int C)
1570 maya 3227 {
1571 doda 3494 int i, TempLen, OutLen;
1572 maya 3227 WORD K;
1573 doda 3442 char TempStr[12];
1574 maya 3227 int SendCodeNew;
1575     BYTE d;
1576     BOOL Full, KanjiFlagNew;
1577    
1578     Full = FALSE;
1579     i = 0;
1580     while (! Full && (i < C)) {
1581     TempLen = 0;
1582     d = (BYTE)B[i];
1583     SendCodeNew = cv->SendCode;
1584 doda 3442 KanjiFlagNew = FALSE;
1585 maya 3227
1586     if (cv->SendKanjiFlag) {
1587     SendCodeNew = IdKanji;
1588    
1589     K = (cv->SendKanjiFirst << 8) + d;
1590    
1591     // UTF-8�����������s���B1�`3�o�C�g���������������������B
1592 doda 3408 if (cv->KanjiCodeSend == IdUTF8 || cv->Language == IdUtf8) {
1593 doda 3442 TempLen += OutputTextUTF8(K, TempStr, cv);
1594     }
1595     else {
1596     switch (cv->Language) {
1597     case IdJapanese:
1598 doda 6435 switch (cv->KanjiCodeSend) {
1599 doda 3442 case IdEUC:
1600 doda 3419 K = SJIS2EUC(K);
1601 doda 3442 break;
1602     case IdJIS:
1603 doda 3419 K = SJIS2JIS(K);
1604 doda 3442 if ((cv->SendCode==IdKatakana) &&
1605     (cv->JIS7KatakanaSend==1)) {
1606     TempStr[TempLen++] = SI;
1607     }
1608     break;
1609     case IdSJIS:
1610     /* nothing to do */
1611     break;
1612 doda 3419 }
1613 doda 3442 break;
1614     case IdKorean:
1615 doda 6435 break;
1616 maya 3227 }
1617 doda 3442 TempStr[TempLen++] = HIBYTE(K);
1618     TempStr[TempLen++] = LOBYTE(K);
1619 maya 3227 }
1620     }
1621 doda 3932 else if (_isleadbyte_l(d, cv->locale)) {
1622 maya 3227 KanjiFlagNew = TRUE;
1623     cv->SendKanjiFirst = d;
1624     SendCodeNew = IdKanji;
1625    
1626 doda 3442 if (cv->Language == IdJapanese) {
1627     if ((cv->SendCode!=IdKanji) && (cv->KanjiCodeSend==IdJIS)) {
1628     TempStr[0] = 0x1B;
1629     TempStr[1] = '$';
1630     if (cv->KanjiIn == IdKanjiInB) {
1631     TempStr[2] = 'B';
1632     }
1633     else {
1634     TempStr[2] = '@';
1635     }
1636     TempLen = 3;
1637 maya 3392 }
1638 maya 3227 }
1639     }
1640     else {
1641 doda 3442 if (cv->Language == IdJapanese) {
1642     if ((cv->SendCode==IdKanji) && (cv->KanjiCodeSend==IdJIS)) {
1643     TempStr[0] = 0x1B;
1644     TempStr[1] = '(';
1645     switch (cv->KanjiOut) {
1646     case IdKanjiOutJ:
1647 maya 3409 TempStr[2] = 'J';
1648     break;
1649 doda 3442 case IdKanjiOutH:
1650 maya 3409 TempStr[2] = 'H';
1651     break;
1652 doda 3442 default:
1653 maya 3409 TempStr[2] = 'B';
1654 doda 3442 }
1655     TempLen = 3;
1656 maya 3227 }
1657    
1658 doda 3442 if ((0xa0<d) && (d<0xe0)) {
1659     SendCodeNew = IdKatakana;
1660     if ((cv->SendCode!=IdKatakana) &&
1661     (cv->KanjiCodeSend==IdJIS) &&
1662     (cv->JIS7KatakanaSend==1)) {
1663     TempStr[TempLen++] = SO;
1664     }
1665 maya 3227 }
1666 doda 3442 else {
1667     SendCodeNew = IdASCII;
1668     if ((cv->SendCode==IdKatakana) &&
1669     (cv->KanjiCodeSend==IdJIS) &&
1670     (cv->JIS7KatakanaSend==1)) {
1671     TempStr[TempLen++] = SI;
1672     }
1673 maya 3227 }
1674     }
1675    
1676 doda 3497 if (d==CR) {
1677 doda 3442 TempStr[TempLen++] = 0x0d;
1678 maya 3227 if (cv->CRSend==IdCRLF) {
1679 doda 3442 TempStr[TempLen++] = 0x0a;
1680 maya 3227 }
1681     else if ((cv->CRSend==IdCR) &&
1682 doda 3398 cv->TelFlag && ! cv->TelBinSend) {
1683 doda 3442 TempStr[TempLen++] = 0;
1684 maya 3227 }
1685 maya 6369 else if (cv->CRSend == IdLF) {
1686     TempStr[TempLen-1] = 0x0a;
1687     }
1688 doda 3494 if (cv->TelLineMode) {
1689     cv->Flush = TRUE;
1690     }
1691 maya 3227 }
1692 doda 3497 else if (d==BS) {
1693     if (cv->TelLineMode) {
1694     if (cv->FlushLen < cv->LineModeBuffCount) {
1695     cv->LineModeBuffCount--;
1696     }
1697     }
1698 maya 6369 else {
1699 doda 3497 TempStr[TempLen++] = d;
1700     }
1701     }
1702 doda 3498 else if (d==0x15) { // Ctrl-U
1703     if (cv->TelLineMode) {
1704     cv->LineModeBuffCount = cv->FlushLen;
1705     }
1706 maya 6369 else {
1707 doda 3498 TempStr[TempLen++] = d;
1708     }
1709     }
1710 doda 3442 else if ((d>=0x80) && (cv->KanjiCodeSend==IdUTF8 || cv->Language==IdUtf8)) {
1711     TempLen += OutputTextUTF8((WORD)d, TempStr, cv);
1712     }
1713     else if ((d>=0xa1) && (d<=0xe0) && (cv->Language == IdJapanese)) {
1714 doda 3452 /* Katakana */
1715 maya 3227 if (cv->KanjiCodeSend==IdEUC) {
1716 doda 3444 TempStr[TempLen++] = (char)SS2;
1717 maya 3227 }
1718     if ((cv->KanjiCodeSend==IdJIS) &&
1719 maya 3392 (cv->JIS7KatakanaSend==1)) {
1720 doda 3442 TempStr[TempLen++] = d & 0x7f;
1721 maya 3392 }
1722     else {
1723 doda 3442 TempStr[TempLen++] = d;
1724 maya 3392 }
1725 maya 3227 }
1726     else {
1727 doda 3442 TempStr[TempLen++] = d;
1728 maya 3227 if (cv->TelFlag && (d==0xff)) {
1729 doda 3442 TempStr[TempLen++] = (char)0xff;
1730 maya 3227 }
1731     }
1732     } // if (cv->SendKanjiFlag) else if ... else ... end
1733    
1734 doda 3494 if (cv->TelLineMode) {
1735     if (TempLen == 0) {
1736     i++;
1737     cv->SendCode = SendCodeNew;
1738     cv->SendKanjiFlag = KanjiFlagNew;
1739     }
1740     else {
1741     Full = OutBuffSize - cv->LineModeBuffCount - TempLen < 0;
1742     if (!Full) {
1743     i++;
1744     cv->SendCode = SendCodeNew;
1745     cv->SendKanjiFlag = KanjiFlagNew;
1746     memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), TempStr, TempLen);
1747     cv->LineModeBuffCount += TempLen;
1748     if (cv->Flush) {
1749     cv->FlushLen = cv->LineModeBuffCount;
1750     }
1751     }
1752     }
1753     if (cv->FlushLen > 0) {
1754     OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
1755     cv->FlushLen -= OutLen;
1756     cv->LineModeBuffCount -= OutLen;
1757     memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
1758     }
1759     cv->Flush = FALSE;
1760 maya 3227 }
1761     else {
1762 doda 3494 if (TempLen == 0) {
1763 maya 3227 i++;
1764     cv->SendCode = SendCodeNew;
1765     cv->SendKanjiFlag = KanjiFlagNew;
1766     }
1767 doda 3494 else {
1768     Full = OutBuffSize-cv->OutBuffCount-TempLen < 0;
1769     if (! Full) {
1770     i++;
1771     cv->SendCode = SendCodeNew;
1772     cv->SendKanjiFlag = KanjiFlagNew;
1773     CommRawOut(cv,TempStr,TempLen);
1774     }
1775     }
1776 maya 3227 }
1777    
1778     } // end of "while {}"
1779    
1780     return i;
1781     }
1782    
1783 doda 6801 int PASCAL CommTextOut(PComVar cv, PCHAR B, int C)
1784 maya 3227 {
1785 doda 3494 int i, TempLen, OutLen;
1786 doda 3442 char TempStr[12];
1787 maya 3227 BYTE d;
1788     BOOL Full;
1789    
1790 maya 3392 if (! cv->Ready ) {
1791 maya 3227 return C;
1792 maya 3392 }
1793 maya 3227
1794 maya 4009 switch (cv->Language) {
1795     case IdUtf8:
1796     case IdJapanese:
1797     case IdKorean:
1798     return TextOutMBCS(cv, B, C);
1799     break;
1800 maya 3392 }
1801 maya 3227
1802     Full = FALSE;
1803     i = 0;
1804     while (! Full && (i < C)) {
1805     TempLen = 0;
1806     d = (BYTE)B[i];
1807 doda 6435
1808 doda 3497 switch (d) {
1809     case CR:
1810 maya 3227 TempStr[TempLen] = 0x0d;
1811     TempLen++;
1812     if (cv->CRSend==IdCRLF) {
1813 doda 3452 TempStr[TempLen++] = 0x0a;
1814 maya 3227 }
1815 doda 3452 else if (cv->CRSend==IdCR && cv->TelFlag && ! cv->TelBinSend) {
1816     TempStr[TempLen++] = 0;
1817 maya 3227 }
1818 maya 6369 else if (cv->CRSend == IdLF) {
1819     TempStr[TempLen-1] = 0x0a;
1820     }
1821 doda 3494 if (cv->TelLineMode) {
1822     cv->Flush = TRUE;
1823     }
1824 doda 3497 break;
1825    
1826     case BS:
1827     if (cv->TelLineMode) {
1828     if (cv->FlushLen < cv->LineModeBuffCount) {
1829     cv->LineModeBuffCount--;
1830     }
1831     }
1832 doda 6435 else {
1833 doda 3497 TempStr[TempLen++] = d;
1834     }
1835     break;
1836    
1837 doda 3498 case 0x15: // Ctrl-U
1838     if (cv->TelLineMode) {
1839     cv->LineModeBuffCount = cv->FlushLen;
1840     }
1841     else {
1842     TempStr[TempLen++] = d;
1843     }
1844 doda 3504 break;
1845 doda 3498
1846 doda 3497 default:
1847 doda 3452 if ((cv->Language==IdRussian) && (d>=128)) {
1848 doda 3494 d = RussConv(cv->RussClient, cv->RussHost, d);
1849 doda 3452 }
1850     TempStr[TempLen++] = d;
1851 maya 3227 if (cv->TelFlag && (d==0xff)) {
1852 doda 3452 TempStr[TempLen++] = (char)0xff;
1853 maya 3227 }
1854     }
1855    
1856 doda 3494 if (cv->TelLineMode) {
1857     Full = OutBuffSize - cv->LineModeBuffCount - TempLen < 0;
1858     if (!Full) {
1859 doda 3888 i++;
1860 doda 3494 memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), TempStr, TempLen);
1861     cv->LineModeBuffCount += TempLen;
1862     if (cv->Flush) {
1863     cv->FlushLen = cv->LineModeBuffCount;
1864     }
1865     }
1866     if (cv->FlushLen > 0) {
1867     OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
1868     cv->FlushLen -= OutLen;
1869     cv->LineModeBuffCount -= OutLen;
1870     memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
1871     }
1872     cv->Flush = FALSE;
1873 maya 3227 }
1874 doda 3494 else {
1875     Full = OutBuffSize - cv->OutBuffCount - TempLen < 0;
1876     if (! Full) {
1877     i++;
1878     CommRawOut(cv,TempStr,TempLen);
1879     }
1880     }
1881 maya 3227 } // end of while {}
1882    
1883     return i;
1884     }
1885    
1886 doda 6801 int PASCAL CommBinaryEcho(PComVar cv, PCHAR B, int C)
1887 maya 3227 {
1888     int a, i, Len;
1889     char d[3];
1890    
1891     if ( ! cv->Ready )
1892     return C;
1893    
1894     if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
1895     memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
1896     cv->InPtr = 0;
1897     }
1898    
1899     i = 0;
1900     a = 1;
1901     while ((a>0) && (i<C)) {
1902     Len = 0;
1903    
1904     d[Len] = B[i];
1905     Len++;
1906    
1907     if ( cv->TelFlag && (B[i]=='\x0d') &&
1908     ! cv->TelBinSend ) {
1909     d[Len] = 0x00;
1910     Len++;
1911     }
1912    
1913     if ( cv->TelFlag && (B[i]=='\xff') ) {
1914     d[Len] = '\xff';
1915     Len++;
1916     }
1917    
1918     if ( InBuffSize-cv->InBuffCount-Len >=0 ) {
1919     memcpy(&(cv->InBuff[cv->InBuffCount]),d,Len);
1920     cv->InBuffCount = cv->InBuffCount + Len;
1921     a = 1;
1922     }
1923     else
1924     a = 0;
1925     i = i + a;
1926     }
1927     return i;
1928     }
1929    
1930 doda 6801 int PASCAL TextEchoMBCS(PComVar cv, PCHAR B, int C)
1931 maya 3227 {
1932     int i, TempLen;
1933     WORD K;
1934 doda 3452 char TempStr[12];
1935 maya 3227 int EchoCodeNew;
1936     BYTE d;
1937     BOOL Full, KanjiFlagNew;
1938    
1939     Full = FALSE;
1940     i = 0;
1941     while (! Full && (i < C)) {
1942     TempLen = 0;
1943     d = (BYTE)B[i];
1944     EchoCodeNew = cv->EchoCode;
1945 doda 3452 KanjiFlagNew = FALSE;
1946 maya 3227
1947     if (cv->EchoKanjiFlag) {
1948     EchoCodeNew = IdKanji;
1949    
1950     K = (cv->EchoKanjiFirst << 8) + d;
1951 doda 3452
1952 maya 3227 // UTF-8�����������s���B1�`3�o�C�g���������������������B
1953 doda 3452 if (cv->KanjiCodeEcho == IdUTF8 || cv->Language==IdUtf8) {
1954 doda 3442 TempLen += OutputTextUTF8(K, TempStr, cv);
1955 maya 3227 }
1956     else {
1957 doda 3452 switch (cv->Language) {
1958     case IdJapanese:
1959     switch (cv->KanjiCodeEcho) {
1960     case IdEUC:
1961     K = SJIS2EUC(K);
1962     break;
1963     case IdJIS:
1964     K = SJIS2JIS(K);
1965     if ((cv->EchoCode==IdKatakana) &&
1966     (cv->JIS7KatakanaEcho==1)) {
1967     TempStr[TempLen++] = SI;
1968     }
1969     break;
1970     case IdSJIS:
1971     /* nothing to do */
1972     break;
1973     }
1974     break;
1975     case IdKorean:
1976     break;
1977 maya 3392 }
1978 doda 3452 TempStr[TempLen++] = HIBYTE(K);
1979     TempStr[TempLen++] = LOBYTE(K);
1980 maya 3227 }
1981     }
1982 doda 3932 else if (_isleadbyte_l(d, cv->locale)) {
1983 maya 3227 KanjiFlagNew = TRUE;
1984     cv->EchoKanjiFirst = d;
1985     EchoCodeNew = IdKanji;
1986    
1987 doda 3452 if (cv->Language == IdJapanese) {
1988     if ((cv->EchoCode!=IdKanji) && (cv->KanjiCodeEcho==IdJIS)) {
1989     TempStr[0] = 0x1B;
1990     TempStr[1] = '$';
1991     if (cv->KanjiIn == IdKanjiInB) {
1992     TempStr[2] = 'B';
1993     }
1994     else {
1995     TempStr[2] = '@';
1996     }
1997     TempLen = 3;
1998 maya 3392 }
1999 maya 3227 }
2000     }
2001     else {
2002 doda 3452 if (cv->Language == IdJapanese) {
2003     if ((cv->EchoCode==IdKanji) && (cv->KanjiCodeEcho==IdJIS)) {
2004     TempStr[0] = 0x1B;
2005     TempStr[1] = '(';
2006     switch (cv->KanjiOut) {
2007     case IdKanjiOutJ:
2008 maya 3227 TempStr[2] = 'J';
2009     break;
2010 doda 3452 case IdKanjiOutH:
2011 maya 3227 TempStr[2] = 'H';
2012     break;
2013 doda 3452 default:
2014 maya 3227 TempStr[2] = 'B';
2015 doda 3452 }
2016     TempLen = 3;
2017 maya 3227 }
2018    
2019 doda 3452 if ((0xa0<d) && (d<0xe0)) {
2020     EchoCodeNew = IdKatakana;
2021     if ((cv->EchoCode!=IdKatakana) &&
2022     (cv->KanjiCodeEcho==IdJIS) &&
2023     (cv->JIS7KatakanaEcho==1)) {
2024     TempStr[TempLen++] = SO;
2025     }
2026 maya 3227 }
2027 doda 3452 else {
2028     EchoCodeNew = IdASCII;
2029     if ((cv->EchoCode==IdKatakana) &&
2030     (cv->KanjiCodeEcho==IdJIS) &&
2031     (cv->JIS7KatakanaEcho==1)) {
2032     TempStr[TempLen++] = SI;
2033     }
2034 maya 3227 }
2035     }
2036    
2037 doda 3503 if (d==CR) {
2038 doda 3452 TempStr[TempLen++] = 0x0d;
2039 maya 3227 if (cv->CRSend==IdCRLF) {
2040 doda 3452 TempStr[TempLen++] = 0x0a;
2041 maya 3227 }
2042     else if ((cv->CRSend==IdCR) &&
2043 maya 3392 cv->TelFlag && ! cv->TelBinSend) {
2044 doda 3452 TempStr[TempLen++] = 0;
2045 maya 3227 }
2046 maya 6369 else if (cv->CRSend == IdLF) {
2047     TempStr[TempLen-1] = 0x0a;
2048     }
2049 maya 3227 }
2050 doda 3503 else if (d==0x15) { // Ctrl-U
2051     if (cv->TelLineMode) {
2052     // Move to top of line (CHA "\033[G") and erase line (EL "\033[K")
2053     strncpy_s(TempStr, sizeof(TempStr), "\033[G\033[K", _TRUNCATE);
2054     TempLen += 6;
2055     }
2056     else {
2057     TempStr[TempLen++] = d;
2058     }
2059     }
2060 doda 3452 else if ((d>=0x80) && (cv->KanjiCodeEcho==IdUTF8 || cv->Language==IdUtf8)) {
2061     TempLen += OutputTextUTF8((WORD)d, TempStr, cv);
2062     }
2063     else if ((d>=0xa1) && (d<=0xe0) && (cv->Language == IdJapanese)) {
2064 maya 3227 /* Katakana */
2065     if (cv->KanjiCodeEcho==IdEUC) {
2066 doda 3452 TempStr[TempLen++] = (char)SS2;
2067 maya 3227 }
2068     if ((cv->KanjiCodeEcho==IdJIS) &&
2069 maya 3392 (cv->JIS7KatakanaEcho==1)) {
2070 doda 3452 TempStr[TempLen++] = d & 0x7f;
2071 maya 3392 }
2072     else {
2073 doda 3452 TempStr[TempLen++] = d;
2074 maya 3392 }
2075 maya 3227 }
2076     else {
2077 doda 3452 TempStr[TempLen++] = d;
2078 maya 3227 if (cv->TelFlag && (d==0xff)) {
2079 doda 3452 TempStr[TempLen++] = (char)0xff;
2080 maya 3227 }
2081     }
2082 doda 3452 } // if (cv->EchoKanjiFlag) else if ... else ... end
2083 maya 3227
2084     if (TempLen == 0) {
2085     i++;
2086     cv->EchoCode = EchoCodeNew;
2087     cv->EchoKanjiFlag = KanjiFlagNew;
2088     }
2089     else {
2090     Full = InBuffSize-cv->InBuffCount-TempLen < 0;
2091     if (! Full) {
2092     i++;
2093     cv->EchoCode = EchoCodeNew;
2094     cv->EchoKanjiFlag = KanjiFlagNew;
2095     memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
2096     cv->InBuffCount = cv->InBuffCount + TempLen;
2097     }
2098     }
2099    
2100     } // end of "while {}"
2101    
2102     return i;
2103     }
2104    
2105 doda 6801 int PASCAL CommTextEcho(PComVar cv, PCHAR B, int C)
2106 maya 3227 {
2107     int i, TempLen;
2108     char TempStr[11];
2109     BYTE d;
2110     BOOL Full;
2111    
2112 maya 3392 if ( ! cv->Ready ) {
2113 maya 3227 return C;
2114 maya 3392 }
2115 maya 3227
2116     if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
2117     memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
2118     cv->InPtr = 0;
2119     }
2120    
2121 doda 3452 switch (cv->Language) {
2122     case IdUtf8:
2123     case IdJapanese:
2124     case IdKorean:
2125 doda 3458 return TextEchoMBCS(cv,B,C);
2126 doda 3452 break;
2127 doda 3438 }
2128 maya 3227
2129     Full = FALSE;
2130     i = 0;
2131     while (! Full && (i < C)) {
2132     TempLen = 0;
2133     d = (BYTE)B[i];
2134    
2135 doda 3503 switch (d) {
2136     case CR:
2137 maya 3227 TempStr[TempLen] = 0x0d;
2138     TempLen++;
2139     if (cv->CRSend==IdCRLF) {
2140 doda 3452 TempStr[TempLen++] = 0x0a;
2141 maya 3227 }
2142 doda 3452 else if (cv->CRSend==IdCR && cv->TelFlag && ! cv->TelBinSend) {
2143     TempStr[TempLen++] = 0;
2144 maya 3227 }
2145 maya 6369 else if (cv->CRSend == IdLF) {
2146     TempStr[TempLen-1] = 0x0a;
2147     }
2148 doda 3503 break;
2149 doda 6435
2150 doda 3503 case 0x15: // Ctrl-U
2151     if (cv->TelLineMode) {
2152     // Move to top of line (CHA "\033[G") and erase line (EL "\033[K")
2153     strncpy_s(TempStr, sizeof(TempStr), "\033[G\033[K", _TRUNCATE);
2154     TempLen += 6;
2155     }
2156     else {
2157     TempStr[TempLen++] = d;
2158     }
2159     break;
2160    
2161     default:
2162 doda 3452 if ((cv->Language==IdRussian) && (d>=128)) {
2163 maya 3227 d = RussConv(cv->RussClient,cv->RussHost,d);
2164 maya 3392 }
2165 doda 3452 TempStr[TempLen++] = d;
2166 maya 3227 if (cv->TelFlag && (d==0xff)) {
2167 doda 3452 TempStr[TempLen++] = (char)0xff;
2168 maya 3227 }
2169     }
2170    
2171     Full = InBuffSize-cv->InBuffCount-TempLen < 0;
2172     if (! Full) {
2173     i++;
2174     memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
2175     cv->InBuffCount = cv->InBuffCount + TempLen;
2176     }
2177     } // end of while {}
2178    
2179     return i;
2180     }
2181    
2182 doda 6435 // listup serial port driver
2183 maya 3227 // cf. http://www.codeproject.com/system/setupdi.asp?df=100&forumid=4368&exp=0&select=479661
2184     // (2007.8.17 yutaka)
2185     static void ListupSerialPort(LPWORD ComPortTable, int comports, char **ComPortDesc, int ComPortMax)
2186     {
2187     GUID ClassGuid[1];
2188     DWORD dwRequiredSize;
2189     BOOL bRet;
2190     HDEVINFO DeviceInfoSet = NULL;
2191     SP_DEVINFO_DATA DeviceInfoData;
2192     DWORD dwMemberIndex = 0;
2193     int i;
2194    
2195     DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
2196    
2197     // ���O�����������t���[��������
2198     for (i = 0 ; i < ComPortMax ; i++) {
2199     free(ComPortDesc[i]);
2200     ComPortDesc[i] = NULL;
2201     }
2202    
2203     // Get ClassGuid from ClassName for PORTS class
2204     bRet =
2205     SetupDiClassGuidsFromName(_T("PORTS"), (LPGUID) & ClassGuid, 1,
2206     &dwRequiredSize);
2207 maya 3392 if (!bRet) {
2208 maya 3227 goto cleanup;
2209 maya 3392 }
2210 maya 3227
2211     // Get class devices
2212     // COM�|�[�g�����������t�����������������A�������������������A���W�X�g�����c��������
2213     // ����FriendlyName���\���������������������������B(2007.11.8 yutaka)
2214     DeviceInfoSet =
2215     SetupDiGetClassDevs(&ClassGuid[0], NULL, NULL, DIGCF_PRESENT | DIGCF_PROFILE);
2216    
2217     if (DeviceInfoSet) {
2218     // Enumerate devices
2219     dwMemberIndex = 0;
2220     while (SetupDiEnumDeviceInfo
2221 maya 3392 (DeviceInfoSet, dwMemberIndex++, &DeviceInfoData)) {
2222 maya 3227 TCHAR szFriendlyName[MAX_PATH];
2223     TCHAR szPortName[MAX_PATH];
2224     //TCHAR szMessage[MAX_PATH];
2225     DWORD dwReqSize = 0;
2226     DWORD dwPropType;
2227     DWORD dwType = REG_SZ;
2228     HKEY hKey = NULL;
2229    
2230     // Get friendlyname
2231     bRet = SetupDiGetDeviceRegistryProperty(DeviceInfoSet,
2232     &DeviceInfoData,
2233     SPDRP_FRIENDLYNAME,
2234     &dwPropType,
2235     (LPBYTE)
2236     szFriendlyName,
2237     sizeof(szFriendlyName),
2238     &dwReqSize);
2239    
2240     // Open device parameters reg key
2241     hKey = SetupDiOpenDevRegKey(DeviceInfoSet,
2242     &DeviceInfoData,
2243     DICS_FLAG_GLOBAL,
2244     0, DIREG_DEV, KEY_READ);
2245     if (hKey) {
2246     // Qurey for portname
2247     long lRet;
2248     dwReqSize = sizeof(szPortName);
2249     lRet = RegQueryValueEx(hKey,
2250     _T("PortName"),
2251     0,
2252     &dwType,
2253     (LPBYTE) & szPortName,
2254     &dwReqSize);
2255    
2256     // Close reg key
2257     RegCloseKey(hKey);
2258     }
2259    
2260     #if 0
2261     sprintf(szMessage, _T("Name: %s\nPort: %s\n"), szFriendlyName,
2262     szPortName);
2263     printf("%s\n", szMessage);
2264     #endif
2265    
2266     if (_strnicmp(szPortName, "COM", 3) == 0) { // COM�|�[�g�h���C�o������
2267     int port = atoi(&szPortName[3]);
2268     int i;
2269    
2270     for (i = 0 ; i < comports ; i++) {
2271     if (ComPortTable[i] == port) { // �������m�F
2272     ComPortDesc[i] = _strdup(szFriendlyName);
2273     break;
2274     }
2275     }
2276     }
2277    
2278     }
2279     }
2280    
2281 maya 3392 cleanup:
2282 maya 3227 // Destroy device info list
2283     SetupDiDestroyDeviceInfoList(DeviceInfoSet);
2284     }
2285    
2286    
2287     int PASCAL DetectComPorts(LPWORD ComPortTable, int ComPortMax, char **ComPortDesc)
2288     {
2289     HMODULE h;
2290     TCHAR devicesBuff[65535];