teraterm/teraterm/vtwin.cpp

/*
 * Copyright (C) 1994-1998 T. Teranishi
 * (C) 2004-2019 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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>
#include <tchar.h>

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

#include <windowsx.h>
#include <imm.h>
#include <dbt.h>
#include <assert.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 "TipWin.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 _T("VTWin32")

#undef SetDlgItemText
#define SetDlgItemText SetDlgItemTextA
#undef CreateProcess
#define CreateProcess CreateProcessA
#undef STARTUPINFO
#define STARTUPINFO STARTUPINFOA
#undef GetStartupInfo
#define GetStartupInfo GetStartupInfoA

#if defined(UNICODE)
#define CreateProcessT CreateProcessW
#define GetStartupInfoT GetStartupInfoW
#define STARTUPINFOT STARTUPINFOW
#define SetDlgItemTextT SetDlgItemTextW
#else
#define CreateProcessT CreateProcessA
#define GetStartupInfoT GetStartupInfoA
#define STARTUPINFOT STARTUPINFOA
#define SetDlgItemTextT SetDlgItemTextA
#endif

#ifdef _DEBUG
#define malloc(l)       _malloc_dbg((l), _NORMAL_BLOCK, __FILE__, __LINE__)
#define free(p)         _free_dbg((p), _NORMAL_BLOCK)
#if defined(_MSC_VER)
#define new             ::new(_NORMAL_BLOCK, __FILE__, __LINE__)
#endif
#endif

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

// WM_COPYDATA�������v���Z�X�����M������ (2005.1.22 yutaka)
#define IPC_BROADCAST_COMMAND 1      // �S�[�������M
#define IPC_MULTICAST_COMMAND 2      // �C�����[���Q�����M

#define BROADCAST_LOGFILE "broadcast.log"

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

static BOOL IgnoreRelease = FALSE;

static HDEVNOTIFY hDevNotify = NULL;

static int AutoDisconnectedPort = -1;

static TipWin *TransparencyTip;
static int TransparencyTipPtsX = 0;
static int TransparencyTipPtsY = 0;

#ifndef WM_IME_COMPOSITION
#define WM_IME_COMPOSITION              0x010F
#endif

/////////////////////////////////////////////////////////////////////////////
// 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);
        }
}

static void DestroyTransparencyTip(void) {
        if (TransparencyTip) {
                TipWinDestroy(TransparencyTip);
                TransparencyTip = NULL;
        }
}

/**
 * @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);

        MessageBox(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;
        TCHAR 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)
{
        WNDCLASS wc;
        RECT rect;
        DWORD Style;
#ifdef ALPHABLEND_TYPE2
        DWORD ExStyle;
#endif
        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;

        /* Initialize scroll buffer */
        InitBuffer();

        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;

        RegisterClass(&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;
        }
        Create(hInstance, VTClassName, _T("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) {
                ExStyle  = ::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;
}

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

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) {
                BuffEndSelect();
        }

        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];

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

        /* 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) {
                return FALSE;
        }
        return TRUE;
}

void CVTWindow::InitMenu(HMENU *Menu)
{
        *Menu = LoadMenu(m_hInst,
                         MAKEINTRESOURCE(IDR_MENU));
        char uimsg[MAX_UIMSG];
        int ret;

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

        /* 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);
        }

        GetMenuString(*Menu, ID_FILE, uimsg, sizeof(uimsg), MF_BYPOSITION);
        get_lang_msg("MENU_FILE", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(*Menu, ID_FILE, MF_BYPOSITION, ID_FILE, ts.UIMsg);
        GetMenuString(FileMenu, ID_FILE_NEWCONNECTION, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_FILE_NEW", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_NEWCONNECTION, MF_BYCOMMAND, ID_FILE_NEWCONNECTION, ts.UIMsg);
        GetMenuString(FileMenu, ID_FILE_DUPLICATESESSION, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_FILE_DUPLICATE", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_DUPLICATESESSION, MF_BYCOMMAND, ID_FILE_DUPLICATESESSION, ts.UIMsg);
        GetMenuString(FileMenu, ID_FILE_CYGWINCONNECTION, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_FILE_GYGWIN", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_CYGWINCONNECTION, MF_BYCOMMAND, ID_FILE_CYGWINCONNECTION, ts.UIMsg);
        GetMenuString(FileMenu, ID_FILE_LOG, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_FILE_LOG", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_LOG, MF_BYCOMMAND, ID_FILE_LOG, ts.UIMsg);
        GetMenuString(FileMenu, ID_FILE_COMMENTTOLOG, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_FILE_COMMENTLOG", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_COMMENTTOLOG, MF_BYCOMMAND, ID_FILE_COMMENTTOLOG, ts.UIMsg);
        GetMenuString(FileMenu, ID_FILE_VIEWLOG, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_FILE_VIEWLOG", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_VIEWLOG, MF_BYCOMMAND, ID_FILE_VIEWLOG, ts.UIMsg);
        GetMenuString(FileMenu, ID_FILE_SHOWLOGDIALOG, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_FILE_SHOWLOGDIALOG", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_SHOWLOGDIALOG, MF_BYCOMMAND, ID_FILE_SHOWLOGDIALOG, ts.UIMsg);
        GetMenuString(FileMenu, ID_FILE_SENDFILE, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_FILE_SENDFILE", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_SENDFILE, MF_BYCOMMAND, ID_FILE_SENDFILE, ts.UIMsg);
        GetMenuString(FileMenu, ID_FILE_REPLAYLOG, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_FILE_REPLAYLOG", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_REPLAYLOG, MF_BYCOMMAND, ID_FILE_REPLAYLOG, ts.UIMsg);
        GetMenuString(FileMenu, ID_FILE_CHANGEDIR, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_FILE_CHANGEDIR", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_CHANGEDIR, MF_BYCOMMAND, ID_FILE_CHANGEDIR, ts.UIMsg);
        ret = GetMenuString(FileMenu, ID_FILE_LOGMEIN, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        if (ret != 0) {
                get_lang_msg("MENU_FILE_LOGMETT", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
                ModifyMenu(FileMenu, ID_FILE_LOGMEIN, MF_BYCOMMAND, ID_FILE_LOGMEIN, ts.UIMsg);
        }
        GetMenuString(FileMenu, ID_FILE_PRINT2, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_FILE_PRINT", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_PRINT2, MF_BYCOMMAND, ID_FILE_PRINT2, ts.UIMsg);
        GetMenuString(FileMenu, ID_FILE_DISCONNECT, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_FILE_DISCONNECT", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_DISCONNECT, MF_BYCOMMAND, ID_FILE_DISCONNECT, ts.UIMsg);
        GetMenuString(FileMenu, ID_FILE_EXIT, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_FILE_EXIT", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_EXIT, MF_BYCOMMAND, ID_FILE_EXIT, ts.UIMsg);
        GetMenuString(FileMenu, ID_FILE_EXITALL, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_FILE_EXITALL", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_EXITALL, MF_BYCOMMAND, ID_FILE_EXITALL, ts.UIMsg);

        GetMenuString(FileMenu, 9, uimsg, sizeof(uimsg), MF_BYPOSITION);
        get_lang_msg("MENU_TRANS", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, 9, MF_BYPOSITION, 9, ts.UIMsg);

        GetMenuString(FileMenu, ID_FILE_KERMITRCV, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_TRANS_KERMIT_RCV", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_KERMITRCV, MF_BYCOMMAND, ID_FILE_KERMITRCV, ts.UIMsg);
        GetMenuString(FileMenu, ID_FILE_KERMITGET, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_TRANS_KERMIT_GET", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_KERMITGET, MF_BYCOMMAND, ID_FILE_KERMITGET, ts.UIMsg);
        GetMenuString(FileMenu, ID_FILE_KERMITSEND, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_TRANS_KERMIT_SEND", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_KERMITSEND, MF_BYCOMMAND, ID_FILE_KERMITSEND, ts.UIMsg);
        GetMenuString(FileMenu, ID_FILE_KERMITFINISH, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_TRANS_KERMIT_FINISH", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_KERMITFINISH, MF_BYCOMMAND, ID_FILE_KERMITFINISH, ts.UIMsg);

        GetMenuString(FileMenu, ID_FILE_XRCV, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_TRANS_X_RCV", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_XRCV, MF_BYCOMMAND, ID_FILE_XRCV, ts.UIMsg);
        GetMenuString(FileMenu, ID_FILE_XSEND, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_TRANS_X_SEND", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_XSEND, MF_BYCOMMAND, ID_FILE_XSEND, ts.UIMsg);

        GetMenuString(FileMenu, ID_FILE_YRCV, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_TRANS_Y_RCV", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_YRCV, MF_BYCOMMAND, ID_FILE_YRCV, ts.UIMsg);
        GetMenuString(FileMenu, ID_FILE_YSEND, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_TRANS_Y_SEND", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_YSEND, MF_BYCOMMAND, ID_FILE_YSEND, ts.UIMsg);

        GetMenuString(FileMenu, ID_FILE_ZRCV, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_TRANS_Z_RCV", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_ZRCV, MF_BYCOMMAND, ID_FILE_ZRCV, ts.UIMsg);
        GetMenuString(FileMenu, ID_FILE_ZSEND, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_TRANS_Z_SEND", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_ZSEND, MF_BYCOMMAND, ID_FILE_ZSEND, ts.UIMsg);

        GetMenuString(FileMenu, ID_FILE_BPRCV, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_TRANS_BP_RCV", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_BPRCV, MF_BYCOMMAND, ID_FILE_BPRCV, ts.UIMsg);
        GetMenuString(FileMenu, ID_FILE_BPSEND, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_TRANS_BP_SEND", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_BPSEND, MF_BYCOMMAND, ID_FILE_BPSEND, ts.UIMsg);

        GetMenuString(FileMenu, ID_FILE_QVRCV, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_TRANS_QV_RCV", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_QVRCV, MF_BYCOMMAND, ID_FILE_QVRCV, ts.UIMsg);
        GetMenuString(FileMenu, ID_FILE_QVSEND, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_TRANS_QV_SEND", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(FileMenu, ID_FILE_QVSEND, MF_BYCOMMAND, ID_FILE_QVSEND, ts.UIMsg);

        GetMenuString(*Menu, ID_EDIT, uimsg, sizeof(uimsg), MF_BYPOSITION);
        get_lang_msg("MENU_EDIT", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(*Menu, ID_EDIT, MF_BYPOSITION, ID_EDIT, ts.UIMsg);
        GetMenuString(EditMenu, ID_EDIT_COPY2, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_EDIT_COPY", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(EditMenu, ID_EDIT_COPY2, MF_BYCOMMAND, ID_EDIT_COPY2, ts.UIMsg);
        GetMenuString(EditMenu, ID_EDIT_COPYTABLE, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_EDIT_COPYTABLE", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(EditMenu, ID_EDIT_COPYTABLE, MF_BYCOMMAND, ID_EDIT_COPYTABLE, ts.UIMsg);
        GetMenuString(EditMenu, ID_EDIT_PASTE2, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_EDIT_PASTE", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(EditMenu, ID_EDIT_PASTE2, MF_BYCOMMAND, ID_EDIT_PASTE2, ts.UIMsg);
        GetMenuString(EditMenu, ID_EDIT_PASTECR, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_EDIT_PASTECR", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(EditMenu, ID_EDIT_PASTECR, MF_BYCOMMAND, ID_EDIT_PASTECR, ts.UIMsg);
        GetMenuString(EditMenu, ID_EDIT_CLEARSCREEN, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_EDIT_CLSCREEN", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(EditMenu, ID_EDIT_CLEARSCREEN, MF_BYCOMMAND, ID_EDIT_CLEARSCREEN, ts.UIMsg);
        GetMenuString(EditMenu, ID_EDIT_CLEARBUFFER, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_EDIT_CLBUFFER", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(EditMenu, ID_EDIT_CLEARBUFFER, MF_BYCOMMAND, ID_EDIT_CLEARBUFFER, ts.UIMsg);
        GetMenuString(EditMenu, ID_EDIT_CANCELSELECT, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_EDIT_CANCELSELECT", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(EditMenu, ID_EDIT_CANCELSELECT, MF_BYCOMMAND, ID_EDIT_CANCELSELECT, ts.UIMsg);
        GetMenuString(EditMenu, ID_EDIT_SELECTSCREEN, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_EDIT_SELECTSCREEN", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(EditMenu, ID_EDIT_SELECTSCREEN, MF_BYCOMMAND, ID_EDIT_SELECTSCREEN, ts.UIMsg);
        GetMenuString(EditMenu, ID_EDIT_SELECTALL, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_EDIT_SELECTALL", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(EditMenu, ID_EDIT_SELECTALL, MF_BYCOMMAND, ID_EDIT_SELECTALL, ts.UIMsg);

        GetMenuString(*Menu, ID_SETUP, uimsg, sizeof(uimsg), MF_BYPOSITION);
        get_lang_msg("MENU_SETUP", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(*Menu, ID_SETUP, MF_BYPOSITION, ID_SETUP, ts.UIMsg);
        GetMenuString(SetupMenu, ID_SETUP_TERMINAL, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_SETUP_TERMINAL", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(SetupMenu, ID_SETUP_TERMINAL, MF_BYCOMMAND, ID_SETUP_TERMINAL, ts.UIMsg);
        GetMenuString(SetupMenu, ID_SETUP_WINDOW, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_SETUP_WINDOW", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(SetupMenu, ID_SETUP_WINDOW, MF_BYCOMMAND, ID_SETUP_WINDOW, ts.UIMsg);
        GetMenuString(SetupMenu, ID_SETUP_FONT, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_SETUP_FONT", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(SetupMenu, ID_SETUP_FONT, MF_BYCOMMAND, ID_SETUP_FONT, ts.UIMsg);
        GetMenuString(SetupMenu, ID_SETUP_DLG_FONT, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_SETUP_DIALOG_FONT", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(SetupMenu, ID_SETUP_DLG_FONT, MF_BYCOMMAND, ID_SETUP_DLG_FONT, ts.UIMsg);
        GetMenuString(SetupMenu, 2, uimsg, sizeof(uimsg), MF_BYPOSITION);
        get_lang_msg("MENU_SETUP_FONT_SUBMENU", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(SetupMenu, 2, MF_BYPOSITION, 2, ts.UIMsg);
        GetMenuString(SetupMenu, ID_SETUP_KEYBOARD, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_SETUP_KEYBOARD", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(SetupMenu, ID_SETUP_KEYBOARD, MF_BYCOMMAND, ID_SETUP_KEYBOARD, ts.UIMsg);
        GetMenuString(SetupMenu, ID_SETUP_SERIALPORT, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_SETUP_SERIALPORT", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(SetupMenu, ID_SETUP_SERIALPORT, MF_BYCOMMAND, ID_SETUP_SERIALPORT, ts.UIMsg);
        GetMenuString(SetupMenu, ID_SETUP_TCPIP, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_SETUP_TCPIP", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(SetupMenu, ID_SETUP_TCPIP, MF_BYCOMMAND, ID_SETUP_TCPIP, ts.UIMsg);
        GetMenuString(SetupMenu, ID_SETUP_GENERAL, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_SETUP_GENERAL", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(SetupMenu, ID_SETUP_GENERAL, MF_BYCOMMAND, ID_SETUP_GENERAL, ts.UIMsg);
        GetMenuString(SetupMenu, ID_SETUP_ADDITIONALSETTINGS, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_SETUP_ADDITION", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(SetupMenu, ID_SETUP_ADDITIONALSETTINGS, MF_BYCOMMAND, ID_SETUP_ADDITIONALSETTINGS, ts.UIMsg);
        GetMenuString(SetupMenu, ID_SETUP_SAVE, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_SETUP_SAVE", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(SetupMenu, ID_SETUP_SAVE, MF_BYCOMMAND, ID_SETUP_SAVE, ts.UIMsg);
        GetMenuString(SetupMenu, ID_SETUP_RESTORE, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_SETUP_RESTORE", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(SetupMenu, ID_SETUP_RESTORE, MF_BYCOMMAND, ID_SETUP_RESTORE, ts.UIMsg);
        GetMenuString(SetupMenu, ID_OPEN_SETUP, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_SETUP_OPENSETUP", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(SetupMenu, ID_OPEN_SETUP, MF_BYCOMMAND, ID_OPEN_SETUP, ts.UIMsg);
        GetMenuString(SetupMenu, ID_SETUP_LOADKEYMAP, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_SETUP_LOADKEYMAP", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(SetupMenu, ID_SETUP_LOADKEYMAP, MF_BYCOMMAND, ID_SETUP_LOADKEYMAP, ts.UIMsg);

        GetMenuString(*Menu, ID_CONTROL, uimsg, sizeof(uimsg), MF_BYPOSITION);
        get_lang_msg("MENU_CONTROL", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(*Menu, ID_CONTROL, MF_BYPOSITION, ID_CONTROL, ts.UIMsg);
        GetMenuString(ControlMenu, ID_CONTROL_RESETTERMINAL, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_CONTROL_RESET", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(ControlMenu, ID_CONTROL_RESETTERMINAL, MF_BYCOMMAND, ID_CONTROL_RESETTERMINAL, ts.UIMsg);
        GetMenuString(ControlMenu, ID_CONTROL_RESETREMOTETITLE, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_CONTROL_RESETTITLE", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(ControlMenu, ID_CONTROL_RESETREMOTETITLE, MF_BYCOMMAND, ID_CONTROL_RESETREMOTETITLE, ts.UIMsg);
        GetMenuString(ControlMenu, ID_CONTROL_AREYOUTHERE, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_CONTROL_AREYOUTHERE", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(ControlMenu, ID_CONTROL_AREYOUTHERE, MF_BYCOMMAND, ID_CONTROL_AREYOUTHERE, ts.UIMsg);
        GetMenuString(ControlMenu, ID_CONTROL_SENDBREAK, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_CONTROL_SENDBREAK", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(ControlMenu, ID_CONTROL_SENDBREAK, MF_BYCOMMAND, ID_CONTROL_SENDBREAK, ts.UIMsg);
        GetMenuString(ControlMenu, ID_CONTROL_RESETPORT, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_CONTROL_RESETPORT", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(ControlMenu, ID_CONTROL_RESETPORT, MF_BYCOMMAND, ID_CONTROL_RESETPORT, ts.UIMsg);
        GetMenuString(ControlMenu, ID_CONTROL_BROADCASTCOMMAND, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_CONTROL_BROADCAST", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(ControlMenu, ID_CONTROL_BROADCASTCOMMAND, MF_BYCOMMAND, ID_CONTROL_BROADCASTCOMMAND, ts.UIMsg);
        GetMenuString(ControlMenu, ID_CONTROL_OPENTEK, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_CONTROL_OPENTEK", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(ControlMenu, ID_CONTROL_OPENTEK, MF_BYCOMMAND, ID_CONTROL_OPENTEK, ts.UIMsg);
        GetMenuString(ControlMenu, ID_CONTROL_CLOSETEK, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_CONTROL_CLOSETEK", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(ControlMenu, ID_CONTROL_CLOSETEK, MF_BYCOMMAND, ID_CONTROL_CLOSETEK, ts.UIMsg);

        GetMenuString(ControlMenu, ID_CONTROL_MACRO, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_CONTROL_MACRO", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(ControlMenu, ID_CONTROL_MACRO, MF_BYCOMMAND, ID_CONTROL_MACRO, ts.UIMsg);
        GetMenuString(ControlMenu, ID_CONTROL_SHOW_MACRO, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_CONTROL_SHOW_MACRO", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(ControlMenu, ID_CONTROL_SHOW_MACRO, MF_BYCOMMAND, ID_CONTROL_SHOW_MACRO, ts.UIMsg);

        GetMenuString(*Menu, ID_HELPMENU, uimsg, sizeof(uimsg), MF_BYPOSITION);
        get_lang_msg("MENU_HELP", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(*Menu, ID_HELPMENU, MF_BYPOSITION, ID_HELPMENU, ts.UIMsg);
        GetMenuString(HelpMenu, ID_HELP_INDEX2, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_HELP_INDEX", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(HelpMenu, ID_HELP_INDEX2, MF_BYCOMMAND, ID_HELP_INDEX2, ts.UIMsg);
        GetMenuString(HelpMenu, ID_HELP_ABOUT, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_HELP_ABOUT", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(HelpMenu, ID_HELP_ABOUT, MF_BYCOMMAND, ID_HELP_ABOUT, ts.UIMsg);

        if ((ts.MenuFlag & MF_SHOWWINMENU) !=0) {
                WinMenu = CreatePopupMenu();
                get_lang_msg("MENU_WINDOW", ts.UIMsg, sizeof(ts.UIMsg),
                             "&Window", ts.UILanguageFile);
                ::InsertMenu(*Menu,ID_HELPMENU,
                             MF_STRING | MF_ENABLED | MF_POPUP | MF_BYPOSITION,
                             (UINT_PTR)WinMenu, ts.UIMsg);
        }

        TTXModifyMenu(*Menu); /* 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 (LogVar!=NULL) { // ���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);
                } 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);
                }

        }
        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)
                if (cv.Ready &&
                    ((cv.PortType==IdTCPIP) || (cv.PortType==IdFile)) ||
                        (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 ((ConvH!=0) || (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)
{
        char uimsg[MAX_UIMSG];

        *Menu = LoadMenu(m_hInst,
                         MAKEINTRESOURCE(IDR_PASTEMENU));

        GetMenuString(*Menu, ID_EDIT_PASTE2, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_EDIT_PASTE", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(*Menu, ID_EDIT_PASTE2, MF_BYCOMMAND, ID_EDIT_PASTE2, ts.UIMsg);
        GetMenuString(*Menu, ID_EDIT_PASTECR, uimsg, sizeof(uimsg), MF_BYCOMMAND);
        get_lang_msg("MENU_EDIT_PASTECR", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
        ModifyMenu(*Menu, ID_EDIT_PASTECR, MF_BYCOMMAND, ID_EDIT_PASTECR, ts.UIMsg);
}

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();
        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(UINT nChar, UINT nRepCnt, UINT nFlags)
{
        unsigned int i;
        char Code;

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

        if (MetaKey(ts.MetaKey)) {
                ::PostMessage(HVTWin,WM_SYSCHAR,nChar,MAKELONG(nRepCnt,nFlags));
                return;
        }
        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);
                }
        }

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

/* copy from ttset.c*/
static void WriteInt2(PCHAR Sect, PCHAR Key, PCHAR 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;
        }
        get_lang_msg("MSG_DISCONNECT_CONF", ts.UIMsg, sizeof(ts.UIMsg),
                     "Disconnect?", ts.UILanguageFile);
        if (cv.Ready && (cv.PortType==IdTCPIP) &&
            ((ts.PortFlag & PF_CONFIRMDISCONN) != 0) &&
            ! CloseTT &&
            (::MessageBox(HVTWin, ts.UIMsg, "Tera Term",
             MB_OKCANCEL | MB_ICONEXCLAMATION | MB_DEFBUTTON2)==IDCANCEL)) {
                return;
        }

        FileTransEnd(0);
        ProtoEnd();

        SaveVTPos();
        DestroyWindow();
}

