scbc_repos/TestWizardTool/TestWizardTool/TestWizardToolDlg.cpp

// TestWizardToolDlg.cpp : 实现文件
//

#include "stdafx.h"
#include "TestWizardTool.h"
#include "TestWizardToolDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

#define MINIMUM_WINDOWS_X 395  
#define MINIMUM_WINDOWS_Y 535

unsigned char TwoHexChar2Char(char ch1, char ch2)
{
    char Numb1;
    char Numb2;

    if (ch1 >= 'A')
        Numb1 = (toupper(ch1) - '0' - 7) * 16;
    else
        Numb1 = (ch1 - '0') * 16;

    if (ch2 >= 'A')
        Numb2 = (toupper(ch2) - '0' - 7);
    else
        Numb2 = (ch2 - '0');

    return (Numb1 + Numb2);
}

COLORREF HexColor2RGB(std::string strHexColor)
{
    DWORD r = TwoHexChar2Char(strHexColor[0], strHexColor[1]);
    DWORD g = TwoHexChar2Char(strHexColor[2], strHexColor[3]);
    DWORD b = TwoHexChar2Char(strHexColor[4], strHexColor[5]);

    return RGB(r, g, b);
}

BOOL GetSysSerialPort(std::vector<std::string>& vtports)
{
    HKEY hKey;
    LSTATUS lReg = 0;
    DWORD dwMaxValLen = 0;
    DWORD dwValNum = 0;
    lReg = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "HARDWARE\\DEVICEMAP\\SERIALCOMM", 0, KEY_QUERY_VALUE, &hKey);
    if (lReg != ERROR_SUCCESS)
    {
        return FALSE;
    }

    lReg = RegQueryInfoKeyA(hKey, NULL, NULL, NULL, NULL, NULL, NULL, &dwValNum, &dwMaxValLen, NULL, NULL, NULL);
    if (lReg != ERROR_SUCCESS)
    {
        return FALSE;
    }

    if (vtports.size())
    {
        vtports.clear();
    }

    LPSTR lpValName, lpComNum;
    DWORD dwValName, dwValSize = 6;
    for (DWORD i = 0; i < dwValNum; i++)
    {
        dwValName = dwMaxValLen + 1;
        dwValSize = 6;
        lpValName = (LPSTR)VirtualAlloc(NULL, dwValName, MEM_COMMIT, PAGE_READWRITE);
        lReg = RegEnumValueA(hKey, i, lpValName, &dwValName, NULL, NULL, NULL, NULL);
        if ((lReg != ERROR_SUCCESS) && (lReg != ERROR_NO_MORE_ITEMS))
        {
            continue;
        }
        lpComNum = (LPSTR)VirtualAlloc(NULL, 6, MEM_COMMIT, PAGE_READWRITE);
        lReg = RegQueryValueExA(hKey, lpValName, NULL, NULL, (LPBYTE)lpComNum, &dwValSize);
        if (lReg != ERROR_SUCCESS)
        {
            continue;
        }

        vtports.push_back(lpComNum);
        VirtualFree(lpValName, 0, MEM_RELEASE);
        VirtualFree(lpComNum, 0, MEM_RELEASE);
    }

    return TRUE;
}

// 用于应用程序“关于”菜单项的 CAboutDlg 对话框

class CAboutDlg : public CDialog
{
public:
    CAboutDlg();

    // 对话框数据
    enum { IDD = IDD_ABOUTBOX };

protected:
    virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 支持

    // 实现
protected:
    DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
    CDialog::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
END_MESSAGE_MAP()


// CTestWizardToolDlg 对话框




CTestWizardToolDlg::CTestWizardToolDlg(CWnd* pParent /*=NULL*/)
: CDialog(CTestWizardToolDlg::IDD, pParent)
{
    m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);

    m_nCols = 3;
    m_nTopMargin = 8;
    m_nLeftMargin = 8;
    m_nComboHeight = 20;
    m_nDefaultWidth = 360;
    m_nDefaultHeight = 600;
}

void CTestWizardToolDlg::DoDataExchange(CDataExchange* pDX)
{
    CDialog::DoDataExchange(pDX);
    DDX_Control(pDX, COMBO_COM, m_cbCOM);
    DDX_Control(pDX, COMBO_SINGALS, m_cbSignals);
}

