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 9129 - (hide annotations) (download) (as text)
Sat Jan 16 05:21:37 2021 UTC (3 years, 2 months ago) by zmatsuo
File MIME type: text/x-csrc
File size: 67927 byte(s) 
VS2005 による Windows 95 のサポート方法を変更

- 各々のソースファイル内の Windows 95 サポート用コードを不要にする
  - ファイルのinclude + 関数呼出をやめる
    - #include "compat_w95.h" を削除
    - DoCover_IsDebuggerPresent() 呼び出しを削除
  - 代わりにファイル(common/compat_w95_vs2005.c)をリンク
- VSプロジェクトファイル
  - プロジェクトから compat_w95.h を削除
  - VS2005プロジェクトに compat_w95_vs2005.c を追加
    - VS2005以外では Windows 95 で動作するバイナリが生成できないので追加は不要
- cmake
  - SUPPORT_OLD_WINDOWS=ON 時、compat_w95_vs2005.c をリンクするよう修正
  - なるべく target_* を使用するよう修正
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 doda 6435 //
1630 doda 3451 // MBCS�����e�������R�[�h�����������o�������B
1631 maya 3227 //
1632 zmatsuo 7411 static int TextOutMBCS(PComVar cv, PCHAR B, int C)
1633 maya 3227 {
1634 doda 8445 int i, TempLen;
1635 maya 3227 WORD K;
1636 doda 3442 char TempStr[12];
1637 maya 3227 BYTE d;
1638 doda 8445 BOOL Full;
1639     int SendCodeNew; // ���M�R�[�h
1640     BOOL KanjiFlagNew; // TRUE=����������������������������
1641 maya 3227
1642     Full = FALSE;
1643     i = 0;
1644     while (! Full && (i < C)) {
1645     TempLen = 0;
1646     d = (BYTE)B[i];
1647     SendCodeNew = cv->SendCode;
1648 doda 3442 KanjiFlagNew = FALSE;
1649 maya 3227
1650     if (cv->SendKanjiFlag) {
1651     SendCodeNew = IdKanji;
1652    
1653     K = (cv->SendKanjiFirst << 8) + d;
1654    
1655     // UTF-8�����������s���B1�`3�o�C�g���������������������B
1656 doda 3408 if (cv->KanjiCodeSend == IdUTF8 || cv->Language == IdUtf8) {
1657 doda 3442 TempLen += OutputTextUTF8(K, TempStr, cv);
1658     }
1659     else {
1660     switch (cv->Language) {
1661     case IdJapanese:
1662 doda 6435 switch (cv->KanjiCodeSend) {
1663 doda 3442 case IdEUC:
1664 doda 3419 K = SJIS2EUC(K);
1665 doda 3442 break;
1666     case IdJIS:
1667 doda 3419 K = SJIS2JIS(K);
1668 doda 3442 if ((cv->SendCode==IdKatakana) &&
1669     (cv->JIS7KatakanaSend==1)) {
1670     TempStr[TempLen++] = SI;
1671     }
1672     break;
1673     case IdSJIS:
1674     /* nothing to do */
1675     break;
1676 doda 3419 }
1677 doda 3442 break;
1678     case IdKorean:
1679 doda 6435 break;
1680 maya 3227 }
1681 doda 3442 TempStr[TempLen++] = HIBYTE(K);
1682     TempStr[TempLen++] = LOBYTE(K);
1683 maya 3227 }
1684     }
1685 doda 3932 else if (_isleadbyte_l(d, cv->locale)) {
1686 maya 3227 KanjiFlagNew = TRUE;
1687     cv->SendKanjiFirst = d;
1688     SendCodeNew = IdKanji;
1689    
1690 doda 3442 if (cv->Language == IdJapanese) {
1691     if ((cv->SendCode!=IdKanji) && (cv->KanjiCodeSend==IdJIS)) {
1692     TempStr[0] = 0x1B;
1693     TempStr[1] = '$';
1694     if (cv->KanjiIn == IdKanjiInB) {
1695     TempStr[2] = 'B';
1696     }
1697     else {
1698     TempStr[2] = '@';
1699     }
1700     TempLen = 3;
1701 maya 3392 }
1702 maya 3227 }
1703     }
1704     else {
1705 doda 3442 if (cv->Language == IdJapanese) {
1706     if ((cv->SendCode==IdKanji) && (cv->KanjiCodeSend==IdJIS)) {
1707     TempStr[0] = 0x1B;
1708     TempStr[1] = '(';
1709     switch (cv->KanjiOut) {
1710     case IdKanjiOutJ:
1711 maya 3409 TempStr[2] = 'J';
1712     break;
1713 doda 3442 case IdKanjiOutH:
1714 maya 3409 TempStr[2] = 'H';
1715     break;
1716 doda 3442 default:
1717 maya 3409 TempStr[2] = 'B';
1718 doda 3442 }
1719     TempLen = 3;
1720 maya 3227 }
1721    
1722 doda 3442 if ((0xa0<d) && (d<0xe0)) {
1723     SendCodeNew = IdKatakana;
1724     if ((cv->SendCode!=IdKatakana) &&
1725     (cv->KanjiCodeSend==IdJIS) &&
1726     (cv->JIS7KatakanaSend==1)) {
1727     TempStr[TempLen++] = SO;
1728     }
1729 maya 3227 }
1730 doda 3442 else {
1731     SendCodeNew = IdASCII;
1732     if ((cv->SendCode==IdKatakana) &&
1733     (cv->KanjiCodeSend==IdJIS) &&
1734     (cv->JIS7KatakanaSend==1)) {
1735     TempStr[TempLen++] = SI;
1736     }
1737 maya 3227 }
1738     }
1739    
1740 doda 3497 if (d==CR) {
1741 doda 3442 TempStr[TempLen++] = 0x0d;
1742 maya 3227 if (cv->CRSend==IdCRLF) {
1743 doda 3442 TempStr[TempLen++] = 0x0a;
1744 maya 3227 }
1745     else if ((cv->CRSend==IdCR) &&
1746 doda 3398 cv->TelFlag && ! cv->TelBinSend) {
1747 doda 3442 TempStr[TempLen++] = 0;
1748 maya 3227 }
1749 maya 6369 else if (cv->CRSend == IdLF) {
1750     TempStr[TempLen-1] = 0x0a;
1751     }
1752 doda 3494 if (cv->TelLineMode) {
1753     cv->Flush = TRUE;
1754     }
1755 maya 3227 }
1756 doda 3497 else if (d==BS) {
1757     if (cv->TelLineMode) {
1758     if (cv->FlushLen < cv->LineModeBuffCount) {
1759     cv->LineModeBuffCount--;
1760     }
1761     }
1762 maya 6369 else {
1763 doda 3497 TempStr[TempLen++] = d;
1764     }
1765     }
1766 doda 3498 else if (d==0x15) { // Ctrl-U
1767     if (cv->TelLineMode) {
1768     cv->LineModeBuffCount = cv->FlushLen;
1769     }
1770 maya 6369 else {
1771 doda 3498 TempStr[TempLen++] = d;
1772     }
1773     }
1774 doda 3442 else if ((d>=0x80) && (cv->KanjiCodeSend==IdUTF8 || cv->Language==IdUtf8)) {
1775     TempLen += OutputTextUTF8((WORD)d, TempStr, cv);
1776     }
1777     else if ((d>=0xa1) && (d<=0xe0) && (cv->Language == IdJapanese)) {
1778 doda 3452 /* Katakana */
1779 maya 3227 if (cv->KanjiCodeSend==IdEUC) {
1780 doda 3444 TempStr[TempLen++] = (char)SS2;
1781 maya 3227 }
1782     if ((cv->KanjiCodeSend==IdJIS) &&
1783 maya 3392 (cv->JIS7KatakanaSend==1)) {
1784 doda 3442 TempStr[TempLen++] = d & 0x7f;
1785 maya 3392 }
1786     else {
1787 doda 3442 TempStr[TempLen++] = d;
1788 maya 3392 }
1789 maya 3227 }
1790     else {
1791 doda 3442 TempStr[TempLen++] = d;
1792 maya 3227 if (cv->TelFlag && (d==0xff)) {
1793 doda 3442 TempStr[TempLen++] = (char)0xff;
1794 maya 3227 }
1795     }
1796     } // if (cv->SendKanjiFlag) else if ... else ... end
1797    
1798 doda 8445 if (WriteOutBuff(cv, TempStr, TempLen)) {
1799     i++; // 1������������
1800     // ��������������������
1801     cv->SendCode = SendCodeNew;
1802     cv->SendKanjiFlag = KanjiFlagNew;
1803     } else {
1804     Full = TRUE;
1805 maya 3227 }
1806    
1807     } // end of "while {}"
1808    
1809     return i;
1810     }
1811    
1812 zmatsuo 7305 int WINAPI CommTextOut(PComVar cv, PCHAR B, int C)
1813 maya 3227 {
1814 doda 8445 int i, TempLen;
1815 doda 3442 char TempStr[12];
1816 maya 3227 BYTE d;
1817     BOOL Full;
1818    
1819 maya 3392 if (! cv->Ready ) {
1820 maya 3227 return C;
1821 maya 3392 }
1822 maya 3227
1823 maya 4009 switch (cv->Language) {
1824     case IdUtf8:
1825     case IdJapanese:
1826     case IdKorean:
1827     return TextOutMBCS(cv, B, C);
1828     break;
1829 maya 3392 }
1830 maya 3227
1831     Full = FALSE;
1832     i = 0;
1833     while (! Full && (i < C)) {
1834     TempLen = 0;
1835     d = (BYTE)B[i];
1836 doda 6435
1837 doda 3497 switch (d) {
1838     case CR:
1839 maya 3227 TempStr[TempLen] = 0x0d;
1840     TempLen++;
1841     if (cv->CRSend==IdCRLF) {
1842 doda 3452 TempStr[TempLen++] = 0x0a;
1843 maya 3227 }
1844 doda 3452 else if (cv->CRSend==IdCR && cv->TelFlag && ! cv->TelBinSend) {
1845     TempStr[TempLen++] = 0;
1846 maya 3227 }
1847 maya 6369 else if (cv->CRSend == IdLF) {
1848     TempStr[TempLen-1] = 0x0a;
1849     }
1850 doda 3494 if (cv->TelLineMode) {
1851     cv->Flush = TRUE;
1852     }
1853 doda 3497 break;
1854    
1855     case BS:
1856     if (cv->TelLineMode) {
1857     if (cv->FlushLen < cv->LineModeBuffCount) {
1858     cv->LineModeBuffCount--;
1859     }
1860     }
1861 doda 6435 else {
1862 doda 3497 TempStr[TempLen++] = d;
1863     }
1864     break;
1865    
1866 doda 3498 case 0x15: // Ctrl-U
1867     if (cv->TelLineMode) {
1868     cv->LineModeBuffCount = cv->FlushLen;
1869     }
1870     else {
1871     TempStr[TempLen++] = d;
1872     }
1873 doda 3504 break;
1874 doda 3498
1875 doda 3497 default:
1876 doda 3452 if ((cv->Language==IdRussian) && (d>=128)) {
1877 doda 3494 d = RussConv(cv->RussClient, cv->RussHost, d);
1878 doda 3452 }
1879     TempStr[TempLen++] = d;
1880 maya 3227 if (cv->TelFlag && (d==0xff)) {
1881 doda 3452 TempStr[TempLen++] = (char)0xff;
1882 maya 3227 }
1883     }
1884    
1885 doda 8445 if (WriteOutBuff(cv, TempStr, TempLen)) {
1886     i++; // 1������������
1887     } else {
1888     Full = TRUE;
1889     }
1890    
1891     } // end of while {}
1892    
1893     return i;
1894     }
1895    
1896     /**
1897     * @retval true ���{�������p�J�^�J�i
1898     * @retval false ������
1899     */
1900     static BOOL IsHalfWidthKatakana(unsigned int u32)
1901     {
1902     // Halfwidth CJK punctuation (U+FF61�`FF64)
1903     // Halfwidth Katakana variants (U+FF65�`FF9F)
1904     return (0xff61 <= u32 && u32 <= 0xff9f);
1905     }
1906    
1907     /**
1908     * �o���p�A TODO echo�p������
1909     * @param cv
1910     * @param u32 ��������
1911     * @param check_only TRUE���������s�����A
1912     * @param TempStr �o��������
1913     * @param StrLen TempStr�����o��������
1914     * @retval �������s����
1915     */
1916     static BOOL OutControl(PComVar cv, unsigned int u32, BOOL check_only, char *TempStr, size_t *StrLen)
1917     {
1918     const wchar_t d = u32;
1919     size_t TempLen = 0;
1920     BOOL retval = FALSE;
1921     if (check_only == TRUE) {
1922     /* �`�F�b�N���� */
1923     if (d == CR || d == BS || d == 0x15/*ctrl-u*/) {
1924     return TRUE;
1925     } else {
1926     return FALSE;
1927     }
1928     }
1929     if (d==CR) {
1930     TempStr[TempLen++] = 0x0d;
1931     if (cv->CRSend==IdCRLF) {
1932     TempStr[TempLen++] = 0x0a;
1933     }
1934     else if ((cv->CRSend ==IdCR) &&
1935     cv->TelFlag && ! cv->TelBinSend) {
1936     TempStr[TempLen++] = 0;
1937     }
1938     else if (cv->CRSend == IdLF) {
1939     TempStr[TempLen-1] = 0x0a;
1940     }
1941 doda 3494 if (cv->TelLineMode) {
1942 doda 8445 cv->Flush = TRUE;
1943     }
1944     retval = TRUE;
1945     }
1946     else if (d== BS) {
1947     if (cv->TelLineMode) {
1948     if (cv->FlushLen < cv->LineModeBuffCount) {
1949     cv->LineModeBuffCount--;
1950     }
1951     }
1952     else {
1953     TempStr[TempLen++] = BS;
1954     }
1955     retval = TRUE;
1956     }
1957     else if (d==0x15) { // ctrl-u
1958     if (cv->TelLineMode) {
1959     cv->LineModeBuffCount = cv->FlushLen;
1960     }
1961     else {
1962     TempStr[TempLen++] = 0x15;
1963     }
1964     retval = TRUE;
1965     }
1966     *StrLen = TempLen;
1967     return retval;
1968     }
1969     static BOOL ControlEcho(PComVar cv, unsigned int u32, BOOL check_only, char *TempStr, size_t *StrLen)
1970     {
1971     const wchar_t d = u32;
1972     size_t TempLen = 0;
1973     BOOL retval = FALSE;
1974     if (check_only == TRUE) {
1975     /* �`�F�b�N���� */
1976     if (d == CR || (d == 0x15/*ctrl-u*/ && cv->TelLineMode)) {
1977     return TRUE;
1978     } else {
1979     return FALSE;
1980     }
1981     }
1982     if (d==CR) {
1983     TempStr[TempLen++] = 0x0d;
1984     if (cv->CRSend==IdCRLF) {
1985     TempStr[TempLen++] = 0x0a;
1986     }
1987     else if ((cv->CRSend ==IdCR) && cv->TelFlag && ! cv->TelBinSend) {
1988     TempStr[TempLen++] = 0;
1989     }
1990     else if (cv->CRSend == IdLF) {
1991     TempStr[TempLen-1] = 0x0a;
1992     }
1993     retval = TRUE;
1994     }
1995     else if (d==0x15/*ctrl-u*/ && cv->TelLineMode) {
1996     // Move to top of line (CHA "\033[G") and erase line (EL "\033[K")
1997     memcpy(TempStr, "\033[G\033[K", 6);
1998     TempLen += 6;
1999     retval = TRUE;
2000     }
2001     *StrLen = TempLen;
2002     return retval;
2003     }
2004    
2005     /**
2006     * �o���p����������������
2007     *
2008     * @retval ��������������
2009     */
2010     typedef struct {
2011     int KanjiCode; // [in]�o�������R�[�h(sjis,jis����)
2012     BOOL (*ControlOut)(PComVar cv, unsigned int u32, BOOL check_only, char *TempStr, size_t *StrLen);
2013     // state�����������K�v�����������R�[�h���g�p
2014     BOOL JIS7Katakana; // [in](Kanji JIS)kana
2015     int SendCode; // [in,out](Kanji JIS)���O�����M�R�[�h Ascii/Kana/Kanji
2016     BOOL KanjiFlag; // [in,out](MBCS)���O��1byte��������������?(2byte������������?)
2017     BYTE KanjiFirst; // [in,out](MBCS)���O��1byte
2018     } OutputCharState;
2019    
2020     /**
2021     * unicode(UTF-16)����unicode(UTF-32)��1���������o����
2022     * �o���f�[�^(TempStr)����������
2023     */
2024     static size_t MakeOutputString(PComVar cv, OutputCharState *states,
2025     const wchar_t *B, int C,
2026     char *TempStr, int *TempLen_)
2027     {
2028     BOOL (*ControlOut)(PComVar cv, unsigned int u32, BOOL check_only, char *TempStr, size_t *StrLen)
2029     = states->ControlOut;
2030     //
2031     int TempLen = 0;
2032     size_t TempLen2;
2033     size_t output_char_count; // ��������������
2034    
2035     // UTF-32 ��1���������o��
2036     unsigned int u32;
2037     size_t u16_len = UTF16ToUTF32(B, C, &u32);
2038     if (u16_len == 0) {
2039     // �f�R�[�h��������? ����������������?
2040     assert(FALSE);
2041     u32 = '?';
2042     u16_len = 1;
2043     }
2044     output_char_count = u16_len;
2045    
2046     // �e���V�t�g����������������
2047     if (u32 < 0x100 || ControlOut(cv, u32, TRUE, NULL, NULL)) {
2048     if (cv->Language == IdJapanese && states->KanjiCode == IdJIS) {
2049     // �����������A���{��,JIS��������
2050     if (cv->SendCode == IdKanji) {
2051     // �����������������A����OUT
2052     TempStr[TempLen++] = 0x1B;
2053     TempStr[TempLen++] = '(';
2054     switch (cv->KanjiOut) {
2055     case IdKanjiOutJ:
2056     TempStr[TempLen++] = 'J';
2057     break;
2058     case IdKanjiOutH:
2059     TempStr[TempLen++] = 'H';
2060     break;
2061     default:
2062     TempStr[TempLen++] = 'B';
2063 doda 3494 }
2064     }
2065 doda 8445
2066     if (states->JIS7Katakana == 1) {
2067     if (cv->SendCode == IdKatakana) {
2068     TempStr[TempLen++] = SO;
2069     }
2070 doda 3494 }
2071 doda 8445
2072     states->SendCode = IdASCII;
2073 maya 3227 }
2074 doda 8445 }
2075    
2076     // 1������������
2077     if (ControlOut(cv, u32, FALSE, TempStr, &TempLen2)) {
2078     // ��������������������
2079     TempLen += TempLen2;
2080     output_char_count = 1;
2081     } else if (cv->Language == IdUtf8 ||
2082     (cv->Language == IdJapanese && states->KanjiCode == IdUTF8) ||
2083     (cv->Language == IdKorean && states->KanjiCode == IdUTF8))
2084     {
2085     // UTF-8 ���o��
2086     size_t utf8_len = sizeof(TempStr);
2087     utf8_len = UTF32ToUTF8(u32, TempStr, utf8_len);
2088     TempLen += utf8_len;
2089     } else if (cv->Language == IdJapanese && *cv->CodePage == 932) {
2090     // ���{��
2091     // ���� CP932(SJIS) ���������������o��
2092     char mb_char[2];
2093     size_t mb_len = sizeof(mb_char);
2094     mb_len = UTF32ToMBCP(u32, 932, mb_char, mb_len);
2095     if (mb_len == 0) {
2096     // SJIS��������������
2097     TempStr[TempLen++] = '?';
2098     } else {
2099     switch (states->KanjiCode) {
2100     case IdEUC:
2101     // TODO ���p�J�i
2102     if (mb_len == 1) {
2103     TempStr[TempLen++] = mb_char[0];
2104     } else {
2105     WORD K;
2106     K = (((WORD)(unsigned char)mb_char[0]) << 8) +
2107     (WORD)(unsigned char)mb_char[1];
2108     K = SJIS2EUC(K);
2109     TempStr[TempLen++] = HIBYTE(K);
2110     TempStr[TempLen++] = LOBYTE(K);
2111     }
2112     break;
2113     case IdJIS:
2114     if (u32 < 0x100) {
2115     // ASCII
2116     TempStr[TempLen++] = mb_char[0];
2117     states->SendCode = IdASCII;
2118     } else if (IsHalfWidthKatakana(u32)) {
2119     // ���p�J�^�J�i
2120     if (states->JIS7Katakana==1) {
2121     if (cv->SendCode != IdKatakana) {
2122     TempStr[TempLen++] = SI;
2123     }
2124     TempStr[TempLen++] = mb_char[0] & 0x7f;
2125     } else {
2126     TempStr[TempLen++] = mb_char[0];
2127     }
2128     states->SendCode = IdKatakana;
2129     } else {
2130     // ����
2131     WORD K;
2132     K = (((WORD)(unsigned char)mb_char[0]) << 8) +
2133     (WORD)(unsigned char)mb_char[1];
2134     K = SJIS2JIS(K);
2135     if (states->SendCode != IdKanji) {
2136     // ����IN
2137     TempStr[TempLen++] = 0x1B;
2138     TempStr[TempLen++] = '$';
2139     if (cv->KanjiIn == IdKanjiInB) {
2140     TempStr[TempLen++] = 'B';
2141     }
2142     else {
2143     TempStr[TempLen++] = '@';
2144     }
2145     states->SendCode = IdKanji;
2146     }
2147     TempStr[TempLen++] = HIBYTE(K);
2148     TempStr[TempLen++] = LOBYTE(K);
2149     }
2150     break;
2151     case IdSJIS:
2152     if (mb_len == 1) {
2153     TempStr[TempLen++] = mb_char[0];
2154     } else {
2155     TempStr[TempLen++] = mb_char[0];
2156     TempStr[TempLen++] = mb_char[1];
2157     }
2158     break;
2159     default:
2160     assert(FALSE);
2161     break;
2162 doda 3494 }
2163     }
2164 doda 8445 } else if (cv->Language == IdRussian) {
2165     /* ����CP1251�����������o�� */
2166     char mb_char[2];
2167     size_t mb_len = sizeof(mb_char);
2168     BYTE b;
2169     mb_len = UTF32ToMBCP(u32, 1251, mb_char, mb_len);
2170     if (mb_len != 1) {
2171     b = '?';
2172     } else {
2173     b = RussConv(IdWindows, cv->RussHost, mb_char[0]);
2174     }
2175     TempStr[TempLen++] = b;
2176     } else if (cv->Language == IdKorean && *cv->CodePage == 51949) {
2177     /* CP51949�����������o�� */
2178     char mb_char[2];
2179     size_t mb_len = sizeof(mb_char);
2180     mb_len = UTF32ToMBCP(u32, 51949, mb_char, mb_len);
2181     if (mb_len == 0) {
2182     TempStr[TempLen++] = '?';
2183     }
2184     else if (mb_len == 1) {
2185     TempStr[TempLen++] = mb_char[0];
2186     } else {
2187     TempStr[TempLen++] = mb_char[0];
2188     TempStr[TempLen++] = mb_char[1];
2189     }
2190     } else if (cv->Language == IdEnglish) {
2191     TempStr[TempLen++] = u32;
2192     } else {
2193     // CodePage������
2194     char mb_char[2];
2195     size_t mb_len = sizeof(mb_char);
2196     mb_len = UTF32ToMBCP(u32, *cv->CodePage, mb_char, mb_len);
2197     if (mb_len == 0) {
2198     TempStr[TempLen++] = '?';
2199     }
2200     else if (mb_len == 1) {
2201     TempStr[TempLen++] = mb_char[0];
2202     } else {
2203     TempStr[TempLen++] = mb_char[0];
2204     TempStr[TempLen++] = mb_char[1];
2205     }
2206     }
2207 maya 3227
2208 doda 8445 *TempLen_ = TempLen;
2209     return output_char_count;
2210 maya 3227 }
2211    
2212 doda 8445
2213     /**
2214     * CommTextOut() �� wchar_t ��
2215     *
2216     * @retval �o��������(wchar_t�P��)
2217     */
2218 zmatsuo 7484 int WINAPI CommTextOutW(PComVar cv, const wchar_t *B, int C)
2219     {
2220 doda 8445 char TempStr[12];
2221     BOOL Full = FALSE;
2222     int i = 0;
2223     while (! Full && (i < C)) {
2224     // �o���p�f�[�^������
2225     int TempLen = 0;
2226     size_t output_char_count; // ��������������
2227     OutputCharState state;
2228     state.KanjiCode = cv->KanjiCodeSend;
2229     state.ControlOut = OutControl;
2230     state.SendCode = cv->SendCode;
2231     state.JIS7Katakana = cv->JIS7KatakanaSend;
2232     output_char_count = MakeOutputString(cv, &state, &B[i], C-i, TempStr, &TempLen);
2233    
2234     // �f�[�^���o���o�b�t�@��
2235     if (WriteOutBuff(cv, TempStr, TempLen)) {
2236     i += output_char_count; // output_char_count ������ ��������
2237     // ��������������������
2238     cv->SendCode = state.SendCode;
2239     } else {
2240     Full = TRUE;
2241     }
2242     } // end of "while {}"
2243     _CrtCheckMemory();
2244     return i;
2245 zmatsuo 7484 }
2246    
2247 doda 8445 /**
2248     * CommTextEcho() �� wchar_t ��
2249     *
2250     * @retval �o��������(wchar_t�P��)
2251     */
2252 zmatsuo 7484 int WINAPI CommTextEchoW(PComVar cv, const wchar_t *B, int C)
2253     {
2254 doda 8445 char TempStr[12];
2255     BOOL Full = FALSE;
2256     int i = 0;
2257     while (! Full && (i < C)) {
2258     // �o���p�f�[�^������
2259     int TempLen = 0;
2260     size_t output_char_count; // ��������������
2261     OutputCharState state;
2262     state.KanjiCode = cv->KanjiCodeEcho;
2263     state.ControlOut = ControlEcho;
2264     state.SendCode = cv->EchoCode;
2265     state.JIS7Katakana = cv->JIS7KatakanaEcho;
2266     output_char_count = MakeOutputString(cv, &state, &B[i], C-i, TempStr, &TempLen);
2267    
2268     // �f�[�^���o���o�b�t�@��
2269     if (WriteInBuff(cv, TempStr, TempLen)) {
2270     i += output_char_count; // output_char_count ������ ��������
2271     // ��������������������
2272     cv->EchoCode = state.SendCode;
2273     } else {
2274     Full = TRUE;
2275     }
2276     } // end of "while {}"
2277     _CrtCheckMemory();
2278     return i;
2279 zmatsuo 7484 }
2280    
2281 zmatsuo 7305 int WINAPI CommBinaryEcho(PComVar cv, PCHAR B, int C)
2282 maya 3227 {
2283     int a, i, Len;
2284     char d[3];
2285    
2286     if ( ! cv->Ready )
2287     return C;
2288    
2289 doda 8445 PackInBuff(cv);
2290 maya 3227
2291     i = 0;
2292     a = 1;
2293     while ((a>0) && (i<C)) {
2294     Len = 0;
2295    
2296     d[Len] = B[i];
2297     Len++;
2298    
2299     if ( cv->TelFlag && (B[i]=='\x0d') &&
2300     ! cv->TelBinSend ) {
2301     d[Len] = 0x00;
2302     Len++;
2303     }
2304    
2305     if ( cv->TelFlag && (B[i]=='\xff') ) {
2306     d[Len] = '\xff';
2307     Len++;
2308     }
2309    
2310 doda 8445 if (WriteInBuff(cv, d, Len)) {
2311 maya 3227 a = 1;
2312 doda 8445 i++;
2313     } else {
2314     a = 0;
2315 maya 3227 }
2316     }
2317     return i;
2318     }
2319    
2320