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 9244 - (show annotations) (download) (as text)
Mon May 10 14:12:02 2021 UTC (2 years, 11 months ago) by zmatsuo
File MIME type: text/x-csrc
File size: 61151 byte(s) 
キーボードに関連する部分を別ファイルに分離

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