BEGIN_MESSAGE_MAP(CTestWizardToolDlg, CDialog)
    ON_WM_SYSCOMMAND()
    ON_WM_PAINT()
    ON_WM_QUERYDRAGICON()
    ON_WM_QUERYDRAGICON()
    //}}AFX_MSG_MAP
    ON_WM_SIZE()
    ON_WM_SIZING()
    ON_WM_GETMINMAXINFO()
    // 信号按钮;
    ON_COMMAND_RANGE(BTNID, BTNID + 100, OnSignalBtnClick)
    ON_BN_CLICKED(BTN_OPEN_COM, &CTestWizardToolDlg::OnBnClickedOpenCom)
    ON_CBN_SELCHANGE(COMBO_SINGALS, &CTestWizardToolDlg::OnCbnSelchangeSingals)
    ON_BN_CLICKED(BTN_RELOAD_SIGNAL, &CTestWizardToolDlg::OnBnClickedReloadSignal)
    ON_WM_DESTROY()
END_MESSAGE_MAP()


// CTestWizardToolDlg 消息处理程序

BOOL CTestWizardToolDlg::OnInitDialog()
{
    CDialog::OnInitDialog();

    // 将“关于...”菜单项添加到系统菜单中。

    // IDM_ABOUTBOX 必须在系统命令范围内。
    ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
    ASSERT(IDM_ABOUTBOX < 0xF000);

    CMenu* pSysMenu = GetSystemMenu(FALSE);
    if (pSysMenu != NULL)
    {
        BOOL bNameValid;
        CString strAboutMenu;
        bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
        ASSERT(bNameValid);
        if (!strAboutMenu.IsEmpty())
        {
            pSysMenu->AppendMenu(MF_SEPARATOR);
            pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
        }
    }

    // 设置此对话框的图标。当应用程序主窗口不是对话框时，框架将自动
    //  执行此操作
    SetIcon(m_hIcon, TRUE);			// 设置大图标
    SetIcon(m_hIcon, FALSE);		// 设置小图标

    // TODO: 在此添加额外的初始化代码
    GetSysSerialPort(m_vtPorts);
    InitSerialCombobox();
    m_cbCOM.SelectString(0, Global::g_Config.twPort.c_str());
    LoadSignals();
    m_cbSignals.SelectString(0, Global::g_Config.twUseSignal.c_str());
    LoadKeyInfo(m_vtKeyInfo, Global::g_Config.twSignaldir + _T("\\") + Global::g_Config.twUseSignal + _T(".xml"));

    return TRUE;  // 除非将焦点设置到控件，否则返回 TRUE
}

void CTestWizardToolDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
    if ((nID & 0xFFF0) == IDM_ABOUTBOX)
    {
        CAboutDlg dlgAbout;
        dlgAbout.DoModal();
    }
    else
    {
        CDialog::OnSysCommand(nID, lParam);
    }
}

// 如果向对话框添加最小化按钮，则需要下面的代码
//  来绘制该图标。对于使用文档/视图模型的 MFC 应用程序，
//  这将由框架自动完成。

void CTestWizardToolDlg::OnPaint()
{
    if (IsIconic())
    {
        CPaintDC dc(this); // 用于绘制的设备上下文

        SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

        // 使图标在工作区矩形中居中
        int cxIcon = GetSystemMetrics(SM_CXICON);
        int cyIcon = GetSystemMetrics(SM_CYICON);
        CRect rect;
        GetClientRect(&rect);
        int x = (rect.Width() - cxIcon + 1) / 2;
        int y = (rect.Height() - cyIcon + 1) / 2;

        // 绘制图标
        dc.DrawIcon(x, y, m_hIcon);
    }
    else
    {
        CDialog::OnPaint();

    }
}

//当用户拖动最小化窗口时系统调用此函数取得光标
//显示。
HCURSOR CTestWizardToolDlg::OnQueryDragIcon()
{
    return static_cast<HCURSOR>(m_hIcon);
}

BOOL CTestWizardToolDlg::OnDeviceChange(UINT nEventType, DWORD_PTR dwData)
{
    switch (nEventType)
    {
        // 串口拨掉;
    case DBT_DEVICEREMOVECOMPLETE:
        break;
        // 串口插入;
    case DBT_DEVICEARRIVAL:
        {
            GetSysSerialPort(m_vtPorts);
            InitSerialCombobox();
            break;
        }	
    default:
        break;
    }
    return TRUE;
}