// �STera Term���I�����w������
void CVTWindow::OnAllClose()
{
        // ���R�I���������������������A�����������[�U���������������o�������������B
        // (2013.8.17 yutaka)
        get_lang_msg("MSG_ALL_TERMINATE_CONF", ts.UIMsg, sizeof(ts.UIMsg),
                     "Terminate ALL Tera Term(s)?", ts.UILanguageFile);
        if (::MessageBox(HVTWin, ts.UIMsg, "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);

        OpenHelp(HH_CLOSE_ALL, 0, ts.UILanguageFile);

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

        do { }
        while (FreeTTFILE());

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

        EndTerm();
        EndDisp();

        FreeBuffer();

        TTCFrameWnd::OnDestroy();
        TTXEnd(); /* TTPLUG */

        DeleteNotifyIcon(&cv);
}

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

static void PasteString(PComVar cv, const char *str, bool escape)
{
        PCHAR ptr = (PCHAR)str;
        char *tmpbuf = NULL;
        if (escape) {
                size_t len = strlen(str) * 2;
                tmpbuf = (char *)malloc(len);
                EscapeFilename(str, tmpbuf);
                ptr = tmpbuf;
        }

        // console�����M
        while (*ptr) {
                CommTextOut(cv, ptr, 1);
                if (ts.LocalEcho > 0) {
                        CommTextEcho(cv, ptr, 1);
                }
                ptr++;
        }

        if (tmpbuf != NULL) free(tmpbuf);
}

/* �������t�@�C������(�t�H���_������������) */
static bool SendScp(char *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++) {
                const char *FileName = Filenames[i];
                func((char *)FileName, ts.ScpSendDir);
        }
        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 char *FileName = DropLists[i];
                const DWORD attr = GetFileAttributes(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 char *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:
                case DROP_TYPE_SEND_FILE_BINARY:
                        if (SendVar==NULL && NewFileVar(&SendVar)) {
                                HelpId = HlpFileSend;
                                strncpy_s(SendVar->FullName, sizeof(SendVar->FullName), FileName,  _TRUNCATE);
                                SendVar->DirLen = 0;
                                ts.TransBin = DropType == DROP_TYPE_SEND_FILE ? 0 : 1;
                                FileSendStart();
#if 0
#if 0
                                goto finish;    // send file���A��������������
#else
                                {
                                        LONG lCount = 0;
                                        CWinApp *app = AfxGetApp();
                                        while(1) {
                                                if (SendVar == NULL) {
                                                        break;
                                                }
                                                app->OnIdle(lCount++);
                                        }
                                }
#endif
#endif
                        }
                        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 char *separator = (DropTypePaste & DROP_TYPE_PASTE_NEWLINE) ? "\n" : " ";
                                PasteString(&cv, separator, false);
                        }

                        TermSendEndBracket();

                        break;
                }
                case DROP_TYPE_SCP:
                {
                        // send by scp
                        char **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 = DragQueryFile(hDropInfo, -1, NULL, 0);
                DropLists = (char **)malloc(sizeof(char *) * DropListCount);

                for (int i = 0; i < DropListCount; i++) {
                        const UINT cch = DragQueryFile(hDropInfo, i, NULL, 0) + 1;
                        char *FileName = (char *)malloc(cch);
                        DropLists[i] = FileName;
                        DragQueryFile(hDropInfo,i,FileName,cch);
                }

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