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