Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/trunk/teraterm/ttpcmn/ttcmn.c

Contents of /trunk/teraterm/ttpcmn/ttcmn.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 7412 - (show annotations) (download) (as text)
Mon Jan 28 13:33:57 2019 UTC (5 years, 2 months ago) by zmatsuo
File MIME type: text/x-csrc
File size: 62312 byte(s) 
htmlhelpで、hhctrl.ocxを参照するようにした
1 /*
2 * Copyright (C) 1994-1998 T. Teranishi
3 * (C) 2004-2019 TeraTerm Project
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 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 *
18 * 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 */
29
30 #ifndef _WIN32_IE
31 #define _WIN32_IE 0x501
32 #endif
33
34 /* 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 #include <locale.h>
47 #include <htmlhelp.h>
48
49 #include "compat_w95.h"
50 #include "tt_res.h"
51 #include "codeconv.h"
52
53 // TMap ���i�[�����t�@�C���}�b�s���O�I�u�W�F�N�g(���L������)�����O
54 // TMap(�����������o)���X�V�������o�[�W�������������N���������������K�v��������
55 // �A�������o�[�W�����������g�����������X�������A���������������X�����K�v������
56 #define TT_FILEMAPNAME "ttset_memfilemap_" TT_VERSION_STR("_")
57
58 /* first instance flag */
59 static BOOL FirstInstance = TRUE;
60
61 static HINSTANCE hInst;
62
63 static PMap pm;
64
65 static HANDLE HMap = NULL;
66 #define VTCLASSNAME _T("VTWin32")
67 #define TEKCLASSNAME _T("TEKWin32")
68
69 #ifdef UNICODE
70 static HWND(WINAPI *pHtmlHelp)(HWND hwndCaller, LPCWSTR pszFile, UINT uCommand, DWORD_PTR dwData);
71 #define HTMLHELP_API_NAME "HtmlHelpW"
72 #else
73 static HWND(WINAPI *pHtmlHelp)(HWND hwndCaller, LPCSTR pszFile, UINT uCommand, DWORD_PTR dwData);
74 #define HTMLHELP_API_NAME "HtmlHelpA"
75 #endif
76
77 enum window_style {
78 WIN_CASCADE,
79 WIN_STACKED,
80 WIN_SIDEBYSIDE,
81 };
82
83
84 void WINAPI CopyShmemToTTSet(PTTSet ts)
85 {
86 // ���������������L�����������R�s�[����
87 memcpy(ts, &pm->ts, sizeof(TTTSet));
88 }
89
90 void WINAPI CopyTTSetToShmem(PTTSet ts)
91 {
92 // ���������������L���������R�s�[����
93 memcpy(&pm->ts, ts, sizeof(TTTSet));
94 }
95
96
97 BOOL WINAPI StartTeraTerm(PTTSet ts)
98 {
99 char Temp[MAX_PATH];
100
101 if (FirstInstance) {
102 // init window list
103 pm->NWin = 0;
104 }
105 else {
106 /* only the first instance uses saved position */
107 pm->ts.VTPos.x = CW_USEDEFAULT;
108 pm->ts.VTPos.y = CW_USEDEFAULT;
109 pm->ts.TEKPos.x = CW_USEDEFAULT;
110 pm->ts.TEKPos.y = CW_USEDEFAULT;
111 }
112
113 memcpy(ts,&(pm->ts),sizeof(TTTSet));
114
115 // if (FirstInstance) { �������������� (2008.3.13 maya)
116 // �N���������A���L�������� HomeDir �� SetupFName ����������
117 /* Get home directory */
118 if (GetModuleFileName(hInst,Temp,sizeof(Temp)) == 0) {
119 return TRUE;
120 }
121 ExtractDirName(Temp, ts->HomeDir);
122 _chdir(ts->HomeDir);
123 GetDefaultSetupFName(ts->HomeDir, ts->SetupFName, sizeof(ts->SetupFName));
124
125 strncpy_s(ts->KeyCnfFN, sizeof(ts->KeyCnfFN), ts->HomeDir, _TRUNCATE);
126 AppendSlash(ts->KeyCnfFN, sizeof(ts->KeyCnfFN));
127 strncat_s(ts->KeyCnfFN, sizeof(ts->KeyCnfFN), "KEYBOARD.CNF", _TRUNCATE);
128
129 if (FirstInstance) {
130 FirstInstance = FALSE;
131 return TRUE;
132 }
133 else {
134 return FALSE;
135 }
136 }
137
138 // �����t�@�C�����f�B�X�N���������ATera Term�{�������N�������B
139 // (2012.4.30 yutaka)
140 void WINAPI RestartTeraTerm(HWND hwnd, PTTSet ts)
141 {
142 char path[1024];
143 STARTUPINFO si;
144 PROCESS_INFORMATION pi;
145 char uimsg[MAX_UIMSG];
146 int ret;
147
148 get_lang_msg("MSG_TT_TAKE_EFFECT", uimsg, sizeof(uimsg),
149 "This option takes effect the next time a session is started.\n"
150 "Are you sure that you want to relaunch Tera Term?"
151 , ts->UILanguageFile);
152 ret = MessageBox(hwnd, uimsg, "Tera Term: Configuration Warning", MB_YESNO | MB_ICONEXCLAMATION | MB_DEFBUTTON2);
153 if (ret != IDYES)
154 return;
155
156 SendMessage(hwnd, WM_COMMAND, ID_SETUP_SAVE, 0);
157 // ID_FILE_EXIT ���b�Z�[�W�����A�v�������������������������AWM_QUIT ���|�X�g�����B
158 //PostMessage(hwnd, WM_COMMAND, ID_FILE_EXIT, 0);
159 PostQuitMessage(0);
160
161 // ���v���Z�X�����N���B
162 if (GetModuleFileName(NULL, path, sizeof(path)) == 0) {
163 return;
164 }
165 memset(&si, 0, sizeof(si));
166 GetStartupInfo(&si);
167 memset(&pi, 0, sizeof(pi));
168 if (CreateProcess(NULL, path, NULL, NULL, FALSE, 0,
169 NULL, NULL, &si, &pi) == 0) {
170 }
171 }
172
173 void WINAPI ChangeDefaultSet(PTTSet ts, PKeyMap km)
174 {
175 if ((ts!=NULL) &&
176 (_stricmp(ts->SetupFName, pm->ts.SetupFName) == 0)) {
177 memcpy(&(pm->ts),ts,sizeof(TTTSet));
178 }
179 if (km!=NULL) {
180 memcpy(&(pm->km),km,sizeof(TKeyMap));
181 }
182 }
183
184 void WINAPI GetDefaultSet(PTTSet ts)
185 {
186 memcpy(ts,&(pm->ts),sizeof(TTTSet));
187 }
188
189
190 /* Key scan code -> Tera Term key code */
191 WORD WINAPI GetKeyCode(PKeyMap KeyMap, WORD Scan)
192 {
193 WORD Key;
194
195 if (KeyMap==NULL) {
196 KeyMap = &(pm->km);
197 }
198 Key = IdKeyMax;
199 while ((Key>0) && (KeyMap->Map[Key-1] != Scan)) {
200 Key--;
201 }
202 return Key;
203 }
204
205 void WINAPI GetKeyStr(HWND HWin, PKeyMap KeyMap, WORD KeyCode,
206 BOOL AppliKeyMode, BOOL AppliCursorMode,
207 BOOL Send8BitMode, PCHAR KeyStr, int destlen,
208 LPINT Len, LPWORD Type)
209 {
210 MSG Msg;
211 char Temp[201];
212
213 if (KeyMap==NULL) {
214 KeyMap = &(pm->km);
215 }
216
217 *Type = IdBinary; // key type
218 *Len = 0;
219 switch (KeyCode) {
220 case IdUp:
221 if (Send8BitMode) {
222 *Len = 2;
223 if (AppliCursorMode)
224 strncpy_s(KeyStr,destlen,"\217A",_TRUNCATE);
225 else
226 strncpy_s(KeyStr,destlen,"\233A",_TRUNCATE);
227 } else {
228 *Len = 3;
229 if (AppliCursorMode)
230 strncpy_s(KeyStr,destlen,"\033OA",_TRUNCATE);
231 else
232 strncpy_s(KeyStr,destlen,"\033[A",_TRUNCATE);
233 }
234 break;
235 case IdDown:
236 if (Send8BitMode) {
237 *Len = 2;
238 if (AppliCursorMode)
239 strncpy_s(KeyStr,destlen,"\217B",_TRUNCATE);
240 else
241 strncpy_s(KeyStr,destlen,"\233B",_TRUNCATE);
242 } else {
243 *Len = 3;
244 if (AppliCursorMode)
245 strncpy_s(KeyStr,destlen,"\033OB",_TRUNCATE);
246 else
247 strncpy_s(KeyStr,destlen,"\033[B",_TRUNCATE);
248 }
249 break;
250 case IdRight:
251 if (Send8BitMode) {
252 *Len = 2;
253 if (AppliCursorMode)
254 strncpy_s(KeyStr,destlen,"\217C",_TRUNCATE);
255 else
256 strncpy_s(KeyStr,destlen,"\233C",_TRUNCATE);
257 } else {
258 *Len = 3;
259 if (AppliCursorMode)
260 strncpy_s(KeyStr,destlen,"\033OC",_TRUNCATE);
261 else
262 strncpy_s(KeyStr,destlen,"\033[C",_TRUNCATE);
263 }
264 break;
265 case IdLeft:
266 if (Send8BitMode) {
267 *Len = 2;
268 if (AppliCursorMode)
269 strncpy_s(KeyStr,destlen,"\217D",_TRUNCATE);
270 else
271 strncpy_s(KeyStr,destlen,"\233D",_TRUNCATE);
272 } else {
273 *Len = 3;
274 if (AppliCursorMode)
275 strncpy_s(KeyStr,destlen,"\033OD",_TRUNCATE);
276 else
277 strncpy_s(KeyStr,destlen,"\033[D",_TRUNCATE);
278 }
279 break;
280 case Id0:
281 if (AppliKeyMode) {
282 if (Send8BitMode) {
283 *Len = 2;
284 strncpy_s(KeyStr,destlen,"\217p",_TRUNCATE);
285 } else {
286 *Len = 3;
287 strncpy_s(KeyStr,destlen,"\033Op",_TRUNCATE);
288 }
289 }
290 else {
291 *Len = 1;
292 KeyStr[0] = '0';
293 }
294 break;
295 case Id1:
296 if (AppliKeyMode) {
297 if (Send8BitMode) {
298 *Len = 2;
299 strncpy_s(KeyStr,destlen,"\217q",_TRUNCATE);
300 } else {
301 *Len = 3;
302 strncpy_s(KeyStr,destlen,"\033Oq",_TRUNCATE);
303 }
304 }
305 else {
306 *Len = 1;
307 KeyStr[0] = '1';
308 }
309 break;
310 case Id2:
311 if (AppliKeyMode) {
312 if (Send8BitMode) {
313 *Len = 2;
314 strncpy_s(KeyStr,destlen,"\217r",_TRUNCATE);
315 } else {
316 *Len = 3;
317 strncpy_s(KeyStr,destlen,"\033Or",_TRUNCATE);
318 }
319 }
320 else {
321 *Len = 1;
322 KeyStr[0] = '2';
323 }
324 break;
325 case Id3:
326 if (AppliKeyMode) {
327 if (Send8BitMode) {
328 *Len = 2;
329 strncpy_s(KeyStr,destlen,"\217s",_TRUNCATE);
330 } else {
331 *Len = 3;
332 strncpy_s(KeyStr,destlen,"\033Os",_TRUNCATE);
333 }
334 }
335 else {
336 *Len = 1;
337 KeyStr[0] = '3';
338 }
339 break;
340 case Id4:
341 if (AppliKeyMode) {
342 if (Send8BitMode) {
343 *Len = 2;
344 strncpy_s(KeyStr,destlen,"\217t",_TRUNCATE);
345 } else {
346 *Len = 3;
347 strncpy_s(KeyStr,destlen,"\033Ot",_TRUNCATE);
348 }
349 }
350 else {
351 *Len = 1;
352 KeyStr[0] = '4';
353 }
354 break;
355 case Id5:
356 if (AppliKeyMode) {
357 if (Send8BitMode) {
358 *Len = 2;
359 strncpy_s(KeyStr,destlen,"\217u",_TRUNCATE);
360 } else {
361 *Len = 3;
362 strncpy_s(KeyStr,destlen,"\033Ou",_TRUNCATE);
363 }
364 }
365 else {
366 *Len = 1;
367 KeyStr[0] = '5';
368 }
369 break;
370 case Id6:
371 if (AppliKeyMode) {
372 if (Send8BitMode) {
373 *Len = 2;
374 strncpy_s(KeyStr,destlen,"\217v",_TRUNCATE);
375 } else {
376 *Len = 3;
377 strncpy_s(KeyStr,destlen,"\033Ov",_TRUNCATE);
378 }
379 }
380 else {
381 *Len = 1;
382 KeyStr[0] = '6';
383 }
384 break;
385 case Id7:
386 if (AppliKeyMode) {
387 if (Send8BitMode) {
388 *Len = 2;
389 strncpy_s(KeyStr,destlen,"\217w",_TRUNCATE);
390 } else {
391 *Len = 3;
392 strncpy_s(KeyStr,destlen,"\033Ow",_TRUNCATE);
393 }
394 }
395 else {
396 *Len = 1;
397 KeyStr[0] = '7';
398 }
399 break;
400 case Id8:
401 if (AppliKeyMode) {
402 if (Send8BitMode) {
403 *Len = 2;
404 strncpy_s(KeyStr,destlen,"\217x",_TRUNCATE);
405 } else {
406 *Len = 3;
407 strncpy_s(KeyStr,destlen,"\033Ox",_TRUNCATE);
408 }
409 }
410 else {
411 *Len = 1;
412 KeyStr[0] = '8';
413 }
414 break;
415 case Id9:
416 if (AppliKeyMode) {
417 if (Send8BitMode) {
418 *Len = 2;
419 strncpy_s(KeyStr,destlen,"\217y",_TRUNCATE);
420 } else {
421 *Len = 3;
422 strncpy_s(KeyStr,destlen,"\033Oy",_TRUNCATE);
423 }
424 }
425 else {
426 *Len = 1;
427 KeyStr[0] = '9';
428 }
429 break;
430 case IdMinus: /* numeric pad - key (DEC) */
431 if (AppliKeyMode) {
432 if (Send8BitMode) {
433 *Len = 2;
434 strncpy_s(KeyStr,destlen,"\217m",_TRUNCATE);
435 } else {
436 *Len = 3;
437 strncpy_s(KeyStr,destlen,"\033Om",_TRUNCATE);
438 }
439 }
440 else {
441 *Len = 1;
442 KeyStr[0] = '-';
443 }
444 break;
445 case IdComma: /* numeric pad , key (DEC) */
446 if (AppliKeyMode) {
447 if (Send8BitMode) {
448 *Len = 2;
449 strncpy_s(KeyStr,destlen,"\217l",_TRUNCATE);
450 } else {
451 *Len = 3;
452 strncpy_s(KeyStr,destlen,"\033Ol",_TRUNCATE);
453 }
454 }
455 else {
456 *Len = 1;
457 KeyStr[0] = ',';
458 }
459 break;
460 case IdPeriod: /* numeric pad . key */
461 if (AppliKeyMode) {
462 if (Send8BitMode) {
463 *Len = 2;
464 strncpy_s(KeyStr,destlen,"\217n",_TRUNCATE);
465 } else {
466 *Len = 3;
467 strncpy_s(KeyStr,destlen,"\033On",_TRUNCATE);
468 }
469 }
470 else {
471 *Len = 1;
472 KeyStr[0] = '.';
473 }
474 break;
475 case IdEnter: /* numeric pad enter key */
476 if (AppliKeyMode) {
477 if (Send8BitMode) {
478 *Len = 2;
479 strncpy_s(KeyStr,destlen,"\217M",_TRUNCATE);
480 } else {
481 *Len = 3;
482 strncpy_s(KeyStr,destlen,"\033OM",_TRUNCATE);
483 }
484 }
485 else {
486 *Type = IdText; // do new-line conversion
487 *Len = 1;
488 KeyStr[0] = 0x0D;
489 }
490 break;
491 case IdSlash: /* numeric pad slash key */
492 if (AppliKeyMode) {
493 if (Send8BitMode) {
494 *Len = 2;
495 strncpy_s(KeyStr,destlen,"\217o",_TRUNCATE);
496 } else {
497 *Len = 3;
498 strncpy_s(KeyStr,destlen,"\033Oo",_TRUNCATE);
499 }
500 }
501 else {
502 *Len = 1;
503 KeyStr[0] = '/';
504 }
505 break;
506 case IdAsterisk: /* numeric pad asterisk key */
507 if (AppliKeyMode) {
508 if (Send8BitMode) {
509 *Len = 2;
510 strncpy_s(KeyStr,destlen,"\217j",_TRUNCATE);
511 } else {
512 *Len = 3;
513 strncpy_s(KeyStr,destlen,"\033Oj",_TRUNCATE);
514 }
515 }
516 else {
517 *Len = 1;
518 KeyStr[0] = '*';
519 }
520 break;
521 case IdPlus: /* numeric pad plus key */
522 if (AppliKeyMode) {
523 if (Send8BitMode) {
524 *Len = 2;
525 strncpy_s(KeyStr,destlen,"\217k",_TRUNCATE);
526 } else {
527 *Len = 3;
528 strncpy_s(KeyStr,destlen,"\033Ok",_TRUNCATE);
529 }
530 }
531 else {
532 *Len = 1;
533 KeyStr[0] = '+';
534 }
535 break;
536 case IdPF1: /* DEC Key: PF1 */
537 if (Send8BitMode) {
538 *Len = 2;
539 strncpy_s(KeyStr,destlen,"\217P",_TRUNCATE);
540 } else {
541 *Len = 3;
542 strncpy_s(KeyStr,destlen,"\033OP",_TRUNCATE);
543 }
544 break;
545 case IdPF2: /* DEC Key: PF2 */
546 if (Send8BitMode) {
547 *Len = 2;
548 strncpy_s(KeyStr,destlen,"\217Q",_TRUNCATE);
549 } else {
550 *Len = 3;
551 strncpy_s(KeyStr,destlen,"\033OQ",_TRUNCATE);
552 }
553 break;
554 case IdPF3: /* DEC Key: PF3 */
555 if (Send8BitMode) {
556 *Len = 2;
557 strncpy_s(KeyStr,destlen,"\217R",_TRUNCATE);
558 } else {
559 *Len = 3;
560 strncpy_s(KeyStr,destlen,"\033OR",_TRUNCATE);
561 }
562 break;
563 case IdPF4: /* DEC Key: PF4 */
564 if (Send8BitMode) {
565 *Len = 2;
566 strncpy_s(KeyStr,destlen,"\217S",_TRUNCATE);
567 } else {
568 *Len = 3;
569 strncpy_s(KeyStr,destlen,"\033OS",_TRUNCATE);
570 }
571 break;
572 case IdFind: /* DEC Key: Find */
573 if (Send8BitMode) {
574 *Len = 3;
575 strncpy_s(KeyStr,destlen,"\2331~",_TRUNCATE);
576 } else {
577 *Len = 4;
578 strncpy_s(KeyStr,destlen,"\033[1~",_TRUNCATE);
579 }
580 break;
581 case IdInsert: /* DEC Key: Insert Here */
582 if (Send8BitMode) {
583 *Len = 3;
584 strncpy_s(KeyStr,destlen,"\2332~",_TRUNCATE);
585 } else {
586 *Len = 4;
587 strncpy_s(KeyStr,destlen,"\033[2~",_TRUNCATE);
588 }
589 break;
590 case IdRemove: /* DEC Key: Remove */
591 if (Send8BitMode) {
592 *Len = 3;
593 strncpy_s(KeyStr,destlen,"\2333~",_TRUNCATE);
594 } else {
595 *Len = 4;
596 strncpy_s(KeyStr,destlen,"\033[3~",_TRUNCATE);
597 }
598 break;
599 case IdSelect: /* DEC Key: Select */
600 if (Send8BitMode) {
601 *Len = 3;
602 strncpy_s(KeyStr,destlen,"\2334~",_TRUNCATE);
603 } else {
604 *Len = 4;
605 strncpy_s(KeyStr,destlen,"\033[4~",_TRUNCATE);
606 }
607 break;
608 case IdPrev: /* DEC Key: Prev */
609 if (Send8BitMode) {
610 *Len = 3;
611 strncpy_s(KeyStr,destlen,"\2335~",_TRUNCATE);
612 } else {
613 *Len = 4;
614 strncpy_s(KeyStr,destlen,"\033[5~",_TRUNCATE);
615 }
616 break;
617 case IdNext: /* DEC Key: Next */
618 if (Send8BitMode) {
619 *Len = 3;
620 strncpy_s(KeyStr,destlen,"\2336~",_TRUNCATE);
621 } else {
622 *Len = 4;
623 strncpy_s(KeyStr,destlen,"\033[6~",_TRUNCATE);
624 }
625 break;
626 case IdF6: /* DEC Key: F6 */
627 if (Send8BitMode) {
628 *Len = 4;
629 strncpy_s(KeyStr,destlen,"\23317~",_TRUNCATE);
630 } else {
631 *Len = 5;
632 strncpy_s(KeyStr,destlen,"\033[17~",_TRUNCATE);
633 }
634 break;
635 case IdF7: /* DEC Key: F7 */
636 if (Send8BitMode) {
637 *Len = 4;
638 strncpy_s(KeyStr,destlen,"\23318~",_TRUNCATE);
639 } else {
640 *Len = 5;
641 strncpy_s(KeyStr,destlen,"\033[18~",_TRUNCATE);
642 }
643 break;
644 case IdF8: /* DEC Key: F8 */
645 if (Send8BitMode) {
646 *Len = 4;
647 strncpy_s(KeyStr,destlen,"\23319~",_TRUNCATE);
648 } else {
649 *Len = 5;
650 strncpy_s(KeyStr,destlen,"\033[19~",_TRUNCATE);
651 }
652 break;
653 case IdF9: /* DEC Key: F9 */
654 if (Send8BitMode) {
655 *Len = 4;
656 strncpy_s(KeyStr,destlen,"\23320~",_TRUNCATE);
657 } else {
658 *Len = 5;
659 strncpy_s(KeyStr,destlen,"\033[20~",_TRUNCATE);
660 }
661 break;
662 case IdF10: /* DEC Key: F10 */
663 if (Send8BitMode) {
664 *Len = 4;
665 strncpy_s(KeyStr,destlen,"\23321~",_TRUNCATE);
666 } else {
667 *Len = 5;
668 strncpy_s(KeyStr,destlen,"\033[21~",_TRUNCATE);
669 }
670 break;
671 case IdF11: /* DEC Key: F11 */
672 if (Send8BitMode) {
673 *Len = 4;
674 strncpy_s(KeyStr,destlen,"\23323~",_TRUNCATE);
675 } else {
676 *Len = 5;
677 strncpy_s(KeyStr,destlen,"\033[23~",_TRUNCATE);
678 }
679 break;
680 case IdF12: /* DEC Key: F12 */
681 if (Send8BitMode) {
682 *Len = 4;
683 strncpy_s(KeyStr,destlen,"\23324~",_TRUNCATE);
684 } else {
685 *Len = 5;
686 strncpy_s(KeyStr,destlen,"\033[24~",_TRUNCATE);
687 }
688 break;
689 case IdF13: /* DEC Key: F13 */
690 if (Send8BitMode) {
691 *Len = 4;
692 strncpy_s(KeyStr,destlen,"\23325~",_TRUNCATE);
693 } else {
694 *Len = 5;
695 strncpy_s(KeyStr,destlen,"\033[25~",_TRUNCATE);
696 }
697 break;
698 case IdF14: /* DEC Key: F14 */
699 if (Send8BitMode) {
700 *Len = 4;
701 strncpy_s(KeyStr,destlen,"\23326~",_TRUNCATE);
702 } else {
703 *Len = 5;
704 strncpy_s(KeyStr,destlen,"\033[26~",_TRUNCATE);
705 }
706 break;
707 case IdHelp: /* DEC Key: Help */
708 if (Send8BitMode) {
709 *Len = 4;
710 strncpy_s(KeyStr,destlen,"\23328~",_TRUNCATE);
711 } else {
712 *Len = 5;
713 strncpy_s(KeyStr,destlen,"\033[28~",_TRUNCATE);
714 }
715 break;
716 case IdDo: /* DEC Key: Do */
717 if (Send8BitMode) {
718 *Len = 4;
719 strncpy_s(KeyStr,destlen,"\23329~",_TRUNCATE);
720 } else {
721 *Len = 5;
722 strncpy_s(KeyStr,destlen,"\033[29~",_TRUNCATE);
723 }
724 break;
725 case IdF17: /* DEC Key: F17 */
726 if (Send8BitMode) {
727 *Len = 4;
728 strncpy_s(KeyStr,destlen,"\23331~",_TRUNCATE);
729 } else {
730 *Len = 5;
731 strncpy_s(KeyStr,destlen,"\033[31~",_TRUNCATE);
732 }
733 break;
734 case IdF18: /* DEC Key: F18 */
735 if (Send8BitMode) {
736 *Len = 4;
737 strncpy_s(KeyStr,destlen,"\23332~",_TRUNCATE);
738 } else {
739 *Len = 5;
740 strncpy_s(KeyStr,destlen,"\033[32~",_TRUNCATE);
741 }
742 break;
743 case IdF19: /* DEC Key: F19 */
744 if (Send8BitMode) {
745 *Len = 4;
746 strncpy_s(KeyStr,destlen,"\23333~",_TRUNCATE);
747 } else {
748 *Len = 5;
749 strncpy_s(KeyStr,destlen,"\033[33~",_TRUNCATE);
750 }
751 break;
752 case IdF20: /* DEC Key: F20 */
753 if (Send8BitMode) {
754 *Len = 4;
755 strncpy_s(KeyStr,destlen,"\23334~",_TRUNCATE);
756 } else {
757 *Len = 5;
758 strncpy_s(KeyStr,destlen,"\033[34~",_TRUNCATE);
759 }
760 break;
761 case IdXF1: /* XTERM F1 */
762 if (Send8BitMode) {
763 *Len = 4;
764 strncpy_s(KeyStr,destlen,"\23311~",_TRUNCATE);
765 } else {
766 *Len = 5;
767 strncpy_s(KeyStr,destlen,"\033[11~",_TRUNCATE);
768 }
769 break;
770 case IdXF2: /* XTERM F2 */
771 if (Send8BitMode) {
772 *Len = 4;
773 strncpy_s(KeyStr,destlen,"\23312~",_TRUNCATE);
774 } else {
775 *Len = 5;
776 strncpy_s(KeyStr,destlen,"\033[12~",_TRUNCATE);
777 }
778 break;
779 case IdXF3: /* XTERM F3 */
780 if (Send8BitMode) {
781 *Len = 4;
782 strncpy_s(KeyStr,destlen,"\23313~",_TRUNCATE);
783 } else {
784 *Len = 5;
785 strncpy_s(KeyStr,destlen,"\033[13~",_TRUNCATE);
786 }
787 break;
788 case IdXF4: /* XTERM F4 */
789 if (Send8BitMode) {
790 *Len = 4;
791 strncpy_s(KeyStr,destlen,"\23314~",_TRUNCATE);
792 } else {
793 *Len = 5;
794 strncpy_s(KeyStr,destlen,"\033[14~",_TRUNCATE);
795 }
796 break;
797 case IdXF5: /* XTERM F5 */
798 if (Send8BitMode) {
799 *Len = 4;
800 strncpy_s(KeyStr,destlen,"\23315~",_TRUNCATE);
801 } else {
802 *Len = 5;
803 strncpy_s(KeyStr,destlen,"\033[15~",_TRUNCATE);
804 }
805 break;
806 case IdXBackTab: /* XTERM Back Tab */
807 if (Send8BitMode) {
808 *Len = 2;
809 strncpy_s(KeyStr,destlen,"\233Z",_TRUNCATE);
810 } else {
811 *Len = 3;
812 strncpy_s(KeyStr,destlen,"\033[Z",_TRUNCATE);
813 }
814 break;
815 case IdHold:
816 case IdPrint:
817 case IdBreak:
818 case IdCmdEditCopy:
819 case IdCmdEditPaste:
820 case IdCmdEditPasteCR:
821 case IdCmdEditCLS:
822 case IdCmdEditCLB:
823 case IdCmdCtrlOpenTEK:
824 case IdCmdCtrlCloseTEK:
825 case IdCmdLineUp:
826 case IdCmdLineDown:
827 case IdCmdPageUp:
828 case IdCmdPageDown:
829 case IdCmdBuffTop:
830 case IdCmdBuffBottom:
831 case IdCmdNextWin:
832 case IdCmdPrevWin:
833 case IdCmdNextSWin:
834 case IdCmdPrevSWin:
835 case IdCmdLocalEcho:
836 case IdCmdScrollLock:
837 PostMessage(HWin,WM_USER_ACCELCOMMAND,KeyCode,0);
838 break;
839 default:
840 if ((KeyCode >= IdUser1) && (KeyCode <= IdKeyMax)) {
841 *Type = (WORD)(*KeyMap).UserKeyType[KeyCode-IdUser1]; // key type
842 *Len = KeyMap->UserKeyLen[KeyCode-IdUser1];
843 memcpy(Temp,
844 &KeyMap->UserKeyStr[KeyMap->UserKeyPtr[KeyCode-IdUser1]],
845 *Len);
846 Temp[*Len] = 0;
847 if ((*Type==IdBinary) || (*Type==IdText))
848 *Len = Hex2Str(Temp,KeyStr,destlen);
849 else
850 strncpy_s(KeyStr,destlen,Temp,_TRUNCATE);
851 }
852 else
853 return;
854 }
855 /* remove WM_CHAR message for used keycode */
856 PeekMessage(&Msg,HWin, WM_CHAR, WM_CHAR,PM_REMOVE);
857 }
858
859 void WINAPI SetCOMFlag(int Com)
860 {
861 pm->ComFlag[(Com-1)/CHAR_BIT] |= 1 << ((Com-1)%CHAR_BIT);
862 }
863
864 void WINAPI ClearCOMFlag(int Com)
865 {
866 pm->ComFlag[(Com-1)/CHAR_BIT] &= ~(1 << ((Com-1)%CHAR_BIT));
867 }
868
869 int WINAPI CheckCOMFlag(int Com)
870 {
871 return ((pm->ComFlag[(Com-1)/CHAR_BIT] & 1 << (Com-1)%CHAR_BIT) > 0);
872 }
873
874 int WINAPI RegWin(HWND HWinVT, HWND HWinTEK)
875 {
876 int i, j;
877
878 if (pm->NWin>=MAXNWIN)
879 return 0;
880 if (HWinVT==NULL)
881 return 0;
882 if (HWinTEK!=NULL) {
883 i = 0;
884 while ((i<pm->NWin) && (pm->WinList[i]!=HWinVT))
885 i++;
886 if (i>=pm->NWin)
887 return 0;
888 for (j=pm->NWin-1 ; j>i ; j--)
889 pm->WinList[j+1] = pm->WinList[j];
890 pm->WinList[i+1] = HWinTEK;
891 pm->NWin++;
892 return 0;
893 }
894 pm->WinList[pm->NWin++] = HWinVT;
895 memset(&pm->WinPrevRect[pm->NWin - 1], 0, sizeof(pm->WinPrevRect[pm->NWin - 1])); // RECT clear
896 if (pm->NWin==1) {
897 return 1;
898 }
899 else {
900 return (int)(SendMessage(pm->WinList[pm->NWin-2],
901 WM_USER_GETSERIALNO,0,0)+1);
902 }
903 }
904
905 void WINAPI UnregWin(HWND HWin)
906 {
907 int i, j;
908
909 i = 0;
910 while ((i<pm->NWin) && (pm->WinList[i]!=HWin)) {
911 i++;
912 }
913 if (pm->WinList[i]!=HWin) {
914 return;
915 }
916 for (j=i ; j<pm->NWin-1 ; j++) {
917 pm->WinList[j] = pm->WinList[j+1];
918 pm->WinPrevRect[j] = pm->WinPrevRect[j+1]; // RECT shift
919 }
920 if (pm->NWin>0) {
921 pm->NWin--;
922 }
923 }
924
925 char GetWindowTypeChar(HWND Hw, HWND HWin)
926 {
927 #if 0
928 if (HWin == Hw)
929 return '*';
930 else if (!IsWindowVisible(Hw))
931 #else
932 if (!IsWindowVisible(Hw))
933 #endif
934 return '#';
935 else if (IsIconic(Hw))
936 return '-';
937 else if (IsZoomed(Hw))
938 return '@';
939 else
940 return '+';
941 }
942
943 void WINAPI SetWinMenu(HMENU menu, PCHAR buf, int buflen, PCHAR langFile, int VTFlag)
944 {
945 int i;
946 char Temp[MAXPATHLEN];
947 HWND Hw;
948
949 // delete all items in Window menu
950 i = GetMenuItemCount(menu);
951 if (i>0)
952 do {
953 i--;
954 RemoveMenu(menu,i,MF_BYPOSITION);
955 } while (i>0);
956
957 i = 0;
958 while (i<pm->NWin) {
959 Hw = pm->WinList[i]; // get window handle
960 if ((GetClassName(Hw,Temp,sizeof(Temp))>0) &&
961 ((strcmp(Temp,VTCLASSNAME)==0) ||
962 (strcmp(Temp,TEKCLASSNAME)==0))) {
963 Temp[0] = '&';
964 Temp[1] = (char)(0x31 + i);
965 Temp[2] = ' ';
966 Temp[3] = GetWindowTypeChar(Hw, NULL);
967 Temp[4] = ' ';
968 GetWindowText(Hw,&Temp[5],sizeof(Temp)-6);
969 AppendMenu(menu,MF_ENABLED | MF_STRING,ID_WINDOW_1+i,Temp);
970 i++;
971 if (i>8) {
972 i = pm->NWin;
973 }
974 }
975 else {
976 UnregWin(Hw);
977 }
978 }
979 get_lang_msg("MENU_WINDOW_WINDOW", buf, buflen, "&Window", langFile);
980 if (VTFlag == 1) {
981 AppendMenu(menu, MF_SEPARATOR, 0, NULL);
982 AppendMenu(menu,MF_ENABLED | MF_STRING,ID_WINDOW_WINDOW, buf);
983
984 get_lang_msg("MENU_WINDOW_MINIMIZEALL", buf, buflen, "&Minimize All", langFile);
985 AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_MINIMIZEALL, buf);
986
987 get_lang_msg("MENU_WINDOW_RESTOREALL", buf, buflen, "&Restore All", langFile);
988 AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_RESTOREALL, buf);
989
990 get_lang_msg("MENU_WINDOW_CASCADE", buf, buflen, "&Cascade", langFile);
991 AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_CASCADEALL, buf);
992
993 get_lang_msg("MENU_WINDOW_STACKED", buf, buflen, "&Stacked", langFile);
994 AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_STACKED, buf);
995
996 get_lang_msg("MENU_WINDOW_SIDEBYSIDE", buf, buflen, "Side &by Side", langFile);
997 AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_SIDEBYSIDE, buf);
998
999 if (pm->WinUndoFlag) {
1000 if (pm->WinUndoStyle == WIN_CASCADE)
1001 get_lang_msg("MENU_WINDOW_CASCADE_UNDO", buf, buflen, "&Undo - Cascade", langFile);
1002 else if (pm->WinUndoStyle == WIN_STACKED)
1003 get_lang_msg("MENU_WINDOW_STACKED_UNDO", buf, buflen, "&Undo - Stacked", langFile);
1004 else
1005 get_lang_msg("MENU_WINDOW_SIDEBYSIDE_UNDO", buf, buflen, "&Undo - Side by Side", langFile);
1006 AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_UNDO, buf);
1007 }
1008
1009 }
1010 else {
1011 AppendMenu(menu,MF_ENABLED | MF_STRING,ID_TEKWINDOW_WINDOW, buf);
1012 }
1013 }
1014
1015 void WINAPI SetWinList(HWND HWin, HWND HDlg, int IList)
1016 {
1017 int i;
1018 char Temp[MAXPATHLEN];
1019 HWND Hw;
1020
1021 for (i=0; i<pm->NWin; i++) {
1022 Hw = pm->WinList[i]; // get window handle
1023 if ((GetClassName(Hw,Temp,sizeof(Temp))>0) &&
1024 ((strcmp(Temp,VTCLASSNAME)==0) ||
1025 (strcmp(Temp,TEKCLASSNAME)==0))) {
1026 Temp[0] = GetWindowTypeChar(Hw, HWin);
1027 Temp[1] = ' ';
1028 GetWindowText(Hw,&Temp[2],sizeof(Temp)-3);
1029 SendDlgItemMessage(HDlg, IList, LB_ADDSTRING,
1030 0, (LONG)Temp);
1031 if (Hw==HWin) {
1032 SendDlgItemMessage(HDlg, IList, LB_SETCURSEL, i,0);
1033 }
1034 }
1035 else {
1036 UnregWin(Hw);
1037 }
1038 }
1039 }
1040
1041 void WINAPI SelectWin(int WinId)
1042 {
1043 if ((WinId>=0) && (WinId<pm->NWin)) {
1044 /* �E�B���h�E�����������������������������������A���������������������������A
1045 * SW_SHOWNORMAL ���� SW_SHOW �����X�����B
1046 * (2009.11.8 yutaka)
1047 * �E�B���h�E�����������������������������T�C�Y������(SW_RESTORE)�����������B
1048 * (2009.11.9 maya)
1049 */
1050 if (IsIconic(pm->WinList[WinId])) {
1051 ShowWindow(pm->WinList[WinId],SW_RESTORE);
1052 }
1053 else {
1054 ShowWindow(pm->WinList[WinId],SW_SHOW);
1055 }
1056 SetForegroundWindow(pm->WinList[WinId]);
1057 }
1058 }
1059
1060 void WINAPI SelectNextWin(HWND HWin, int Next, BOOL SkipIconic)
1061 {
1062 int i;
1063
1064 i = 0;
1065 while ((i < pm->NWin) && (pm->WinList[i]!=HWin)) {
1066 i++;
1067 }
1068 if (pm->WinList[i]!=HWin) {
1069 return;
1070 }
1071
1072 do {
1073 i += Next;
1074 if (i >= pm->NWin) {
1075 i = 0;
1076 }
1077 else if (i < 0) {
1078 i = pm->NWin-1;
1079 }
1080
1081 if (pm->WinList[i] == HWin) {
1082 break;
1083 }
1084 } while ((SkipIconic && IsIconic(pm->WinList[i])) || !IsWindowVisible(pm->WinList[i]));
1085
1086 SelectWin(i);
1087 }
1088
1089 void WINAPI ShowAllWin(int stat) {
1090 int i;
1091
1092 for (i=0; i < pm->NWin; i++) {
1093 ShowWindow(pm->WinList[i], stat);
1094 }
1095 }
1096
1097 void WINAPI UndoAllWin(void) {
1098 int i;
1099 WINDOWPLACEMENT rc0;
1100 RECT rc;
1101 HMONITOR hMonitor;
1102 MONITORINFO mi;
1103 int stat = SW_RESTORE;
1104 int multi_mon = 0;
1105
1106 if (HasMultiMonitorSupport()) {
1107 multi_mon = 1;
1108 }
1109
1110 // ���x�A�����������t���O���������B
1111 pm->WinUndoFlag = FALSE;
1112
1113 memset(&rc0, 0, sizeof(rc0));
1114
1115 for (i=0; i < pm->NWin; i++) {
1116 // �����w�����A�O�����������c���������������A�E�B���h�E�����������������B
1117 if (stat == SW_RESTORE && memcmp(&pm->WinPrevRect[i], &rc0, sizeof(rc0)) != 0) {
1118 rc = pm->WinPrevRect[i].rcNormalPosition;
1119
1120 // NT4.0, 95 ���}���`���j�^API��������
1121 if (multi_mon) {
1122 // �������j�^������������
1123 hMonitor = MonitorFromRect(&rc, MONITOR_DEFAULTTONEAREST);
1124 mi.cbSize = sizeof(MONITORINFO);
1125 GetMonitorInfo(hMonitor, &mi);
1126
1127 // ���u�����i�����O���������x���������������������������j
1128 if (rc.right > mi.rcMonitor.right) {
1129 rc.left -= rc.right - mi.rcMonitor.right;
1130 rc.right = mi.rcMonitor.right;
1131 }
1132 if (rc.left < mi.rcMonitor.left) {
1133 rc.right += mi.rcMonitor.left - rc.left;
1134 rc.left = mi.rcMonitor.left;
1135 }
1136 if (rc.bottom > mi.rcMonitor.bottom) {
1137 rc.top -= rc.bottom - mi.rcMonitor.bottom;
1138 rc.bottom = mi.rcMonitor.bottom;
1139 }
1140 if (rc.top < mi.rcMonitor.top) {
1141 rc.bottom += mi.rcMonitor.top - rc.top;
1142 rc.top = mi.rcMonitor.top;
1143 }
1144 }
1145
1146 // �E�B���h�E���u����
1147 SetWindowPos(
1148 pm->WinList[i], NULL,
1149 rc.left,
1150 rc.top,
1151 rc.right - rc.left,
1152 rc.bottom - rc.top,
1153 SWP_NOZORDER);
1154
1155 // �E�B���h�E����������
1156 ShowWindow(pm->WinList[i], pm->WinPrevRect[i].showCmd);
1157
1158 } else {
1159 ShowWindow(pm->WinList[i], stat);
1160 }
1161 }
1162 }
1163
1164 void WINAPI OpenHelp(UINT Command, DWORD Data, char *UILanguageFile)
1165 {
1166 char HomeDir[MAX_PATH];
1167 char Temp[MAX_PATH];
1168 HWND HWin;
1169 TCHAR HelpFN[MAX_PATH];
1170 TCHAR uimsg[MAX_UIMSG];
1171 TCHAR dllName[MAX_PATH];
1172 const TCHAR *HomeDirT;
1173 const TCHAR *errorFile;
1174 TCHAR buf[MAX_PATH];
1175
1176 /* Get home directory */
1177 if (GetModuleFileNameA(NULL,Temp,_countof(Temp)) == 0) {
1178 return;
1179 }
1180 ExtractDirName(Temp, HomeDir);
1181 HomeDirT = ToTcharA(HomeDir);
1182
1183 get_lang_msgT("HELPFILE", uimsg, _countof(uimsg),
1184 _T("teraterm.chm"), UILanguageFile);
1185
1186 if (pHtmlHelp == NULL) {
1187 HINSTANCE hDll;
1188 GetSystemDirectory(dllName, _countof(dllName));
1189 _tcscat_s(dllName, _countof(dllName), _T("\\hhctrl.ocx"));
1190 hDll = LoadLibrary(dllName);
1191 if (hDll == NULL) {
1192 errorFile = dllName;
1193 goto error;
1194 }
1195 pHtmlHelp = (void *)GetProcAddress(hDll, HTMLHELP_API_NAME);
1196 if (pHtmlHelp == NULL) {
1197 errorFile = dllName;
1198 goto error;
1199 }
1200 }
1201 // �w���v���I�[�i�[�������f�X�N�g�b�v������ (2007.5.12 maya)
1202 HWin = GetDesktopWindow();
1203 _sntprintf_s(HelpFN, _countof(HelpFN), _TRUNCATE, _T("%s\\%s"), (TCHAR *)HomeDirT, uimsg);
1204 if (pHtmlHelp != NULL && pHtmlHelp(HWin, HelpFN, Command, Data) == NULL && Command != HH_CLOSE_ALL) {
1205 errorFile = HelpFN;
1206 goto error;
1207 }
1208 goto finish;
1209
1210 error:
1211 get_lang_msgT("MSG_OPENHELP_ERROR", uimsg, _countof(uimsg),
1212 _T("Can't open HTML help file(%s)."), UILanguageFile);
1213 _sntprintf_s(buf, _countof(buf), _TRUNCATE, uimsg, HelpFN);
1214 MessageBox(HWin, buf, _T("Tera Term: HTML help"), MB_OK | MB_ICONERROR);
1215
1216 finish:
1217 free((void *)HomeDirT);
1218 }
1219
1220 HWND WINAPI GetNthWin(int n)
1221 {
1222 if (n<pm->NWin) {
1223 return pm->WinList[n];
1224 }
1225 else {
1226 return NULL;
1227 }
1228 }
1229
1230 int WINAPI GetRegisteredWindowCount()
1231 {
1232 return (pm->NWin);
1233 }
1234
1235 // �L�����E�B���h�E���T���A�������u���L�������������B
1236 static void get_valid_window_and_memorize_rect(HWND myhwnd, HWND hwnd[], int *num, int style)
1237 {
1238 int i, n;
1239 WINDOWPLACEMENT wndPlace;
1240
1241 // ��������(Undo)���j���[�����x�����\���������B
1242 if (pm->WinUndoFlag == FALSE) {
1243 pm->WinUndoFlag = TRUE;
1244 } else {
1245 // ���������j���[���\�������������A�������O�������X�^�C�����I�����������A
1246 // ���j���[�������B
1247 // Windows8�����A�������A�����������X�^�C�����I�����������j���[�����������������A
1248 // Tera Term�������j���[���\�������������A�������������B
1249 if (pm->WinUndoStyle == style)
1250 pm->WinUndoFlag = FALSE;
1251 }
1252 pm->WinUndoStyle = style;
1253
1254 n = 0;
1255 for (i = 0 ; i < pm->NWin ; i++) {
1256 // �������u���o���������B
1257 wndPlace.length = sizeof(WINDOWPLACEMENT);
1258 GetWindowPlacement(pm->WinList[i], &wndPlace);
1259 pm->WinPrevRect[i] = wndPlace;
1260
1261 // �������g�������������B
1262 if (pm->WinList[i] == myhwnd) {
1263 hwnd[n] = hwnd[0];
1264 hwnd[0] = myhwnd;
1265 } else {
1266 hwnd[n] = pm->WinList[i];
1267 }
1268 n++;
1269 }
1270 *num = n;
1271 }
1272
1273 // �E�B���h�E�����E���������\������(Show Windows Side by Side)
1274 void WINAPI ShowAllWinSidebySide(HWND myhwnd)
1275 {
1276 int n;
1277 HWND hwnd[MAXNWIN];
1278
1279 get_valid_window_and_memorize_rect(myhwnd, hwnd, &n, WIN_SIDEBYSIDE);
1280 TileWindows(NULL, MDITILE_VERTICAL, NULL, n, hwnd);
1281 }
1282
1283 // �E�B���h�E���������������\������(Show Windows Stacked)
1284 void WINAPI ShowAllWinStacked(HWND myhwnd)
1285 {
1286 int n;
1287 HWND hwnd[MAXNWIN];
1288
1289 get_valid_window_and_memorize_rect(myhwnd, hwnd, &n, WIN_STACKED);
1290 TileWindows(NULL, MDITILE_HORIZONTAL, NULL, n, hwnd);
1291 }
1292
1293 // �E�B���h�E���d�����\������(Cascade)
1294 void WINAPI ShowAllWinCascade(HWND myhwnd)
1295 {
1296 int n;
1297 HWND hwnd[MAXNWIN];
1298
1299 get_valid_window_and_memorize_rect(myhwnd, hwnd, &n, WIN_CASCADE);
1300 CascadeWindows(NULL, MDITILE_SKIPDISABLED, NULL, n, hwnd);
1301 }
1302
1303 // �STera Term���I���w�����o���B
1304 void WINAPI BroadcastClosingMessage(HWND myhwnd)
1305 {
1306 int i, max;
1307 HWND hwnd[MAXNWIN];
1308
1309 // Tera Term���I�����������A���L���������������������A
1310 // ���������o�b�t�@���R�s�[���������B
1311 max = pm->NWin;
1312 for (i = 0 ; i < pm->NWin ; i++) {
1313 hwnd[i] = pm->WinList[i];
1314 }
1315
1316 for (i = 0 ; i < max ; i++) {
1317 // �������g�������������B
1318 if (hwnd[i] == myhwnd)
1319 continue;
1320
1321 PostMessage(hwnd[i], WM_USER_NONCONFIRM_CLOSE, 0, 0);
1322 }
1323 PostMessage(myhwnd, WM_USER_NONCONFIRM_CLOSE, 0, 0);
1324 }
1325
1326
1327 int WINAPI CommReadRawByte(PComVar cv, LPBYTE b)
1328 {
1329 if ( ! cv->Ready ) {
1330 return 0;
1331 }
1332
1333 if ( cv->InBuffCount>0 ) {
1334 *b = cv->InBuff[cv->InPtr];
1335 cv->InPtr++;
1336 cv->InBuffCount--;
1337 if ( cv->InBuffCount==0 ) {
1338 cv->InPtr = 0;
1339 }
1340 return 1;
1341 }
1342 else {
1343 cv->InPtr = 0;
1344 return 0;
1345 }
1346 }
1347
1348 void WINAPI CommInsert1Byte(PComVar cv, BYTE b)
1349 {
1350 if ( ! cv->Ready ) {
1351 return;
1352 }
1353
1354 if (cv->InPtr == 0) {
1355 memmove(&(cv->InBuff[1]),&(cv->InBuff[0]),cv->InBuffCount);
1356 }
1357 else {
1358 cv->InPtr--;
1359 }
1360 cv->InBuff[cv->InPtr] = b;
1361 cv->InBuffCount++;
1362
1363 if (cv->HBinBuf!=0 ) {
1364 cv->BinSkip++;
1365 }
1366 }
1367
1368 void Log1Bin(PComVar cv, BYTE b)
1369 {
1370 if (((cv->FilePause & OpLog)!=0) || cv->ProtoFlag) {
1371 return;
1372 }
1373 if (cv->BinSkip > 0) {
1374 cv->BinSkip--;
1375 return;
1376 }
1377 cv->BinBuf[cv->BinPtr] = b;
1378 cv->BinPtr++;
1379 if (cv->BinPtr>=InBuffSize) {
1380 cv->BinPtr = cv->BinPtr-InBuffSize;
1381 }
1382 if (cv->BCount>=InBuffSize) {
1383 cv->BCount = InBuffSize;
1384 cv->BStart = cv->BinPtr;
1385 }
1386 else {
1387 cv->BCount++;
1388 }
1389 }
1390
1391 int WINAPI CommRead1Byte(PComVar cv, LPBYTE b)
1392 {
1393 int c;
1394
1395 if ( ! cv->Ready ) {
1396 return 0;
1397 }
1398
1399 if ((cv->HLogBuf!=NULL) &&
1400 ((cv->LCount>=InBuffSize-10) ||
1401 (cv->DCount>=InBuffSize-10))) {
1402 // �������o�b�t�@���]�T�������������ACPU�X�P�W���[�����O�����������A
1403 // CPU���X�g�[���������h���B
1404 // (2006.10.13 yutaka)
1405 Sleep(1);
1406 return 0;
1407 }
1408
1409 if ((cv->HBinBuf!=NULL) &&
1410 (cv->BCount>=InBuffSize-10)) {
1411 return 0;
1412 }
1413
1414 if ( cv->TelMode ) {
1415 c = 0;
1416 }
1417 else {
1418 c = CommReadRawByte(cv,b);
1419 }
1420
1421 if ((c==1) && cv->TelCRFlag) {
1422 cv->TelCRFlag = FALSE;
1423 if (*b==0) {
1424 c = 0;
1425 }
1426 }
1427
1428 if ( c==1 ) {
1429 if ( cv->IACFlag ) {
1430 cv->IACFlag = FALSE;
1431 if ( *b != 0xFF ) {
1432 cv->TelMode = TRUE;
1433 CommInsert1Byte(cv,*b);
1434 if ( cv->HBinBuf!=0 ) {
1435 cv->BinSkip--;
1436 }
1437 c = 0;
1438 }
1439 }
1440 else if ((cv->PortType==IdTCPIP) && (*b==0xFF)) {
1441 if (!cv->TelFlag && cv->TelAutoDetect) { /* TTPLUG */
1442 cv->TelFlag = TRUE;
1443 }
1444 if (cv->TelFlag) {
1445 cv->IACFlag = TRUE;
1446 c = 0;
1447 }
1448 }
1449 else if (cv->TelFlag && ! cv->TelBinRecv && (*b==0x0D)) {
1450 cv->TelCRFlag = TRUE;
1451 }
1452 }
1453
1454 if ( (c==1) && (cv->HBinBuf!=0) ) {
1455 Log1Bin(cv, *b);
1456 }
1457
1458 return c;
1459 }
1460
1461 int WINAPI CommRawOut(PComVar cv, PCHAR B, int C)
1462 {
1463 int a;
1464
1465 if ( ! cv->Ready ) {
1466 return C;
1467 }
1468
1469 if (C > OutBuffSize - cv->OutBuffCount) {
1470 a = OutBuffSize - cv->OutBuffCount;
1471 }
1472 else {
1473 a = C;
1474 }
1475 if ( cv->OutPtr > 0 ) {
1476 memmove(&(cv->OutBuff[0]),&(cv->OutBuff[cv->OutPtr]),cv->OutBuffCount);
1477 cv->OutPtr = 0;
1478 }
1479 memcpy(&(cv->OutBuff[cv->OutBuffCount]),B,a);
1480 cv->OutBuffCount = cv->OutBuffCount + a;
1481 return a;
1482 }
1483
1484 int WINAPI CommBinaryOut(PComVar cv, PCHAR B, int C)
1485 {
1486 int a, i, Len;
1487 char d[3];
1488
1489 if ( ! cv->Ready ) {
1490 return C;
1491 }
1492
1493 i = 0;
1494 a = 1;
1495 while ((a>0) && (i<C)) {
1496 Len = 0;
1497
1498 d[Len] = B[i];
1499 Len++;
1500
1501 if ( cv->TelFlag && (B[i]=='\x0d') && ! cv->TelBinSend ) {
1502 d[Len++] = '\x00';
1503 }
1504 else if ( cv->TelFlag && (B[i]=='\xff') ) {
1505 d[Len++] = '\xff';
1506 }
1507
1508 if ( OutBuffSize - cv->OutBuffCount - Len >= 0 ) {
1509 CommRawOut(cv, d, Len);
1510 a = 1;
1511 }
1512 else {
1513 a = 0;
1514 }
1515
1516 i += a;
1517 }
1518 return i;
1519 }
1520
1521 int WINAPI CommBinaryBuffOut(PComVar cv, PCHAR B, int C)
1522 {
1523 int a, i, Len, OutLen;
1524 char d[3];
1525
1526 if ( ! cv->Ready ) {
1527 return C;
1528 }
1529
1530 i = 0;
1531 a = 1;
1532 while ((a>0) && (i<C)) {
1533 Len = 0;
1534
1535 d[Len] = B[i];
1536 Len++;
1537
1538 if (B[i] == CR) {
1539 if ( cv->TelFlag && ! cv->TelBinSend ) {
1540 d[Len++] = '\x00';
1541 }
1542 if (cv->TelLineMode) {
1543 cv->Flush = TRUE;
1544 }
1545 }
1546 else if ( cv->TelFlag && (B[i]=='\xff') ) {
1547 d[Len++] = '\xff';
1548 }
1549
1550 if (cv->TelLineMode) {
1551 if (OutBuffSize - cv->LineModeBuffCount - Len >= 0) {
1552 memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), d, Len);
1553 cv->LineModeBuffCount += Len;
1554 if (cv->Flush) {
1555 cv->FlushLen = cv->LineModeBuffCount;
1556 }
1557 a = 1;
1558 }
1559 else {
1560 a = 0;
1561 }
1562 if (cv->FlushLen > 0) {
1563 OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
1564 cv->FlushLen -= OutLen;
1565 cv->LineModeBuffCount -= OutLen;
1566 memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
1567 }
1568 cv->Flush = FALSE;
1569 }
1570 else {
1571 if ( OutBuffSize - cv->OutBuffCount - Len >= 0 ) {
1572 CommRawOut(cv, d, Len);
1573 a = 1;
1574 }
1575 else {
1576 a = 0;
1577 }
1578 }
1579
1580 i += a;
1581 }
1582 return i;
1583 }
1584
1585 static int OutputTextUTF8(WORD K, char *TempStr, PComVar cv)
1586 {
1587 unsigned int code;
1588 int outlen;
1589 int TempLen = 0;
1590
1591 code = SJIS2UTF8(K, &outlen, *cv->CodePage);
1592 switch (outlen) {
1593 case 4:
1594 TempStr[TempLen++] = (code >> 24) & 0xff;
1595 case 3:
1596 TempStr[TempLen++] = (code >> 16) & 0xff;
1597 case 2:
1598 TempStr[TempLen++] = (code >> 8) & 0xff;
1599 case 1:
1600 TempStr[TempLen++] = code & 0xff;
1601 }
1602
1603 return TempLen;
1604 }
1605
1606 //
1607 // MBCS�����e�������R�[�h�����������o�������B
1608 //
1609 static int TextOutMBCS(PComVar cv, PCHAR B, int C)
1610 {
1611 int i, TempLen, OutLen;
1612 WORD K;
1613 char TempStr[12];
1614 int SendCodeNew;
1615 BYTE d;
1616 BOOL Full, KanjiFlagNew;
1617
1618 Full = FALSE;
1619 i = 0;
1620 while (! Full && (i < C)) {
1621 TempLen = 0;
1622 d = (BYTE)B[i];
1623 SendCodeNew = cv->SendCode;
1624 KanjiFlagNew = FALSE;
1625
1626 if (cv->SendKanjiFlag) {
1627 SendCodeNew = IdKanji;
1628
1629 K = (cv->SendKanjiFirst << 8) + d;
1630
1631 // UTF-8�����������s���B1�`3�o�C�g���������������������B
1632 if (cv->KanjiCodeSend == IdUTF8 || cv->Language == IdUtf8) {
1633 TempLen += OutputTextUTF8(K, TempStr, cv);
1634 }
1635 else {
1636 switch (cv->Language) {
1637 case IdJapanese:
1638 switch (cv->KanjiCodeSend) {
1639 case IdEUC:
1640 K = SJIS2EUC(K);
1641 break;
1642 case IdJIS:
1643 K = SJIS2JIS(K);
1644 if ((cv->SendCode==IdKatakana) &&
1645 (cv->JIS7KatakanaSend==1)) {
1646 TempStr[TempLen++] = SI;
1647 }
1648 break;
1649 case IdSJIS:
1650 /* nothing to do */
1651 break;
1652 }
1653 break;
1654 case IdKorean:
1655 break;
1656 }
1657 TempStr[TempLen++] = HIBYTE(K);
1658 TempStr[TempLen++] = LOBYTE(K);
1659 }
1660 }
1661 else if (_isleadbyte_l(d, cv->locale)) {
1662 KanjiFlagNew = TRUE;
1663 cv->SendKanjiFirst = d;
1664 SendCodeNew = IdKanji;
1665
1666 if (cv->Language == IdJapanese) {
1667 if ((cv->SendCode!=IdKanji) && (cv->KanjiCodeSend==IdJIS)) {
1668 TempStr[0] = 0x1B;
1669 TempStr[1] = '$';
1670 if (cv->KanjiIn == IdKanjiInB) {
1671 TempStr[2] = 'B';
1672 }
1673 else {
1674 TempStr[2] = '@';
1675 }
1676 TempLen = 3;
1677 }
1678 }
1679 }
1680 else {
1681 if (cv->Language == IdJapanese) {
1682 if ((cv->SendCode==IdKanji) && (cv->KanjiCodeSend==IdJIS)) {
1683 TempStr[0] = 0x1B;
1684 TempStr[1] = '(';
1685 switch (cv->KanjiOut) {
1686 case IdKanjiOutJ:
1687 TempStr[2] = 'J';
1688 break;
1689 case IdKanjiOutH:
1690 TempStr[2] = 'H';
1691 break;
1692 default:
1693 TempStr[2] = 'B';
1694 }
1695 TempLen = 3;
1696 }
1697
1698 if ((0xa0<d) && (d<0xe0)) {
1699 SendCodeNew = IdKatakana;
1700 if ((cv->SendCode!=IdKatakana) &&
1701 (cv->KanjiCodeSend==IdJIS) &&
1702 (cv->JIS7KatakanaSend==1)) {
1703 TempStr[TempLen++] = SO;
1704 }
1705 }
1706 else {
1707 SendCodeNew = IdASCII;
1708 if ((cv->SendCode==IdKatakana) &&
1709 (cv->KanjiCodeSend==IdJIS) &&
1710 (cv->JIS7KatakanaSend==1)) {
1711 TempStr[TempLen++] = SI;
1712 }
1713 }
1714 }
1715
1716 if (d==CR) {
1717 TempStr[TempLen++] = 0x0d;
1718 if (cv->CRSend==IdCRLF) {
1719 TempStr[TempLen++] = 0x0a;
1720 }
1721 else if ((cv->CRSend==IdCR) &&
1722 cv->TelFlag && ! cv->TelBinSend) {
1723 TempStr[TempLen++] = 0;
1724 }
1725 else if (cv->CRSend == IdLF) {
1726 TempStr[TempLen-1] = 0x0a;
1727 }
1728 if (cv->TelLineMode) {
1729 cv->Flush = TRUE;
1730 }
1731 }
1732 else if (d==BS) {
1733 if (cv->TelLineMode) {
1734 if (cv->FlushLen < cv->LineModeBuffCount) {
1735 cv->LineModeBuffCount--;
1736 }
1737 }
1738 else {
1739 TempStr[TempLen++] = d;
1740 }
1741 }
1742 else if (d==0x15) { // Ctrl-U
1743 if (cv->TelLineMode) {
1744 cv->LineModeBuffCount = cv->FlushLen;
1745 }
1746 else {
1747 TempStr[TempLen++] = d;
1748 }
1749 }
1750 else if ((d>=0x80) && (cv->KanjiCodeSend==IdUTF8 || cv->Language==IdUtf8)) {
1751 TempLen += OutputTextUTF8((WORD)d, TempStr, cv);
1752 }
1753 else if ((d>=0xa1) && (d<=0xe0) && (cv->Language == IdJapanese)) {
1754 /* Katakana */
1755 if (cv->KanjiCodeSend==IdEUC) {
1756 TempStr[TempLen++] = (char)SS2;
1757 }
1758 if ((cv->KanjiCodeSend==IdJIS) &&
1759 (cv->JIS7KatakanaSend==1)) {
1760 TempStr[TempLen++] = d & 0x7f;
1761 }
1762 else {
1763 TempStr[TempLen++] = d;
1764 }
1765 }
1766 else {
1767 TempStr[TempLen++] = d;
1768 if (cv->TelFlag && (d==0xff)) {
1769 TempStr[TempLen++] = (char)0xff;
1770 }
1771 }
1772 } // if (cv->SendKanjiFlag) else if ... else ... end
1773
1774 if (cv->TelLineMode) {
1775 if (TempLen == 0) {
1776 i++;
1777 cv->SendCode = SendCodeNew;
1778 cv->SendKanjiFlag = KanjiFlagNew;
1779 }
1780 else {
1781 Full = OutBuffSize - cv->LineModeBuffCount - TempLen < 0;
1782 if (!Full) {
1783 i++;
1784 cv->SendCode = SendCodeNew;
1785 cv->SendKanjiFlag = KanjiFlagNew;
1786 memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), TempStr, TempLen);
1787 cv->LineModeBuffCount += TempLen;
1788 if (cv->Flush) {
1789 cv->FlushLen = cv->LineModeBuffCount;
1790 }
1791 }
1792 }
1793 if (cv->FlushLen > 0) {
1794 OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
1795 cv->FlushLen -= OutLen;
1796 cv->LineModeBuffCount -= OutLen;
1797 memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
1798 }
1799 cv->Flush = FALSE;
1800 }
1801 else {
1802 if (TempLen == 0) {
1803 i++;
1804 cv->SendCode = SendCodeNew;
1805 cv->SendKanjiFlag = KanjiFlagNew;
1806 }
1807 else {
1808 Full = OutBuffSize-cv->OutBuffCount-TempLen < 0;
1809 if (! Full) {
1810 i++;
1811 cv->SendCode = SendCodeNew;
1812 cv->SendKanjiFlag = KanjiFlagNew;
1813 CommRawOut(cv,TempStr,TempLen);
1814 }
1815 }
1816 }
1817
1818 } // end of "while {}"
1819
1820 return i;
1821 }
1822
1823 int WINAPI CommTextOut(PComVar cv, PCHAR B, int C)
1824 {
1825 int i, TempLen, OutLen;
1826 char TempStr[12];
1827 BYTE d;
1828 BOOL Full;
1829
1830 if (! cv->Ready ) {
1831 return C;
1832 }
1833
1834 switch (cv->Language) {
1835 case IdUtf8:
1836 case IdJapanese:
1837 case IdKorean:
1838 return TextOutMBCS(cv, B, C);
1839 break;
1840 }
1841
1842 Full = FALSE;
1843 i = 0;
1844 while (! Full && (i < C)) {
1845 TempLen = 0;
1846 d = (BYTE)B[i];
1847
1848 switch (d) {
1849 case CR:
1850 TempStr[TempLen] = 0x0d;
1851 TempLen++;
1852 if (cv->CRSend==IdCRLF) {
1853 TempStr[TempLen++] = 0x0a;
1854 }
1855 else if (cv->CRSend==IdCR && cv->TelFlag && ! cv->TelBinSend) {
1856 TempStr[TempLen++] = 0;
1857 }
1858 else if (cv->CRSend == IdLF) {
1859 TempStr[TempLen-1] = 0x0a;
1860 }
1861 if (cv->TelLineMode) {
1862 cv->Flush = TRUE;
1863 }
1864 break;
1865
1866 case BS:
1867 if (cv->TelLineMode) {
1868 if (cv->FlushLen < cv->LineModeBuffCount) {
1869 cv->LineModeBuffCount--;
1870 }
1871 }
1872 else {
1873 TempStr[TempLen++] = d;
1874 }
1875 break;
1876
1877 case 0x15: // Ctrl-U
1878 if (cv->TelLineMode) {
1879 cv->LineModeBuffCount = cv->FlushLen;
1880 }
1881 else {
1882 TempStr[TempLen++] = d;
1883 }
1884 break;
1885
1886 default:
1887 if ((cv->Language==IdRussian) && (d>=128)) {
1888 d = RussConv(cv->RussClient, cv->RussHost, d);
1889 }
1890 TempStr[TempLen++] = d;
1891 if (cv->TelFlag && (d==0xff)) {
1892 TempStr[TempLen++] = (char)0xff;
1893 }
1894 }
1895
1896 if (cv->TelLineMode) {
1897 Full = OutBuffSize - cv->LineModeBuffCount - TempLen < 0;
1898 if (!Full) {
1899 i++;
1900 memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), TempStr, TempLen);
1901 cv->LineModeBuffCount += TempLen;
1902 if (cv->Flush) {
1903 cv->FlushLen = cv->LineModeBuffCount;
1904 }
1905 }
1906 if (cv->FlushLen > 0) {
1907 OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
1908 cv->FlushLen -= OutLen;
1909 cv->LineModeBuffCount -= OutLen;
1910 memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
1911 }
1912 cv->Flush = FALSE;
1913 }
1914 else {
1915 Full = OutBuffSize - cv->OutBuffCount - TempLen < 0;
1916 if (! Full) {
1917 i++;
1918 CommRawOut(cv,TempStr,TempLen);
1919 }
1920 }
1921 } // end of while {}
1922
1923 return i;
1924 }
1925
1926 int WINAPI CommBinaryEcho(PComVar cv, PCHAR B, int C)
1927 {
1928 int a, i, Len;
1929 char d[3];
1930
1931 if ( ! cv->Ready )
1932 return C;
1933
1934 if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
1935 memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
1936 cv->InPtr = 0;
1937 }
1938
1939 i = 0;
1940 a = 1;
1941 while ((a>0) && (i<C)) {
1942 Len = 0;
1943
1944 d[Len] = B[i];
1945 Len++;
1946
1947 if ( cv->TelFlag && (B[i]=='\x0d') &&
1948 ! cv->TelBinSend ) {
1949 d[Len] = 0x00;
1950 Len++;
1951 }
1952
1953 if ( cv->TelFlag && (B[i]=='\xff') ) {
1954 d[Len] = '\xff';
1955 Len++;
1956 }
1957
1958 if ( InBuffSize-cv->InBuffCount-Len >=0 ) {
1959 memcpy(&(cv->InBuff[cv->InBuffCount]),d,Len);
1960 cv->InBuffCount = cv->InBuffCount + Len;
1961 a = 1;
1962 }
1963 else
1964 a = 0;
1965 i = i + a;
1966 }
1967 return i;
1968 }
1969
1970 static int WINAPI TextEchoMBCS(PComVar cv, PCHAR B, int C)
1971 {
1972 int i, TempLen;
1973 WORD K;
1974 char TempStr[12];
1975 int EchoCodeNew;
1976 BYTE d;
1977 BOOL Full, KanjiFlagNew;
1978
1979 Full = FALSE;
1980 i = 0;
1981 while (! Full && (i < C)) {
1982 TempLen = 0;
1983 d = (BYTE)B[i];
1984 EchoCodeNew = cv->EchoCode;
1985 KanjiFlagNew = FALSE;
1986
1987 if (cv->EchoKanjiFlag) {
1988 EchoCodeNew = IdKanji;
1989
1990 K = (cv->EchoKanjiFirst << 8) + d;
1991
1992 // UTF-8�����������s���B1�`3�o�C�g���������������������B
1993 if (cv->KanjiCodeEcho == IdUTF8 || cv->Language==IdUtf8) {
1994 TempLen += OutputTextUTF8(K, TempStr, cv);
1995 }
1996 else {
1997 switch (cv->Language) {
1998 case IdJapanese:
1999 switch (cv->KanjiCodeEcho) {
2000 case IdEUC:
2001 K = SJIS2EUC(K);
2002 break;
2003 case IdJIS:
2004 K = SJIS2JIS(K);
2005 if ((cv->EchoCode==IdKatakana) &&
2006 (cv->JIS7KatakanaEcho==1)) {
2007 TempStr[TempLen++] = SI;
2008 }
2009 break;
2010 case IdSJIS:
2011 /* nothing to do */
2012 break;
2013 }
2014 break;
2015 case IdKorean:
2016 break;
2017 }
2018 TempStr[TempLen++] = HIBYTE(K);
2019 TempStr[TempLen++] = LOBYTE(K);
2020 }
2021 }
2022 else if (_isleadbyte_l(d, cv->locale)) {
2023 KanjiFlagNew = TRUE;
2024 cv->EchoKanjiFirst = d;
2025 EchoCodeNew = IdKanji;
2026
2027 if (cv->Language == IdJapanese) {
2028 if ((cv->EchoCode!=IdKanji) && (cv->KanjiCodeEcho==IdJIS)) {
2029 TempStr[0] = 0x1B;
2030 TempStr[1] = '$';
2031 if (cv->KanjiIn == IdKanjiInB) {
2032 TempStr[2] = 'B';
2033 }
2034 else {
2035 TempStr[2] = '@';
2036 }
2037 TempLen = 3;
2038 }
2039 }
2040 }
2041 else {
2042 if (cv->Language == IdJapanese) {
2043 if ((cv->EchoCode==IdKanji) && (cv->KanjiCodeEcho==IdJIS)) {
2044 TempStr[0] = 0x1B;
2045 TempStr[1] = '(';
2046 switch (cv->KanjiOut) {
2047 case IdKanjiOutJ:
2048 TempStr[2] = 'J';
2049 break;
2050 case IdKanjiOutH:
2051 TempStr[2] = 'H';
2052 break;
2053 default:
2054 TempStr[2] = 'B';
2055 }
2056 TempLen = 3;
2057 }
2058
2059 if ((0xa0<d) && (d<0xe0)) {
2060 EchoCodeNew = IdKatakana;
2061 if ((cv->EchoCode!=IdKatakana) &&
2062 (cv->KanjiCodeEcho==IdJIS) &&
2063 (cv->JIS7KatakanaEcho==1)) {
2064 TempStr[TempLen++] = SO;
2065 }
2066 }
2067 else {
2068 EchoCodeNew = IdASCII;
2069 if ((cv->EchoCode==IdKatakana) &&
2070 (cv->KanjiCodeEcho==IdJIS) &&
2071 (cv->JIS7KatakanaEcho==1)) {
2072 TempStr[TempLen++] = SI;
2073 }
2074 }
2075 }
2076
2077 if (d==CR) {
2078 TempStr[TempLen++] = 0x0d;
2079 if (cv->CRSend==IdCRLF) {
2080 TempStr[TempLen++] = 0x0a;
2081 }
2082 else if ((cv->CRSend==IdCR) &&
2083 cv->TelFlag && ! cv->TelBinSend) {
2084 TempStr[TempLen++] = 0;
2085 }
2086 else if (cv->CRSend == IdLF) {
2087 TempStr[TempLen-1] = 0x0a;
2088 }
2089 }
2090 else if (d==0x15) { // Ctrl-U
2091 if (cv->TelLineMode) {
2092 // Move to top of line (CHA "\033[G") and erase line (EL "\033[K")
2093 strncpy_s(TempStr, sizeof(TempStr), "\033[G\033[K", _TRUNCATE);
2094 TempLen += 6;
2095 }
2096 else {
2097 TempStr[TempLen++] = d;
2098 }
2099 }
2100 else if ((d>=0x80) && (cv->KanjiCodeEcho==IdUTF8 || cv->Language==IdUtf8)) {
2101 TempLen += OutputTextUTF8((WORD)d, TempStr, cv);
2102 }
2103 else if ((d>=0xa1) && (d<=0xe0) && (cv->Language == IdJapanese)) {
2104 /* Katakana */
2105 if (cv->KanjiCodeEcho==IdEUC) {
2106 TempStr[TempLen++] = (char)SS2;
2107 }
2108 if ((cv->KanjiCodeEcho==IdJIS) &&
2109 (cv->JIS7KatakanaEcho==1)) {
2110 TempStr[TempLen++] = d & 0x7f;
2111 }
2112 else {
2113 TempStr[TempLen++] = d;
2114 }
2115 }
2116 else {
2117 TempStr[TempLen++] = d;
2118 if (cv->TelFlag && (d==0xff)) {
2119 TempStr[TempLen++] = (char)0xff;
2120 }
2121 }
2122 } // if (cv->EchoKanjiFlag) else if ... else ... end
2123
2124 if (TempLen == 0) {
2125 i++;
2126 cv->EchoCode = EchoCodeNew;
2127 cv->EchoKanjiFlag = KanjiFlagNew;
2128 }
2129 else {
2130 Full = InBuffSize-cv->InBuffCount-TempLen < 0;
2131 if (! Full) {
2132 i++;
2133 cv->EchoCode = EchoCodeNew;
2134 cv->EchoKanjiFlag = KanjiFlagNew;
2135 memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
2136 cv->InBuffCount = cv->InBuffCount + TempLen;
2137 }
2138 }
2139
2140 } // end of "while {}"
2141
2142 return i;
2143 }
2144
2145 int WINAPI CommTextEcho(PComVar cv, PCHAR B, int C)
2146 {
2147 int i, TempLen;
2148 char TempStr[11];
2149 BYTE d;
2150 BOOL Full;
2151
2152 if ( ! cv->Ready ) {
2153 return C;
2154 }
2155
2156 if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
2157 memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
2158 cv->InPtr = 0;
2159 }
2160
2161 switch (cv->Language) {
2162 case IdUtf8:
2163 case IdJapanese:
2164 case IdKorean:
2165 return TextEchoMBCS(cv,B,C);
2166 break;
2167 }
2168
2169 Full = FALSE;
2170 i = 0;
2171 while (! Full && (i < C)) {
2172 TempLen = 0;
2173 d = (BYTE)B[i];
2174
2175 switch (d) {
2176 case CR:
2177 TempStr[TempLen] = 0x0d;
2178 TempLen++;
2179 if (cv->CRSend==IdCRLF) {
2180 TempStr[TempLen++] = 0x0a;
2181 }
2182 else if (cv->CRSend==IdCR && cv->TelFlag && ! cv->TelBinSend) {
2183 TempStr[TempLen++] = 0;
2184 }
2185 else if (cv->CRSend == IdLF) {
2186 TempStr[TempLen-1] = 0x0a;
2187 }
2188 break;
2189
2190 case 0x15: // Ctrl-U
2191 if (cv->TelLineMode) {
2192 // Move to top of line (CHA "\033[G") and erase line (EL "\033[K")
2193 strncpy_s(TempStr, sizeof(TempStr), "\033[G\033[K", _TRUNCATE);
2194 TempLen += 6;
2195 }
2196 else {
2197 TempStr[TempLen++] = d;
2198 }
2199 break;
2200
2201 default:
2202 if ((cv->Language==IdRussian) && (d>=128)) {
2203 d = RussConv(cv->RussClient,cv->RussHost,d);
2204 }
2205 TempStr[TempLen++] = d;
2206 if (cv->TelFlag && (d==0xff)) {
2207 TempStr[TempLen++] = (char)0xff;
2208 }
2209 }
2210
2211 Full = InBuffSize-cv->InBuffCount-TempLen < 0;
2212 if (! Full) {
2213 i++;
2214 memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
2215 cv->InBuffCount = cv->InBuffCount + TempLen;
2216 }
2217 } // end of while {}
2218
2219 return i;
2220 }
2221
2222 // listup serial port driver
2223 // cf. http://www.codeproject.com/system/setupdi.asp?df=100&forumid=4368&exp=0&select=479661
2224 // (2007.8.17 yutaka)
2225 static void ListupSerialPort(LPWORD ComPortTable, int comports, char **ComPortDesc, int ComPortMax)
2226 {
2227 GUID ClassGuid[1];
2228 DWORD dwRequiredSize;
2229 BOOL bRet;
2230 HDEVINFO DeviceInfoSet = NULL;
2231 SP_DEVINFO_DATA DeviceInfoData;
2232 DWORD dwMemberIndex = 0;
2233 int i;
2234
2235 DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
2236
2237 // ���O�����������t���[��������
2238 for (i = 0 ; i < ComPortMax ; i++) {
2239 free(ComPortDesc[i]);
2240 ComPortDesc[i] = NULL;
2241 }
2242
2243 // Get ClassGuid from ClassName for PORTS class
2244 bRet =
2245 SetupDiClassGuidsFromName(_T("PORTS"), (LPGUID) & ClassGuid, 1,
2246 &dwRequiredSize);
2247 if (!bRet) {
2248 goto cleanup;
2249 }
2250
2251 // Get class devices
2252 // COM�|�[�g�����������t�����������������A�������������������A���W�X�g�����c��������
2253 // ����FriendlyName���\���������������������������B(2007.11.8 yutaka)
2254 DeviceInfoSet =
2255 SetupDiGetClassDevs(&ClassGuid[0], NULL, NULL, DIGCF_PRESENT | DIGCF_PROFILE);
2256
2257 if (DeviceInfoSet) {
2258 // Enumerate devices
2259 dwMemberIndex = 0;
2260 while (SetupDiEnumDeviceInfo
2261 (DeviceInfoSet, dwMemberIndex++, &DeviceInfoData)) {
2262 TCHAR szFriendlyName[MAX_PATH];
2263 TCHAR szPortName[MAX_PATH];
2264 //TCHAR szMessage[MAX_PATH];
2265 DWORD dwReqSize = 0;
2266 DWORD dwPropType;
2267 DWORD dwType = REG_SZ;
2268 HKEY hKey = NULL;
2269
2270 // Get friendlyname
2271 bRet = SetupDiGetDeviceRegistryProperty(DeviceInfoSet,
2272 &DeviceInfoData,
2273 SPDRP_FRIENDLYNAME,
2274 &dwPropType,
2275 (LPBYTE)
2276 szFriendlyName,
2277 sizeof(szFriendlyName),
2278 &dwReqSize);
2279
2280 // Open device parameters reg key
2281 hKey = SetupDiOpenDevRegKey(DeviceInfoSet,
2282 &DeviceInfoData,
2283 DICS_FLAG_GLOBAL,
2284 0, DIREG_DEV, KEY_READ);
2285 if (hKey) {
2286 // Qurey for portname
2287 long lRet;
2288 dwReqSize = sizeof(szPortName);
2289 lRet = RegQueryValueEx(hKey,
2290 _T("PortName"),
2291 0,
2292 &dwType,
2293 (LPBYTE) & szPortName,
2294 &dwReqSize);
2295
2296 // Close reg key
2297 RegCloseKey(hKey);
2298 }
2299
2300 #if 0
2301 sprintf(szMessage, _T("Name: %s\nPort: %s\n"), szFriendlyName,
2302 szPortName);
2303 printf("%s\n", szMessage);
2304 #endif
2305
2306 if (_strnicmp(szPortName, "COM", 3) == 0) { // COM�|�[�g�h���C�o������
2307 int port = atoi(&szPortName[3]);
2308 int i;
2309
2310 for (i = 0 ; i < comports ; i++) {
2311 if (ComPortTable[i] == port) { // �������m�F
2312 ComPortDesc[i] = _strdup(szFriendlyName);
2313 break;
2314 }
2315 }
2316 }
2317
2318 }
2319 }
2320
2321 cleanup:
2322 // Destroy device info list
2323 SetupDiDestroyDeviceInfoList(DeviceInfoSet);
2324 }
2325
2326
2327 int WINAPI DetectComPorts(LPWORD ComPortTable, int ComPortMax, char **ComPortDesc)
2328 {
2329 HMODULE h;
2330 TCHAR devicesBuff[65535];
2331 TCHAR *p;
2332 int comports = 0;
2333 int i, j, min;
2334 WORD s;
2335
2336 if (((h = GetModuleHandle("kernel32.dll")) != NULL) &&
2337 (GetProcAddress(h, "QueryDosDeviceA") != NULL) &&
2338 (QueryDosDevice(NULL, devicesBuff, 65535) != 0)) {
2339 p = devicesBuff;
2340 while (*p != '\0') {
2341 if (strncmp(p, "COM", 3) == 0 && p[3] != '\0') {
2342 ComPortTable[comports++] = atoi(p+3);
2343 if (comports >= ComPortMax)
2344 break;
2345 }
2346 p += (strlen(p)+1);
2347 }
2348
2349 for (i=0; i<comports-1; i++) {
2350 min = i;
2351 for (j=i+1; j<comports; j++) {
2352 if (ComPortTable[min] > ComPortTable[j]) {
2353 min = j;
2354 }
2355 }
2356 if (min != i) {
2357 s = ComPortTable[i];
2358 ComPortTable[i] = ComPortTable[min];
2359 ComPortTable[min] = s;
2360 }
2361 }
2362 }
2363 else {
2364 #if 1
2365 for (i=1; i<=ComPortMax; i++) {
2366 FILE *fp;
2367 char buf[12]; // \\.\COMxxxx + NULL
2368 _snprintf_s(buf, sizeof(buf), _TRUNCATE, "\\\\.\\COM%d", i);
2369 if ((fp = fopen(buf, "r")) != NULL) {
2370 fclose(fp);
2371 ComPortTable[comports++] = i;
2372 }
2373 }
2374 #else
2375 comports = -1;
2376 #endif
2377 }
2378
2379 ListupSerialPort(ComPortTable, comports, ComPortDesc, ComPortMax);
2380
2381 return comports;
2382 }
2383
2384 int WINAPI CheckComPort(WORD ComPort)
2385 {
2386 HMODULE h;
2387 TCHAR devicesBuff[65535];
2388 char com_str[64];
2389 BOOL bRet;
2390 GUID ClassGuid[1];
2391 DWORD dwRequiredSize;
2392 HDEVINFO DeviceInfoSet = NULL;
2393 SP_DEVINFO_DATA DeviceInfoData;
2394 int found = 0;
2395
2396 _snprintf_s(com_str, sizeof(com_str), _TRUNCATE, "COM%d", ComPort);
2397
2398 if (((h = GetModuleHandle("kernel32.dll")) == NULL) | (GetProcAddress(h, "QueryDosDeviceA") == NULL) ) {
2399 /* ERROR */
2400 return -1;
2401 }
2402
2403 if (QueryDosDevice(com_str, devicesBuff, 65535) == 0) {
2404 DWORD err = GetLastError();
2405 if (err == ERROR_FILE_NOT_FOUND) {
2406 /* NOT FOUND */
2407 return 0;
2408 }
2409 /* ERROR */
2410 return -1;
2411 }
2412
2413 /* QueryDosDevice�����f�����m���������������������������`�F�b�N */
2414 bRet = SetupDiClassGuidsFromName(_T("PORTS"), (LPGUID) & ClassGuid, 1, &dwRequiredSize);
2415 if (bRet == FALSE) {
2416 return -1;
2417 }
2418
2419 DeviceInfoSet = SetupDiGetClassDevs(&ClassGuid[0], NULL, NULL, DIGCF_PRESENT | DIGCF_PROFILE);
2420 if (DeviceInfoSet == NULL) {
2421 return -1;
2422 }
2423
2424 if (DeviceInfoSet) {
2425 DWORD dwMemberIndex = 0;
2426 HKEY hKey = NULL;
2427 TCHAR szPortName[MAX_PATH];
2428 DWORD dwReqSize;
2429 DWORD dwType;
2430
2431 DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
2432 while (SetupDiEnumDeviceInfo(DeviceInfoSet, dwMemberIndex, &DeviceInfoData)) {
2433 hKey = SetupDiOpenDevRegKey(DeviceInfoSet, &DeviceInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_READ);
2434 if (hKey) {
2435 long lRet;
2436 dwReqSize = sizeof(szPortName);
2437 lRet = RegQueryValueEx(hKey, _T("PortName"), 0, &dwType, (LPBYTE)& szPortName, &dwReqSize);
2438 RegCloseKey(hKey);
2439 if (_stricmp(szPortName, com_str) == 0) {
2440 found = TRUE;
2441 break;
2442 }
2443 }
2444 dwMemberIndex++;
2445 }
2446 }
2447
2448 SetupDiDestroyDeviceInfoList(DeviceInfoSet);
2449
2450 return found;
2451 }
2452
2453 // Notify Icon ���A
2454 static NOTIFYICONDATA notify_icon = {0};
2455 static int NotifyIconShowCount = 0;
2456 static HICON CustomIcon = NULL;
2457
2458 void WINAPI SetCustomNotifyIcon(HICON icon)
2459 {
2460 CustomIcon = icon;
2461 }
2462
2463 HICON WINAPI GetCustomNotifyIcon()
2464 {
2465 return CustomIcon;
2466 }
2467
2468 void WINAPI CreateNotifyIcon(PComVar cv)
2469 {
2470 if (cv->NotifyIcon == NULL) {
2471 notify_icon.cbSize = sizeof(notify_icon);
2472 notify_icon.hWnd = cv->HWin;
2473 notify_icon.uID = 1;
2474 notify_icon.uFlags = NIF_ICON | NIF_MESSAGE;
2475 notify_icon.uCallbackMessage = WM_USER_NOTIFYICON;
2476 if (CustomIcon) {
2477 notify_icon.hIcon = CustomIcon;
2478 }
2479 else {
2480 notify_icon.hIcon = (HICON)SendMessage(cv->HWin, WM_GETICON, ICON_SMALL, 0);
2481 }
2482 notify_icon.szTip[0] = '\0';
2483 notify_icon.dwState = 0;
2484 notify_icon.dwStateMask = 0;
2485 notify_icon.szInfo[0] = '\0';
2486 notify_icon.uTimeout = 0;
2487 notify_icon.szInfoTitle[0] = '\0';
2488 notify_icon.dwInfoFlags = 0;
2489
2490 cv->NotifyIcon = &notify_icon;
2491
2492 Shell_NotifyIcon(NIM_ADD, cv->NotifyIcon);
2493
2494 NotifyIconShowCount = 0;
2495 }
2496
2497 return;
2498 }
2499
2500 void WINAPI DeleteNotifyIcon(PComVar cv)
2501 {
2502 if (cv->NotifyIcon) {
2503 Shell_NotifyIcon(NIM_DELETE, cv->NotifyIcon);
2504 cv->NotifyIcon = NULL;
2505 NotifyIconShowCount = 0;
2506 }
2507
2508 return;
2509 }
2510
2511 void WINAPI ShowNotifyIcon(PComVar cv)
2512 {
2513 if (cv->NotifyIcon == NULL) {
2514 CreateNotifyIcon(cv);
2515 }
2516
2517 cv->NotifyIcon->uFlags = NIF_STATE;
2518 cv->NotifyIcon->dwState = 0;
2519 cv->NotifyIcon->dwStateMask = NIS_HIDDEN;
2520 Shell_NotifyIcon(NIM_MODIFY, cv->NotifyIcon);
2521 NotifyIconShowCount += 1;
2522
2523 return;
2524 }
2525
2526 void WINAPI HideNotifyIcon(PComVar cv)
2527 {
2528 if (NotifyIconShowCount > 1) {
2529 NotifyIconShowCount -= 1;
2530 }
2531 else {
2532 if (cv->NotifyIcon) {
2533 cv->NotifyIcon->uFlags = NIF_STATE;
2534 cv->NotifyIcon->dwState = NIS_HIDDEN;
2535 cv->NotifyIcon->dwStateMask = NIS_HIDDEN;
2536 Shell_NotifyIcon(NIM_MODIFY, cv->NotifyIcon);
2537 }
2538 NotifyIconShowCount = 0;
2539 }
2540
2541 return;
2542 }
2543
2544 void WINAPI SetVerNotifyIcon(PComVar cv, unsigned int ver)
2545 {
2546 if (cv->NotifyIcon) {
2547 cv->NotifyIcon->uVersion = ver;
2548 Shell_NotifyIcon(NIM_SETVERSION, cv->NotifyIcon);
2549 }
2550 return;
2551 }
2552
2553 void WINAPI NotifyMessage(PComVar cv, char *msg, char *title, DWORD flag)
2554 {
2555 if (msg == NULL) {
2556 return;
2557 }
2558
2559 if (! HasBalloonTipSupport()) {
2560 return;
2561 }
2562
2563 if (cv->NotifyIcon == NULL) {
2564 CreateNotifyIcon(cv);
2565 }
2566
2567 cv->NotifyIcon->uFlags = NIF_INFO | NIF_STATE;
2568 cv->NotifyIcon->dwState = 0;
2569 cv->NotifyIcon->dwStateMask = NIS_HIDDEN;
2570
2571 if (title) {
2572 cv->NotifyIcon->dwInfoFlags = flag;
2573 strncpy_s(cv->NotifyIcon->szInfoTitle, sizeof(cv->NotifyIcon->szInfoTitle), title, _TRUNCATE);
2574 }
2575 else {
2576 cv->NotifyIcon->dwInfoFlags = NIIF_NONE;
2577 cv->NotifyIcon->szInfoTitle[0] = 0;
2578 }
2579
2580 strncpy_s(cv->NotifyIcon->szInfo, sizeof(cv->NotifyIcon->szInfo), msg, _TRUNCATE);
2581
2582 Shell_NotifyIcon(NIM_MODIFY, cv->NotifyIcon);
2583
2584 NotifyIconShowCount += 1;
2585
2586 return;
2587 }
2588
2589 /*
2590 * @return �G���[���L������ FALSE
2591 * @param[in] BOOL first_instance
2592 */
2593 static BOOL OpenSharedMemory(BOOL *first_instance_)
2594 {
2595 int i;
2596 HMap = NULL;
2597 pm = NULL;
2598 for (i = 0; i < 100; i++) {
2599 char tmp[32];
2600 HANDLE hMap;
2601 BOOL first_instance;
2602 TMap *map;
2603 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, i == 0 ? "%s" : "%s_%d", TT_FILEMAPNAME, i);
2604 hMap = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
2605 0, sizeof(TMap), tmp);
2606 if (hMap == NULL) {
2607 return FALSE;
2608 }
2609
2610 first_instance = (GetLastError() != ERROR_ALREADY_EXISTS);
2611
2612 map = (TMap *)MapViewOfFile(hMap,FILE_MAP_WRITE,0,0,0);
2613 if (map == NULL) {
2614 return FALSE;
2615 }
2616
2617 if (first_instance ||
2618 (map->size_tmap == sizeof(TMap) &&
2619 map->size_tttset == sizeof(TTTSet)))
2620 {
2621 map->size_tmap = sizeof(TMap);
2622 map->size_tttset = sizeof(TTTSet);
2623 HMap = hMap;
2624 pm = map;
2625 *first_instance_ = first_instance;
2626 return TRUE;
2627 }
2628
2629 // next try
2630 UnmapViewOfFile(map);
2631 CloseHandle(hMap);
2632 }
2633 return FALSE;
2634 }
2635
2636 BOOL WINAPI DllMain(HANDLE hInstance,
2637 ULONG ul_reason_for_call,
2638 LPVOID lpReserved)
2639 {
2640 switch( ul_reason_for_call ) {
2641 case DLL_THREAD_ATTACH:
2642 /* do thread initialization */
2643 break;
2644 case DLL_THREAD_DETACH:
2645 /* do thread cleanup */
2646 break;
2647 case DLL_PROCESS_ATTACH:
2648 /* do process initialization */
2649 DoCover_IsDebuggerPresent();
2650 hInst = hInstance;
2651 if (OpenSharedMemory(&FirstInstance) == FALSE) {
2652 // dll���[�h���s�Ateraterm���N��������
2653 return FALSE;
2654 }
2655 break;
2656 case DLL_PROCESS_DETACH:
2657 /* do process cleanup */
2658 UnmapViewOfFile(pm);
2659 CloseHandle(HMap);
2660 break;
2661 }
2662 return TRUE;
2663 }
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help