teraterm/teraterm/vtwin.cpp

/*
 * Copyright (C) 1994-1998 T. Teranishi
 * (C) 2004- 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 */

// SDK7.0�������AWIN32_IE���K�������`��������
#if _MSC_VER == 1400    // VS2005����������
#if !defined(_WIN32_IE)
#define _WIN32_IE 0x0501
#endif
#endif

#include "teraterm.h"
#include "tttypes.h"
#include "tttypes_key.h"

#define TTCMN_NOTIFY_INTERNAL 1
#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 "filesys.h"
#include "telnet.h"
#include "tektypes.h"
#include "ttdde.h"
#include "ttlib.h"
#include "dlglib.h"
#include "helpid.h"
#include "teraprn.h"
#include <winsock2.h>
#include <ws2tcpip.h>
#include "ttplug.h"  /* TTPLUG */
#include "teraterml.h"
#include "buffer.h"
#include "cyglib.h"

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

#include <shlobj.h>
#include <windows.h>
#include <windowsx.h>
#include <imm.h>
#include <dbt.h>
#include <assert.h>
#include <wchar.h>
#include <htmlhelp.h>

#include "tt_res.h"
#include "vtwin.h"
#include "addsetting.h"
#include "winjump.h"
#include "sizetip.h"
#include "dnddlg.h"
#include "tekwin.h"
#include "compat_win.h"
#include "unicode_test.h"
#if UNICODE_DEBUG
#include "tipwin.h"
#endif
#include "codeconv.h"
#include "sendmem.h"
#include "sendfiledlg.h"
#include "setting.h"
#include "broadcast.h"
#include "asprintf.h"
#include "teraprn.h"
#include "setupdirdlg.h"
#include "ttcmn_static.h"

#include <initguid.h>
#if _MSC_VER < 1600
// Visual Studio 2005,2008 �������A2010���������o�[�W����������
DEFINE_GUID(GUID_DEVINTERFACE_USB_DEVICE, 0xA5DCBF10L, 0x6530, 0x11D2, 0x90, 0x1F, 0x00, \
             0xC0, 0x4F, 0xB9, 0x51, 0xED);
#else
#include <usbiodef.h>   // GUID_DEVINTERFACE_USB_DEVICE
#endif

#include "win32helper.h"

#define VTClassName L"VTWin32"

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

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

static BOOL IgnoreRelease = FALSE;

static HDEVNOTIFY hDevNotify = NULL;

static int AutoDisconnectedPort = -1;

static BOOL SendScpDoing;
static WCHAR **DropListsSendScp;
static int DropListCountSendScp;
static int DropListsSendScpIndex;

UnicodeDebugParam_t UnicodeDebugParam;
typedef struct {
        char dbcs_lead_byte;
} vtwin_work_t;
static vtwin_work_t vtwin_work;

extern "C" PrintFile *PrintFile_;

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

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

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

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

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

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

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

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

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

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

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

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

        pUnregisterDeviceNotification(hDevNotify);
}

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

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

