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 8828 - (hide annotations) (download) (as text)
Fri Jul 3 14:43:44 2020 UTC (3 years, 9 months ago) by zmatsuo
File MIME type: text/x-csrc
File size: 68645 byte(s) 
struct TMap を tttypes.h から ttcmn.c へ移動

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