Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/branches/ttcomtester/teraterm/teraterm/vtwin.cpp

Contents of /branches/ttcomtester/teraterm/teraterm/vtwin.cpp

Parent Directory Parent Directory | Revision Log Revision Log

Revision 10521 - (show annotations) (download) (as text)
Fri Jan 20 16:03:38 2023 UTC (13 months, 2 weeks ago) by zmatsuo
File MIME type: text/x-c++src
File size: 138486 byte(s) 
add communication test tool
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 /* IPv6 modification is Copyright(C) 2000 Jun-ya Kato <kato@win6.jp> */
30
31 /* TERATERM.EXE, VT window */
32
33 // SDK7.0�������AWIN32_IE���K�������`��������
34 #if _MSC_VER == 1400 // VS2005����������
35 #if !defined(_WIN32_IE)
36 #define _WIN32_IE 0x0501
37 #endif
38 #endif
39
40 #include "teraterm.h"
41 #include "tttypes.h"
42 #include "tttypes_key.h"
43
44 #include "ttcommon.h"
45 #include "ttwinman.h"
46 #include "ttsetup.h"
47 #include "keyboard.h"
48 #include "buffer.h"
49 #include "vtterm.h"
50 #include "vtdisp.h"
51 #include "ttdialog.h"
52 #include "ttime.h"
53 #include "commlib.h"
54 #include "clipboar.h"
55 #include "filesys.h"
56 #include "telnet.h"
57 #include "tektypes.h"
58 #include "ttdde.h"
59 #include "ttlib.h"
60 #include "dlglib.h"
61 #include "helpid.h"
62 #include "teraprn.h"
63 #include <winsock2.h>
64 #include <ws2tcpip.h>
65 #include "ttplug.h" /* TTPLUG */
66 #include "teraterml.h"
67 #include "buffer.h"
68 #include "cyglib.h"
69 #include "theme.h"
70
71 #include <stdio.h>
72 #define _CRTDBG_MAP_ALLOC
73 #include <stdlib.h>
74 #include <crtdbg.h>
75 #include <string.h>
76 #include <io.h>
77 #include <errno.h>
78
79 #include <shlobj.h>
80 #include <windows.h>
81 #include <windowsx.h>
82 #include <imm.h>
83 #include <dbt.h>
84 #include <assert.h>
85 #include <wchar.h>
86 #include <htmlhelp.h>
87
88 #include "tt_res.h"
89 #include "vtwin.h"
90 #include "addsetting.h"
91 #include "winjump.h"
92 #include "sizetip.h"
93 #include "dnddlg.h"
94 #include "tekwin.h"
95 #include "compat_win.h"
96 #include "unicode_test.h"
97 #if UNICODE_DEBUG
98 #include "tipwin.h"
99 #endif
100 #include "codeconv.h"
101 #include "sendmem.h"
102 #include "sendfiledlg.h"
103 #include "setting.h"
104 #include "broadcast.h"
105 #include "asprintf.h"
106 #include "teraprn.h"
107 #include "setupdirdlg.h"
108 #include "themedlg.h"
109 #include "ttcmn_static.h"
110 #include "ttcmn_notify2.h"
111 #include "scp.h"
112 #include "ttcommdlg.h"
113
114 #include <initguid.h>
115 #if _MSC_VER < 1600
116 // Visual Studio 2005,2008 �������A2010���������o�[�W����������
117 DEFINE_GUID(GUID_DEVINTERFACE_USB_DEVICE, 0xA5DCBF10L, 0x6530, 0x11D2, 0x90, 0x1F, 0x00, \
118 0xC0, 0x4F, 0xB9, 0x51, 0xED);
119 #else
120 #include <usbiodef.h> // GUID_DEVINTERFACE_USB_DEVICE
121 #endif
122
123 #include "win32helper.h"
124
125 #define VTClassName L"VTWin32"
126
127 // �E�B���h�E�������{�^�����L�������� (2005.1.15 yutaka)
128 #define WINDOW_MAXMIMUM_ENABLED 1
129
130 static BOOL TCPLocalEchoUsed = FALSE;
131 static BOOL TCPCRSendUsed = FALSE;
132
133 static BOOL IgnoreRelease = FALSE;
134
135 static HDEVNOTIFY hDevNotify = NULL;
136
137 static int AutoDisconnectedPort = -1;
138
139 UnicodeDebugParam_t UnicodeDebugParam;
140 typedef struct {
141 char dbcs_lead_byte;
142 } vtwin_work_t;
143 static vtwin_work_t vtwin_work;
144
145 extern "C" PrintFile *PrintFile_;
146
147 /////////////////////////////////////////////////////////////////////////////
148 // CVTWindow
149
150 // Tera Term�N������URL������mouse over������������ (2005.4.2 yutaka)
151 static void SetMouseCursor(const char *cursor)
152 {
153 HCURSOR hc;
154 LPCTSTR name = NULL;
155 int i;
156
157 for (i = 0 ; MouseCursor[i].name ; i++) {
158 if (_stricmp(cursor, MouseCursor[i].name) == 0) {
159 name = MouseCursor[i].id;
160 break;
161 }
162 }
163 if (name == NULL) {
164 return;
165 }
166
167 hc = (HCURSOR)LoadImage(NULL, name, IMAGE_CURSOR,
168 0, 0, LR_DEFAULTSIZE | LR_SHARED);
169
170 if (hc != NULL) {
171 SetClassLongPtr(HVTWin, GCLP_HCURSOR, (LONG_PTR)hc);
172 }
173 }
174
175 /**
176 * @param[in] alpha 0-255
177 */
178 void CVTWindow::SetWindowAlpha(BYTE alpha)
179 {
180 if (pSetLayeredWindowAttributes == NULL) {
181 return; // ���C���[�h�E�C���h�E���T�|�[�g����
182 }
183 if (Alpha == alpha) {
184 return; // ����������������������
185 }
186 LONG_PTR lp = GetWindowLongPtr(GWL_EXSTYLE);
187 if (lp == 0) {
188 return;
189 }
190
191 // 2006/03/16 by 337: BGUseAlphaBlendAPI��On������Layered����������
192 //if (ts->EtermLookfeel.BGUseAlphaBlendAPI) {
193 // �A���t�@�l��255�������A�����������������}�����������������������������B(2006.4.1 yutaka)
194 // �����o�������A�l�����X�����������������������f�����B(2007.10.19 maya)
195 if (alpha < 255) {
196 ::SetWindowLongPtr(HVTWin, GWL_EXSTYLE, lp | WS_EX_LAYERED);
197 pSetLayeredWindowAttributes(HVTWin, 0, alpha, LWA_ALPHA);
198 }
199 else {
200 // �A���t�@�l�� 255 �������A�����������������������`�������B(2007.10.22 maya)
201 ::SetWindowLongPtr(HVTWin, GWL_EXSTYLE, lp & ~WS_EX_LAYERED);
202 ::RedrawWindow(HVTWin, NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_FRAME);
203 }
204 Alpha = alpha;
205 }
206
207 void RegDeviceNotify(HWND hWnd)
208 {
209 typedef HDEVNOTIFY (WINAPI *PRegisterDeviceNotification)(HANDLE hRecipient, LPVOID NotificationFilter, DWORD Flags);
210 HMODULE h;
211 PRegisterDeviceNotification pRegisterDeviceNotification;
212 DEV_BROADCAST_DEVICEINTERFACE filter;
213
214 if (((h = GetModuleHandle("user32.dll")) == NULL) ||
215 ((pRegisterDeviceNotification = (PRegisterDeviceNotification)GetProcAddress(h, "RegisterDeviceNotificationA")) == NULL)) {
216 return;
217 }
218
219 ZeroMemory(&filter, sizeof(filter));
220 filter.dbcc_size = sizeof(filter);
221 filter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
222 filter.dbcc_classguid = GUID_DEVINTERFACE_USB_DEVICE;
223 hDevNotify = pRegisterDeviceNotification(hWnd, &filter, DEVICE_NOTIFY_WINDOW_HANDLE);
224 }
225
226 void UnRegDeviceNotify(HWND hWnd)
227 {
228 typedef BOOL (WINAPI *PUnregisterDeviceNotification)(HDEVNOTIFY Handle);
229 HMODULE h;
230 PUnregisterDeviceNotification pUnregisterDeviceNotification;
231
232 if (((h = GetModuleHandle("user32.dll")) == NULL) ||
233 ((pUnregisterDeviceNotification = (PUnregisterDeviceNotification)GetProcAddress(h, "UnregisterDeviceNotification")) == NULL)) {
234 return;
235 }
236
237 pUnregisterDeviceNotification(hDevNotify);
238 }
239
240 void SetAutoConnectPort(int port)
241 {
242 AutoDisconnectedPort = port;
243 }
244
245 /////////////////////////////////////////////////////////////////////////////
246 // CVTWindow constructor
247
248 CVTWindow::CVTWindow(HINSTANCE hInstance)
249 {
250 WNDCLASSW wc;
251 RECT rect;
252 DWORD Style;
253 int CmdShow;
254 BOOL isFirstInstance;
255 m_hInst = hInstance;
256
257 CommInit(&cv);
258 cv.ts = &ts;
259 isFirstInstance = StartTeraTerm(m_hInst, &ts);
260
261 TTXInit(&ts, &cv); /* TTPLUG */
262
263 MsgDlgHelp = RegisterWindowMessage(HELPMSGSTRING);
264
265 if (isFirstInstance) {
266 /* first instance */
267 if (LoadTTSET()) {
268 /* read setup info from "teraterm.ini" */
269 (*ReadIniFile)(ts.SetupFNameW, &ts);
270 FreeTTSET();
271 }
272 else {
273 abort();
274 }
275
276 } else {
277 // 2�������~���v���Z�X�����������A�f�B�X�N���� TERATERM.INI �������B(2004.11.4 yutaka)
278 if (LoadTTSET()) {
279 /* read setup info from "teraterm.ini" */
280 (*ReadIniFile)(ts.SetupFNameW, &ts);
281 FreeTTSET();
282 }
283 else {
284 abort();
285 }
286 }
287
288 /* Parse command line parameters*/
289 // 256�o�C�g�������R�}���h���C���p�����[�^�w�����������ABOF(Buffer Over Flow)��
290 // �������o�O���C���B(2007.6.12 maya)
291 if (LoadTTSET()) {
292 // GetCommandLineW() in MSDN remark
293 // The lifetime of the returned value is managed by the
294 // system, applications should not free or modify this value.
295 wchar_t *ParamW = GetCommandLineW();
296 (*ParseParam)(ParamW, &ts, &(TopicName[0]));
297 }
298 FreeTTSET();
299
300 // DPI Aware (��DPI����)
301 if (pIsValidDpiAwarenessContext != NULL && pSetThreadDpiAwarenessContext != NULL) {
302 wchar_t Temp[4];
303 GetPrivateProfileStringW(L"Tera Term", L"DPIAware", L"on", Temp, _countof(Temp), ts.SetupFNameW);
304 if (_wcsicmp(Temp, L"on") == 0) {
305 if (pIsValidDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2) == TRUE) {
306 pSetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
307 }
308 }
309 }
310
311 // duplicate session���w�������������A���L�����������R�s�[���� (2004.12.7 yutaka)
312 if (ts.DuplicateSession == 1) {
313 // ���L�����������W�����������������E�B���h�E���W�������B
314 // �������������� TERATERM.INI ���l���g�����������A�������������B
315 POINT VTPos = ts.VTPos;
316 POINT TEKPos = ts.TEKPos;
317
318 CopyShmemToTTSet(&ts);
319
320 ts.VTPos = VTPos;
321 ts.TEKPos = TEKPos;
322 }
323
324 InitKeyboard();
325 SetKeyMap();
326
327 /* window status */
328 AdjustSize = TRUE;
329 Minimized = FALSE;
330 LButton = FALSE;
331 MButton = FALSE;
332 RButton = FALSE;
333 DblClk = FALSE;
334 AfterDblClk = FALSE;
335 TplClk = FALSE;
336 Hold = FALSE;
337 FirstPaint = TRUE;
338 ScrollLock = FALSE; // �����l������ (2006.11.14 yutaka)
339 Alpha = 255;
340 IgnoreSizeMessage = FALSE;
341 #if UNICODE_DEBUG
342 TipWinCodeDebug = NULL;
343 #endif
344
345 // UnicodeDebugParam
346 {
347 #if _DEBUG
348 UnicodeDebugParam.CodePopupEnable = TRUE;
349 #else
350 UnicodeDebugParam.CodePopupEnable = FALSE;
351 #endif
352 UnicodeDebugParam.CodePopupKey1 = VK_CONTROL;
353 UnicodeDebugParam.CodePopupKey2 = VK_CONTROL;
354 UnicodeDebugParam.UseUnicodeApi = FALSE;
355 UnicodeDebugParam.CodePageForANSIDraw = GetACP();
356 }
357
358 /* Initialize scroll buffer */
359 UnicodeDebugParam.UseUnicodeApi = IsWindowsNTKernel() ? TRUE : FALSE;
360 InitBuffer(UnicodeDebugParam.UseUnicodeApi);
361 BuffSetDispCodePage(UnicodeDebugParam.CodePageForANSIDraw);
362
363 InitDisp();
364 BGLoadThemeFile(&ts);
365
366 if (ts.HideTitle>0) {
367 Style = WS_VSCROLL | WS_HSCROLL |
368 WS_BORDER | WS_THICKFRAME | WS_POPUP;
369
370 if (ts.EtermLookfeel.BGNoFrame)
371 Style &= ~(WS_BORDER | WS_THICKFRAME);
372 }
373 else
374 #ifdef WINDOW_MAXMIMUM_ENABLED
375 Style = WS_VSCROLL | WS_HSCROLL |
376 WS_BORDER | WS_THICKFRAME |
377 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX;
378 #else
379 Style = WS_VSCROLL | WS_HSCROLL |
380 WS_BORDER | WS_THICKFRAME |
381 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
382 #endif
383
384 wc.style = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
385 wc.lpfnWndProc = (WNDPROC)ProcStub;
386 wc.cbClsExtra = 0;
387 wc.cbWndExtra = 0;
388 wc.hInstance = hInstance;
389 wc.hIcon = NULL;
390 //wc.hCursor = LoadCursor(NULL,IDC_IBEAM);
391 wc.hCursor = NULL; // �}�E�X�J�[�\�������I�����X���� (2005.4.2 yutaka)
392 wc.hbrBackground = NULL;
393 wc.lpszMenuName = NULL;
394 wc.lpszClassName = VTClassName;
395
396 RegisterClassW(&wc);
397 m_hAccel = ::LoadAccelerators(hInstance, MAKEINTRESOURCE(IDR_ACC));
398
399 if (ts.VTPos.x==CW_USEDEFAULT) {
400 rect = rectDefault;
401 }
402 else {
403 rect.left = ts.VTPos.x;
404 rect.top = ts.VTPos.y;
405 rect.right = rect.left + 100;
406 rect.bottom = rect.top + 100;
407 }
408 CreateW(hInstance, VTClassName, L"Tera Term", Style, rect, NULL, NULL);
409
410 /*--------- Init2 -----------------*/
411 HVTWin = GetSafeHwnd();
412 if (HVTWin == NULL) return;
413 cv.HWin = HVTWin;
414
415 // Windows 11 ���E�B���h�E���p������������������������
416 if (ts.WindowCornerDontround && pDwmSetWindowAttribute != NULL) {
417 DWM_WINDOW_CORNER_PREFERENCE preference = DWMWCP_DONOTROUND;
418 pDwmSetWindowAttribute(HVTWin, DWMWA_WINDOW_CORNER_PREFERENCE, &preference, sizeof(preference));
419 }
420
421 // register this window to the window list
422 SerialNo = RegWin(HVTWin,NULL);
423
424 logfile_lock_initialize();
425 SetMouseCursor(ts.MouseCursorName);
426
427 if(ts.EtermLookfeel.BGNoFrame && ts.HideTitle > 0) {
428 DWORD ExStyle = (DWORD)::GetWindowLongPtr(HVTWin,GWL_EXSTYLE);
429 ExStyle &= ~WS_EX_CLIENTEDGE;
430 ::SetWindowLongPtr(HVTWin,GWL_EXSTYLE,ExStyle);
431 }
432
433 // USB�f�o�C�X�������m�o�^
434 RegDeviceNotify(HVTWin);
435
436 // ���m����������
437 NotifyIcon *ni = Notify2Initialize();
438 cv.NotifyIcon = ni;
439 Notify2SetWindow(ni, m_hWnd, WM_USER_NOTIFYICON, m_hInst, (ts.VTIcon != IdIconDefault) ? ts.VTIcon: IDI_VT);
440 Notify2SetSound(ni, ts.NotifySound);
441
442 // VT �E�B���h�E���A�C�R��
443 SetVTIconID(&cv, NULL, 0);
444
445 MainMenu = NULL;
446 WinMenu = NULL;
447 if ((ts.HideTitle==0) && (ts.PopupMenu==0)) {
448 InitMenu(&MainMenu);
449 ::SetMenu(HVTWin,MainMenu);
450 }
451
452 /* Reset Terminal */
453 ResetTerminal();
454
455 if ((ts.PopupMenu>0) || (ts.HideTitle>0)) {
456 ::PostMessage(HVTWin,WM_USER_CHANGEMENU,0,0);
457 }
458
459 ChangeFont();
460
461 ResetIME();
462
463 BuffChangeWinSize(NumOfColumns,NumOfLines);
464
465 ChangeTitle();
466 /* Enable drag-drop */
467 ::DragAcceptFiles(HVTWin,TRUE);
468
469 if (ts.HideWindow>0) {
470 if (strlen(TopicName)>0) {
471 InitDDE();
472 SendDDEReady();
473 }
474 FirstPaint = FALSE;
475 Startup();
476 return;
477 }
478 CmdShow = SW_SHOWDEFAULT;
479 if (ts.Minimize>0) {
480 CmdShow = SW_SHOWMINIMIZED;
481 }
482 SetWindowAlpha(ts.AlphaBlendActive);
483 ShowWindow(CmdShow);
484 ChangeCaret();
485
486 DropInit();
487 DropLists = NULL;
488 DropListCount = 0;
489
490 #if UNICODE_DEBUG
491 CtrlKeyState = 0;
492 #endif
493
494 // TipWin
495 TipWin = new CTipWin(hInstance);
496 TipWin->Create(HVTWin);
497 }
498
499 /////////////////////////////////////////////////////////////////////////////
500 // CVTWindow destructor
501
502 CVTWindow::~CVTWindow()
503 {
504 TipWin->Destroy();
505 delete TipWin;
506 TipWin = NULL;
507 }
508
509 /////////////////////////////////////////////////////////////////////////////
510
511 int CVTWindow::Parse()
512 {
513 // added ScrollLock (2006.11.14 yutaka)
514 if (LButton || MButton || RButton || ScrollLock)
515 return 0;
516 return (VTParse()); // Parse received characters
517 }
518
519 void CVTWindow::ButtonUp(BOOL Paste)
520 {
521 BOOL disableBuffEndSelect = false;
522
523 /* disable autoscrolling */
524 ::KillTimer(HVTWin,IdScrollTimer);
525 ReleaseCapture();
526
527 if (ts.SelectOnlyByLButton &&
528 (MButton || RButton)) {
529 disableBuffEndSelect = true;
530 }
531
532 LButton = FALSE;
533 MButton = FALSE;
534 RButton = FALSE;
535 DblClk = FALSE;
536 TplClk = FALSE;
537 CaretOn();
538
539 // SelectOnlyByLButton �� on �� ���E�E�N���b�N����������
540 // �o�b�t�@���I���������������A�I�����e���N���b�v�{�[�h��
541 // �R�s�[�������������������C�� (2007.12.6 maya)
542 if (!disableBuffEndSelect) {
543 // �I�������������������A�N���b�v�{�[�h���Z�b�g����
544 wchar_t *strW = BuffEndSelect();
545 if (strW != NULL) {
546 CBSetTextW(HVTWin, strW, 0);
547 free(strW);
548 }
549 }
550
551 if (Paste) {
552 CBStartPaste(HVTWin, FALSE, BracketedPasteMode());
553
554 // �X�N���[�����u�����Z�b�g
555 if (WinOrgY != 0) {
556 DispVScroll(SCROLL_BOTTOM, 0);
557 }
558 }
559 }
560
561 void CVTWindow::ButtonDown(POINT p, int LMR)
562 {
563 HMENU PopupMenu, PopupBase;
564 BOOL mousereport;
565
566 if ((LMR==IdLeftButton) && ControlKey() && (MainMenu==NULL) &&
567 ((ts.MenuFlag & MF_NOPOPUP)==0)) {
568 int i, numItems;
569
570 InitMenu(&PopupMenu);
571
572 PopupBase = CreatePopupMenu();
573 numItems = GetMenuItemCount(PopupMenu);
574
575 for (i = 0; i < numItems; i++) {
576 wchar_t itemText[256];
577 HMENU submenu = GetSubMenu(PopupMenu, i);
578
579 if (submenu != NULL) {
580 InitMenuPopup(submenu);
581 }
582
583 if (GetMenuStringW(PopupMenu, i, itemText, _countof(itemText), MF_BYPOSITION) != 0) {
584 int state = GetMenuState(PopupMenu, i, MF_BYPOSITION) &
585 (MF_CHECKED | MF_DISABLED | MF_GRAYED | MF_HILITE |
586 MF_MENUBARBREAK | MF_MENUBREAK | MF_SEPARATOR);
587
588 AppendMenuW(PopupBase,
589 submenu != NULL ? LOBYTE(state) | MF_POPUP : state,
590 submenu != NULL ? (UINT_PTR)submenu : GetMenuItemID(PopupMenu, i),
591 itemText);
592 }
593 }
594
595 ::ClientToScreen(HVTWin, &p);
596 TrackPopupMenu(PopupBase,TPM_LEFTALIGN | TPM_LEFTBUTTON,
597 p.x,p.y,0,HVTWin,NULL);
598 if (WinMenu!=NULL) {
599 DestroyMenu(WinMenu);
600 WinMenu = NULL;
601 }
602 DestroyMenu(PopupBase);
603 DestroyMenu(PopupMenu);
604 PopupMenu = 0;
605 return;
606 }
607
608 mousereport = MouseReport(IdMouseEventBtnDown, LMR, p.x, p.y);
609 if (mousereport) {
610 ::SetCapture(m_hWnd);
611 return;
612 }
613
614 // added ConfirmPasteMouseRButton (2007.3.17 maya)
615 if ((LMR == IdRightButton) &&
616 (ts.PasteFlag & CPF_DISABLE_RBUTTON) == 0 &&
617 (ts.PasteFlag & CPF_CONFIRM_RBUTTON) != 0 &&
618 cv.Ready &&
619 !mousereport &&
620 IsSendVarNULL() && IsFileVarNULL() &&
621 (cv.PortType!=IdFile) &&
622 (IsClipboardFormatAvailable(CF_TEXT) ||
623 IsClipboardFormatAvailable(CF_OEMTEXT))) {
624
625 int i, numItems;
626
627 InitPasteMenu(&PopupMenu);
628 PopupBase = CreatePopupMenu();
629 numItems = GetMenuItemCount(PopupMenu);
630
631 for (i = 0; i < numItems; i++) {
632 wchar_t itemText[256];
633 if (GetMenuStringW(PopupMenu, i, itemText, _countof(itemText), MF_BYPOSITION) != 0) {
634 int state = GetMenuState(PopupMenu, i, MF_BYPOSITION) &
635 (MF_CHECKED | MF_DISABLED | MF_GRAYED | MF_HILITE |
636 MF_MENUBARBREAK | MF_MENUBREAK | MF_SEPARATOR);
637
638 AppendMenuW(PopupBase, state,
639 GetMenuItemID(PopupMenu, i), itemText);
640 }
641 }
642
643 ::ClientToScreen(HVTWin, &p);
644 TrackPopupMenu(PopupBase,TPM_LEFTALIGN | TPM_LEFTBUTTON,
645 p.x,p.y,0,HVTWin,NULL);
646 if (WinMenu!=NULL) {
647 DestroyMenu(WinMenu);
648 WinMenu = NULL;
649 }
650 DestroyMenu(PopupBase);
651 DestroyMenu(PopupMenu);
652 PopupMenu = 0;
653 return;
654 }
655
656 if (AfterDblClk && (LMR==IdLeftButton) &&
657 (abs(p.x-DblClkX)<=GetSystemMetrics(SM_CXDOUBLECLK)) &&
658 (abs(p.y-DblClkY)<=GetSystemMetrics(SM_CYDOUBLECLK))) {
659 /* triple click */
660 ::KillTimer(HVTWin, IdDblClkTimer);
661 AfterDblClk = FALSE;
662 BuffTplClk(p.y);
663 LButton = TRUE;
664 TplClk = TRUE;
665 /* for AutoScrolling */
666 ::SetCapture(HVTWin);
667 ::SetTimer(HVTWin, IdScrollTimer, 100, NULL);
668 }
669 else {
670 if (! (LButton || MButton || RButton)) {
671 BOOL box = FALSE;
672
673 // select several pages of output from Tera Term window (2005.5.15 yutaka)
674 if (LMR == IdLeftButton && ShiftKey()) {
675 BuffSeveralPagesSelect(p.x, p.y);
676
677 } else {
678 // Select rectangular block with Alt Key. Delete Shift key.(2005.5.15 yutaka)
679 if (LMR == IdLeftButton && AltKey()) {
680 box = TRUE;
681 }
682
683 // Starting the selection only by a left button.(2007.11.20 maya)
684 if (!ts.SelectOnlyByLButton ||
685 (ts.SelectOnlyByLButton && LMR == IdLeftButton) ) {
686 BuffStartSelect(p.x,p.y, box);
687 TplClk = FALSE;
688
689 /* for AutoScrolling */
690 ::SetCapture(HVTWin);
691 ::SetTimer(HVTWin, IdScrollTimer, 100, NULL);
692 }
693 }
694 }
695
696 switch (LMR) {
697 case IdRightButton:
698 RButton = TRUE;
699 break;
700 case IdMiddleButton:
701 MButton = TRUE;
702 break;
703 case IdLeftButton:
704 LButton = TRUE;
705 break;
706 }
707 }
708 }
709
710 void CVTWindow::InitMenu(HMENU *Menu)
711 {
712 static const DlgTextInfo MenuTextInfo[] = {
713 { ID_FILE, "MENU_FILE" },
714 { ID_EDIT, "MENU_EDIT" },
715 { ID_SETUP, "MENU_SETUP" },
716 { ID_CONTROL, "MENU_CONTROL" },
717 { ID_HELPMENU, "MENU_HELP" },
718 };
719 static const DlgTextInfo FileMenuTextInfo[] = {
720 { ID_FILE_NEWCONNECTION, "MENU_FILE_NEW" },
721 { ID_FILE_DUPLICATESESSION, "MENU_FILE_DUPLICATE" },
722 { ID_FILE_CYGWINCONNECTION, "MENU_FILE_GYGWIN" },
723 { ID_FILE_LOG, "MENU_FILE_LOG" },
724 { ID_FILE_COMMENTTOLOG, "MENU_FILE_COMMENTLOG" },
725 { ID_FILE_VIEWLOG, "MENU_FILE_VIEWLOG" },
726 { ID_FILE_SHOWLOGDIALOG, "MENU_FILE_SHOWLOGDIALOG" },
727 { ID_FILE_PAUSELOG, "MENU_FILE_PAUSELOG" },
728 { ID_FILE_STOPLOG, "MENU_FILE_STOPLOG" },
729 { ID_FILE_SENDFILE, "MENU_FILE_SENDFILE" },
730 { ID_FILE_REPLAYLOG, "MENU_FILE_REPLAYLOG" },
731 { ID_FILE_CHANGEDIR, "MENU_FILE_CHANGEDIR" },
732 { ID_FILE_PRINT2, "MENU_FILE_PRINT" },
733 { ID_FILE_DISCONNECT, "MENU_FILE_DISCONNECT" },
734 { ID_FILE_EXIT, "MENU_FILE_EXIT" },
735 { ID_FILE_EXITALL, "MENU_FILE_EXITALL" },
736 { 11, "MENU_TRANS" },
737 { ID_FILE_KERMITRCV, "MENU_TRANS_KERMIT_RCV" },
738 { ID_FILE_KERMITGET, "MENU_TRANS_KERMIT_GET" },
739 { ID_FILE_KERMITSEND, "MENU_TRANS_KERMIT_SEND" },
740 { ID_FILE_KERMITFINISH, "MENU_TRANS_KERMIT_FINISH" },
741 { ID_FILE_XRCV, "MENU_TRANS_X_RCV" },
742 { ID_FILE_XSEND, "MENU_TRANS_X_SEND" },
743 { ID_FILE_YRCV, "MENU_TRANS_Y_RCV" },
744 { ID_FILE_YSEND, "MENU_TRANS_Y_SEND" },
745 { ID_FILE_ZRCV, "MENU_TRANS_Z_RCV" },
746 { ID_FILE_ZSEND, "MENU_TRANS_Z_SEND" },
747 { ID_FILE_BPRCV, "MENU_TRANS_BP_RCV" },
748 { ID_FILE_BPSEND, "MENU_TRANS_BP_SEND" },
749 { ID_FILE_QVRCV, "MENU_TRANS_QV_RCV" },
750 { ID_FILE_QVSEND, "MENU_TRANS_QV_SEND" },
751 };
752 static const DlgTextInfo EditMenuTextInfo[] = {
753 { ID_EDIT_COPY2, "MENU_EDIT_COPY" },
754 { ID_EDIT_COPYTABLE, "MENU_EDIT_COPYTABLE" },
755 { ID_EDIT_PASTE2, "MENU_EDIT_PASTE" },
756 { ID_EDIT_PASTECR, "MENU_EDIT_PASTECR" },
757 { ID_EDIT_CLEARSCREEN, "MENU_EDIT_CLSCREEN" },
758 { ID_EDIT_CLEARBUFFER, "MENU_EDIT_CLBUFFER" },
759 { ID_EDIT_CANCELSELECT, "MENU_EDIT_CANCELSELECT" },
760 { ID_EDIT_SELECTSCREEN, "MENU_EDIT_SELECTSCREEN" },
761 { ID_EDIT_SELECTALL, "MENU_EDIT_SELECTALL" },
762 };
763 static const DlgTextInfo SetupMenuTextInfo[] = {
764 { ID_SETUP_TERMINAL, "MENU_SETUP_TERMINAL" },
765 { ID_SETUP_WINDOW, "MENU_SETUP_WINDOW" },
766 { ID_SETUP_FONT, "MENU_SETUP_FONT" },
767 { ID_SETUP_DLG_FONT, "MENU_SETUP_DIALOG_FONT" },
768 { 2, "MENU_SETUP_FONT_SUBMENU" },
769 { ID_SETUP_KEYBOARD, "MENU_SETUP_KEYBOARD" },
770 { ID_SETUP_SERIALPORT, "MENU_SETUP_SERIALPORT" },
771 { ID_SETUP_TCPIP, "MENU_SETUP_TCPIP" },
772 { ID_SETUP_GENERAL, "MENU_SETUP_GENERAL" },
773 { ID_SETUP_ADDITIONALSETTINGS, "MENU_SETUP_ADDITION" },
774 { ID_SETUP_SAVE, "MENU_SETUP_SAVE" },
775 { ID_SETUP_RESTORE, "MENU_SETUP_RESTORE" },
776 { ID_OPEN_SETUP, "MENU_SETUP_OPENSETUP" },
777 { ID_SETUP_LOADKEYMAP, "MENU_SETUP_LOADKEYMAP" },
778 };
779 static const DlgTextInfo ControlMenuTextInfo[] = {
780 { ID_CONTROL_RESETTERMINAL, "MENU_CONTROL_RESET" },
781 { ID_CONTROL_RESETREMOTETITLE, "MENU_CONTROL_RESETTITLE" },
782 { ID_CONTROL_AREYOUTHERE, "MENU_CONTROL_AREYOUTHERE" },
783 { ID_CONTROL_SENDBREAK, "MENU_CONTROL_SENDBREAK" },
784 { ID_CONTROL_RESETPORT, "MENU_CONTROL_RESETPORT" },
785 { ID_CONTROL_BROADCASTCOMMAND, "MENU_CONTROL_BROADCAST" },
786 { ID_CONTROL_OPENTEK, "MENU_CONTROL_OPENTEK" },
787 { ID_CONTROL_CLOSETEK, "MENU_CONTROL_CLOSETEK" },
788 { ID_CONTROL_MACRO, "MENU_CONTROL_MACRO" },
789 { ID_CONTROL_SHOW_MACRO, "MENU_CONTROL_SHOW_MACRO" },
790 };
791 static const DlgTextInfo HelpMenuTextInfo[] = {
792 { ID_HELP_INDEX2, "MENU_HELP_INDEX" },
793 { ID_HELP_ABOUT, "MENU_HELP_ABOUT" },
794 };
795
796 HMENU hMenu = LoadMenu(m_hInst, MAKEINTRESOURCE(IDR_MENU));
797 *Menu = hMenu;
798
799 FileMenu = GetSubMenu(hMenu,ID_FILE);
800 TransMenu = GetSubMenu(FileMenu,ID_TRANSFER);
801 EditMenu = GetSubMenu(hMenu,ID_EDIT);
802 SetupMenu = GetSubMenu(hMenu,ID_SETUP);
803 ControlMenu = GetSubMenu(hMenu,ID_CONTROL);
804 HelpMenu = GetSubMenu(hMenu,ID_HELPMENU);
805
806 SetDlgMenuTextsW(hMenu, MenuTextInfo, _countof(MenuTextInfo), ts.UILanguageFileW);
807
808 SetDlgMenuTextsW(FileMenu, FileMenuTextInfo, _countof(FileMenuTextInfo), ts.UILanguageFileW);
809 SetDlgMenuTextsW(EditMenu, EditMenuTextInfo, _countof(EditMenuTextInfo), ts.UILanguageFileW);
810 SetDlgMenuTextsW(SetupMenu, SetupMenuTextInfo, _countof(SetupMenuTextInfo), ts.UILanguageFileW);
811 SetDlgMenuTextsW(ControlMenu, ControlMenuTextInfo, _countof(ControlMenuTextInfo), ts.UILanguageFileW);
812 SetDlgMenuTextsW(HelpMenu, HelpMenuTextInfo, _countof(HelpMenuTextInfo), ts.UILanguageFileW);
813
814 if ((ts.MenuFlag & MF_SHOWWINMENU) !=0) {
815 wchar_t uimsg[MAX_UIMSG];
816 WinMenu = CreatePopupMenu();
817 get_lang_msgW("MENU_WINDOW", uimsg, _countof(uimsg),
818 L"&Window", ts.UILanguageFile);
819 InsertMenuW(hMenu, ID_HELPMENU,
820 MF_STRING | MF_ENABLED | MF_POPUP | MF_BYPOSITION,
821 (UINT_PTR)WinMenu, uimsg);
822 }
823
824 TTXModifyMenu(hMenu); /* TTPLUG */
825 }
826
827 void CVTWindow::InitMenuPopup(HMENU SubMenu)
828 {
829 if ( SubMenu == FileMenu )
830 {
831 if (ts.DisableMenuNewConnection) {
832 if ( Connecting || cv.Open ) {
833 EnableMenuItem(FileMenu,ID_FILE_NEWCONNECTION,MF_BYCOMMAND | MF_GRAYED);
834 }
835 else {
836 EnableMenuItem(FileMenu,ID_FILE_NEWCONNECTION,MF_BYCOMMAND | MF_ENABLED);
837 }
838 }
839 else {
840 if ( Connecting ) {
841 EnableMenuItem(FileMenu,ID_FILE_NEWCONNECTION,MF_BYCOMMAND | MF_GRAYED);
842 }
843 else {
844 EnableMenuItem(FileMenu,ID_FILE_NEWCONNECTION,MF_BYCOMMAND | MF_ENABLED);
845 }
846 }
847
848 if ( (! cv.Ready) || (!IsSendVarNULL()) ||
849 (!IsFileVarNULL()) || (cv.PortType==IdFile) ) {
850 EnableMenuItem(FileMenu,ID_FILE_SENDFILE,MF_BYCOMMAND | MF_GRAYED);
851 EnableMenuItem(FileMenu,ID_TRANSFER,MF_BYPOSITION | MF_GRAYED); /* Transfer */
852 EnableMenuItem(FileMenu,ID_FILE_CHANGEDIR,MF_BYCOMMAND | MF_GRAYED);
853 EnableMenuItem(FileMenu,ID_FILE_DISCONNECT,MF_BYCOMMAND | MF_GRAYED);
854 EnableMenuItem(FileMenu,ID_FILE_DUPLICATESESSION,MF_BYCOMMAND | MF_GRAYED);
855 }
856 else {
857 EnableMenuItem(FileMenu,ID_FILE_SENDFILE,MF_BYCOMMAND | MF_ENABLED);
858 EnableMenuItem(FileMenu,ID_TRANSFER,MF_BYPOSITION | MF_ENABLED); /* Transfer */
859 EnableMenuItem(FileMenu,ID_FILE_CHANGEDIR,MF_BYCOMMAND | MF_ENABLED);
860 EnableMenuItem(FileMenu,ID_FILE_DISCONNECT,MF_BYCOMMAND | MF_ENABLED);
861 if (ts.DisableMenuDuplicateSession) {
862 EnableMenuItem(FileMenu,ID_FILE_DUPLICATESESSION,MF_BYCOMMAND | MF_GRAYED);
863 }
864 else {
865 EnableMenuItem(FileMenu,ID_FILE_DUPLICATESESSION,MF_BYCOMMAND | MF_ENABLED);
866 }
867 }
868
869 // �V�K���j���[������ (2004.12.5 yutaka)
870 EnableMenuItem(FileMenu,ID_FILE_CYGWINCONNECTION,MF_BYCOMMAND | MF_ENABLED);
871 EnableMenuItem(FileMenu,ID_FILE_TERATERMMENU,MF_BYCOMMAND | MF_ENABLED);
872
873 // XXX: �������u�����������Alog���O���C�����������B (2005.2.1 yutaka)
874 if (FLogIsOpend()) { // ���O�������[�h������
875 EnableMenuItem(FileMenu,ID_FILE_LOG,MF_BYCOMMAND | MF_GRAYED);
876 EnableMenuItem(FileMenu,ID_FILE_COMMENTTOLOG, MF_BYCOMMAND | MF_ENABLED);
877 EnableMenuItem(FileMenu,ID_FILE_VIEWLOG, MF_BYCOMMAND | MF_ENABLED);
878 EnableMenuItem(FileMenu,ID_FILE_SHOWLOGDIALOG, MF_BYCOMMAND | MF_ENABLED);
879 EnableMenuItem(FileMenu,ID_FILE_PAUSELOG, MF_BYCOMMAND | MF_ENABLED);
880 EnableMenuItem(FileMenu,ID_FILE_STOPLOG, MF_BYCOMMAND | MF_ENABLED);
881 if (FLogIsPause()) {
882 CheckMenuItem(FileMenu,ID_FILE_PAUSELOG, MF_BYCOMMAND | MF_CHECKED);
883 }
884 else {
885 CheckMenuItem(FileMenu,ID_FILE_PAUSELOG, MF_BYCOMMAND | MF_UNCHECKED);
886 }
887 } else {
888 EnableMenuItem(FileMenu,ID_FILE_LOG,MF_BYCOMMAND | MF_ENABLED);
889 EnableMenuItem(FileMenu,ID_FILE_COMMENTTOLOG, MF_BYCOMMAND | MF_GRAYED);
890 EnableMenuItem(FileMenu,ID_FILE_VIEWLOG, MF_BYCOMMAND | MF_GRAYED);
891 EnableMenuItem(FileMenu,ID_FILE_SHOWLOGDIALOG, MF_BYCOMMAND | MF_GRAYED);
892 EnableMenuItem(FileMenu,ID_FILE_PAUSELOG, MF_BYCOMMAND | MF_GRAYED);
893 EnableMenuItem(FileMenu,ID_FILE_STOPLOG, MF_BYCOMMAND | MF_GRAYED);
894
895 CheckMenuItem(FileMenu,ID_FILE_PAUSELOG, MF_BYCOMMAND | MF_UNCHECKED);
896 }
897
898 }
899 else if ( SubMenu == TransMenu )
900 {
901 if ((cv.PortType==IdSerial) &&
902 ((ts.DataBit==IdDataBit7) || (ts.Flow==IdFlowX))) {
903 EnableMenuItem(TransMenu,1,MF_BYPOSITION | MF_GRAYED); /* XMODEM */
904 EnableMenuItem(TransMenu,4,MF_BYPOSITION | MF_GRAYED); /* Quick-VAN */
905 }
906 else {
907 EnableMenuItem(TransMenu,1,MF_BYPOSITION | MF_ENABLED); /* XMODEM */
908 EnableMenuItem(TransMenu,4,MF_BYPOSITION | MF_ENABLED); /* Quick-VAN */
909 }
910 if ((cv.PortType==IdSerial) &&
911 (ts.DataBit==IdDataBit7)) {
912 EnableMenuItem(TransMenu,2,MF_BYPOSITION | MF_GRAYED); /* ZMODEM */
913 EnableMenuItem(TransMenu,3,MF_BYPOSITION | MF_GRAYED); /* B-Plus */
914 }
915 else {
916 EnableMenuItem(TransMenu,2,MF_BYPOSITION | MF_ENABLED); /* ZMODEM */
917 EnableMenuItem(TransMenu,3,MF_BYPOSITION | MF_ENABLED); /* B-Plus */
918 }
919 }
920 else if (SubMenu == EditMenu)
921 {
922 if (Selected) {
923 EnableMenuItem(EditMenu,ID_EDIT_COPY2,MF_BYCOMMAND | MF_ENABLED);
924 EnableMenuItem(EditMenu,ID_EDIT_COPYTABLE,MF_BYCOMMAND | MF_ENABLED);
925 }
926 else {
927 EnableMenuItem(EditMenu,ID_EDIT_COPY2,MF_BYCOMMAND | MF_GRAYED);
928 EnableMenuItem(EditMenu,ID_EDIT_COPYTABLE,MF_BYCOMMAND | MF_GRAYED);
929 }
930 if (cv.Ready &&
931 IsSendVarNULL() && IsFileVarNULL() &&
932 (cv.PortType!=IdFile) &&
933 (IsClipboardFormatAvailable(CF_TEXT) ||
934 IsClipboardFormatAvailable(CF_OEMTEXT))) {
935 EnableMenuItem(EditMenu,ID_EDIT_PASTE2,MF_BYCOMMAND | MF_ENABLED);
936 EnableMenuItem(EditMenu,ID_EDIT_PASTECR,MF_BYCOMMAND | MF_ENABLED);
937 }
938 else {
939 EnableMenuItem(EditMenu,ID_EDIT_PASTE2,MF_BYCOMMAND | MF_GRAYED);
940 EnableMenuItem(EditMenu,ID_EDIT_PASTECR,MF_BYCOMMAND | MF_GRAYED);
941 }
942 }
943 else if (SubMenu == SetupMenu)
944 /*
945 * �l�b�g���[�N������(TCP/IP���I������������������)���V���A���|�[�g
946 * (ID_SETUP_SERIALPORT)�����j���[���I�����������������������������A
947 * �����K�[�h���O���A�V���A���|�[�g�����_�C�A���O�����V���������������������������B
948 */
949 if (!IsSendVarNULL() || !IsFileVarNULL() || Connecting) {
950 EnableMenuItem(SetupMenu,ID_SETUP_SERIALPORT,MF_BYCOMMAND | MF_GRAYED);
951 }
952 else {
953 EnableMenuItem(SetupMenu,ID_SETUP_SERIALPORT,MF_BYCOMMAND | MF_ENABLED);
954 }
955
956 else if (SubMenu == ControlMenu)
957 {
958 if (cv.Ready &&
959 IsSendVarNULL() && IsFileVarNULL()) {
960 if (ts.DisableMenuSendBreak) {
961 EnableMenuItem(ControlMenu,ID_CONTROL_SENDBREAK,MF_BYCOMMAND | MF_GRAYED);
962 }
963 else {
964 EnableMenuItem(ControlMenu,ID_CONTROL_SENDBREAK,MF_BYCOMMAND | MF_ENABLED);
965 }
966 if (cv.PortType==IdSerial) {
967 EnableMenuItem(ControlMenu,ID_CONTROL_RESETPORT,MF_BYCOMMAND | MF_ENABLED);
968 }
969 else {
970 EnableMenuItem(ControlMenu,ID_CONTROL_RESETPORT,MF_BYCOMMAND | MF_GRAYED);
971 }
972 }
973 else {
974 EnableMenuItem(ControlMenu,ID_CONTROL_SENDBREAK,MF_BYCOMMAND | MF_GRAYED);
975 EnableMenuItem(ControlMenu,ID_CONTROL_RESETPORT,MF_BYCOMMAND | MF_GRAYED);
976 }
977
978 if (cv.Ready && cv.TelFlag && IsFileVarNULL()) {
979 EnableMenuItem(ControlMenu,ID_CONTROL_AREYOUTHERE,MF_BYCOMMAND | MF_ENABLED);
980 }
981 else {
982 EnableMenuItem(ControlMenu,ID_CONTROL_AREYOUTHERE,MF_BYCOMMAND | MF_GRAYED);
983 }
984
985 if (HTEKWin==0) {
986 EnableMenuItem(ControlMenu,ID_CONTROL_CLOSETEK,MF_BYCOMMAND | MF_GRAYED);
987 }
988 else {
989 EnableMenuItem(ControlMenu,ID_CONTROL_CLOSETEK,MF_BYCOMMAND | MF_ENABLED);
990 }
991
992 if (DDELog || !IsFileVarNULL()) {
993 EnableMenuItem(ControlMenu,ID_CONTROL_MACRO,MF_BYCOMMAND | MF_GRAYED);
994 EnableMenuItem(ControlMenu,ID_CONTROL_SHOW_MACRO,MF_BYCOMMAND | MF_ENABLED);
995 }
996 else {
997 EnableMenuItem(ControlMenu,ID_CONTROL_MACRO,MF_BYCOMMAND | MF_ENABLED);
998 EnableMenuItem(ControlMenu,ID_CONTROL_SHOW_MACRO,MF_BYCOMMAND | MF_GRAYED);
999 }
1000
1001 }
1002 else if (SubMenu == WinMenu)
1003 {
1004 SetWinMenu(WinMenu, ts.UIMsg, sizeof(ts.UIMsg), ts.UILanguageFile, 1);
1005 }
1006
1007 TTXModifyPopupMenu(SubMenu); /* TTPLUG */
1008 }
1009
1010 // added ConfirmPasteMouseRButton (2007.3.17 maya)
1011 void CVTWindow::InitPasteMenu(HMENU *Menu)
1012 {
1013 static const DlgTextInfo MenuTextInfo[] = {
1014 { ID_EDIT_PASTE2, "MENU_EDIT_PASTE" },
1015 { ID_EDIT_PASTECR, "MENU_EDIT_PASTECR" },
1016 };
1017 *Menu = LoadMenu(m_hInst,
1018 MAKEINTRESOURCE(IDR_PASTEMENU));
1019 SetDlgMenuTextsW(*Menu, MenuTextInfo, _countof(MenuTextInfo), ts.UILanguageFileW);
1020 }
1021
1022 void CVTWindow::ResetSetup()
1023 {
1024 ChangeFont();
1025 BuffChangeWinSize(WinWidth,WinHeight);
1026 ChangeCaret();
1027
1028 if (cv.Ready) {
1029 ts.PortType = cv.PortType;
1030 if (cv.PortType==IdSerial) {
1031 /* if serial port, change port parameters */
1032 ts.ComPort = cv.ComPort;
1033 CommResetSerial(&ts, &cv, TRUE);
1034 }
1035 }
1036
1037 /* setup terminal */
1038 SetupTerm();
1039
1040 /* background and ANSI color */
1041
1042 #if 0
1043 // �N�������������������e�[�}����������������������������
1044 BGInitialize(FALSE);
1045 BGSetupPrimary(TRUE);
1046 #endif
1047
1048 // 2006/03/17 by 337 : Alpha�l���������X
1049 // Layered��������������������������������
1050 //
1051 // AlphaBlend ���������f�����������������B
1052 // (2016.12.24 yutaka)
1053 SetWindowAlpha(ts.AlphaBlendActive);
1054
1055 /* setup window */
1056 ChangeWin();
1057
1058 /* Language & IME */
1059 ResetIME();
1060
1061 /* change TEK window */
1062 if (pTEKWin != NULL)
1063 ((CTEKWindow *)pTEKWin)->RestoreSetup();
1064 }
1065
1066 void CVTWindow::RestoreSetup()
1067 {
1068 char TempDir[MAXPATHLEN];
1069 char TempName[MAX_PATH];
1070
1071 if ( strlen(ts.SetupFName)==0 ) {
1072 return;
1073 }
1074
1075 ExtractFileName(ts.SetupFName,TempName,sizeof(TempName));
1076 ExtractDirName(ts.SetupFName,TempDir);
1077 if (TempDir[0]==0)
1078 strncpy_s(TempDir, sizeof(TempDir),ts.HomeDir, _TRUNCATE);
1079 FitFileName(TempName,sizeof(TempName),".INI");
1080
1081 strncpy_s(ts.SetupFName, sizeof(ts.SetupFName),TempDir, _TRUNCATE);
1082 AppendSlash(ts.SetupFName,sizeof(ts.SetupFName));
1083 strncat_s(ts.SetupFName,sizeof(ts.SetupFName),TempName,_TRUNCATE);
1084
1085 if (LoadTTSET()) {
1086 (*ReadIniFile)(ts.SetupFNameW, &ts);
1087 }
1088 FreeTTSET();
1089
1090 ResetSetup();
1091 }
1092
1093 /* called by the [Setup] Terminal command */
1094 void CVTWindow::SetupTerm()
1095 {
1096 // if (ts.Language==IdJapanese || ts.Language==IdKorean || ts.Language==IdUtf8) {
1097 ResetCharSet();
1098 // }
1099 cv.CRSend = ts.CRSend;
1100
1101 if (cv.Ready) {
1102 if (cv.TelFlag && (ts.TelEcho>0)) {
1103 TelChangeEcho();
1104 }
1105 }
1106
1107 if ((ts.TerminalWidth!=NumOfColumns) ||
1108 (ts.TerminalHeight!=NumOfLines-StatusLine)) {
1109 LockBuffer();
1110 HideStatusLine();
1111 ChangeTerminalSize(ts.TerminalWidth,
1112 ts.TerminalHeight);
1113 UnlockBuffer();
1114 }
1115 else if ((ts.TermIsWin>0) &&
1116 ((ts.TerminalWidth!=WinWidth) ||
1117 (ts.TerminalHeight!=WinHeight-StatusLine))) {
1118 BuffChangeWinSize(ts.TerminalWidth,ts.TerminalHeight+StatusLine);
1119 }
1120
1121 ChangeTerminalID();
1122 }
1123
1124 void CVTWindow::Startup()
1125 {
1126 /* auto log */
1127 /* OnCommOpen ���J�n�������������������J�n������ (2007.5.14 maya) */
1128
1129 if ((TopicName[0]==0) && (ts.MacroFN[0]!=0)) {
1130 // start the macro specified in the command line or setup file
1131 RunMacro(ts.MacroFN,TRUE);
1132 ts.MacroFN[0] = 0;
1133 }
1134 else {// start connection
1135 if (TopicName[0]!=0) {
1136 cv.NoMsg=1; /* suppress error messages */
1137 }
1138 ::PostMessage(HVTWin,WM_USER_COMMSTART,0,0);
1139 }
1140 }
1141
1142 void CVTWindow::OpenTEK()
1143 {
1144 ActiveWin = IdTEK;
1145 if (HTEKWin==NULL) {
1146 pTEKWin = new CTEKWindow(m_hInst);
1147 }
1148 else {
1149 ::ShowWindow(HTEKWin,SW_SHOWNORMAL);
1150 ::SetFocus(HTEKWin);
1151 }
1152 }
1153
1154 /////////////////////////////////////////////////////////////////////////////
1155 // CVTWindow message handler
1156
1157 BOOL CVTWindow::OnCommand(WPARAM wParam, LPARAM lParam)
1158 {
1159 WORD wID = LOWORD(wParam);
1160 WORD wNotifyCode = HIWORD(wParam);
1161
1162 if (wNotifyCode==1) {
1163 switch (wID) {
1164 case ID_ACC_SENDBREAK:
1165 // added DisableAcceleratorSendBreak (2007.3.17 maya)
1166 if (!ts.DisableAcceleratorSendBreak)
1167 OnControlSendBreak();
1168 return TRUE;
1169 case ID_ACC_AREYOUTHERE:
1170 OnControlAreYouThere();
1171 return TRUE;
1172 }
1173 if (ActiveWin==IdVT) {
1174 switch (wID) {
1175 case ID_ACC_NEWCONNECTION:
1176 if (ts.AcceleratorNewConnection)
1177 OnFileNewConnection();
1178 return TRUE;
1179 case ID_ACC_DUPLICATESESSION:
1180 // added DisableAcceleratorDuplicateSession (2009.4.6 maya)
1181 if (!ts.DisableAcceleratorDuplicateSession)
1182 OnDuplicateSession();
1183 return TRUE;
1184 case ID_ACC_CYGWINCONNECTION:
1185 if (ts.AcceleratorCygwinConnection)
1186 OnCygwinConnection();
1187 return TRUE;
1188 case ID_ACC_DISCONNECT:
1189 Disconnect(TRUE);
1190 return TRUE;
1191 case ID_ACC_COPY:
1192 OnEditCopy();
1193 return TRUE;
1194 case ID_ACC_PASTECR:
1195 OnEditPasteCR();
1196 return TRUE;
1197 case ID_ACC_PASTE:
1198 OnEditPaste();
1199 return TRUE;
1200 case ID_ACC_PRINT:
1201 OnFilePrint();
1202 return TRUE;
1203 case ID_ACC_EXIT:
1204 OnFileExit();
1205 return TRUE;
1206 }
1207 }
1208 else { // transfer accelerator message to TEK win
1209 switch (wID) {
1210 case ID_ACC_COPY:
1211 ::PostMessage(HTEKWin,WM_COMMAND,ID_TEKEDIT_COPY,0);
1212 return TRUE;
1213 case ID_ACC_PASTECR:
1214 ::PostMessage(HTEKWin,WM_COMMAND,ID_TEKEDIT_PASTECR,0);
1215 return TRUE;
1216 case ID_ACC_PASTE:
1217 ::PostMessage(HTEKWin,WM_COMMAND,ID_TEKEDIT_PASTE,0);
1218 return TRUE;
1219 case ID_ACC_PRINT:
1220 ::PostMessage(HTEKWin,WM_COMMAND,ID_TEKFILE_PRINT,0);
1221 return TRUE;
1222 case ID_ACC_EXIT:
1223 ::PostMessage(HTEKWin,WM_COMMAND,ID_TEKFILE_EXIT,0);
1224 return TRUE;
1225 }
1226 }
1227 }
1228
1229 if ((wID>=ID_WINDOW_1) && (wID<ID_WINDOW_1+9)) {
1230 SelectWin(wID-ID_WINDOW_1);
1231 return TRUE;
1232 }
1233 else {
1234 if (TTXProcessCommand(HVTWin, wID)) {
1235 return TRUE;
1236 }
1237 else { /* TTPLUG */
1238 return TTCFrameWnd::OnCommand(wParam, lParam);
1239 }
1240 }
1241 }
1242
1243 void CVTWindow::OnActivate(UINT nState, HWND pWndOther, BOOL bMinimized)
1244 {
1245 DispSetActive(nState!=WA_INACTIVE);
1246 if (nState == WA_INACTIVE) {
1247 SetWindowAlpha(ts.AlphaBlendInactive);
1248 } else {
1249 SetWindowAlpha(ts.AlphaBlendActive);
1250 }
1251 }
1252
1253 /**
1254 * �L�[�{�[�h����1��������
1255 * @param nChar UTF-16 char(wchar_t) IsWindowUnicode() == TRUE ��
1256 * ANSI char(char) IsWindowUnicode() == FALSE ��
1257 */
1258 void CVTWindow::OnChar(WPARAM nChar, UINT nRepCnt, UINT nFlags)
1259 {
1260 unsigned int i;
1261
1262 if (!KeybEnabled || (TalkStatus!=IdTalkKeyb)) {
1263 return;
1264 }
1265
1266 if (MetaKey(ts.MetaKey)) {
1267 ::PostMessage(HVTWin,WM_SYSCHAR,nChar,MAKELONG(nRepCnt,nFlags));
1268 return;
1269 }
1270
1271 wchar_t u16;
1272 if (IsWindowUnicode(HVTWin) == TRUE) {
1273 // ������ UTF-16
1274 u16 = (wchar_t)nChar;
1275 } else {
1276 // ������ ANSI
1277 if (ts.Language == IdJapanese || ts.Language == IdChinese || ts.Language == IdKorean) {
1278 // CJK (2byte����)
1279 if (vtwin_work.dbcs_lead_byte == 0 && IsDBCSLeadByte(nChar)) {
1280 // ANSI 2�o�C�g������ 1byte��������
1281 // ������ WM_IME_* ���b�Z�[�W������������
1282 // ������������������������
1283 // TERATERM.INI �� IME=off ������
1284 // imm32.dll �����[�h����������������
1285 vtwin_work.dbcs_lead_byte = nChar;
1286 return;
1287 }
1288 else {
1289 // ANSI(ACP) -> UTF-32 -> UTF-16
1290 char mb_str[2];
1291 size_t mb_len;
1292 if (vtwin_work.dbcs_lead_byte == 0) {
1293 // 1�o�C�g����
1294 mb_str[0] = (char)nChar;
1295 mb_len = 1;
1296 }
1297 else {
1298 // 2�o�C�g����
1299 mb_str[0] = (char)vtwin_work.dbcs_lead_byte;
1300 mb_str[1] = (char)nChar;
1301 mb_len = 2;
1302 vtwin_work.dbcs_lead_byte = 0;
1303 }
1304 unsigned int u32;
1305 mb_len = MBCPToUTF32(mb_str, mb_len, CP_ACP, &u32);
1306 if (mb_len == 0) {
1307 return;
1308 }
1309 u16 = (wchar_t)u32;
1310 }
1311 }
1312 else if (ts.Language == IdRussian) {
1313 BYTE c;
1314 if (ts.RussKeyb == IdWindows) {
1315 // key = CP1251
1316 c = (char)nChar;
1317 }
1318 else {
1319 // key -> CP1251
1320 c = RussConv(ts.RussKeyb, IdWindows, nChar);
1321 }
1322 // CP1251 -> UTF-32 -> UTF-16
1323 unsigned long u32 = MBCP_UTF32(c, 1251);
1324 u16 = (wchar_t)u32;
1325 }
1326 else {
1327 u16 = (wchar_t)nChar;
1328 }
1329 }
1330
1331 // �o�b�t�@���o���A�������o��
1332 for (i=1 ; i<=nRepCnt ; i++) {
1333 CommTextOutW(&cv,&u16,1);
1334 if (ts.LocalEcho>0) {
1335 CommTextEchoW(&cv,&u16,1);
1336 }
1337 }
1338
1339 // �X�N���[�����u�����Z�b�g
1340 if (WinOrgY != 0) {
1341 DispVScroll(SCROLL_BOTTOM, 0);
1342 }
1343 }
1344
1345 LRESULT CVTWindow::OnUniChar(WPARAM wParam, LPARAM lParam)
1346 {
1347 if (wParam == UNICODE_NOCHAR) {
1348 // �������b�Z�[�W���T�|�[�g�����������e�X�g��������������������
1349 return TRUE;
1350 }
1351
1352 char32_t u32 = (char32_t)wParam;
1353 wchar_t strW[2];
1354 size_t u16_len = UTF32ToUTF16(u32, strW, _countof(strW));
1355 CommTextOutW(&cv, strW, u16_len);
1356 if (ts.LocalEcho > 0) {
1357 CommTextEchoW(&cv, strW, u16_len);
1358 }
1359
1360 return FALSE;
1361 }
1362
1363 /* copy from ttset.c*/
1364 static void WriteInt2(const char *Sect, const char *Key, const char *FName, int i1, int i2)
1365 {
1366 char Temp[32];
1367 _snprintf_s(Temp, sizeof(Temp), _TRUNCATE, "%d,%d", i1, i2);
1368 WritePrivateProfileString(Sect, Key, Temp, FName);
1369 }
1370
1371 static void SaveVTPos()
1372 {
1373 #define Section "Tera Term"
1374 if (ts.SaveVTWinPos) {
1375 /* VT win position */
1376 WriteInt2(Section, "VTPos", ts.SetupFName, ts.VTPos.x, ts.VTPos.y);
1377
1378 /* VT terminal size */
1379 WriteInt2(Section, "TerminalSize", ts.SetupFName,
1380 ts.TerminalWidth, ts.TerminalHeight);
1381 }
1382 }
1383
1384 void CVTWindow::OnClose()
1385 {
1386 if ((HTEKWin!=NULL) && ! ::IsWindowEnabled(HTEKWin)) {
1387 MessageBeep(0);
1388 return;
1389 }
1390
1391 if (cv.Ready && (cv.PortType==IdTCPIP) &&
1392 ((ts.PortFlag & PF_CONFIRMDISCONN) != 0) &&
1393 ! CloseTT) {
1394 static const TTMessageBoxInfoW info = {
1395 "Tera Term",
1396 NULL, L"Tera Term",
1397 "MSG_DISCONNECT_CONF", L"Disconnect?",
1398 MB_OKCANCEL | MB_ICONEXCLAMATION | MB_DEFBUTTON2
1399 };
1400 int result = TTMessageBoxW(HVTWin, &info, ts.UILanguageFileW);
1401 if (result == IDCANCEL) {
1402 return;
1403 }
1404 }
1405
1406 FLogClose();
1407 FileSendEnd();
1408 ProtoEnd();
1409
1410 SaveVTPos();
1411 Notify2UnsetWindow((NotifyIcon *)cv.NotifyIcon);
1412
1413 // �A�v���P�[�V�����I�������A�C�R�����j���������A�E�B���h�E���������O��
1414 // �^�C�g���o�[���A�C�R���� "Windows �����s�t�@�C�����A�C�R��" ��������
1415 // ���������������j��������
1416 // TTSetIcon(m_hInst, m_hWnd, NULL, 0);
1417
1418 DestroyWindow();
1419 }
1420
1421 // �STera Term���I�����w������
1422 void CVTWindow::OnAllClose()
1423 {
1424 // ���R�I���������������������A�����������[�U���������������o�������������B
1425 static const TTMessageBoxInfoW info = {
1426 "Tera Term",
1427 NULL, L"Tera Term",
1428 "MSG_ALL_TERMINATE_CONF", L"Terminate ALL Tera Term(s)?",
1429 MB_OKCANCEL | MB_ICONERROR | MB_DEFBUTTON2
1430 };
1431 int result = TTMessageBoxW(HVTWin, &info, ts.UILanguageFileW);
1432 if (result == IDCANCEL)
1433 return;
1434
1435 BroadcastClosingMessage(HVTWin);
1436 }
1437
1438 // �I������������������Tera Term���I�������BOnAllClose()���M�p�B
1439 LRESULT CVTWindow::OnNonConfirmClose(WPARAM wParam, LPARAM lParam)
1440 {
1441 // ������ ts �����e�����}�I���������������A�I�����������Z�[�u�����������������������A�������������B
1442 ts.PortFlag &= ~PF_CONFIRMDISCONN;
1443 OnClose();
1444 return 1;
1445 }
1446
1447 void CVTWindow::OnDestroy()
1448 {
1449 // remove this window from the window list
1450 UnregWin(HVTWin);
1451
1452 // USB�f�o�C�X�������m����
1453 UnRegDeviceNotify(HVTWin);
1454
1455 EndKeyboard();
1456
1457 /* Disable drag-drop */
1458 ::DragAcceptFiles(HVTWin,FALSE);
1459 DropListFree();
1460
1461 EndDDE();
1462
1463 if (cv.TelFlag) {
1464 EndTelnet();
1465 }
1466 CommClose(&cv);
1467
1468 FreeIME(HVTWin);
1469 FreeTTSET();
1470
1471 #if 0
1472 do { }
1473 while (FreeTTFILE());
1474 #endif
1475
1476 if (HTEKWin != NULL) {
1477 ::DestroyWindow(HTEKWin);
1478 }
1479
1480 EndTerm();
1481 EndDisp();
1482
1483 FreeBuffer();
1484
1485 TTXEnd(); /* TTPLUG */
1486
1487 TTSetUnInit(&ts);
1488
1489 Notify2Uninitialize((NotifyIcon *)cv.NotifyIcon);
1490 cv.NotifyIcon = NULL;
1491
1492 DropUninit();
1493 }
1494
1495 static void EscapeFilename(const wchar_t *src, wchar_t *dest)
1496 {
1497 #define ESCAPE_CHARS L" ;&()$!`'[]{}#^~"
1498 const wchar_t *s = src;
1499 wchar_t *d = dest;
1500 while (*s) {
1501 wchar_t c = *s++;
1502 if (c == L'\\') {
1503 // �p�X���������� \ -> / ��
1504 *d = '/';
1505 } else if (wcschr(ESCAPE_CHARS, c) != NULL) {
1506 // �G�X�P�[�v���K�v������
1507 *d++ = L'\\';
1508 *d = c;
1509 } else {
1510 *d = c;
1511 }
1512 d++;
1513 }
1514 *d = '\0'; // null-terminate
1515 }
1516
1517 static wchar_t *GetPasteString(const wchar_t *str, bool escape)
1518 {
1519 wchar_t *tmpbuf;
1520 if (!escape) {
1521 tmpbuf = _wcsdup(str);
1522 }
1523 else {
1524 const size_t len = wcslen(str) * sizeof(wchar_t) * 2;
1525 tmpbuf = (wchar_t *)malloc(len);
1526 EscapeFilename(str, tmpbuf);
1527 }
1528 return tmpbuf;
1529 }
1530
1531 void CVTWindow::DropListFree()
1532 {
1533 if (DropListCount > 0) {
1534 for (int i = 0; i < DropListCount; i++) {
1535 free(DropLists[i]);
1536 DropLists[i] = NULL;
1537 }
1538 free(DropLists);
1539 DropLists = NULL;
1540 DropListCount = 0;
1541 }
1542 }
1543
1544 typedef struct DropData_tag {
1545 // ini���������������A�����s��������Tera Term�������L��������
1546 enum drop_type DefaultDropType;
1547 unsigned char DefaultDropTypePaste;
1548 bool DefaultShowDialog;
1549 bool TransBin;
1550 bool DoSameProcess;
1551 enum drop_type DropType;
1552 unsigned char DropTypePaste;
1553
1554 HWND vtwin;
1555 UINT_PTR PollingTimerID;
1556
1557 int FileCount;
1558 int DirectoryCount;
1559 int SendIndex;
1560 } DropData_t;
1561
1562 /**
1563 * ������
1564 */
1565 void CVTWindow::DropInit()
1566 {
1567 DropData_t *data =(DropData_t *)calloc(sizeof(*data), 1);
1568 data->DefaultDropType = DROP_TYPE_CANCEL;
1569 data->DefaultDropTypePaste = DROP_TYPE_PASTE_ESCAPE;
1570 data->DefaultShowDialog = ts.ConfirmFileDragAndDrop ? true : false;
1571 data->vtwin = HVTWin;
1572
1573 DropData = data;
1574 }
1575
1576 void CVTWindow::DropUninit()
1577 {
1578 free(DropData);
1579 DropData = NULL;
1580 }
1581
1582 /**
1583 * ���M�����R�[���o�b�N
1584 */
1585 static void DropSendCallback(void *callback_data)
1586 {
1587 DropData_t *data = (DropData_t *)callback_data;
1588 // �������M���s��
1589 ::PostMessage(data->vtwin, WM_USER_DROPNOTIFY, 0, 1);
1590 }
1591
1592 /**
1593 * �^�C�}�[��SCP�����M�������`�F�b�N
1594 */
1595 static void CALLBACK DropSendTimerProc(HWND, UINT, UINT_PTR nIDEvent, DWORD)
1596 {
1597 DropData_t *data = (DropData_t *)nIDEvent;
1598
1599 // ���M��?
1600 if (ScpGetStatus() == TRUE) {
1601 // �����^�C�}�[�C���^�[�o�������x�`�F�b�N
1602 return;
1603 }
1604
1605 assert(data->PollingTimerID != 0);
1606 BOOL r = KillTimer(HVTWin, data->PollingTimerID);
1607 assert(r == 1); (void)r;
1608 data->PollingTimerID = 0;
1609
1610 // �������M���s��
1611 ::PostMessage(data->vtwin, WM_USER_DROPNOTIFY, 0, 1);
1612 }
1613
1614 /**
1615 * �t�@�C�����h���b�v���m
1616 * @param lparam 0 �t�@�C�����h���b�v������
1617 * ShowDialog���Q��������
1618 * 1 �t�@�C�����]������������
1619 * @param ShowDialog 0 �\���������\����������������
1620 * 1 �K���\������
1621 */
1622 LRESULT CVTWindow::OnDropNotify(WPARAM ShowDialog, LPARAM lparam)
1623 {
1624 DropData_t *data = DropData;
1625
1626 switch (lparam) {
1627 case 0: {
1628 data->FileCount = 0;
1629 data->DirectoryCount = 0;
1630 for (int i = 0; i < DropListCount; i++) {
1631 const wchar_t *FileName = DropLists[i];
1632 const DWORD attr = GetFileAttributesW(FileName);
1633 if (attr == INVALID_FILE_ATTRIBUTES) {
1634 data->FileCount++;
1635 } else if (attr & FILE_ATTRIBUTE_DIRECTORY) {
1636 data->DirectoryCount++;
1637 } else {
1638 data->FileCount++;
1639 }
1640 }
1641
1642 data->DoSameProcess = false;
1643 const bool isSSH = (cv.isSSH == 2);
1644 data->DropTypePaste = DROP_TYPE_PASTE_ESCAPE;
1645 if (data->DefaultDropType == DROP_TYPE_CANCEL) {
1646 // default is not set
1647 data->TransBin = ts.TransBin == 0 ? false : true;
1648 if (!ShowDialog) {
1649 if (data->FileCount == 1 && data->DirectoryCount == 0) {
1650 if (ts.ConfirmFileDragAndDrop) {
1651 if (isSSH) {
1652 data->DropType = DROP_TYPE_SCP;
1653 } else {
1654 data->DropType = DROP_TYPE_SEND_FILE;
1655 }
1656 data->DoSameProcess = false;
1657 } else {
1658 data->DropType = DROP_TYPE_SEND_FILE;
1659 data->DoSameProcess = data->DefaultShowDialog ? false : true;
1660 }
1661 }
1662 else if (data->FileCount == 0 && data->DirectoryCount == 1) {
1663 data->DropType = DROP_TYPE_PASTE_FILENAME;
1664 data->DoSameProcess = data->DefaultShowDialog ? false : true;
1665 }
1666 else if (data->FileCount > 0 && data->DirectoryCount > 0) {
1667 data->DropType = DROP_TYPE_PASTE_FILENAME;
1668 data->DoSameProcess = false;
1669 }
1670 else if (data->FileCount > 0 && data->DirectoryCount == 0) {
1671 // filename only
1672 if (isSSH) {
1673 data->DropType = DROP_TYPE_SCP;
1674 } else {
1675 data->DropType = DROP_TYPE_SEND_FILE;
1676 }
1677 data->DoSameProcess = false;
1678 } else {
1679 // directory only
1680 data->DropType = DROP_TYPE_PASTE_FILENAME;
1681 data->DoSameProcess = ts.ConfirmFileDragAndDrop ? false : true;
1682 }
1683 } else {
1684 // show dialog
1685 if (data->DirectoryCount > 0) {
1686 data->DropType = DROP_TYPE_PASTE_FILENAME;
1687 } else {
1688 if (isSSH) {
1689 data->DropType = DROP_TYPE_SCP;
1690 } else {
1691 data->DropType = DROP_TYPE_SEND_FILE;
1692 }
1693 }
1694 data->DoSameProcess = false;
1695 }
1696 } else {
1697 if (data->DirectoryCount > 0 &&
1698 (data->DefaultDropType == DROP_TYPE_SEND_FILE ||
1699 data->DefaultDropType == DROP_TYPE_SCP))
1700 { // �f�t�H���g�����������������������g��������
1701 data->DropType = DROP_TYPE_PASTE_FILENAME;
1702 data->DropTypePaste = data->DefaultDropTypePaste;
1703 data->DoSameProcess = false;
1704 } else {
1705 data->DropType = data->DefaultDropType;
1706 data->DropTypePaste = data->DefaultDropTypePaste;
1707 data->DoSameProcess = (ShowDialog || data->DefaultShowDialog) ? false : true;
1708 }
1709 }
1710
1711 data->SendIndex = 0;
1712 // break;
1713 // FALLTHROUGH
1714 }
1715 case 1:
1716 next_file: {
1717 if (data->SendIndex == DropListCount) {
1718 // ���������M����
1719 goto finish;
1720 }
1721 int i = data->SendIndex;
1722 data->SendIndex++;
1723 const wchar_t *FileName = DropLists[i];
1724
1725 if (!data->DoSameProcess) {
1726 const bool isSSH = (cv.isSSH == 2);
1727 bool DoSameProcessNextDrop;
1728 bool DoNotShowDialog = !data->DefaultShowDialog;
1729 SetDialogFont(ts.DialogFontNameW, ts.DialogFontPoint, ts.DialogFontCharSet,
1730 ts.UILanguageFileW, "Tera Term", "DLG_SYSTEM_FONT");
1731 data->DropType =
1732 ShowDropDialogBox(m_hInst, HVTWin, FileName, data->DropType,
1733 DropListCount - i,
1734 (data->DirectoryCount == 0 && isSSH) ? true : false, data->DirectoryCount == 0 ? true : false,
1735 &data->TransBin,
1736 &ts,
1737 &data->DropTypePaste, &data->DoSameProcess,
1738 &DoSameProcessNextDrop,
1739 &DoNotShowDialog);
1740 if (data->DropType == DROP_TYPE_CANCEL) {
1741 goto finish;
1742 }
1743 if (DoSameProcessNextDrop) {
1744 data->DefaultDropType = data->DropType;
1745 }
1746 if (!ts.ConfirmFileDragAndDrop) {
1747 data->DefaultShowDialog = !DoNotShowDialog;
1748 }
1749 }
1750
1751 switch (data->DropType) {
1752 case DROP_TYPE_CANCEL:
1753 default:
1754 // cancel
1755 break;
1756 case DROP_TYPE_SEND_FILE: {
1757 if (!data->TransBin) {
1758 SendMemSendFile2(FileName, FALSE, SENDMEM_DELAYTYPE_NO_DELAY, 0, 0, DropSendCallback, data);
1759 }
1760 else {
1761 SendMemSendFile2(FileName, TRUE, SENDMEM_DELAYTYPE_NO_DELAY, 0, 0, DropSendCallback, data);
1762 }
1763 break;
1764 }
1765 case DROP_TYPE_PASTE_FILENAME:
1766 {
1767 const bool escape = (data->DropTypePaste & DROP_TYPE_PASTE_ESCAPE) ? true : false;
1768
1769 data->DefaultDropTypePaste = data->DropTypePaste;
1770
1771 TermSendStartBracket();
1772
1773 wchar_t *str = GetPasteString(FileName, escape);
1774 TermPasteStringNoBracket(str, wcslen(str));
1775 free(str);
1776 if (DropListCount > 1 && i < DropListCount - 1) {
1777 if (data->DropTypePaste & DROP_TYPE_PASTE_NEWLINE) {
1778 TermPasteStringNoBracket(L"\x0d", 1); // ���s(CR,0x0d)
1779 }
1780 else {
1781 TermPasteStringNoBracket(L" ", 1); // space
1782 }
1783 }
1784
1785 TermSendEndBracket();
1786
1787 // �����t�@�C����������
1788 goto next_file;
1789 }
1790 case DROP_TYPE_SCP:
1791 {
1792 // send by scp
1793 const wchar_t *FileName = DropLists[i];
1794 wchar_t *SendDirW = ToWcharA(ts.ScpSendDir);
1795 BOOL r = ScpSend(FileName, SendDirW);
1796 free(SendDirW);
1797 if (!r) {
1798 // ���M�G���[
1799 ::MessageBoxA(HVTWin, "scp send error", "Tera Term: error", MB_OK | MB_ICONERROR);
1800 goto finish;
1801 }
1802
1803 data->PollingTimerID = SetTimer(HVTWin, (UINT_PTR)data, 100, DropSendTimerProc);
1804 break;
1805
1806 }
1807 }
1808 break;
1809 }
1810 case 2:
1811 default:
1812 finish:
1813 // �I������
1814 DropListFree();
1815 break;
1816 }
1817
1818 return 0;
1819 }
1820
1821 void CVTWindow::OnDropFiles(HDROP hDropInfo)
1822 {
1823 ::SetForegroundWindow(HVTWin);
1824 if (cv.Ready && IsSendVarNULL())
1825 {
1826 const UINT ShowDialog =
1827 ((GetAsyncKeyState(VK_CONTROL) & 0x8000) != 0) ? 1 : 0;
1828 DropListCount = DragQueryFileW(hDropInfo, -1, NULL, 0);
1829 DropLists = (wchar_t **)malloc(sizeof(wchar_t *) * DropListCount);
1830
1831 for (int i = 0; i < DropListCount; i++) {
1832 const UINT cch = DragQueryFileW(hDropInfo, i, NULL, 0);
1833 if (cch == 0) {
1834 continue;
1835 }
1836 wchar_t *FileName = (wchar_t *)malloc(sizeof(wchar_t) * (cch + 1));
1837 DragQueryFileW(hDropInfo,i,FileName,cch + 1);
1838 FileName[cch] = '\0';
1839 DropLists[i] = FileName;
1840 }
1841
1842 ::PostMessage(HVTWin, WM_USER_DROPNOTIFY, ShowDialog, 0);
1843 }
1844 DragFinish(hDropInfo);
1845 }
1846
1847 void CVTWindow::OnGetMinMaxInfo(MINMAXINFO *lpMMI)
1848 {
1849 #ifndef WINDOW_MAXMIMUM_ENABLED
1850 lpMMI->ptMaxSize.x = 10000;
1851 lpMMI->ptMaxSize.y = 10000;
1852 lpMMI->ptMaxTrackSize.x = 10000;
1853 lpMMI->ptMaxTrackSize.y = 10000;
1854 #endif
1855 }
1856
1857 void CVTWindow::OnHScroll(UINT nSBCode, UINT nPos, HWND pScrollBar)
1858 {
1859 int Func;
1860
1861 switch (nSBCode) {
1862 case SB_BOTTOM:
1863 Func = SCROLL_BOTTOM;
1864 break;
1865 case SB_ENDSCROLL:
1866 return;
1867 case SB_LINEDOWN:
1868 Func = SCROLL_LINEDOWN;
1869 break;
1870 case SB_LINEUP:
1871 Func = SCROLL_LINEUP;
1872 break;
1873 case SB_PAGEDOWN:
1874 Func = SCROLL_PAGEDOWN;
1875 break;
1876 case SB_PAGEUP:
1877 Func = SCROLL_PAGEUP;
1878 break;
1879 case SB_THUMBPOSITION:
1880 case SB_THUMBTRACK:
1881 Func = SCROLL_POS;
1882 break;
1883 case SB_TOP:
1884 Func = SCROLL_TOP;
1885 break;
1886 default:
1887 return;
1888 }
1889 DispHScroll(Func,nPos);
1890 }
1891
1892 void CVTWindow::OnInitMenuPopup(HMENU hPopupMenu, UINT nIndex, BOOL bSysMenu)
1893 {
1894 InitMenuPopup(hPopupMenu);
1895 }
1896
1897 void CVTWindow::OnKeyDown(WPARAM nChar, UINT nRepCnt, UINT nFlags)
1898 {
1899 #if UNICODE_DEBUG
1900 if (UnicodeDebugParam.CodePopupEnable)
1901 {
1902 const DWORD now = GetTickCount();
1903 switch(CtrlKeyState) {
1904 case 0:
1905 if (nChar == UnicodeDebugParam.CodePopupKey1) {
1906 CtrlKeyDownTick = now;
1907 CtrlKeyState = 1;
1908 }
1909 break;
1910 case 2:
1911 if (nChar != UnicodeDebugParam.CodePopupKey2) {
1912 CtrlKeyState = 0;
1913 break;
1914 }
1915 if (now - CtrlKeyDownTick < 500 && TipWinCodeDebug == NULL) {
1916 POINT pos;
1917 GetCursorPos(&pos);
1918 ScreenToClient(m_hWnd, &pos);
1919 CodePopup(pos.x, pos.y);
1920 CtrlKeyState = 3;
1921 } else {
1922 CtrlKeyDownTick = now;
1923 CtrlKeyState = 1;
1924 }
1925 break;
1926 case 3:
1927 break;
1928 default:
1929 CtrlKeyState = 0;
1930 break;
1931 }
1932 }
1933 if (TipWinCodeDebug != NULL && nChar == VK_SHIFT) {
1934 POINT pos;
1935 GetCursorPos(&pos);
1936 ScreenToClient(m_hWnd, &pos);
1937 wchar_t *buf = BuffGetCharInfo(pos.x, pos.y);
1938 CBSetTextW(HVTWin, buf, 0);
1939 free(buf);
1940 MessageBeep(MB_OK);
1941 TipWinDestroy(TipWinCodeDebug);
1942 TipWinCodeDebug = NULL;
1943 CtrlKeyState = 0;
1944 }
1945 #endif
1946 switch (KeyDown(HVTWin,nChar,nRepCnt,nFlags & 0x1ff)) {
1947 case KEYDOWN_OTHER:
1948 break;
1949 case KEYDOWN_CONTROL:
1950 return;
1951 case KEYDOWN_COMMOUT:
1952 // �X�N���[�����u�����Z�b�g
1953 if (WinOrgY != 0) {
1954 DispVScroll(SCROLL_BOTTOM, 0);
1955 }
1956 return;
1957 }
1958
1959 if (MetaKey(ts.MetaKey) && (nFlags & 0x2000) != 0)
1960 {
1961 BYTE KeyState[256];
1962 MSG M;
1963
1964 PeekMessage((LPMSG)&M,HVTWin,WM_CHAR,WM_CHAR,PM_REMOVE);
1965 /* for Ctrl+Alt+Key combination */
1966 GetKeyboardState(KeyState);
1967 KeyState[VK_MENU] = 0;
1968 SetKeyboardState(KeyState);
1969 M.hwnd = HVTWin;
1970 M.message = WM_KEYDOWN;
1971 M.wParam = nChar;
1972 M.lParam = MAKELONG(nRepCnt,nFlags & 0xdfff);
1973 TranslateMessage(&M);
1974 }
1975
1976 }
1977
1978 void CVTWindow::OnKeyUp(WPARAM nChar, UINT nRepCnt, UINT nFlags)
1979 {
1980 KeyUp(nChar);
1981 #if UNICODE_DEBUG
1982 if (CtrlKeyState == 1 && nChar == UnicodeDebugParam.CodePopupKey1) {
1983 CtrlKeyState++;
1984 } else {
1985 CtrlKeyState = 0;
1986 }
1987 if (nChar == UnicodeDebugParam.CodePopupKey2) {
1988 if (TipWinCodeDebug != NULL) {
1989 TipWinDestroy(TipWinCodeDebug);
1990 TipWinCodeDebug = NULL;
1991 CtrlKeyState = 0;
1992 }
1993 }
1994 #endif
1995 }
1996
1997 void CVTWindow::OnKillFocus(HWND hNewWnd)
1998 {
1999 DispDestroyCaret();
2000 FocusReport(FALSE);
2001 // TTCFrameWnd::OnKillFocus(hNewWnd); // TODO
2002
2003 if (IsCaretOn()) {
2004 CaretKillFocus(TRUE);
2005 }
2006 }
2007
2008 void CVTWindow::OnLButtonDblClk(WPARAM nFlags, POINTS point)
2009 {
2010 if (LButton || MButton || RButton) {
2011 return;
2012 }
2013
2014 DblClkX = point.x;
2015 DblClkY = point.y;
2016
2017 if (MouseReport(IdMouseEventBtnDown, IdLeftButton, DblClkX, DblClkY)) {
2018 return;
2019 }
2020
2021 if (BuffUrlDblClk(DblClkX, DblClkY)) { // �u���E�U�����o���������������������B (2005.4.3 yutaka)
2022 return;
2023 }
2024
2025 BuffDblClk(DblClkX, DblClkY);
2026
2027 LButton = TRUE;
2028 DblClk = TRUE;
2029 AfterDblClk = TRUE;
2030 ::SetTimer(HVTWin, IdDblClkTimer, GetDoubleClickTime(), NULL);
2031
2032 /* for AutoScrolling */
2033 ::SetCapture(HVTWin);
2034 ::SetTimer(HVTWin, IdScrollTimer, 100, NULL);
2035 }
2036
2037 void CVTWindow::OnLButtonDown(WPARAM nFlags, POINTS point)
2038 {
2039 POINT p;
2040
2041 p.x = point.x;
2042 p.y = point.y;
2043 ButtonDown(p,IdLeftButton);
2044 }
2045
2046 void CVTWindow::OnLButtonUp(WPARAM nFlags, POINTS point)
2047 {
2048 if (IgnoreRelease)
2049 IgnoreRelease = FALSE;
2050 else if (MouseReport(IdMouseEventBtnUp, IdLeftButton, point.x, point.y)) {
2051 ReleaseCapture();
2052 }
2053
2054 if (! LButton) {
2055 return;
2056 }
2057
2058 ButtonUp(FALSE);
2059 }
2060
2061 void CVTWindow::OnMButtonDown(WPARAM nFlags, POINTS point)
2062 {
2063 POINT p;
2064
2065 p.x = point.x;
2066 p.y = point.y;
2067 ButtonDown(p,IdMiddleButton);
2068 }
2069
2070 void CVTWindow::OnMButtonUp(WPARAM nFlags, POINTS point)
2071 {
2072 if (IgnoreRelease)
2073 IgnoreRelease = FALSE;
2074 else if (MouseReport(IdMouseEventBtnUp, IdMiddleButton, point.x, point.y)) {
2075 ReleaseCapture();
2076 }
2077
2078 if (! MButton) {
2079 return;
2080 }
2081
2082 // added DisablePasteMouseMButton (2008.3.2 maya)
2083 if (ts.PasteFlag & CPF_DISABLE_MBUTTON) {
2084 ButtonUp(FALSE);
2085 }
2086 else {
2087 ButtonUp(TRUE);
2088 }
2089 }
2090
2091 LRESULT CVTWindow::OnMouseActivate(HWND pDesktopWnd, UINT nHitTest, UINT message)
2092 {
2093 if ((ts.SelOnActive==0) && (nHitTest==HTCLIENT)) { //disable mouse event for text selection
2094 IgnoreRelease = TRUE;
2095 return MA_ACTIVATEANDEAT; // when window is activated
2096 }
2097 else {
2098 return MA_ACTIVATE;
2099 }
2100 }
2101
2102
2103 void CVTWindow::CodePopup(int client_x, int client_y)
2104 {
2105 wchar_t *buf = BuffGetCharInfo(client_x, client_y);
2106 if (TipWinCodeDebug == NULL) {
2107 TipWinCodeDebug = TipWinCreate(m_hInst, m_hWnd);
2108 }
2109 POINT pos = { client_x, client_y };
2110 ClientToScreen(m_hWnd, &pos);
2111 TipWinSetPos(TipWinCodeDebug, pos.x, pos.y);
2112 TipWinSetTextW(TipWinCodeDebug, buf);
2113 TipWinSetVisible(TipWinCodeDebug, TRUE);
2114 free(buf);
2115 }
2116
2117 void CVTWindow::OnMouseMove(WPARAM nFlags, POINTS point)
2118 {
2119 int i;
2120 BOOL mousereport = FALSE;
2121
2122 #if UNICODE_DEBUG
2123 if (TipWinCodeDebug != NULL) {
2124 CodePopup(point.x, point.y);
2125 }
2126 #endif
2127
2128 if (!IgnoreRelease)
2129 mousereport = MouseReport(IdMouseEventMove, 0, point.x, point.y);
2130
2131 if (! (LButton || MButton || RButton)) {
2132 if (BuffCheckMouseOnURL(point.x, point.y))
2133 SetMouseCursor("HAND");
2134 else
2135 SetMouseCursor(ts.MouseCursorName);
2136 return;
2137 }
2138
2139 if (mousereport) {
2140 return;
2141 }
2142
2143 if (DblClk) {
2144 i = 2;
2145 }
2146 else if (TplClk) {
2147 i = 3;
2148 }
2149 else {
2150 i = 1;
2151 }
2152
2153 if (!ts.SelectOnlyByLButton ||
2154 (ts.SelectOnlyByLButton && LButton) ) {
2155 // SelectOnlyByLButton == TRUE ���������A���{�^���_�E���������I������ (2007.11.21 maya)
2156 BuffChangeSelect(point.x, point.y,i);
2157 }
2158 }
2159
2160 void CVTWindow::OnMove(int x, int y)
2161 {
2162 // �E�B���h�E���u������
2163 // �� x,y ���N���C�A���g���������������W
2164 RECT R;
2165 ::GetWindowRect(HVTWin,&R);
2166 ts.VTPos.x = R.left;
2167 ts.VTPos.y = R.top;
2168
2169 DispSetWinPos();
2170 }
2171
2172 // �}�E�X�z�C�[�������]
2173 BOOL CVTWindow::OnMouseWheel(
2174 UINT nFlags, // ���z�L�[
2175 short zDelta, // ���]����
2176 POINTS pts // �J�[�\�����u
2177 )
2178 {
2179 POINT pt;
2180 pt.x = pts.x;
2181 pt.y = pts.y;
2182
2183 int line, i;
2184
2185 if (pSetLayeredWindowAttributes != NULL) {
2186 BOOL InTitleBar;
2187 POINT point = pt;
2188 GetPositionOnWindow(HVTWin, &point,
2189 NULL, NULL, &InTitleBar);
2190 if (InTitleBar) {
2191 int delta = zDelta < 0 ? -1 : 1;
2192 int newAlpha = Alpha;
2193 POINT tippos;
2194
2195 newAlpha += delta * ts.MouseWheelScrollLine;
2196 if (newAlpha > 255)
2197 newAlpha = 255;
2198 else if (newAlpha < 0)
2199 newAlpha = 0;
2200 SetWindowAlpha(newAlpha);
2201
2202 wchar_t *uimsg;
2203 GetI18nStrWA("Tera Term", "TOOLTIP_TITLEBAR_OPACITY", L"Opacity %.1f %%", ts.UILanguageFile, &uimsg);
2204 wchar_t *tipbuf;
2205 aswprintf(&tipbuf, uimsg, (newAlpha / 255.0) * 100);
2206 free(uimsg);
2207
2208 tippos = TipWin->GetPos();
2209 if (tippos.x != pt.x ||
2210 tippos.y != pt.y) {
2211 TipWin->SetVisible(FALSE);
2212 }
2213
2214 TipWin->SetText(tipbuf);
2215 TipWin->SetPos(pt.x, pt.y);
2216 TipWin->SetHideTimer(1000);
2217
2218 if(! TipWin->IsVisible()) {
2219 TipWin->SetVisible(TRUE);
2220 }
2221
2222 free(tipbuf);
2223
2224 return TRUE;
2225 }
2226 }
2227
2228 ::ScreenToClient(HVTWin, &pt);
2229
2230 line = abs(zDelta) / WHEEL_DELTA; // ���C����
2231 if (line < 1) line = 1;
2232
2233 // ���X�N���[�����������s������������ (2008.4.6 yutaka)
2234 if (line == 1 && ts.MouseWheelScrollLine > 0)
2235 line *= ts.MouseWheelScrollLine;
2236
2237 if (MouseReport(IdMouseEventWheel, zDelta<0, pt.x, pt.y))
2238 return TRUE;
2239
2240 if (WheelToCursorMode()) {
2241 if (zDelta < 0) {
2242 KeyDown(HVTWin, VK_DOWN, line, MapVirtualKey(VK_DOWN, 0) | 0x100);
2243 KeyUp(VK_DOWN);
2244 } else {
2245 KeyDown(HVTWin, VK_UP, line, MapVirtualKey(VK_UP, 0) | 0x100);
2246 KeyUp(VK_UP);
2247 }
2248 } else {
2249 for (i = 0 ; i < line ; i++) {
2250 if (zDelta < 0) {
2251 OnVScroll(SB_LINEDOWN, 0, NULL);
2252 } else {
2253 OnVScroll(SB_LINEUP, 0, NULL);
2254 }
2255 }
2256 }
2257
2258 return (TRUE);
2259 }
2260
2261 void CVTWindow::OnNcLButtonDblClk(UINT nHitTest, POINTS point)
2262 {
2263 if (! Minimized && !ts.TermIsWin && (nHitTest == HTCAPTION)) {
2264 DispRestoreWinSize();
2265 }
2266 }
2267
2268 void CVTWindow::OnNcRButtonDown(UINT nHitTest, POINTS point)
2269 {
2270 if ((nHitTest==HTCAPTION) &&
2271 (ts.HideTitle>0) &&
2272 AltKey()) {
2273 ::CloseWindow(HVTWin); /* iconize */
2274 }
2275 }
2276
2277 void CVTWindow::OnPaint()
2278 {
2279 PAINTSTRUCT ps;
2280 HDC PaintDC;
2281 int Xs, Ys, Xe, Ye;
2282
2283 // �\������������������WM_PAINT�����������P�[�X����
2284 if (::IsWindowVisible(m_hWnd) == 0) {
2285 return;
2286 }
2287
2288 BGSetupPrimary(FALSE);
2289
2290 PaintDC = BeginPaint(&ps);
2291
2292 PaintWindow(PaintDC,ps.rcPaint,ps.fErase, &Xs,&Ys,&Xe,&Ye);
2293 LockBuffer();
2294 BuffUpdateRect(Xs,Ys,Xe,Ye);
2295 UnlockBuffer();
2296 DispEndPaint();
2297
2298 EndPaint(&ps);
2299
2300 if (FirstPaint) {
2301 if (strlen(TopicName)>0) {
2302 InitDDE();
2303 SendDDEReady();
2304 }
2305 FirstPaint = FALSE;
2306 Startup();
2307 }
2308 }
2309
2310 void CVTWindow::OnRButtonDown(UINT nFlags, POINTS point)
2311 {
2312 POINT p;
2313
2314 p.x = point.x;
2315 p.y = point.y;
2316 ButtonDown(p,IdRightButton);
2317 }
2318
2319 void CVTWindow::OnRButtonUp(UINT nFlags, POINTS point)
2320 {
2321 if (IgnoreRelease)
2322 IgnoreRelease = FALSE;
2323 else if (MouseReport(IdMouseEventBtnUp, IdRightButton, point.x, point.y)) {
2324 ReleaseCapture();
2325 }
2326
2327 if (! RButton) {
2328 return;
2329 }
2330
2331 /*
2332 * �y�[�X�g����:
2333 * �Ets.PasteFlag & CPF_DISABLE_RBUTTON -> �E�{�^���������y�[�X�g����
2334 * �Ets.PasteFlag & CPF_CONFIRM_RBUTTON -> �\�����������j���[�����y�[�X�g���s�������A
2335 * �E�{�^���A�b�v�������y�[�X�g���s������
2336 */
2337 if ((ts.PasteFlag & CPF_DISABLE_RBUTTON) || (ts.PasteFlag & CPF_CONFIRM_RBUTTON)) {
2338 ButtonUp(FALSE);
2339 } else {
2340 ButtonUp(TRUE);
2341 }
2342 }
2343
2344 void CVTWindow::OnSetFocus(HWND hOldWnd)
2345 {
2346 ChangeCaret();
2347 FocusReport(TRUE);
2348 }
2349
2350 void CVTWindow::OnSize(WPARAM nType, int cx, int cy)
2351 {
2352 if (IgnoreSizeMessage) {
2353 return;
2354 }
2355 RECT R;
2356 int w, h;
2357
2358 Minimized = (nType==SIZE_MINIMIZED);
2359
2360 if (FirstPaint && Minimized)
2361 {
2362 if (strlen(TopicName)>0)
2363 {
2364 InitDDE();
2365 SendDDEReady();
2366 }
2367 FirstPaint = FALSE;
2368 Startup();
2369 return;
2370 }
2371 if (Minimized || DontChangeSize) {
2372 return;
2373 }
2374
2375 if (nType == SIZE_MAXIMIZED) {
2376 ts.TerminalOldWidth = ts.TerminalWidth;
2377 ts.TerminalOldHeight = ts.TerminalHeight;
2378 }
2379
2380 ::GetWindowRect(HVTWin,&R);
2381 w = R.right - R.left;
2382 h = R.bottom - R.top;
2383 if (AdjustSize) {
2384 ResizeWindow(R.left,R.top,w,h,cx,cy);
2385 }
2386 else {
2387 if (ts.FontScaling) {
2388 int NewFontWidth, NewFontHeight;
2389 BOOL FontChanged = FALSE;
2390
2391 NewFontWidth = cx / ts.TerminalWidth;
2392 NewFontHeight = cy / ts.TerminalHeight;
2393
2394 if (NewFontWidth - ts.FontDW < 3) {
2395 NewFontWidth = ts.FontDW + 3;
2396 }
2397 if (NewFontWidth != FontWidth) {
2398 ts.VTFontSize.x = ts.FontDW - NewFontWidth;
2399 FontWidth = NewFontWidth;
2400 FontChanged = TRUE;
2401 }
2402
2403 if (NewFontHeight - ts.FontDH < 3) {
2404 NewFontHeight = ts.FontDH + 3;
2405 }
2406 if (NewFontHeight != FontHeight) {
2407 ts.VTFontSize.y = ts.FontDH - NewFontHeight;
2408 FontHeight = NewFontHeight;
2409 FontChanged = TRUE;
2410 }
2411
2412 w = ts.TerminalWidth;
2413 h = ts.TerminalHeight;
2414
2415 if (FontChanged) {
2416 ChangeFont();
2417 }
2418 }
2419 else {
2420 w = cx / FontWidth;
2421 h = cy / FontHeight;
2422 }
2423
2424 HideStatusLine();
2425 BuffChangeWinSize(w,h);
2426 }
2427
2428 #ifdef WINDOW_MAXMIMUM_ENABLED
2429 if (nType == SIZE_MAXIMIZED) {
2430 AdjustSize = 0;
2431 }
2432 #endif
2433 }
2434
2435 // ���T�C�Y���������������A�������������s���B
2436 // �E�c�[���`�b�v���V�����[���T�C�Y���\������
2437 // �E�t�H���g�T�C�Y���[���T�C�Y�����������A�E�B���h�E���u�E�T�C�Y����������
2438 void CVTWindow::OnSizing(WPARAM fwSide, LPRECT pRect)
2439 {
2440 int nWidth;
2441 int nHeight;
2442 RECT cr, wr;
2443 int margin_width, margin_height;
2444 int w, h;
2445 int fixed_width, fixed_height;
2446
2447 ::GetWindowRect(HVTWin, &wr);
2448 ::GetClientRect(HVTWin, &cr);
2449
2450 margin_width = wr.right - wr.left - cr.right + cr.left;
2451 margin_height = wr.bottom - wr.top - cr.bottom + cr.top;
2452 nWidth = (pRect->right) - (pRect->left) - margin_width;
2453 nHeight = (pRect->bottom) - (pRect->top) - margin_height;
2454
2455 w = nWidth / FontWidth;
2456 h = nHeight / FontHeight;
2457
2458 if (!ts.TermIsWin) {
2459 // TermIsWin=off ���������T�C�Y�����[���T�C�Y����������������
2460 // �������[���T�C�Y�������������B
2461 if (w > ts.TerminalWidth)
2462 w = ts.TerminalWidth;
2463 if (h > ts.TerminalHeight)
2464 h = ts.TerminalHeight;
2465 }
2466
2467 // �������� 1x1 ���[���T�C�Y�����������B
2468 if (w <= 0)
2469 w = 1;
2470 if (h <= 0)
2471 h = 1;
2472
2473 UpdateSizeTip(HVTWin, w, h, fwSide, pRect->left, pRect->top);
2474
2475 fixed_width = w * FontWidth + margin_width;
2476 fixed_height = h * FontHeight + margin_height;
2477
2478 switch (fwSide) { // ������
2479 case 1: // ��
2480 case 4: // ����
2481 case 7: // ����
2482 pRect->left = pRect->right - fixed_width;
2483 break;
2484 case 2: // �E
2485 case 5: // �E��
2486 case 8: // �E��
2487 pRect->right = pRect->left + fixed_width;
2488 break;
2489 }
2490
2491 switch (fwSide) { // ��������
2492 case 3: // ��
2493 case 4: // ����
2494 case 5: // �E��
2495 pRect->top = pRect->bottom - fixed_height;
2496 break;
2497 case 6: // ��
2498 case 7: // ����
2499 case 8: // �E��
2500 pRect->bottom = pRect->top + fixed_height;
2501 break;
2502 }
2503 }
2504
2505 void CVTWindow::OnSysChar(WPARAM nChar, UINT nRepCnt, UINT nFlags)
2506 {
2507 #ifdef WINDOW_MAXMIMUM_ENABLED
2508 // ALT + x������������ WM_SYSCHAR �������������B
2509 // ALT + Enter���E�B���h�E�������� (2005.4.24 yutaka)
2510 if ((nFlags&0x2000) != 0 && nChar == CR) {
2511 if (::IsZoomed(m_hWnd)) { // window is maximum
2512 ShowWindow(SW_RESTORE);
2513 } else {
2514 ShowWindow(SW_MAXIMIZE);
2515 }
2516 }
2517 #endif
2518
2519 if (MetaKey(ts.MetaKey)) {
2520 if (!KeybEnabled || (TalkStatus != IdTalkKeyb))
2521 return;
2522
2523 char Code = nChar;
2524 wchar_t u16;
2525 switch (ts.Meta8Bit) {
2526 case IdMeta8BitRaw:
2527 Code = nChar;
2528 break;
2529 default:
2530 if (IsWindowUnicode(HVTWin) == TRUE) {
2531 u16 = nChar;
2532 }
2533 else {
2534 if (ts.Meta8Bit != IdMeta8BitRaw) {
2535 const char mb_str[2] = {(char)nChar, 0};
2536 unsigned int u32;
2537 size_t mb_len = MBCPToUTF32(mb_str, 1, CP_ACP, &u32);
2538 if (mb_len == 0) {
2539 return;
2540 }
2541 u16 = (wchar_t)u32;
2542 }
2543 }
2544 }
2545 for (unsigned int i = 1; i <= nRepCnt; i++) {
2546 switch (ts.Meta8Bit) {
2547 case IdMeta8BitRaw:
2548 Code |= 0x80;
2549 CommBinaryBuffOut(&cv, &Code, 1);
2550 if (ts.LocalEcho) {
2551 CommBinaryEcho(&cv, &Code, 1);
2552 }
2553 break;
2554 case IdMeta8BitText:
2555 u16 |= 0x80;
2556 CommTextOutW(&cv, &u16, 1);
2557 if (ts.LocalEcho) {
2558 CommTextEchoW(&cv, &u16, 1);
2559 }
2560 break;
2561 default: {
2562 const wchar_t e = ESC;
2563 CommTextOutW(&cv, &e, 1);
2564 CommTextOutW(&cv, &u16, 1);
2565 if (ts.LocalEcho) {
2566 CommTextEchoW(&cv, &e, 1);
2567 CommTextEchoW(&cv, &u16, 1);
2568 }
2569 }
2570 }
2571 }
2572 return;
2573 }
2574
2575 TTCFrameWnd::DefWindowProc(WM_SYSCHAR, nChar, MAKELONG(nRepCnt, nFlags));
2576 }
2577
2578 void CVTWindow::OnSysCommand(WPARAM nID, LPARAM lParam)
2579 {
2580 if (nID==ID_SHOWMENUBAR) {
2581 ts.PopupMenu = 0;
2582 SwitchMenu();
2583 }
2584 else if (((nID & 0xfff0)==SC_CLOSE) && (cv.PortType==IdTCPIP) &&
2585 cv.Open && ! cv.Ready && (cv.ComPort>0)) {
2586 // now getting host address (see CommOpen() in commlib.c)
2587 ::PostMessage(HVTWin,WM_SYSCOMMAND,nID,lParam);
2588 }
2589 #if 0
2590 else {
2591 TTCFrameWnd::OnSysCommand(nID,lParam);
2592 }
2593 #endif
2594 }
2595
2596 void CVTWindow::OnSysKeyDown(WPARAM nChar, UINT nRepCnt, UINT nFlags)
2597 {
2598 if ((nChar==VK_F10) || (MetaKey(ts.MetaKey) && ((MainMenu==NULL) || (nChar!=VK_MENU)))) {
2599 KeyDown(HVTWin,nChar,nRepCnt,nFlags & 0x1ff);
2600 // OnKeyDown(nChar,nRepCnt,nFlags);
2601 }
2602 else {
2603 TTCFrameWnd::OnSysKeyDown(nChar,nRepCnt,nFlags);
2604 }
2605 }
2606
2607 void CVTWindow::OnSysKeyUp(WPARAM nChar, UINT nRepCnt, UINT nFlags)
2608 {
2609 if (nChar==VK_F10) {
2610 OnKeyUp(nChar,nRepCnt,nFlags);
2611 }
2612 else {
2613 TTCFrameWnd::OnSysKeyUp(nChar,nRepCnt,nFlags);
2614 }
2615 }
2616
2617 void CVTWindow::OnTimer(UINT_PTR nIDEvent)
2618 {
2619 POINT Point;
2620 WORD PortType;
2621 UINT T;
2622
2623 if (nIDEvent==IdCaretTimer) {
2624 if (ts.NonblinkingCursor!=0) {
2625 T = GetCaretBlinkTime();
2626 SetCaretBlinkTime(T);
2627 }
2628 else {
2629 ::KillTimer(HVTWin,IdCaretTimer);
2630 }
2631 return;
2632 }
2633 else if (nIDEvent==IdScrollTimer) {
2634 GetCursorPos(&Point);
2635 ::ScreenToClient(HVTWin,&Point);
2636 DispAutoScroll(Point);
2637 if ((Point.x < 0) || (Point.x >= ScreenWidth) ||
2638 (Point.y < 0) || (Point.y >= ScreenHeight)) {
2639 ::PostMessage(HVTWin,WM_MOUSEMOVE,MK_LBUTTON,MAKELONG(Point.x,Point.y));
2640 }
2641 return;
2642 }
2643 else if (nIDEvent == IdCancelConnectTimer) {
2644 // �����������������������������A�\�P�b�g�������N���[�Y�B
2645 // CloseSocket()�������������A�����������������������A����Win32API���R�[�������B
2646 if (!cv.Ready) {
2647 closesocket(cv.s);
2648 cv.s = INVALID_SOCKET; /* �\�P�b�g�����������t�����B(2010.8.6 yutaka) */
2649 //::PostMessage(HVTWin, WM_USER_COMMNOTIFY, 0, FD_CLOSE);
2650 }
2651 }
2652
2653 ::KillTimer(HVTWin, nIDEvent);
2654
2655 switch (nIDEvent) {
2656 case IdDelayTimer:
2657 cv.CanSend = TRUE;
2658 break;
2659 case IdProtoTimer:
2660 ProtoDlgTimeOut();
2661 break;
2662 case IdDblClkTimer:
2663 AfterDblClk = FALSE;
2664 break;
2665 case IdComEndTimer:
2666 if (! CommCanClose(&cv)) {
2667 // wait if received data remains
2668 ::SetTimer(m_hWnd, IdComEndTimer,1,NULL);
2669 break;
2670 }
2671 cv.Ready = FALSE;
2672 if (cv.TelFlag) {
2673 EndTelnet();
2674 }
2675 PortType = cv.PortType;
2676 CommClose(&cv);
2677 SetDdeComReady(0);
2678 if ((PortType==IdTCPIP) &&
2679 ((ts.PortFlag & PF_BEEPONCONNECT) != 0)) {
2680 MessageBeep(0);
2681 }
2682 if ((PortType==IdTCPIP) &&
2683 (ts.AutoWinClose>0) &&
2684 ::IsWindowEnabled(HVTWin) &&
2685 ((HTEKWin==NULL) || ::IsWindowEnabled(HTEKWin)) ) {
2686 OnClose();
2687 }
2688 else {
2689 ChangeTitle();
2690 if (ts.ClearScreenOnCloseConnection) {
2691 OnEditClearScreen();
2692 }
2693 }
2694 break;
2695 case IdPrnStartTimer:
2696 PrnFileStart(PrintFile_);
2697 break;
2698 case IdPrnProcTimer:
2699 PrnFileDirectProc(PrintFile_);
2700 break;
2701 }
2702 }
2703
2704 void CVTWindow::OnVScroll(UINT nSBCode, UINT nPos, HWND pScrollBar)
2705 {
2706 int Func;
2707 SCROLLINFO si;
2708
2709 switch (nSBCode) {
2710 case SB_BOTTOM:
2711 Func = SCROLL_BOTTOM;
2712 break;
2713 case SB_ENDSCROLL:
2714 return;
2715 case SB_LINEDOWN:
2716 Func = SCROLL_LINEDOWN;
2717 break;
2718 case SB_LINEUP:
2719 Func = SCROLL_LINEUP;
2720 break;
2721 case SB_PAGEDOWN:
2722 Func = SCROLL_PAGEDOWN;
2723 break;
2724 case SB_PAGEUP:
2725 Func = SCROLL_PAGEUP;
2726 break;
2727 case SB_THUMBPOSITION:
2728 case SB_THUMBTRACK:
2729 Func = SCROLL_POS;
2730 break;
2731 case SB_TOP:
2732 Func = SCROLL_TOP;
2733 break;
2734 default:
2735 return;
2736 }
2737
2738 // �X�N���[�������W�� 16bit ���� 32bit ���g������ (2005.10.4 yutaka)
2739 ZeroMemory(&si, sizeof(SCROLLINFO));
2740 si.cbSize = sizeof(SCROLLINFO);
2741 si.fMask = SIF_TRACKPOS;
2742 if (::GetScrollInfo(HVTWin, SB_VERT, &si)) { // success
2743 nPos = si.nTrackPos;
2744 }
2745
2746 DispVScroll(Func,nPos);
2747 }
2748
2749 BOOL CVTWindow::OnDeviceChange(UINT nEventType, DWORD_PTR dwData)
2750 {
2751 PDEV_BROADCAST_HDR pDevHdr;
2752 #ifdef DEBUG
2753 char port_name[8]; /* COMxxxx + NULL */
2754 #endif
2755
2756 pDevHdr = (PDEV_BROADCAST_HDR)dwData;
2757
2758 switch (nEventType) {
2759 case DBT_DEVICEARRIVAL:
2760 #ifdef DEBUG
2761 OutputDebugPrintf("DBT_DEVICEARRIVAL devicetype=%d PortType=%d AutoDisconnectedPort=%d\n", pDevHdr->dbch_devicetype, ts.PortType, AutoDisconnectedPort);
2762 #endif
2763 // DBT_DEVTYP_PORT �������� DBT_DEVTYP_DEVICEINTERFACE �������������h���C�o����������
2764 if ((pDevHdr->dbch_devicetype == DBT_DEVTYP_PORT || pDevHdr->dbch_devicetype == DBT_DEVTYP_DEVICEINTERFACE) &&
2765 ts.PortType == IdSerial &&
2766 ts.AutoComPortReconnect &&
2767 AutoDisconnectedPort == ts.ComPort) {
2768 #ifdef DEBUG
2769 if (pDevHdr->dbch_devicetype == DBT_DEVTYP_PORT) {
2770 PDEV_BROADCAST_PORT pDevPort;
2771 pDevPort = (PDEV_BROADCAST_PORT)pDevHdr;
2772 strncpy_s(port_name, sizeof(port_name), pDevPort->dbcp_name, _TRUNCATE);
2773 OutputDebugPrintf("%s\n", port_name);
2774 }
2775 #endif
2776 if (!cv.Open) {
2777 /* Tera Term ������ */
2778 if (CheckComPort(ts.ComPort) == 1) {
2779 /* �|�[�g���L�� */
2780 AutoDisconnectedPort = -1;
2781 Connecting = TRUE;
2782 ChangeTitle();
2783 CommOpen(HVTWin, &ts, &cv);
2784 }
2785 }
2786 }
2787 break;
2788 case DBT_DEVICEREMOVECOMPLETE:
2789 #ifdef DEBUG
2790 OutputDebugPrintf("DBT_DEVICEREMOVECOMPLETE devicetype=%d PortType=%d AutoDisconnectedPort=%d\n", pDevHdr->dbch_devicetype, ts.PortType, AutoDisconnectedPort);
2791 #endif
2792 if ((pDevHdr->dbch_devicetype == DBT_DEVTYP_PORT || pDevHdr->dbch_devicetype == DBT_DEVTYP_DEVICEINTERFACE) &&
2793 ts.PortType == IdSerial &&
2794 ts.AutoComPortReconnect &&
2795 AutoDisconnectedPort == -1) {
2796 #ifdef DEBUG
2797 if (pDevHdr->dbch_devicetype == DBT_DEVTYP_PORT) {
2798 PDEV_BROADCAST_PORT pDevPort;
2799 pDevPort = (PDEV_BROADCAST_PORT)pDevHdr;
2800 strncpy_s(port_name, sizeof(port_name), pDevPort->dbcp_name, _TRUNCATE);
2801 OutputDebugPrintf("%s\n", port_name);
2802 }
2803 #endif
2804 if (cv.Open) {
2805 /* Tera Term ������ */
2806 if (CheckComPort(cv.ComPort) == 0) {
2807 /* �|�[�g������ */
2808 AutoDisconnectedPort = cv.ComPort;
2809 Disconnect(TRUE);
2810 }
2811 }
2812 }
2813 break;
2814 }
2815 return TRUE;
2816 }
2817
2818 LRESULT CVTWindow::OnWindowPosChanging(WPARAM wParam, LPARAM lParam)
2819 {
2820 if(ts.EtermLookfeel.BGEnable && ts.EtermLookfeel.BGNoCopyBits) {
2821 ((WINDOWPOS*)lParam)->flags |= SWP_NOCOPYBITS;
2822 }
2823
2824 return TTCFrameWnd::DefWindowProc(WM_WINDOWPOSCHANGING,wParam,lParam);
2825 }
2826
2827 LRESULT CVTWindow::OnSettingChange(WPARAM wParam, LPARAM lParam)
2828 {
2829 BGOnSettingChange();
2830 return TTCFrameWnd::DefWindowProc(WM_SETTINGCHANGE,wParam,lParam);
2831 }
2832
2833 LRESULT CVTWindow::OnEnterSizeMove(WPARAM wParam, LPARAM lParam)
2834 {
2835 EnableSizeTip(1);
2836
2837 BGOnEnterSizeMove();
2838 return TTCFrameWnd::DefWindowProc(WM_ENTERSIZEMOVE,wParam,lParam);
2839 }
2840
2841 LRESULT CVTWindow::OnExitSizeMove(WPARAM wParam, LPARAM lParam)
2842 {
2843 BGOnExitSizeMove();
2844
2845 EnableSizeTip(0);
2846
2847 return TTCFrameWnd::DefWindowProc(WM_EXITSIZEMOVE,wParam,lParam);
2848 }
2849
2850 LRESULT CVTWindow::OnIMEStartComposition(WPARAM wParam, LPARAM lParam)
2851 {
2852 IMECompositionState = TRUE;
2853
2854 // ���u�����m����
2855 int CaretX = (CursorX-WinOrgX)*FontWidth;
2856 int CaretY = (CursorY-WinOrgY)*FontHeight;
2857 SetConversionWindow(HVTWin,CaretX,CaretY);
2858
2859 return TTCFrameWnd::DefWindowProc(WM_IME_STARTCOMPOSITION,wParam,lParam);
2860 }
2861
2862 LRESULT CVTWindow::OnIMEEndComposition(WPARAM wParam, LPARAM lParam)
2863 {
2864 IMECompositionState = FALSE;
2865 return TTCFrameWnd::DefWindowProc(WM_IME_ENDCOMPOSITION,wParam,lParam);
2866 }
2867
2868 LRESULT CVTWindow::OnIMEComposition(WPARAM wParam, LPARAM lParam)
2869 {
2870 if (CanUseIME()) {
2871 size_t len;
2872 const wchar_t *lpstr = GetConvStringW(HVTWin, lParam, &len);
2873 if (lpstr != NULL) {
2874 const wchar_t *output_wstr = lpstr;
2875 if (len == 1 && ControlKey()) {
2876 const static wchar_t code_ctrl_space = 0;
2877 const static wchar_t code_ctrl_backslash = 0x1c;
2878 switch(*lpstr) {
2879 case 0x20:
2880 output_wstr = &code_ctrl_space;
2881 break;
2882 case 0x5c: // Ctrl-\ support for NEC-PC98
2883 output_wstr = &code_ctrl_backslash;
2884 break;
2885 }
2886 }
2887 if (ts.LocalEcho>0) {
2888 CommTextEchoW(&cv,output_wstr,len);
2889 }
2890 CommTextOutW(&cv,output_wstr,len);
2891 free((void *)lpstr);
2892 return 0;
2893 }
2894 }
2895 return TTCFrameWnd::DefWindowProc(WM_IME_COMPOSITION,wParam,lParam);
2896 }
2897
2898 LRESULT CVTWindow::OnIMEInputChange(WPARAM wParam, LPARAM lParam)
2899 {
2900 ChangeCaret();
2901
2902 return TTCFrameWnd::DefWindowProc(WM_INPUTLANGCHANGE,wParam,lParam);
2903 }
2904
2905 LRESULT CVTWindow::OnIMENotify(WPARAM wParam, LPARAM lParam)
2906 {
2907 switch (wParam) {
2908 case IMN_SETOPENSTATUS:
2909 // �����R���e�L�X�g���J���������X�V������(IME On/OFF)
2910
2911 // IME��On/Off����������
2912 IMEstat = GetIMEOpenStatus(HVTWin);
2913 if (IMEstat != 0) {
2914 // IME On
2915
2916 // �������\������IME�����������u�����m����
2917 int CaretX = (CursorX-WinOrgX)*FontWidth;
2918 int CaretY = (CursorY-WinOrgY)*FontHeight;
2919 SetConversionWindow(HVTWin,CaretX,CaretY);
2920
2921 // �t�H���g����������
2922 ResetConversionLogFont(HVTWin);
2923 }
2924
2925 // �`��
2926 ChangeCaret();
2927
2928 break;
2929
2930 // �����E�B���h�E���\���������m
2931 // IME_OPENCANDIDATE / IMN_CLOSECANDIDATE �T�|�[�g����
2932 //
2933 // IME status
2934 // --------------------------------+----------
2935 // MS IME ���{��(Windows 10 1809) suport
2936 // Google ���{������(2.24.3250.0) not support
2937 //
2938 // WM_IME_STARTCOMPOSITION / WM_IME_ENDCOMPOSITION ��
2939 // ���������������X�^�[�g���� / �I�����������������B
2940 // IME_OPENCANDIDATE / IMN_CLOSECANDIDATE ��
2941 // �����E�B���h�E���\�������� / �����������������B
2942 case IMN_OPENCANDIDATE: {
2943 // �����E�B���h�E���J��������������
2944
2945 // �������\������IME�����������u�����m����
2946 // �������������������A���u������������
2947 // - ���������������\��
2948 // - �������������������������m���������s��
2949 // - ����������������������������������
2950 int CaretX = (CursorX-WinOrgX)*FontWidth;
2951 int CaretY = (CursorY-WinOrgY)*FontHeight;
2952 SetConversionWindow(HVTWin,CaretX,CaretY);
2953
2954 // �t�H���g����������
2955 ResetConversionLogFont(HVTWin);
2956
2957 break;
2958 }
2959
2960 case IMN_OPENSTATUSWINDOW:
2961 // �X�e�[�^�X�E�B���h�E���I�[�v��(���m���������\��?)����������������
2962
2963 // IME���������������A�t�H���g�_�C�A���O���I�[�v�������N���[�Y������
2964 // IME���������������t�H���g������������������������������
2965 // �������t�H���g�����������s��
2966
2967 // �t�H���g����������
2968 ResetConversionLogFont(HVTWin);
2969 break;
2970 default:
2971 break;
2972 }
2973
2974 return TTCFrameWnd::DefWindowProc(WM_IME_NOTIFY,wParam,lParam);
2975 }
2976
2977 static LRESULT ReplyIMERequestDocumentfeed(HWND hWnd, LPARAM lParam)
2978 {
2979 static RECONVERTSTRING *pReconvPtrSave; // TODO leak
2980 static size_t ReconvSizeSave;
2981 LRESULT result;
2982
2983 if (lParam == 0)
2984 { // 1�����������o�� �T�C�Y����������
2985 if(IsWindowUnicode(hWnd) == FALSE) {
2986 // ANSI��
2987 char buf[512]; // �Q�������������������o�b�t�@
2988 size_t str_len_count;
2989 int cx;
2990
2991 // �Q�������������A1�s�����o��
2992 { // �J�[�\�����������A�X�y�[�X���O���������������������s��������
2993 int x;
2994 int len;
2995 cx = BuffGetCurrentLineData(buf, sizeof(buf));
2996 len = cx;
2997 for (x=cx; x < NumOfColumns; x++) {
2998 const char c = buf[x];
2999 if (c != 0 && c != 0x20) {
3000 len = x+1;
3001 }
3002 }
3003 str_len_count = len;
3004 }
3005
3006 // IME�������\��������������
3007 if (pReconvPtrSave != NULL) {
3008 free(pReconvPtrSave);
3009 }
3010 pReconvPtrSave = (RECONVERTSTRING *)CreateReconvStringStA(
3011 hWnd, buf, str_len_count, cx, &ReconvSizeSave);
3012 }
3013 else {
3014 // UNICODE��
3015 size_t str_len_count;
3016 int cx;
3017 wchar_t *strW;
3018
3019 // �Q�������������A1�s�����o��
3020 { // �J�[�\�����������A�X�y�[�X���O���������������������s��������
3021 int x;
3022 size_t len = 0;
3023 cx = CursorX;
3024 strW = BuffGetLineStrW(CursorY, &cx, &len);
3025 len = cx;
3026 for (x=cx; x < NumOfColumns; x++) {
3027 const wchar_t c = strW[x];
3028 if (c == 0 || c == 0x20) {
3029 len = x;
3030 break;
3031 }
3032 }
3033 str_len_count = len;
3034 }
3035
3036 // IME�������\��������������
3037 if (pReconvPtrSave != NULL) {
3038 free(pReconvPtrSave);
3039 }
3040 pReconvPtrSave = (RECONVERTSTRING *)CreateReconvStringStW(
3041 hWnd, strW, str_len_count, cx, &ReconvSizeSave);
3042 free(strW);
3043 }
3044
3045 // 1�������T�C�Y����������
3046 result = ReconvSizeSave;
3047 }
3048 else {
3049 // 2�����������o�� �\�������n��
3050 if (pReconvPtrSave != NULL) {
3051 RECONVERTSTRING *pReconv = (RECONVERTSTRING*)lParam;
3052 result = 0;
3053 if (pReconv->dwSize >= ReconvSizeSave) {
3054 // 1�������T�C�Y���m��������������������
3055 memcpy(pReconv, pReconvPtrSave, ReconvSizeSave);
3056 result = ReconvSizeSave;
3057 }
3058 free(pReconvPtrSave);
3059 pReconvPtrSave = NULL;
3060 ReconvSizeSave = 0;
3061 } else {
3062 // 3����?
3063 result = 0;
3064 }
3065 }
3066
3067 return result;
3068 }
3069
3070 LRESULT CVTWindow::OnIMERequest(WPARAM wParam, LPARAM lParam)
3071 {
3072 // "IME=off"���������A�����������B
3073 if (ts.UseIME > 0) {
3074 switch(wParam) {
3075 case IMR_DOCUMENTFEED:
3076 return ReplyIMERequestDocumentfeed(HVTWin, lParam);
3077 default:
3078 break;
3079 }
3080 }
3081 return TTCFrameWnd::DefWindowProc(WM_IME_REQUEST,wParam,lParam);
3082 }
3083
3084 LRESULT CVTWindow::OnAccelCommand(WPARAM wParam, LPARAM lParam)
3085 {
3086 switch (wParam) {
3087 case IdHold:
3088 if (TalkStatus==IdTalkKeyb) {
3089 Hold = ! Hold;
3090 CommLock(&ts,&cv,Hold);
3091 }
3092 break;
3093 case IdPrint:
3094 OnFilePrint();
3095 break;
3096 case IdBreak:
3097 OnControlSendBreak();
3098 break;
3099 case IdCmdEditCopy:
3100 OnEditCopy();
3101 break;
3102 case IdCmdEditPaste:
3103 OnEditPaste();
3104 break;
3105 case IdCmdEditPasteCR:
3106 OnEditPasteCR();
3107 break;
3108 case IdCmdEditCLS:
3109 OnEditClearScreen();
3110 break;
3111 case IdCmdEditCLB:
3112 OnEditClearBuffer();
3113 break;
3114 case IdCmdCtrlOpenTEK:
3115 OnControlOpenTEK();
3116 break;
3117 case IdCmdCtrlCloseTEK:
3118 OnControlCloseTEK();
3119 break;
3120 case IdCmdLineUp:
3121 OnVScroll(SB_LINEUP,0,NULL);
3122 break;
3123 case IdCmdLineDown:
3124 OnVScroll(SB_LINEDOWN,0,NULL);
3125 break;
3126 case IdCmdPageUp:
3127 OnVScroll(SB_PAGEUP,0,NULL);
3128 break;
3129 case IdCmdPageDown:
3130 OnVScroll(SB_PAGEDOWN,0,NULL);
3131 break;
3132 case IdCmdBuffTop:
3133 OnVScroll(SB_TOP,0,NULL);
3134 break;
3135 case IdCmdBuffBottom:
3136 OnVScroll(SB_BOTTOM,0,NULL);
3137 break;
3138 case IdCmdNextWin:
3139 SelectNextWin(HVTWin,1,FALSE);
3140 break;
3141 case IdCmdPrevWin:
3142 SelectNextWin(HVTWin,-1,FALSE);
3143 break;
3144 case IdCmdNextSWin:
3145 SelectNextWin(HVTWin,1,TRUE);
3146 break;
3147 case IdCmdPrevSWin:
3148 SelectNextWin(HVTWin,-1,TRUE);
3149 break;
3150 case IdCmdLocalEcho:
3151 if (ts.LocalEcho==0) {
3152 ts.LocalEcho = 1;
3153 }
3154 else {
3155 ts.LocalEcho = 0;
3156 }
3157 if (cv.Ready && cv.TelFlag && (ts.TelEcho>0)) {
3158 TelChangeEcho();
3159 }
3160 break;
3161 case IdCmdDisconnect: // called by TTMACRO
3162 Disconnect(lParam);
3163 break;
3164 case IdCmdLoadKeyMap: // called by TTMACRO
3165 SetKeyMap();
3166 break;
3167 case IdCmdRestoreSetup: // called by TTMACRO
3168 RestoreSetup();
3169 break;
3170 case IdCmdScrollLock:
3171 ScrollLock = ! ScrollLock;
3172 break;
3173 }
3174 return 0;
3175 }
3176
3177 LRESULT CVTWindow::OnChangeMenu(WPARAM wParam, LPARAM lParam)
3178 {
3179 HMENU SysMenu;
3180 BOOL Show, B1, B2;
3181
3182 Show = (ts.PopupMenu==0) && (ts.HideTitle==0);
3183
3184 // TTXKanjiMenu ���������A���j���[���\��������������
3185 // ���`�����������������B (2007.7.14 maya)
3186 if (Show != (MainMenu!=NULL)) {
3187 AdjustSize = TRUE;
3188 }
3189
3190 if (MainMenu!=NULL) {
3191 DestroyMenu(MainMenu);
3192 MainMenu = NULL;
3193 }
3194
3195 if (! Show) {
3196 if (WinMenu!=NULL) {
3197 DestroyMenu(WinMenu);
3198 }
3199 WinMenu = NULL;
3200 }
3201 else {
3202 InitMenu(&MainMenu);
3203 }
3204
3205 ::SetMenu(HVTWin, MainMenu);
3206 ::DrawMenuBar(HVTWin);
3207
3208 B1 = ((ts.MenuFlag & MF_SHOWWINMENU)!=0);
3209 B2 = (WinMenu!=NULL);
3210 if ((MainMenu!=NULL) &&
3211 (B1 != B2)) {
3212 if (WinMenu==NULL) {
3213 WinMenu = CreatePopupMenu();
3214 get_lang_msg("MENU_WINDOW", ts.UIMsg, sizeof(ts.UIMsg),
3215 "&Window", ts.UILanguageFile);
3216 ::InsertMenu(MainMenu,ID_HELPMENU,
3217 MF_STRING | MF_ENABLED | MF_POPUP | MF_BYPOSITION,
3218 (UINT_PTR)WinMenu, ts.UIMsg);
3219 }
3220 else {
3221 RemoveMenu(MainMenu,ID_HELPMENU,MF_BYPOSITION);
3222 DestroyMenu(WinMenu);
3223 WinMenu = NULL;
3224 }
3225 ::DrawMenuBar(HVTWin);
3226 }
3227
3228 ::GetSystemMenu(HVTWin,TRUE);
3229 if ((! Show) && ((ts.MenuFlag & MF_NOSHOWMENU)==0)) {
3230 SysMenu = ::GetSystemMenu(HVTWin,FALSE);
3231 AppendMenu(SysMenu, MF_SEPARATOR, 0, NULL);
3232 get_lang_msg("MENU_SHOW_MENUBAR", ts.UIMsg, sizeof(ts.UIMsg),
3233 "Show menu &bar", ts.UILanguageFile);
3234 AppendMenu(SysMenu, MF_STRING, ID_SHOWMENUBAR, ts.UIMsg);
3235 }
3236 return 0;
3237 }
3238
3239 LRESULT CVTWindow::OnChangeTBar(WPARAM wParam, LPARAM lParam)
3240 {
3241 BOOL TBar;
3242 DWORD Style,ExStyle;
3243 HMENU SysMenu;
3244
3245 Style = (DWORD)::GetWindowLongPtr (HVTWin, GWL_STYLE);
3246 ExStyle = (DWORD)::GetWindowLongPtr (HVTWin, GWL_EXSTYLE);
3247 TBar = ((Style & WS_SYSMENU)!=0);
3248 if (TBar == (ts.HideTitle==0)) {
3249 return 0;
3250 }
3251
3252 #ifndef WINDOW_MAXMIMUM_ENABLED
3253 if (ts.HideTitle>0)
3254 Style = Style & ~(WS_SYSMENU | WS_CAPTION |
3255 WS_MINIMIZEBOX) | WS_BORDER | WS_POPUP;
3256 else
3257 Style = Style & ~WS_POPUP | WS_SYSMENU | WS_CAPTION |
3258 WS_MINIMIZEBOX;
3259 #else
3260 if (ts.HideTitle>0) {
3261 Style = (Style & ~(WS_SYSMENU | WS_CAPTION |
3262 WS_MINIMIZEBOX | WS_MAXIMIZEBOX)) | WS_BORDER | WS_POPUP;
3263
3264 if(ts.EtermLookfeel.BGNoFrame) {
3265 Style &= ~(WS_THICKFRAME | WS_BORDER);
3266 ExStyle &= ~WS_EX_CLIENTEDGE;
3267 }else{
3268 ExStyle |= WS_EX_CLIENTEDGE;
3269 }
3270 }
3271 else {
3272 Style = (Style & ~WS_POPUP) | WS_SYSMENU | WS_CAPTION |
3273 WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_THICKFRAME | WS_BORDER;
3274
3275 ExStyle |= WS_EX_CLIENTEDGE;
3276 }
3277 #endif
3278
3279 AdjustSize = TRUE;
3280 ::SetWindowLongPtr(HVTWin, GWL_STYLE, Style);
3281 ::SetWindowLongPtr(HVTWin, GWL_EXSTYLE, ExStyle);
3282 ::SetWindowPos(HVTWin, NULL, 0, 0, 0, 0,
3283 SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
3284 ::ShowWindow(HVTWin, SW_SHOW);
3285
3286 if ((ts.HideTitle==0) && (MainMenu==NULL) &&
3287 ((ts.MenuFlag & MF_NOSHOWMENU) == 0)) {