g1g2hardwarechecker/G1G2HardwareCheckerDlg.cpp


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

#include "pch.h"
#include "framework.h"
#include "G1G2HardwareChecker.h"
#include "G1G2HardwareCheckerDlg.h"
#include "afxdialogex.h"
#include "applog.h"
#include "stringex.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif

static const char* loggername = "Dlg";
void string_replaceAll(std::string& str, const std::string& src, const std::string& dst)
{
	std::string::size_type pos = 0;
	std::string::size_type srclen = src.size();
	std::string::size_type dstlen = dst.size();

	while ((pos = str.find(src, pos)) != std::string::npos)
	{
		str.replace(pos, srclen, dst);
		pos += dstlen;
	}
}
// CG1G2HardwareCheckerDlg 对话框

std::string StringToUtf(std::string strValue)
{
	int nwLen = MultiByteToWideChar(CP_UTF8, 0, strValue.c_str(), -1, NULL, 0);
	wchar_t* pwBuf = new wchar_t[nwLen + 1];//加上末尾'\0'
	memset(pwBuf, 0, nwLen * 2 + 2);
	MultiByteToWideChar(CP_UTF8, 0, strValue.c_str(), strValue.length(), pwBuf, nwLen);
	int nLen = WideCharToMultiByte(CP_ACP, 0, pwBuf, -1, NULL, NULL, NULL, NULL);
	char* pBuf = new char[nLen + 1];
	memset(pBuf, 0, nLen + 1);
	WideCharToMultiByte(CP_ACP, 0, pwBuf, nwLen, pBuf, nLen, NULL, NULL);
	std::string retStr = pBuf;
	delete[]pBuf;
	delete[]pwBuf;
	return retStr;
}


CG1G2HardwareCheckerDlg::CG1G2HardwareCheckerDlg(CWnd* pParent /*=nullptr*/)
	: CDialogEx(IDD_G1G2HARDWARECHECKER_DIALOG, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDI_ICON_HG);
	LOG_INITX(logname);
}

void CG1G2HardwareCheckerDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_BTNCHK_RECOVERY, m_btn_check_recovery);
	SetBtnBgClr(&m_btn_check_recovery, BTNStatus::BTN_UNTESTED);
	DDX_Control(pDX, IDC_BTNCHK_POWER, m_btn_check_power);
	SetBtnBgClr(&m_btn_check_power, BTNStatus::BTN_UNTESTED);
	DDX_Control(pDX, IDC_BTNCHK_RESET, m_btn_ckeck_reset);
	SetBtnBgClr(&m_btn_ckeck_reset, BTNStatus::BTN_UNTESTED);
	DDX_Control(pDX, IDC_BTNCHK_POWERSUPPLY, m_btn_check_powersupply);
	SetBtnBgClr(&m_btn_check_powersupply, BTNStatus::BTN_UNTESTED);
	DDX_Control(pDX, IDC_BTNCHK_LED, m_btn_check_led);
	SetBtnBgClr(&m_btn_check_led, BTNStatus::BTN_UNTESTED);
	DDX_Control(pDX, IDC_BTNCHK_UART, m_btn_check_uart);
	SetBtnBgClr(&m_btn_check_uart, BTNStatus::BTN_UNTESTED);
	DDX_Control(pDX, IDC_BTNCHK_SWITCH, m_btn_check_switchs);
	SetBtnBgClr(&m_btn_check_switchs, BTNStatus::BTN_UNTESTED);
	DDX_Control(pDX, IDC_BTNCHK_IMAGE, m_btn_check_imgs);
	SetBtnBgClr(&m_btn_check_imgs, BTNStatus::BTN_UNTESTED);
	DDX_Control(pDX, IDC_BTNCHK_CAPACITY, m_btn_check_hw_capacity);
	SetBtnBgClr(&m_btn_check_hw_capacity, BTNStatus::BTN_UNTESTED);
	DDX_Control(pDX, IDC_BTNCHK_DISPLAY, m_btn_check_display);
	SetBtnBgClr(&m_btn_check_display, BTNStatus::BTN_UNTESTED);
	DDX_Control(pDX, IDC_CMB_DEVS, m_dev_cmbx);
	DDX_Control(pDX, IDC_LB_SHOWINFO, m_showinfo);
	m_showinfo.SetLimitText(0xfffffff);

	m_tile_font.CreatePointFont(125, _T("宋体"));
	m_info_font.CreatePointFont(120, _T("宋体"));
	GetDlgItem(IDC_LB_TITLE)->SetFont(&m_tile_font);
	GetDlgItem(IDC_LBL_CHECKINFO)->SetFont(&m_info_font);
	CRect rect;
	GetDlgItem(IDC_PIC_SHOW)->GetWindowRect(rect);
	GetDlgItem(IDC_PIC_SHOW)->MoveWindow(rect.left - 15, rect.top - 25, 370, 450, true);
}

