teraterm/teraterm/vtwin.cpp

/*
 * Copyright (C) 1994-1998 T. Teranishi
 * (C) 2004-2020 TeraTerm Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/* IPv6 modification is Copyright(C) 2000 Jun-ya Kato <kato@win6.jp> */

/* TERATERM.EXE, VT window */

#include "teraterm_conf.h"
#include "teraterm.h"
#include "tttypes.h"

#include "ttcommon.h"
#include "ttwinman.h"
#include "ttsetup.h"
#include "keyboard.h"
#include "buffer.h"
#include "vtterm.h"
#include "vtdisp.h"
#include "ttdialog.h"
#include "ttime.h"
#include "commlib.h"
#include "clipboar.h"
#include "ttftypes.h"
#include "filesys.h"
#include "telnet.h"
#include "tektypes.h"
#include "ttdde.h"
#include "ttlib.h"
#include "dlglib.h"
#include "helpid.h"
#include "teraprn.h"
#include <winsock2.h>
#include <ws2tcpip.h>
#include "ttplug.h"  /* TTPLUG */
#include "teraterml.h"
#include "buffer.h"

#include <stdio.h>
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
#include <string.h>
#include <locale.h>

#include <shlobj.h>
#include <io.h>
#include <errno.h>
#include <imagehlp.h>

#include <windowsx.h>
#include <imm.h>
#include <dbt.h>
#include <assert.h>
#include <wchar.h>

#include "tt_res.h"
#include "vtwin.h"
#include "addsetting.h"
#include "winjump.h"
#include "sizetip.h"
#include "dnddlg.h"
#include "tekwin.h"
#include <htmlhelp.h>
#include "compat_win.h"
#include "unicode_test.h"
#if UNICODE_DEBUG
#include "tipwin.h"
#endif
#include "codeconv.h"
#include "layer_for_unicode.h"
#include "sendmem.h"
#include "sendfiledlg.h"
#include "setting.h"
#include "broadcast.h"
#include "asprintf.h"

#include "initguid.h"
//#include "Usbiodef.h"
DEFINE_GUID(GUID_DEVINTERFACE_USB_DEVICE, 0xA5DCBF10L, 0x6530, 0x11D2, 0x90, 0x1F, 0x00, \
             0xC0, 0x4F, 0xB9, 0x51, 0xED);

#define VTClassName L"VTWin32"

// �E�B���h�E�������{�^�����L�������� (2005.1.15 yutaka)
#define WINDOW_MAXMIMUM_ENABLED 1

static BOOL TCPLocalEchoUsed = FALSE;
static BOOL TCPCRSendUsed = FALSE;

static BOOL IgnoreRelease = FALSE;

static HDEVNOTIFY hDevNotify = NULL;

static int AutoDisconnectedPort = -1;

#ifndef WM_IME_COMPOSITION
#define WM_IME_COMPOSITION              0x010F
#endif

UnicodeDebugParam_t UnicodeDebugParam;

/////////////////////////////////////////////////////////////////////////////
// CVTWindow

// Tera Term�N������URL������mouse over������������ (2005.4.2 yutaka)
static void SetMouseCursor(const char *cursor)
{
        HCURSOR hc;
        LPCTSTR name = NULL;
        int i;

        for (i = 0 ; MouseCursor[i].name ; i++) {
                if (_stricmp(cursor, MouseCursor[i].name) == 0) {
                        name = MouseCursor[i].id;
                        break;
                }
        }
        if (name == NULL) {
                return;
        }

        hc = (HCURSOR)LoadImage(NULL, name, IMAGE_CURSOR,
                                0, 0, LR_DEFAULTSIZE | LR_SHARED);

        if (hc != NULL) {
                SetClassLongPtr(HVTWin, GCLP_HCURSOR, (LONG_PTR)hc);
        }
}

/**
 * @param[in]   alpha   0-255
 */
void CVTWindow::SetWindowAlpha(BYTE alpha)
{
        if (pSetLayeredWindowAttributes == NULL) {
                return; // ���C���[�h�E�C���h�E���T�|�[�g����
        }
        if (Alpha == alpha) {
                return; // ����������������������
        }
        LONG_PTR lp = GetWindowLongPtr(GWL_EXSTYLE);
        if (lp == 0) {
                return;
        }

        // 2006/03/16 by 337: BGUseAlphaBlendAPI��On������Layered����������
        //if (ts->EtermLookfeel.BGUseAlphaBlendAPI) {
        // �A���t�@�l��255�������A�����������������}�����������������������������B(2006.4.1 yutaka)
        // �����o�������A�l�����X�����������������������f�����B(2007.10.19 maya)
        if (alpha < 255) {
                ::SetWindowLongPtr(HVTWin, GWL_EXSTYLE, lp | WS_EX_LAYERED);
                pSetLayeredWindowAttributes(HVTWin, 0, alpha, LWA_ALPHA);
        }
        else {
                // �A���t�@�l�� 255 �������A�����������������������`�������B(2007.10.22 maya)
                ::SetWindowLongPtr(HVTWin, GWL_EXSTYLE, lp & ~WS_EX_LAYERED);
                ::RedrawWindow(HVTWin, NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_FRAME);
        }
        Alpha = alpha;
}

void RegDeviceNotify(HWND hWnd)
{
        typedef HDEVNOTIFY (WINAPI *PRegisterDeviceNotification)(HANDLE hRecipient, LPVOID NotificationFilter, DWORD Flags);
        HMODULE h;
        PRegisterDeviceNotification pRegisterDeviceNotification;
        DEV_BROADCAST_DEVICEINTERFACE filter;

        if (((h = GetModuleHandle("user32.dll")) == NULL) ||
                        ((pRegisterDeviceNotification = (PRegisterDeviceNotification)GetProcAddress(h, "RegisterDeviceNotificationA")) == NULL)) {
                return;
        }

        ZeroMemory(&filter, sizeof(filter));
        filter.dbcc_size = sizeof(filter);
        filter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
        filter.dbcc_classguid = GUID_DEVINTERFACE_USB_DEVICE;
        hDevNotify = pRegisterDeviceNotification(hWnd, &filter, DEVICE_NOTIFY_WINDOW_HANDLE);
}

void UnRegDeviceNotify(HWND hWnd)
{
        typedef BOOL (WINAPI *PUnregisterDeviceNotification)(HDEVNOTIFY Handle);
        HMODULE h;
        PUnregisterDeviceNotification pUnregisterDeviceNotification;

        if (((h = GetModuleHandle("user32.dll")) == NULL) ||
                        ((pUnregisterDeviceNotification = (PUnregisterDeviceNotification)GetProcAddress(h, "UnregisterDeviceNotification")) == NULL)) {
                return;
        }

        pUnregisterDeviceNotification(hDevNotify);
}

void SetAutoConnectPort(int port)
{
        AutoDisconnectedPort = port;
}

//
// ���O�n���h�����t�b�N�i�X�^�b�N�g���[�X���_���v�j
//
// cf. http://svn.collab.net/repos/svn/trunk/subversion/libsvn_subr/win32_crashrpt.c
// (2007.9.30 yutaka)
//
// ���O�R�[�h������������������
#if !defined(_M_X64)
static const char *GetExceptionString(DWORD exception)
{
#define EXCEPTION(x) case EXCEPTION_##x: return (#x);
        static char buf[16];

        switch (exception)
        {
                EXCEPTION(ACCESS_VIOLATION)
                EXCEPTION(DATATYPE_MISALIGNMENT)
                EXCEPTION(BREAKPOINT)
                EXCEPTION(SINGLE_STEP)
                EXCEPTION(ARRAY_BOUNDS_EXCEEDED)
                EXCEPTION(FLT_DENORMAL_OPERAND)
                EXCEPTION(FLT_DIVIDE_BY_ZERO)
                EXCEPTION(FLT_INEXACT_RESULT)
                EXCEPTION(FLT_INVALID_OPERATION)
                EXCEPTION(FLT_OVERFLOW)
                EXCEPTION(FLT_STACK_CHECK)
                EXCEPTION(FLT_UNDERFLOW)
                EXCEPTION(INT_DIVIDE_BY_ZERO)
                EXCEPTION(INT_OVERFLOW)
                EXCEPTION(PRIV_INSTRUCTION)
                EXCEPTION(IN_PAGE_ERROR)
                EXCEPTION(ILLEGAL_INSTRUCTION)
                EXCEPTION(NONCONTINUABLE_EXCEPTION)
                EXCEPTION(STACK_OVERFLOW)
                EXCEPTION(INVALID_DISPOSITION)
                EXCEPTION(GUARD_PAGE)
                EXCEPTION(INVALID_HANDLE)

        default:
                _snprintf_s(buf, sizeof(buf), _TRUNCATE, "0x%x", exception);
                return buf;
                //return "UNKNOWN_ERROR";
        }
#undef EXCEPTION
}

