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 8576 - (hide annotations) (download) (as text)
Fri Mar 6 15:21:54 2020 UTC (4 years, 1 month ago) by zmatsuo
File MIME type: text/x-csrc
File size: 68019 byte(s) 
Tera Term と htmlhelp ウィンドウを同時に閉じたときエラーが出ないよう修正

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