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
#define MAX_SWITCH_LEN 16

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;
    m_bFindTestWizardPort = false;
    m_bFindSwitcherPort = false;
}

void CTestWizardToolDlg::DoDataExchange(CDataExchange* pDX)
{
    CDialog::DoDataExchange(pDX);
    DDX_Control(pDX, COMBO_COM, m_cbCOMTW);
    DDX_Control(pDX, COMBO_SINGALS, m_cbSignals);
    DDX_Control(pDX, BTN_OPEN_COM, m_btnOpenTW);
    DDX_Control(pDX, BTN_RELOAD_SIGNAL, m_btnReload);
    DDX_Control(pDX, IDC_STATIC_GROUP, m_stGroup);
    DDX_Control(pDX, BTN_OPEN_COM2, m_btnOpenUSB);
    DDX_Control(pDX, COMBO_COM2, m_cbUSBPort);
}

BEGIN_MESSAGE_MAP(CTestWizardToolDlg, CDialog)
    ON_WM_SYSCOMMAND()
    ON_WM_PAINT()
    ON_WM_DEVICECHANGE()
    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()
    ON_WM_TIMER()
    ON_BN_CLICKED(BTN_OPEN_COM2, &CTestWizardToolDlg::OnBnClickedOpenCom2)
    ON_BN_CLICKED(IDC_CHECK_A, &CTestWizardToolDlg::OnBnClickedCheckA)
    ON_BN_CLICKED(IDC_CHECK_B, &CTestWizardToolDlg::OnBnClickedCheckB)
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: 在此添加额外的初始化代码
    InitBtnStyle();
    m_stGroup.GetWindowRect(m_rcGroup);
    ScreenToClient(m_rcGroup);

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

    SetTimer(0, 100, NULL);

    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)
{
    //DEV_BROADCAST_DEVICEINTERFACE* pdbd = (DEV_BROADCAST_DEVICEINTERFACE*)dwData;
    DEV_BROADCAST_PORT *pbdp = (DEV_BROADCAST_PORT*)dwData;
    if ( pbdp && _tcsstr(pbdp->dbcp_name, _T("COM")) )
    {
        {
            // 查找是否有添加过该项;
            int nIndex = m_cbCOMTW.FindString(0, pbdp->dbcp_name);
            // 删除和新增前,先获取当前选中的项;
            CString strCurCOM = _T("");
            int nCurIndex = m_cbCOMTW.GetCurSel();
            if ( nCurIndex != CB_ERR )
                m_cbCOMTW.GetLBText(nCurIndex, strCurCOM);

            if ( nEventType == DBT_DEVICEREMOVECOMPLETE )
            {// 串口拨掉;
                TRACE(_T("串口拨掉\n"));
                if ( nIndex != CB_ERR )
                {                
                    m_cbCOMTW.DeleteString(nIndex);
                    // 删除后, 由于索引变化了,要重新设置选中项;
                    if ( nCurIndex != CB_ERR )
                        m_cbCOMTW.SelectString(0, strCurCOM);
                }
            }
            else if ( nEventType == DBT_DEVICEARRIVAL )
            {// 串口插入;
                TRACE(_T("串口插入\n"));
                if ( nIndex == CB_ERR )
                {
                    m_cbCOMTW.AddString(pbdp->dbcp_name);
                    // 新增后,由于索引变化了,要重新设置选中项;
                    if ( nCurIndex != CB_ERR )
                        m_cbCOMTW.SelectString(0, strCurCOM);
                    else
                    {
                        IsTestWizardPort(pbdp->dbcp_name);
                    }

                }
            }
        }

        {
            // 查找是否有添加过该项;
            int nIndex = m_cbUSBPort.FindString(0, pbdp->dbcp_name);
            // 删除和新增前,先获取当前选中的项;
            CString strCurCOM = _T("");
            int nCurIndex = m_cbUSBPort.GetCurSel();
            if ( nCurIndex != CB_ERR )
                m_cbUSBPort.GetLBText(nCurIndex, strCurCOM);

            if ( nEventType == DBT_DEVICEREMOVECOMPLETE )
            {// 串口拨掉;
                TRACE(_T("串口拨掉\n"));
                if ( nIndex != CB_ERR )
                {                
                    m_cbUSBPort.DeleteString(nIndex);
                    // 删除后, 由于索引变化了,要重新设置选中项;
                    if ( nCurIndex != CB_ERR )
                        m_cbUSBPort.SelectString(0, strCurCOM);
                }
            }
            else if ( nEventType == DBT_DEVICEARRIVAL )
            {// 串口插入;
                TRACE(_T("串口插入\n"));
                if ( nIndex == CB_ERR )
                {
                    m_cbUSBPort.AddString(pbdp->dbcp_name);
                    // 新增后,由于索引变化了,要重新设置选中项;
                    if ( nCurIndex != CB_ERR )
                        m_cbUSBPort.SelectString(0, strCurCOM);
                    else
                    {
                        IsUSBSwitchPort(pbdp->dbcp_name);
                    }

                }
            }
        }
    }

    TRACE(_T("OnDeviceChange\n"));

    return TRUE;
}

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

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

    CRect rectClient;
    GetClientRect(rectClient);
    TRACE2(_T("更新后的大小：%d,%d\n"), rectClient.Width(), rectClient.Height());

    int sx = 0, sy = m_rcGroup.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;
        sx = m_nLeftMargin + (i % m_nCols) * (nWidth + 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());
    }

    AutoSetDroppedWidth(&m_cbSignals);
}

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_rcGroup.bottom + m_nTopMargin;
    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();
        }
        else
        {
            it->pbtnInfo->pBTN->SetWindowText(it->strName.c_str());
        }

        // 设置背景色;
        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++;
    }

    std::vector<KeyInfo>::iterator it = vtKeyInfo.begin();
    m_nDefaultHeight = m_rcGroup.bottom + 15 + (vtKeyInfo.size()/m_nCols + (vtKeyInfo.size()%m_nCols > 0 ? 1 : 0)) * (it->height + m_nRowSpacing);
    m_nDefaultHeight = m_nDefaultHeight < MINIMUM_WINDOWS_Y ? MINIMUM_WINDOWS_Y : m_nDefaultHeight;

    m_nDefaultWidth = m_nLeftMargin*2 + m_nCols * it->width + m_nCols * m_nColSpacing;
    m_nDefaultWidth = m_nDefaultWidth < MINIMUM_WINDOWS_X ? MINIMUM_WINDOWS_X : m_nDefaultWidth;

    // 获取标题栏高度;
    int nCaptionHeight = 39; //GetSystemMetrics(SM_CYCAPTION);不准 GetWindowRect - GetClientRect
    // 设置窗口大小;
    SetWindowPos(NULL, 0, 0, m_nDefaultWidth, m_nDefaultHeight + nCaptionHeight, SWP_NOMOVE|SWP_FRAMECHANGED);   //SWP_NOACTIVATE | SWP_NOZORDER

    AdjustLayout();
}