/* ���O�������������������o���������\�������A���O�t�B���^���� */
static LONG CALLBACK ApplicationFaultHandler(EXCEPTION_POINTERS *ExInfo)
{
        HGLOBAL gptr;
        STACKFRAME sf;
        BOOL bResult;
        PIMAGEHLP_SYMBOL pSym;
        DWORD Disp;
        HANDLE hProcess = GetCurrentProcess();
        HANDLE hThread = GetCurrentThread();
        IMAGEHLP_MODULE ih_module;
        IMAGEHLP_LINE   ih_line;
        int frame;
        char msg[3072], buf[256];
        HMODULE h, h2;
        char imagehlp_dll[MAX_PATH];

        // Windows98/Me/NT4�����������������X�L�b�v�����B(2007.10.9 yutaka)
        GetSystemDirectory(imagehlp_dll, sizeof(imagehlp_dll));
        strncat_s(imagehlp_dll, sizeof(imagehlp_dll), "\\imagehlp.dll", _TRUNCATE);
        h2 = LoadLibrary(imagehlp_dll);
        if (((h = GetModuleHandle(imagehlp_dll)) == NULL) ||
                (GetProcAddress(h, "SymGetLineFromAddr") == NULL)) {
                        FreeLibrary(h2);
                        goto error;
        }
        FreeLibrary(h2);

        /* �V���{�������i�[�p�o�b�t�@�������� */
        gptr = GlobalAlloc(GMEM_FIXED, 10000);
        if (gptr == NULL) {
                goto error;
        }
        pSym = (PIMAGEHLP_SYMBOL)GlobalLock(gptr);
        ZeroMemory(pSym, sizeof(IMAGEHLP_SYMBOL));
        pSym->SizeOfStruct = 10000;
        pSym->MaxNameLength = 10000 - sizeof(IMAGEHLP_SYMBOL);

        /* �X�^�b�N�t���[���������� */
        ZeroMemory(&sf, sizeof(sf));
        sf.AddrPC.Offset = ExInfo->ContextRecord->Eip;
        sf.AddrStack.Offset = ExInfo->ContextRecord->Esp;
        sf.AddrFrame.Offset = ExInfo->ContextRecord->Ebp;
        sf.AddrPC.Mode = AddrModeFlat;
        sf.AddrStack.Mode = AddrModeFlat;
        sf.AddrFrame.Mode = AddrModeFlat;

        /* �V���{���n���h���������� */
        SymInitialize(hProcess, NULL, TRUE);

        // ���W�X�^�_���v
        msg[0] = '\0';
        _snprintf_s(buf, sizeof(buf), _TRUNCATE, "eax=%08X ebx=%08X ecx=%08X edx=%08X esi=%08X edi=%08X\r\n"
                   "ebp=%08X esp=%08X eip=%08X efl=%08X\r\n"
                   "cs=%04X ss=%04X ds=%04X es=%04X fs=%04X gs=%04X\r\n",
                   ExInfo->ContextRecord->Eax,
                   ExInfo->ContextRecord->Ebx,
                   ExInfo->ContextRecord->Ecx,
                   ExInfo->ContextRecord->Edx,
                   ExInfo->ContextRecord->Esi,
                   ExInfo->ContextRecord->Edi,
                   ExInfo->ContextRecord->Ebp,
                   ExInfo->ContextRecord->Esp,
                   ExInfo->ContextRecord->Eip,
                   ExInfo->ContextRecord->EFlags,
                   ExInfo->ContextRecord->SegCs,
                   ExInfo->ContextRecord->SegSs,
                   ExInfo->ContextRecord->SegDs,
                   ExInfo->ContextRecord->SegEs,
                   ExInfo->ContextRecord->SegFs,
                   ExInfo->ContextRecord->SegGs
        );
        strncat_s(msg, sizeof(msg), buf, _TRUNCATE);

        if (ExInfo->ExceptionRecord != NULL) {
                _snprintf_s(buf, sizeof(buf), _TRUNCATE, "Exception: %s\r\n", GetExceptionString(ExInfo->ExceptionRecord->ExceptionCode));
                strncat_s(msg, sizeof(msg), buf, _TRUNCATE);
        }

        /* �X�^�b�N�t���[���������\���������� */
        frame = 0;
        for (;;) {
                /* �����X�^�b�N�t���[�������� */
                bResult = StackWalk(
                        IMAGE_FILE_MACHINE_I386,
                        hProcess,
                        hThread,
                        &sf,
                        NULL,
                        NULL,
                        SymFunctionTableAccess,
                        SymGetModuleBase,
                        NULL);

                /* ���s�������A���[�v�������� */
                if (!bResult || sf.AddrFrame.Offset == 0)
                        break;

                frame++;

                /* �v���O�����J�E���^�i���z�A�h���X�j�������������I�t�Z�b�g������ */
                bResult = SymGetSymFromAddr(hProcess, sf.AddrPC.Offset, &Disp, pSym);

                /* �����������\�� */
                _snprintf_s(buf, sizeof(buf), _TRUNCATE, "#%d  0x%08x in ", frame, sf.AddrPC.Offset);
                strncat_s(msg, sizeof(msg), buf, _TRUNCATE);
                if (bResult) {
                        _snprintf_s(buf, sizeof(buf), _TRUNCATE, "%s() + 0x%x ", pSym->Name, Disp);
                        strncat_s(msg, sizeof(msg), buf, _TRUNCATE);
                } else {
                        _snprintf_s(buf, sizeof(buf), _TRUNCATE, " --- ");
                        strncat_s(msg, sizeof(msg), buf, _TRUNCATE);
                }

                // ���s�t�@�C����������
                ZeroMemory( &(ih_module), sizeof(ih_module) );
                ih_module.SizeOfStruct = sizeof(ih_module);
                bResult = SymGetModuleInfo( hProcess, sf.AddrPC.Offset, &(ih_module) );
                strncat_s(msg, sizeof(msg), "at ", _TRUNCATE);
                if (bResult) {
                        _snprintf_s(buf, sizeof(buf), _TRUNCATE, "%s ", ih_module.ImageName );
                        strncat_s(msg, sizeof(msg), buf, _TRUNCATE);
                } else {
                        _snprintf_s(buf, sizeof(buf), _TRUNCATE, "%s ", "<Unknown Module>" );
                        strncat_s(msg, sizeof(msg), buf, _TRUNCATE);
                }

                // �t�@�C�������s����������
                ZeroMemory( &(ih_line), sizeof(ih_line) );
                ih_line.SizeOfStruct = sizeof(ih_line);
                bResult = SymGetLineFromAddr( hProcess, sf.AddrPC.Offset, &Disp, &ih_line );
                if (bResult)
                {
                        _snprintf_s(buf, sizeof(buf), _TRUNCATE, "%s:%lu", ih_line.FileName, ih_line.LineNumber );
                        strncat_s(msg, sizeof(msg), buf, _TRUNCATE);
                }

                strncat_s(msg, sizeof(msg), "\n", _TRUNCATE);
        }

        /* ������ */
        SymCleanup(hProcess);
        GlobalUnlock(pSym);
        GlobalFree(pSym);

        // ���O�������������AAPI�����������o��
        ::MessageBoxA(NULL, msg, "Tera Term: Application fault", MB_OK | MB_ICONEXCLAMATION);

error:
//      return (EXCEPTION_EXECUTE_HANDLER);  /* ���������v���Z�X���I�������� */
        return (EXCEPTION_CONTINUE_SEARCH);  /* ���������m�A�v���P�[�V�����G���[�n�|�b�v�A�b�v���b�Z�[�W�{�b�N�X�������o�� */
}
#endif // !defined(_M_X64 )


// Virtual Store���L���������������������������B
//
// [Windows 95-XP]
// return FALSE (always)
//
// [Windows Vista-10]
// return TRUE:  Virtual Store Enabled
//        FALSE: Virtual Store Disabled or Unknown
//
BOOL GetVirtualStoreEnvironment(void)
{
#if _MSC_VER == 1400  // VSC2005(VC8.0)
        typedef struct _TOKEN_ELEVATION {
                DWORD TokenIsElevated;
        } TOKEN_ELEVATION, *PTOKEN_ELEVATION;
        int TokenElevation = 20;
#endif
        BOOL ret = FALSE;
        int flag = 0;
        HANDLE          hToken;
        DWORD           dwLength;
        TOKEN_ELEVATION tokenElevation;
        LONG lRet;
        HKEY hKey;
        char lpData[256];
        DWORD dwDataSize;
        DWORD dwType;
        BYTE bValue;

        // Windows Vista���O�����������B
        if (!IsWindowsVistaOrLater())
                goto error;

        // UAC���L�����������B
        // HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System��EnableLUA(DWORD�l)��0�������������f��������(0��UAC�����A1��UAC�L��)�B
        flag = 0;
        lRet = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
                TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\System"),
                NULL, KEY_QUERY_VALUE, &hKey
                );
        if (lRet == ERROR_SUCCESS) {
                dwDataSize = sizeof(lpData) / sizeof(lpData[0]);
                lRet = RegQueryValueEx(
                        hKey,
                        TEXT("EnableLUA"),
                        0,
                        &dwType,
                        (LPBYTE)lpData,
                        &dwDataSize);
                if (lRet == ERROR_SUCCESS) {
                        bValue = ((LPBYTE)lpData)[0];
                        if (bValue == 1)
                                // UAC���L���������AVirtual Store�������B
                                flag = 1;
                }
                RegCloseKey(hKey);
        }
        if (flag == 0)
                goto error;

        // UAC���L�����A�v���Z�X�����������������i�����������B
        flag = 0;
        if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY | TOKEN_ADJUST_DEFAULT, &hToken)) {
                if (GetTokenInformation(hToken, (TOKEN_INFORMATION_CLASS)TokenElevation, &tokenElevation, sizeof(TOKEN_ELEVATION), &dwLength)) {
                        // (0�����i�����������A��0�����i��������)�B
                        if (tokenElevation.TokenIsElevated == 0) {
                                // �����������������������������AVirtual Store�������B
                                flag = 1;
                        }
                }
                CloseHandle(hToken);
        }
        if (flag == 0)
                goto error;

        ret = TRUE;
        return (ret);

error:
        return (ret);
}

/////////////////////////////////////////////////////////////////////////////
// CVTWindow constructor

CVTWindow::CVTWindow(HINSTANCE hInstance)
{
        WNDCLASSW wc;
        RECT rect;
        DWORD Style;
        char *Param;
        int CmdShow;
#ifdef SHARED_KEYMAP
        char Temp[MAX_PATH];
        PKeyMap tempkm;
#endif
        int fuLoad = LR_DEFAULTCOLOR;
        BOOL isFirstInstance;
        m_hInst = hInstance;

        // ���O�n���h�����t�b�N (2007.9.30 yutaka)
#if !defined(_M_X64)
        SetUnhandledExceptionFilter(ApplicationFaultHandler);
#endif

        CommInit(&cv);
        isFirstInstance = StartTeraTerm(&ts);

        TTXInit(&ts, &cv); /* TTPLUG */

        MsgDlgHelp = RegisterWindowMessage(HELPMSGSTRING);

        if (isFirstInstance) {
                /* first instance */
                if (LoadTTSET()) {
                        /* read setup info from "teraterm.ini" */
                        (*ReadIniFile)(ts.SetupFName, &ts);
#ifdef SHARED_KEYMAP
                        /* read keycode map from "keyboard.cnf" */
                        tempkm = (PKeyMap)malloc(sizeof(TKeyMap));
                        if (tempkm!=NULL) {
                                strncpy_s(Temp, sizeof(Temp), ts.HomeDir, _TRUNCATE);
                                AppendSlash(Temp,sizeof(Temp));
                                strncat_s(Temp,sizeof(Temp),"KEYBOARD.CNF",_TRUNCATE);
                                (*ReadKeyboardCnf)(Temp,tempkm,TRUE);
                        }
#endif
                        FreeTTSET();
#ifdef SHARED_KEYMAP
                        /* store default sets in TTCMN */
#if 0
                        ChangeDefaultSet(&ts,tempkm);
#else
                        ChangeDefaultSet(NULL,tempkm);
#endif
                        if (tempkm!=NULL) free(tempkm);
#endif
                }
                else {
                        abort();
                }

        } else {
                // 2�������~���v���Z�X�����������A�f�B�X�N���� TERATERM.INI �������B(2004.11.4 yutaka)
                if (LoadTTSET()) {
                        /* read setup info from "teraterm.ini" */
                        (*ReadIniFile)(ts.SetupFName, &ts);
#ifdef SHARED_KEYMAP
                        /* read keycode map from "keyboard.cnf" */
                        tempkm = (PKeyMap)malloc(sizeof(TKeyMap));
                        if (tempkm!=NULL) {
                                strncpy_s(Temp, sizeof(Temp), ts.HomeDir, _TRUNCATE);
                                AppendSlash(Temp,sizeof(Temp));
                                strncat_s(Temp,sizeof(Temp),"KEYBOARD.CNF",_TRUNCATE);
                                (*ReadKeyboardCnf)(Temp,tempkm,TRUE);
                        }
#endif
                        FreeTTSET();
#ifdef SHARED_KEYMAP
                        /* store default sets in TTCMN */
                        if (tempkm!=NULL) {
                                free(tempkm);
                        }
#endif
                }
                else {
                        abort();
                }
        }

        /* Parse command line parameters*/
        // 256�o�C�g�������R�}���h���C���p�����[�^�w�����������ABOF(Buffer Over Flow)��
        // �������o�O���C���B(2007.6.12 maya)
        Param = GetCommandLine();
        if (LoadTTSET()) {
                (*ParseParam)(Param, &ts, &(TopicName[0]));
        }
        FreeTTSET();

        // DPI Aware (��DPI����)
        if (pIsValidDpiAwarenessContext != NULL && pSetThreadDpiAwarenessContext != NULL) {
                char Temp[4];
                GetPrivateProfileString("Tera Term", "DPIAware", NULL, Temp, sizeof(Temp), ts.SetupFName);
                if (_stricmp(Temp, "on") == 0) {
                        if (pIsValidDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2) == TRUE) {
                                pSetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
                        }
                }
        }

        // duplicate session���w�������������A���L�����������R�s�[���� (2004.12.7 yutaka)
        if (ts.DuplicateSession == 1) {
                CopyShmemToTTSet(&ts);
        }

        InitKeyboard();
        SetKeyMap();

        /* window status */
        AdjustSize = TRUE;
        Minimized = FALSE;
        LButton = FALSE;
        MButton = FALSE;
        RButton = FALSE;
        DblClk = FALSE;
        AfterDblClk = FALSE;
        TplClk = FALSE;
        Hold = FALSE;
        FirstPaint = TRUE;
        ScrollLock = FALSE;  // �����l������ (2006.11.14 yutaka)
        Alpha = 255;
        IgnoreSizeMessage = FALSE;
