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