void CTestWizardToolDlg::InitSerialCombobox()
{
    m_cbCOM.ResetContent();
    for (std::vector<std::string>::iterator it = m_vtPorts.begin(); it != m_vtPorts.end(); it++) 
    {
        m_cbCOM.AddString(it->c_str());
    }
}

void CTestWizardToolDlg::AdjustLayout()
{
    if (GetSafeHwnd() == NULL || (AfxGetMainWnd() != NULL && AfxGetMainWnd()->IsIconic()) || !m_vtKeyInfo.size())
    {
        return;
    }

    CRect rcCtrl;
    CRect rectClient;
    GetClientRect(rectClient);
    TRACE2(_T("更新后的大小：%d,%d"), rectClient.Width(), rectClient.Height());
    m_cbCOM.GetWindowRect(rcCtrl);
    ScreenToClient(rcCtrl);

    int sx = 0, sy = rcCtrl.bottom + m_nTopMargin;
    int i = 0, id = 10000;
    int nWidth = (rectClient.Width() - 25) / m_nCols;
    DWORD dwStyle = WS_CHILD | WS_VISIBLE;
    for (std::vector<KeyInfo>::iterator it = m_vtKeyInfo.begin(); it != m_vtKeyInfo.end(); it++)
    {
        if (it->pbtnInfo->pBTN == NULL)
            continue;
        if (i != 0 && i % m_nCols == 0)
        {//换行;
            sy += it->height + m_nRowSpacing;
        }

        sx = m_nLeftMargin + (i % m_nCols) * nWidth + (i % m_nCols + 1) * m_nColSpacing;
        it->pbtnInfo->pBTN->SetWindowPos(NULL, sx, sy, nWidth, it->height, SWP_NOACTIVATE | SWP_NOZORDER);
        i++;
    }
}

void CTestWizardToolDlg::LoadSignals()
{
    filehelper fh;
    m_vtTWSignal.clear();
    fh.getfiles_findout_subfolder(Global::g_Config.twSignaldir.c_str(), _T("*.xml"), &m_vtTWSignal);

    m_cbSignals.ResetContent();
    for (std::vector<std::string>::iterator it = m_vtTWSignal.begin(); it != m_vtTWSignal.end(); it++ )
    {
        m_cbSignals.AddString(fh.getfilename(it->c_str()).c_str());
    }
}

