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 6806 - (show annotations) (download) (as text)
Thu Jun 15 00:37:01 2017 UTC (6 years, 9 months ago) by doda
File MIME type: text/x-csrc
File size: 60186 byte(s) 
TeraTerm Project としてのライセンス表記を追加

とりあえず Tera Term 本体分。
TeraTerm Project としての copyright 表記の年部分はコミットログを確認して書いたつもりだけど、ミスってたらすみません。

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