#if UNICODE_DEBUG
        TipWinCodeDebug = NULL;
#endif

        // UnicodeDebugParam
        {
#if _DEBUG
                UnicodeDebugParam.CodePopupEnable = TRUE;
#else
                UnicodeDebugParam.CodePopupEnable = FALSE;
#endif
                UnicodeDebugParam.CodePopupKey1 = VK_CONTROL;
                UnicodeDebugParam.CodePopupKey2 = VK_CONTROL;
                UnicodeDebugParam.UseUnicodeApi = FALSE;
        UnicodeDebugParam.CodePageForANSIDraw = 932;
        }

        /* Initialize scroll buffer */
        UnicodeDebugParam.UseUnicodeApi = IsWindowsNTKernel() ? TRUE : FALSE;
        InitBuffer(UnicodeDebugParam.UseUnicodeApi);
        BuffSetDispCodePage(UnicodeDebugParam.CodePageForANSIDraw);

        InitDisp();

        if (ts.HideTitle>0) {
                Style = WS_VSCROLL | WS_HSCROLL |
                        WS_BORDER | WS_THICKFRAME | WS_POPUP;

#ifdef ALPHABLEND_TYPE2
                if(BGNoFrame)
                        Style &= ~(WS_BORDER | WS_THICKFRAME);
#endif
        }
        else
#ifdef WINDOW_MAXMIMUM_ENABLED
                Style = WS_VSCROLL | WS_HSCROLL |
                        WS_BORDER | WS_THICKFRAME |
                        WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX;
#else
                Style = WS_VSCROLL | WS_HSCROLL |
                        WS_BORDER | WS_THICKFRAME |
                        WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
#endif

        wc.style = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
        wc.lpfnWndProc = (WNDPROC)ProcStub;
        wc.cbClsExtra = 0;
        wc.cbWndExtra = 0;
        wc.hInstance = hInstance;
        wc.hIcon = NULL;
        //wc.hCursor = LoadCursor(NULL,IDC_IBEAM);
        wc.hCursor = NULL; // �}�E�X�J�[�\�������I�����X���� (2005.4.2 yutaka)
        wc.hbrBackground = NULL;
        wc.lpszMenuName = NULL;
        wc.lpszClassName = VTClassName;

        _RegisterClassW(&wc);
        m_hAccel = ::LoadAccelerators(hInstance, MAKEINTRESOURCE(IDR_ACC));

        if (ts.VTPos.x==CW_USEDEFAULT) {
                rect = rectDefault;
        }
        else {
                rect.left = ts.VTPos.x;
                rect.top = ts.VTPos.y;
                rect.right = rect.left + 100;
                rect.bottom = rect.top + 100;
        }
        CreateW(hInstance, VTClassName, L"Tera Term", Style, rect, NULL, NULL);

        /*--------- Init2 -----------------*/
        HVTWin = GetSafeHwnd();
        if (HVTWin == NULL) return;
        // register this window to the window list
        SerialNo = RegWin(HVTWin,NULL);

        logfile_lock_initialize();
        SetMouseCursor(ts.MouseCursorName);
        // ���P�[��������
        // wctomb ������
        setlocale(LC_ALL, ts.Locale);

#ifdef ALPHABLEND_TYPE2
//<!--by AKASI
        if(BGNoFrame && ts.HideTitle > 0) {
                DWORD ExStyle = (DWORD)::GetWindowLongPtr(HVTWin,GWL_EXSTYLE);
                ExStyle &= ~WS_EX_CLIENTEDGE;
                ::SetWindowLongPtr(HVTWin,GWL_EXSTYLE,ExStyle);
        }
//-->
#endif

        // USB�f�o�C�X�������m�o�^
        RegDeviceNotify(HVTWin);

        if (IsWindowsNT4()) {
                fuLoad = LR_VGACOLOR;
        }
        ::PostMessage(HVTWin,WM_SETICON,ICON_SMALL,
                      (LPARAM)LoadImage(hInstance,
                                        MAKEINTRESOURCE((ts.VTIcon!=IdIconDefault)?ts.VTIcon:IDI_VT),
                                        IMAGE_ICON,16,16,fuLoad));
        // Vista �� Aero �������� Alt+Tab �����������\���������A�C�R����
        // 16x16 �A�C�R�����g���������������������A�������A�C�R����
        // �Z�b�g���� (2008.9.3 maya)
        ::PostMessage(HVTWin,WM_SETICON,ICON_BIG,
                      (LPARAM)LoadImage(hInstance,
                                        MAKEINTRESOURCE((ts.VTIcon!=IdIconDefault)?ts.VTIcon:IDI_VT),
                                        IMAGE_ICON, 0, 0, fuLoad));

        SetCustomNotifyIcon(
                (HICON)LoadImage(
                        hInstance,
                        MAKEINTRESOURCE((ts.VTIcon!=IdIconDefault)?ts.VTIcon:IDI_VT),
                        IMAGE_ICON, 16, 16, LR_VGACOLOR|LR_SHARED));

        MainMenu = NULL;
        WinMenu = NULL;
        if ((ts.HideTitle==0) && (ts.PopupMenu==0)) {
                InitMenu(&MainMenu);
                ::SetMenu(HVTWin,MainMenu);
        }

        /* Reset Terminal */
        ResetTerminal();

        if ((ts.PopupMenu>0) || (ts.HideTitle>0)) {
                ::PostMessage(HVTWin,WM_USER_CHANGEMENU,0,0);
        }

        ChangeFont();

        ResetIME();

        BuffChangeWinSize(NumOfColumns,NumOfLines);

        ChangeTitle();
        /* Enable drag-drop */
        ::DragAcceptFiles(HVTWin,TRUE);

        if (ts.HideWindow>0) {
                if (strlen(TopicName)>0) {
                        InitDDE();
                        SendDDEReady();
                }
                FirstPaint = FALSE;
                Startup();
                return;
        }
        CmdShow = SW_SHOWDEFAULT;
        if (ts.Minimize>0) {
                CmdShow = SW_SHOWMINIMIZED;
        }
        SetWindowAlpha(ts.AlphaBlendActive);
        ShowWindow(CmdShow);
        ChangeCaret();

        // Tera Term���N�����AVirtual Store�����������������o���������B
        // (2015.11.14 yutaka)
        cv.VirtualStoreEnabled = GetVirtualStoreEnvironment();

        DropLists = NULL;
        DropListCount = 0;

#if UNICODE_DEBUG
        CtrlKeyState = 0;
#endif

        // TipWin
        TipWin = new CTipWin(hInstance);
        TipWin->Create(HVTWin);
}

/////////////////////////////////////////////////////////////////////////////
// CVTWindow destructor

CVTWindow::~CVTWindow()
{
        TipWin->Destroy();
        delete TipWin;
        TipWin = NULL;
}

/////////////////////////////////////////////////////////////////////////////

int CVTWindow::Parse()
{
        // added ScrollLock (2006.11.14 yutaka)
        if (LButton || MButton || RButton || ScrollLock)
                return 0;
        return (VTParse()); // Parse received characters
}

void CVTWindow::ButtonUp(BOOL Paste)
{
        BOOL disableBuffEndSelect = false;

        /* disable autoscrolling */
        ::KillTimer(HVTWin,IdScrollTimer);
        ReleaseCapture();

        if (ts.SelectOnlyByLButton &&
            (MButton || RButton)) {
                disableBuffEndSelect = true;
        }

        LButton = FALSE;
        MButton = FALSE;
        RButton = FALSE;
        DblClk = FALSE;
        TplClk = FALSE;
        CaretOn();

        // SelectOnlyByLButton �� on �� ���E�E�N���b�N����������
        // �o�b�t�@���I���������������A�I�����e���N���b�v�{�[�h��
        // �R�s�[�������������������C�� (2007.12.6 maya)
        if (!disableBuffEndSelect) {
                wchar_t *strW = BuffEndSelect();
                if (strW != NULL) {
                        CBSetTextW(HVTWin, strW, 0);
                }
        }

        if (Paste) {
                CBStartPaste(HVTWin, FALSE, BracketedPasteMode());

                // �X�N���[�����u�����Z�b�g
                if (WinOrgY != 0) {
                        DispVScroll(SCROLL_BOTTOM, 0);
                }
        }
}

void CVTWindow::ButtonDown(POINT p, int LMR)
{
        HMENU PopupMenu, PopupBase;
        BOOL mousereport;

        if ((LMR==IdLeftButton) && ControlKey() && (MainMenu==NULL) &&
            ((ts.MenuFlag & MF_NOPOPUP)==0)) {
                int i, numItems;
                char itemText[256];

                InitMenu(&PopupMenu);

                PopupBase = CreatePopupMenu();
                numItems = GetMenuItemCount(PopupMenu);

                for (i = 0; i < numItems; i++) {
                        HMENU submenu = GetSubMenu(PopupMenu, i);

                        if (submenu != NULL) {
                                InitMenuPopup(submenu);
                        }

                        if (GetMenuString(PopupMenu, i, itemText, sizeof(itemText), MF_BYPOSITION) != 0) {
                                int state = GetMenuState(PopupMenu, i, MF_BYPOSITION) &
                                            (MF_CHECKED | MF_DISABLED | MF_GRAYED | MF_HILITE |
                                             MF_MENUBARBREAK | MF_MENUBREAK | MF_SEPARATOR);

                                AppendMenu(PopupBase,
                                           submenu != NULL ? LOBYTE(state) | MF_POPUP : state,
                                           submenu != NULL ? (UINT_PTR)submenu : GetMenuItemID(PopupMenu, i),
                                           itemText);
                        }
                }

                ::ClientToScreen(HVTWin, &p);
                TrackPopupMenu(PopupBase,TPM_LEFTALIGN | TPM_LEFTBUTTON,
                               p.x,p.y,0,HVTWin,NULL);
                if (WinMenu!=NULL) {
                        DestroyMenu(WinMenu);
                        WinMenu = NULL;
                }
                DestroyMenu(PopupBase);
                DestroyMenu(PopupMenu);
                PopupMenu = 0;
                return;
        }

        mousereport = MouseReport(IdMouseEventBtnDown, LMR, p.x, p.y);
        if (mousereport) {
                ::SetCapture(m_hWnd);
                return;
        }

        // added ConfirmPasteMouseRButton (2007.3.17 maya)
        if ((LMR == IdRightButton) &&
                (ts.PasteFlag & CPF_DISABLE_RBUTTON) == 0 &&
                (ts.PasteFlag & CPF_CONFIRM_RBUTTON) != 0 &&
                cv.Ready &&
                !mousereport &&
                (SendVar==NULL) && (FileVar==NULL) &&
                (cv.PortType!=IdFile) &&
                (IsClipboardFormatAvailable(CF_TEXT) ||
                 IsClipboardFormatAvailable(CF_OEMTEXT))) {

                int i, numItems;
                char itemText[256];

                InitPasteMenu(&PopupMenu);
                PopupBase = CreatePopupMenu();
                numItems = GetMenuItemCount(PopupMenu);

                for (i = 0; i < numItems; i++) {
                        if (GetMenuString(PopupMenu, i, itemText, sizeof(itemText), MF_BYPOSITION) != 0) {
                                int state = GetMenuState(PopupMenu, i, MF_BYPOSITION) &
                                            (MF_CHECKED | MF_DISABLED | MF_GRAYED | MF_HILITE |
                                             MF_MENUBARBREAK | MF_MENUBREAK | MF_SEPARATOR);

                                AppendMenu(PopupBase, state,
                                           GetMenuItemID(PopupMenu, i), itemText);
                        }
                }

                ::ClientToScreen(HVTWin, &p);
                TrackPopupMenu(PopupBase,TPM_LEFTALIGN | TPM_LEFTBUTTON,
                               p.x,p.y,0,HVTWin,NULL);
                if (WinMenu!=NULL) {
                        DestroyMenu(WinMenu);
                        WinMenu = NULL;
                }
                DestroyMenu(PopupBase);
                DestroyMenu(PopupMenu);
                PopupMenu = 0;
                return;
        }

        if (AfterDblClk && (LMR==IdLeftButton) &&
            (abs(p.x-DblClkX)<=GetSystemMetrics(SM_CXDOUBLECLK)) &&
            (abs(p.y-DblClkY)<=GetSystemMetrics(SM_CYDOUBLECLK))) {
                /* triple click */
                ::KillTimer(HVTWin, IdDblClkTimer);
                AfterDblClk = FALSE;
                BuffTplClk(p.y);
                LButton = TRUE;
                TplClk = TRUE;
                /* for AutoScrolling */
                ::SetCapture(HVTWin);
                ::SetTimer(HVTWin, IdScrollTimer, 100, NULL);
        }
        else {
                if (! (LButton || MButton || RButton)) {
                        BOOL box = FALSE;

                        // select several pages of output from Tera Term window (2005.5.15 yutaka)
                        if (LMR == IdLeftButton && ShiftKey()) {
                                BuffSeveralPagesSelect(p.x, p.y);

                        } else {
                                // Select rectangular block with Alt Key. Delete Shift key.(2005.5.15 yutaka)
                                if (LMR == IdLeftButton && AltKey()) {
                                        box = TRUE;
                                }

                                // Starting the selection only by a left button.(2007.11.20 maya)
                                if (!ts.SelectOnlyByLButton ||
                                    (ts.SelectOnlyByLButton && LMR == IdLeftButton) ) {
                                        BuffStartSelect(p.x,p.y, box);
                                        TplClk = FALSE;

                                        /* for AutoScrolling */
                                        ::SetCapture(HVTWin);
                                        ::SetTimer(HVTWin, IdScrollTimer, 100, NULL);
                                }
                        }
                }

                switch (LMR) {
                        case IdRightButton:
                                RButton = TRUE;
                                break;
                        case IdMiddleButton:
                                MButton = TRUE;
                                break;
                        case IdLeftButton:
                                LButton = TRUE;
                                break;
                }
        }
}