CVTWindow::CVTWindow(HINSTANCE hInstance)
{
        WNDCLASSW wc;
        RECT rect;
        DWORD Style;
        int CmdShow;
        BOOL isFirstInstance;
        m_hInst = hInstance;

        CommInit(&cv);
        cv.ts = &ts;
        isFirstInstance = StartTeraTerm(m_hInst, &ts);

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

        MsgDlgHelp = RegisterWindowMessage(HELPMSGSTRING);

        if (isFirstInstance) {
                /* first instance */
                if (LoadTTSET()) {
                        /* read setup info from "teraterm.ini" */
                        (*ReadIniFile)(ts.SetupFNameW, &ts);
                        FreeTTSET();
                }
                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.SetupFNameW, &ts);
                        FreeTTSET();
                }
                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)
        if (LoadTTSET()) {
                wchar_t *ParamW = GetCommandLineW();
                (*ParseParam)(ParamW, &ts, &(TopicName[0]));
        }
        FreeTTSET();

        // DPI Aware (��DPI����)
        if (pIsValidDpiAwarenessContext != NULL && pSetThreadDpiAwarenessContext != NULL) {
                wchar_t Temp[4];
                GetPrivateProfileStringW(L"Tera Term", L"DPIAware", L"on", Temp, _countof(Temp), ts.SetupFNameW);
                if (_wcsicmp(Temp, L"on") == 0) {
                        if (pIsValidDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2) == TRUE) {
                                pSetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
                        }
                }
        }

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

        InitKeyboard();
        SetKeyMap();

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

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

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

        InitDisp();

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

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

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

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

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

        /*--------- Init2 -----------------*/
        HVTWin = GetSafeHwnd();
        if (HVTWin == NULL) return;
        cv.HWin = HVTWin;

        // Windows 11 ���E�B���h�E���p������������������������
        if (ts.WindowCornerDontround && pDwmSetWindowAttribute != NULL) {
                DWM_WINDOW_CORNER_PREFERENCE preference = DWMWCP_DONOTROUND;
                pDwmSetWindowAttribute(HVTWin, DWMWA_WINDOW_CORNER_PREFERENCE, &preference, sizeof(preference));
        }

        // register this window to the window list
        SerialNo = RegWin(HVTWin,NULL);

        logfile_lock_initialize();
        SetMouseCursor(ts.MouseCursorName);

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

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

        // ���m����������
        NotifyInitialize(&cv);
        NotifySetWindow(&cv, m_hWnd, WM_USER_NOTIFYICON, m_hInst, (ts.VTIcon != IdIconDefault) ? ts.VTIcon: IDI_VT);

        // VT �E�B���h�E���A�C�R��
        SetVTIconID(&cv, NULL, 0);

        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();

        DropLists = NULL;
        DropListCount = 0;

#if UNICODE_DEBUG
        CtrlKeyState = 0;
