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