// LogMeIn.exe -> LogMeTT.exe �����l�[�� (2005.2.21 yutaka)
static char LogMeTTMenuString[] = "Log&MeTT";
static char LogMeTT[MAX_PATH];

#define IS_LOGMETT_NOTFOUND     0
#define IS_LOGMETT_FOUND        1
#define IS_LOGMETT_UNKNOWN      2

static BOOL isLogMeTTExist()
{
        const char *LogMeTTexename = "LogMeTT.exe";
        LONG result;
        HKEY key;
        int inregist = 0;
        DWORD dwSize;
        DWORD dwType;
        DWORD dwDisposition;
        char *path;

        static int status = IS_LOGMETT_UNKNOWN;

        if (status != IS_LOGMETT_UNKNOWN) {
                return status == IS_LOGMETT_FOUND;
        }

        /* LogMeTT 2.9.6���������W�X�g�����C���X�g�[���p�X�����������B*/
        result = RegCreateKeyEx(HKEY_CURRENT_USER, "Software\\LogMeTT", 0, NULL,
                                REG_OPTION_NON_VOLATILE, KEY_READ, NULL, &key, &dwDisposition);
        if (result == ERROR_SUCCESS) {
                result = RegQueryValueEx(key, "InstallPath", NULL, &dwType, NULL, &dwSize);
                if (result == ERROR_SUCCESS) {
                        path = (char *)malloc(dwSize);
                        if (path != NULL) {
                                result = RegQueryValueEx(key, "InstallPath", NULL, &dwType, (LPBYTE)path, &dwSize);
                                if (result == ERROR_SUCCESS) {
                                        inregist = 1;
                                        strncpy_s(LogMeTT, sizeof(LogMeTT), path, _TRUNCATE);
                                }
                                free(path);
                        }
                }
                RegCloseKey(key);
        }

        if (inregist == 0) {
                strncpy_s(LogMeTT, sizeof(LogMeTT), ts.HomeDir, _TRUNCATE);
                AppendSlash(LogMeTT, sizeof(LogMeTT));
                strncat_s(LogMeTT, sizeof(LogMeTT), LogMeTTexename, _TRUNCATE);
        }

        if (_access(LogMeTT, 0) == -1) {
                status = IS_LOGMETT_NOTFOUND;
                return FALSE;
        }
        status = IS_LOGMETT_FOUND;
        return TRUE;
}

void CVTWindow::InitMenu(HMENU *Menu)
{
        static const DlgTextInfo MenuTextInfo[] = {
                { ID_FILE, "MENU_FILE" },
                { ID_EDIT, "MENU_EDIT" },
                { ID_SETUP, "MENU_SETUP" },
                { ID_CONTROL, "MENU_CONTROL" },
                { ID_HELPMENU, "MENU_HELP" },
        };
        static const DlgTextInfo FileMenuTextInfo[] = {
                { ID_FILE_NEWCONNECTION, "MENU_FILE_NEW" },
                { ID_FILE_DUPLICATESESSION, "MENU_FILE_DUPLICATE" },
                { ID_FILE_CYGWINCONNECTION, "MENU_FILE_GYGWIN" },
                { ID_FILE_LOG, "MENU_FILE_LOG" },
                { ID_FILE_COMMENTTOLOG, "MENU_FILE_COMMENTLOG" },
                { ID_FILE_VIEWLOG, "MENU_FILE_VIEWLOG" },
                { ID_FILE_SHOWLOGDIALOG, "MENU_FILE_SHOWLOGDIALOG" },
                { ID_FILE_PAUSELOG, "MENU_FILE_PAUSELOG" },
                { ID_FILE_STOPLOG, "MENU_FILE_STOPLOG" },
                { ID_FILE_SENDFILE, "MENU_FILE_SENDFILE" },
                { ID_FILE_REPLAYLOG, "MENU_FILE_REPLAYLOG" },
                { ID_FILE_CHANGEDIR, "MENU_FILE_CHANGEDIR" },
                { ID_FILE_LOGMEIN, "MENU_FILE_LOGMETT" },
                { ID_FILE_PRINT2, "MENU_FILE_PRINT" },
                { ID_FILE_DISCONNECT, "MENU_FILE_DISCONNECT" },
                { ID_FILE_EXIT, "MENU_FILE_EXIT" },
                { ID_FILE_EXITALL, "MENU_FILE_EXITALL" },
                { 11, "MENU_TRANS" },
                { ID_FILE_KERMITRCV, "MENU_TRANS_KERMIT_RCV" },
                { ID_FILE_KERMITGET, "MENU_TRANS_KERMIT_GET" },
                { ID_FILE_KERMITSEND, "MENU_TRANS_KERMIT_SEND" },
                { ID_FILE_KERMITFINISH, "MENU_TRANS_KERMIT_FINISH" },
                { ID_FILE_XRCV, "MENU_TRANS_X_RCV" },
                { ID_FILE_XSEND, "MENU_TRANS_X_SEND" },
                { ID_FILE_YRCV, "MENU_TRANS_Y_RCV" },
                { ID_FILE_YSEND, "MENU_TRANS_Y_SEND" },
                { ID_FILE_ZRCV, "MENU_TRANS_Z_RCV" },
                { ID_FILE_ZSEND, "MENU_TRANS_Z_SEND" },
                { ID_FILE_BPRCV, "MENU_TRANS_BP_RCV" },
                { ID_FILE_BPSEND, "MENU_TRANS_BP_SEND" },
                { ID_FILE_QVRCV, "MENU_TRANS_QV_RCV" },
                { ID_FILE_QVSEND, "MENU_TRANS_QV_SEND" },
        };
        static const DlgTextInfo EditMenuTextInfo[] = {
                { ID_EDIT_COPY2, "MENU_EDIT_COPY" },
                { ID_EDIT_COPYTABLE, "MENU_EDIT_COPYTABLE" },
                { ID_EDIT_PASTE2, "MENU_EDIT_PASTE" },
                { ID_EDIT_PASTECR, "MENU_EDIT_PASTECR" },
                { ID_EDIT_CLEARSCREEN, "MENU_EDIT_CLSCREEN" },
                { ID_EDIT_CLEARBUFFER, "MENU_EDIT_CLBUFFER" },
                { ID_EDIT_CANCELSELECT, "MENU_EDIT_CANCELSELECT" },
                { ID_EDIT_SELECTSCREEN, "MENU_EDIT_SELECTSCREEN" },
                { ID_EDIT_SELECTALL, "MENU_EDIT_SELECTALL" },
        };
        static const DlgTextInfo SetupMenuTextInfo[] = {
                { ID_SETUP_TERMINAL, "MENU_SETUP_TERMINAL" },
                { ID_SETUP_WINDOW, "MENU_SETUP_WINDOW" },
                { ID_SETUP_FONT, "MENU_SETUP_FONT" },
                { ID_SETUP_DLG_FONT, "MENU_SETUP_DIALOG_FONT" },
                { 2, "MENU_SETUP_FONT_SUBMENU" },
                { ID_SETUP_KEYBOARD, "MENU_SETUP_KEYBOARD" },
                { ID_SETUP_SERIALPORT, "MENU_SETUP_SERIALPORT" },
                { ID_SETUP_TCPIP, "MENU_SETUP_TCPIP" },
                { ID_SETUP_GENERAL, "MENU_SETUP_GENERAL" },
                { ID_SETUP_ADDITIONALSETTINGS, "MENU_SETUP_ADDITION" },
                { ID_SETUP_SAVE, "MENU_SETUP_SAVE" },
                { ID_SETUP_RESTORE, "MENU_SETUP_RESTORE" },
                { ID_OPEN_SETUP, "MENU_SETUP_OPENSETUP" },
                { ID_SETUP_LOADKEYMAP, "MENU_SETUP_LOADKEYMAP" },
        };
        static const DlgTextInfo ControlMenuTextInfo[] = {
                { ID_CONTROL_RESETTERMINAL, "MENU_CONTROL_RESET" },
                { ID_CONTROL_RESETREMOTETITLE, "MENU_CONTROL_RESETTITLE" },
                { ID_CONTROL_AREYOUTHERE, "MENU_CONTROL_AREYOUTHERE" },
                { ID_CONTROL_SENDBREAK, "MENU_CONTROL_SENDBREAK" },
                { ID_CONTROL_RESETPORT, "MENU_CONTROL_RESETPORT" },
                { ID_CONTROL_BROADCASTCOMMAND, "MENU_CONTROL_BROADCAST" },
                { ID_CONTROL_OPENTEK, "MENU_CONTROL_OPENTEK" },
                { ID_CONTROL_CLOSETEK, "MENU_CONTROL_CLOSETEK" },
                { ID_CONTROL_MACRO, "MENU_CONTROL_MACRO" },
                { ID_CONTROL_SHOW_MACRO, "MENU_CONTROL_SHOW_MACRO" },
        };
        static const DlgTextInfo HelpMenuTextInfo[] = {
                { ID_HELP_INDEX2, "MENU_HELP_INDEX" },
                { ID_HELP_ABOUT, "MENU_HELP_ABOUT" },
        };

        HMENU hMenu = LoadMenu(m_hInst, MAKEINTRESOURCE(IDR_MENU));
        *Menu = hMenu;

        FileMenu = GetSubMenu(hMenu,ID_FILE);
        TransMenu = GetSubMenu(FileMenu,ID_TRANSFER);
        EditMenu = GetSubMenu(hMenu,ID_EDIT);
        SetupMenu = GetSubMenu(hMenu,ID_SETUP);
        ControlMenu = GetSubMenu(hMenu,ID_CONTROL);
        HelpMenu = GetSubMenu(hMenu,ID_HELPMENU);

        SetDlgMenuTexts(hMenu, MenuTextInfo, _countof(MenuTextInfo), ts.UILanguageFile);

        /* LogMeTT ���������m�F�������j���[���������� */
        if (isLogMeTTExist()) {
                ::InsertMenu(FileMenu, ID_FILE_PRINT2, MF_STRING | MF_ENABLED | MF_BYCOMMAND,
                             ID_FILE_LOGMEIN, LogMeTTMenuString);
                ::InsertMenu(FileMenu, ID_FILE_PRINT2, MF_SEPARATOR, NULL, NULL);
        }

        SetDlgMenuTexts(FileMenu, FileMenuTextInfo, _countof(FileMenuTextInfo), ts.UILanguageFile);
        SetDlgMenuTexts(EditMenu, EditMenuTextInfo, _countof(EditMenuTextInfo), ts.UILanguageFile);
        SetDlgMenuTexts(SetupMenu, SetupMenuTextInfo, _countof(SetupMenuTextInfo), ts.UILanguageFile);
        SetDlgMenuTexts(ControlMenu, ControlMenuTextInfo, _countof(ControlMenuTextInfo), ts.UILanguageFile);
        SetDlgMenuTexts(HelpMenu, HelpMenuTextInfo, _countof(HelpMenuTextInfo), ts.UILanguageFile);

        if ((ts.MenuFlag & MF_SHOWWINMENU) !=0) {
                wchar_t uimsg[MAX_UIMSG];
                WinMenu = CreatePopupMenu();
                get_lang_msgW("MENU_WINDOW", uimsg, _countof(uimsg),
                                          L"&Window", ts.UILanguageFile);
                _InsertMenuW(hMenu, ID_HELPMENU,
                                         MF_STRING | MF_ENABLED | MF_POPUP | MF_BYPOSITION,
                                         (UINT_PTR)WinMenu, uimsg);
        }

        TTXModifyMenu(hMenu); /* TTPLUG */
}

