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 9243 - (hide annotations) (download) (as text)
Mon May 10 14:11:51 2021 UTC (2 years, 11 months ago) by zmatsuo
File MIME type: text/x-csrc
File size: 61125 byte(s) 
SHARED_KEYMAP マクロに関する部分を削除

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