BEGIN_MESSAGE_MAP(CG1G2HardwareCheckerDlg, CDialogEx)
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDC_BTN_REBOOT, &CG1G2HardwareCheckerDlg::OnBnClickedBtnReboot)
	ON_BN_CLICKED(IDC_BTN_POWEROFF, &CG1G2HardwareCheckerDlg::OnBnClickedBtnPoweroff)
	ON_BN_CLICKED(IDC_BTNCHK_RECOVERY, &CG1G2HardwareCheckerDlg::OnBnClickedBtnchkRecovery)
	ON_BN_CLICKED(IDC_BTNCHK_POWER, &CG1G2HardwareCheckerDlg::OnBnClickedBtnchkPower)
	ON_BN_CLICKED(IDC_BTNCHK_RESET, &CG1G2HardwareCheckerDlg::OnBnClickedBtnchkReset)
	ON_BN_CLICKED(IDC_BTNCHK_POWERSUPPLY, &CG1G2HardwareCheckerDlg::OnBnClickedBtnchkPowersupply)
	ON_BN_CLICKED(IDC_BTNCHK_LED, &CG1G2HardwareCheckerDlg::OnBnClickedBtnchkLed)
	ON_BN_CLICKED(IDC_BTNCHK_UART, &CG1G2HardwareCheckerDlg::OnBnClickedBtnchkUart)
	ON_BN_CLICKED(IDC_BTNCHK_SWITCH, &CG1G2HardwareCheckerDlg::OnBnClickedBtnchkSwitch)
	ON_BN_CLICKED(IDC_BTNCHK_IMAGE, &CG1G2HardwareCheckerDlg::OnBnClickedBtnchkImage)
	ON_BN_CLICKED(IDC_BTNCHK_CAPACITY, &CG1G2HardwareCheckerDlg::OnBnClickedBtnchkCapacity)
	ON_BN_CLICKED(IDC_BTN_CHECK, &CG1G2HardwareCheckerDlg::OnBnClickedBtnCheck)
	ON_BN_CLICKED(IDC_BTN_PASS, &CG1G2HardwareCheckerDlg::OnBnClickedBtnPass)
	ON_BN_CLICKED(IDC_BTN_NG, &CG1G2HardwareCheckerDlg::OnBnClickedBtnNg)
	ON_CBN_SELCHANGE(IDC_CMB_DEVS, &CG1G2HardwareCheckerDlg::OnCbxdevselect)
	ON_STN_DBLCLK(IDC_PIC_SHOW, &CG1G2HardwareCheckerDlg::OnStnDblclickPicShow)
	ON_BN_CLICKED(IDC_BTNCHK_FINISH, &CG1G2HardwareCheckerDlg::OnBnClickedBtnchkFinish)
	ON_BN_CLICKED(IDC_BTNCHK_DISPLAY, &CG1G2HardwareCheckerDlg::OnBnClickedBtnchkDisplay)
	ON_BN_CLICKED(IDC_BTN_OPENFLODER, &CG1G2HardwareCheckerDlg::OnBnClickedBtnOpenfloder)
END_MESSAGE_MAP()


// CG1G2HardwareCheckerDlg 消息处理程序

BOOL CG1G2HardwareCheckerDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();
	m_scn_manager.reset(new ScannerManager());
	m_scn_manager->SetScannerEventCallback(&CG1G2HardwareCheckerDlg::OnScannerEvent, this);
	m_scn_manager->Init();

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

	// TODO: 在此添加额外的初始化代码s

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

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

void CG1G2HardwareCheckerDlg::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
	{
		CDialogEx::OnPaint();
	}
}

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

