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 8496 - (hide annotations) (download) (as text)
Wed Jan 22 13:53:43 2020 UTC (4 years, 2 months ago) by zmatsuo
File MIME type: text/x-csrc
File size: 71000 byte(s) 
common_static を ttpcmn からリンク, windowメニューを多言語化
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     HMONITOR hMonitor;
1102     MONITORINFO mi;
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     hMonitor = MonitorFromRect(&rc, MONITOR_DEFAULTTONEAREST);
1124     mi.cbSize = sizeof(MONITORINFO);
1125     GetMonitorInfo(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     wchar_t *HomeDirT;
1172 maya 5308
1173     /* Get home directory */
1174 zmatsuo 7412 if (GetModuleFileNameA(NULL,Temp,_countof(Temp)) == 0) {
1175 maya 5308 return;
1176     }
1177     ExtractDirName(Temp, HomeDir);
1178 zmatsuo 8496 HomeDirT = ToWcharA(HomeDir);
1179 doda 6435
1180 zmatsuo 8496 get_lang_msgW("HELPFILE", uimsg, _countof(uimsg), L"teraterm.chm", UILanguageFile);
1181 maya 5308
1182     // �w���v���I�[�i�[�������f�X�N�g�b�v������ (2007.5.12 maya)
1183     HWin = GetDesktopWindow();
1184 zmatsuo 8496 _snwprintf_s(HelpFN, _countof(HelpFN), _TRUNCATE, L"%s\\%s", HomeDirT, uimsg);
1185     if (_HtmlHelpW(HWin, HelpFN, Command, Data) == NULL && Command != HH_CLOSE_ALL) {
1186 zmatsuo 7412 goto error;
1187 maya 5308 }
1188 zmatsuo 7412 goto finish;
1189    
1190     error:
1191 zmatsuo 8496 {
1192     wchar_t buf[MAX_PATH];
1193     get_lang_msgW("MSG_OPENHELP_ERROR", uimsg, _countof(uimsg),
1194     L"Can't open HTML help file(%s).", UILanguageFile);
1195     _snwprintf_s(buf, _countof(buf), _TRUNCATE, uimsg, HelpFN);
1196     _MessageBoxW(HWin, buf, L"Tera Term: HTML help", MB_OK | MB_ICONERROR);
1197     }
1198 zmatsuo 7412
1199     finish:
1200 zmatsuo 8496 free(HomeDirT);
1201 maya 5308 }
1202    
1203 zmatsuo 7305 HWND WINAPI GetNthWin(int n)
1204 maya 3227 {
1205 maya 3392 if (n<pm->NWin) {
1206 maya 3227 return pm->WinList[n];
1207 maya 3392 }
1208     else {
1209 maya 3227 return NULL;
1210 maya 3392 }
1211 maya 3227 }
1212    
1213 zmatsuo 7725 int WINAPI GetRegisteredWindowCount(void)
1214 doda 6888 {
1215     return (pm->NWin);
1216     }
1217 yutakapon 5222
1218 yutakapon 5223 // �L�����E�B���h�E���T���A�������u���L�������������B
1219 yutakapon 5299 static void get_valid_window_and_memorize_rect(HWND myhwnd, HWND hwnd[], int *num, int style)
1220 yutakapon 5222 {
1221 yutakapon 5223 int i, n;
1222     WINDOWPLACEMENT wndPlace;
1223 yutakapon 5222
1224 yutakapon 5299 // ��������(Undo)���j���[�����x�����\���������B
1225     if (pm->WinUndoFlag == FALSE) {
1226     pm->WinUndoFlag = TRUE;
1227     } else {
1228     // ���������j���[���\�������������A�������O�������X�^�C�����I�����������A
1229     // ���j���[�������B
1230     // Windows8�����A�������A�����������X�^�C�����I�����������j���[�����������������A
1231     // Tera Term�������j���[���\�������������A�������������B
1232     if (pm->WinUndoStyle == style)
1233     pm->WinUndoFlag = FALSE;
1234     }
1235     pm->WinUndoStyle = style;
1236    
1237 yutakapon 5222 n = 0;
1238     for (i = 0 ; i < pm->NWin ; i++) {
1239 yutakapon 5223 // �������u���o���������B
1240     wndPlace.length = sizeof(WINDOWPLACEMENT);
1241     GetWindowPlacement(pm->WinList[i], &wndPlace);
1242     pm->WinPrevRect[i] = wndPlace;
1243    
1244     // �������g�������������B
1245 yutakapon 5222 if (pm->WinList[i] == myhwnd) {
1246     hwnd[n] = hwnd[0];
1247     hwnd[0] = myhwnd;
1248     } else {
1249     hwnd[n] = pm->WinList[i];
1250     }
1251     n++;
1252     }
1253 yutakapon 5223 *num = n;
1254     }
1255 yutakapon 5222
1256 yutakapon 5223 // �E�B���h�E�����E���������\������(Show Windows Side by Side)
1257 zmatsuo 7305 void WINAPI ShowAllWinSidebySide(HWND myhwnd)
1258 yutakapon 5223 {
1259     int n;
1260     HWND hwnd[MAXNWIN];
1261    
1262 yutakapon 5299 get_valid_window_and_memorize_rect(myhwnd, hwnd, &n, WIN_SIDEBYSIDE);
1263 yutakapon 5251 TileWindows(NULL, MDITILE_VERTICAL, NULL, n, hwnd);
1264 yutakapon 5222 }
1265    
1266     // �E�B���h�E���������������\������(Show Windows Stacked)
1267 zmatsuo 7305 void WINAPI ShowAllWinStacked(HWND myhwnd)
1268 yutakapon 5222 {
1269 yutakapon 5223 int n;
1270 yutakapon 5222 HWND hwnd[MAXNWIN];
1271    
1272 yutakapon 5299 get_valid_window_and_memorize_rect(myhwnd, hwnd, &n, WIN_STACKED);
1273 yutakapon 5251 TileWindows(NULL, MDITILE_HORIZONTAL, NULL, n, hwnd);
1274 yutakapon 5222 }
1275    
1276     // �E�B���h�E���d�����\������(Cascade)
1277 zmatsuo 7305 void WINAPI ShowAllWinCascade(HWND myhwnd)
1278 yutakapon 5222 {
1279 yutakapon 5223 int n;
1280     HWND hwnd[MAXNWIN];
1281    
1282 yutakapon 5299 get_valid_window_and_memorize_rect(myhwnd, hwnd, &n, WIN_CASCADE);
1283 yutakapon 5251 CascadeWindows(NULL, MDITILE_SKIPDISABLED, NULL, n, hwnd);
1284 yutakapon 5222 }
1285    
1286 yutakapon 5232 // �STera Term���I���w�����o���B
1287 zmatsuo 7305 void WINAPI BroadcastClosingMessage(HWND myhwnd)
1288 yutakapon 5232 {
1289     int i, max;
1290     HWND hwnd[MAXNWIN];
1291    
1292     // Tera Term���I�����������A���L���������������������A
1293     // ���������o�b�t�@���R�s�[���������B
1294     max = pm->NWin;
1295     for (i = 0 ; i < pm->NWin ; i++) {
1296     hwnd[i] = pm->WinList[i];
1297     }
1298    
1299     for (i = 0 ; i < max ; i++) {
1300     // �������g�������������B
1301 doda 6435 if (hwnd[i] == myhwnd)
1302 yutakapon 5232 continue;
1303    
1304     PostMessage(hwnd[i], WM_USER_NONCONFIRM_CLOSE, 0, 0);
1305     }
1306     PostMessage(myhwnd, WM_USER_NONCONFIRM_CLOSE, 0, 0);
1307     }
1308    
1309    
1310 zmatsuo 7305 int WINAPI CommReadRawByte(PComVar cv, LPBYTE b)
1311 maya 3227 {
1312 maya 3392 if ( ! cv->Ready ) {
1313 maya 3227 return 0;
1314 maya 3392 }
1315 maya 3227
1316     if ( cv->InBuffCount>0 ) {
1317     *b = cv->InBuff[cv->InPtr];
1318     cv->InPtr++;
1319     cv->InBuffCount--;
1320 maya 3392 if ( cv->InBuffCount==0 ) {
1321 maya 3227 cv->InPtr = 0;
1322 maya 3392 }
1323 maya 3227 return 1;
1324     }
1325     else {
1326     cv->InPtr = 0;
1327     return 0;
1328     }
1329     }
1330    
1331 zmatsuo 7305 void WINAPI CommInsert1Byte(PComVar cv, BYTE b)
1332 maya 3227 {
1333 maya 3392 if ( ! cv->Ready ) {
1334 maya 3227 return;
1335 maya 3392 }
1336 maya 3227
1337 maya 3392 if (cv->InPtr == 0) {
1338 maya 3227 memmove(&(cv->InBuff[1]),&(cv->InBuff[0]),cv->InBuffCount);
1339 maya 3392 }
1340     else {
1341 maya 3227 cv->InPtr--;
1342 maya 3392 }
1343 maya 3227 cv->InBuff[cv->InPtr] = b;
1344     cv->InBuffCount++;
1345    
1346 maya 3392 if (cv->HBinBuf!=0 ) {
1347 maya 3227 cv->BinSkip++;
1348 maya 3392 }
1349 maya 3227 }
1350    
1351     void Log1Bin(PComVar cv, BYTE b)
1352     {
1353 maya 3392 if (((cv->FilePause & OpLog)!=0) || cv->ProtoFlag) {
1354 maya 3227 return;
1355 maya 3392 }
1356 maya 3227 if (cv->BinSkip > 0) {
1357     cv->BinSkip--;
1358     return;
1359     }
1360     cv->BinBuf[cv->BinPtr] = b;
1361     cv->BinPtr++;
1362 maya 3392 if (cv->BinPtr>=InBuffSize) {
1363 maya 3227 cv->BinPtr = cv->BinPtr-InBuffSize;
1364 maya 3392 }
1365 maya 3227 if (cv->BCount>=InBuffSize) {
1366     cv->BCount = InBuffSize;
1367     cv->BStart = cv->BinPtr;
1368     }
1369 maya 3392 else {
1370 maya 3227 cv->BCount++;
1371 maya 3392 }
1372 maya 3227 }
1373    
1374 zmatsuo 7305 int WINAPI CommRead1Byte(PComVar cv, LPBYTE b)
1375 maya 3227 {
1376     int c;
1377    
1378 maya 3392 if ( ! cv->Ready ) {
1379 maya 3227 return 0;
1380 maya 3392 }
1381 maya 3227
1382     if ((cv->HLogBuf!=NULL) &&
1383     ((cv->LCount>=InBuffSize-10) ||
1384     (cv->DCount>=InBuffSize-10))) {
1385     // �������o�b�t�@���]�T�������������ACPU�X�P�W���[�����O�����������A
1386     // CPU���X�g�[���������h���B
1387     // (2006.10.13 yutaka)
1388     Sleep(1);
1389     return 0;
1390     }
1391    
1392     if ((cv->HBinBuf!=NULL) &&
1393 maya 3392 (cv->BCount>=InBuffSize-10)) {
1394 maya 3227 return 0;
1395 maya 3392 }
1396 maya 3227
1397 maya 3392 if ( cv->TelMode ) {
1398 maya 3227 c = 0;
1399 maya 3392 }
1400     else {
1401 maya 3227 c = CommReadRawByte(cv,b);
1402 maya 3392 }
1403 maya 3227
1404     if ((c==1) && cv->TelCRFlag) {
1405     cv->TelCRFlag = FALSE;
1406 maya 3392 if (*b==0) {
1407     c = 0;
1408     }
1409 maya 3227 }
1410    
1411     if ( c==1 ) {
1412     if ( cv->IACFlag ) {
1413     cv->IACFlag = FALSE;
1414     if ( *b != 0xFF ) {
1415     cv->TelMode = TRUE;
1416     CommInsert1Byte(cv,*b);
1417 maya 3392 if ( cv->HBinBuf!=0 ) {
1418 maya 3227 cv->BinSkip--;
1419 maya 3392 }
1420 maya 3227 c = 0;
1421     }
1422     }
1423     else if ((cv->PortType==IdTCPIP) && (*b==0xFF)) {
1424 maya 3392 if (!cv->TelFlag && cv->TelAutoDetect) { /* TTPLUG */
1425 maya 3227 cv->TelFlag = TRUE;
1426 maya 3392 }
1427 maya 3227 if (cv->TelFlag) {
1428     cv->IACFlag = TRUE;
1429     c = 0;
1430     }
1431     }
1432 maya 3392 else if (cv->TelFlag && ! cv->TelBinRecv && (*b==0x0D)) {
1433 maya 3227 cv->TelCRFlag = TRUE;
1434 maya 3392 }
1435 maya 3227 }
1436    
1437 maya 3392 if ( (c==1) && (cv->HBinBuf!=0) ) {
1438 maya 3227 Log1Bin(cv, *b);
1439 maya 3392 }
1440 maya 3227
1441     return c;
1442     }
1443    
1444 doda 8445 int WINAPI CommRawOut(PComVar cv, /*const*/ PCHAR B, int C)
1445 maya 3227 {
1446     int a;
1447    
1448 maya 3392 if ( ! cv->Ready ) {
1449 maya 3227 return C;
1450 maya 3392 }
1451 maya 3227
1452 maya 3392 if (C > OutBuffSize - cv->OutBuffCount) {
1453 maya 3227 a = OutBuffSize - cv->OutBuffCount;
1454 maya 3392 }
1455     else {
1456 maya 3227 a = C;
1457 maya 3392 }
1458 maya 3227 if ( cv->OutPtr > 0 ) {
1459     memmove(&(cv->OutBuff[0]),&(cv->OutBuff[cv->OutPtr]),cv->OutBuffCount);
1460     cv->OutPtr = 0;
1461     }
1462     memcpy(&(cv->OutBuff[cv->OutBuffCount]),B,a);
1463     cv->OutBuffCount = cv->OutBuffCount + a;
1464     return a;
1465     }
1466    
1467 zmatsuo 7305 int WINAPI CommBinaryOut(PComVar cv, PCHAR B, int C)
1468 maya 3227 {
1469     int a, i, Len;
1470     char d[3];
1471    
1472 maya 3392 if ( ! cv->Ready ) {
1473 maya 3227 return C;
1474 maya 3392 }
1475 maya 3227
1476     i = 0;
1477     a = 1;
1478     while ((a>0) && (i<C)) {
1479     Len = 0;
1480    
1481     d[Len] = B[i];
1482     Len++;
1483    
1484 doda 3505 if ( cv->TelFlag && (B[i]=='\x0d') && ! cv->TelBinSend ) {
1485     d[Len++] = '\x00';
1486 maya 3227 }
1487 doda 3505 else if ( cv->TelFlag && (B[i]=='\xff') ) {
1488     d[Len++] = '\xff';
1489     }
1490 maya 3227
1491 doda 3505 if ( OutBuffSize - cv->OutBuffCount - Len >= 0 ) {
1492     CommRawOut(cv, d, Len);
1493 maya 3227 a = 1;
1494     }
1495 maya 3392 else {
1496 maya 3227 a = 0;
1497 maya 3392 }
1498 maya 3227
1499 doda 3505 i += a;
1500 maya 3227 }
1501     return i;
1502     }
1503    
1504 doda 8445 /**
1505     * �f�[�^(������)���o���o�b�t�@����������
1506     *
1507     * �w���f�[�^��������������������������������������
1508     * CommRawOut() ��������������������������
1509     *
1510     * @retval TRUE �o��������
1511     * @retval FALSE �o��������������(buffer full)
1512     */
1513     static BOOL WriteOutBuff(PComVar cv, const char *TempStr, int TempLen)
1514     {
1515     BOOL output;
1516    
1517     if (TempLen == 0) {
1518     // ����0������������������������
1519     return TRUE;
1520     }
1521    
1522     output = FALSE;
1523     if (cv->TelLineMode) {
1524     const BOOL Full = OutBuffSize - cv->LineModeBuffCount - TempLen < 0;
1525     if (!Full) {
1526     output = TRUE;
1527     memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), TempStr, TempLen);
1528     cv->LineModeBuffCount += TempLen;
1529     if (cv->Flush) {
1530     cv->FlushLen = cv->LineModeBuffCount;
1531     }
1532     }
1533     if (cv->FlushLen > 0) {
1534     const int OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
1535     cv->FlushLen -= OutLen;
1536     cv->LineModeBuffCount -= OutLen;
1537     memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
1538     }
1539     cv->Flush = FALSE;
1540     }
1541     else {
1542     const BOOL Full = OutBuffSize-cv->OutBuffCount-TempLen < 0;
1543     if (! Full) {
1544     output = TRUE;
1545     CommRawOut(cv, (char *)TempStr, TempLen);
1546     }
1547     }
1548     return output;
1549     }
1550    
1551     /**
1552     * �f�[�^(������)�������o�b�t�@����������
1553     * �����o�b�t�@�������� -> �G�R�[������
1554     *
1555     * @retval TRUE �o��������
1556     * @retval FALSE �o��������������(buffer full)
1557     */
1558     static BOOL WriteInBuff(PComVar cv, const char *TempStr, int TempLen)
1559     {
1560     BOOL Full;
1561    
1562     if (TempLen == 0) {
1563     return TRUE;
1564     }
1565    
1566     Full = InBuffSize-cv->InBuffCount-TempLen < 0;
1567     if (! Full) {
1568     memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
1569     cv->InBuffCount = cv->InBuffCount + TempLen;
1570     return TRUE;
1571     }
1572     return FALSE;
1573     }
1574    
1575     /**
1576     * �����o�b�t�@�����������������������l����
1577     */
1578     static void PackInBuff(PComVar cv)
1579     {
1580     if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
1581     memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
1582     cv->InPtr = 0;
1583     }
1584     }
1585    
1586 zmatsuo 7305 int WINAPI CommBinaryBuffOut(PComVar cv, PCHAR B, int C)
1587 doda 3505 {
1588 doda 8445 int a, i, Len;
1589 doda 3505 char d[3];
1590    
1591     if ( ! cv->Ready ) {
1592     return C;
1593     }
1594    
1595     i = 0;
1596     a = 1;
1597     while ((a>0) && (i<C)) {
1598     Len = 0;
1599    
1600     d[Len] = B[i];
1601     Len++;
1602    
1603     if (B[i] == CR) {
1604     if ( cv->TelFlag && ! cv->TelBinSend ) {
1605     d[Len++] = '\x00';
1606     }
1607     if (cv->TelLineMode) {
1608     cv->Flush = TRUE;
1609     }
1610     }
1611     else if ( cv->TelFlag && (B[i]=='\xff') ) {
1612     d[Len++] = '\xff';
1613     }
1614    
1615 doda 8445 if (WriteOutBuff(cv, d, Len)) {
1616     a = 1;
1617     i++;
1618     } else {
1619     a = 0;
1620 doda 3505 }
1621     }
1622     return i;
1623     }
1624    
1625 zmatsuo 7462 // �����R�[�h(CodePage)��UTF-8���o������
1626 doda 3442 static int OutputTextUTF8(WORD K, char *TempStr, PComVar cv)
1627 maya 3227 {
1628 zmatsuo 7462 int CodePage = *cv->CodePage;
1629 maya 3227 unsigned int code;
1630 doda 3442 int outlen;
1631 maya 3227
1632 zmatsuo 7466 code = MBCP_UTF32(K, CodePage);
1633 zmatsuo 7464 if (code == 0) {
1634     // �������s
1635     code = 0xfffd; // U+FFFD: Replacement Character
1636     }
1637 zmatsuo 7462 outlen = UTF32ToUTF8(code, TempStr, 4);
1638     return outlen;
1639 maya 3227 }
1640    
1641 doda 6435 //
1642 doda 3451 // MBCS�����e�������R�[�h�����������o�������B
1643 maya 3227 //
1644 zmatsuo 7411 static int TextOutMBCS(PComVar cv, PCHAR B, int C)
1645 maya 3227 {
1646 doda 8445 int i, TempLen;
1647 maya 3227 WORD K;
1648 doda 3442 char TempStr[12];
1649 maya 3227 BYTE d;
1650 doda 8445 BOOL Full;
1651     int SendCodeNew; // ���M�R�[�h
1652     BOOL KanjiFlagNew; // TRUE=����������������������������
1653 maya 3227
1654     Full = FALSE;
1655     i = 0;
1656     while (! Full && (i < C)) {
1657     TempLen = 0;
1658     d = (BYTE)B[i];
1659     SendCodeNew = cv->SendCode;
1660 doda 3442 KanjiFlagNew = FALSE;
1661 maya 3227
1662     if (cv->SendKanjiFlag) {
1663     SendCodeNew = IdKanji;
1664    
1665     K = (cv->SendKanjiFirst << 8) + d;
1666    
1667     // UTF-8�����������s���B1�`3�o�C�g���������������������B
1668 doda 3408 if (cv->KanjiCodeSend == IdUTF8 || cv->Language == IdUtf8) {
1669 doda 3442 TempLen += OutputTextUTF8(K, TempStr, cv);
1670     }
1671     else {
1672     switch (cv->Language) {
1673     case IdJapanese:
1674 doda 6435 switch (cv->KanjiCodeSend) {
1675 doda 3442 case IdEUC:
1676 doda 3419 K = SJIS2EUC(K);
1677 doda 3442 break;
1678     case IdJIS:
1679 doda 3419 K = SJIS2JIS(K);
1680 doda 3442 if ((cv->SendCode==IdKatakana) &&
1681     (cv->JIS7KatakanaSend==1)) {
1682     TempStr[TempLen++] = SI;
1683     }
1684     break;
1685     case IdSJIS:
1686     /* nothing to do */
1687     break;
1688 doda 3419 }
1689 doda 3442 break;
1690     case IdKorean:
1691 doda 6435 break;
1692 maya 3227 }
1693 doda 3442 TempStr[TempLen++] = HIBYTE(K);
1694     TempStr[TempLen++] = LOBYTE(K);
1695 maya 3227 }
1696     }
1697 doda 3932 else if (_isleadbyte_l(d, cv->locale)) {
1698 maya 3227 KanjiFlagNew = TRUE;
1699     cv->SendKanjiFirst = d;
1700     SendCodeNew = IdKanji;
1701    
1702 doda 3442 if (cv->Language == IdJapanese) {
1703     if ((cv->SendCode!=IdKanji) && (cv->KanjiCodeSend==IdJIS)) {
1704     TempStr[0] = 0x1B;
1705     TempStr[1] = '$';
1706     if (cv->KanjiIn == IdKanjiInB) {
1707     TempStr[2] = 'B';
1708     }
1709     else {
1710     TempStr[2] = '@';
1711     }
1712     TempLen = 3;
1713 maya 3392 }
1714 maya 3227 }
1715     }
1716     else {
1717 doda 3442 if (cv->Language == IdJapanese) {
1718     if ((cv->SendCode==IdKanji) && (cv->KanjiCodeSend==IdJIS)) {
1719     TempStr[0] = 0x1B;
1720     TempStr[1] = '(';
1721     switch (cv->KanjiOut) {
1722     case IdKanjiOutJ:
1723 maya 3409 TempStr[2] = 'J';
1724     break;
1725 doda 3442 case IdKanjiOutH:
1726 maya 3409 TempStr[2] = 'H';
1727     break;
1728 doda 3442 default:
1729 maya 3409 TempStr[2] = 'B';
1730 doda 3442 }
1731     TempLen = 3;
1732 maya 3227 }
1733    
1734 doda 3442 if ((0xa0<d) && (d<0xe0)) {
1735     SendCodeNew = IdKatakana;
1736     if ((cv->SendCode!=IdKatakana) &&
1737     (cv->KanjiCodeSend==IdJIS) &&
1738     (cv->JIS7KatakanaSend==1)) {
1739     TempStr[TempLen++] = SO;
1740     }
1741 maya 3227 }
1742 doda 3442 else {
1743     SendCodeNew = IdASCII;
1744     if ((cv->SendCode==IdKatakana) &&
1745     (cv->KanjiCodeSend==IdJIS) &&
1746     (cv->JIS7KatakanaSend==1)) {
1747     TempStr[TempLen++] = SI;
1748     }
1749 maya 3227 }
1750     }
1751    
1752 doda 3497 if (d==CR) {
1753 doda 3442 TempStr[TempLen++] = 0x0d;
1754 maya 3227 if (cv->CRSend==IdCRLF) {
1755 doda 3442 TempStr[TempLen++] = 0x0a;
1756 maya 3227 }
1757     else if ((cv->CRSend==IdCR) &&
1758 doda 3398 cv->TelFlag && ! cv->TelBinSend) {
1759 doda 3442 TempStr[TempLen++] = 0;
1760 maya 3227 }
1761 maya 6369 else if (cv->CRSend == IdLF) {
1762     TempStr[TempLen-1] = 0x0a;
1763     }
1764 doda 3494 if (cv->TelLineMode) {
1765     cv->Flush = TRUE;
1766     }
1767 maya 3227 }
1768 doda 3497 else if (d==BS) {
1769     if (cv->TelLineMode) {
1770     if (cv->FlushLen < cv->LineModeBuffCount) {
1771     cv->LineModeBuffCount--;
1772     }
1773     }
1774 maya 6369 else {
1775 doda 3497 TempStr[TempLen++] = d;
1776     }
1777     }
1778 doda 3498 else if (d==0x15) { // Ctrl-U
1779     if (cv->TelLineMode) {
1780     cv->LineModeBuffCount = cv->FlushLen;
1781     }
1782 maya 6369 else {
1783 doda 3498 TempStr[TempLen++] = d;
1784     }
1785     }
1786 doda 3442 else if ((d>=0x80) && (cv->KanjiCodeSend==IdUTF8 || cv->Language==IdUtf8)) {
1787     TempLen += OutputTextUTF8((WORD)d, TempStr, cv);
1788     }
1789     else if ((d>=0xa1) && (d<=0xe0) && (cv->Language == IdJapanese)) {
1790 doda 3452 /* Katakana */
1791 maya 3227 if (cv->KanjiCodeSend==IdEUC) {
1792 doda 3444 TempStr[TempLen++] = (char)SS2;
1793 maya 3227 }
1794     if ((cv->KanjiCodeSend==IdJIS) &&
1795 maya 3392 (cv->JIS7KatakanaSend==1)) {
1796 doda 3442 TempStr[TempLen++] = d & 0x7f;
1797 maya 3392 }
1798     else {
1799 doda 3442 TempStr[TempLen++] = d;
1800 maya 3392 }
1801 maya 3227 }
1802     else {
1803 doda 3442 TempStr[TempLen++] = d;
1804 maya 3227 if (cv->TelFlag && (d==0xff)) {
1805 doda 3442 TempStr[TempLen++] = (char)0xff;
1806 maya 3227 }
1807     }
1808     } // if (cv->SendKanjiFlag) else if ... else ... end
1809    
1810 doda 8445 if (WriteOutBuff(cv, TempStr, TempLen)) {
1811     i++; // 1������������
1812     // ��������������������
1813     cv->SendCode = SendCodeNew;
1814     cv->SendKanjiFlag = KanjiFlagNew;
1815     } else {
1816     Full = TRUE;
1817 maya 3227 }
1818    
1819     } // end of "while {}"
1820    
1821     return i;
1822     }
1823    
1824 zmatsuo 7305 int WINAPI CommTextOut(PComVar cv, PCHAR B, int C)
1825 maya 3227 {
1826 doda 8445 int i, TempLen;
1827 doda 3442 char TempStr[12];
1828 maya 3227 BYTE d;
1829     BOOL Full;
1830    
1831 maya 3392 if (! cv->Ready ) {
1832 maya 3227 return C;
1833 maya 3392 }
1834 maya 3227
1835 maya 4009 switch (cv->Language) {
1836     case IdUtf8:
1837     case IdJapanese:
1838     case IdKorean:
1839     return TextOutMBCS(cv, B, C);
1840     break;
1841 maya 3392 }
1842 maya 3227
1843     Full = FALSE;
1844     i = 0;
1845     while (! Full && (i < C)) {
1846     TempLen = 0;
1847     d = (BYTE)B[i];
1848 doda 6435
1849 doda 3497 switch (d) {
1850     case CR:
1851 maya 3227 TempStr[TempLen] = 0x0d;
1852     TempLen++;
1853     if (cv->CRSend==IdCRLF) {
1854 doda 3452 TempStr[TempLen++] = 0x0a;
1855 maya 3227 }
1856 doda 3452 else if (cv->CRSend==IdCR && cv->TelFlag && ! cv->TelBinSend) {
1857     TempStr[TempLen++] = 0;
1858 maya 3227 }
1859 maya 6369 else if (cv->CRSend == IdLF) {
1860     TempStr[TempLen-1] = 0x0a;
1861     }
1862 doda 3494 if (cv->TelLineMode) {
1863     cv->Flush = TRUE;
1864     }
1865 doda 3497 break;
1866    
1867     case BS:
1868     if (cv->TelLineMode) {
1869     if (cv->FlushLen < cv->LineModeBuffCount) {
1870     cv->LineModeBuffCount--;
1871     }
1872     }
1873 doda 6435 else {
1874 doda 3497 TempStr[TempLen++] = d;
1875     }
1876     break;
1877    
1878 doda 3498 case 0x15: // Ctrl-U
1879     if (cv->TelLineMode) {
1880     cv->LineModeBuffCount = cv->FlushLen;
1881     }
1882     else {
1883     TempStr[TempLen++] = d;
1884     }
1885 doda 3504 break;
1886 doda 3498
1887 doda 3497 default:
1888 doda 3452 if ((cv->Language==IdRussian) && (d>=128)) {
1889 doda 3494 d = RussConv(cv->RussClient, cv->RussHost, d);
1890 doda 3452 }
1891     TempStr[TempLen++] = d;
1892 maya 3227 if (cv->TelFlag && (d==0xff)) {
1893 doda 3452 TempStr[TempLen++] = (char)0xff;
1894 maya 3227 }
1895     }
1896    
1897 doda 8445 if (WriteOutBuff(cv, TempStr, TempLen)) {
1898     i++; // 1������������
1899     } else {
1900     Full = TRUE;
1901     }
1902    
1903     } // end of while {}
1904    
1905     return i;
1906     }
1907    
1908     /**
1909     * @retval true ���{�������p�J�^�J�i
1910     * @retval false ������
1911     */
1912     static BOOL IsHalfWidthKatakana(unsigned int u32)
1913     {
1914     // Halfwidth CJK punctuation (U+FF61�`FF64)
1915     // Halfwidth Katakana variants (U+FF65�`FF9F)
1916     return (0xff61 <= u32 && u32 <= 0xff9f);
1917     }
1918    
1919     /**
1920     * �o���p�A TODO echo�p������
1921     * @param cv
1922     * @param u32 ��������
1923     * @param check_only TRUE���������s�����A
1924     * @param TempStr �o��������
1925     * @param StrLen TempStr�����o��������
1926     * @retval �������s����
1927     */
1928     static BOOL OutControl(PComVar cv, unsigned int u32, BOOL check_only, char *TempStr, size_t *StrLen)
1929     {
1930     const wchar_t d = u32;
1931     size_t TempLen = 0;
1932     BOOL retval = FALSE;
1933     if (check_only == TRUE) {
1934     /* �`�F�b�N���� */
1935     if (d == CR || d == BS || d == 0x15/*ctrl-u*/) {
1936     return TRUE;
1937     } else {
1938     return FALSE;
1939     }
1940     }
1941     if (d==CR) {
1942     TempStr[TempLen++] = 0x0d;
1943     if (cv->CRSend==IdCRLF) {
1944     TempStr[TempLen++] = 0x0a;
1945     }
1946     else if ((cv->CRSend ==IdCR) &&
1947     cv->TelFlag && ! cv->TelBinSend) {
1948     TempStr[TempLen++] = 0;
1949     }
1950     else if (cv->CRSend == IdLF) {
1951     TempStr[TempLen-1] = 0x0a;
1952     }
1953 doda 3494 if (cv->TelLineMode) {
1954 doda 8445 cv->Flush = TRUE;
1955     }
1956     retval = TRUE;
1957     }
1958     else if (d== BS) {
1959     if (cv->TelLineMode) {
1960     if (cv->FlushLen < cv->LineModeBuffCount) {
1961     cv->LineModeBuffCount--;
1962     }
1963     }
1964     else {
1965     TempStr[TempLen++] = BS;
1966     }
1967     retval = TRUE;
1968     }
1969     else if (d==0x15) { // ctrl-u
1970     if (cv->TelLineMode) {
1971     cv->LineModeBuffCount = cv->FlushLen;
1972     }
1973     else {
1974     TempStr[TempLen++] = 0x15;
1975     }
1976     retval = TRUE;
1977     }
1978     *StrLen = TempLen;
1979     return retval;
1980     }
1981     static BOOL ControlEcho(PComVar cv, unsigned int u32, BOOL check_only, char *TempStr, size_t *StrLen)
1982     {
1983     const wchar_t d = u32;
1984     size_t TempLen = 0;
1985     BOOL retval = FALSE;
1986     if (check_only == TRUE) {
1987     /* �`�F�b�N���� */
1988     if (d == CR || (d == 0x15/*ctrl-u*/ && cv->TelLineMode)) {
1989     return TRUE;
1990     } else {
1991     return FALSE;
1992     }
1993     }
1994     if (d==CR) {
1995     TempStr[TempLen++] = 0x0d;
1996     if (cv->CRSend==IdCRLF) {
1997     TempStr[TempLen++] = 0x0a;
1998     }
1999     else if ((cv->CRSend ==IdCR) && cv->TelFlag && ! cv->TelBinSend) {
2000     TempStr[TempLen++] = 0;
2001     }
2002     else if (cv->CRSend == IdLF) {
2003     TempStr[TempLen-1] = 0x0a;
2004     }
2005     retval = TRUE;
2006     }
2007     else if (d==0x15/*ctrl-u*/ && cv->TelLineMode) {
2008     // Move to top of line (CHA "\033[G") and erase line (EL "\033[K")
2009     memcpy(TempStr, "\033[G\033[K", 6);
2010     TempLen += 6;
2011     retval = TRUE;
2012     }
2013     *StrLen = TempLen;
2014     return retval;
2015     }
2016    
2017     /**
2018     * �o���p����������������
2019     *
2020     * @retval ��������������
2021     */
2022     typedef struct {
2023     int KanjiCode; // [in]�o�������R�[�h(sjis,jis����)
2024     BOOL (*ControlOut)(PComVar cv, unsigned int u32, BOOL check_only, char *TempStr, size_t *StrLen);
2025     // state�����������K�v�����������R�[�h���g�p
2026     BOOL JIS7Katakana; // [in](Kanji JIS)kana
2027     int SendCode; // [in,out](Kanji JIS)���O�����M�R�[�h Ascii/Kana/Kanji
2028     BOOL KanjiFlag; // [in,out](MBCS)���O��1byte��������������?(2byte������������?)
2029     BYTE KanjiFirst; // [in,out](MBCS)���O��1byte
2030     } OutputCharState;
2031    
2032     /**
2033     * unicode(UTF-16)����unicode(UTF-32)��1���������o����
2034     * �o���f�[�^(TempStr)����������
2035     */
2036     static size_t MakeOutputString(PComVar cv, OutputCharState *states,
2037     const wchar_t *B, int C,
2038     char *TempStr, int *TempLen_)
2039     {
2040     BOOL (*ControlOut)(PComVar cv, unsigned int u32, BOOL check_only, char *TempStr, size_t *StrLen)
2041     = states->ControlOut;
2042     //
2043     int TempLen = 0;
2044     size_t TempLen2;
2045     size_t output_char_count; // ��������������
2046    
2047     // UTF-32 ��1���������o��
2048     unsigned int u32;
2049     size_t u16_len = UTF16ToUTF32(B, C, &u32);
2050     if (u16_len == 0) {
2051     // �f�R�[�h��������? ����������������?
2052     assert(FALSE);
2053     u32 = '?';
2054     u16_len = 1;
2055     }
2056     output_char_count = u16_len;
2057    
2058     // �e���V�t�g����������������
2059     if (u32 < 0x100 || ControlOut(cv, u32, TRUE, NULL, NULL)) {
2060     if (cv->Language == IdJapanese && states->KanjiCode == IdJIS) {
2061     // �����������A���{��,JIS��������
2062     if (cv->SendCode == IdKanji) {
2063     // �����������������A����OUT
2064     TempStr[TempLen++] = 0x1B;
2065     TempStr[TempLen++] = '(';
2066     switch (cv->KanjiOut) {
2067     case IdKanjiOutJ:
2068     TempStr[TempLen++] = 'J';
2069     break;
2070     case IdKanjiOutH:
2071     TempStr[TempLen++] = 'H';
2072     break;
2073     default:
2074     TempStr[TempLen++] = 'B';
2075 doda 3494 }
2076     }
2077 doda 8445
2078     if (states->JIS7Katakana == 1) {
2079     if (cv->SendCode == IdKatakana) {
2080     TempStr[TempLen++] = SO;
2081     }
2082 doda 3494 }
2083 doda 8445
2084     states->SendCode = IdASCII;
2085 maya 3227 }
2086 doda 8445 }
2087    
2088     // 1������������
2089     if (ControlOut(cv, u32, FALSE, TempStr, &TempLen2)) {
2090     // ��������������������
2091     TempLen += TempLen2;
2092     output_char_count = 1;
2093     } else if (cv->Language == IdUtf8 ||
2094     (cv->Language == IdJapanese && states->KanjiCode == IdUTF8) ||
2095     (cv->Language == IdKorean && states->KanjiCode == IdUTF8))
2096     {
2097     // UTF-8 ���o��
2098     size_t utf8_len = sizeof(TempStr);
2099     utf8_len = UTF32ToUTF8(u32, TempStr, utf8_len);
2100     TempLen += utf8_len;
2101     } else if (cv->Language == IdJapanese && *cv->CodePage == 932) {
2102     // ���{��
2103     // ���� CP932(SJIS) ���������������o��
2104     char mb_char[2];
2105     size_t mb_len = sizeof(mb_char);
2106     mb_len = UTF32ToMBCP(u32, 932, mb_char, mb_len);
2107     if (mb_len == 0) {
2108     // SJIS��������������
2109     TempStr[TempLen++] = '?';
2110     } else {
2111     switch (states->KanjiCode) {
2112     case IdEUC:
2113     // TODO ���p�J�i
2114     if (mb_len == 1) {
2115     TempStr[TempLen++] = mb_char[0];
2116     } else {
2117     WORD K;
2118     K = (((WORD)(unsigned char)mb_char[0]) << 8) +
2119     (WORD)(unsigned char)mb_char[1];
2120     K = SJIS2EUC(K);
2121     TempStr[TempLen++] = HIBYTE(K);
2122     TempStr[TempLen++] = LOBYTE(K);
2123     }
2124     break;
2125     case IdJIS:
2126     if (u32 < 0x100) {
2127     // ASCII
2128     TempStr[TempLen++] = mb_char[0];
2129     states->SendCode = IdASCII;
2130     } else if (IsHalfWidthKatakana(u32)) {
2131     // ���p�J�^�J�i
2132     if (states->JIS7Katakana==1) {
2133     if (cv->SendCode != IdKatakana) {
2134     TempStr[TempLen++] = SI;
2135     }
2136     TempStr[TempLen++] = mb_char[0] & 0x7f;
2137     } else {
2138     TempStr[TempLen++] = mb_char[0];
2139     }
2140     states->SendCode = IdKatakana;
2141     } else {
2142     // ����
2143     WORD K;
2144     K = (((WORD)(unsigned char)mb_char[0]) << 8) +
2145     (WORD)(unsigned char)mb_char[1];
2146     K = SJIS2JIS(K);
2147     if (states->SendCode != IdKanji) {
2148     // ����IN
2149     TempStr[TempLen++] = 0x1B;
2150     TempStr[TempLen++] = '$';
2151     if (cv->KanjiIn == IdKanjiInB) {
2152     TempStr[TempLen++] = 'B';
2153     }
2154     else {
2155     TempStr[TempLen++] = '@';
2156     }
2157     states->SendCode = IdKanji;
2158     }
2159     TempStr[TempLen++] = HIBYTE(K);
2160     TempStr[TempLen++] = LOBYTE(K);
2161     }
2162     break;
2163     case IdSJIS:
2164     if (mb_len == 1) {
2165     TempStr[TempLen++] = mb_char[0];
2166     } else {
2167     TempStr[TempLen++] = mb_char[0];
2168     TempStr[TempLen++] = mb_char[1];
2169     }
2170     break;
2171     default:
2172     assert(FALSE);
2173     break;
2174 doda 3494 }
2175     }
2176 doda 8445 } else if (cv->Language == IdRussian) {
2177     /* ����CP1251�����������o�� */
2178     char mb_char[2];
2179     size_t mb_len = sizeof(mb_char);
2180     BYTE b;
2181     mb_len = UTF32ToMBCP(u32, 1251, mb_char, mb_len);
2182     if (mb_len != 1) {
2183     b = '?';
2184     } else {
2185     b = RussConv(IdWindows, cv->RussHost, mb_char[0]);
2186     }
2187     TempStr[TempLen++] = b;
2188     } else if (cv->Language == IdKorean && *cv->CodePage == 51949) {
2189     /* CP51949�����������o�� */
2190     char mb_char[2];
2191     size_t mb_len = sizeof(mb_char);
2192     mb_len = UTF32ToMBCP(u32, 51949, mb_char, mb_len);
2193     if (mb_len == 0) {
2194     TempStr[TempLen++] = '?';
2195     }
2196     else if (mb_len == 1) {
2197     TempStr[TempLen++] = mb_char[0];
2198     } else {
2199     TempStr[TempLen++] = mb_char[0];
2200     TempStr[TempLen++] = mb_char[1];
2201     }
2202     } else if (cv->Language == IdEnglish) {
2203     TempStr[TempLen++] = u32;
2204     } else {
2205     // CodePage������
2206     char mb_char[2];
2207     size_t mb_len = sizeof(mb_char);
2208     mb_len = UTF32ToMBCP(u32, *cv->CodePage, mb_char, mb_len);
2209     if (mb_len == 0) {
2210     TempStr[TempLen++] = '?';
2211     }
2212     else if (mb_len == 1) {
2213     TempStr[TempLen++] = mb_char[0];
2214     } else {
2215     TempStr[TempLen++] = mb_char[0];
2216     TempStr[TempLen++] = mb_char[1];
2217     }
2218     }
2219 maya 3227
2220 doda 8445 *TempLen_ = TempLen;
2221     return output_char_count;
2222 maya 3227 }
2223    
2224 doda 8445
2225     /**
2226     * CommTextOut() �� wchar_t ��
2227     *
2228     * @retval �o��������(wchar_t�P��)
2229     */
2230 zmatsuo 7484 int WINAPI CommTextOutW(PComVar cv, const wchar_t *B, int C)
2231     {
2232 doda 8445 char TempStr[12];
2233     BOOL Full = FALSE;
2234     int i = 0;
2235     while (! Full && (i < C)) {
2236     // �o���p�f�[�^������
2237     int TempLen = 0;
2238     size_t output_char_count; // ��������������
2239     OutputCharState state;
2240     state.KanjiCode = cv->KanjiCodeSend;
2241     state.ControlOut = OutControl;
2242     state.SendCode = cv->SendCode;
2243     state.JIS7Katakana = cv->JIS7KatakanaSend;
2244     output_char_count = MakeOutputString(cv, &state, &B[i], C-i, TempStr, &TempLen);
2245    
2246     // �f�[�^���o���o�b�t�@��
2247     if (WriteOutBuff(cv, TempStr, TempLen)) {
2248     i += output_char_count; // output_char_count ������ ��������
2249     // ��������������������
2250     cv->SendCode = state.SendCode;
2251     } else {
2252     Full = TRUE;
2253     }
2254     } // end of "while {}"
2255     _CrtCheckMemory();
2256     return i;
2257 zmatsuo 7484 }
2258    
2259 doda 8445 /**
2260     * CommTextEcho() �� wchar_t ��
2261     *
2262     * @retval �o��������(wchar_t�P��)
2263     */
2264 zmatsuo 7484 int WINAPI CommTextEchoW(PComVar cv, const wchar_t *B, int C)
2265     {
2266 doda 8445 char TempStr[12];
2267     BOOL Full = FALSE;
2268     int i = 0;
2269     while (! Full && (i < C)) {
2270     // �o���p�f�[�^������
2271     int TempLen = 0;
2272     size_t output_char_count; // ��������������
2273     OutputCharState state;
2274     state.KanjiCode = cv->KanjiCodeEcho;
2275     state.ControlOut = ControlEcho;
2276     state.SendCode = cv->EchoCode;
2277     state.JIS7Katakana = cv->JIS7KatakanaEcho;
2278     output_char_count = MakeOutputString(cv, &state, &B[i], C-i, TempStr, &TempLen);
2279    
2280     // �f�[�^���o���o�b�t�@��
2281     if (WriteInBuff(cv, TempStr, TempLen)) {
2282     i += output_char_count; // output_char_count ������ ��������
2283     // ��������������������
2284     cv->EchoCode = state.SendCode;
2285     } else {
2286     Full = TRUE;
2287     }
2288     } // end of "while {}"
2289     _CrtCheckMemory();
2290     return i;
2291 zmatsuo 7484 }
2292    
2293 zmatsuo 7305 int WINAPI CommBinaryEcho(PComVar cv, PCHAR B, int C)
2294 maya 3227 {
2295     int a, i, Len;
2296     char d[3];
2297    
2298     if ( ! cv->Ready )
2299     return C;
2300    
2301 doda 8445 PackInBuff(cv);
2302 maya 3227
2303     i = 0;
2304     a = 1;
2305     while ((a>0) && (i<C)) {
2306     Len = 0;
2307    
2308     d[Len] = B[i];
2309     Len++;
2310    
2311     if ( cv->TelFlag && (