void CVTWindow::InitMenuPopup(HMENU SubMenu)
{
        if ( SubMenu == FileMenu )
        {
                if (ts.DisableMenuNewConnection) {
                        if ( Connecting || cv.Open ) {
                                EnableMenuItem(FileMenu,ID_FILE_NEWCONNECTION,MF_BYCOMMAND | MF_GRAYED);
                        }
                        else {
                                EnableMenuItem(FileMenu,ID_FILE_NEWCONNECTION,MF_BYCOMMAND | MF_ENABLED);
                        }
                }
                else {
                        if ( Connecting ) {
                                EnableMenuItem(FileMenu,ID_FILE_NEWCONNECTION,MF_BYCOMMAND | MF_GRAYED);
                        }
                        else {
                                EnableMenuItem(FileMenu,ID_FILE_NEWCONNECTION,MF_BYCOMMAND | MF_ENABLED);
                        }
                }

                if ( (! cv.Ready) || (SendVar!=NULL) ||
                     (FileVar!=NULL) || (cv.PortType==IdFile) ) {
                        EnableMenuItem(FileMenu,ID_FILE_SENDFILE,MF_BYCOMMAND | MF_GRAYED);
                        EnableMenuItem(FileMenu,ID_TRANSFER,MF_BYPOSITION | MF_GRAYED); /* Transfer */
                        EnableMenuItem(FileMenu,ID_FILE_CHANGEDIR,MF_BYCOMMAND | MF_GRAYED);
                        EnableMenuItem(FileMenu,ID_FILE_DISCONNECT,MF_BYCOMMAND | MF_GRAYED);
                        EnableMenuItem(FileMenu,ID_FILE_DUPLICATESESSION,MF_BYCOMMAND | MF_GRAYED);
                }
                else {
                        EnableMenuItem(FileMenu,ID_FILE_SENDFILE,MF_BYCOMMAND | MF_ENABLED);
                        EnableMenuItem(FileMenu,ID_TRANSFER,MF_BYPOSITION | MF_ENABLED); /* Transfer */
                        EnableMenuItem(FileMenu,ID_FILE_CHANGEDIR,MF_BYCOMMAND | MF_ENABLED);
                        EnableMenuItem(FileMenu,ID_FILE_DISCONNECT,MF_BYCOMMAND | MF_ENABLED);
                        if (ts.DisableMenuDuplicateSession) {
                                EnableMenuItem(FileMenu,ID_FILE_DUPLICATESESSION,MF_BYCOMMAND | MF_GRAYED);
                        }
                        else {
                                EnableMenuItem(FileMenu,ID_FILE_DUPLICATESESSION,MF_BYCOMMAND | MF_ENABLED);
                        }
                }

                // �V�K���j���[������ (2004.12.5 yutaka)
                EnableMenuItem(FileMenu,ID_FILE_CYGWINCONNECTION,MF_BYCOMMAND | MF_ENABLED);
                EnableMenuItem(FileMenu,ID_FILE_TERATERMMENU,MF_BYCOMMAND | MF_ENABLED);
                EnableMenuItem(FileMenu,ID_FILE_LOGMEIN,MF_BYCOMMAND | MF_ENABLED);

                // XXX: �������u�����������Alog���O���C�����������B (2005.2.1 yutaka)
                if (FLogIsOpend()) { // ���O�������[�h������
                        EnableMenuItem(FileMenu,ID_FILE_LOG,MF_BYCOMMAND | MF_GRAYED);
                        EnableMenuItem(FileMenu,ID_FILE_COMMENTTOLOG, MF_BYCOMMAND | MF_ENABLED);
                        EnableMenuItem(FileMenu,ID_FILE_VIEWLOG, MF_BYCOMMAND | MF_ENABLED);
                        EnableMenuItem(FileMenu,ID_FILE_SHOWLOGDIALOG, MF_BYCOMMAND | MF_ENABLED);
                        EnableMenuItem(FileMenu,ID_FILE_PAUSELOG, MF_BYCOMMAND | MF_ENABLED);
                        EnableMenuItem(FileMenu,ID_FILE_STOPLOG, MF_BYCOMMAND | MF_ENABLED);
                        if (FLogIsPause()) {
                                CheckMenuItem(FileMenu,ID_FILE_PAUSELOG, MF_BYCOMMAND | MF_CHECKED);
                        }
                        else {
                                CheckMenuItem(FileMenu,ID_FILE_PAUSELOG, MF_BYCOMMAND | MF_UNCHECKED);
                        }
                } else {
                        EnableMenuItem(FileMenu,ID_FILE_LOG,MF_BYCOMMAND | MF_ENABLED);
                        EnableMenuItem(FileMenu,ID_FILE_COMMENTTOLOG, MF_BYCOMMAND | MF_GRAYED);
                        EnableMenuItem(FileMenu,ID_FILE_VIEWLOG, MF_BYCOMMAND | MF_GRAYED);
                        EnableMenuItem(FileMenu,ID_FILE_SHOWLOGDIALOG, MF_BYCOMMAND | MF_GRAYED);
                        EnableMenuItem(FileMenu,ID_FILE_PAUSELOG, MF_BYCOMMAND | MF_GRAYED);
                        EnableMenuItem(FileMenu,ID_FILE_STOPLOG, MF_BYCOMMAND | MF_GRAYED);

                        CheckMenuItem(FileMenu,ID_FILE_PAUSELOG, MF_BYCOMMAND | MF_UNCHECKED);
                }

        }
        else if ( SubMenu == TransMenu )
        {
                if ((cv.PortType==IdSerial) &&
                    ((ts.DataBit==IdDataBit7) || (ts.Flow==IdFlowX))) {
                        EnableMenuItem(TransMenu,1,MF_BYPOSITION | MF_GRAYED);  /* XMODEM */
                        EnableMenuItem(TransMenu,4,MF_BYPOSITION | MF_GRAYED);  /* Quick-VAN */
                }
                else {
                        EnableMenuItem(TransMenu,1,MF_BYPOSITION | MF_ENABLED); /* XMODEM */
                        EnableMenuItem(TransMenu,4,MF_BYPOSITION | MF_ENABLED); /* Quick-VAN */
                }
                if ((cv.PortType==IdSerial) &&
                    (ts.DataBit==IdDataBit7)) {
                        EnableMenuItem(TransMenu,2,MF_BYPOSITION | MF_GRAYED); /* ZMODEM */
                        EnableMenuItem(TransMenu,3,MF_BYPOSITION | MF_GRAYED); /* B-Plus */
                }
                else {
                        EnableMenuItem(TransMenu,2,MF_BYPOSITION | MF_ENABLED); /* ZMODEM */
                        EnableMenuItem(TransMenu,3,MF_BYPOSITION | MF_ENABLED); /* B-Plus */
                }
        }
        else if (SubMenu == EditMenu)
        {
                if (Selected) {
                        EnableMenuItem(EditMenu,ID_EDIT_COPY2,MF_BYCOMMAND | MF_ENABLED);
                        EnableMenuItem(EditMenu,ID_EDIT_COPYTABLE,MF_BYCOMMAND | MF_ENABLED);
                }
                else {
                        EnableMenuItem(EditMenu,ID_EDIT_COPY2,MF_BYCOMMAND | MF_GRAYED);
                        EnableMenuItem(EditMenu,ID_EDIT_COPYTABLE,MF_BYCOMMAND | MF_GRAYED);
                }
                if (cv.Ready &&
                    (SendVar==NULL) && (FileVar==NULL) &&
                    (cv.PortType!=IdFile) &&
                    (IsClipboardFormatAvailable(CF_TEXT) ||
                    IsClipboardFormatAvailable(CF_OEMTEXT))) {
                        EnableMenuItem(EditMenu,ID_EDIT_PASTE2,MF_BYCOMMAND | MF_ENABLED);
                        EnableMenuItem(EditMenu,ID_EDIT_PASTECR,MF_BYCOMMAND | MF_ENABLED);
                }
                else {
                        EnableMenuItem(EditMenu,ID_EDIT_PASTE2,MF_BYCOMMAND | MF_GRAYED);
                        EnableMenuItem(EditMenu,ID_EDIT_PASTECR,MF_BYCOMMAND | MF_GRAYED);
                }
        }
        else if (SubMenu == SetupMenu)
                /*
                 * �l�b�g���[�N������(TCP/IP���I������������������)���V���A���|�[�g
                 * (ID_SETUP_SERIALPORT)�����j���[���I�����������������������������A
                 * �����K�[�h���O���A�V���A���|�[�g�����_�C�A���O�����V���������������������������B
                 */
                if ((SendVar!=NULL) || (FileVar!=NULL) || Connecting) {
                        EnableMenuItem(SetupMenu,ID_SETUP_SERIALPORT,MF_BYCOMMAND | MF_GRAYED);
                }
                else {
                        EnableMenuItem(SetupMenu,ID_SETUP_SERIALPORT,MF_BYCOMMAND | MF_ENABLED);
                }

        else if (SubMenu == ControlMenu)
        {
                if (cv.Ready &&
                    (SendVar==NULL) && (FileVar==NULL)) {
                        if (ts.DisableMenuSendBreak) {
                                EnableMenuItem(ControlMenu,ID_CONTROL_SENDBREAK,MF_BYCOMMAND | MF_GRAYED);
                        }
                        else {
                                EnableMenuItem(ControlMenu,ID_CONTROL_SENDBREAK,MF_BYCOMMAND | MF_ENABLED);
                        }
                        if (cv.PortType==IdSerial) {
                                EnableMenuItem(ControlMenu,ID_CONTROL_RESETPORT,MF_BYCOMMAND | MF_ENABLED);
                        }
                        else {
                                EnableMenuItem(ControlMenu,ID_CONTROL_RESETPORT,MF_BYCOMMAND | MF_GRAYED);
                        }
                }
                else {
                        EnableMenuItem(ControlMenu,ID_CONTROL_SENDBREAK,MF_BYCOMMAND | MF_GRAYED);
                        EnableMenuItem(ControlMenu,ID_CONTROL_RESETPORT,MF_BYCOMMAND | MF_GRAYED);
                }

                if (cv.Ready && cv.TelFlag && (FileVar==NULL)) {
                        EnableMenuItem(ControlMenu,ID_CONTROL_AREYOUTHERE,MF_BYCOMMAND | MF_ENABLED);
                }
                else {
                        EnableMenuItem(ControlMenu,ID_CONTROL_AREYOUTHERE,MF_BYCOMMAND | MF_GRAYED);
                }

                if (HTEKWin==0) {
                        EnableMenuItem(ControlMenu,ID_CONTROL_CLOSETEK,MF_BYCOMMAND | MF_GRAYED);
                }
                else {
                        EnableMenuItem(ControlMenu,ID_CONTROL_CLOSETEK,MF_BYCOMMAND | MF_ENABLED);
                }

                if (DDELog || (FileVar!=NULL)) {
                        EnableMenuItem(ControlMenu,ID_CONTROL_MACRO,MF_BYCOMMAND | MF_GRAYED);
                        EnableMenuItem(ControlMenu,ID_CONTROL_SHOW_MACRO,MF_BYCOMMAND | MF_ENABLED);
                }
                else {
                        EnableMenuItem(ControlMenu,ID_CONTROL_MACRO,MF_BYCOMMAND | MF_ENABLED);
                        EnableMenuItem(ControlMenu,ID_CONTROL_SHOW_MACRO,MF_BYCOMMAND | MF_GRAYED);
                }

        }
        else if (SubMenu == WinMenu)
        {
                SetWinMenu(WinMenu, ts.UIMsg, sizeof(ts.UIMsg), ts.UILanguageFile, 1);
        }

        TTXModifyPopupMenu(SubMenu); /* TTPLUG */
}