void CG1G2HardwareCheckerDlg::SetBtnBgClr(CMFCButton* btn, BTNStatus status)
{
	if (!btn)
		return;

	switch (status)
	{
	case BTN_UNTESTED:
		btn->SetFaceColor(RGB(255, 128, 0));
		break;
	case BTN_PASS:
		btn->SetFaceColor(RGB(0, 255, 0));
		break;
	case BTN_NG:
		btn->SetFaceColor(RGB(255, 0, 0));
		break;
	default:
		break;
	}
	btn->m_bTransparent = FALSE;
	btn->m_bDontUseWinXPTheme = TRUE;
	btn->m_bDrawFocus = FALSE;
}

void CG1G2HardwareCheckerDlg::UpdateUI()
{

}

int CG1G2HardwareCheckerDlg::OnScannerEvent(DevEvent dev, int from, int status, int data_type, int data_len, void* data, void* user)
{
	CG1G2HardwareCheckerDlg* This = (CG1G2HardwareCheckerDlg*)user;
	if (This)
	{
		This->on_scanner_evt(dev, from, status, data_type, data_len, data);
	}
	return 1;
}

void CG1G2HardwareCheckerDlg::on_scanner_evt(DevEvent dev, int from, int status, int data_type, int data_len, void* data)
{
	std::lock_guard<std::mutex> mut(m_callback_mut);
	if (from == 0)//来自USB
	{
		if (dev.EvtCode == USB_EVENT_DEVICE_ARRIVED)
		{
			m_dev_cmbx.InsertString(dev.Index, CString(dev.Msg.c_str()));
			LOG_INFO(string_format("USB_EVENT_DEVICE_ARRIVED vid=%04x pid=%04x \n", dev.Vid, dev.Pid));
			if (m_dev_cmbx.GetCount() == 1)
			{
				m_scn_manager->SetCurrentDevice(0);
				m_task_infos = m_scn_manager->GetCurSupTests();
			}
		}
		else if (dev.EvtCode == USB_EVENT_DEVICE_LEFT)
		{
			LOG_INFO(string_format("USB_EVENT_DEVICE_LEFT vid=%04x pid=%04x \n", dev.Vid, dev.Pid));
			m_dev_cmbx.DeleteString(dev.Index);
			m_showinfo.SetWindowText(_T(""));
		}
	}
	else if (from == 1)//来自 scanner 实例
	{
		DATA_TYPE dt = (DATA_TYPE)data_type;
		switch (dt)
		{
		case DAT_UNKOWN:
			break;
		case DAT_INT:
			break;
		case DAT_DOUBLE:
			break;
		case DAT_STRING:
		{
			USES_CONVERSION;
			std::string info_s;
			info_s.resize(data_len);
			memcpy(&info_s[0], data, data_len);
			CString str = A2T(info_s.c_str());
			m_showinfo.SetSel(m_showinfo.GetWindowTextLength(), m_showinfo.GetWindowTextLength());
			m_showinfo.ReplaceSel(str);
		}
		break;
		case DAT_FLATINFO:
		{
			USES_CONVERSION;
			std::string info_s;
			info_s.resize(data_len);
			memcpy(&info_s[0], data, data_len);
			CString str = A2T(StringToUtf(info_s).c_str());
			m_showinfo.SetSel(m_showinfo.GetWindowTextLength(), m_showinfo.GetWindowTextLength());
			m_showinfo.ReplaceSel(str);
		}
		break;
		case DAT_USB:
			break;
		case DAT_IMAGE_PATH:
		{
			std::string img_path;
			img_path.resize(data_len);
			memcpy(&img_path[0], data, data_len);
			LOG_INFO(string_format("callback image path: %s \n",img_path.c_str()));

			CString path(img_path.c_str());
			draw_picture(path);
		}
		default:
			break;
		}
	}

	{
		GetDlgItem(IDC_BTN_REBOOT)->EnableWindow(m_dev_cmbx.GetCount() == 0 ? FALSE : TRUE);
		GetDlgItem(IDC_BTN_POWEROFF)->EnableWindow(m_dev_cmbx.GetCount() == 0 ? FALSE : TRUE);
	}
}

