Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/trunk/teraterm/teraterm/vtwin.cpp

Contents of /trunk/teraterm/teraterm/vtwin.cpp

Parent Directory Parent Directory | Revision Log Revision Log

Revision 10617 - (show annotations) (download) (as text)
Fri Mar 3 15:15:04 2023 UTC (12 months ago) by zmatsuo
File MIME type: text/x-c++src
File size: 137900 byte(s) 
lngファイル名変数を ANSI版から Unicode 版へ切り替え

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