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 7412 - (hide annotations) (download) (as text)
Mon Jan 28 13:33:57 2019 UTC (5 years, 2 months ago) by zmatsuo
File MIME type: text/x-csrc
File size: 62312 byte(s) 
htmlhelpで、hhctrl.ocxを参照するようにした
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 doda 3442 static int OutputTextUTF8(WORD K, char *TempStr, PComVar cv)
1586 maya 3227 {
1587     unsigned int code;
1588 doda 3442 int outlen;
1589     int TempLen = 0;
1590 maya 3227
1591 zmatsuo 7406 code = SJIS2UTF8(K, &outlen, *cv->CodePage);
1592 doda 3442 switch (outlen) {
1593 doda 3457 case 4:
1594     TempStr[TempLen++] = (code >> 24) & 0xff;
1595 doda 3442 case 3:
1596 maya 3227 TempStr[TempLen++] = (code >> 16) & 0xff;
1597 doda 3442 case 2:
1598 maya 3227 TempStr[TempLen++] = (code >> 8) & 0xff;
1599 doda 3442 case 1:
1600 maya 3227 TempStr[TempLen++] = code & 0xff;
1601     }
1602    
1603 doda 3442 return TempLen;
1604 maya 3227 }
1605    
1606 doda 6435 //
1607 doda 3451 // MBCS�����e�������R�[�h�����������o�������B
1608 maya 3227 //
1609 zmatsuo 7411 static int TextOutMBCS(PComVar cv, PCHAR B, int C)
1610 maya 3227 {
1611 doda 3494 int i, TempLen, OutLen;
1612 maya 3227 WORD K;
1613 doda 3442 char TempStr[12];
1614 maya 3227 int SendCodeNew;
1615     BYTE d;
1616     BOOL Full, KanjiFlagNew;
1617    
1618     Full = FALSE;
1619     i = 0;
1620     while (! Full && (i < C)) {
1621     TempLen = 0;
1622     d = (BYTE)B[i];
1623     SendCodeNew = cv->SendCode;
1624 doda 3442 KanjiFlagNew = FALSE;
1625 maya 3227
1626     if (cv->SendKanjiFlag) {
1627     SendCodeNew = IdKanji;
1628    
1629     K = (cv->SendKanjiFirst << 8) + d;
1630    
1631     // UTF-8�����������s���B1�`3�o�C�g���������������������B
1632 doda 3408 if (cv->KanjiCodeSend == IdUTF8 || cv->Language == IdUtf8) {
1633 doda 3442 TempLen += OutputTextUTF8(K, TempStr, cv);
1634     }
1635     else {
1636     switch (cv->Language) {
1637     case IdJapanese:
1638 doda 6435 switch (cv->KanjiCodeSend) {
1639 doda 3442 case IdEUC:
1640 doda 3419 K = SJIS2EUC(K);
1641 doda 3442 break;
1642     case IdJIS:
1643 doda 3419 K = SJIS2JIS(K);
1644 doda 3442 if ((cv->SendCode==IdKatakana) &&
1645     (cv->JIS7KatakanaSend==1)) {
1646     TempStr[TempLen++] = SI;
1647     }
1648     break;
1649     case IdSJIS:
1650     /* nothing to do */
1651     break;
1652 doda 3419 }
1653 doda 3442 break;
1654     case IdKorean:
1655 doda 6435 break;
1656 maya 3227 }
1657 doda 3442 TempStr[TempLen++] = HIBYTE(K);
1658     TempStr[TempLen++] = LOBYTE(K);
1659 maya 3227 }
1660     }
1661 doda 3932 else if (_isleadbyte_l(d, cv->locale)) {
1662 maya 3227 KanjiFlagNew = TRUE;
1663     cv->SendKanjiFirst = d;
1664     SendCodeNew = IdKanji;
1665    
1666 doda 3442 if (cv->Language == IdJapanese) {
1667     if ((cv->SendCode!=IdKanji) && (cv->KanjiCodeSend==IdJIS)) {
1668     TempStr[0] = 0x1B;
1669     TempStr[1] = '$';
1670     if (cv->KanjiIn == IdKanjiInB) {
1671     TempStr[2] = 'B';
1672     }
1673     else {
1674     TempStr[2] = '@';
1675     }
1676     TempLen = 3;
1677 maya 3392 }
1678 maya 3227 }
1679     }
1680     else {
1681 doda 3442 if (cv->Language == IdJapanese) {
1682     if ((cv->SendCode==IdKanji) && (cv->KanjiCodeSend==IdJIS)) {
1683     TempStr[0] = 0x1B;
1684     TempStr[1] = '(';
1685     switch (cv->KanjiOut) {
1686     case IdKanjiOutJ:
1687 maya 3409 TempStr[2] = 'J';
1688     break;
1689 doda 3442 case IdKanjiOutH:
1690 maya 3409 TempStr[2] = 'H';
1691     break;
1692 doda 3442 default:
1693 maya 3409 TempStr[2] = 'B';
1694 doda 3442 }
1695     TempLen = 3;
1696 maya 3227 }
1697    
1698 doda 3442 if ((0xa0<d) && (d<0xe0)) {
1699     SendCodeNew = IdKatakana;
1700     if ((cv->SendCode!=IdKatakana) &&
1701     (cv->KanjiCodeSend==IdJIS) &&
1702     (cv->JIS7KatakanaSend==1)) {
1703     TempStr[TempLen++] = SO;
1704     }
1705 maya 3227 }
1706 doda 3442 else {
1707     SendCodeNew = IdASCII;
1708     if ((cv->SendCode==IdKatakana) &&
1709     (cv->KanjiCodeSend==IdJIS) &&
1710     (cv->JIS7KatakanaSend==1)) {
1711     TempStr[TempLen++] = SI;
1712     }
1713 maya 3227 }
1714     }
1715    
1716 doda 3497 if (d==CR) {
1717 doda 3442 TempStr[TempLen++] = 0x0d;
1718 maya 3227 if (cv->CRSend==IdCRLF) {
1719 doda 3442 TempStr[TempLen++] = 0x0a;
1720 maya 3227 }
1721     else if ((cv->CRSend==IdCR) &&
1722 doda 3398 cv->TelFlag && ! cv->TelBinSend) {
1723 doda 3442 TempStr[TempLen++] = 0;
1724 maya 3227 }
1725 maya 6369 else if (cv->CRSend == IdLF) {
1726     TempStr[TempLen-1] = 0x0a;
1727     }
1728 doda 3494 if (cv->TelLineMode) {
1729     cv->Flush = TRUE;
1730     }
1731 maya 3227 }
1732 doda 3497 else if (d==BS) {
1733     if (cv->TelLineMode) {
1734     if (cv->FlushLen < cv->LineModeBuffCount) {
1735     cv->LineModeBuffCount--;
1736     }
1737     }
1738 maya 6369 else {
1739 doda 3497 TempStr[TempLen++] = d;
1740     }
1741     }
1742 doda 3498 else if (d==0x15) { // Ctrl-U
1743     if (cv->TelLineMode) {
1744     cv->LineModeBuffCount = cv->FlushLen;
1745     }
1746 maya 6369 else {
1747 doda 3498 TempStr[TempLen++] = d;
1748     }
1749     }
1750 doda 3442 else if ((d>=0x80) && (cv->KanjiCodeSend==IdUTF8 || cv->Language==IdUtf8)) {
1751     TempLen += OutputTextUTF8((WORD)d, TempStr, cv);
1752     }
1753     else if ((d>=0xa1) && (d<=0xe0) && (cv->Language == IdJapanese)) {
1754 doda 3452 /* Katakana */
1755 maya 3227 if (cv->KanjiCodeSend==IdEUC) {
1756 doda 3444 TempStr[TempLen++] = (char)SS2;
1757 maya 3227 }
1758     if ((cv->KanjiCodeSend==IdJIS) &&
1759 maya 3392 (cv->JIS7KatakanaSend==1)) {
1760 doda 3442 TempStr[TempLen++] = d & 0x7f;
1761 maya 3392 }
1762     else {
1763 doda 3442 TempStr[TempLen++] = d;
1764 maya 3392 }
1765 maya 3227 }
1766     else {
1767 doda 3442 TempStr[TempLen++] = d;
1768 maya 3227 if (cv->TelFlag && (d==0xff)) {
1769 doda 3442 TempStr[TempLen++] = (char)0xff;
1770 maya 3227 }
1771     }
1772     } // if (cv->SendKanjiFlag) else if ... else ... end
1773    
1774 doda 3494 if (cv->TelLineMode) {
1775     if (TempLen == 0) {
1776     i++;
1777     cv->SendCode = SendCodeNew;
1778     cv->SendKanjiFlag = KanjiFlagNew;
1779     }
1780     else {
1781     Full = OutBuffSize - cv->LineModeBuffCount - TempLen < 0;
1782     if (!Full) {
1783     i++;
1784     cv->SendCode = SendCodeNew;
1785     cv->SendKanjiFlag = KanjiFlagNew;
1786     memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), TempStr, TempLen);
1787     cv->LineModeBuffCount += TempLen;
1788     if (cv->Flush) {
1789     cv->FlushLen = cv->LineModeBuffCount;
1790     }
1791     }
1792     }
1793     if (cv->FlushLen > 0) {
1794     OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
1795     cv->FlushLen -= OutLen;
1796     cv->LineModeBuffCount -= OutLen;
1797     memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
1798     }
1799     cv->Flush = FALSE;
1800 maya 3227 }
1801     else {
1802 doda 3494 if (TempLen == 0) {
1803 maya 3227 i++;
1804     cv->SendCode = SendCodeNew;
1805     cv->SendKanjiFlag = KanjiFlagNew;
1806     }
1807 doda 3494 else {
1808     Full = OutBuffSize-cv->OutBuffCount-TempLen < 0;
1809     if (! Full) {
1810     i++;
1811     cv->SendCode = SendCodeNew;
1812     cv->SendKanjiFlag = KanjiFlagNew;
1813     CommRawOut(cv,TempStr,TempLen);
1814     }
1815     }
1816 maya 3227 }
1817    
1818     } // end of "while {}"
1819    
1820     return i;
1821     }
1822    
1823 zmatsuo 7305 int WINAPI CommTextOut(PComVar cv, PCHAR B, int C)
1824 maya 3227 {
1825 doda 3494 int i, TempLen, OutLen;
1826 doda 3442 char TempStr[12];
1827 maya 3227 BYTE d;
1828     BOOL Full;
1829    
1830 maya 3392 if (! cv->Ready ) {
1831 maya 3227 return C;
1832 maya 3392 }
1833 maya 3227
1834 maya 4009 switch (cv->Language) {
1835     case IdUtf8:
1836     case IdJapanese:
1837     case IdKorean:
1838     return TextOutMBCS(cv, B, C);
1839     break;
1840 maya 3392 }
1841 maya 3227
1842     Full = FALSE;
1843     i = 0;
1844     while (! Full && (i < C)) {
1845     TempLen = 0;
1846     d = (BYTE)B[i];
1847 doda 6435
1848 doda 3497 switch (d) {
1849     case CR:
1850 maya 3227 TempStr[TempLen] = 0x0d;
1851     TempLen++;
1852     if (cv->CRSend==IdCRLF) {
1853 doda 3452 TempStr[TempLen++] = 0x0a;
1854 maya 3227 }
1855 doda 3452 else if (cv->CRSend==IdCR && cv->TelFlag && ! cv->TelBinSend) {
1856     TempStr[TempLen++] = 0;
1857 maya 3227 }
1858 maya 6369 else if (cv->CRSend == IdLF) {
1859     TempStr[TempLen-1] = 0x0a;
1860     }
1861 doda 3494 if (cv->TelLineMode) {
1862     cv->Flush = TRUE;
1863     }
1864 doda 3497 break;
1865    
1866     case BS:
1867     if (cv->TelLineMode) {
1868     if (cv->FlushLen < cv->LineModeBuffCount) {
1869     cv->LineModeBuffCount--;
1870     }
1871     }
1872 doda 6435 else {
1873 doda 3497 TempStr[TempLen++] = d;
1874     }
1875     break;
1876    
1877 doda 3498 case 0x15: // Ctrl-U
1878     if (cv->TelLineMode) {
1879     cv->LineModeBuffCount = cv->FlushLen;
1880     }
1881     else {
1882     TempStr[TempLen++] = d;
1883     }
1884 doda 3504 break;
1885 doda 3498
1886 doda 3497 default:
1887 doda 3452 if ((cv->Language==IdRussian) && (d>=128)) {
1888 doda 3494 d = RussConv(cv->RussClient, cv->RussHost, d);
1889 doda 3452 }
1890     TempStr[TempLen++] = d;
1891 maya 3227 if (cv->TelFlag && (d==0xff)) {
1892 doda 3452 TempStr[TempLen++] = (char)0xff;
1893 maya 3227 }
1894     }
1895    
1896 doda 3494 if (cv->TelLineMode) {
1897     Full = OutBuffSize - cv->LineModeBuffCount - TempLen < 0;
1898     if (!Full) {
1899 doda 3888 i++;
1900 doda 3494 memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), TempStr, TempLen);
1901     cv->LineModeBuffCount += TempLen;
1902     if (cv->Flush) {
1903     cv->FlushLen = cv->LineModeBuffCount;
1904     }
1905     }
1906     if (cv->FlushLen > 0) {
1907     OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
1908     cv->FlushLen -= OutLen;
1909     cv->LineModeBuffCount -= OutLen;
1910     memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
1911     }
1912     cv->Flush = FALSE;
1913 maya 3227 }
1914 doda 3494 else {
1915     Full = OutBuffSize - cv->OutBuffCount - TempLen < 0;
1916     if (! Full) {
1917     i++;
1918     CommRawOut(cv,TempStr,TempLen);
1919     }
1920     }
1921 maya 3227 } // end of while {}
1922    
1923     return i;
1924     }
1925    
1926 zmatsuo 7305 int WINAPI CommBinaryEcho(PComVar cv, PCHAR B, int C)
1927 maya 3227 {
1928     int a, i, Len;
1929     char d[3];
1930    
1931     if ( ! cv->Ready )
1932     return C;
1933    
1934     if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
1935     memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
1936     cv->InPtr = 0;
1937     }
1938    
1939     i = 0;
1940     a = 1;
1941     while ((a>0) && (i<C)) {
1942     Len = 0;
1943    
1944     d[Len] = B[i];
1945     Len++;
1946    
1947     if ( cv->TelFlag && (B[i]=='\x0d') &&
1948     ! cv->TelBinSend ) {
1949     d[Len] = 0x00;
1950     Len++;
1951     }
1952    
1953     if ( cv->TelFlag && (B[i]=='\xff') ) {
1954     d[Len] = '\xff';
1955     Len++;
1956     }
1957    
1958     if ( InBuffSize-cv->InBuffCount-Len >=0 ) {
1959     memcpy(&(cv->InBuff[cv->InBuffCount]),d,Len);
1960     cv->InBuffCount = cv->InBuffCount + Len;
1961     a = 1;
1962     }
1963     else
1964     a = 0;
1965     i = i + a;
1966     }
1967     return i;
1968     }
1969    
1970 zmatsuo 7411 static int WINAPI TextEchoMBCS(PComVar cv, PCHAR B, int C)
1971 maya 3227 {
1972     int i, TempLen;
1973     WORD K;
1974 doda 3452 char TempStr[12];
1975 maya 3227 int EchoCodeNew;
1976     BYTE d;
1977     BOOL Full, KanjiFlagNew;
1978    
1979     Full = FALSE;
1980     i = 0;
1981     while (! Full && (i < C)) {
1982     TempLen = 0;
1983     d = (BYTE)B[i];
1984     EchoCodeNew = cv->EchoCode;
1985 doda 3452 KanjiFlagNew = FALSE;
1986 maya 3227
1987     if (cv->EchoKanjiFlag) {
1988     EchoCodeNew = IdKanji;
1989    
1990     K = (cv->EchoKanjiFirst << 8) + d;
1991 doda 3452
1992 maya 3227 // UTF-8�����������s���B1�`3�o�C�g���������������������B
1993 doda 3452 if (cv->KanjiCodeEcho == IdUTF8 || cv->Language==IdUtf8) {
1994 doda 3442 TempLen += OutputTextUTF8(K, TempStr, cv);
1995 maya 3227 }
1996     else {
1997 doda 3452 switch (cv->Language) {
1998     case IdJapanese:
1999     switch (cv->KanjiCodeEcho) {
2000     case IdEUC:
2001     K = SJIS2EUC(K);
2002     break;
2003     case IdJIS:
2004     K = SJIS2JIS(K);
2005     if ((cv->EchoCode==IdKatakana) &&
2006     (cv->JIS7KatakanaEcho==1)) {
2007     TempStr[TempLen++] = SI;
2008     }
2009     break;
2010     case IdSJIS:
2011     /* nothing to do */
2012     break;
2013     }
2014     break;
2015     case IdKorean:
2016     break;
2017 maya 3392 }
2018 doda 3452 TempStr[TempLen++] = HIBYTE(K);
2019     TempStr[TempLen++] = LOBYTE(K);
2020 maya 3227 }
2021     }
2022 doda 3932 else if (_isleadbyte_l(d, cv->locale)) {
2023 maya 3227 KanjiFlagNew = TRUE;
2024     cv->EchoKanjiFirst = d;
2025     EchoCodeNew = IdKanji;
2026    
2027 doda 3452 if (cv->Language == IdJapanese) {
2028     if ((cv->EchoCode!=IdKanji) && (cv->KanjiCodeEcho==IdJIS)) {
2029     TempStr[0] = 0x1B;
2030     TempStr[1] = '$';
2031     if (cv->KanjiIn == IdKanjiInB) {
2032     TempStr[2] = 'B';
2033     }
2034     else {
2035     TempStr[2] = '@';
2036     }
2037     TempLen = 3;
2038 maya 3392 }
2039 maya 3227 }
2040     }
2041     else {
2042 doda 3452 if (cv->Language == IdJapanese) {
2043     if ((cv->EchoCode==IdKanji) && (cv->KanjiCodeEcho==IdJIS)) {
2044     TempStr[0] = 0x1B;
2045     TempStr[1] = '(';
2046     switch (cv->KanjiOut) {
2047     case IdKanjiOutJ:
2048 maya 3227 TempStr[2] = 'J';
2049     break;
2050 doda 3452 case IdKanjiOutH:
2051 maya 3227 TempStr[2] = 'H';
2052     break;
2053 doda 3452 default:
2054 maya 3227 TempStr[2] = 'B';
2055 doda 3452 }
2056     TempLen = 3;
2057 maya 3227 }
2058    
2059 doda 3452 if ((0xa0<d) && (d<0xe0)) {
2060     EchoCodeNew = IdKatakana;
2061     if ((cv->EchoCode!=IdKatakana) &&
2062     (cv->KanjiCodeEcho==IdJIS) &&
2063     (cv->JIS7KatakanaEcho==1)) {
2064     TempStr[TempLen++] = SO;
2065     }
2066 maya 3227 }
2067 doda 3452 else {
2068     EchoCodeNew = IdASCII;
2069     if ((cv->EchoCode==IdKatakana) &&
2070     (cv->KanjiCodeEcho==IdJIS) &&
2071     (cv->JIS7KatakanaEcho==1)) {
2072     TempStr[TempLen++] = SI;
2073     }
2074 maya 3227 }
2075     }
2076    
2077 doda 3503 if (d==CR) {
2078 doda 3452 TempStr[TempLen++] = 0x0d;
2079 maya 3227 if (cv->CRSend==IdCRLF) {
2080 doda 3452 TempStr[TempLen++] = 0x0a;
2081 maya 3227 }
2082     else if ((cv->CRSend==IdCR) &&
2083 maya 3392 cv->TelFlag && ! cv->TelBinSend) {
2084 doda 3452 TempStr[TempLen++] = 0;
2085 maya 3227 }
2086 maya 6369 else if (cv->CRSend == IdLF) {
2087     TempStr[TempLen-1] = 0x0a;
2088     }
2089 maya 3227 }
2090 doda 3503 else if (d==0x15) { // Ctrl-U
2091     if (cv->TelLineMode) {
2092     // Move to top of line (CHA "\033[G") and erase line (EL "\033[K")
2093     strncpy_s(TempStr, sizeof(TempStr), "\033[G\033[K", _TRUNCATE);
2094     TempLen += 6;
2095     }
2096     else {
2097     TempStr[TempLen++] = d;
2098     }
2099     }
2100 doda 3452 else if ((d>=0x80) && (cv->KanjiCodeEcho==IdUTF8 || cv->Language==IdUtf8)) {
2101     TempLen += OutputTextUTF8((WORD)d, TempStr, cv);
2102     }
2103     else if ((d>=0xa1) && (d<=0xe0) && (cv->Language == IdJapanese)) {
2104 maya 3227 /* Katakana */
2105     if (cv->KanjiCodeEcho==IdEUC) {
2106 doda 3452 TempStr[TempLen++] = (char)SS2;
2107 maya 3227 }
2108     if ((cv->KanjiCodeEcho==IdJIS) &&
2109 maya 3392 (cv->JIS7KatakanaEcho==1)) {
2110 doda 3452 TempStr[TempLen++] = d & 0x7f;
2111 maya 3392 }
2112     else {
2113 doda 3452 TempStr[TempLen++] = d;
2114 maya 3392 }
2115 maya 3227 }
2116     else {
2117 doda 3452 TempStr[TempLen++] = d;
2118 maya 3227 if (cv->TelFlag && (d==0xff)) {
2119 doda 3452 TempStr[TempLen++] = (char)0xff;
2120 maya 3227 }
2121     }
2122 doda 3452 } // if (cv->EchoKanjiFlag) else if ... else ... end
2123 maya 3227
2124     if (TempLen == 0) {
2125     i++;
2126     cv->EchoCode = EchoCodeNew;
2127     cv->EchoKanjiFlag = KanjiFlagNew;
2128     }
2129     else {
2130     Full = InBuffSize-cv->InBuffCount-TempLen < 0;
2131     if (! Full) {
2132     i++;
2133     cv->EchoCode = EchoCodeNew;
2134     cv->EchoKanjiFlag = KanjiFlagNew;
2135     memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
2136     cv->InBuffCount = cv->InBuffCount + TempLen;
2137     }
2138     }
2139    
2140     } // end of "while {}"
2141    
2142     return i;
2143     }
2144    
2145 zmatsuo 7305 int WINAPI CommTextEcho(PComVar cv, PCHAR B, int C)
2146 maya 3227 {
2147     int i, TempLen;
2148     char TempStr[11];
2149     BYTE d;
2150     BOOL Full;
2151    
2152 maya 3392 if ( ! cv->Ready ) {
2153 maya 3227 return C;
2154 maya 3392 }
2155 maya 3227
2156     if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
2157     memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
2158     cv->InPtr = 0;
2159     }
2160    
2161 doda 3452 switch (cv->Language) {
2162     case IdUtf8:
2163     case IdJapanese:
2164     case IdKorean:
2165 doda 3458 return TextEchoMBCS(cv,B,C);
2166 doda 3452 break;
2167 doda 3438 }
2168 maya 3227
2169     Full = FALSE;
2170     i = 0;
2171     while (! Full && (i < C)) {
2172     TempLen = 0;
2173     d = (BYTE)B[i];
2174    
2175 doda 3503 switch (d) {
2176     case CR:
2177 maya 3227 TempStr[TempLen] = 0x0d;
2178     TempLen++;
2179     if (cv->CRSend==IdCRLF) {
2180 doda 3452 TempStr[TempLen++] = 0x0a;
2181 maya 3227 }
2182 doda 3452 else if (cv->CRSend==IdCR && cv->TelFlag && ! cv->TelBinSend) {
2183     TempStr[TempLen++] = 0;
2184 maya 3227 }
2185 maya 6369 else if (cv->CRSend == IdLF) {
2186     TempStr[TempLen-1] = 0x0a;
2187     }
2188 doda 3503 break;
2189 doda 6435
2190 doda 3503 case 0x15: // Ctrl-U
2191     if (cv->TelLineMode) {
2192     // Move to top of line (CHA "\033[G") and erase line (EL "\033[K")
2193     strncpy_s(TempStr, sizeof(TempStr), "\033[G\033[K", _TRUNCATE);
2194     TempLen += 6;
2195     }
2196     else {
2197     TempStr[TempLen++] = d;
2198     }
2199     break;
2200    
2201     default:
2202 doda 3452 if ((cv->Language==IdRussian) && (d>=128)) {
2203 maya 3227 d = RussConv(cv->RussClient,cv->RussHost,d);
2204 maya 3392 }
2205 doda 3452 TempStr[TempLen++] = d;
2206 maya 3227 if (cv->TelFlag && (d==0xff)) {
2207 doda 3452 TempStr[TempLen++] = (char)0xff;
2208 maya 3227 }
2209     }
2210    
2211     Full = InBuffSize-cv->InBuffCount-TempLen < 0;
2212     if (! Full) {
2213     i++;
2214     memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
2215     cv->InBuffCount = cv->InBuffCount + TempLen;
2216     }
2217     } // end of while {}
2218    
2219     return i;
2220     }
2221    
2222 doda 6435 // listup serial port driver
2223 maya 3227 // cf. http://www.codeproject.com/system/setupdi.asp?df=100&forumid=4368&exp=0&select=479661
2224     // (2007.8.17 yutaka)
2225     static void ListupSerialPort(LPWORD ComPortTable, int comports, char **ComPortDesc, int ComPortMax)
2226     {
2227     GUID ClassGuid[1];
2228     DWORD dwRequiredSize;
2229     BOOL bRet;
2230     HDEVINFO DeviceInfoSet = NULL;
2231     SP_DEVINFO_DATA DeviceInfoData;
2232     DWORD dwMemberIndex = 0;
2233     int i;
2234    
2235     DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
2236    
2237     // ���O�����������t���[��������
2238     for (i = 0 ; i < ComPortMax ; i++) {
2239     free(ComPortDesc[i]);
2240     ComPortDesc[i] = NULL;
2241     }
2242    
2243     // Get ClassGuid from ClassName for PORTS class
2244     bRet =
2245     SetupDiClassGuidsFromName(_T("PORTS"), (LPGUID) & ClassGuid, 1,
2246     &dwRequiredSize);
2247 maya 3392 if (!bRet) {
2248 maya 3227 goto cleanup;
2249 maya 3392 }
2250 maya 3227
2251     // Get class devices
2252     // COM�|�[�g�����������t�����������������A�������������������A���W�X�g�����c��������
2253     // ����FriendlyName���\���������������������������B(2007.11.8 yutaka)
2254     DeviceInfoSet =
2255     SetupDiGetClassDevs(&ClassGuid[0], NULL, NULL, DIGCF_PRESENT | DIGCF_PROFILE);
2256    
2257     if (DeviceInfoSet) {
2258     // Enumerate devices
2259     dwMemberIndex = 0;
2260     while (SetupDiEnumDeviceInfo
2261 maya 3392 (DeviceInfoSet, dwMemberIndex++, &DeviceInfoData)) {
2262 maya 3227 TCHAR szFriendlyName[MAX_PATH];
2263     TCHAR szPortName[MAX_PATH];
2264     //TCHAR szMessage[MAX_PATH];
2265     DWORD dwReqSize = 0;
2266     DWORD dwPropType;
2267     DWORD dwType = REG_SZ;
2268     HKEY hKey = NULL;
2269    
2270     // Get friendlyname
2271     bRet = SetupDiGetDeviceRegistryProperty(DeviceInfoSet,
2272     &DeviceInfoData,
2273     SPDRP_FRIENDLYNAME,
2274     &dwPropType,
2275     (LPBYTE)
2276     szFriendlyName,
2277     sizeof(szFriendlyName),
2278