// added ConfirmPasteMouseRButton (2007.3.17 maya)
void CVTWindow::InitPasteMenu(HMENU *Menu)
{
        static const DlgTextInfo MenuTextInfo[] = {
                { ID_EDIT_PASTE2, "MENU_EDIT_PASTE" },
                { ID_EDIT_PASTECR, "MENU_EDIT_PASTECR" },
        };
        *Menu = LoadMenu(m_hInst,
                         MAKEINTRESOURCE(IDR_PASTEMENU));
        SetDlgMenuTexts(*Menu, MenuTextInfo, _countof(MenuTextInfo), ts.UILanguageFile);
}

void CVTWindow::ResetSetup()
{
        ChangeFont();
        BuffChangeWinSize(WinWidth,WinHeight);
        ChangeCaret();

        if (cv.Ready) {
                ts.PortType = cv.PortType;
                if (cv.PortType==IdSerial) {
                        /* if serial port, change port parameters */
                        ts.ComPort = cv.ComPort;
                        CommResetSerial(&ts, &cv, TRUE);
                }
        }

        /* setup terminal */
        SetupTerm();

        /* background and ANSI color */
#ifdef ALPHABLEND_TYPE2
        BGInitialize(FALSE);
        BGSetupPrimary(TRUE);
        // 2006/03/17 by 337 : Alpha�l���������X
        // Layered��������������������������������
        //
        // AlphaBlend ���������f�����������������B
        // (2016.12.24 yutaka)
        SetWindowAlpha(ts.AlphaBlendActive);
#else
        DispApplyANSIColor();
#endif
        DispSetNearestColors(IdBack, IdFore+8, NULL);

        /* setup window */
        ChangeWin();

        /* Language & IME */
        ResetIME();

        /* change TEK window */
        if (pTEKWin != NULL)
                ((CTEKWindow *)pTEKWin)->RestoreSetup();
}

void CVTWindow::RestoreSetup()
{
        char TempDir[MAXPATHLEN];
        char TempName[MAX_PATH];

        if ( strlen(ts.SetupFName)==0 ) {
                return;
        }

        ExtractFileName(ts.SetupFName,TempName,sizeof(TempName));
        ExtractDirName(ts.SetupFName,TempDir);
        if (TempDir[0]==0)
                strncpy_s(TempDir, sizeof(TempDir),ts.HomeDir, _TRUNCATE);
        FitFileName(TempName,sizeof(TempName),".INI");

        strncpy_s(ts.SetupFName, sizeof(ts.SetupFName),TempDir, _TRUNCATE);
        AppendSlash(ts.SetupFName,sizeof(ts.SetupFName));
        strncat_s(ts.SetupFName,sizeof(ts.SetupFName),TempName,_TRUNCATE);

        if (LoadTTSET()) {
                (*ReadIniFile)(ts.SetupFName,&ts);
        }
        FreeTTSET();

#if 0
        ChangeDefaultSet(&ts,NULL);
#endif

        ResetSetup();
}

/* called by the [Setup] Terminal command */
void CVTWindow::SetupTerm()
{
        if (ts.Language==IdJapanese || ts.Language==IdKorean || ts.Language==IdUtf8) {
                ResetCharSet();
        }
        cv.CRSend = ts.CRSend;

        // for russian mode
        cv.RussHost = ts.RussHost;
        cv.RussClient = ts.RussClient;

        if (cv.Ready) {
                if (cv.TelFlag && (ts.TelEcho>0)) {
                        TelChangeEcho();
                }
                _free_locale(cv.locale);
                cv.locale = _create_locale(LC_ALL, cv.Locale);
        }

        if ((ts.TerminalWidth!=NumOfColumns) ||
            (ts.TerminalHeight!=NumOfLines-StatusLine)) {
                LockBuffer();
                HideStatusLine();
                ChangeTerminalSize(ts.TerminalWidth,
                                   ts.TerminalHeight);
                UnlockBuffer();
        }
        else if ((ts.TermIsWin>0) &&
                 ((ts.TerminalWidth!=WinWidth) ||
                  (ts.TerminalHeight!=WinHeight-StatusLine))) {
                BuffChangeWinSize(ts.TerminalWidth,ts.TerminalHeight+StatusLine);
        }

        ChangeTerminalID();
}

void CVTWindow::Startup()
{
        /* auto log */
        /* OnCommOpen ���J�n�������������������J�n������ (2007.5.14 maya) */

        if ((TopicName[0]==0) && (ts.MacroFN[0]!=0)) {
                // start the macro specified in the command line or setup file
                RunMacro(ts.MacroFN,TRUE);
                ts.MacroFN[0] = 0;
        }
        else {// start connection
                if (TopicName[0]!=0) {
                        cv.NoMsg=1; /* suppress error messages */
                }
                ::PostMessage(HVTWin,WM_USER_COMMSTART,0,0);
        }
}

void CVTWindow::OpenTEK()
{
        ActiveWin = IdTEK;
        if (HTEKWin==NULL) {
                pTEKWin = new CTEKWindow(m_hInst);
        }
        else {
                ::ShowWindow(HTEKWin,SW_SHOWNORMAL);
                ::SetFocus(HTEKWin);
        }
}

/////////////////////////////////////////////////////////////////////////////
// CVTWindow message handler

BOOL CVTWindow::OnCommand(WPARAM wParam, LPARAM lParam)
{
        WORD wID = LOWORD(wParam);
        WORD wNotifyCode = HIWORD(wParam);

        if (wNotifyCode==1) {
                switch (wID) {
                        case ID_ACC_SENDBREAK:
                                // added DisableAcceleratorSendBreak (2007.3.17 maya)
                                if (!ts.DisableAcceleratorSendBreak)
                                        OnControlSendBreak();
                                return TRUE;
                        case ID_ACC_AREYOUTHERE:
                                OnControlAreYouThere();
                                return TRUE;
                }
                if (ActiveWin==IdVT) {
                        switch (wID) {
                                case ID_ACC_NEWCONNECTION:
                                        if (ts.AcceleratorNewConnection)
                                                OnFileNewConnection();
                                        return TRUE;
                                case ID_ACC_DUPLICATESESSION:
                                        // added DisableAcceleratorDuplicateSession (2009.4.6 maya)
                                        if (!ts.DisableAcceleratorDuplicateSession)
                                                OnDuplicateSession();
                                        return TRUE;
                                case ID_ACC_CYGWINCONNECTION:
                                        if (ts.AcceleratorCygwinConnection)
                                                OnCygwinConnection();
                                        return TRUE;
                                case ID_ACC_DISCONNECT:
                                        Disconnect(TRUE);
                                        return TRUE;
                                case ID_ACC_COPY:
                                        OnEditCopy();
                                        return TRUE;
                                case ID_ACC_PASTECR:
                                        OnEditPasteCR();
                                        return TRUE;
                                case ID_ACC_PASTE:
                                        OnEditPaste();
                                        return TRUE;
                                case ID_ACC_PRINT:
                                        OnFilePrint();
                                        return TRUE;
                                case ID_ACC_EXIT:
                                        OnFileExit();
                                        return TRUE;
                        }
                }
                else { // transfer accelerator message to TEK win
                        switch (wID) {
                                case ID_ACC_COPY:
                                        ::PostMessage(HTEKWin,WM_COMMAND,ID_TEKEDIT_COPY,0);
                                        return TRUE;
                                case ID_ACC_PASTECR:
                                        ::PostMessage(HTEKWin,WM_COMMAND,ID_TEKEDIT_PASTECR,0);
                                        return TRUE;
                                case ID_ACC_PASTE:
                                        ::PostMessage(HTEKWin,WM_COMMAND,ID_TEKEDIT_PASTE,0);
                                        return TRUE;
                                case ID_ACC_PRINT:
                                        ::PostMessage(HTEKWin,WM_COMMAND,ID_TEKFILE_PRINT,0);
                                        return TRUE;
                                case ID_ACC_EXIT:
                                        ::PostMessage(HTEKWin,WM_COMMAND,ID_TEKFILE_EXIT,0);
                                        return TRUE;
                        }
                }
        }

        if ((wID>=ID_WINDOW_1) && (wID<ID_WINDOW_1+9)) {
                SelectWin(wID-ID_WINDOW_1);
                return TRUE;
        }
        else {
                if (TTXProcessCommand(HVTWin, wID)) {
                        return TRUE;
                }
                else { /* TTPLUG */
                        return TTCFrameWnd::OnCommand(wParam, lParam);
                }
        }
}

void CVTWindow::OnActivate(UINT nState, HWND pWndOther, BOOL bMinimized)
{
        DispSetActive(nState!=WA_INACTIVE);
        if (nState == WA_INACTIVE) {
                SetWindowAlpha(ts.AlphaBlendInactive);
        } else {
                SetWindowAlpha(ts.AlphaBlendActive);
        }
}

void CVTWindow::OnChar(WPARAM nChar, UINT nRepCnt, UINT nFlags)
{
        unsigned int i;

        if (!KeybEnabled || (TalkStatus!=IdTalkKeyb)) {
                return;
        }

        if (MetaKey(ts.MetaKey)) {
                ::PostMessage(HVTWin,WM_SYSCHAR,nChar,MAKELONG(nRepCnt,nFlags));
                return;
        }

#if UNICODE_INTERNAL_BUFF
        for (i=1 ; i<=nRepCnt ; i++) {
                wchar_t u16 = nChar;
                CommTextOutW(&cv,&u16,1);
                if (ts.LocalEcho>0) {
                        CommTextEchoW(&cv,&u16,1);
                }
        }
#else
        {
                char Code = nChar;
                if ((ts.Language==IdRussian) &&
                        ((BYTE)Code>=128)) {
                        Code = (char)RussConv(ts.RussKeyb,ts.RussClient,(BYTE)Code);
                }

                for (i=1 ; i<=nRepCnt ; i++) {
                        CommTextOut(&cv,&Code,1);
                        if (ts.LocalEcho>0) {
                                CommTextEcho(&cv,&Code,1);
                        }
                }
        }
#endif

        // �X�N���[�����u�����Z�b�g
        if (WinOrgY != 0) {
                DispVScroll(SCROLL_BOTTOM, 0);
        }
}

