Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/trunk/teraterm/ttpcmn/ttcmn.c

Annotation of /trunk/teraterm/ttpcmn/ttcmn.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 9292 - (hide annotations) (download) (as text)
Thu May 27 15:42:20 2021 UTC (2 years, 10 months ago) by zmatsuo
File MIME type: text/x-csrc
File size: 45800 byte(s) 
TCHAR を wchar_t(Unicode)へ変更

- 特に設定していないので、TCHAR = char
  - ANSI(非Unicode)としてコンパイルされていた
1 doda 6806 /*
2     * Copyright (C) 1994-1998 T. Teranishi
3 nmaya 9048 * (C) 2004- TeraTerm Project
4 doda 6806 * All rights reserved.
5     *
6 doda 6841 * Redistribution and use in source and binary forms, with or without
7     * modification, are permitted provided that the following conditions
8     * are met:
9 doda 6806 *
10 doda 6841 * 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 doda 6806 *
18 doda 6841 * 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 doda 6806 */
29 maya 3227
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 doda 3462 #include <locale.h>
37 maya 5308 #include <htmlhelp.h>
38 doda 8445 #include <assert.h>
39     #include <crtdbg.h>
40 maya 3227
41 zmatsuo 7536 #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 yutakapon 4915 #include "tt_res.h"
49 zmatsuo 7412 #include "codeconv.h"
50 doda 8445 #include "compat_win.h"
51 maya 3227
52 zmatsuo 7536 #define DllExport __declspec(dllexport)
53     #include "ttcommon.h"
54 zmatsuo 8496 #include "layer_for_unicode.h"
55 zmatsuo 7536
56 zmatsuo 8828 /* 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 zmatsuo 7536
78 zmatsuo 7304 // 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 maya 3227 /* 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 zmatsuo 9292 #define VTCLASSNAME "VTWin32"
92     #define TEKCLASSNAME "TEKWin32"
93 maya 3227
94 yutakapon 5299 enum window_style {
95     WIN_CASCADE,
96     WIN_STACKED,
97     WIN_SIDEBYSIDE,
98     };
99    
100    
101 zmatsuo 7305 void WINAPI CopyShmemToTTSet(PTTSet ts)
102 maya 3227 {
103     // ���������������L�����������R�s�[����
104     memcpy(ts, &pm->ts, sizeof(TTTSet));
105     }
106    
107 zmatsuo 7305 void WINAPI CopyTTSetToShmem(PTTSet ts)
108 maya 3227 {
109     // ���������������L���������R�s�[����
110     memcpy(&pm->ts, ts, sizeof(TTTSet));
111     }
112    
113    
114 zmatsuo 7305 BOOL WINAPI StartTeraTerm(PTTSet ts)
115 maya 3227 {
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 zmatsuo 7674 GetHomeDir(hInst, ts->HomeDir, sizeof(ts->HomeDir));
134 maya 3227 _chdir(ts->HomeDir);
135     GetDefaultSetupFName(ts->HomeDir, ts->SetupFName, sizeof(ts->SetupFName));
136    
137 maya 5877 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 maya 3227 if (FirstInstance) {
142     FirstInstance = FALSE;
143     return TRUE;
144     }
145 maya 3392 else {
146 maya 3227 return FALSE;
147 maya 3392 }
148 maya 3227 }
149    
150 yutakapon 4915 // �����t�@�C�����f�B�X�N���������ATera Term�{�������N�������B
151     // (2012.4.30 yutaka)
152 zmatsuo 7305 void WINAPI RestartTeraTerm(HWND hwnd, PTTSet ts)
153 yutakapon 4915 {
154     char path[1024];
155     STARTUPINFO si;
156     PROCESS_INFORMATION pi;
157 yutakapon 4916 int ret;
158 yutakapon 4915
159 zmatsuo 8616 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 doda 6435 if (ret != IDYES)
168 yutakapon 4916 return;
169    
170 yutakapon 4915 SendMessage(hwnd, WM_COMMAND, ID_SETUP_SAVE, 0);
171 yutakapon 4919 // 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 yutakapon 4915
175 yutakapon 4919 // ���v���Z�X�����N���B
176 yutakapon 4915 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 zmatsuo 7305 void WINAPI SetCOMFlag(int Com)
188 maya 3227 {
189     pm->ComFlag[(Com-1)/CHAR_BIT] |= 1 << ((Com-1)%CHAR_BIT);
190     }
191    
192 zmatsuo 7305 void WINAPI ClearCOMFlag(int Com)
193 maya 3227 {
194     pm->ComFlag[(Com-1)/CHAR_BIT] &= ~(1 << ((Com-1)%CHAR_BIT));
195     }
196    
197 zmatsuo 7305 int WINAPI CheckCOMFlag(int Com)
198 maya 3227 {
199     return ((pm->ComFlag[(Com-1)/CHAR_BIT] & 1 << (Com-1)%CHAR_BIT) > 0);
200     }
201    
202 zmatsuo 7305 int WINAPI RegWin(HWND HWinVT, HWND HWinTEK)
203 maya 3227 {
204     int i, j;
205    
206     if (pm->NWin>=MAXNWIN)
207     return 0;
208     if (HWinVT==NULL)
209     return 0;
210     if (HWinTEK!=NULL) {
211     i = 0;
212     while ((i<pm->NWin) && (pm->WinList[i]!=HWinVT))
213     i++;
214     if (i>=pm->NWin)
215     return 0;
216     for (j=pm->NWin-1 ; j>i ; j--)
217     pm->WinList[j+1] = pm->WinList[j];
218     pm->WinList[i+1] = HWinTEK;
219     pm->NWin++;
220     return 0;
221     }
222     pm->WinList[pm->NWin++] = HWinVT;
223 yutakapon 5223 memset(&pm->WinPrevRect[pm->NWin - 1], 0, sizeof(pm->WinPrevRect[pm->NWin - 1])); // RECT clear
224 maya 3392 if (pm->NWin==1) {
225 maya 3227 return 1;
226 maya 3392 }
227     else {
228 maya 3227 return (int)(SendMessage(pm->WinList[pm->NWin-2],
229 maya 3392 WM_USER_GETSERIALNO,0,0)+1);
230     }
231 maya 3227 }
232    
233 zmatsuo 7305 void WINAPI UnregWin(HWND HWin)
234 maya 3227 {
235     int i, j;
236    
237     i = 0;
238 maya 3392 while ((i<pm->NWin) && (pm->WinList[i]!=HWin)) {
239 maya 3227 i++;
240 maya 3392 }
241     if (pm->WinList[i]!=HWin) {
242 maya 3227 return;
243 maya 3392 }
244     for (j=i ; j<pm->NWin-1 ; j++) {
245 maya 3227 pm->WinList[j] = pm->WinList[j+1];
246 yutakapon 5223 pm->WinPrevRect[j] = pm->WinPrevRect[j+1]; // RECT shift
247 maya 3392 }
248     if (pm->NWin>0) {
249 maya 3227 pm->NWin--;
250 maya 3392 }
251 maya 3227 }
252    
253 doda 6435 char GetWindowTypeChar(HWND Hw, HWND HWin)
254 doda 4073 {
255 doda 4076 #if 0
256 doda 4073 if (HWin == Hw)
257     return '*';
258     else if (!IsWindowVisible(Hw))
259 doda 4076 #else
260     if (!IsWindowVisible(Hw))
261     #endif
262 doda 4073 return '#';
263     else if (IsIconic(Hw))
264     return '-';
265     else if (IsZoomed(Hw))
266     return '@';
267     else
268     return '+';
269     }
270    
271 zmatsuo 7305 void WINAPI SetWinMenu(HMENU menu, PCHAR buf, int buflen, PCHAR langFile, int VTFlag)
272 maya 3227 {
273     int i;
274     char Temp[MAXPATHLEN];
275     HWND Hw;
276 zmatsuo 8496 wchar_t uimsg[MAX_UIMSG];
277 maya 3227
278     // delete all items in Window menu
279     i = GetMenuItemCount(menu);
280     if (i>0)
281     do {
282     i--;
283     RemoveMenu(menu,i,MF_BYPOSITION);
284     } while (i>0);
285    
286     i = 0;
287     while (i<pm->NWin) {
288     Hw = pm->WinList[i]; // get window handle
289     if ((GetClassName(Hw,Temp,sizeof(Temp))>0) &&
290     ((strcmp(Temp,VTCLASSNAME)==0) ||
291     (strcmp(Temp,TEKCLASSNAME)==0))) {
292     Temp[0] = '&';
293     Temp[1] = (char)(0x31 + i);
294     Temp[2] = ' ';
295 doda 4073 Temp[3] = GetWindowTypeChar(Hw, NULL);
296     Temp[4] = ' ';
297     GetWindowText(Hw,&Temp[5],sizeof(Temp)-6);
298 maya 3227 AppendMenu(menu,MF_ENABLED | MF_STRING,ID_WINDOW_1+i,Temp);
299     i++;
300 maya 3392 if (i>8) {
301 maya 3227 i = pm->NWin;
302 maya 3392 }
303 maya 3227 }
304 maya 3392 else {
305 maya 3227 UnregWin(Hw);
306 maya 3392 }
307 maya 3227 }
308     if (VTFlag == 1) {
309 zmatsuo 8496 static const DlgTextInfo MenuTextInfo[] = {
310     { ID_WINDOW_WINDOW, "MENU_WINDOW_WINDOW" },
311     { ID_WINDOW_MINIMIZEALL, "MENU_WINDOW_MINIMIZEALL" },
312     { ID_WINDOW_RESTOREALL, "MENU_WINDOW_RESTOREALL" },
313     { ID_WINDOW_CASCADEALL, "MENU_WINDOW_CASCADE" },
314     { ID_WINDOW_STACKED, "MENU_WINDOW_STACKED" },
315     { ID_WINDOW_SIDEBYSIDE, "MENU_WINDOW_SIDEBYSIDE" },
316     };
317    
318 maya 4655 AppendMenu(menu, MF_SEPARATOR, 0, NULL);
319 zmatsuo 8496 AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_WINDOW, "&Window");
320     AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_MINIMIZEALL, "&Minimize All");
321     AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_RESTOREALL, "&Restore All");
322     AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_CASCADEALL, "&Cascade");
323     AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_STACKED, "&Stacked");
324     AppendMenu(menu, MF_ENABLED | MF_STRING, ID_WINDOW_SIDEBYSIDE, "Side &by Side");
325 doda 4647
326 zmatsuo 8496 SetI18nMenuStrs("Tera Term", menu, MenuTextInfo, _countof(MenuTextInfo), langFile);
327 doda 4647
328 yutakapon 5299 if (pm->WinUndoFlag) {
329     if (pm->WinUndoStyle == WIN_CASCADE)
330 zmatsuo 8496 get_lang_msgW("MENU_WINDOW_CASCADE_UNDO", uimsg, _countof(uimsg), L"&Undo - Cascade", langFile);
331 yutakapon 5299 else if (pm->WinUndoStyle == WIN_STACKED)
332 zmatsuo 8496 get_lang_msgW("MENU_WINDOW_STACKED_UNDO", uimsg, _countof(uimsg), L"&Undo - Stacked", langFile);
333 yutakapon 5299 else
334 zmatsuo 8496 get_lang_msgW("MENU_WINDOW_SIDEBYSIDE_UNDO", uimsg, _countof(uimsg), L"&Undo - Side by Side", langFile);
335     _AppendMenuW(menu, MF_ENABLED | MF_STRING, ID_WINDOW_UNDO, uimsg); // TODO UNICODE
336 yutakapon 5299 }
337    
338 maya 3227 }
339     else {
340 zmatsuo 8496 get_lang_msgW("MENU_WINDOW_WINDOW", uimsg, _countof(uimsg), L"&Window", langFile);
341     _AppendMenuW(menu,MF_ENABLED | MF_STRING,ID_TEKWINDOW_WINDOW, uimsg);
342 maya 3227 }
343     }
344    
345 zmatsuo 7305 void WINAPI SetWinList(HWND HWin, HWND HDlg, int IList)
346 maya 3227 {
347     int i;
348     char Temp[MAXPATHLEN];
349     HWND Hw;
350    
351     for (i=0; i<pm->NWin; i++) {
352     Hw = pm->WinList[i]; // get window handle
353     if ((GetClassName(Hw,Temp,sizeof(Temp))>0) &&
354     ((strcmp(Temp,VTCLASSNAME)==0) ||
355     (strcmp(Temp,TEKCLASSNAME)==0))) {
356 doda 4073 Temp[0] = GetWindowTypeChar(Hw, HWin);
357     Temp[1] = ' ';
358     GetWindowText(Hw,&Temp[2],sizeof(Temp)-3);
359 maya 3227 SendDlgItemMessage(HDlg, IList, LB_ADDSTRING,
360 zmatsuo 7896 0, (LPARAM)Temp);
361 maya 3392 if (Hw==HWin) {
362     SendDlgItemMessage(HDlg, IList, LB_SETCURSEL, i,0);
363     }
364 maya 3227 }
365 maya 3392 else {
366 maya 3227 UnregWin(Hw);
367 maya 3392 }
368 maya 3227 }
369     }
370    
371 zmatsuo 7305 void WINAPI SelectWin(int WinId)
372 maya 3227 {
373     if ((WinId>=0) && (WinId<pm->NWin)) {
374 yutakapon 3673 /* �E�B���h�E�����������������������������������A���������������������������A
375     * SW_SHOWNORMAL ���� SW_SHOW �����X�����B
376     * (2009.11.8 yutaka)
377 maya 3675 * �E�B���h�E�����������������������������T�C�Y������(SW_RESTORE)�����������B
378     * (2009.11.9 maya)
379 yutakapon 3673 */
380 maya 3675 if (IsIconic(pm->WinList[WinId])) {
381     ShowWindow(pm->WinList[WinId],SW_RESTORE);
382     }
383     else {
384     ShowWindow(pm->WinList[WinId],SW_SHOW);
385     }
386 maya 3227 SetForegroundWindow(pm->WinList[WinId]);
387     }
388     }
389    
390 zmatsuo 7305 void WINAPI SelectNextWin(HWND HWin, int Next, BOOL SkipIconic)
391 maya 3227 {
392     int i;
393    
394     i = 0;
395 doda 3950 while ((i < pm->NWin) && (pm->WinList[i]!=HWin)) {
396     i++;
397     }
398     if (pm->WinList[i]!=HWin) {
399     return;
400     }
401    
402     do {
403     i += Next;
404     if (i >= pm->NWin) {
405     i = 0;
406     }
407     else if (i < 0) {
408     i = pm->NWin-1;
409     }
410    
411     if (pm->WinList[i] == HWin) {
412 doda 4030 break;
413 doda 3950 }
414 doda 4030 } while ((SkipIconic && IsIconic(pm->WinList[i])) || !IsWindowVisible(pm->WinList[i]));
415 doda 3950
416     SelectWin(i);
417     }
418    
419 zmatsuo 7305 void WINAPI ShowAllWin(int stat) {
420 doda 4647 int i;
421 doda 5280
422     for (i=0; i < pm->NWin; i++) {
423     ShowWindow(pm->WinList[i], stat);
424     }
425     }
426    
427 zmatsuo 7305 void WINAPI UndoAllWin(void) {
428 doda 5280 int i;
429 yutakapon 5223 WINDOWPLACEMENT rc0;
430     RECT rc;
431 yutakapon 5299 int stat = SW_RESTORE;
432 yutakapon 5407 int multi_mon = 0;
433 doda 4647
434 yutakapon 6286 if (HasMultiMonitorSupport()) {
435 yutakapon 5407 multi_mon = 1;
436     }
437    
438 yutakapon 5299 // ���x�A�����������t���O���������B
439     pm->WinUndoFlag = FALSE;
440    
441 yutakapon 5223 memset(&rc0, 0, sizeof(rc0));
442    
443 doda 4647 for (i=0; i < pm->NWin; i++) {
444 yutakapon 5223 // �����w�����A�O�����������c���������������A�E�B���h�E�����������������B
445     if (stat == SW_RESTORE && memcmp(&pm->WinPrevRect[i], &rc0, sizeof(rc0)) != 0) {
446     rc = pm->WinPrevRect[i].rcNormalPosition;
447    
448 yutakapon 5407 // NT4.0, 95 ���}���`���j�^API��������
449     if (multi_mon) {
450     // �������j�^������������
451 zmatsuo 8517 HMONITOR hMonitor;
452     MONITORINFO mi;
453     hMonitor = pMonitorFromRect(&rc, MONITOR_DEFAULTTONEAREST);
454 yutakapon 5407 mi.cbSize = sizeof(MONITORINFO);
455 zmatsuo 8517 pGetMonitorInfoA(hMonitor, &mi);
456 yutakapon 5223
457 yutakapon 5407 // ���u�����i�����O���������x���������������������������j
458     if (rc.right > mi.rcMonitor.right) {
459     rc.left -= rc.right - mi.rcMonitor.right;
460     rc.right = mi.rcMonitor.right;
461     }
462     if (rc.left < mi.rcMonitor.left) {
463     rc.right += mi.rcMonitor.left - rc.left;
464     rc.left = mi.rcMonitor.left;
465     }
466     if (rc.bottom > mi.rcMonitor.bottom) {
467     rc.top -= rc.bottom - mi.rcMonitor.bottom;
468     rc.bottom = mi.rcMonitor.bottom;
469     }
470     if (rc.top < mi.rcMonitor.top) {
471     rc.bottom += mi.rcMonitor.top - rc.top;
472     rc.top = mi.rcMonitor.top;
473     }
474 yutakapon 5223 }
475    
476     // �E�B���h�E���u����
477     SetWindowPos(
478 doda 6435 pm->WinList[i], NULL,
479     rc.left,
480 yutakapon 5223 rc.top,
481 doda 6435 rc.right - rc.left,
482 yutakapon 5223 rc.bottom - rc.top,
483     SWP_NOZORDER);
484    
485 yutakapon 5230 // �E�B���h�E����������
486     ShowWindow(pm->WinList[i], pm->WinPrevRect[i].showCmd);
487 yutakapon 5223
488     } else {
489     ShowWindow(pm->WinList[i], stat);
490     }
491 doda 4647 }
492     }
493    
494 zmatsuo 7305 void WINAPI OpenHelp(UINT Command, DWORD Data, char *UILanguageFile)
495 maya 5308 {
496     char HomeDir[MAX_PATH];
497     char Temp[MAX_PATH];
498     HWND HWin;
499 zmatsuo 8496 wchar_t HelpFN[MAX_PATH];
500     wchar_t uimsg[MAX_UIMSG];
501 zmatsuo 8516 wchar_t *HomeDirW;
502 maya 5308
503 zmatsuo 8576 /* Get home directory */
504 zmatsuo 7412 if (GetModuleFileNameA(NULL,Temp,_countof(Temp)) == 0) {
505 maya 5308 return;
506     }
507     ExtractDirName(Temp, HomeDir);
508 zmatsuo 8516 HomeDirW = ToWcharA(HomeDir);
509 zmatsuo 8496 get_lang_msgW("HELPFILE", uimsg, _countof(uimsg), L"teraterm.chm", UILanguageFile);
510 zmatsuo 8516 _snwprintf_s(HelpFN, _countof(HelpFN), _TRUNCATE, L"%s\\%s", HomeDirW, uimsg);
511     free(HomeDirW);
512 maya 5308
513     // �w���v���I�[�i�[�������f�X�N�g�b�v������ (2007.5.12 maya)
514     HWin = GetDesktopWindow();
515 zmatsuo 8576 if (_HtmlHelpW(HWin, HelpFN, Command, Data) == NULL) {
516 zmatsuo 8516 // �w���v���J����������
517 zmatsuo 8616 static const TTMessageBoxInfoW info = {
518     "Tera Term",
519     NULL, L"Tera Term: HTML help",
520     "MSG_OPENHELP_ERROR", L"Can't open HTML help file(%s)." };
521     TTMessageBoxW(HWin, &info, MB_OK | MB_ICONERROR, UILanguageFile, HelpFN);
522 zmatsuo 8516 return;
523 zmatsuo 8496 }
524 maya 5308 }
525    
526 zmatsuo 7305 HWND WINAPI GetNthWin(int n)
527 maya 3227 {
528 maya 3392 if (n<pm->NWin) {
529 maya 3227 return pm->WinList[n];
530 maya 3392 }
531     else {
532 maya 3227 return NULL;
533 maya 3392 }
534 maya 3227 }
535    
536 zmatsuo 7725 int WINAPI GetRegisteredWindowCount(void)
537 doda 6888 {
538     return (pm->NWin);
539     }
540 yutakapon 5222
541 yutakapon 5223 // �L�����E�B���h�E���T���A�������u���L�������������B
542 yutakapon 5299 static void get_valid_window_and_memorize_rect(HWND myhwnd, HWND hwnd[], int *num, int style)
543 yutakapon 5222 {
544 yutakapon 5223 int i, n;
545     WINDOWPLACEMENT wndPlace;
546 yutakapon 5222
547 yutakapon 5299 // ��������(Undo)���j���[�����x�����\���������B
548     if (pm->WinUndoFlag == FALSE) {
549     pm->WinUndoFlag = TRUE;
550     } else {
551     // ���������j���[���\�������������A�������O�������X�^�C�����I�����������A
552     // ���j���[�������B
553     // Windows8�����A�������A�����������X�^�C�����I�����������j���[�����������������A
554     // Tera Term�������j���[���\�������������A�������������B
555     if (pm->WinUndoStyle == style)
556     pm->WinUndoFlag = FALSE;
557     }
558     pm->WinUndoStyle = style;
559    
560 yutakapon 5222 n = 0;
561     for (i = 0 ; i < pm->NWin ; i++) {
562 yutakapon 5223 // �������u���o���������B
563     wndPlace.length = sizeof(WINDOWPLACEMENT);
564     GetWindowPlacement(pm->WinList[i], &wndPlace);
565     pm->WinPrevRect[i] = wndPlace;
566    
567     // �������g�������������B
568 yutakapon 5222 if (pm->WinList[i] == myhwnd) {
569     hwnd[n] = hwnd[0];
570     hwnd[0] = myhwnd;
571     } else {
572     hwnd[n] = pm->WinList[i];
573     }
574     n++;
575     }
576 yutakapon 5223 *num = n;
577     }
578 yutakapon 5222
579 yutakapon 5223 // �E�B���h�E�����E���������\������(Show Windows Side by Side)
580 zmatsuo 7305 void WINAPI ShowAllWinSidebySide(HWND myhwnd)
581 yutakapon 5223 {
582     int n;
583     HWND hwnd[MAXNWIN];
584    
585 yutakapon 5299 get_valid_window_and_memorize_rect(myhwnd, hwnd, &n, WIN_SIDEBYSIDE);
586 yutakapon 5251 TileWindows(NULL, MDITILE_VERTICAL, NULL, n, hwnd);
587 yutakapon 5222 }
588    
589     // �E�B���h�E���������������\������(Show Windows Stacked)
590 zmatsuo 7305 void WINAPI ShowAllWinStacked(HWND myhwnd)
591 yutakapon 5222 {
592 yutakapon 5223 int n;
593 yutakapon 5222 HWND hwnd[MAXNWIN];
594    
595 yutakapon 5299 get_valid_window_and_memorize_rect(myhwnd, hwnd, &n, WIN_STACKED);
596 yutakapon 5251 TileWindows(NULL, MDITILE_HORIZONTAL, NULL, n, hwnd);
597 yutakapon 5222 }
598    
599     // �E�B���h�E���d�����\������(Cascade)
600 zmatsuo 7305 void WINAPI ShowAllWinCascade(HWND myhwnd)
601 yutakapon 5222 {
602 yutakapon 5223 int n;
603     HWND hwnd[MAXNWIN];
604    
605 yutakapon 5299 get_valid_window_and_memorize_rect(myhwnd, hwnd, &n, WIN_CASCADE);
606 yutakapon 5251 CascadeWindows(NULL, MDITILE_SKIPDISABLED, NULL, n, hwnd);
607 yutakapon 5222 }
608    
609 yutakapon 5232 // �STera Term���I���w�����o���B
610 zmatsuo 7305 void WINAPI BroadcastClosingMessage(HWND myhwnd)
611 yutakapon 5232 {
612     int i, max;
613     HWND hwnd[MAXNWIN];
614    
615     // Tera Term���I�����������A���L���������������������A
616     // ���������o�b�t�@���R�s�[���������B
617     max = pm->NWin;
618     for (i = 0 ; i < pm->NWin ; i++) {
619     hwnd[i] = pm->WinList[i];
620     }
621    
622     for (i = 0 ; i < max ; i++) {
623     // �������g�������������B
624 doda 6435 if (hwnd[i] == myhwnd)
625 yutakapon 5232 continue;
626    
627     PostMessage(hwnd[i], WM_USER_NONCONFIRM_CLOSE, 0, 0);
628     }
629     PostMessage(myhwnd, WM_USER_NONCONFIRM_CLOSE, 0, 0);
630     }
631    
632    
633 zmatsuo 7305 int WINAPI CommReadRawByte(PComVar cv, LPBYTE b)
634 maya 3227 {
635 maya 3392 if ( ! cv->Ready ) {
636 maya 3227 return 0;
637 maya 3392 }
638 maya 3227
639     if ( cv->InBuffCount>0 ) {
640     *b = cv->InBuff[cv->InPtr];
641     cv->InPtr++;
642     cv->InBuffCount--;
643 maya 3392 if ( cv->InBuffCount==0 ) {
644 maya 3227 cv->InPtr = 0;
645 maya 3392 }
646 maya 3227 return 1;
647     }
648     else {
649     cv->InPtr = 0;
650     return 0;
651     }
652     }
653    
654 zmatsuo 8897 static void LogBinSkip(PComVar cv, int add)
655     {
656     if (cv->LogBinSkip != NULL) {
657     cv->LogBinSkip(add);
658     }
659     }
660    
661 zmatsuo 7305 void WINAPI CommInsert1Byte(PComVar cv, BYTE b)
662 maya 3227 {
663 maya 3392 if ( ! cv->Ready ) {
664 maya 3227 return;
665 maya 3392 }
666 maya 3227
667 maya 3392 if (cv->InPtr == 0) {
668 maya 3227 memmove(&(cv->InBuff[1]),&(cv->InBuff[0]),cv->InBuffCount);
669 maya 3392 }
670     else {
671 maya 3227 cv->InPtr--;
672 maya 3392 }
673 maya 3227 cv->InBuff[cv->InPtr] = b;
674     cv->InBuffCount++;
675    
676 zmatsuo 8897 LogBinSkip(cv, 1);
677 maya 3227 }
678    
679 zmatsuo 8897 static void Log1Bin(PComVar cv, BYTE b)
680 maya 3227 {
681 zmatsuo 8897 if (cv->Log1Bin != NULL) {
682     cv->Log1Bin(b);
683 maya 3392 }
684 maya 3227 }
685    
686 zmatsuo 7305 int WINAPI CommRead1Byte(PComVar cv, LPBYTE b)
687 maya 3227 {
688     int c;
689    
690 maya 3392 if ( ! cv->Ready ) {
691 maya 3227 return 0;
692 maya 3392 }
693 maya 3227
694 maya 3392 if ( cv->TelMode ) {
695 maya 3227 c = 0;
696 maya 3392 }
697     else {
698 maya 3227 c = CommReadRawByte(cv,b);
699 maya 3392 }
700 maya 3227
701     if ((c==1) && cv->TelCRFlag) {
702     cv->TelCRFlag = FALSE;
703 maya 3392 if (*b==0) {
704     c = 0;
705     }
706 maya 3227 }
707    
708     if ( c==1 ) {
709     if ( cv->IACFlag ) {
710     cv->IACFlag = FALSE;
711     if ( *b != 0xFF ) {
712     cv->TelMode = TRUE;
713     CommInsert1Byte(cv,*b);
714 zmatsuo 8897 LogBinSkip(cv, -1);
715 maya 3227 c = 0;
716     }
717     }
718     else if ((cv->PortType==IdTCPIP) && (*b==0xFF)) {
719 maya 3392 if (!cv->TelFlag && cv->TelAutoDetect) { /* TTPLUG */
720 maya 3227 cv->TelFlag = TRUE;
721 maya 3392 }
722 maya 3227 if (cv->TelFlag) {
723     cv->IACFlag = TRUE;
724     c = 0;
725     }
726     }
727 maya 3392 else if (cv->TelFlag && ! cv->TelBinRecv && (*b==0x0D)) {
728 maya 3227 cv->TelCRFlag = TRUE;
729 maya 3392 }
730 maya 3227 }
731    
732 zmatsuo 8897 if (c == 1) {
733 maya 3227 Log1Bin(cv, *b);
734 maya 3392 }
735 maya 3227
736     return c;
737     }
738    
739 doda 8445 int WINAPI CommRawOut(PComVar cv, /*const*/ PCHAR B, int C)
740 maya 3227 {
741     int a;
742    
743 maya 3392 if ( ! cv->Ready ) {
744 maya 3227 return C;
745 maya 3392 }
746 maya 3227
747 maya 3392 if (C > OutBuffSize - cv->OutBuffCount) {
748 maya 3227 a = OutBuffSize - cv->OutBuffCount;
749 maya 3392 }
750     else {
751 maya 3227 a = C;
752 maya 3392 }
753 maya 3227 if ( cv->OutPtr > 0 ) {
754     memmove(&(cv->OutBuff[0]),&(cv->OutBuff[cv->OutPtr]),cv->OutBuffCount);
755     cv->OutPtr = 0;
756     }
757     memcpy(&(cv->OutBuff[cv->OutBuffCount]),B,a);
758     cv->OutBuffCount = cv->OutBuffCount + a;
759     return a;
760     }
761    
762 zmatsuo 7305 int WINAPI CommBinaryOut(PComVar cv, PCHAR B, int C)
763 maya 3227 {
764     int a, i, Len;
765     char d[3];
766    
767 maya 3392 if ( ! cv->Ready ) {
768 maya 3227 return C;
769 maya 3392 }
770 maya 3227
771     i = 0;
772     a = 1;
773     while ((a>0) && (i<C)) {
774     Len = 0;
775    
776     d[Len] = B[i];
777     Len++;
778    
779 doda 3505 if ( cv->TelFlag && (B[i]=='\x0d') && ! cv->TelBinSend ) {
780     d[Len++] = '\x00';
781 maya 3227 }
782 doda 3505 else if ( cv->TelFlag && (B[i]=='\xff') ) {
783     d[Len++] = '\xff';
784     }
785 maya 3227
786 doda 3505 if ( OutBuffSize - cv->OutBuffCount - Len >= 0 ) {
787     CommRawOut(cv, d, Len);
788 maya 3227 a = 1;
789     }
790 maya 3392 else {
791 maya 3227 a = 0;
792 maya 3392 }
793 maya 3227
794 doda 3505 i += a;
795 maya 3227 }
796     return i;
797     }
798    
799 doda 8445 /**
800     * �f�[�^(������)���o���o�b�t�@����������
801     *
802     * �w���f�[�^��������������������������������������
803     * CommRawOut() ��������������������������
804     *
805     * @retval TRUE �o��������
806     * @retval FALSE �o��������������(buffer full)
807     */
808     static BOOL WriteOutBuff(PComVar cv, const char *TempStr, int TempLen)
809     {
810     BOOL output;
811    
812     if (TempLen == 0) {
813     // ����0������������������������
814     return TRUE;
815     }
816    
817     output = FALSE;
818     if (cv->TelLineMode) {
819     const BOOL Full = OutBuffSize - cv->LineModeBuffCount - TempLen < 0;
820     if (!Full) {
821     output = TRUE;
822     memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), TempStr, TempLen);
823     cv->LineModeBuffCount += TempLen;
824     if (cv->Flush) {
825     cv->FlushLen = cv->LineModeBuffCount;
826     }
827     }
828     if (cv->FlushLen > 0) {
829     const int OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
830     cv->FlushLen -= OutLen;
831     cv->LineModeBuffCount -= OutLen;
832     memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
833     }
834     cv->Flush = FALSE;
835     }
836     else {
837     const BOOL Full = OutBuffSize-cv->OutBuffCount-TempLen < 0;
838     if (! Full) {
839     output = TRUE;
840     CommRawOut(cv, (char *)TempStr, TempLen);
841     }
842     }
843     return output;
844     }
845    
846     /**
847     * �f�[�^(������)�������o�b�t�@����������
848     * �����o�b�t�@�������� -> �G�R�[������
849     *
850     * @retval TRUE �o��������
851     * @retval FALSE �o��������������(buffer full)
852     */
853     static BOOL WriteInBuff(PComVar cv, const char *TempStr, int TempLen)
854     {
855     BOOL Full;
856    
857     if (TempLen == 0) {
858     return TRUE;
859     }
860    
861     Full = InBuffSize-cv->InBuffCount-TempLen < 0;
862     if (! Full) {
863     memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
864     cv->InBuffCount = cv->InBuffCount + TempLen;
865     return TRUE;
866     }
867     return FALSE;
868     }
869    
870     /**
871     * �����o�b�t�@�����������������������l����
872     */
873     static void PackInBuff(PComVar cv)
874     {
875     if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
876     memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
877     cv->InPtr = 0;
878     }
879     }
880    
881 zmatsuo 7305 int WINAPI CommBinaryBuffOut(PComVar cv, PCHAR B, int C)
882 doda 3505 {
883 doda 8445 int a, i, Len;
884 doda 3505 char d[3];
885    
886     if ( ! cv->Ready ) {
887     return C;
888     }
889    
890     i = 0;
891     a = 1;
892     while ((a>0) && (i<C)) {
893     Len = 0;
894    
895     d[Len] = B[i];
896     Len++;
897    
898     if (B[i] == CR) {
899     if ( cv->TelFlag && ! cv->TelBinSend ) {
900     d[Len++] = '\x00';
901     }
902     if (cv->TelLineMode) {
903     cv->Flush = TRUE;
904     }
905     }
906     else if ( cv->TelFlag && (B[i]=='\xff') ) {
907     d[Len++] = '\xff';
908     }
909    
910 doda 8445 if (WriteOutBuff(cv, d, Len)) {
911     a = 1;
912     i++;
913     } else {
914     a = 0;
915 doda 3505 }
916     }
917     return i;
918     }
919    
920 zmatsuo 7462 // �����R�[�h(CodePage)��UTF-8���o������
921 doda 3442 static int OutputTextUTF8(WORD K, char *TempStr, PComVar cv)
922 maya 3227 {
923 zmatsuo 7462 int CodePage = *cv->CodePage;
924 maya 3227 unsigned int code;
925 doda 3442 int outlen;
926 maya 3227
927 zmatsuo 7466 code = MBCP_UTF32(K, CodePage);
928 zmatsuo 7464 if (code == 0) {
929     // �������s
930     code = 0xfffd; // U+FFFD: Replacement Character
931     }
932 zmatsuo 7462 outlen = UTF32ToUTF8(code, TempStr, 4);
933     return outlen;
934 maya 3227 }
935    
936 zmatsuo 9130 static int __isleadbyte_l(int d, PComVar cv)
937     {
938     int CodePage = *cv->CodePage;
939     return IsDBCSLeadByteEx(CodePage, d);
940     }
941    
942 doda 6435 //
943 doda 3451 // MBCS�����e�������R�[�h�����������o�������B
944 maya 3227 //
945 zmatsuo 7411 static int TextOutMBCS(PComVar cv, PCHAR B, int C)
946 maya 3227 {
947 doda 8445 int i, TempLen;
948 maya 3227 WORD K;
949 doda 3442 char TempStr[12];
950 maya 3227 BYTE d;
951 doda 8445 BOOL Full;
952     int SendCodeNew; // ���M�R�[�h
953     BOOL KanjiFlagNew; // TRUE=����������������������������
954 maya 3227
955     Full = FALSE;
956     i = 0;
957     while (! Full && (i < C)) {
958     TempLen = 0;
959     d = (BYTE)B[i];
960     SendCodeNew = cv->SendCode;
961 doda 3442 KanjiFlagNew = FALSE;
962 maya 3227
963     if (cv->SendKanjiFlag) {
964     SendCodeNew = IdKanji;
965    
966     K = (cv->SendKanjiFirst << 8) + d;
967    
968     // UTF-8�����������s���B1�`3�o�C�g���������������������B
969 doda 3408 if (cv->KanjiCodeSend == IdUTF8 || cv->Language == IdUtf8) {
970 doda 3442 TempLen += OutputTextUTF8(K, TempStr, cv);
971     }
972     else {
973     switch (cv->Language) {
974     case IdJapanese:
975 doda 6435 switch (cv->KanjiCodeSend) {
976 doda 3442 case IdEUC:
977 doda 3419 K = SJIS2EUC(K);
978 doda 3442 break;
979     case IdJIS:
980 doda 3419 K = SJIS2JIS(K);
981 doda 3442 if ((cv->SendCode==IdKatakana) &&
982     (cv->JIS7KatakanaSend==1)) {
983     TempStr[TempLen++] = SI;
984     }
985     break;
986     case IdSJIS:
987     /* nothing to do */
988     break;
989 doda 3419 }
990 doda 3442 break;
991     case IdKorean:
992 doda 6435 break;
993 maya 3227 }
994 doda 3442 TempStr[TempLen++] = HIBYTE(K);
995     TempStr[TempLen++] = LOBYTE(K);
996 maya 3227 }
997     }
998 zmatsuo 9130 else if (__isleadbyte_l(d, cv)) {
999 maya 3227 KanjiFlagNew = TRUE;
1000     cv->SendKanjiFirst = d;
1001     SendCodeNew = IdKanji;
1002    
1003 doda 3442 if (cv->Language == IdJapanese) {
1004     if ((cv->SendCode!=IdKanji) && (cv->KanjiCodeSend==IdJIS)) {
1005     TempStr[0] = 0x1B;
1006     TempStr[1] = '$';
1007     if (cv->KanjiIn == IdKanjiInB) {
1008     TempStr[2] = 'B';
1009     }
1010     else {
1011     TempStr[2] = '@';
1012     }
1013     TempLen = 3;
1014 maya 3392 }
1015 maya 3227 }
1016     }
1017     else {
1018 doda 3442 if (cv->Language == IdJapanese) {
1019     if ((cv->SendCode==IdKanji) && (cv->KanjiCodeSend==IdJIS)) {
1020     TempStr[0] = 0x1B;
1021     TempStr[1] = '(';
1022     switch (cv->KanjiOut) {
1023     case IdKanjiOutJ:
1024 maya 3409 TempStr[2] = 'J';
1025     break;
1026 doda 3442 case IdKanjiOutH:
1027 maya 3409 TempStr[2] = 'H';
1028     break;
1029 doda 3442 default:
1030 maya 3409 TempStr[2] = 'B';
1031 doda 3442 }
1032     TempLen = 3;
1033 maya 3227 }
1034    
1035 doda 3442 if ((0xa0<d) && (d<0xe0)) {
1036     SendCodeNew = IdKatakana;
1037     if ((cv->SendCode!=IdKatakana) &&
1038     (cv->KanjiCodeSend==IdJIS) &&
1039     (cv->JIS7KatakanaSend==1)) {
1040     TempStr[TempLen++] = SO;
1041     }
1042 maya 3227 }
1043 doda 3442 else {
1044     SendCodeNew = IdASCII;
1045     if ((cv->SendCode==IdKatakana) &&
1046     (cv->KanjiCodeSend==IdJIS) &&
1047     (cv->JIS7KatakanaSend==1)) {
1048     TempStr[TempLen++] = SI;
1049     }
1050 maya 3227 }
1051     }
1052    
1053 doda 3497 if (d==CR) {
1054 doda 3442 TempStr[TempLen++] = 0x0d;
1055 maya 3227 if (cv->CRSend==IdCRLF) {
1056 doda 3442 TempStr[TempLen++] = 0x0a;
1057 maya 3227 }
1058     else if ((cv->CRSend==IdCR) &&
1059 doda 3398 cv->TelFlag && ! cv->TelBinSend) {
1060 doda 3442 TempStr[TempLen++] = 0;
1061 maya 3227 }
1062 maya 6369 else if (cv->CRSend == IdLF) {
1063     TempStr[TempLen-1] = 0x0a;
1064     }
1065 doda 3494 if (cv->TelLineMode) {
1066     cv->Flush = TRUE;
1067     }
1068 maya 3227 }
1069 doda 3497 else if (d==BS) {
1070     if (cv->TelLineMode) {
1071     if (cv->FlushLen < cv->LineModeBuffCount) {
1072     cv->LineModeBuffCount--;
1073     }
1074     }
1075 maya 6369 else {
1076 doda 3497 TempStr[TempLen++] = d;
1077     }
1078     }
1079 doda 3498 else if (d==0x15) { // Ctrl-U
1080     if (cv->TelLineMode) {
1081     cv->LineModeBuffCount = cv->FlushLen;
1082     }
1083 maya 6369 else {
1084 doda 3498 TempStr[TempLen++] = d;
1085     }
1086     }
1087 doda 3442 else if ((d>=0x80) && (cv->KanjiCodeSend==IdUTF8 || cv->Language==IdUtf8)) {
1088     TempLen += OutputTextUTF8((WORD)d, TempStr, cv);
1089     }
1090     else if ((d>=0xa1) && (d<=0xe0) && (cv->Language == IdJapanese)) {
1091 doda 3452 /* Katakana */
1092 maya 3227 if (cv->KanjiCodeSend==IdEUC) {
1093 doda 3444 TempStr[TempLen++] = (char)SS2;
1094 maya 3227 }
1095     if ((cv->KanjiCodeSend==IdJIS) &&
1096 maya 3392 (cv->JIS7KatakanaSend==1)) {
1097 doda 3442 TempStr[TempLen++] = d & 0x7f;
1098 maya 3392 }
1099     else {
1100 doda 3442 TempStr[TempLen++] = d;
1101 maya 3392 }
1102 maya 3227 }
1103     else {
1104 doda 3442 TempStr[TempLen++] = d;
1105 maya 3227 if (cv->TelFlag && (d==0xff)) {
1106 doda 3442 TempStr[TempLen++] = (char)0xff;
1107 maya 3227 }
1108     }
1109     } // if (cv->SendKanjiFlag) else if ... else ... end
1110    
1111 doda 8445 if (WriteOutBuff(cv, TempStr, TempLen)) {
1112     i++; // 1������������
1113     // ��������������������
1114     cv->SendCode = SendCodeNew;
1115     cv->SendKanjiFlag = KanjiFlagNew;
1116     } else {
1117     Full = TRUE;
1118 maya 3227 }
1119    
1120     } // end of "while {}"
1121    
1122     return i;
1123     }
1124    
1125 zmatsuo 7305 int WINAPI CommTextOut(PComVar cv, PCHAR B, int C)
1126 maya 3227 {
1127 doda 8445 int i, TempLen;
1128 doda 3442 char TempStr[12];
1129 maya 3227 BYTE d;
1130     BOOL Full;
1131    
1132 maya 3392 if (! cv->Ready ) {
1133 maya 3227 return C;
1134 maya 3392 }
1135 maya 3227
1136 maya 4009 switch (cv->Language) {
1137     case IdUtf8:
1138     case IdJapanese:
1139     case IdKorean:
1140     return TextOutMBCS(cv, B, C);
1141     break;
1142 maya 3392 }
1143 maya 3227
1144     Full = FALSE;
1145     i = 0;
1146     while (! Full && (i < C)) {
1147     TempLen = 0;
1148     d = (BYTE)B[i];
1149 doda 6435
1150 doda 3497 switch (d) {
1151     case CR:
1152 maya 3227 TempStr[TempLen] = 0x0d;
1153     TempLen++;
1154     if (cv->CRSend==IdCRLF) {
1155 doda 3452 TempStr[TempLen++] = 0x0a;
1156 maya 3227 }
1157 doda 3452 else if (cv->CRSend==IdCR && cv->TelFlag && ! cv->TelBinSend) {
1158     TempStr[TempLen++] = 0;
1159 maya 3227 }
1160 maya 6369 else if (cv->CRSend == IdLF) {
1161     TempStr[TempLen-1] = 0x0a;
1162     }
1163 doda 3494 if (cv->TelLineMode) {
1164     cv->Flush = TRUE;
1165     }
1166 doda 3497 break;
1167    
1168     case BS:
1169     if (cv->TelLineMode) {
1170     if (cv->FlushLen < cv->LineModeBuffCount) {
1171     cv->LineModeBuffCount--;
1172     }
1173     }
1174 doda 6435 else {
1175 doda 3497 TempStr[TempLen++] = d;
1176     }
1177     break;
1178    
1179 doda 3498 case 0x15: // Ctrl-U
1180     if (cv->TelLineMode) {
1181     cv->LineModeBuffCount = cv->FlushLen;
1182     }
1183     else {
1184     TempStr[TempLen++] = d;
1185     }
1186 doda 3504 break;
1187 doda 3498
1188 doda 3497 default:
1189 doda 3452 if ((cv->Language==IdRussian) && (d>=128)) {
1190 doda 3494 d = RussConv(cv->RussClient, cv->RussHost, d);
1191 doda 3452 }
1192     TempStr[TempLen++] = d;
1193 maya 3227 if (cv->TelFlag && (d==0xff)) {
1194 doda 3452 TempStr[TempLen++] = (char)0xff;
1195 maya 3227 }
1196     }
1197    
1198 doda 8445 if (WriteOutBuff(cv, TempStr, TempLen)) {
1199     i++; // 1������������
1200     } else {
1201     Full = TRUE;
1202     }
1203    
1204     } // end of while {}
1205    
1206     return i;
1207     }
1208    
1209     /**
1210     * @retval true ���{�������p�J�^�J�i
1211     * @retval false ������
1212     */
1213     static BOOL IsHalfWidthKatakana(unsigned int u32)
1214     {
1215     // Halfwidth CJK punctuation (U+FF61�`FF64)
1216     // Halfwidth Katakana variants (U+FF65�`FF9F)
1217     return (0xff61 <= u32 && u32 <= 0xff9f);
1218     }
1219    
1220     /**
1221     * �o���p�A TODO echo�p������
1222     * @param cv
1223     * @param u32 ��������
1224     * @param check_only TRUE���������s�����A
1225     * @param TempStr �o��������
1226     * @param StrLen TempStr�����o��������
1227     * @retval �������s����
1228     */
1229     static BOOL OutControl(PComVar cv, unsigned int u32, BOOL check_only, char *TempStr, size_t *StrLen)
1230     {
1231     const wchar_t d = u32;
1232     size_t TempLen = 0;
1233     BOOL retval = FALSE;
1234     if (check_only == TRUE) {
1235     /* �`�F�b�N���� */
1236     if (d == CR || d == BS || d == 0x15/*ctrl-u*/) {
1237     return TRUE;
1238     } else {
1239     return FALSE;
1240     }
1241     }
1242     if (d==CR) {
1243     TempStr[TempLen++] = 0x0d;
1244     if (cv->CRSend==IdCRLF) {
1245     TempStr[TempLen++] = 0x0a;
1246     }
1247     else if ((cv->CRSend ==IdCR) &&
1248     cv->TelFlag && ! cv->TelBinSend) {
1249     TempStr[TempLen++] = 0;
1250     }
1251     else if (cv->CRSend == IdLF) {
1252     TempStr[TempLen-1] = 0x0a;
1253     }
1254 doda 3494 if (cv->TelLineMode) {
1255 doda 8445 cv->Flush = TRUE;
1256     }
1257     retval = TRUE;
1258     }
1259     else if (d== BS) {
1260     if (cv->TelLineMode) {
1261     if (cv->FlushLen < cv->LineModeBuffCount) {
1262     cv->LineModeBuffCount--;
1263     }
1264     }
1265     else {
1266     TempStr[TempLen++] = BS;
1267     }
1268     retval = TRUE;
1269     }
1270     else if (d==0x15) { // ctrl-u
1271     if (cv->TelLineMode) {
1272     cv->LineModeBuffCount = cv->FlushLen;
1273     }
1274     else {
1275     TempStr[TempLen++] = 0x15;
1276     }
1277     retval = TRUE;
1278     }
1279     *StrLen = TempLen;
1280     return retval;
1281     }
1282     static BOOL ControlEcho(PComVar cv, unsigned int u32, BOOL check_only, char *TempStr, size_t *StrLen)
1283     {
1284     const wchar_t d = u32;
1285     size_t TempLen = 0;
1286     BOOL retval = FALSE;
1287     if (check_only == TRUE) {
1288     /* �`�F�b�N���� */
1289     if (d == CR || (d == 0x15/*ctrl-u*/ && cv->TelLineMode)) {
1290     return TRUE;
1291     } else {
1292     return FALSE;
1293     }
1294     }
1295     if (d==CR) {
1296     TempStr[TempLen++] = 0x0d;
1297     if (cv->CRSend==IdCRLF) {
1298     TempStr[TempLen++] = 0x0a;
1299     }
1300     else if ((cv->CRSend ==IdCR) && cv->TelFlag && ! cv->TelBinSend) {
1301     TempStr[TempLen++] = 0;
1302     }
1303     else if (cv->CRSend == IdLF) {
1304     TempStr[TempLen-1] = 0x0a;
1305     }
1306     retval = TRUE;
1307     }
1308     else if (d==0x15/*ctrl-u*/ && cv->TelLineMode) {
1309     // Move to top of line (CHA "\033[G") and erase line (EL "\033[K")
1310     memcpy(TempStr, "\033[G\033[K", 6);
1311     TempLen += 6;
1312     retval = TRUE;
1313     }
1314     *StrLen = TempLen;
1315     return retval;
1316     }
1317    
1318     /**
1319     * �o���p����������������
1320     *
1321     * @retval ��������������
1322     */
1323     typedef struct {
1324     int KanjiCode; // [in]�o�������R�[�h(sjis,jis����)
1325     BOOL (*ControlOut)(PComVar cv, unsigned int u32, BOOL check_only, char *TempStr, size_t *StrLen);
1326     // state�����������K�v�����������R�[�h���g�p
1327     BOOL JIS7Katakana; // [in](Kanji JIS)kana
1328     int SendCode; // [in,out](Kanji JIS)���O�����M�R�[�h Ascii/Kana/Kanji
1329     BOOL KanjiFlag; // [in,out](MBCS)���O��1byte��������������?(2byte������������?)
1330     BYTE KanjiFirst; // [in,out](MBCS)���O��1byte
1331     } OutputCharState;
1332    
1333     /**
1334     * unicode(UTF-16)����unicode(UTF-32)��1���������o����
1335     * �o���f�[�^(TempStr)����������
1336     */
1337     static size_t MakeOutputString(PComVar cv, OutputCharState *states,
1338     const wchar_t *B, int C,
1339     char *TempStr, int *TempLen_)
1340     {
1341     BOOL (*ControlOut)(PComVar cv, unsigned int u32, BOOL check_only, char *TempStr, size_t *StrLen)
1342     = states->ControlOut;
1343     //
1344     int TempLen = 0;
1345     size_t TempLen2;
1346     size_t output_char_count; // ��������������
1347    
1348     // UTF-32 ��1���������o��
1349     unsigned int u32;
1350     size_t u16_len = UTF16ToUTF32(B, C, &u32);
1351     if (u16_len == 0) {
1352     // �f�R�[�h��������? ����������������?
1353     assert(FALSE);
1354     u32 = '?';
1355     u16_len = 1;
1356     }
1357     output_char_count = u16_len;
1358    
1359     // �e���V�t�g����������������
1360     if (u32 < 0x100 || ControlOut(cv, u32, TRUE, NULL, NULL)) {
1361     if (cv->Language == IdJapanese && states->KanjiCode == IdJIS) {
1362     // �����������A���{��,JIS��������
1363     if (cv->SendCode == IdKanji) {
1364     // �����������������A����OUT
1365     TempStr[TempLen++] = 0x1B;
1366     TempStr[TempLen++] = '(';
1367     switch (cv->KanjiOut) {
1368     case IdKanjiOutJ:
1369     TempStr[TempLen++] = 'J';
1370     break;
1371     case IdKanjiOutH:
1372     TempStr[TempLen++] = 'H';
1373     break;
1374     default:
1375     TempStr[TempLen++] = 'B';
1376 doda 3494 }
1377     }
1378 doda 8445
1379     if (states->JIS7Katakana == 1) {
1380     if (cv->SendCode == IdKatakana) {
1381     TempStr[TempLen++] = SO;
1382     }
1383 doda 3494 }
1384 doda 8445
1385     states->SendCode = IdASCII;
1386 maya 3227 }
1387 doda 8445 }
1388    
1389     // 1������������
1390     if (ControlOut(cv, u32, FALSE, TempStr, &TempLen2)) {
1391     // ��������������������
1392     TempLen += TempLen2;
1393     output_char_count = 1;
1394     } else if (cv->Language == IdUtf8 ||
1395     (cv->Language == IdJapanese && states->KanjiCode == IdUTF8) ||
1396     (cv->Language == IdKorean && states->KanjiCode == IdUTF8))
1397     {
1398     // UTF-8 ���o��
1399     size_t utf8_len = sizeof(TempStr);
1400     utf8_len = UTF32ToUTF8(u32, TempStr, utf8_len);
1401     TempLen += utf8_len;
1402     } else if (cv->Language == IdJapanese && *cv->CodePage == 932) {
1403     // ���{��
1404     // ���� CP932(SJIS) ���������������o��
1405     char mb_char[2];
1406     size_t mb_len = sizeof(mb_char);
1407     mb_len = UTF32ToMBCP(u32, 932, mb_char, mb_len);
1408     if (mb_len == 0) {
1409     // SJIS��������������
1410     TempStr[TempLen++] = '?';
1411     } else {
1412     switch (states->KanjiCode) {
1413     case IdEUC:
1414     // TODO ���p�J�i
1415     if (mb_len == 1) {
1416     TempStr[TempLen++] = mb_char[0];
1417     } else {
1418     WORD K;
1419     K = (((WORD)(unsigned char)mb_char[0]) << 8) +
1420     (WORD)(unsigned char)mb_char[1];
1421     K = SJIS2EUC(K);
1422     TempStr[TempLen++] = HIBYTE(K);
1423     TempStr[TempLen++] = LOBYTE(K);
1424     }
1425     break;
1426     case IdJIS:
1427     if (u32 < 0x100) {
1428     // ASCII
1429     TempStr[TempLen++] = mb_char[0];
1430     states->SendCode = IdASCII;
1431     } else if (IsHalfWidthKatakana(u32)) {
1432     // ���p�J�^�J�i
1433     if (states->JIS7Katakana==1) {
1434     if (cv->SendCode != IdKatakana) {
1435     TempStr[TempLen++] = SI;
1436     }
1437     TempStr[TempLen++] = mb_char[0] & 0x7f;
1438     } else {
1439     TempStr[TempLen++] = mb_char[0];
1440     }
1441     states->SendCode = IdKatakana;
1442     } else {
1443     // ����
1444     WORD K;
1445     K = (((WORD)(unsigned char)mb_char[0]) << 8) +
1446     (WORD)(unsigned char)mb_char[1];
1447     K = SJIS2JIS(K);
1448     if (states->SendCode != IdKanji) {
1449     // ����IN
1450     TempStr[TempLen++] = 0x1B;
1451     TempStr[TempLen++] = '$';
1452     if (cv->KanjiIn == IdKanjiInB) {
1453     TempStr[TempLen++] = 'B';
1454     }
1455     else {
1456     TempStr[TempLen++] = '@';
1457     }
1458     states->SendCode = IdKanji;
1459     }
1460     TempStr[TempLen++] = HIBYTE(K);
1461     TempStr[TempLen++] = LOBYTE(K);
1462     }
1463     break;
1464     case IdSJIS:
1465     if (mb_len == 1) {
1466     TempStr[TempLen++] = mb_char[0];
1467     } else {
1468     TempStr[TempLen++] = mb_char[0];
1469     TempStr[TempLen++] = mb_char[1];
1470     }
1471     break;
1472     default:
1473     assert(FALSE);
1474     break;
1475 doda 3494 }
1476     }
1477 doda 8445 } else if (cv->Language == IdRussian) {
1478     /* ����CP1251�����������o�� */
1479     char mb_char[2];
1480     size_t mb_len = sizeof(mb_char);
1481     BYTE b;
1482     mb_len = UTF32ToMBCP(u32, 1251, mb_char, mb_len);
1483     if (mb_len != 1) {
1484     b = '?';
1485     } else {
1486     b = RussConv(IdWindows, cv->RussHost, mb_char[0]);
1487     }
1488     TempStr[TempLen++] = b;
1489     } else if (cv->Language == IdKorean && *cv->CodePage == 51949) {
1490     /* CP51949�����������o�� */
1491     char mb_char[2];
1492     size_t mb_len = sizeof(mb_char);
1493     mb_len = UTF32ToMBCP(u32, 51949, mb_char, mb_len);
1494     if (mb_len == 0) {
1495     TempStr[TempLen++] = '?';
1496     }
1497     else if (mb_len == 1) {
1498     TempStr[TempLen++] = mb_char[0];
1499     } else {
1500     TempStr[TempLen++] = mb_char[0];
1501     TempStr[TempLen++] = mb_char[1];
1502     }
1503     } else if (cv->Language == IdEnglish) {
1504     TempStr[TempLen++] = u32;
1505     } else {
1506     // CodePage������
1507     char mb_char[2];
1508     size_t mb_len = sizeof(mb_char);
1509     mb_len = UTF32ToMBCP(u32, *cv->CodePage, mb_char, mb_len);
1510     if (mb_len == 0) {
1511     TempStr[TempLen++] = '?';
1512     }
1513     else if (mb_len == 1) {
1514     TempStr[TempLen++] = mb_char[0];
1515     } else {
1516     TempStr[TempLen++] = mb_char[0];
1517     TempStr[TempLen++] = mb_char[1];
1518     }
1519     }
1520 maya 3227
1521 doda 8445 *TempLen_ = TempLen;
1522     return output_char_count;
1523 maya 3227 }
1524    
1525 doda 8445
1526     /**
1527     * CommTextOut() �� wchar_t ��
1528     *
1529     * @retval �o��������(wchar_t�P��)
1530     */
1531 zmatsuo 7484 int WINAPI CommTextOutW(PComVar cv, const wchar_t *B, int C)
1532     {
1533 doda 8445 char TempStr[12];
1534     BOOL Full = FALSE;
1535     int i = 0;
1536     while (! Full && (i < C)) {
1537     // �o���p�f�[�^������
1538     int TempLen = 0;
1539     size_t output_char_count; // ��������������
1540     OutputCharState state;
1541     state.KanjiCode = cv->KanjiCodeSend;
1542     state.ControlOut = OutControl;
1543     state.SendCode = cv->SendCode;
1544     state.JIS7Katakana = cv->JIS7KatakanaSend;
1545     output_char_count = MakeOutputString(cv, &state, &B[i], C-i, TempStr, &TempLen);
1546    
1547     // �f�[�^���o���o�b�t�@��
1548     if (WriteOutBuff(cv, TempStr, TempLen)) {
1549     i += output_char_count; // output_char_count ������ ��������
1550     // ��������������������
1551     cv->SendCode = state.SendCode;
1552     } else {
1553     Full = TRUE;
1554     }
1555     } // end of "while {}"
1556     _CrtCheckMemory();
1557     return i;
1558 zmatsuo 7484 }
1559    
1560 doda 8445 /**
1561     * CommTextEcho() �� wchar_t ��
1562     *
1563     * @retval �o��������(wchar_t�P��)
1564     */
1565 zmatsuo 7484 int WINAPI CommTextEchoW(PComVar cv, const wchar_t *B, int C)
1566     {
1567 doda 8445 char TempStr[12];
1568     BOOL Full = FALSE;
1569     int i = 0;
1570     while (! Full && (i < C)) {
1571     // �o���p�f�[�^������
1572     int TempLen = 0;
1573     size_t output_char_count; // ��������������
1574     OutputCharState state;
1575     state.KanjiCode = cv->KanjiCodeEcho;
1576     state.ControlOut = ControlEcho;
1577     state.SendCode = cv->EchoCode;
1578     state.JIS7Katakana = cv->JIS7KatakanaEcho;
1579     output_char_count = MakeOutputString(cv, &state, &B[i], C-i, TempStr, &TempLen);
1580    
1581     // �f�[�^���o���o�b�t�@��
1582     if (WriteInBuff(cv, TempStr, TempLen)) {
1583     i += output_char_count; // output_char_count ������ ��������
1584     // ��������������������
1585     cv->EchoCode = state.SendCode;
1586     } else {
1587     Full = TRUE;
1588     }
1589     } // end of "while {}"
1590     _CrtCheckMemory();
1591     return i;
1592 zmatsuo 7484 }
1593    
1594 zmatsuo 7305 int WINAPI CommBinaryEcho(PComVar cv, PCHAR B, int C)
1595 maya 3227 {
1596     int a, i, Len;
1597     char d[3];
1598    
1599     if ( ! cv->Ready )
1600     return C;
1601    
1602 doda 8445 PackInBuff(cv);
1603 maya 3227
1604     i = 0;
1605     a = 1;
1606     while ((a>0) && (i<C)) {
1607     Len = 0;
1608    
1609     d[Len] = B[i];
1610     Len++;
1611    
1612     if ( cv->TelFlag && (B[i]=='\x0d') &&
1613     ! cv->TelBinSend ) {
1614     d[Len] = 0x00;
1615     Len++;
1616     }
1617    
1618     if ( cv->TelFlag && (B[i]=='\xff') ) {
1619     d[Len] = '\xff';
1620     Len++;
1621     }
1622    
1623 doda 8445 if (WriteInBuff(cv, d, Len)) {
1624 maya 3227 a = 1;
1625 doda 8445 i++;
1626     } else {
1627     a = 0;
1628 maya 3227 }
1629     }
1630     return i;
1631     }
1632    
1633 zmatsuo 7411 static int WINAPI TextEchoMBCS(PComVar cv, PCHAR B, int C)
1634 maya 3227 {
1635     int i, TempLen;
1636     WORD K;
1637 doda 3452 char TempStr[12];
1638 maya 3227 int EchoCodeNew;
1639     BYTE d;
1640     BOOL Full, KanjiFlagNew;
1641    
1642     Full = FALSE;
1643     i = 0;
1644     while (! Full && (i < C)) {
1645     TempLen = 0;
1646     d = (BYTE)B[i];
1647     EchoCodeNew = cv->EchoCode;
1648 doda 3452 KanjiFlagNew = FALSE;
1649 maya 3227
1650     if (cv->EchoKanjiFlag) {
1651     EchoCodeNew = IdKanji;
1652    
1653     K = (cv->EchoKanjiFirst << 8) + d;
1654 doda 3452
1655 maya 3227 // UTF-8�����������s���B1�`3�o�C�g���������������������B
1656 doda 3452 if (cv->KanjiCodeEcho == IdUTF8 || cv->Language==IdUtf8) {
1657 doda 3442 TempLen += OutputTextUTF8(K, TempStr, cv);
1658 maya 3227 }
1659     else {
1660 doda 3452 switch (cv->Language) {
1661     case IdJapanese:
1662     switch (cv->KanjiCodeEcho) {
1663     case IdEUC:
1664     K = SJIS2EUC(K);
1665     break;
1666     case IdJIS:
1667     K = SJIS2JIS(K);
1668     if ((cv->EchoCode==IdKatakana) &&
1669     (cv->JIS7KatakanaEcho==1)) {
1670     TempStr[TempLen++] = SI;
1671     }
1672     break;
1673     case IdSJIS:
1674     /* nothing to do */
1675     break;
1676     }
1677     break;
1678     case IdKorean:
1679     break;
1680 maya 3392 }
1681 doda 3452 TempStr[TempLen++] = HIBYTE(K);
1682     TempStr[TempLen++] = LOBYTE(K);
1683 maya 3227 }
1684     }
1685 zmatsuo 9130 else if (__isleadbyte_l(d, cv)) {
1686 maya 3227 KanjiFlagNew = TRUE;
1687     cv->EchoKanjiFirst = d;
1688     EchoCodeNew = IdKanji;
1689    
1690 doda 3452 if (cv->Language == IdJapanese) {
1691     if ((cv->EchoCode!=IdKanji) && (cv->KanjiCodeEcho==IdJIS)) {
1692     TempStr[0] = 0x1B;
1693     TempStr[1] = '$';
1694     if (cv->KanjiIn == IdKanjiInB) {
1695     TempStr[2] = 'B';
1696     }
1697     else {
1698     TempStr[2] = '@';
1699     }
1700     TempLen = 3;
1701 maya 3392 }
1702 maya 3227 }
1703     }
1704     else {
1705 doda 3452 if (cv->Language == IdJapanese) {
1706     if ((cv->EchoCode==IdKanji) && (cv->KanjiCodeEcho==IdJIS)) {
1707     TempStr[0] = 0x1B;
1708     TempStr[1] = '(';
1709     switch (cv->KanjiOut) {
1710     case IdKanjiOutJ:
1711 maya 3227 TempStr[2] = 'J';
1712     break;
1713 doda 3452 case IdKanjiOutH:
1714 maya 3227 TempStr[2] = 'H';
1715     break;
1716 doda 3452 default:
1717 maya 3227 TempStr[2] = 'B';
1718 doda 3452 }
1719     TempLen = 3;
1720 maya 3227 }
1721    
1722 doda 3452 if ((0xa0<d) && (d<0xe0)) {
1723     EchoCodeNew = IdKatakana;
1724     if ((cv->EchoCode!=IdKatakana) &&
1725     (cv->KanjiCodeEcho==IdJIS) &&
1726     (cv->JIS7KatakanaEcho==1)) {
1727     TempStr[TempLen++] = SO;
1728     }
1729 maya 3227 }
1730 doda 3452 else {
1731     EchoCodeNew = IdASCII;
1732     if ((cv->EchoCode==IdKatakana) &&
1733     (cv->KanjiCodeEcho==IdJIS) &&
1734     (cv->JIS7KatakanaEcho==1)) {
1735     TempStr[TempLen++] = SI;
1736     }
1737 maya 3227 }
1738     }
1739    
1740 doda 3503 if (d==CR) {
1741 doda 3452 TempStr[TempLen++] = 0x0d;
1742 maya 3227 if (cv->CRSend==IdCRLF) {
1743 doda 3452 TempStr[TempLen++] = 0x0a;
1744 maya 3227 }
1745     else if ((cv->CRSend==IdCR) &&
1746 maya 3392 cv->TelFlag && ! cv->TelBinSend) {
1747 doda 3452 TempStr[TempLen++] = 0;
1748 maya 3227 }
1749 maya 6369 else if (cv->CRSend == IdLF) {
1750     TempStr[TempLen-1] = 0x0a;
1751     }
1752 maya 3227 }
1753 doda 3503 else if (d==0x15) { // Ctrl-U
1754     if (cv->TelLineMode) {
1755     // Move to top of line (CHA "\033[G") and erase line (EL "\033[K")
1756     strncpy_s(TempStr, sizeof(TempStr), "\033[G\033[K", _TRUNCATE);
1757     TempLen += 6;
1758     }
1759     else {
1760     TempStr[TempLen++] = d;
1761     }
1762     }
1763 doda 3452 else if ((d>=0x80) && (cv->KanjiCodeEcho==IdUTF8 || cv->Language==IdUtf8)) {
1764     TempLen += OutputTextUTF8((WORD)d, TempStr, cv);
1765     }
1766     else if ((d>=0xa1) && (d<=0xe0) && (cv->Language == IdJapanese)) {
1767 maya 3227 /* Katakana */
1768     if (cv->KanjiCodeEcho==IdEUC) {
1769 doda 3452 TempStr[TempLen++] = (char)SS2;
1770 maya 3227 }
1771     if ((cv->KanjiCodeEcho==IdJIS) &&
1772 maya 3392 (cv->JIS7KatakanaEcho==1)) {
1773 doda 3452 TempStr[TempLen++] = d & 0x7f;
1774 maya 3392 }
1775     else {
1776 doda 3452 TempStr[TempLen++] = d;
1777 maya 3392 }
1778 maya 3227 }
1779     else {
1780 doda 3452 TempStr[TempLen++] = d;
1781 maya 3227 if (cv->TelFlag && (d==0xff)) {
1782 doda 3452 TempStr[TempLen++] = (char)0xff;
1783 maya 3227 }
1784     }
1785 doda 3452 } // if (cv->EchoKanjiFlag) else if ... else ... end
1786 maya 3227
1787 doda 8445 if (WriteInBuff(cv, TempStr, TempLen)) {
1788 maya 3227 i++;
1789     cv->EchoCode = EchoCodeNew;
1790     cv->EchoKanjiFlag = KanjiFlagNew;
1791 doda 8445 } else {
1792     Full = FALSE;
1793 maya 3227 }
1794    
1795     } // end of "while {}"
1796    
1797     return i;
1798     }
1799    
1800 zmatsuo 7305 int WINAPI CommTextEcho(PComVar cv, PCHAR B, int C)
1801 maya 3227 {
1802     int i, TempLen;
1803     char TempStr[11];
1804     BYTE d;
1805     BOOL Full;
1806    
1807 maya 3392 if ( ! cv->Ready ) {
1808 maya 3227 return C;
1809 maya 3392 }
1810 maya 3227
1811 doda 8445 PackInBuff(cv);
1812 maya 3227
1813 doda 3452 switch (cv->Language) {
1814     case IdUtf8:
1815     case IdJapanese:
1816     case IdKorean:
1817 doda 3458 return TextEchoMBCS(cv,B,C);
1818 doda 3452 break;
1819 doda 3438 }
1820 maya 3227
1821     Full = FALSE;
1822     i = 0;
1823     while (! Full && (i < C)) {
1824     TempLen = 0;
1825     d = (BYTE)B[i];
1826    
1827 doda 3503 switch (d) {
1828     case CR:
1829 maya 3227 TempStr[TempLen] = 0x0d;
1830     TempLen++;
1831     if (cv->CRSend==IdCRLF) {
1832 doda 3452 TempStr[TempLen++] = 0x0a;
1833 maya 3227 }
1834 doda 3452 else if (cv->CRSend==IdCR && cv->TelFlag && ! cv->TelBinSend) {
1835     TempStr[TempLen++] = 0;
1836 maya 3227 }
1837 maya 6369 else if (cv->CRSend == IdLF) {
1838     TempStr[TempLen-1] = 0x0a;
1839     }
1840 doda 3503 break;
1841 doda 6435
1842 doda 3503 case 0x15: // Ctrl-U
1843     if (cv->TelLineMode) {
1844     // Move to top of line (CHA "\033[G") and erase line (EL "\033[K")
1845     strncpy_s(TempStr, sizeof(TempStr), "\033[G\033[K", _TRUNCATE);
1846     TempLen += 6;
1847     }
1848     else {
1849     TempStr[TempLen++] = d;
1850     }
1851     break;
1852    
1853     default:
1854 doda 3452 if ((cv->Language==IdRussian) && (d>=128)) {
1855 maya 3227 d = RussConv(cv->RussClient,cv->RussHost,d);
1856 maya 3392 }
1857 doda 3452 TempStr[TempLen++] = d;
1858 maya 3227 if (cv->TelFlag && (d==0xff)) {
1859 doda 3452 TempStr[TempLen++] = (char)0xff;
1860 maya 3227 }
1861     }
1862    
1863 doda 8445 if(WriteInBuff(cv, TempStr,TempLen)) {
1864 maya 3227 i++;
1865 doda 8445 } else {
1866     Full = TRUE;
1867 maya 3227 }
1868     } // end of while {}
1869    
1870     return i;
1871     }
1872    
1873 yutakapon 8188 /*
1874 zmatsuo 7304 * @return �G���[���L������ FALSE
1875     * @param[in] BOOL first_instance
1876     */
1877     static BOOL OpenSharedMemory(BOOL *first_instance_)
1878     {
1879     int i;
1880     HMap = NULL;
1881     pm = NULL;
1882     for (i = 0; i < 100; i++) {
1883     char tmp[32];
1884     HANDLE hMap;
1885     BOOL first_instance;
1886 zmatsuo 7306 TMap *map;
1887 zmatsuo 7304 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, i == 0 ? "%s" : "%s_%d", TT_FILEMAPNAME, i);
1888     hMap = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
1889     0, sizeof(TMap), tmp);
1890     if (hMap == NULL) {
1891     return FALSE;
1892     }
1893    
1894     first_instance = (GetLastError() != ERROR_ALREADY_EXISTS);
1895    
1896 zmatsuo 7306 map = (TMap *)MapViewOfFile(hMap,FILE_MAP_WRITE,0,0,0);
1897 zmatsuo 7304 if (map == NULL) {
1898     return FALSE;
1899     }
1900    
1901     if (first_instance ||
1902     (map->size_tmap == sizeof(TMap) &&
1903     map->size_tttset == sizeof(TTTSet)))
1904     {
1905     map->size_tmap = sizeof(TMap);
1906     map->size_tttset = sizeof(TTTSet);
1907     HMap = hMap;
1908     pm = map;
1909     *first_instance_ = first_instance;
1910     return TRUE;
1911     }
1912    
1913     // next try
1914     UnmapViewOfFile(map);
1915     CloseHandle(hMap);
1916     }
1917     return FALSE;
1918     }
1919    
1920 maya 3227 BOOL WINAPI DllMain(HANDLE hInstance,
1921     ULONG ul_reason_for_call,
1922     LPVOID lpReserved)
1923     {
1924     switch( ul_reason_for_call ) {
1925     case DLL_THREAD_ATTACH:
1926     /* do thread initialization */
1927     break;
1928     case DLL_THREAD_DETACH:
1929     /* do thread cleanup */
1930     break;
1931     case DLL_PROCESS_ATTACH:
1932     /* do process initialization */
1933     hInst = hInstance;
1934 zmatsuo 7304 if (OpenSharedMemory(&FirstInstance) == FALSE) {
1935     // dll���[�h���s�Ateraterm���N��������
1936 maya 3227 return FALSE;
1937 maya 3392 }
1938 doda 8445 WinCompatInit();
1939 maya 3227 break;
1940     case DLL_PROCESS_DETACH:
1941     /* do process cleanup */
1942     UnmapViewOfFile(pm);
1943     CloseHandle(HMap);
1944     break;
1945     }
1946     return TRUE;
1947     }
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help