void CTestWizardToolDlg::LoadKeyInfo(std::vector<KeyInfo> &vtKeyInfo, std::string path)
{
    // 解析xml;
    tinyxml2::XMLDocument doc;
    if (tinyxml2::XML_SUCCESS != doc.LoadFile(path.c_str()))
    {
        return;
    }

    vtKeyInfo.clear();
    std::string data;
    tinyxml2::XMLElement* pXmlRoot = NULL;
    if ((pXmlRoot = doc.RootElement()) != NULL)
    {
        if (_tcsicmp(pXmlRoot->Value(), "KeyList") == 0)
        {
            //////////////////////////////////////////////////////////////////////////
            // 获取属性;
            m_nCols = _tstoi(pXmlRoot->Attribute("cols") ? pXmlRoot->Attribute("cols") : "3");
            m_nRowSpacing = _tstoi(pXmlRoot->Attribute("rowSpacing") ? pXmlRoot->Attribute("rowSpacing") : "5");
            m_nColSpacing = _tstoi(pXmlRoot->Attribute("colSpacing") ? pXmlRoot->Attribute("colSpacing") : "5");
            m_nTopMargin = _tstoi(pXmlRoot->Attribute("topMargin") ? pXmlRoot->Attribute("topMargin") : "8");
            m_nLeftMargin = _tstoi(pXmlRoot->Attribute("leftMargin") ? pXmlRoot->Attribute("leftMargin") : "8");
            int nWidth = _tstoi(pXmlRoot->Attribute("with") ? pXmlRoot->Attribute("with") : "58");
            int nHeight = _tstoi(pXmlRoot->Attribute("height") ? pXmlRoot->Attribute("height") : "25");
            //////////////////////////////////////////////////////////////////////////

            // 子项;
            tinyxml2::XMLElement* pXmlElent = pXmlRoot->FirstChildElement();
            while (pXmlElent)
            {
                if (_tcsicmp(pXmlElent->Value(), _T("ITEM")) == 0)
                {
                    KeyInfo keyInfo;
                    // 获取属性值;
                    keyInfo.width = pXmlElent->Attribute("with") ? _ttol(pXmlElent->Attribute("with")) : nWidth;
                    keyInfo.height = pXmlElent->Attribute("height") ? _ttol(pXmlElent->Attribute("height")) : nHeight;
                    keyInfo.color = HexColor2RGB(pXmlElent->Attribute("color") ? pXmlElent->Attribute("color") : "87CEFA");

                    tinyxml2::XMLElement* pItem = pXmlElent->FirstChildElement();
                    while (pItem)
                    {
                        if (_tcsicmp(pItem->Value(), _T("NAME")) == 0)
                        {
                            keyInfo.strName = pItem->GetText();
                        }
                        else if (_tcsicmp(pItem->Value(), _T("USE")) == 0)
                        {
                            keyInfo.bUse = pItem->BoolText(true);
                        }
                        else if (_tcsicmp(pItem->Value(), _T("DESC")) == 0)
                        {
                            keyInfo.strDesc = pItem->GetText();
                        }
                        else if (_tcsicmp(pItem->Value(), _T("TYPE")) == 0)
                        {
                            keyInfo.strType = pItem->GetText();
                        }
                        else if (_tcsicmp(pItem->Value(), _T("VALUE")) == 0)
                        {
                            keyInfo.strValue = pItem->GetText();
                        }

                        pItem = pItem->NextSiblingElement();
                    }

                    keyInfo.pbtnInfo = GetUnUseBTN();
                    if ( keyInfo.pbtnInfo == NULL)
                    {
                        BTNInfo *pbtnInfo = new BTNInfo();
                        pbtnInfo->pBTN = new CMFCButton();
                        m_vtBTNInfo.push_back(pbtnInfo);

                        keyInfo.pbtnInfo = pbtnInfo;
                    }
                    SetBTNStatus(keyInfo.pbtnInfo, TRUE);
                    
                    vtKeyInfo.push_back(keyInfo);
                }

                pXmlElent = pXmlElent->NextSiblingElement();
            }
        }
    }

    int sx = 0, sy = m_nComboHeight * 2 + 15;
    int i = 0, id = 10000;
    DWORD dwStyle = WS_CHILD | WS_VISIBLE;
    int maxX = 0, maxY = 0;
    for (std::vector<KeyInfo>::iterator it = vtKeyInfo.begin(); it != vtKeyInfo.end(); it++)
    {
        if (i != 0 && i % m_nCols == 0)
        {//换行;
            sy += it->height + m_nRowSpacing;
        }

        sx = (i % m_nCols) * it->width + (i % m_nCols + 1) * m_nColSpacing;
        m_nDefaultWidth = m_nLeftMargin + m_nCols * it->width + m_nCols * m_nColSpacing;

        if ( !it->pbtnInfo->bCreated )
        {
            it->pbtnInfo->pBTN->Create(it->strName.c_str(), dwStyle, CRect(sx, sy, sx + it->width, sy + it->height), this, BTNID + i);
            it->pbtnInfo->bCreated = true;

            // 设置透明false以显示背景色
            it->pbtnInfo->pBTN->m_bTransparent = FALSE;
            it->pbtnInfo->pBTN->m_bDontUseWinXPTheme = TRUE;
            // 消除单击时黑色内圈;
            it->pbtnInfo->pBTN->m_bDrawFocus = FALSE;
            // 设置按钮扁平样式;
            it->pbtnInfo->pBTN->m_nFlatStyle = CMFCButton::FlatStyle::BUTTONSTYLE_FLAT;
            // 设置鼠标形状;
            it->pbtnInfo->pBTN->SetMouseCursorHand();
        }
       
        // 设置背景色;
        it->pbtnInfo->pBTN->SetFaceColor(it->color, TRUE);
        // 显示窗口;
        it->pbtnInfo->pBTN->ShowWindow(SW_SHOW);
        // 是否禁用;
        it->pbtnInfo->pBTN->EnableWindow(it->bUse);

        // 存入map中;
        m_map_key.insert(std::pair<UINT, KeyInfo*>(BTNID + i, &*it));

        i++;
    }

    m_nDefaultHeight = sy + m_nTopMargin;
    m_nDefaultHeight = m_nDefaultHeight < MINIMUM_WINDOWS_Y ? MINIMUM_WINDOWS_Y : m_nDefaultHeight;
    m_nDefaultWidth = m_nDefaultWidth < MINIMUM_WINDOWS_X ? MINIMUM_WINDOWS_X : m_nDefaultWidth+30;

    // 设置窗口大小;
    SetWindowPos(NULL,0,0, m_nDefaultWidth, m_nDefaultHeight, SWP_NOMOVE);

    AdjustLayout();
}

