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