LRESULT CVTWindow::OnUniChar(WPARAM wParam, LPARAM lParam)
{
        if (wParam == UNICODE_NOCHAR) {
                // �������b�Z�[�W���T�|�[�g�����������e�X�g��������������������
                return TRUE;
        }

        char32_t u32 = (char32_t)wParam;
        wchar_t strW[2];
        size_t u16_len = UTF32ToUTF16(u32, strW, _countof(strW));
        CommTextOutW(&cv, strW, u16_len);
        if (ts.LocalEcho > 0) {
                CommTextEchoW(&cv, strW, u16_len);
        }

        return FALSE;
}

/* copy from ttset.c*/
static void WriteInt2(const char *Sect, const char *Key, const char *FName, int i1, int i2)
{
        char Temp[32];
        _snprintf_s(Temp, sizeof(Temp), _TRUNCATE, "%d,%d", i1, i2);
        WritePrivateProfileString(Sect, Key, Temp, FName);
}

static void SaveVTPos()
{
#define Section "Tera Term"
        if (ts.SaveVTWinPos) {
                /* VT win position */
                WriteInt2(Section, "VTPos", ts.SetupFName, ts.VTPos.x, ts.VTPos.y);

                /* VT terminal size  */
                WriteInt2(Section, "TerminalSize", ts.SetupFName,
                          ts.TerminalWidth, ts.TerminalHeight);
        }
}

void CVTWindow::OnClose()
{
        if ((HTEKWin!=NULL) && ! ::IsWindowEnabled(HTEKWin)) {
                MessageBeep(0);
                return;
        }

        if (cv.Ready && (cv.PortType==IdTCPIP) &&
            ((ts.PortFlag & PF_CONFIRMDISCONN) != 0) &&
            ! CloseTT) {
                wchar_t uimsg[MAX_UIMSG];
                get_lang_msgW("MSG_DISCONNECT_CONF", uimsg, _countof(uimsg),
                                          L"Disconnect?", ts.UILanguageFile);
                int result = _MessageBoxW(HVTWin, uimsg, L"Tera Term",
                                                                  MB_OKCANCEL | MB_ICONEXCLAMATION | MB_DEFBUTTON2);
                if (result == IDCANCEL) {
                        return;
                }
        }

        FLogClose();
        FileTransEnd(0);
        ProtoEnd();

        SaveVTPos();
        DestroyWindow();
}

// �STera Term���I�����w������
void CVTWindow::OnAllClose()
{
        // ���R�I���������������������A�����������[�U���������������o�������������B
        // (2013.8.17 yutaka)
        wchar_t uimsg[MAX_UIMSG];

        get_lang_msgW("MSG_ALL_TERMINATE_CONF", uimsg, _countof(uimsg), L"Terminate ALL Tera Term(s)?", ts.UILanguageFile);
        if (_MessageBoxW(HVTWin, uimsg, L"Tera Term", MB_OKCANCEL | MB_ICONERROR | MB_DEFBUTTON2) == IDCANCEL)
                return;

        BroadcastClosingMessage(HVTWin);
}

// �I������������������Tera Term���I�������BOnAllClose()���M�p�B
LRESULT CVTWindow::OnNonConfirmClose(WPARAM wParam, LPARAM lParam)
{
        // ������ ts �����e�����}�I���������������A�I�����������Z�[�u�����������������������A�������������B
        ts.PortFlag &= ~PF_CONFIRMDISCONN;
        OnClose();
        return 1;
}

void CVTWindow::OnDestroy()
{
        // remove this window from the window list
        UnregWin(HVTWin);

        // USB�f�o�C�X�������m����
        UnRegDeviceNotify(HVTWin);

        EndKeyboard();

        /* Disable drag-drop */
        ::DragAcceptFiles(HVTWin,FALSE);
        DropListFree();

        EndDDE();

        if (cv.TelFlag) {
                EndTelnet();
        }
        CommClose(&cv);

        FreeIME(HVTWin);
        FreeTTSET();
#if 0   // free�����s��������free��������
        do { }
        while (FreeTTDLG());
#endif

        do { }
        while (FreeTTFILE());

        if (HTEKWin != NULL) {
                ::DestroyWindow(HTEKWin);
        }

        EndTerm();
        EndDisp();

        FreeBuffer();

        TTXEnd(); /* TTPLUG */

        DeleteNotifyIcon(&cv);
}

static void EscapeFilename(const wchar_t *src, wchar_t *dest)
{
#define ESCAPE_CHARS    L" ;&()$!`'[]{}#^~"
        const wchar_t *s = src;
        wchar_t *d = dest;
        while (*s) {
                wchar_t c = *s++;
                if (c == L'\\') {
                        // �p�X���������� \ -> / ��
                        *d = '/';
                } else if (wcschr(ESCAPE_CHARS, c) != NULL) {
                        // �G�X�P�[�v���K�v������
                        *d++ = L'\\';
                        *d = c;
                } else {
                        *d = c;
                }
                d++;
        }
        *d = '\0'; // null-terminate
}

static void PasteString(PComVar cv, const wchar_t *str, bool escape)
{
        wchar_t *tmpbuf;
        if (!escape) {
                tmpbuf = _wcsdup(str);
        }
        else {
                const size_t len = wcslen(str) * sizeof(wchar_t) * 2;
                tmpbuf = (wchar_t *)malloc(len);
                EscapeFilename(str, tmpbuf);
        }

        SendMemPasteString(tmpbuf);
}

/* �������t�@�C������(�t�H���_������������) */
static bool SendScp(wchar_t *Filenames[], int FileCount, const char *SendDir)
{
        typedef int (CALLBACK *PSSH_start_scp)(char *, char *);
        static PSSH_start_scp func = NULL;
        static HMODULE h = NULL;
        char msg[128];

        if (h == NULL) {
                if ( ((h = GetModuleHandle("ttxssh.dll")) == NULL) ) {
                        _snprintf_s(msg, sizeof(msg), _TRUNCATE, "GetModuleHandle(\"ttxssh.dll\")) %d", GetLastError());
                scp_send_error:
                        ::MessageBox(NULL, msg, "Tera Term: scpsend command error", MB_OK | MB_ICONERROR);
                        return false;
                }
        }
        if (func == NULL) {
                func = (PSSH_start_scp)GetProcAddress(h, "TTXScpSendfile");
                if (func == NULL) {
                        _snprintf_s(msg, sizeof(msg), _TRUNCATE, "GetProcAddress(\"TTXScpSendfile\")) %d", GetLastError());
                        goto scp_send_error;
                }
        }

        for (int i = 0; i < FileCount; i++) {
                char *FileName = ToU8W(Filenames[i]);
                func(FileName, ts.ScpSendDir);
                free(FileName);
        }
        return true;
}

void CVTWindow::DropListFree()
{
        if (DropListCount > 0) {
                for (int i = 0; i < DropListCount; i++) {
                        free(DropLists[i]);
                        DropLists[i] = NULL;
                }
                free(DropLists);
                DropLists = NULL;
                DropListCount = 0;
        }
}

LRESULT CVTWindow::OnDropNotify(WPARAM ShowDialog, LPARAM lParam)
{
        // ini���������������A�����s��������Tera Term�������L��������
        static enum drop_type DefaultDropType = DROP_TYPE_CANCEL;
        static unsigned char DefaultDropTypePaste = DROP_TYPE_PASTE_ESCAPE;
        static bool DefaultShowDialog = ts.ConfirmFileDragAndDrop ? true : false;

        (void)lParam;
        int FileCount = 0;
        int DirectoryCount = 0;
        for (int i = 0; i < DropListCount; i++) {
                const wchar_t *FileName = DropLists[i];
                const DWORD attr = _GetFileAttributesW(FileName);
                if (attr == INVALID_FILE_ATTRIBUTES) {
                        FileCount++;
                } else if (attr & FILE_ATTRIBUTE_DIRECTORY) {
                        DirectoryCount++;
                } else {
                        FileCount++;
                }
        }

        bool DoSameProcess = false;
        const bool isSSH = (cv.isSSH == 2);
        enum drop_type DropType;
        unsigned char DropTypePaste = DROP_TYPE_PASTE_ESCAPE;
        if (DefaultDropType == DROP_TYPE_CANCEL) {
                // default is not set
                if (!ShowDialog) {
                        if (FileCount == 1 && DirectoryCount == 0) {
                                if (ts.ConfirmFileDragAndDrop) {
                                        if (isSSH) {
                                                DropType = DROP_TYPE_SCP;
                                        } else {
                                                DropType = DROP_TYPE_SEND_FILE;
                                        }
                                        DoSameProcess = false;
                                } else {
                                        DropType = DROP_TYPE_SEND_FILE;
                                        DoSameProcess = DefaultShowDialog ? false : true;
                                }
                        } else if (FileCount == 0 && DirectoryCount == 1) {
                                DropType = DROP_TYPE_PASTE_FILENAME;
                                DoSameProcess = DefaultShowDialog ? false : true;
                        } else if (FileCount > 0 && DirectoryCount > 0) {
                                DropType = DROP_TYPE_PASTE_FILENAME;
                                DoSameProcess = false;
                        } else if (FileCount > 0 && DirectoryCount == 0) {
                                // filename only
                                if (isSSH) {
                                        DropType = DROP_TYPE_SCP;
                                } else {
                                        DropType = DROP_TYPE_SEND_FILE;
                                }
                                DoSameProcess = false;
                        } else {
                                // directory only
                                DropType = DROP_TYPE_PASTE_FILENAME;
                                DoSameProcess = ts.ConfirmFileDragAndDrop ? false : true;
                        }
                } else {
                        // show dialog
                        if (DirectoryCount > 0) {
                                DropType = DROP_TYPE_PASTE_FILENAME;
                        } else {
                                if (isSSH) {
                                        DropType = DROP_TYPE_SCP;
                                } else {
                                        DropType = DROP_TYPE_SEND_FILE;
                                }
                        }
                        DoSameProcess = false;
                }
        } else {
                if (DirectoryCount > 0 &&
                        (DefaultDropType == DROP_TYPE_SEND_FILE ||
                         DefaultDropType == DROP_TYPE_SEND_FILE_BINARY ||
                         DefaultDropType == DROP_TYPE_SCP))
                {       // �f�t�H���g�����������������������g��������
                        DropType = DROP_TYPE_PASTE_FILENAME;
                        DropTypePaste = DefaultDropTypePaste;
                        DoSameProcess = false;
                } else {
                        DropType = DefaultDropType;
                        DropTypePaste = DefaultDropTypePaste;
                        DoSameProcess = (ShowDialog || DefaultShowDialog) ? false : true;
                }
        }

        for (int i = 0; i < DropListCount; i++) {
                const wchar_t *FileName = DropLists[i];

                if (!DoSameProcess) {
                        bool DoSameProcessNextDrop;
                        bool DoNotShowDialog = !DefaultShowDialog;
                        SetDialogFont(ts.DialogFontName, ts.DialogFontPoint, ts.DialogFontCharSet,
                                                  ts.UILanguageFile, "Tera Term", "DLG_SYSTEM_FONT");
                        DropType =
                                ShowDropDialogBox(m_hInst, HVTWin,
                                                                  FileName, DropType,
                                                                  DropListCount - i,
                                                                  (DirectoryCount == 0 && isSSH) ? true : false,
                                                                  DirectoryCount == 0 ? true : false,
                                                                  &ts,
                                                                  &DropTypePaste,
                                                                  &DoSameProcess,
                                                                  &DoSameProcessNextDrop,
                                                                  &DoNotShowDialog);
                        if (DropType == DROP_TYPE_CANCEL) {
                                goto finish;
                        }
                        if (DoSameProcessNextDrop) {
                                DefaultDropType = DropType;
                                DefaultDropTypePaste = DropTypePaste;
                        }
                        if (!ts.ConfirmFileDragAndDrop) {
                                DefaultShowDialog = !DoNotShowDialog;
                        }
                }

                switch (DropType) {
                case DROP_TYPE_CANCEL:
                default:
                        // cancel
                        break;
                case DROP_TYPE_SEND_FILE:
                        SendMemSendFile(FileName, FALSE);
                        break;
                case DROP_TYPE_SEND_FILE_BINARY:
                        SendMemSendFile(FileName, TRUE);
                        break;
                case DROP_TYPE_PASTE_FILENAME:
                {
                        const bool escape = (DropTypePaste & DROP_TYPE_PASTE_ESCAPE) ? true : false;

                        TermSendStartBracket();

                        PasteString(&cv, FileName, escape);
                        if (DropListCount > 1 && i < DropListCount - 1) {
                                const wchar_t *separator = (DropTypePaste & DROP_TYPE_PASTE_NEWLINE) ? L"\n" : L" ";
                                PasteString(&cv, separator, false);
                        }

                        TermSendEndBracket();

                        break;
                }
                case DROP_TYPE_SCP:
                {
                        // send by scp
                        wchar_t **FileNames = &DropLists[i];
                        int FileCount = DoSameProcess ? DropListCount - i : 1;
                        if (!SendScp(FileNames, FileCount, ts.ScpSendDir)) {
                                goto finish;
                        }
                        i += FileCount - 1;
                        break;
                }
                }
        }

finish:
        DropListFree();
        return 0;
}