BTNInfo *CTestWizardToolDlg::GetUnUseBTN()
{
    for (std::vector<BTNInfo*>::iterator it = m_vtBTNInfo.begin(); it != m_vtBTNInfo.end(); it++ )
    {
        if ( !(*it)->bUsed )
            return *it;
    }

    return NULL;
}

void CTestWizardToolDlg::SetBTNStatus(BTNInfo *pbtnInfo, BOOL bStatus /* = TRUE */)
{
    if ( pbtnInfo )
    {
        pbtnInfo->bUsed = bStatus;
    }
}

void CTestWizardToolDlg::SetAllBTNUnUsed()
{
    BTNInfo *pbtnInfo = NULL;
    for (std::vector<BTNInfo*>::iterator it = m_vtBTNInfo.begin(); it != m_vtBTNInfo.end(); it++ )
    {
        pbtnInfo = (*it);
        if ( pbtnInfo )
        {
            pbtnInfo->bUsed = false;
            if ( pbtnInfo->bCreated )
            {
                pbtnInfo->pBTN->ShowWindow(SW_HIDE);
            }
        }
    }
}

void CTestWizardToolDlg::ClearAllBTNInfo()
{
    BTNInfo *pbtnInfo = NULL;
    for (std::vector<BTNInfo*>::iterator it = m_vtBTNInfo.begin(); it != m_vtBTNInfo.end(); it++ )
    {
        pbtnInfo = (*it);
        if ( pbtnInfo )
        {
            pbtnInfo->pBTN->DestroyWindow();
            delete pbtnInfo->pBTN;
            pbtnInfo->pBTN = NULL;
        }

        delete pbtnInfo;
        pbtnInfo = NULL;
    }

    m_vtBTNInfo.clear();
}

void CTestWizardToolDlg::OnSize(UINT nType, int cx, int cy)
{
    CDialog::OnSize(nType, cx, cy);

    // TODO: 在此处添加消息处理程序代码
    AdjustLayout();
}

void CTestWizardToolDlg::OnSizing(UINT fwSide, LPRECT pRect)
{
    CDialog::OnSizing(fwSide, pRect);

    // TODO: 在此处添加消息处理程序代码
}

void CTestWizardToolDlg::OnGetMinMaxInfo(MINMAXINFO* lpMMI)
{
    // TODO: 在此添加消息处理程序代码和/或调用默认值
    int cx = GetSystemMetrics(SM_CXSCREEN); 
    int cy = GetSystemMetrics(SM_CYSCREEN); 
    int nShellHight = 0;

    //获取任务栏
    CWnd* pTaskWnd = FindWindow( _T("Shell_TrayWnd"), NULL ); 

    if (pTaskWnd != NULL)
    {
        LONG lStyle = GetWindowLong( pTaskWnd->GetSafeHwnd(), GWL_STYLE ); 		

        //如果任务栏存在且可见，要减去任务栏高度
        if( lStyle & WS_VISIBLE ) 
        { 
            //任务栏可见 
            RECT TastRect;
            pTaskWnd->GetWindowRect(&TastRect); //任务栏的尺寸
            nShellHight = TastRect.bottom - TastRect.top;
        } 
        else 
        { 
            //任务栏隐藏 不做处理
        }
    }

    cy -= nShellHight;

    lpMMI->ptMaxSize.x = cx;  // 设置窗口最大化时的宽度
    lpMMI->ptMaxSize.y = cy;  // 设置窗口最大化时的高度
    lpMMI->ptMaxPosition.x = 0; // 设置窗口最大化时x坐标
    lpMMI->ptMaxPosition.y = 0; // 设置窗口最大化时y坐标
    lpMMI->ptMinTrackSize.x = MINIMUM_WINDOWS_X; // 设置窗口最小宽度
    lpMMI->ptMinTrackSize.y = MINIMUM_WINDOWS_Y; // 设置窗口最小高度
    lpMMI->ptMaxTrackSize.x = cx; // 设置窗口最大宽度
    lpMMI->ptMaxTrackSize.y = cy; // 设置窗口最大高度

    CDialog::OnGetMinMaxInfo(lpMMI);
}

