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