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 9197 - (hide annotations) (download) (as text)
Sat Mar 13 14:42:48 2021 UTC (3 years ago) by zmatsuo
File MIME type: text/x-csrc
File size: 61686 byte(s) 
comポートの列挙、情報取得を一か所にまとめた

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