void CTestWizardToolDlg::OnSignalBtnClick(UINT uId) // 发送遥控信号;
{
    CWnd* pWnd = GetFocus();
    int id = pWnd->GetDlgCtrlID();
    if (id >= BTNID && id <= BTNID + 100)
    {
        CString text;
        pWnd->GetWindowText(text);
        KeyInfo *pKey = m_map_key.find(id)->second;

        if ( m_Serial.IsOpen() ){
            // 封装发送包;
            byte szSendData[MAX_PATH] = {0};
            _stprintf_s((TCHAR*)szSendData, MAX_PATH, _T("*INPUT %s %s\r"), pKey->strType.c_str(), pKey->strValue.c_str());

            // 发送单信号;
            if ( m_Serial.WriteSync(szSendData, _tcslen((TCHAR*)szSendData)) )
            {
                memset(szSendData, 0, MAX_PATH);
                m_Serial.ReadSync(szSendData, MAX_PATH);
                TRACE("发送单信号成功\n");
            }
            else
            {
                TRACE("发送单信号失败\n");
            }
        }
        else
        {
            MessageBox(_T("The serial port is not open."), _T("Warnning"), MB_OK|MB_ICONWARNING);
        }
    }
}

void CTestWizardToolDlg::OnBnClickedOpenCom() // 打开串口;
{
    // TODO: 在此添加控件通知处理程序代码
    CString strText = _T("");
    GetDlgItemText(BTN_OPEN_COM, strText);
    if ( strText == _T("Open") )
    {
        int nCurSel = m_cbCOM.GetCurSel();
        if ( nCurSel != CB_ERR ) 
        {
            m_Serial.SetIOMode();
            m_cbCOM.GetLBText(nCurSel,strText);
            if ( m_Serial.Open(atol(strText.Mid(3).GetString()), 115200) )
            {
                SetDlgItemText(BTN_OPEN_COM, _T("Close"));
                m_cbCOM.EnableWindow(FALSE);
                m_Serial.SetBufferSize(1024,1024);
                WritePrivateProfileString("TestWizard", "Com", strText.GetString(), Global::g_szConfig);
            }
        }
    }
    else
    {
        m_cbCOM.EnableWindow();
        SetDlgItemText(BTN_OPEN_COM, _T("Open"));
        if ( m_Serial.IsOpen() )
            m_Serial.Close();
    }
}

void CTestWizardToolDlg::OnCbnSelchangeSingals()
{
    // TODO: 在此添加控件通知处理程序代码
    CString strSignal;
    int nCurSel = m_cbSignals.GetCurSel();
    if (nCurSel != CB_ERR)
    {
        std::string signalpath;
        m_cbSignals.GetLBText(nCurSel, strSignal);

        // 保存到配置文件中;
        Global::g_Config.twUseSignal = strSignal.GetString();
        WritePrivateProfileString("TestWizard", "useSignal", strSignal.GetString(), Global::g_szConfig);

        SetAllBTNUnUsed();
        LoadKeyInfo(m_vtKeyInfo, Global::g_Config.twSignaldir + _T("\\") +  Global::g_Config.twUseSignal + _T(".xml"));
    }
}

void CTestWizardToolDlg::OnBnClickedReloadSignal() // 重新加载;
{
    // TODO: 在此添加控件通知处理程序代码
    LoadSignals();
    m_cbSignals.SelectString(0, Global::g_Config.twUseSignal.c_str());
}

void CTestWizardToolDlg::OnDestroy()
{
    CDialog::OnDestroy();
    
    // TODO: 在此处添加消息处理程序代码
    ClearAllBTNInfo();
}

void CTestWizardToolDlg::OnOK()
{
    // TODO: 在此添加专用代码和/或调用基类

    //CDialog::OnOK();
}