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