void CG1G2HardwareCheckerDlg::update_task_info(TASKID id)
{
	for (size_t i = 0; i < m_task_infos.size(); i++)
	{
		if (m_task_infos[i].id == id)
		{
			USES_CONVERSION;
			CString title = A2T(StringToUtf(m_task_infos[i].title).c_str());
			GetDlgItem(IDC_LB_TITLE)->SetWindowText(title);
			title = A2T(StringToUtf(m_task_infos[i].info).c_str());
			GetDlgItem(IDC_LBL_CHECKINFO)->SetWindowText(title);
			int en_human_check = m_task_infos[i].human_ajust;
			GetDlgItem(IDC_BTN_CHECK)->EnableWindow(en_human_check == 1 || en_human_check == 2);
			GetDlgItem(IDC_BTN_NG)->EnableWindow(en_human_check == 2 || en_human_check == 0);
			GetDlgItem(IDC_BTN_PASS)->EnableWindow(en_human_check == 2 || en_human_check == 0);
		}
	}
}

void CG1G2HardwareCheckerDlg::draw_picture(CString path)
{
	if (path.GetLength() == 0)
		return;

	CImage img;
	img.Load(path);
	CRect rectf;
	int cx = img.GetWidth();
	int cy = img.GetHeight();
	if (cx == 0 || cy == 0)
		return;
	CWnd* pWnd = GetDlgItem(IDC_PIC_SHOW);
	pWnd->GetClientRect(&rectf);
	CDC* pDC = pWnd->GetDC();
	SetStretchBltMode(pDC->m_hDC, STRETCH_HALFTONE);
	CPoint pos = rectf.TopLeft();
	rectf = CRect(pos, CSize(370, 450));
	img.Draw(pDC->m_hDC, rectf);
	ReleaseDC(pDC);
	img.Destroy();
	m_bupdate_img = true;
	m_img_path = path;
}

void CG1G2HardwareCheckerDlg::OnBnClickedBtnReboot()
{
	if (m_scn_manager.get())
	{
		m_scn_manager->Reboot(0);
	}
}


void CG1G2HardwareCheckerDlg::OnBnClickedBtnPoweroff()
{
	if (m_scn_manager.get())
	{
		m_scn_manager->PowerOFF();
	}
}

//外观检测
void CG1G2HardwareCheckerDlg::OnBnClickedBtnchkRecovery()
{
	m_task_id = TASK_ID_CHECK_OUTLOOK;
	update_task_info(m_task_id);
}

//机械性能
void CG1G2HardwareCheckerDlg::OnBnClickedBtnchkPower()
{
	m_task_id = TASK_ID_CHECK_MECHANICAL_PRP;
	update_task_info(m_task_id);
}

//装配校验
void CG1G2HardwareCheckerDlg::OnBnClickedBtnchkReset()
{
	m_task_id = TASK_ID_CKECK_ASSEMBLE;
	update_task_info(m_task_id);
}

//电源供电
void CG1G2HardwareCheckerDlg::OnBnClickedBtnchkPowersupply()
{
	m_task_id = TASK_ID_CHECK_POWERSUPPLY;
	update_task_info(m_task_id);
}

//PWR按键功能
void CG1G2HardwareCheckerDlg::OnBnClickedBtnchkLed()
{
	m_task_id = TASK_ID_CHECK_PWRBTN;
	update_task_info(m_task_id);
}

//RESET和RECOVERY按键功能检查
void CG1G2HardwareCheckerDlg::OnBnClickedBtnchkUart()
{
	m_task_id = TASK_ID_CHECK_RESET_RECOVERY_BTN;
	update_task_info(m_task_id);
}

//拨码开关检查
void CG1G2HardwareCheckerDlg::OnBnClickedBtnchkSwitch()
{
	m_task_id = TASK_ID_CHECK_SWITCHS;
	update_task_info(m_task_id);
}

//内存和存储容量检查
void CG1G2HardwareCheckerDlg::OnBnClickedBtnchkImage()
{
	m_task_id = TASK_ID_CHECK_HW_CAPACITY;
	update_task_info(m_task_id);
}

//图像检查
void CG1G2HardwareCheckerDlg::OnBnClickedBtnchkCapacity()
{
	m_task_id = TASK_ID_CHECK_IMGS;
	update_task_info(m_task_id);
}

//液晶显示校验
void CG1G2HardwareCheckerDlg::OnBnClickedBtnchkDisplay()
{
	// TODO: 在此添加控件通知处理程序代码
	m_task_id = TASK_ID_CHECK_DISPLAY;
	update_task_info(m_task_id);
}


