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