void CVTWindow::OnDropFiles(HDROP hDropInfo)
{
        ::SetForegroundWindow(HVTWin);
        if (cv.Ready && SendVar==NULL)
        {
                const UINT ShowDialog =
                        ((GetAsyncKeyState(VK_CONTROL) & 0x8000) != 0) ? 1 : 0;
                DropListCount = _DragQueryFileW(hDropInfo, -1, NULL, 0);
                DropLists = (wchar_t **)malloc(sizeof(wchar_t *) * DropListCount);

                for (int i = 0; i < DropListCount; i++) {
                        const UINT cch = _DragQueryFileW(hDropInfo, i, NULL, 0);
                        if (cch == 0) {
                                continue;
                        }
                        wchar_t *FileName = (wchar_t *)malloc(sizeof(wchar_t) * (cch + 1));
                        _DragQueryFileW(hDropInfo,i,FileName,cch + 1);
                        FileName[cch] = '\0';
                        DropLists[i] = FileName;
                }

                ::PostMessage(HVTWin, WM_USER_DROPNOTIFY, ShowDialog, 0);
        }
        DragFinish(hDropInfo);
}

void CVTWindow::OnGetMinMaxInfo(MINMAXINFO *lpMMI)
{
#ifndef WINDOW_MAXMIMUM_ENABLED
        lpMMI->ptMaxSize.x = 10000;
        lpMMI->ptMaxSize.y = 10000;
        lpMMI->ptMaxTrackSize.x = 10000;
        lpMMI->ptMaxTrackSize.y = 10000;
#endif
}

void CVTWindow::OnHScroll(UINT nSBCode, UINT nPos, HWND pScrollBar)
{
        int Func;

        switch (nSBCode) {
                case SB_BOTTOM:
                        Func = SCROLL_BOTTOM;
                        break;
                case SB_ENDSCROLL:
                        return;
                case SB_LINEDOWN:
                        Func = SCROLL_LINEDOWN;
                        break;
                case SB_LINEUP:
                        Func = SCROLL_LINEUP;
                        break;
                case SB_PAGEDOWN:
                        Func = SCROLL_PAGEDOWN;
                        break;
                case SB_PAGEUP:
                        Func = SCROLL_PAGEUP;
                        break;
                case SB_THUMBPOSITION:
                case SB_THUMBTRACK:
                        Func = SCROLL_POS;
                        break;
                case SB_TOP:
                        Func = SCROLL_TOP;
                        break;
                default:
                        return;
        }
        DispHScroll(Func,nPos);
}

void CVTWindow::OnInitMenuPopup(HMENU hPopupMenu, UINT nIndex, BOOL bSysMenu)
{
        InitMenuPopup(hPopupMenu);
}

void CVTWindow::OnKeyDown(WPARAM nChar, UINT nRepCnt, UINT nFlags)
{
        BYTE KeyState[256];
        MSG M;

#if UNICODE_DEBUG
        if (UnicodeDebugParam.CodePopupEnable)
        {
                const DWORD now = GetTickCount();
                switch(CtrlKeyState) {
                case 0:
                        if (nChar == UnicodeDebugParam.CodePopupKey1) {
                                CtrlKeyDownTick = now;
                                CtrlKeyState = 1;
                        }
                        break;
                case 2:
                        if (nChar != UnicodeDebugParam.CodePopupKey2) {
                                CtrlKeyState = 0;
                                break;
                        }
                        if (now - CtrlKeyDownTick < 500 && TipWinCodeDebug == NULL) {
                                POINT pos;
                                GetCursorPos(&pos);
                                ScreenToClient(m_hWnd, &pos);
                                CodePopup(pos.x, pos.y);
                                CtrlKeyState = 3;
                        } else {
                                CtrlKeyDownTick = now;
                                CtrlKeyState = 1;
                        }
                        break;
                case 3:
                        break;
                default:
                        CtrlKeyState = 0;
                        break;
                }
        }
        if (TipWinCodeDebug != NULL && nChar == VK_SHIFT) {
                POINT pos;
                GetCursorPos(&pos);
                ScreenToClient(m_hWnd, &pos);
                wchar_t *buf = BuffGetCharInfo(pos.x, pos.y);
                CBSetTextW(HVTWin, buf, 0);
                free(buf);
                MessageBeep(MB_OK);
                TipWinDestroy(TipWinCodeDebug);
                TipWinCodeDebug = NULL;
                CtrlKeyState = 0;
        }
#endif
        switch (KeyDown(HVTWin,nChar,nRepCnt,nFlags & 0x1ff)) {
        case KEYDOWN_OTHER:
                break;
        case KEYDOWN_CONTROL:
                return;
        case KEYDOWN_COMMOUT:
                // �X�N���[�����u�����Z�b�g
                if (WinOrgY != 0) {
                        DispVScroll(SCROLL_BOTTOM, 0);
                }
                return;
        }

        if (MetaKey(ts.MetaKey) && (nFlags & 0x2000) != 0)
        {
                PeekMessage((LPMSG)&M,HVTWin,WM_CHAR,WM_CHAR,PM_REMOVE);
                /* for Ctrl+Alt+Key combination */
                GetKeyboardState((PBYTE)KeyState);
                KeyState[VK_MENU] = 0;
                SetKeyboardState((PBYTE)KeyState);
                M.hwnd = HVTWin;
                M.message = WM_KEYDOWN;
                M.wParam = nChar;
                M.lParam = MAKELONG(nRepCnt,nFlags & 0xdfff);
                TranslateMessage(&M);
        }

}

void CVTWindow::OnKeyUp(WPARAM nChar, UINT nRepCnt, UINT nFlags)
{
        KeyUp(nChar);
#if UNICODE_DEBUG
        if (CtrlKeyState == 1 && nChar == UnicodeDebugParam.CodePopupKey1) {
                CtrlKeyState++;
        } else {
                CtrlKeyState = 0;
        }
        if (nChar == UnicodeDebugParam.CodePopupKey2) {
                if (TipWinCodeDebug != NULL) {
                        TipWinDestroy(TipWinCodeDebug);
                        TipWinCodeDebug = NULL;
                        CtrlKeyState = 0;
                }
        }
#endif
}

void CVTWindow::OnKillFocus(HWND hNewWnd)
{
        DispDestroyCaret();
        FocusReport(FALSE);
//      TTCFrameWnd::OnKillFocus(hNewWnd);              // TODO

        if (IsCaretOn()) {
                CaretKillFocus(TRUE);
        }
}

void CVTWindow::OnLButtonDblClk(WPARAM nFlags, POINTS point)
{
        if (LButton || MButton || RButton) {
                return;
        }

        DblClkX = point.x;
        DblClkY = point.y;

        if (MouseReport(IdMouseEventBtnDown, IdLeftButton, DblClkX, DblClkY)) {
                return;
        }

        if (BuffUrlDblClk(DblClkX, DblClkY)) { // �u���E�U�����o���������������������B (2005.4.3 yutaka)
                return;
        }

        BuffDblClk(DblClkX, DblClkY);

        LButton = TRUE;
        DblClk = TRUE;
        AfterDblClk = TRUE;
        ::SetTimer(HVTWin, IdDblClkTimer, GetDoubleClickTime(), NULL);

        /* for AutoScrolling */
        ::SetCapture(HVTWin);
        ::SetTimer(HVTWin, IdScrollTimer, 100, NULL);
}

void CVTWindow::OnLButtonDown(WPARAM nFlags, POINTS point)
{
        POINT p;

        p.x = point.x;
        p.y = point.y;
        ButtonDown(p,IdLeftButton);
}

void CVTWindow::OnLButtonUp(WPARAM nFlags, POINTS point)
{
        if (IgnoreRelease)
                IgnoreRelease = FALSE;
        else if (MouseReport(IdMouseEventBtnUp, IdLeftButton, point.x, point.y)) {
                ReleaseCapture();
        }

        if (! LButton) {
                return;
        }

        ButtonUp(FALSE);
}

void CVTWindow::OnMButtonDown(WPARAM nFlags, POINTS point)
{
        POINT p;

        p.x = point.x;
        p.y = point.y;
        ButtonDown(p,IdMiddleButton);
}

void CVTWindow::OnMButtonUp(WPARAM nFlags, POINTS point)
{
        if (IgnoreRelease)
                IgnoreRelease = FALSE;
        else if (MouseReport(IdMouseEventBtnUp, IdMiddleButton, point.x, point.y)) {
                ReleaseCapture();
        }

        if (! MButton) {
                return;
        }

        // added DisablePasteMouseMButton (2008.3.2 maya)
        if (ts.PasteFlag & CPF_DISABLE_MBUTTON) {
                ButtonUp(FALSE);
        }
        else {
                ButtonUp(TRUE);
        }
}

LRESULT CVTWindow::OnMouseActivate(HWND pDesktopWnd, UINT nHitTest, UINT message)
{
        if ((ts.SelOnActive==0) && (nHitTest==HTCLIENT)) { //disable mouse event for text selection
                IgnoreRelease = TRUE;
                return MA_ACTIVATEANDEAT; //     when window is activated
        }
        else {
                return MA_ACTIVATE;
        }
}


void CVTWindow::CodePopup(int client_x, int client_y)
{
        wchar_t *buf = BuffGetCharInfo(client_x, client_y);
        if (TipWinCodeDebug == NULL) {
                TipWinCodeDebug = TipWinCreate(m_hInst, m_hWnd);
        }
        POINT pos = { client_x, client_y };
        ClientToScreen(m_hWnd, &pos);
        TipWinSetPos(TipWinCodeDebug, pos.x, pos.y);
        TipWinSetTextW(TipWinCodeDebug, buf);
        TipWinSetVisible(TipWinCodeDebug, TRUE);
        free(buf);
}

void CVTWindow::OnMouseMove(WPARAM nFlags, POINTS point)
{
        int i;