void CG1G2HardwareCheckerDlg::OnBnClickedBtnCheck()
{
	if (m_scn_manager.get())
	{
		for (size_t i = 0; i < m_task_infos.size(); i++)
		{
			if (m_task_infos[i].id == m_task_id && m_task_infos[i].human_ajust)
			{
				USES_CONVERSION;
				CString str = A2T(StringToUtf(m_task_infos[m_task_id].title).c_str());
				str += +_T(" :自动校验中.....\r\n");
				m_showinfo.SetSel(m_showinfo.GetWindowTextLength(), m_showinfo.GetWindowTextLength());
				m_showinfo.ReplaceSel(str);
				m_scn_manager->AddTask(m_task_id);
			}
		}
	}
}


void CG1G2HardwareCheckerDlg::OnBnClickedBtnPass()
{
	if (m_scn_manager.get())
	{
		auto ret = m_scn_manager->UpdateTaskResult(m_task_id, "Pass");
		USES_CONVERSION;
		CString str = A2T(StringToUtf(m_task_infos[m_task_id].title).c_str());
		str += (ret == true ? _T(": 校验通过\r\n") : _T(": 校验更新失败\r\n"));
		m_showinfo.SetSel(m_showinfo.GetWindowTextLength(), m_showinfo.GetWindowTextLength());
		m_showinfo.ReplaceSel(str);
	}
}


void CG1G2HardwareCheckerDlg::OnBnClickedBtnNg()
{
	if (m_scn_manager.get())
	{
		auto ret = m_scn_manager->UpdateTaskResult(m_task_id, "NG");
		USES_CONVERSION;
		CString str = A2T(StringToUtf(m_task_infos[m_task_id].title).c_str());
		str += (ret == true ? _T(": 校验不通过\r\n") : _T(": 校验更新失败\r\n"));
		m_showinfo.SetSel(m_showinfo.GetWindowTextLength(), m_showinfo.GetWindowTextLength());
		m_showinfo.ReplaceSel(str);
	}
}


//void CG1G2HardwareCheckerDlg::OnBnClickedOk()
//{
//	// TODO: 在此添加控件通知处理程序代码
//	CDialogEx::OnOK();
//}

void CG1G2HardwareCheckerDlg::OnCbxdevselect()
{
	int cur_select = m_dev_cmbx.GetCurSel();
	m_scn_manager->SetCurrentDevice(cur_select);
	m_task_infos = m_scn_manager->GetCurSupTests();
}


void CG1G2HardwareCheckerDlg::OnStnDblclickPicShow()
{
	// TODO: 在此添加控件通知处理程序代码
	if (!m_bupdate_img)
		return;

	ShellExecute(NULL, _T("open"), m_img_path, NULL, NULL, SW_SHOWNORMAL);
}

//完成校验
void CG1G2HardwareCheckerDlg::OnBnClickedBtnchkFinish()
{
	if (m_scn_manager.get())
	{
		bool btest = true;
		CString str_info = _T("当前 ");
		for (size_t i = 0; i < m_scn_manager->GetCurSupTests().size(); i++)
		{
			if (m_scn_manager->GetCurSupTests()[i].tested == "False")
			{
				USES_CONVERSION;
				btest = false;
				CString info = A2T(StringToUtf(m_task_infos[i].title).c_str());
				str_info += info + _T(" ");
			}
		}

		if (btest)
			m_scn_manager->FinishTest();
		else
		{
			str_info += _T("未检测，请检测完成后再更新");
			MessageBox(str_info, _T("提示"), MB_OK | MB_ICONINFORMATION);
		}
	}
}



void CG1G2HardwareCheckerDlg::OnBnClickedBtnOpenfloder()
{
	// TODO: 在此添加控件通知处理程序代码
	TCHAR exeFullPath[MAX_PATH];
	CString strPath;
	GetModuleFileName(NULL, exeFullPath, MAX_PATH);
	strPath = (CString)exeFullPath;
	int position = strPath.ReverseFind('\\');
	strPath = strPath.Left(position + 1);
	strPath += "CacheImage";
	ShellExecute(NULL, _T("open"), strPath, NULL, NULL, SW_SHOWNORMAL);
}