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