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 9243 - (show annotations) (download) (as text)
Mon May 10 14:11:51 2021 UTC (2 years, 11 months ago) by zmatsuo
File MIME type: text/x-csrc
File size: 61125 byte(s) 
SHARED_KEYMAP マクロに関する部分を削除

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