void CTestWizardToolDlg::ConvertOldSignalsToNew(std::string strOldSignal, std::string strNewSignal)
{
    typedef struct
    {
        std::string name;
        std::string protocol;
        std::string key;
        //std::string color;
    }OldXML, *pOldXML;

    std::vector<OldXML> vtOldXML;
    tinyxml2::XMLDocument doc;
    if (tinyxml2::XML_SUCCESS != doc.LoadFile(strOldSignal.c_str()))
    {
        return;
    }

    tinyxml2::XMLElement* pXmlRoot = NULL;
    if ((pXmlRoot = doc.RootElement()) != NULL)
    {
        if (_tcsicmp(pXmlRoot->Value(), "KeyList") == 0)
        {
            // 子项;
            tinyxml2::XMLElement* pXmlElent = pXmlRoot->FirstChildElement();
            while (pXmlElent)
            {
                if (_tcsicmp(pXmlElent->Value(), _T("ITEM")) == 0)
                {
                    OldXML oldxml;
                    tinyxml2::XMLElement* pItem = pXmlElent->FirstChildElement();
                    while (pItem)
                    {
                        if (_tcsicmp(pItem->Value(), _T("KeyName")) == 0)
                        {
                            oldxml.name = pItem->GetText();
                        }
                        else if (_tcsicmp(pItem->Value(), _T("KeyType")) == 0)
                        {
                            oldxml.protocol = pItem->GetText();
                        }
                        else if (_tcsicmp(pItem->Value(), _T("KeyCode")) == 0)
                        {
                            oldxml.key = pItem->GetText();
                        }
                        else if (_tcsicmp(pItem->Value(), _T("KeyCode")) == 0)
                        {
                            oldxml.key = pItem->GetText();
                        }

                        pItem = pItem->NextSiblingElement();
                    }

                    vtOldXML.push_back(oldxml);
                }

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

    if ( vtOldXML.size() == 0 )
        return;

    // 创建新的xml文件;
    const char* declaration = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
    doc.Parse(declaration); // 覆盖之前的xml;

    pXmlRoot = doc.NewElement("KeyList");
    if ( pXmlRoot )
    {
        pXmlRoot->SetAttribute(_T("cols"), _T("4"));
        pXmlRoot->SetAttribute(_T("with"), _T("60"));
        pXmlRoot->SetAttribute(_T("height"), _T("25"));
        pXmlRoot->SetAttribute(_T("rowSpacing"), _T("5"));
        pXmlRoot->SetAttribute(_T("colSpacing"), _T("3"));
        pXmlRoot->SetAttribute(_T("leftMargin"), _T("8"));
        pXmlRoot->SetAttribute(_T("topMargin"), _T("8"));
        pXmlRoot->SetAttribute(_T("ver"), _T("1.0.0.1"));
        pXmlRoot->SetAttribute(_T("desc"), _T("key info"));
        doc.InsertEndChild(pXmlRoot);

        for (std::vector<OldXML>::iterator it = vtOldXML.begin(); it != vtOldXML.end(); it++ )
        {
            tinyxml2::XMLElement* pXmlElent = doc.NewElement("ITEM");
            if ( pXmlElent )
            {
                pXmlElent->SetAttribute(_T("color"), _T("87CEFA"));
                // 赋值各元素节点;
                tinyxml2::XMLElement *pUse = doc.NewElement("USE");
                pUse->SetText(1);
                pXmlElent->InsertEndChild(pUse);

                tinyxml2::XMLElement *pName = doc.NewElement("NAME");
                pName->SetText(it->name.c_str());
                pXmlElent->InsertEndChild(pName);

                tinyxml2::XMLElement *pDesc = doc.NewElement("DESC");
                pDesc->SetText(_T(""));
                pXmlElent->InsertEndChild(pDesc);

                tinyxml2::XMLElement *pType = doc.NewElement("TYPE");
                pType->SetText(it->protocol.c_str());
                pXmlElent->InsertEndChild(pType);

                tinyxml2::XMLElement *pValue = doc.NewElement("VALUE");
                pValue->SetText(it->key.c_str());
                pXmlElent->InsertEndChild(pValue);

                pXmlRoot->InsertEndChild(pXmlElent);
            }
        }
    }

    doc.SaveFile(strNewSignal.c_str());
}

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_SerialTW.IsOpen() ){
            m_SerialTW.SetTimeouts();
            // 封装发送包;
            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_SerialTW.WriteSync(szSendData, _tcslen((TCHAR*)szSendData)) )
            {
                memset(szSendData, 0, MAX_PATH);
                m_SerialTW.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_cbCOMTW.GetCurSel();
        if ( nCurSel != CB_ERR ) 
        {
            m_SerialTW.SetIOMode();
            m_cbCOMTW.GetLBText(nCurSel,strText);
            if ( m_SerialTW.Open(atol(strText.Mid(3).GetString()), 115200) )
            {
                SetDlgItemText(BTN_OPEN_COM, _T("Close"));
                m_cbCOMTW.EnableWindow(FALSE);
                m_SerialTW.SetBufferSize(1024,1024);
                WritePrivateProfileString("TestWizard", "Com", strText.GetString(), Global::g_szConfig);
            }
        }
    }
    else
    {
        m_cbCOMTW.EnableWindow();
        SetDlgItemText(BTN_OPEN_COM, _T("Open"));
        if ( m_SerialTW.IsOpen() )
            m_SerialTW.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();
}

void CTestWizardToolDlg::InitBtnStyle()
{
    // 设置透明false以显示背景色
    m_btnOpenTW.m_bTransparent = FALSE;
    //m_btnOpen.m_bDontUseWinXPTheme = TRUE;
    // 消除单击时黑色内圈;
    m_btnOpenTW.m_bDrawFocus = FALSE;
    // 设置按钮扁平样式;
    //m_btnOpen.m_nFlatStyle = CMFCButton::FlatStyle::BUTTONSTYLE_FLAT;
    // 设置鼠标形状;
    m_btnOpenTW.SetMouseCursorHand();
    // 设置背景色;
    m_btnOpenTW.SetFaceColor(RGB(250,80,80), TRUE);
    // 显示窗口;
    m_btnOpenTW.ShowWindow(SW_SHOW);
    m_btnOpenTW.SetTooltip(_T("Open the serial port"));

    // 设置透明false以显示背景色
    m_btnReload.m_bTransparent = FALSE;
    //m_btnReload.m_bDontUseWinXPTheme = TRUE;
    // 消除单击时黑色内圈;
    m_btnReload.m_bDrawFocus = FALSE;
    // 设置按钮扁平样式;
    //m_btnReload.m_nFlatStyle = CMFCButton::FlatStyle::BUTTONSTYLE_FLAT;
    // 设置鼠标形状;
    m_btnReload.SetMouseCursorHand();
    // 设置背景色;
    m_btnReload.SetFaceColor(RGB(135,220,238), TRUE);
    // 显示窗口;
    m_btnReload.ShowWindow(SW_SHOW);
    m_btnReload.SetTooltip(_T("Reload the signal file"));

    // 设置透明false以显示背景色
    m_btnOpenUSB.m_bTransparent = FALSE;
    //m_btnOpen.m_bDontUseWinXPTheme = TRUE;
    // 消除单击时黑色内圈;
    m_btnOpenUSB.m_bDrawFocus = FALSE;
    // 设置按钮扁平样式;
    //m_btnOpen.m_nFlatStyle = CMFCButton::FlatStyle::BUTTONSTYLE_FLAT;
    // 设置鼠标形状;
    m_btnOpenUSB.SetMouseCursorHand();
    // 设置背景色;
    m_btnOpenUSB.SetFaceColor(RGB(230,100,80), TRUE);
    // 显示窗口;
    m_btnOpenUSB.ShowWindow(SW_SHOW);
    m_btnOpenUSB.SetTooltip(_T("Open the usbmodel port"));
}

BOOL CTestWizardToolDlg::PreTranslateMessage(MSG* pMsg)
{
    // TODO: 在此添加专用代码和/或调用基类
    if (pMsg->message == WM_KEYDOWN)
    {
        if (pMsg->wParam == VK_F3)
        {
            // 查找目录文件;
            filehelper fh;
            std::vector<std::string> vtSignals;
            fh.getfiles_findout_subfolder(Global::g_Config.twOldSignaldir.c_str(), _T("*.xml"), &vtSignals);
            // 逐个文件转换;
            for ( std::vector<std::string>::iterator it = vtSignals.begin(); it != vtSignals.end(); it++ )
            {
                std::string newfile = Global::g_Config.twSignaldir + _T("\\") + filehelper::getfilename(it->c_str()) + _T(".xml");
                ConvertOldSignalsToNew(*it, newfile);
            }

            MessageBox(_T("Convert old signals ok!"), _T("Convert"), MB_OK);
            OnBnClickedReloadSignal();

            return TRUE;
        }
    }
    return CDialog::PreTranslateMessage(pMsg);
}

void CTestWizardToolDlg::AutoSetDroppedWidth(CComboBox* pCombobox)
{
    if (!pCombobox)
        return;
    // Find the longest string in the combo box.
    CString str;
    CSize sz;
    int dx = 0;

    TEXTMETRIC tm = { 0 };
    CDC* pDC = pCombobox->GetDC();
    CFont* pFont = pCombobox->GetFont();

    // Select the listbox font, save the old font
    CFont* pOldFont = pDC->SelectObject(pFont);

    // Get the text metrics for avg char width
    pDC->GetTextMetrics(&tm);

    for (int i = 0; i < pCombobox->GetCount(); i++)
    {
        pCombobox->GetLBText(i, str);
        sz = pDC->GetTextExtent(str);

        // Add the avg width to prevent clipping
        sz.cx += tm.tmAveCharWidth;

        if (sz.cx > dx)
            dx = sz.cx;
    }

    // Select the old font back into the DC
    pDC->SelectObject(pOldFont);
    pCombobox->ReleaseDC(pDC);

    // Set the horizontal extent so every character of all strings can
    // be scrolled to.
    pCombobox->SetHorizontalExtent(dx);
}

bool CTestWizardToolDlg::IsTestWizardPort(CString strCOMPort)
{
    CString strText = _T("");
    GetDlgItemText(BTN_OPEN_COM, strText);
    if ( strText == _T("Close") )
    {// 串口已打开;
        return false;
    }

    /* 
       发送：
            *about 
       返回：
            *about

            Product name:      Test Wizard
            Firmware version:  v3.6.210811
            SN:                30FF6B064243393036140457
            Active state:      Activated

            Developer:         sun shengpeng
            Email:             sunsp@tcl.com
    */
    m_SerialTW.SetIOMode();
    if ( m_SerialTW.Open(atol(strCOMPort.Mid(3).GetString()), 115200) )
    {
        // 快速响应读写,不需要设置过长的超时;
        m_SerialTW.SetTimeouts(0,1,20,1,150);
        // 封装发送包;
        byte szSendData[MAX_PATH] = _T("*about\r");
        if ( m_SerialTW.WriteSync(szSendData, _tcslen((TCHAR*)szSendData)) )
        {
            memset(szSendData, 0, MAX_PATH);
            m_SerialTW.ReadSync(szSendData, MAX_PATH);
            if ( _tcsstr((TCHAR*)szSendData, _T("Product name:      Test Wizard\r")) )
            {
                // 设置当前串口为选中状态;
                m_cbCOMTW.SelectString(0, strCOMPort);
                Global::g_Config.twPort = strCOMPort;
                WritePrivateProfileString("TestWizard", "Com", strCOMPort.GetString(), Global::g_szConfig);
                // SetDlgItemText(BTN_OPEN_COM, _T("Close"));
                // m_cbCOM.EnableWindow(FALSE);
                // 关闭后,重新打开在设置超时值;
                m_SerialTW.Close();
                return true;
            }
            TRACE("发送单信号成功\n");
        }
        else
        {
            TRACE("发送单信号失败\n");
        }

        m_SerialTW.Close();
    }

    return false;
}

bool CTestWizardToolDlg::IsUSBSwitchPort(CString strCOMPort)
{
    CString strText = _T("");
    GetDlgItemText(BTN_OPEN_COM2, strText);
    if ( strText == _T("Close") )
    {// 串口已打开;
        return false;
    }

    /* 
       发送：
            *SET PORT A\r 
       返回：
            set PORT A\r\n 
    */
    m_SerialUSB.SetIOMode();
    if ( m_SerialUSB.Open(atol(strCOMPort.Mid(3).GetString()), 115200) )
    {
        // 快速响应读写,不需要设置过长的超时;
        m_SerialUSB.SetTimeouts(0,1,20,1,150);
        // 封装发送包;
        byte szSendData[MAX_PATH] = _T("*SET PORT A\r");
        if ( m_SerialUSB.WriteSync(szSendData, _tcslen((TCHAR*)szSendData)) )
        {
            memset(szSendData, 0, MAX_PATH);
            m_SerialUSB.ReadSync(szSendData, MAX_PATH);
            if ( _tcscmp((TCHAR*)szSendData, _T("set PORT A\r\n")) == 0 )
            {
                // 设置当前串口为选中状态;
                m_cbUSBPort.SelectString(0, strCOMPort);
                Global::g_Config.switchPort = strCOMPort;
                WritePrivateProfileString("Switcher", "Com", strCOMPort.GetString(), Global::g_szConfig);
                // SetDlgItemText(BTN_OPEN_COM, _T("Close"));
                // m_cbCOM.EnableWindow(FALSE);
                // 关闭后,重新打开在设置超时值;
                m_SerialUSB.Close();
                return true;
            }
            TRACE("发送单信号成功\n");
        }
        else
        {
            TRACE("发送单信号失败\n");
        }

        m_SerialUSB.Close();
    }

    return false;
}

void CTestWizardToolDlg::SwitchUSB(BOOL bCheckA)
{
    if ( m_SerialUSB.IsOpen() )
    {
        m_SerialUSB.SetTimeouts(0,2,50,1,150);
        // 封装发送包;
        byte szSendData[MAX_SWITCH_LEN] = {0};
        _stprintf_s((TCHAR*)szSendData, MAX_SWITCH_LEN, _T("*SET PORT %c\r"), bCheckA ? 'A':'B');

        // 发送单信号;
        if ( m_SerialUSB.WriteSync(szSendData, _tcslen((TCHAR*)szSendData)) )
        {
            memset(szSendData, 0, MAX_SWITCH_LEN);
            m_SerialUSB.ReadSync(szSendData, MAX_SWITCH_LEN);
            TRACE("切换U盘成功\n");
        }
        else
        {
            TRACE("切换U盘失败\n");
        }
    }
}

void CTestWizardToolDlg::OnTimer(UINT_PTR nIDEvent)
{
    // TODO: 在此添加消息处理程序代码和/或调用默认值
    if ( nIDEvent == 0 )
    {
        KillTimer(nIDEvent);
        GetSysSerialPort(m_vtPorts);
        InitSerialCombobox();
        if ( CB_ERR == m_cbCOMTW.SelectString(0, Global::g_Config.twPort.c_str()) )
        {
            for (std::vector<std::string>::iterator it = m_vtPorts.begin(); it != m_vtPorts.end(); it++) 
            {
                if ( !m_bFindTestWizardPort )
                {
                    m_bFindTestWizardPort = IsTestWizardPort(it->c_str());
                }

                if ( !m_bFindSwitcherPort )
                {
                    m_bFindSwitcherPort = IsUSBSwitchPort(it->c_str());
                }
            }

            if ( !m_bFindTestWizardPort )
                MessageBox(_T("No Test Wizard found"), _T("Prompt"), MB_OK);
        }

        if ( CB_ERR == m_cbUSBPort.SelectString(0, Global::g_Config.switchPort.c_str()) )
        {
            for (std::vector<std::string>::iterator it = m_vtPorts.begin(); it != m_vtPorts.end(); it++) 
            {
                if ( !m_bFindSwitcherPort )
                {
                    m_bFindSwitcherPort = IsUSBSwitchPort(it->c_str());
                }
            }

            if ( !m_bFindSwitcherPort )
                MessageBox(_T("No USB Switcher found"), _T("Prompt"), MB_OK);
        }
    }

    CDialog::OnTimer(nIDEvent);
}

void CTestWizardToolDlg::OnBnClickedOpenCom2()  // 打开USB模块串口;
{
    // TODO: 在此添加控件通知处理程序代码
    CString strText = _T("");
    GetDlgItemText(BTN_OPEN_COM2, strText);
    if ( strText == _T("Open") )
    {
        int nCurSel = m_cbUSBPort.GetCurSel();
        if ( nCurSel != CB_ERR ) 
        {
            m_SerialUSB.SetIOMode();
            m_cbUSBPort.GetLBText(nCurSel,strText);
            if ( m_SerialUSB.Open(atol(strText.Mid(3).GetString()), 115200) )
            {
                SetDlgItemText(BTN_OPEN_COM2, _T("Close"));
                m_cbUSBPort.EnableWindow(FALSE);
                m_SerialUSB.SetBufferSize(1024,1024);
                WritePrivateProfileString("Switcher", "Com", strText.GetString(), Global::g_szConfig);

                // 启用复选框;
                GetDlgItem(IDC_CHECK_A)->EnableWindow();
                GetDlgItem(IDC_CHECK_B)->EnableWindow();
            }
        }
    }
    else
    {
        m_cbUSBPort.EnableWindow();
        SetDlgItemText(BTN_OPEN_COM2, _T("Open"));
        if ( m_SerialUSB.IsOpen() )
            m_SerialUSB.Close();

        // 启用复选框;
        GetDlgItem(IDC_CHECK_A)->EnableWindow(FALSE);
        GetDlgItem(IDC_CHECK_B)->EnableWindow(FALSE);
    }
}

void CTestWizardToolDlg::OnBnClickedCheckA()
{
    // TODO: 在此添加控件通知处理程序代码
    CButton *pChckA = (CButton*)GetDlgItem(IDC_CHECK_A);
    BOOL bChecA = pChckA->GetCheck();
    
    pChckA->SetCheck(bChecA);
    ((CButton*)GetDlgItem(IDC_CHECK_B))->SetCheck(!bChecA);
    SwitchUSB(bChecA);
}

void CTestWizardToolDlg::OnBnClickedCheckB()
{
    // TODO: 在此添加控件通知处理程序代码
    CButton *pChckB = (CButton*)GetDlgItem(IDC_CHECK_B);
    BOOL bChecB = pChckB->GetCheck();

    pChckB->SetCheck(bChecB);
    ((CButton*)GetDlgItem(IDC_CHECK_A))->SetCheck(!bChecB);
    SwitchUSB(!bChecB);
}