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 8616 - (hide annotations) (download) (as text)
Mon Mar 23 15:54:26 2020 UTC (4 years ago) by zmatsuo
File MIME type: text/x-csrc
File size: 67980 byte(s) 
TTMessageBoxW() を追加、一部利用するよう修正

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