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 6888 - (show annotations) (download) (as text)
Wed Jul 26 03:47:58 2017 UTC (6 years, 8 months ago) by doda
File MIME type: text/x-csrc
File size: 60248 byte(s) 
現在のウィンドウ数を返す関数を作り、vtwin.cpp ではそれを使うように変更。

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