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