#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                InitMenu(&PopupMenu);

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

                for (i = 0; i < numItems; i++) {
                        wchar_t itemText[256];
                        HMENU submenu = GetSubMenu(PopupMenu, i);

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

                        if (GetMenuStringW(PopupMenu, i, itemText, _countof(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);

                                AppendMenuW(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 &&
                IsSendVarNULL() && IsFileVarNULL() &&
                (cv.PortType!=IdFile) &&
                (IsClipboardFormatAvailable(CF_TEXT) ||
                 IsClipboardFormatAvailable(CF_OEMTEXT))) {

                int i, numItems;

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

                for (i = 0; i < numItems; i++) {
                        wchar_t itemText[256];
                        if (GetMenuStringW(PopupMenu, i, itemText, _countof(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);

                                AppendMenuW(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;
                }
        }
}

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

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

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

        SetDlgMenuTextsW(hMenu, MenuTextInfo, _countof(MenuTextInfo), ts.UILanguageFileW);

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

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

        TTXModifyMenu(hMenu); /* TTPLUG */
}

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

                if ( (! cv.Ready) || (!IsSendVarNULL()) ||
                     (!IsFileVarNULL()) || (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);

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

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

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

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

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

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

        TTXModifyPopupMenu(SubMenu); /* TTPLUG */
}

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

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

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

        /* setup terminal */
        SetupTerm();

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

        /* setup window */
        ChangeWin();

        /* Language & IME */
        ResetIME();

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

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

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

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

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

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

        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;

        if (cv.Ready) {
                if (cv.TelFlag && (ts.TelEcho>0)) {
                        TelChangeEcho();
                }
        }

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

/**
 *      �L�[�{�[�h����1��������
 *      @param  nChar   UTF-16 char(wchar_t)    IsWindowUnicode() == TRUE ��
 *                                      ANSI char(char)                 IsWindowUnicode() == FALSE ��
 */
void CVTWindow::OnChar(WPARAM nChar, UINT nRepCnt, UINT nFlags)
{
        unsigned int i;

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

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

        wchar_t u16;
        if (IsWindowUnicode(HVTWin) == TRUE) {
                // ������ UTF-16
                u16 = (wchar_t)nChar;
        } else {
                // ������ ANSI
                if (ts.Language == IdJapanese || ts.Language == IdChinese || ts.Language == IdKorean) {
                        // CJK (2byte����)
                        if (vtwin_work.dbcs_lead_byte == 0 && IsDBCSLeadByte(nChar)) {
                                // ANSI 2�o�C�g������ 1byte��������
                                //      ������ WM_IME_* ���b�Z�[�W������������
                                //      ������������������������
                                //              TERATERM.INI �� IME=off ������
                                //              imm32.dll �����[�h����������������
                                vtwin_work.dbcs_lead_byte = nChar;
                                return;
                        }
                        else {
                                // ANSI(ACP) -> UTF-32 -> UTF-16
                                char mb_str[2];
                                size_t mb_len;
                                if (vtwin_work.dbcs_lead_byte == 0) {
                                        // 1�o�C�g����
                                        mb_str[0] = (char)nChar;
                                        mb_len = 1;
                                }
                                else {
                                        // 2�o�C�g����
                                        mb_str[0] = (char)vtwin_work.dbcs_lead_byte;
                                        mb_str[1] = (char)nChar;
                                        mb_len = 2;
                                        vtwin_work.dbcs_lead_byte = 0;
                                }
                                unsigned int u32;
                                mb_len = MBCPToUTF32(mb_str, mb_len, CP_ACP, &u32);
                                if (mb_len == 0) {
                                        return;
                                }
                                u16 = (wchar_t)u32;
                        }
                }
                else if (ts.Language == IdRussian) {
                        BYTE c;
                        if (ts.RussKeyb == IdWindows) {
                                // key = CP1251
                                c = (char)nChar;
                        }
                        else {
                                // key -> CP1251
                                c = RussConv(ts.RussKeyb, IdWindows, nChar);
                        }
                        // CP1251 -> UTF-32 -> UTF-16
                        unsigned long u32 = MBCP_UTF32(c, 1251);
                        u16 = (wchar_t)u32;
                }
                else {
                        u16 = (wchar_t)nChar;
                }
        }

        // �o�b�t�@���o���A�������o��
        for (i=1 ; i<=nRepCnt ; i++) {
                CommTextOutW(&cv,&u16,1);
                if (ts.LocalEcho>0) {
                        CommTextEchoW(&cv,&u16,1);
                }
        }

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

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

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

        return FALSE;
}

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

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

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

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

        if (cv.Ready && (cv.PortType==IdTCPIP) &&
            ((ts.PortFlag & PF_CONFIRMDISCONN) != 0) &&
            ! CloseTT) {
                static const TTMessageBoxInfoW info = {
                        "Tera Term",
                        NULL, L"Tera Term",
                        "MSG_DISCONNECT_CONF", L"Disconnect?",
                        MB_OKCANCEL | MB_ICONEXCLAMATION | MB_DEFBUTTON2
                };
                int result = TTMessageBoxW(HVTWin, &info, ts.UILanguageFileW);
                if (result == IDCANCEL) {
                        return;
                }
        }

        FLogClose();
        FileSendEnd();
        ProtoEnd();

        SaveVTPos();
        NotifyUnsetWindow(&cv);

        // �A�v���P�[�V�����I�������A�C�R�����j���������A�E�B���h�E���������O��
        // �^�C�g���o�[���A�C�R���� "Windows �����s�t�@�C�����A�C�R��" ��������
        // ���������������j��������
        // TTSetIcon(m_hInst, m_hWnd, NULL, 0);

        DestroyWindow();
}

// �STera Term���I�����w������
void CVTWindow::OnAllClose()
{
        // ���R�I���������������������A�����������[�U���������������o�������������B
        static const TTMessageBoxInfoW info = {
                "Tera Term",
                NULL, L"Tera Term",
                "MSG_ALL_TERMINATE_CONF", L"Terminate ALL Tera Term(s)?",
                MB_OKCANCEL | MB_ICONERROR | MB_DEFBUTTON2
        };
        int result = TTMessageBoxW(HVTWin, &info, ts.UILanguageFileW);
        if (result == IDCANCEL)
                return;

        BroadcastClosingMessage(HVTWin);
}

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

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

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

        EndKeyboard();

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

        EndDDE();

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

        FreeIME(HVTWin);
        FreeTTSET();

#if 0
        do { }
        while (FreeTTFILE());
#endif

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

        EndTerm();
        EndDisp();

        FreeBuffer();

        TTXEnd(); /* TTPLUG */

        TTSetUnInit(&ts);

        NotifyUninitialize(&cv);
}

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

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

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

        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;
                }
        }
        if (func_status == NULL) {
                func_status = (PSSH_scp_sending_status)GetProcAddress(h, "TTXScpSendingStatus");
                if (func_status == NULL) {
                        _snprintf_s(msg, sizeof(msg), _TRUNCATE, "GetProcAddress(\"TTXScpSendingStatus\")) %d", GetLastError());
                        goto scp_send_error;
                }
        }

        if (SendScpDoing) {
                if (func_status()) {
                        return false;
                }
                else {
                        DropListsSendScpIndex++;
                }
        }

        FileName = ToU8W(Filenames[0]);
        func(FileName, ts.ScpSendDir);
        free(FileName);

        return true;
}

