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 8897 - (hide annotations) (download) (as text)
Tue Aug 18 15:27:54 2020 UTC (3 years, 7 months ago) by zmatsuo
File MIME type: text/x-csrc
File size: 68012 byte(s) 
ログに関するコードを filesys_log.c に移動した

- ログ用構造体(TFileVar_#filesys_log.c)から不要メンバ削除
- OnCommOpen()#vtwin.cpp で log,dde(macro)用バッファを作成していたが、作成済みのため削除
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 8897 static void LogBinSkip(PComVar cv, int add)
1350     {
1351     if (cv->LogBinSkip != NULL) {
1352     cv->LogBinSkip(add);
1353     }
1354     }
1355    
1356 zmatsuo 7305 void WINAPI CommInsert1Byte(PComVar cv, BYTE b)
1357 maya 3227 {
1358 maya 3392 if ( ! cv->Ready ) {
1359 maya 3227 return;
1360 maya 3392 }
1361 maya 3227
1362 maya 3392 if (cv->InPtr == 0) {
1363 maya 3227 memmove(&(cv->InBuff[1]),&(cv->InBuff[0]),cv->InBuffCount);
1364 maya 3392 }
1365     else {
1366 maya 3227 cv->InPtr--;
1367 maya 3392 }
1368 maya 3227 cv->InBuff[cv->InPtr] = b;
1369     cv->InBuffCount++;
1370    
1371 zmatsuo 8897 LogBinSkip(cv, 1);
1372 maya 3227 }
1373    
1374 zmatsuo 8897 static void Log1Bin(PComVar cv, BYTE b)
1375 maya 3227 {
1376 zmatsuo 8897 if (cv->Log1Bin != NULL) {
1377     cv->Log1Bin(b);
1378 maya 3392 }
1379 maya 3227 }
1380    
1381 zmatsuo 7305 int WINAPI CommRead1Byte(PComVar cv, LPBYTE b)
1382 maya 3227 {
1383     int c;
1384    
1385 maya 3392 if ( ! cv->Ready ) {
1386 maya 3227 return 0;
1387 maya 3392 }
1388 maya 3227
1389 maya 3392 if ( cv->TelMode ) {
1390 maya 3227 c = 0;
1391 maya 3392 }
1392     else {
1393 maya 3227 c = CommReadRawByte(cv,b);
1394 maya 3392 }
1395 maya 3227
1396     if ((c==1) && cv->TelCRFlag) {
1397     cv->TelCRFlag = FALSE;
1398 maya 3392 if (*b==0) {
1399     c = 0;
1400     }
1401 maya 3227 }
1402    
1403     if ( c==1 ) {
1404     if ( cv->IACFlag ) {
1405     cv->IACFlag = FALSE;
1406     if ( *b != 0xFF ) {
1407     cv->TelMode = TRUE;
1408     CommInsert1Byte(cv,*b);
1409 zmatsuo 8897 LogBinSkip(cv, -1);
1410 maya 3227 c = 0;
1411     }
1412     }
1413     else if ((cv->PortType==IdTCPIP) && (*b==0xFF)) {
1414 maya 3392 if (!cv->TelFlag && cv->TelAutoDetect) { /* TTPLUG */
1415 maya 3227 cv->TelFlag = TRUE;
1416 maya 3392 }
1417 maya 3227 if (cv->TelFlag) {
1418     cv->IACFlag = TRUE;
1419     c = 0;
1420     }
1421     }
1422 maya 3392 else if (cv->TelFlag && ! cv->TelBinRecv && (*b==0x0D)) {
1423 maya 3227 cv->TelCRFlag = TRUE;
1424 maya 3392 }
1425 maya 3227 }
1426    
1427 zmatsuo 8897 if (c == 1) {
1428 maya 3227 Log1Bin(cv, *b);
1429 maya 3392 }
1430 maya 3227
1431     return c;
1432     }
1433    
1434 doda 8445 int WINAPI CommRawOut(PComVar cv, /*const*/ PCHAR B, int C)
1435 maya 3227 {
1436     int a;
1437    
1438 maya 3392 if ( ! cv->Ready ) {
1439 maya 3227 return C;
1440 maya 3392 }
1441 maya 3227
1442 maya 3392 if (C > OutBuffSize - cv->OutBuffCount) {
1443 maya 3227 a = OutBuffSize - cv->OutBuffCount;
1444 maya 3392 }
1445     else {
1446 maya 3227 a = C;
1447 maya 3392 }
1448 maya 3227 if ( cv->OutPtr > 0 ) {
1449     memmove(&(cv->OutBuff[0]),&(cv->OutBuff[cv->OutPtr]),cv->OutBuffCount);
1450     cv->OutPtr = 0;
1451     }
1452     memcpy(&(cv->OutBuff[cv->OutBuffCount]),B,a);
1453     cv->OutBuffCount = cv->OutBuffCount + a;
1454     return a;
1455     }
1456    
1457 zmatsuo 7305 int WINAPI CommBinaryOut(PComVar cv, PCHAR B, int C)
1458 maya 3227 {
1459     int a, i, Len;
1460     char d[3];
1461    
1462 maya 3392 if ( ! cv->Ready ) {
1463 maya 3227 return C;
1464 maya 3392 }
1465 maya 3227
1466     i = 0;
1467     a = 1;
1468     while ((a>0) && (i<C)) {
1469     Len = 0;
1470    
1471     d[Len] = B[i];
1472     Len++;
1473    
1474 doda 3505 if ( cv->TelFlag && (B[i]=='\x0d') && ! cv->TelBinSend ) {
1475     d[Len++] = '\x00';
1476 maya 3227 }
1477 doda 3505 else if ( cv->TelFlag && (B[i]=='\xff') ) {
1478     d[Len++] = '\xff';
1479     }
1480 maya 3227
1481 doda 3505 if ( OutBuffSize - cv->OutBuffCount - Len >= 0 ) {
1482     CommRawOut(cv, d, Len);
1483 maya 3227 a = 1;
1484     }
1485 maya 3392 else {
1486 maya 3227 a = 0;
1487 maya 3392 }
1488 maya 3227
1489 doda 3505 i += a;
1490 maya 3227 }
1491     return i;
1492     }
1493    
1494 doda 8445 /**
1495     * �f�[�^(������)���o���o�b�t�@����������
1496     *
1497     * �w���f�[�^��������������������������������������
1498     * CommRawOut() ��������������������������
1499     *
1500     * @retval TRUE �o��������
1501     * @retval FALSE �o��������������(buffer full)
1502     */
1503     static BOOL WriteOutBuff(PComVar cv, const char *TempStr, int TempLen)
1504     {
1505     BOOL output;
1506    
1507     if (TempLen == 0) {
1508     // ����0������������������������
1509     return TRUE;
1510     }
1511    
1512     output = FALSE;
1513     if (cv->TelLineMode) {
1514     const BOOL Full = OutBuffSize - cv->LineModeBuffCount - TempLen < 0;
1515     if (!Full) {
1516     output = TRUE;
1517     memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), TempStr, TempLen);
1518     cv->LineModeBuffCount += TempLen;
1519     if (cv->Flush) {
1520     cv->FlushLen = cv->LineModeBuffCount;
1521     }
1522     }
1523     if (cv->FlushLen > 0) {
1524     const int OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
1525     cv->FlushLen -= OutLen;
1526     cv->LineModeBuffCount -= OutLen;
1527     memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
1528     }
1529     cv->Flush = FALSE;
1530     }
1531     else {
1532     const BOOL Full = OutBuffSize-cv->OutBuffCount-TempLen < 0;
1533     if (! Full) {
1534     output = TRUE;
1535     CommRawOut(cv, (char *)TempStr, TempLen);
1536     }
1537     }
1538     return output;
1539     }
1540    
1541     /**
1542     * �f�[�^(������)�������o�b�t�@����������
1543     * �����o�b�t�@�������� -> �G�R�[������
1544     *
1545     * @retval TRUE �o��������
1546     * @retval FALSE �o��������������(buffer full)
1547     */
1548     static BOOL WriteInBuff(PComVar cv, const char *TempStr, int TempLen)
1549     {
1550     BOOL Full;
1551    
1552     if (TempLen == 0) {
1553     return TRUE;
1554     }
1555    
1556     Full = InBuffSize-cv->InBuffCount-TempLen < 0;
1557     if (! Full) {
1558     memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
1559     cv->InBuffCount = cv->InBuffCount + TempLen;
1560     return TRUE;
1561     }
1562     return FALSE;
1563     }
1564    
1565     /**
1566     * �����o�b�t�@�����������������������l����
1567     */
1568     static void PackInBuff(PComVar cv)
1569     {
1570     if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
1571     memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
1572     cv->InPtr = 0;
1573     }
1574     }
1575    
1576 zmatsuo 7305 int WINAPI CommBinaryBuffOut(PComVar cv, PCHAR B, int C)
1577 doda 3505 {
1578 doda 8445 int a, i, Len;
1579 doda 3505 char d[3];
1580    
1581     if ( ! cv->Ready ) {
1582     return C;
1583     }
1584    
1585     i = 0;
1586     a = 1;
1587     while ((a>0) && (i<C)) {
1588     Len = 0;
1589    
1590     d[Len] = B[i];
1591     Len++;
1592    
1593     if (B[i] == CR) {
1594     if ( cv->TelFlag && ! cv->TelBinSend ) {
1595     d[Len++] = '\x00';
1596     }
1597     if (cv->TelLineMode) {
1598     cv->Flush = TRUE;
1599     }
1600     }
1601     else if ( cv->TelFlag && (B[i]=='\xff') ) {
1602     d[Len++] = '\xff';
1603     }
1604    
1605 doda 8445 if (WriteOutBuff(cv, d, Len)) {
1606     a = 1;
1607     i++;
1608     } else {
1609     a = 0;
1610 doda 3505 }
1611     }
1612     return i;
1613     }
1614    
1615 zmatsuo 7462 // �����R�[�h(CodePage)��UTF-8���o������
1616 doda 3442 static int OutputTextUTF8(WORD K, char *TempStr, PComVar cv)
1617 maya 3227 {
1618 zmatsuo 7462 int CodePage = *cv->CodePage;
1619 maya 3227 unsigned int code;
1620 doda 3442 int outlen;
1621 maya 3227
1622 zmatsuo 7466 code = MBCP_UTF32(K, CodePage);
1623 zmatsuo 7464 if (code == 0) {
1624     // �������s
1625     code = 0xfffd; // U+FFFD: Replacement Character
1626     }
1627 zmatsuo 7462 outlen = UTF32ToUTF8(code, TempStr, 4);
1628     return outlen;
1629 maya 3227 }
1630    
1631 doda 6435 //
1632 doda 3451 // MBCS�����e�������R�[�h�����������o�������B
1633 maya 3227 //
1634 zmatsuo 7411 static int TextOutMBCS(PComVar cv, PCHAR B, int C)
1635 maya 3227 {
1636 doda 8445 int i, TempLen;
1637 maya 3227 WORD K;
1638 doda 3442 char TempStr[12];
1639 maya 3227 BYTE d;
1640 doda 8445 BOOL Full;
1641     int SendCodeNew; // ���M�R�[�h
1642     BOOL KanjiFlagNew; // TRUE=����������������������������
1643 maya 3227
1644     Full = FALSE;
1645     i = 0;
1646     while (! Full && (i < C)) {
1647     TempLen = 0;
1648     d = (BYTE)B[i];
1649     SendCodeNew = cv->SendCode;
1650 doda 3442 KanjiFlagNew = FALSE;
1651 maya 3227
1652     if (cv->SendKanjiFlag) {
1653     SendCodeNew = IdKanji;
1654    
1655     K = (cv->SendKanjiFirst << 8) + d;
1656    
1657     // UTF-8�����������s���B1�`3�o�C�g���������������������B
1658 doda 3408 if (cv->KanjiCodeSend == IdUTF8 || cv->Language == IdUtf8) {
1659 doda 3442 TempLen += OutputTextUTF8(K, TempStr, cv);
1660     }
1661     else {
1662     switch (cv->Language) {
1663     case IdJapanese:
1664 doda 6435 switch (cv->KanjiCodeSend) {
1665 doda 3442 case IdEUC:
1666 doda 3419 K = SJIS2EUC(K);
1667 doda 3442 break;
1668     case IdJIS:
1669 doda 3419 K = SJIS2JIS(K);
1670 doda 3442 if ((cv->SendCode==IdKatakana) &&
1671     (cv->JIS7KatakanaSend==1)) {
1672     TempStr[TempLen++] = SI;
1673     }
1674     break;
1675     case IdSJIS:
1676     /* nothing to do */
1677     break;
1678 doda 3419 }
1679 doda 3442 break;
1680     case IdKorean:
1681 doda 6435 break;
1682 maya 3227 }
1683 doda 3442 TempStr[TempLen++] = HIBYTE(K);
1684     TempStr[TempLen++] = LOBYTE(K);
1685 maya 3227 }
1686     }
1687 doda 3932 else if (_isleadbyte_l(d, cv->locale)) {
1688 maya 3227 KanjiFlagNew = TRUE;
1689     cv->SendKanjiFirst = d;
1690     SendCodeNew = IdKanji;
1691    
1692 doda 3442 if (cv->Language == IdJapanese) {
1693     if ((cv->SendCode!=IdKanji) && (cv->KanjiCodeSend==IdJIS)) {
1694     TempStr[0] = 0x1B;
1695     TempStr[1] = '$';
1696     if (cv->KanjiIn == IdKanjiInB) {
1697     TempStr[2] = 'B';
1698     }
1699     else {
1700     TempStr[2] = '@';
1701     }
1702     TempLen = 3;
1703 maya 3392 }
1704 maya 3227 }
1705     }
1706     else {
1707 doda 3442 if (cv->Language == IdJapanese) {
1708     if ((cv->SendCode==IdKanji) && (cv->KanjiCodeSend==IdJIS)) {
1709     TempStr[0] = 0x1B;
1710     TempStr[1] = '(';
1711     switch (cv->KanjiOut) {
1712     case IdKanjiOutJ:
1713 maya 3409 TempStr[2] = 'J';
1714     break;
1715 doda 3442 case IdKanjiOutH:
1716 maya 3409 TempStr[2] = 'H';
1717     break;
1718 doda 3442 default:
1719 maya 3409 TempStr[2] = 'B';
1720 doda 3442 }
1721     TempLen = 3;
1722 maya 3227 }
1723    
1724 doda 3442 if ((0xa0<d) && (d<0xe0)) {
1725     SendCodeNew = IdKatakana;
1726     if ((cv->SendCode!=IdKatakana) &&
1727     (cv->KanjiCodeSend==IdJIS) &&
1728     (cv->JIS7KatakanaSend==1)) {
1729     TempStr[TempLen++] = SO;
1730     }
1731 maya 3227 }
1732 doda 3442 else {
1733     SendCodeNew = IdASCII;
1734     if ((cv->SendCode==IdKatakana) &&
1735     (cv->KanjiCodeSend==IdJIS) &&
1736     (cv->JIS7KatakanaSend==1)) {
1737     TempStr[TempLen++] = SI;
1738     }
1739 maya 3227 }
1740     }
1741    
1742 doda 3497 if (d==CR) {
1743 doda 3442 TempStr[TempLen++] = 0x0d;
1744 maya 3227 if (cv->CRSend==IdCRLF) {
1745 doda 3442 TempStr[TempLen++] = 0x0a;
1746 maya 3227 }
1747     else if ((cv->CRSend==IdCR) &&
1748 doda 3398 cv->TelFlag && ! cv->TelBinSend) {
1749 doda 3442 TempStr[TempLen++] = 0;
1750 maya 3227 }
1751 maya 6369 else if (cv->CRSend == IdLF) {
1752     TempStr[TempLen-1] = 0x0a;
1753     }
1754 doda 3494 if (cv->TelLineMode) {
1755     cv->Flush = TRUE;
1756     }
1757 maya 3227 }
1758 doda 3497 else if (d==BS) {
1759     if (cv->TelLineMode) {
1760     if (cv->FlushLen < cv->LineModeBuffCount) {
1761     cv->LineModeBuffCount--;
1762     }
1763     }
1764 maya 6369 else {
1765 doda 3497 TempStr[TempLen++] = d;
1766     }
1767     }
1768 doda 3498 else if (d==0x15) { // Ctrl-U
1769     if (cv->TelLineMode) {
1770     cv->LineModeBuffCount = cv->FlushLen;
1771     }
1772 maya 6369 else {
1773 doda 3498 TempStr[TempLen++] = d;
1774     }
1775     }
1776 doda 3442 else if ((d>=0x80) && (cv->KanjiCodeSend==IdUTF8 || cv->Language==IdUtf8)) {
1777     TempLen += OutputTextUTF8((WORD)d, TempStr, cv);
1778     }
1779     else if ((d>=0xa1) && (d<=0xe0) && (cv->Language == IdJapanese)) {
1780 doda 3452 /* Katakana */
1781 maya 3227 if (cv->KanjiCodeSend==IdEUC) {
1782 doda 3444 TempStr[TempLen++] = (char)SS2;
1783 maya 3227 }
1784     if ((cv->KanjiCodeSend==IdJIS) &&
1785 maya 3392 (cv->JIS7KatakanaSend==1)) {
1786 doda 3442 TempStr[TempLen++] = d & 0x7f;
1787 maya 3392 }
1788     else {
1789 doda 3442 TempStr[TempLen++] = d;
1790 maya 3392 }
1791 maya 3227 }
1792     else {
1793 doda 3442 TempStr[TempLen++] = d;
1794 maya 3227 if (cv->TelFlag && (d==0xff)) {
1795 doda 3442 TempStr[TempLen++] = (char)0xff;
1796 maya 3227 }
1797     }
1798     } // if (cv->SendKanjiFlag) else if ... else ... end
1799    
1800 doda 8445 if (WriteOutBuff(cv, TempStr, TempLen)) {
1801     i++; // 1������������
1802     // ��������������������
1803     cv->SendCode = SendCodeNew;
1804     cv->SendKanjiFlag = KanjiFlagNew;
1805     } else {
1806     Full = TRUE;
1807 maya 3227 }
1808    
1809     } // end of "while {}"
1810    
1811     return i;
1812     }
1813    
1814 zmatsuo 7305 int WINAPI CommTextOut(PComVar cv, PCHAR B, int C)
1815 maya 3227 {
1816 doda 8445 int i, TempLen;
1817 doda 3442 char TempStr[12];
1818 maya 3227 BYTE d;
1819     BOOL Full;
1820    
1821 maya 3392 if (! cv->Ready ) {
1822 maya 3227 return C;
1823 maya 3392 }
1824 maya 3227
1825 maya 4009 switch (cv->Language) {
1826     case IdUtf8:
1827     case IdJapanese:
1828     case IdKorean:
1829     return TextOutMBCS(cv, B, C);
1830     break;
1831 maya 3392 }
1832 maya 3227
1833     Full = FALSE;
1834     i = 0;
1835     while (! Full && (i < C)) {
1836     TempLen = 0;
1837     d = (BYTE)B[i];
1838 doda 6435
1839 doda 3497 switch (d) {
1840     case CR:
1841 maya 3227 TempStr[TempLen] = 0x0d;
1842     TempLen++;
1843     if (cv->CRSend==IdCRLF) {
1844 doda 3452 TempStr[TempLen++] = 0x0a;
1845 maya 3227 }
1846 doda 3452 else if (cv->CRSend==IdCR && cv->TelFlag && ! cv->TelBinSend) {
1847     TempStr[TempLen++] = 0;
1848 maya 3227 }
1849 maya 6369 else if (cv->CRSend == IdLF) {
1850     TempStr[TempLen-1] = 0x0a;
1851     }
1852 doda 3494 if (cv->TelLineMode) {
1853     cv->Flush = TRUE;
1854     }
1855 doda 3497 break;
1856    
1857     case BS:
1858     if (cv->TelLineMode) {
1859     if (cv->FlushLen < cv->LineModeBuffCount) {
1860     cv->LineModeBuffCount--;
1861     }
1862     }
1863 doda 6435 else {
1864 doda 3497 TempStr[TempLen++] = d;
1865     }
1866     break;
1867    
1868 doda 3498 case 0x15: // Ctrl-U
1869     if (cv->TelLineMode) {
1870     cv->LineModeBuffCount = cv->FlushLen;
1871     }
1872     else {
1873     TempStr[TempLen++] = d;
1874     }
1875 doda 3504 break;
1876 doda 3498
1877 doda 3497 default:
1878 doda 3452 if ((cv->Language==IdRussian) && (d>=128)) {
1879 doda 3494 d = RussConv(cv->RussClient, cv->RussHost, d);
1880 doda 3452 }
1881     TempStr[TempLen++] = d;
1882 maya 3227 if (cv->TelFlag && (d==0xff)) {
1883 doda 3452 TempStr[TempLen++] = (char)0xff;
1884 maya 3227 }
1885     }
1886    
1887 doda 8445 if (WriteOutBuff(cv, TempStr, TempLen)) {
1888     i++; // 1������������
1889     } else {
1890     Full = TRUE;
1891     }
1892    
1893     } // end of while {}
1894    
1895     return i;
1896     }
1897    
1898     /**
1899     * @retval true ���{�������p�J�^�J�i
1900     * @retval false ������
1901     */
1902     static BOOL IsHalfWidthKatakana(unsigned int u32)
1903     {
1904     // Halfwidth CJK punctuation (U+FF61�`FF64)
1905     // Halfwidth Katakana variants (U+FF65�`FF9F)
1906     return (0xff61 <= u32 && u32 <= 0xff9f);
1907     }
1908    
1909     /**
1910     * �o���p�A TODO echo�p������
1911     * @param cv
1912     * @param u32 ��������
1913     * @param check_only TRUE���������s�����A
1914     * @param TempStr �o��������
1915     * @param StrLen TempStr�����o��������
1916     * @retval �������s����
1917     */
1918     static BOOL OutControl(PComVar cv, unsigned int u32, BOOL check_only, char *TempStr, size_t *StrLen)
1919     {
1920     const wchar_t d = u32;
1921     size_t TempLen = 0;
1922     BOOL retval = FALSE;
1923     if (check_only == TRUE) {
1924     /* �`�F�b�N���� */
1925     if (d == CR || d == BS || d == 0x15/*ctrl-u*/) {
1926     return TRUE;
1927     } else {
1928     return FALSE;
1929     }
1930     }
1931     if (d==CR) {
1932     TempStr[TempLen++] = 0x0d;
1933     if (cv->CRSend==IdCRLF) {
1934     TempStr[TempLen++] = 0x0a;
1935     }
1936     else if ((cv->CRSend ==IdCR) &&
1937     cv->TelFlag && ! cv->TelBinSend) {
1938     TempStr[TempLen++] = 0;
1939     }
1940     else if (cv->CRSend == IdLF) {
1941     TempStr[TempLen-1] = 0x0a;
1942     }
1943 doda 3494 if (cv->TelLineMode) {
1944 doda 8445 cv->Flush = TRUE;
1945     }
1946     retval = TRUE;
1947     }
1948     else if (d== BS) {
1949     if (cv->TelLineMode) {
1950     if (cv->FlushLen < cv->LineModeBuffCount) {
1951     cv->LineModeBuffCount--;
1952     }
1953     }
1954     else {
1955     TempStr[TempLen++] = BS;
1956     }
1957     retval = TRUE;
1958     }
1959     else if (d==0x15) { // ctrl-u
1960     if (cv->TelLineMode) {
1961     cv->LineModeBuffCount = cv->FlushLen;
1962     }
1963     else {
1964     TempStr[TempLen++] = 0x15;
1965     }
1966     retval = TRUE;
1967     }
1968     *StrLen = TempLen;
1969     return retval;
1970     }
1971     static BOOL ControlEcho(PComVar cv, unsigned int u32, BOOL check_only, char *TempStr, size_t *StrLen)
1972     {
1973     const wchar_t d = u32;
1974     size_t TempLen = 0;
1975     BOOL retval = FALSE;
1976     if (check_only == TRUE) {
1977     /* �`�F�b�N���� */
1978     if (d == CR || (d == 0x15/*ctrl-u*/ && cv->TelLineMode)) {
1979     return TRUE;
1980     } else {
1981     return FALSE;
1982     }
1983     }
1984     if (d==CR) {
1985     TempStr[TempLen++] = 0x0d;
1986     if (cv->CRSend==IdCRLF) {
1987     TempStr[TempLen++] = 0x0a;
1988     }
1989     else if ((cv->CRSend ==IdCR) && cv->TelFlag && ! cv->TelBinSend) {
1990     TempStr[TempLen++] = 0;
1991     }
1992     else if (cv->CRSend == IdLF) {
1993     TempStr[TempLen-1] = 0x0a;
1994     }
1995     retval = TRUE;
1996     }
1997     else if (d==0x15/*ctrl-u*/ && cv->TelLineMode) {
1998     // Move to top of line (CHA "\033[G") and erase line (EL "\033[K")
1999     memcpy(TempStr, "\033[G\033[K", 6);
2000     TempLen += 6;
2001     retval = TRUE;
2002     }
2003     *StrLen = TempLen;
2004     return retval;
2005     }
2006    
2007     /**
2008     * �o���p����������������
2009     *
2010     * @retval ��������������
2011     */
2012     typedef struct {
2013     int KanjiCode; // [in]�o�������R�[�h(sjis,jis����)
2014     BOOL (*ControlOut)(PComVar cv, unsigned int u32, BOOL check_only, char *TempStr, size_t *StrLen);
2015     // state�����������K�v�����������R�[�h���g�p
2016     BOOL JIS7Katakana; // [in](Kanji JIS)kana
2017     int SendCode; // [in,out](Kanji JIS)���O�����M�R�[�h Ascii/Kana/Kanji
2018     BOOL KanjiFlag; // [in,out](MBCS)���O��1byte��������������?(2byte������������?)
2019     BYTE KanjiFirst; // [in,out](MBCS)���O��1byte
2020     } OutputCharState;
2021    
2022     /**
2023     * unicode(UTF-16)����unicode(UTF-32)��1���������o����
2024     * �o���f�[�^(TempStr)����������
2025     */
2026     static size_t MakeOutputString(PComVar cv, OutputCharState *states,
2027     const wchar_t *B, int C,
2028     char *TempStr, int *TempLen_)
2029     {
2030     BOOL (*ControlOut)(PComVar cv, unsigned int u32, BOOL check_only, char *TempStr, size_t *StrLen)
2031     = states->ControlOut;
2032     //
2033     int TempLen = 0;
2034     size_t TempLen2;
2035     size_t output_char_count; // ��������������
2036    
2037     // UTF-32 ��1���������o��
2038     unsigned int u32;
2039     size_t u16_len = UTF16ToUTF32(B, C, &u32);
2040     if (u16_len == 0) {
2041     // �f�R�[�h��������? ����������������?
2042     assert(FALSE);
2043     u32 = '?';
2044     u16_len = 1;
2045     }
2046     output_char_count = u16_len;
2047    
2048     // �e���V�t�g����������������
2049     if (u32 < 0x100 || ControlOut(cv, u32, TRUE, NULL, NULL)) {
2050     if (cv->Language == IdJapanese && states->KanjiCode == IdJIS) {
2051     // �����������A���{��,JIS��������
2052     if (cv->SendCode == IdKanji) {
2053     // �����������������A����OUT
2054     TempStr[TempLen++] = 0x1B;
2055     TempStr[TempLen++] = '(';
2056     switch (cv->KanjiOut) {
2057     case IdKanjiOutJ:
2058     TempStr[TempLen++] = 'J';
2059     break;
2060     case IdKanjiOutH:
2061     TempStr[TempLen++] = 'H';
2062     break;
2063     default:
2064     TempStr[TempLen++] = 'B';
2065 doda 3494 }
2066     }
2067 doda 8445
2068     if (states->JIS7Katakana == 1) {
2069     if (cv->SendCode == IdKatakana) {
2070     TempStr[TempLen++] = SO;
2071     }
2072 doda 3494 }
2073 doda 8445
2074     states->SendCode = IdASCII;
2075 maya 3227 }
2076 doda 8445 }
2077    
2078     // 1������������
2079     if (ControlOut(cv, u32, FALSE, TempStr, &TempLen2)) {
2080     // ��������������������
2081     TempLen += TempLen2;
2082     output_char_count = 1;
2083     } else if (cv->Language == IdUtf8 ||
2084     (cv->Language == IdJapanese && states->KanjiCode == IdUTF8) ||
2085     (cv->Language == IdKorean && states->KanjiCode == IdUTF8))
2086     {
2087     // UTF-8 ���o��
2088     size_t utf8_len = sizeof(TempStr);
2089     utf8_len = UTF32ToUTF8(u32, TempStr, utf8_len);
2090     TempLen += utf8_len;
2091     } else if (cv->Language == IdJapanese && *cv->CodePage == 932) {
2092     // ���{��
2093     // ���� CP932(SJIS) ���������������o��
2094     char mb_char[2];
2095     size_t mb_len = sizeof(mb_char);
2096     mb_len = UTF32ToMBCP(u32, 932, mb_char, mb_len);
2097     if (mb_len == 0) {
2098     // SJIS��������������
2099     TempStr[TempLen++] = '?';
2100     } else {
2101     switch (states->KanjiCode) {
2102     case IdEUC:
2103     // TODO ���p�J�i
2104     if (mb_len == 1) {
2105     TempStr[TempLen++] = mb_char[0];
2106     } else {
2107     WORD K;
2108     K = (((WORD)(unsigned char)mb_char[0]) << 8) +
2109     (WORD)(unsigned char)mb_char[1];
2110     K = SJIS2EUC(K);
2111     TempStr[TempLen++] = HIBYTE(K);
2112     TempStr[TempLen++] = LOBYTE(K);
2113     }
2114     break;
2115     case IdJIS:
2116     if (u32 < 0x100) {
2117     // ASCII
2118     TempStr[TempLen++] = mb_char[0];
2119     states->SendCode = IdASCII;
2120     } else if (IsHalfWidthKatakana(u32)) {
2121     // ���p�J�^�J�i
2122     if (states->JIS7Katakana==1) {
2123     if (cv->SendCode != IdKatakana) {
2124     TempStr[TempLen++] = SI;
2125     }
2126     TempStr[TempLen++] = mb_char[0] & 0x7f;
2127     } else {
2128     TempStr[TempLen++] = mb_char[0];
2129     }
2130     states->SendCode = IdKatakana;
2131     } else {
2132     // ����
2133     WORD K;
2134     K = (((WORD)(unsigned char)mb_char[0]) << 8) +
2135     (WORD)(unsigned char)mb_char[1];
2136     K = SJIS2JIS(K);
2137     if (states->SendCode != IdKanji) {
2138     // ����IN
2139     TempStr[TempLen++] = 0x1B;
2140     TempStr[TempLen++] = '$';
2141     if (cv->KanjiIn == IdKanjiInB) {
2142     TempStr[TempLen++] = 'B';
2143     }
2144     else {
2145     TempStr[TempLen++] = '@';
2146     }
2147     states->SendCode = IdKanji;
2148     }
2149     TempStr[TempLen++] = HIBYTE(K);
2150     TempStr[TempLen++] = LOBYTE(K);
2151     }
2152     break;
2153     case IdSJIS:
2154     if (mb_len == 1) {
2155     TempStr[TempLen++] = mb_char[0];
2156     } else {
2157     TempStr[TempLen++] = mb_char[0];
2158     TempStr[TempLen++] = mb_char[1];
2159     }
2160     break;
2161     default:
2162     assert(FALSE);
2163     break;
2164 doda 3494 }
2165     }
2166 doda 8445 } else if (cv->Language == IdRussian) {
2167     /* ����CP1251�����������o�� */
2168     char mb_char[2];
2169     size_t mb_len = sizeof(mb_char);
2170     BYTE b;
2171     mb_len = UTF32ToMBCP(u32, 1251, mb_char, mb_len);
2172     if (mb_len != 1) {
2173     b = '?';
2174     } else {
2175     b = RussConv(IdWindows, cv->RussHost, mb_char[0]);
2176     }
2177     TempStr[TempLen++] = b;
2178     } else if (cv->Language == IdKorean && *cv->CodePage == 51949) {
2179     /* CP51949�����������o�� */
2180     char mb_char[2];
2181     size_t mb_len = sizeof(mb_char);
2182     mb_len = UTF32ToMBCP(u32, 51949, mb_char, mb_len);
2183     if (mb_len == 0) {
2184     TempStr[TempLen++] = '?';
2185     }
2186     else if (mb_len == 1) {
2187     TempStr[TempLen++] = mb_char[0];
2188     } else {
2189     TempStr[TempLen++] = mb_char[0];
2190     TempStr[TempLen++] = mb_char[1];
2191     }
2192     } else if (cv->Language == IdEnglish) {
2193     TempStr[TempLen++] = u32;
2194     } else {
2195     // CodePage������
2196     char mb_char[2];
2197     size_t mb_len = sizeof(mb_char);
2198     mb_len = UTF32ToMBCP(u32, *cv->CodePage, mb_char, mb_len);
2199     if (mb_len == 0) {
2200     TempStr[TempLen++] = '?';
2201     }
2202     else if (mb_len == 1) {
2203     TempStr[TempLen++] = mb_char[0];
2204     } else {
2205     TempStr[TempLen++] = mb_char[0];
2206     TempStr[TempLen++] = mb_char[1];
2207     }
2208     }
2209 maya 3227
2210 doda 8445 *TempLen_ = TempLen;
2211     return output_char_count;
2212 maya 3227 }
2213    
2214 doda 8445
2215     /**
2216     * CommTextOut() �� wchar_t ��
2217     *
2218     * @retval �o��������(wchar_t�P��)
2219     */
2220 zmatsuo 7484 int WINAPI CommTextOutW(PComVar cv, const wchar_t *B, int C)
2221     {
2222 doda 8445 char TempStr[12];
2223     BOOL Full = FALSE;
2224     int i = 0;
2225     while (! Full && (i < C)) {
2226     // �o���p�f�[�^������
2227     int TempLen = 0;
2228     size_t output_char_count; // ��������������
2229     OutputCharState state;
2230     state.KanjiCode = cv->KanjiCodeSend;
2231     state.ControlOut = OutControl;
2232     state.SendCode = cv->SendCode;
2233     state.JIS7Katakana = cv->JIS7KatakanaSend;
2234     output_char_count = MakeOutputString(cv, &state, &B[i], C-i, TempStr, &TempLen);
2235    
2236     // �f�[�^���o���o�b�t�@��
2237     if (WriteOutBuff(cv, TempStr, TempLen)) {
2238     i += output_char_count; // output_char_count ������ ��������
2239     // ��������������������
2240     cv->SendCode = state.SendCode;
2241     } else {
2242     Full = TRUE;
2243     }
2244     } // end of "while {}"
2245     _CrtCheckMemory();
2246     return i;
2247 zmatsuo 7484 }
2248    
2249 doda 8445 /**
2250     * CommTextEcho() �� wchar_t ��
2251     *
2252     * @retval �o��������(wchar_t�P��)
2253     */
2254 zmatsuo 7484 int WINAPI CommTextEchoW(PComVar cv, const wchar_t *B, int C)
2255     {
2256 doda 8445 char TempStr[12];
2257     BOOL Full = FALSE;
2258     int i = 0;
2259     while (! Full && (i < C)) {
2260     // �o���p�f�[�^������
2261     int TempLen = 0;
2262     size_t output_char_count; // ��������������
2263     OutputCharState state;
2264     state.KanjiCode = cv->KanjiCodeEcho;
2265     state.ControlOut = ControlEcho;
2266     state.SendCode = cv->EchoCode;
2267     state.JIS7Katakana = cv->JIS7KatakanaEcho;
2268     output_char_count = MakeOutputString(cv, &state, &B[i], C-i, TempStr, &TempLen);
2269    
2270     // �f�[�^���o���o�b�t�@��
2271     if (WriteInBuff(cv, TempStr, TempLen)) {
2272     i += output_char_count; // output_char_count ������ ��������
2273     // ��������������������
2274     cv->EchoCode = state.SendCode;
2275     } else {
2276     Full = TRUE;
2277     }
2278     } // end of "while {}"
2279     _CrtCheckMemory();
2280     return i;
2281 zmatsuo 7484 }
2282    
2283 zmatsuo 7305 int WINAPI CommBinaryEcho(PComVar cv, PCHAR B, int C)
2284 maya 3227 {
2285     int a, i, Len;
2286     char d[3];
2287    
2288     if ( ! cv->Ready )
2289     return C;
2290    
2291 doda 8445 PackInBuff(cv);
2292 maya 3227
2293     i = 0;
2294     a = 1;
2295     while ((a>0) && (i<C)) {
2296     Len = 0;
2297    
2298     d[Len] = B[i];
2299     Len++;
2300    
2301     if ( cv->TelFlag && (B[i]=='\x0d') &&
2302     ! cv->TelBinSend ) {
2303     d[Len] = 0x00;
2304     Len++;
2305     }
2306    
2307     if ( cv->TelFlag && (B[i]=='\xff') ) {
2308     d[Len] = '\xff';
2309     Len++;
2310     }
2311    
2312 doda 8445 if (WriteInBuff(cv, d, Len)) {
2313 maya 3227 a = 1;
2314 doda 8445 i++;
2315     } else {
2316     a = 0;
2317 maya 3227 }
2318     }
2319     return i;
2320     }
2321    
2322 zmatsuo 7411 static int WINAPI TextEchoMBCS(PComVar cv,