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 9244 - (hide annotations) (download) (as text)
Mon May 10 14:12:02 2021 UTC (2 years, 11 months ago) by zmatsuo
File MIME type: text/x-csrc
File size: 61151 byte(s) 
キーボードに関連する部分を別ファイルに分離

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