static void StartSendScpTimer(void)
{
        DropListsSendScpIndex = 0;
        SetTimer(HVTWin, IdScpSendingTimer, 100, NULL);
}

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

/**
 *  �t�@�C�����h���b�v������
 *      @param  ShowDialog      0       �\���������\����������������
 *                                              1       �K���\������
 */
LRESULT CVTWindow::OnDropNotify(WPARAM ShowDialog, 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;
        static bool TransBin;

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

        bool DoSameProcess = false;
        const bool isSSH = (cv.isSSH == 2);
        enum drop_type DropType;
        unsigned char DropTypePaste = DROP_TYPE_PASTE_ESCAPE;
        if (DefaultDropType == DROP_TYPE_CANCEL) {
                // default is not set
                TransBin = ts.TransBin == 0 ? false : true;
                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_SCP))
                {       // �f�t�H���g�����������������������g��������
                        DropType = DROP_TYPE_PASTE_FILENAME;
                        DropTypePaste = DefaultDropTypePaste;
                        DoSameProcess = false;
                } else {
                        DropType = DefaultDropType;
                        DropTypePaste = DefaultDropTypePaste;
                        DoSameProcess = (ShowDialog || DefaultShowDialog) ? false : true;
                }
        }

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

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

                switch (DropType) {
                case DROP_TYPE_CANCEL:
                default:
                        // cancel
                        break;
                case DROP_TYPE_SEND_FILE:
                        if (!TransBin) {
                                SendMemSendFile(FileName, FALSE, SENDMEM_DELAYTYPE_NO_DELAY, 0, 0);
                        }
                        else {
                                SendMemSendFile(FileName, TRUE, SENDMEM_DELAYTYPE_NO_DELAY, 0, 0);
                        }
                        break;
                case DROP_TYPE_PASTE_FILENAME:
                {
                        const bool escape = (DropTypePaste & DROP_TYPE_PASTE_ESCAPE) ? true : false;

                        DefaultDropTypePaste = DropTypePaste;

                        TermSendStartBracket();

                        wchar_t *str = GetPasteString(FileName, escape);
                        TermPasteStringNoBracket(str, wcslen(str));
                        free(str);
                        if (DropListCount > 1 && i < DropListCount - 1) {
                                if (DropTypePaste & DROP_TYPE_PASTE_NEWLINE) {
                                        TermPasteStringNoBracket(L"\x0d", 1);   // ���s(CR,0x0d)
                                }
                                else {
                                        TermPasteStringNoBracket(L" ", 1);              // space
                                }
                        }

                        TermSendEndBracket();

                        break;
                }
                case DROP_TYPE_SCP:
                {
                        // ������SCP���M�����������������B
                        if (SendScpDoing) {
                                // do nothing.
                                goto finish;
                        }
                        else {
                                // �������M���������^�C�}�[�������s���������A�A�����M������
                                // �G���[���N�������������������B
                                if (DoSameProcess) {
                                        int j;

                                        DropListCountSendScp = DropListCount - i;
                                        DropListsSendScp = (wchar_t **)malloc(sizeof(wchar_t *) * DropListCountSendScp);

                                        for (j = 0; j < DropListCountSendScp; j++) {
                                                DropListsSendScp[j] = _wcsdup(DropLists[j]);
                                        }
                                        SendScpDoing = TRUE;

                                        StartSendScpTimer();
                                        goto finish;
                                }
                                else {
                                        // send by scp
                                        wchar_t **FileNames = &DropLists[i];
                                        int FileCount = 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 && IsSendVarNULL())
        {
                const UINT ShowDialog =
                        ((GetAsyncKeyState(VK_CONTROL) & 0x8000) != 0) ? 1 : 0;
                DropListCount = DragQueryFileW(hDropInfo, -1, NULL, 0);
                DropLists = (wchar_t **)malloc(sizeof(wchar_t *) * DropListCount);

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

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

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

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

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

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

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

        if (MetaKey(ts.MetaKey) && (nFlags & 0x2000) != 0)
        {
                BYTE KeyState[256];
                MSG M;

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

}

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

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

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

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

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

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

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

        BuffDblClk(DblClkX, DblClkY);

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

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

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

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

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

        if (! LButton) {
                return;
        }

        ButtonUp(FALSE);
}

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

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

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

        if (! MButton) {
                return;
        }

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

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


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

void CVTWindow::OnMouseMove(WPARAM nFlags, POINTS point)
{
        int i;
        BOOL mousereport = FALSE;

#if UNICODE_DEBUG
        if (TipWinCodeDebug != NULL) {
                CodePopup(point.x, point.y);
        }
#endif

        if (!IgnoreRelease)
                mousereport = MouseReport(IdMouseEventMove, 0, point.x, point.y);

        if (! (LButton || MButton || RButton)) {
                if (BuffCheckMouseOnURL(point.x, point.y))
                        SetMouseCursor("HAND");
                else
                        SetMouseCursor(ts.MouseCursorName);
                return;
        }

        if (mousereport) {
                return;
        }

        if (DblClk) {
                i = 2;
        }
        else if (TplClk) {
                i = 3;
        }
        else {
                i = 1;
        }

        if (!ts.SelectOnlyByLButton ||
            (ts.SelectOnlyByLButton && LButton) ) {
                // SelectOnlyByLButton == TRUE ���������A���{�^���_�E���������I������ (2007.11.21 maya)
                BuffChangeSelect(point.x, point.y,i);
        }
}

void CVTWindow::OnMove(int x, int y)
{
        DispSetWinPos();
}

// �}�E�X�z�C�[�������]
BOOL CVTWindow::OnMouseWheel(
        UINT nFlags,   // ���z�L�[
        short zDelta,  // ���]����
        POINTS pts     // �J�[�\�����u
)
{
        POINT pt;
        pt.x = pts.x;
        pt.y = pts.y;

        int line, i;

        if (pSetLayeredWindowAttributes != NULL) {
                BOOL InTitleBar;
                POINT point = pt;
                GetPositionOnWindow(HVTWin, &point,
                                                        NULL, NULL, &InTitleBar);
                if (InTitleBar) {
                        int delta = zDelta < 0 ? -1 : 1;
                        int newAlpha = Alpha;
                        POINT tippos;

                        newAlpha += delta * ts.MouseWheelScrollLine;
                        if (newAlpha > 255)
                                newAlpha = 255;
                        else if (newAlpha < 0)
                                newAlpha = 0;
                        SetWindowAlpha(newAlpha);

                        wchar_t *uimsg;
                        GetI18nStrWA("Tera Term", "TOOLTIP_TITLEBAR_OPACITY", L"Opacity %.1f %%", ts.UILanguageFile, &uimsg);
                        wchar_t *tipbuf;
                        aswprintf(&tipbuf, uimsg, (newAlpha / 255.0) * 100);
                        free(uimsg);

                        tippos = TipWin->GetPos();
                        if (tippos.x != pt.x ||
                            tippos.y != pt.y) {
                                        TipWin->SetVisible(FALSE);
                        }

                        TipWin->SetText(tipbuf);
                        TipWin->SetPos(pt.x, pt.y);
                        TipWin->SetHideTimer(1000);

                        if(! TipWin->IsVisible()) {
                                TipWin->SetVisible(TRUE);
                        }

                        free(tipbuf);

                        return TRUE;
                }
        }

        ::ScreenToClient(HVTWin, &pt);

        line = abs(zDelta) / WHEEL_DELTA; // ���C����
        if (line < 1) line = 1;

        // ���X�N���[�����������s������������ (2008.4.6 yutaka)
        if (line == 1 && ts.MouseWheelScrollLine > 0)
                line *= ts.MouseWheelScrollLine;

        if (MouseReport(IdMouseEventWheel, zDelta<0, pt.x, pt.y))
                return TRUE;

        if (WheelToCursorMode()) {
                if (zDelta < 0) {
                        KeyDown(HVTWin, VK_DOWN, line, MapVirtualKey(VK_DOWN, 0) | 0x100);
                        KeyUp(VK_DOWN);
                } else {
                        KeyDown(HVTWin, VK_UP, line, MapVirtualKey(VK_UP, 0) | 0x100);
                        KeyUp(VK_UP);
                }
        } else {
                for (i = 0 ; i < line ; i++) {
                        if (zDelta < 0) {
                                OnVScroll(SB_LINEDOWN, 0, NULL);
                        } else {
                                OnVScroll(SB_LINEUP, 0, NULL);
                        }
                }
        }

        return (TRUE);
}

void CVTWindow::OnNcLButtonDblClk(UINT nHitTest, POINTS point)
{
        if (! Minimized && !ts.TermIsWin && (nHitTest == HTCAPTION)) {
                DispRestoreWinSize();
        }
}

void CVTWindow::OnNcRButtonDown(UINT nHitTest, POINTS point)
{
        if ((nHitTest==HTCAPTION) &&
            (ts.HideTitle>0) &&
                AltKey()) {
                ::CloseWindow(HVTWin); /* iconize */
        }
}

void CVTWindow::OnPaint()
{
        PAINTSTRUCT ps;
        HDC PaintDC;
        int Xs, Ys, Xe, Ye;

        // �\������������������WM_PAINT�����������P�[�X����
        if (::IsWindowVisible(m_hWnd) == 0) {
                return;
        }

#ifdef ALPHABLEND_TYPE2
//<!--by AKASI
        BGSetupPrimary(FALSE);
//-->
#endif

        PaintDC = BeginPaint(&ps);

        PaintWindow(PaintDC,ps.rcPaint,ps.fErase, &Xs,&Ys,&Xe,&Ye);
        LockBuffer();
        BuffUpdateRect(Xs,Ys,Xe,Ye);
        UnlockBuffer();
        DispEndPaint();

        EndPaint(&ps);

        if (FirstPaint) {
                if (strlen(TopicName)>0) {
                        InitDDE();
                        SendDDEReady();
                }
                FirstPaint = FALSE;
                Startup();
        }
}

void CVTWindow::OnRButtonDown(UINT nFlags, POINTS point)
{
        POINT p;

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

void CVTWindow::OnRButtonUp(UINT nFlags, POINTS point)
{
        if (IgnoreRelease)
                IgnoreRelease = FALSE;
        else if (MouseReport(IdMouseEventBtnUp, IdRightButton, point.x, point.y)) {
                ReleaseCapture();
        }

        if (! RButton) {
                return;
        }

        /*
         *  �y�[�X�g����:
         *  �Ets.PasteFlag & CPF_DISABLE_RBUTTON -> �E�{�^���������y�[�X�g����
         *  �Ets.PasteFlag & CPF_CONFIRM_RBUTTON -> �\�����������j���[�����y�[�X�g���s�������A
         *                                          �E�{�^���A�b�v�������y�[�X�g���s������
         */
        if ((ts.PasteFlag & CPF_DISABLE_RBUTTON) || (ts.PasteFlag & CPF_CONFIRM_RBUTTON)) {
                ButtonUp(FALSE);
        } else {
                ButtonUp(TRUE);
        }
}

void CVTWindow::OnSetFocus(HWND hOldWnd)
{
        ChangeCaret();
        FocusReport(TRUE);
}

void CVTWindow::OnSize(WPARAM nType, int cx, int cy)
{
        if (IgnoreSizeMessage) {
                return;
        }
        RECT R;
        int w, h;

        Minimized = (nType==SIZE_MINIMIZED);

        if (FirstPaint && Minimized)
        {
                if (strlen(TopicName)>0)
                {
                        InitDDE();
                        SendDDEReady();
                }
                FirstPaint = FALSE;
                Startup();
                return;
        }
        if (Minimized || DontChangeSize) {
                return;
        }

        if (nType == SIZE_MAXIMIZED) {
                ts.TerminalOldWidth = ts.TerminalWidth;
                ts.TerminalOldHeight = ts.TerminalHeight;
        }

        ::GetWindowRect(HVTWin,&R);
        w = R.right - R.left;
        h = R.bottom - R.top;
        if (AdjustSize) {
                ResizeWindow(R.left,R.top,w,h,cx,cy);
        }
        else {
                if (ts.FontScaling) {
                        int NewFontWidth, NewFontHeight;
                        BOOL FontChanged = FALSE;

                        NewFontWidth = cx / ts.TerminalWidth;
                        NewFontHeight = cy / ts.TerminalHeight;

                        if (NewFontWidth - ts.FontDW < 3) {
                                NewFontWidth = ts.FontDW + 3;
                        }
                        if (NewFontWidth != FontWidth) {
                                ts.VTFontSize.x = ts.FontDW - NewFontWidth;
                                FontWidth = NewFontWidth;
                                FontChanged = TRUE;
