myvtm/Module/mod_guiconsole/mainfrm.cpp

#include "stdafx2.h"
#include "mainfrm.h"
#include "guitask.h"
#include "fileutil.h"
#include "array.h"
#include "iniutil.h"
#include "EventCode.h"
#include "import_libSysInit.h"

#include "AccessAuthorization_client_g.h"
using namespace AccessAuthorization;

#include "UpgradeManager_client_g.h"
using namespace UpgradeManager;

#include "CardIssuer_client_g.h"
using namespace CardIssuer;

#include "MaterialMgrCnn.h"
#include "mod_GuiConsole.h"

LRESULT CAboutDlg::OnClose(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	EndDialog(0);
	return 0;
}

void CAboutDlg::OnOK(UINT uNotifyCode, int nID, CWindow wndCtl)
{
	char szY2KTime[64] = {};
	GetDlgItem(IDC_EDIT1).GetWindowTextA(szY2KTime, sizeof(szY2KTime));

	int nLen = strlen(szY2KTime);
	if (nLen == 0)
		return;

	DWORD nY2KTime(0);
	int nRet= sscanf_s(szY2KTime, "%X", &nY2KTime);
	if (nRet == 0)
	{
		MessageBox("invalid y2k time");
		return;
	}
	
	CSmallDateTime dtSysTime(nY2KTime);
	GetDlgItem(IDC_EDIT2).SetWindowTextA(dtSysTime.ToTimeString());	
}

#include "MaintainWatcher_client_g.h"
using namespace MaintainWatcher;

void CAboutDlg::OnOK2(UINT uNotifyCode, int nID, CWindow wndCtl)
{
	GetDlgItem(IDC_EDIT3).SetWindowTextA("");

	CDateTimePickerCtrl dt1;
	dt1.Attach(GetDlgItem(IDC_DATETIMEPICKER1));	
	SYSTEMTIME st1 = {};
	dt1.GetSystemTime(&st1);

	CDateTimePickerCtrl dt2;
	dt2.Attach(GetDlgItem(IDC_DATETIMEPICKER2));
	SYSTEMTIME st2 = {};
	dt2.GetSystemTime(&st2);

	st1.wHour = st2.wHour;
	st1.wMinute = st2.wMinute;
	st1.wSecond = st2.wSecond;
	st1.wMilliseconds = st2.wMilliseconds;
	
	auto pEntity = m_pGUITask->GetEntity();
	CSmallDateTime dtQueryTime;
	dtQueryTime.FromSystemTime(st1);
	CBootInfo info = {};
	pEntity->GetFunction()->GetRebootInfo(dtQueryTime, info);
	
	CSimpleStringA str = CSimpleStringA::Format("start: %s, reboot: %s, ver: %s, reason: %d, reason count: %d, way: %d, way count: %d",
		(const char*)info.tmStart.ToTimeString(), (const char*)info.tmReboot.ToTimeString(), (const char*)info.InstallVersion.ToString(),
		info.eTriggerReason, info.wSameReasonTime, info.eWay, info.wSameWayTime);
	GetDlgItem(IDC_EDIT3).SetWindowTextA(str);

	//auto pEntity = m_pGUITask->GetEntity();
	MaintainCertificate_ClientBase *pClient = new MaintainCertificate_ClientBase(pEntity);
	auto rc = pClient->Connect();
	if (rc != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("connect to MaintainWatcher entity fail: %d", rc);
	}
	else
	{
		MaintainCertificate_GetUserInfo_Req req = {};
		MaintainCertificate_GetUserInfo_Ans ans = {};
		rc = pClient->GetUserInfo(req, ans, 10000);
		if (rc != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get userinfo fail from MaintainWatcher: %d", rc);
			pClient->SafeDelete();
		}
		else
		{
			// UserID=SP00000004;UserName=RVC0001;AuthorierID=SP00000001;AuthorizeTime=2014/8/13 18:46:29;RecommenderSAP=80274390;RecommenderOfficeID=274390;
			CSimpleStringA &str = ans.UserInfo;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get maintainer info: %s", (const char*)str);

			CSimpleStringA m_strUserID, m_strUserName, m_strAuthorizer, m_strAuthTime;
			auto arr = str.Split(';');
			for (int i = 0; i < arr.GetCount(); i++)
			{
				auto arr2 = arr[i].Split('=');
				if (arr2.GetCount() != 2)
					continue;

				if (arr2[0] == "UserID")
					m_strUserID = arr2[1];
				else if (arr2[0] == "UserName")
					m_strUserName = arr2[1];
				else if (arr2[0] == "AuthorierID")
					m_strAuthorizer = arr2[1];
				else if (arr2[0] == "AuthorizeTime")
					m_strAuthTime = arr2[1];
			}

			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("UserID=%s;UserName=%s;Authorizer=%s;AuthTime=%s",
				(const char*)m_strUserID,
				(const char*)m_strUserName,
				(const char*)m_strAuthorizer,
				(const char*)m_strAuthTime);

			pClient->GetFunction()->CloseSession();
		}
		
		pClient = NULL;
	}
}

void CAboutDlg::OnOK3(UINT uNotifyCode, int nID, CWindow wndCtl)
{
	char szFile[256] = {};
	GetDlgItem(IDC_EDIT4).GetWindowTextA(szFile, sizeof(szFile));
	if (strlen(szFile) == 0)
	{
		MessageBoxA("请输入要验证签名的文件路径!");
		return;
	}

	auto pEntity = m_pGUITask->GetEntity();
	CSimpleStringA strErrMsg;
	auto rc = pEntity->GetFunction()->VerifySignature(szFile, strErrMsg);
	if (rc == Error_Succeed)
		MessageBoxA("签名验证通过！");
	else
		MessageBoxA(CSimpleStringA::Format("签名验证不通过：%s", (const char*)strErrMsg));
}

void CAboutDlg::OnOK4(UINT uNotifyCode, int nID, CWindow wndCtl)
{
	auto pEntity = m_pGUITask->GetEntity();
	CSystemStaticInfo info;
	auto rc = pEntity->GetFunction()->GetSystemStaticInfo(info);
	if (rc != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("GetSystemStaticInfo fail: %d", rc);
		return;
	}

	CSimpleStringA str = CSimpleStringA::Format("terminalno: %s, type: %s, site: %s, version: %s",
		(const char*)info.strTerminalID, (const char*)info.strMachineType,
		(const char*)info.strSite, (const char*)info.InstallVersion.ToString());
	GetDlgItem(IDC_EDIT3).SetWindowTextA(str);
}

LRESULT CAboutDlg::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	CenterWindow();
	return 0;
}

LRESULT CLoginDlg::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	CenterWindow();
	GetDlgItem(IDC_EditUser).SetFocus();
	return 0;
}

void CLoginDlg::OnOK(UINT uNotifyCode, int nID, CWindow wndCtl)
{
	char szUserID[32] = {};
	GetDlgItem(IDC_EditUser).GetWindowTextA(szUserID, sizeof(szUserID));

	char szPassword[32] = {};
	GetDlgItem(IDC_EditPassword).GetWindowTextA(szPassword, sizeof(szPassword));

	EndDialog(nID);

	m_strUserID = szUserID;

	if (m_strUserID.Compare("admin") != 0)
	{
		if (m_strUserID.GetLength() == 8)		// SAP用户
			m_strUserID = "SP" + m_strUserID;
		else
			m_strUserID = "SZ" + m_strUserID;
	}

	m_strPassword = szPassword;
}

void CLoginDlg::OnCancel(UINT uNotifyCode, int nID, CWindow wndCtl)
{
	EndDialog(nID);
	m_strUserID = "";
	m_strPassword = "";
}

LRESULT CSysInfoView::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	m_listView1 = GetDlgItem(IDC_VIEWLIST1);
	m_listView1.AddColumn("Item1", 0);
	m_listView1.AddColumn("Item2", 1);

	RECT rc = {};
	m_listView1.GetClientRect(&rc);
	m_listView1.SetColumnWidth(0, (rc.right-rc.left)*1/2);
	m_listView1.SetColumnWidth(1, LVSCW_AUTOSIZE_USEHEADER);

	return 0;
}

void CSysInfoView::OutputMsg(const char *pMsg)
{
	::PostMessage(GetTopLevelParent().m_hWnd, WM_SHOW_MSG, 0, (LPARAM) strdup(pMsg));
}

DWORD64 CSysInfoView::GetFolderSize(LPCTSTR szPath, DWORD *dwFiles, DWORD *dwFolders)
{
	TCHAR szFileFilter[512];
	TCHAR szFilePath[512];
	HANDLE hFind = NULL;
	WIN32_FIND_DATA fileinfo;
	DWORD64    dwSize = 0;

	strcpy(szFilePath,szPath);
	strcat(szFilePath,"\\");
	strcpy(szFileFilter,szFilePath);
	strcat(szFileFilter,"*.*");

	hFind = FindFirstFile(szFileFilter,&fileinfo);
	if (hFind == INVALID_HANDLE_VALUE)
		return 0;

	do
	{
		if(fileinfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
		{
			if (!strcmp(fileinfo.cFileName,".") || !strcmp(fileinfo.cFileName,".."))
			{
				//Do nothing for "." and ".." folders
			}
			else
			{
				TCHAR sztmp[512];
				strcpy(sztmp,szFilePath);
				strcat(sztmp,fileinfo.cFileName);
				dwSize = dwSize + GetFolderSize(sztmp, dwFiles, dwFolders);
				if(dwFolders != NULL)
				{
					++(*dwFolders);
				}
			}
		}
		else if(dwFiles != NULL)
		{
			++(*dwFiles);
		}

		dwSize += fileinfo.nFileSizeLow;
	}
	while(FindNextFile(hFind,&fileinfo));

	FindClose(hFind);
	return dwSize;
}

// 查看操作系统信息
void CSysInfoView::OnViewOSInfo(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	// 查询操作系统信息
	CSimpleStringA strResult = "操作系统信息：\r\n";

	// OS版本
	OSVERSIONINFO osvi;    
    ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
    GetVersionEx(&osvi);

	strResult  = strResult + CSimpleStringA::Format("  操作系统版本: %d.%d.%d\r\n", osvi.dwMajorVersion, osvi.dwMinorVersion, osvi.dwBuildNumber);

	// OS盘符
	_ULARGE_INTEGER lpFreeBytesAvailableToCaller = {}, lpTotalNumberOfBytes = {}, lpTotalNumberOfFreeBytes = {};
	char szRoot[4];
   
    DWORD dwAllDrives = GetLogicalDrives();        
    if (dwAllDrives == 0)
	{
		LOG_TRACE("GetLogicalDrives() return 0");
        return ;  
	}
   
    for(int i=0; i<26 && dwAllDrives > 0; i++)  
    {  
		bool bHasDrive = dwAllDrives & 0x1;
		dwAllDrives = dwAllDrives >> 1;

		if (!bHasDrive)
			continue;

        sprintf((char*)szRoot,"%c:\\", i+'A');
        
        if(GetDriveType(szRoot) == DRIVE_FIXED)
        {
            GetDiskFreeSpaceEx(szRoot, &lpFreeBytesAvailableToCaller, &lpTotalNumberOfBytes, &lpTotalNumberOfFreeBytes);
			
			strResult += CSimpleStringA::Format("    %s 总容量：%8d MB，可用容量：%8d MB\r\n", (const char*)szRoot, 
				(DWORD)(lpTotalNumberOfBytes.QuadPart / (1024 *1024)), (DWORD)(lpTotalNumberOfFreeBytes.QuadPart / (1024 *1024)));
        }
	}

	// 查询相关目录占用空间
	auto pEntity = m_pGUITask->GetEntity();
	CSimpleStringA strRootPath;
	pEntity->GetFunction()->GetPath("Root", strRootPath);
	DWORD nFileCount(0), nFolderCount(0);
	auto nTotalSize = GetFolderSize(strRootPath, &nFileCount, &nFolderCount);
	if (nTotalSize >0)
	{
		strResult += CSimpleStringA::Format("  框架安装目录：{%s}, 共有 %d个文件，%d个子目录，占用磁盘空间：%.1f MB\r\n\r\n",
			(const char*)strRootPath, nFileCount, nFolderCount, (nTotalSize/(1024*1024.0)));
	}

	// 输出
	OutputMsg(strResult);
}

// 查看框架信息
void CSysInfoView::OnViewFWInfo(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	CSimpleStringA strResult = "终端基本信息：\r\n";
	auto pFunc = m_pGUITask->GetEntity()->GetFunction();
	CSystemStaticInfo staticInfo;
	auto rc = pFunc->GetSystemStaticInfo(staticInfo);
	if (rc == Error_Succeed)
	{
		CSimpleStringA strLightPacks ="";
		for(int i=0; i<staticInfo.LightPackInfos.GetCount(); i++)
		{
			if (i >0)
				strLightPacks += "、";

			strLightPacks += staticInfo.LightPackInfos[i].strPackName;
		}

		strResult += CSimpleStringA::Format(
			"  终端号码：{%s}\r\n"
			"  设备型号：{%s}\r\n"
			"  硬件版本：{%s}\r\n"
			"  登记地址：{%s}\r\n"
			"  定位信息：{%f, %f}\r\n"
			"  软件版本：{%s}\r\n"
			"  安装包名：{%s}\r\n"
			"  安装时间：{%s}\r\n"
			"  切换时间：{%s}\r\n"
			"  上次启动：{%s}\r\n"
			"  前一版本：{%s}\r\n"
			"  后一版本：{%s}\r\n"
			"  轻量安装：{%s}\r\n"
			"  运行次数：{%d}\r\n"
			"  当天次数：{%d}\r\n",			
			(const char*)staticInfo.strTerminalID,
			(const char*)staticInfo.strMachineType,
			(const char*)staticInfo.MachineVersion.ToString(),
			(const char*)staticInfo.strEnrolAddr,
			staticInfo.EnrolGPS.GetLatitude(), staticInfo.EnrolGPS.GetLongitude(),
			(const char*)staticInfo.InstallVersion.ToString(),
			(const char*)staticInfo.InstallPack,
			(const char*)staticInfo.tmCreateDate.ToTimeString(),
			(const char*)staticInfo.tmSwithOverDate.ToTimeString(),
			(const char*)staticInfo.tmCurrentTime.ToTimeString(),
			(const char*)staticInfo.PreviousInstallVersion.ToString(),
			(const char*)staticInfo.LatterInstallVersion.ToString(),
			(const char*)strLightPacks,
			staticInfo.nTotalRunCount,
			staticInfo.nTodayRunCount);
	}

	CSystemRunInfo runInfo;
	rc = pFunc->GetSystemRunInfo(runInfo);
	if (rc == Error_Succeed)
	{
		CSimpleStringA strEntityList = "";
		for(int i=0; i<runInfo.strRunningEntityNames.GetCount(); i++)
		{
			if (i>0)
				strEntityList += "、";

			strEntityList += runInfo.strRunningEntityNames[i];
		}

		strResult += CSimpleStringA::Format(
			"  调试级别：{%d}\r\n"
			"  运行实体：{%s}\r\n",
			(int)runInfo.eDebugLevel, 
			(const char*)strEntityList);
	}

	// 输出
	OutputMsg(strResult);
}

void CSysInfoView::ResetListAndButtons(const char *pszOpName, char *pszColName1, char *pszColName2, 
		char *pszBtnName1, char *pszBtnName2,	char *pszBtnName3, char *pszBtnName4)
{
	m_strOpName = pszOpName;

	m_listView1.EnableWindow((pszColName1 != NULL || pszColName2 != NULL) ? TRUE : FALSE);
	m_listView1.DeleteAllItems();	
	m_listView1.DeleteColumn(1);
	m_listView1.DeleteColumn(0);
	
	int nColCount = 0;
	if (pszColName1 != NULL)
		m_listView1.AddColumn(pszColName1, nColCount++);
	
	if (pszColName2 != NULL)
		m_listView1.AddColumn(pszColName2, nColCount++);

	if (nColCount >0)
	{
		RECT rc = {};
		m_listView1.GetClientRect(&rc);
		m_listView1.SetColumnWidth(0, (rc.right-rc.left-20)*1/nColCount);
		m_listView1.SetColumnWidth(1, (rc.right-rc.left-20)*1/nColCount);
	}

	CWindow button = GetDlgItem(IDC_VARBUTTON1);
	if (pszBtnName1 == NULL)
	{
		button.EnableWindow(FALSE);
		button.SetWindowTextA("动作1");
	}
	else
	{
		button.EnableWindow(TRUE);
		button.SetWindowTextA(pszBtnName1);
	}

	button = GetDlgItem(IDC_VARBUTTON2);
	if (pszBtnName2 == NULL)
	{
		button.EnableWindow(FALSE);
		button.SetWindowTextA("动作2");
	}
	else
	{
		button.EnableWindow(TRUE);
		button.SetWindowTextA(pszBtnName2);
	}

	button = GetDlgItem(IDC_VARBUTTON3);
	if (pszBtnName3 == NULL)
	{
		button.EnableWindow(FALSE);
		button.SetWindowTextA("动作3");
	}
	else
	{
		button.EnableWindow(TRUE);
		button.SetWindowTextA(pszBtnName3);
	}

	button = GetDlgItem(IDC_VARBUTTON4);
	if (pszBtnName4 == NULL)
	{
		button.EnableWindow(FALSE);
		button.SetWindowTextA("动作4");
	}
	else
	{
		button.EnableWindow(TRUE);
		button.SetWindowTextA(pszBtnName4);
	}
}

// 查看本地日志
void CSysInfoView::OnViewSysLog(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	ResetListAndButtons("ViewLog", "日志文件", "文件路径", "日志列表", "查看日志", NULL, NULL);

	auto pFunc = m_pGUITask->GetEntity()->GetFunction();
	CSimpleStringA strSysLogPath;
	pFunc->GetPath("SysLog", strSysLogPath);

	int nItemCount = 0;
	m_listView1.InsertItem(	nItemCount, "SysLog\\");
	m_listView1.SetItemText(nItemCount, 1, strSysLogPath);
	nItemCount++;


	CSimpleStringA strDbgPath;
	pFunc->GetPath("Dbg", strDbgPath);
	auto pDbgDirList = fileutil_get_sub_dirs2_a(strDbgPath, 50);
	for (int i = 0; i < pDbgDirList->nelts; ++i) 
	{
		char *pszDirName = ARRAY_IDX(pDbgDirList, i, char*);

		char *p = strrchr(pszDirName, '\\');
		if (p == NULL)
			p = pszDirName;
		else
			p++;

		char szName[128];
		sprintf(szName, "%s\\", p);
		m_listView1.InsertItem(	nItemCount, szName);
		m_listView1.SetItemText(nItemCount, 1, pszDirName);
		nItemCount++;
	}
	toolkit_array_free2(pDbgDirList);
}

// 日志查看处理
void CSysInfoView::OnViewLogSubCmd(int nID)
{
	int nSelectedIndex = m_listView1.GetSelectedIndex();
	if (nSelectedIndex <0 || nSelectedIndex >= m_listView1.GetItemCount())
		return;

	if (nID == IDC_VARBUTTON1)
	{
		char szName[128] = {};
		m_listView1.GetItemText(nSelectedIndex, 0, szName, sizeof(szName));

		if (strncmp(szName, "  |--", 5) == 0)
		{
			// 文件层 
			OutputMsg("当前项非文件目录!\r\n");
			return;
		}
						
		//MessageBox(CSimpleStringA::Format("日志列表:%s", szName));
		// 判断文件夹文件是否已经显示
		char szNextName[128] = {};
		if (nSelectedIndex < m_listView1.GetItemCount()-1 
			&& m_listView1.GetItemText(nSelectedIndex+1, 0, szNextName, sizeof(szNextName)) >0
			&& strncmp(szNextName, "  |--", 5) == 0)
		{
			OutputMsg("目录文件已加载!\r\n");
			return;
		}

		char szFullPath[128] = {};
		m_listView1.GetItemText(nSelectedIndex, 1, szFullPath, sizeof(szFullPath));
		int nInsertIndex = nSelectedIndex + 1;

		auto pLogList = fileutil_get_sub_files2_a(szFullPath, 50);
		for (int i = 0; i < pLogList->nelts; ++i) 
		{
			char *pszLogPath = ARRAY_IDX(pLogList, i, char*);

			char *p = strrchr(pszLogPath, '\\');
			if (p == NULL)
				p = pszLogPath;
			else
				p++;

			char szLogName[128];
			sprintf(szLogName, "  |--%s", p);
			m_listView1.InsertItem(	nInsertIndex, szLogName);
			m_listView1.SetItemText(nInsertIndex, 1, pszLogPath);
			nInsertIndex++;
		}
		toolkit_array_free2(pLogList);

		OutputMsg(CSimpleStringA::Format("目录[%s]共有%d个日志文件\r\n", szName, nInsertIndex - nSelectedIndex -1));
	}
	else
	{
		char szName[128] = {};
		m_listView1.GetItemText(nSelectedIndex, 0, szName, sizeof(szName));

		if (strncmp(szName, "  |--", 5) != 0)
		{
			OutputMsg("当前非文件项!\r\n");
			return;
		}

		char szLogPath[128] = {};
		m_listView1.GetItemText(nSelectedIndex, 1, szLogPath, sizeof(szLogPath));

		OutputMsg(CSimpleStringA::Format("查看日志: %s\r\n", szLogPath));
		//system(CSimpleStringA::Format("notepad %s", szLogPath));

		ShellExecute(NULL,"open","NOTEPAD.EXE",szLogPath,NULL,SW_SHOWNORMAL);
	}
}

// 查看实体配置
void CSysInfoView::OnViewEntityConfig(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	ResetListAndButtons("ViewConfig", "实体名称", "配置类型", "查看配置", NULL, NULL, NULL);

	auto pFunc = m_pGUITask->GetEntity()->GetFunction();
	CAutoArray<CSimpleStringA> strEntityNames;
	CAutoArray<WORD> wEntityIDs;
	pFunc->GetAllRegistedEntity(strEntityNames, wEntityIDs);

	m_listView1.InsertItem(0, "Root");
	m_listView1.SetItemText(0, 1, "硬件配置");
	m_listView1.InsertItem(1, "Shell");
	m_listView1.SetItemText(1, 1, "软件配置");

	for(int i=0; i<strEntityNames.GetCount(); i++)
	{
		CSimpleStringA strEntityName = strEntityNames[i];
		for(int j=0; j<m_listView1.GetItemCount(); j++)
		{
			char szText[128] = {};
			m_listView1.GetItemText(j, 0, szText, sizeof(szText));
			if (stricmp(szText, strEntityName) >0)
			{
				m_listView1.InsertItem(j, strEntityName);
				m_listView1.SetItemText(j, 1, strEntityName=="CenterSetting"? "集中配置":"实体配置");
				break;
			}
		}
	}
}

// 实体配置查看处理
void CSysInfoView::OnViewConfigSubCmd(int nID)
{
	int nSelectedIndex = m_listView1.GetSelectedIndex();
	if (nSelectedIndex <0 || nSelectedIndex >= m_listView1.GetItemCount())
		return;

	char szEntityName[64];
	m_listView1.GetItemText(nSelectedIndex, 0, szEntityName, sizeof(szEntityName));
	CSimpleStringA strCfgPath;
	auto pFunc = m_pGUITask->GetEntity()->GetFunction();

	if (strcmp(szEntityName, "Root") == 0)
	{
		pFunc->GetPath("HardwareCfg", strCfgPath);
	}
	else 
	{
		pFunc->GetPath("Cfg", strCfgPath);
	}

	strCfgPath += CSimpleStringA::Format("\\%s.ini", szEntityName);

	if (!ExistsFileA(strCfgPath))
	{
		OutputMsg(CSimpleStringA::Format("没有找到配置文件%s.ini\r\n", szEntityName));
		return;
	}

	OutputMsg(CSimpleStringA::Format("查看配置%s.ini\r\n", szEntityName));		
	ShellExecute(NULL,"open","NOTEPAD.EXE",strCfgPath,NULL,SW_SHOWNORMAL);
}

// 查看升级日志
void CSysInfoView::OnViewUpgradeConfig(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	ResetListAndButtons("ViewUpgradeLog", "升级日志", "日志路径", "查看日志", NULL, NULL, NULL);

	auto pFunc = m_pGUITask->GetEntity()->GetFunction();
	CSimpleStringA strPath;
	pFunc->GetPath("RunInfo", strPath);
	strPath += "\\InstallLog";

	int nInsertIndex = 0;
	auto pLogList = fileutil_get_sub_files2_a(strPath, 50);
	for (int i = 0; i < pLogList->nelts; ++i) 
	{
		char *pszLogPath = ARRAY_IDX(pLogList, i, char*);

		char *p = strrchr(pszLogPath, '\\');
		if (p == NULL)
			p = pszLogPath;
		else
			p++;

		m_listView1.InsertItem(	nInsertIndex, p);
		m_listView1.SetItemText(nInsertIndex, 1, pszLogPath);
		nInsertIndex++;
	}
	toolkit_array_free2(pLogList);

	OutputMsg(CSimpleStringA::Format("共有%d个升级文件\r\n", nInsertIndex));
}

// 查看升级日志处理
void CSysInfoView::OnViewUpgradeLogSubCmd(int nID)
{
	int nSelectedIndex = m_listView1.GetSelectedIndex();
	if (nSelectedIndex <0 || nSelectedIndex >= m_listView1.GetItemCount())
		return;

	char szLogName[64];
	m_listView1.GetItemText(nSelectedIndex, 0, szLogName, sizeof(szLogName));

	char szLogPath[128];
	m_listView1.GetItemText(nSelectedIndex, 1, szLogPath, sizeof(szLogPath));

	OutputMsg(CSimpleStringA::Format("查看日志文件%s\r\n", szLogName));		
	ShellExecute(NULL,"open","NOTEPAD.EXE",szLogPath,NULL,SW_SHOWNORMAL);
}

// 查看安装目录
void CSysInfoView::OnViewInstallDir(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	ResetListAndButtons("ViewInstallDir", "目录/文件", "文件属性", "返回上层", "查看目录", NULL, NULL);
	GetDlgItem(IDC_VARBUTTON1).EnableWindow(FALSE);

	auto pFunc = m_pGUITask->GetEntity()->GetFunction();
	CSimpleStringA strPath;
	pFunc->GetPath("RootVer", strPath);
	m_strCurViewDir = strPath;

	OnViewInstallDirSubCmd(IDC_VARBUTTON2);
}

// 查看升级日志处理
void CSysInfoView::OnViewInstallDirSubCmd(int nID)
{
	if (nID == IDC_VARBUTTON1)
	{	
		auto pFunc = m_pGUITask->GetEntity()->GetFunction();
		CSimpleStringA strPath;
		pFunc->GetPath("RootVer", strPath);
		if (strPath == m_strCurViewDir)
		{
			OutputMsg("当前目录为根目录\r\n");
			return;
		}

		// 返回上层
		char szTmp[256] = {};
		strcpy(szTmp, m_strCurViewDir);
		char *p = strrchr(szTmp, '\\');
		if (p == NULL)
			return;

		*p = 0;
		m_strCurViewDir = szTmp;

		if (strPath == m_strCurViewDir)
			GetDlgItem(IDC_VARBUTTON1).EnableWindow(FALSE);
	}
	else if (nID = IDC_VARBUTTON2)
	{
		// 查看目录
		int nSelectedIndex = m_listView1.GetSelectedIndex();
		if (nSelectedIndex <0 && m_listView1.GetItemCount() >0)
			return;

		if (nSelectedIndex>=0)
		{
			char szDirName[64];
			m_listView1.GetItemText(nSelectedIndex, 0, szDirName, sizeof(szDirName));

			if (strncmp(szDirName, "[D]", 3) != 0)
			{
				OutputMsg(CSimpleStringA::Format("当前项不是目录: %sr\n", szDirName));
				return;
			}

			char *p = szDirName + 3;
			m_strCurViewDir += CSimpleStringA::Format("\\%s", p);
			GetDlgItem(IDC_VARBUTTON1).EnableWindow(TRUE);
		}
	}
	else
	{
		return;
	}

	// 显示当前目录项
	m_listView1.DeleteAllItems();
	int nIndex = 0;

	WIN32_FIND_DATAA fd = {};
	CSimpleStringA strFindDir = m_strCurViewDir + "\\*";
	HANDLE hFind = FindFirstFileA(strFindDir, &fd);
	if (hFind != INVALID_HANDLE_VALUE) 
	{
		do
		{
			if (strcmp(fd.cFileName, ".") == 0 || strcmp(fd.cFileName, "..") == 0) 
				continue;

			if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
			{
				// 目录
				int j =0;
				for(; j<nIndex; j++)
				{
					char szTmp[64];
					m_listView1.GetItemText(j, 0, szTmp, sizeof(szTmp));

					if(strncmp(szTmp, "[D]", 3) != 0)
						break;
				}
										
				m_listView1.InsertItem(j, CSimpleStringA::Format("[D]%s", fd.cFileName));
				nIndex++;
			}
			else
			{
				// 文件
				m_listView1.InsertItem(nIndex, fd.cFileName);

				SYSTEMTIME st = {};
				FILETIME ft = {};
				FileTimeToLocalFileTime(&fd.ftLastWriteTime, &ft);
				FileTimeToSystemTime(&ft, &st);

				DWORD dwSize = fd.nFileSizeLow;
				CSimpleStringA strTemp = CSimpleStringA::Format("%.4d-%.2d-%.2d %.2d:%.2d:%.2d修改, %d字节",
					st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond, dwSize);
				m_listView1.SetItemText(nIndex, 1, strTemp);
				nIndex++;
			}
		}
		while (FindNextFileA(hFind, &fd));

		FindClose(hFind);
	}
	else
	{
		OutputMsg("当前目录为空r\n");
	}
}

// 监控变量
void CSysInfoView::OnViewSysVar(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	ResetListAndButtons("ViewSysVar", "变量名称", "当前值", "手动刷新", "监控变量", "取消监控", NULL);

	auto pFunc = m_pGUITask->GetEntity()->GetFunction();
	CSimpleStringA strPath;
	pFunc->GetPath("Cfg", strPath);
	strPath += "\\shell.ini";

	auto arr = inifile_read_section_key_all(strPath, "SysEvent");
	for (int i = 0; i < arr->nelts; ++i) 
	{
		char *pszVarName = ARRAY_IDX(arr, i, char*);
		m_listView1.InsertItem(i, pszVarName);
		
		CSimpleStringA strSysVar;
		pFunc->GetSysVar(pszVarName, strSysVar);
		m_listView1.SetItemText(i, 1, strSysVar);
	}
	toolkit_array_free2(arr);

	OutputMsg(CSimpleStringA::Format("共%d个系统变量\r\n", m_listView1.GetItemCount()));
}

void CSysInfoView::OnSysVarEvent(const char *pszKey, const char *pszValue,const char *pszOldValue,const char *pszEntityName)
{
	for(int i=0; i<m_listView1.GetItemCount(); i++)
	{
		char szVarName[64];
		m_listView1.GetItemText(i, 0, szVarName, sizeof(szVarName));

		if (strcmp(pszKey, szVarName) ==0)
		{
			m_listView1.SetItemText(i, 1, pszValue);
			break;
		}
	}

	OutputMsg(CSimpleStringA::Format("[OnSysVarEvent] var: {%s}, old value: {%s}, new value: {%s}\r\n", pszKey, pszOldValue, pszValue));
}

// 查看变量处理
void CSysInfoView::OnViewSysVarSubCmd(int nID)
{
	auto pFunc = m_pGUITask->GetEntity()->GetFunction();

	if (nID == IDC_VARBUTTON1)		// 手工刷新
	{
		for(int i=0; i<m_listView1.GetItemCount(); i++)
		{
			char szVarName[64] = {};
			m_listView1.GetItemText(i, 0, szVarName, sizeof(szVarName));

			CSimpleStringA strSysVar;
			pFunc->GetSysVar(szVarName, strSysVar);
			m_listView1.SetItemText(i, 1, strSysVar);
		}
	}
	else if(nID == IDC_VARBUTTON2)	// 订阅当前变量
	{
		int nSelectedIndex = m_listView1.GetSelectedIndex();
		if (nSelectedIndex <0 || nSelectedIndex >= m_listView1.GetItemCount())
			return;

		char szVarName[64];
		m_listView1.GetItemText(nSelectedIndex, 0, szVarName, sizeof(szVarName));
	
		auto rc = pFunc->RegistSysVarEvent(szVarName, this);
		if (rc == Error_Succeed)
		{
			OutputMsg(CSimpleStringA::Format("监控系统变量(%s)成功\r\n", szVarName));
		}
		else
		{
			OutputMsg(CSimpleStringA::Format("监控系统变量(%s)失败: 0x%X\r\n", szVarName, rc));
		}
	}
	else if(nID == IDC_VARBUTTON3)	// 取消订阅
	{
		int nSelectedIndex = m_listView1.GetSelectedIndex();
		if (nSelectedIndex <0 || nSelectedIndex >= m_listView1.GetItemCount())
			return;

		char szVarName[64];
		m_listView1.GetItemText(nSelectedIndex, 0, szVarName, sizeof(szVarName));

		auto rc = pFunc->UnregistSysVarEvent(szVarName);
		if (rc == Error_Succeed)
		{
			OutputMsg(CSimpleStringA::Format("取消监控系统变量(%s)成功\r\n", szVarName));
		}
		else
		{
			OutputMsg(CSimpleStringA::Format("取消监控系统变量(%s)失败: 0x%X\r\n", szVarName, rc));
		}
	}
}

// 监控实体日志
void CSysInfoView::OnMonitorSysLog(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	ResetListAndButtons("MonitorLog", "实体名称", "是否监控", "开始监控输出", "停止监控输出", "开始监控实体", "停止监控实体");
	if(m_pGUITask->HasSubscibeLog())
	{
		GetDlgItem(IDC_VARBUTTON1).EnableWindow(FALSE);
		GetDlgItem(IDC_VARBUTTON2).EnableWindow(TRUE);
	}
	else
	{
		GetDlgItem(IDC_VARBUTTON1).EnableWindow(TRUE);
		GetDlgItem(IDC_VARBUTTON2).EnableWindow(FALSE);
	}

	auto pFunc = m_pGUITask->GetEntity()->GetFunction();
	CAutoArray<CSimpleStringA> strEntityNames;
	CAutoArray<WORD> wEntityIDs;
	auto rc = pFunc->GetAllRegistedEntity(strEntityNames, wEntityIDs);

	int i=0;
	for(; i<strEntityNames.GetCount(); i++)
	{
		int j=0;
		for(; j<i; j++)
		{
			char szName[64] = {};
			m_listView1.GetItemText(j, 0, szName, sizeof(szName));
			if (stricmp(strEntityNames[i], szName) <0)
				break;
		}

		m_listView1.InsertItem(j, strEntityNames[i]);

		CEntityRunInfo info = {};
		pFunc->GetEntityRunInfo(strEntityNames[i], info);
		m_listView1.SetItemText(j, 1, info.eDebugLevel > 0 ? "Y" : "N");
	}

	OutputMsg(CSimpleStringA::Format("共%d个实体\r\n", i));
}

LRESULT CSysInfoView::OnListItemchanged(NMHDR* phdr)
{
	NMLISTVIEW* pNMListView = (NMLISTVIEW*) phdr;
	if((pNMListView->uChanged==LVIF_STATE) && (pNMListView->uNewState & LVIS_SELECTED))
	{
		// 选中某项
		int nIndex = pNMListView->iItem;
		char szName[64] = {};
		m_listView1.GetItemText(nIndex, 0, szName, sizeof(szName));

		if (m_strOpName == "ViewLog")		// 显示日志
		{
			if (strncmp(szName, "  |--", 5) == 0)
			{
				GetDlgItem(IDC_VARBUTTON1).EnableWindow(FALSE);
				GetDlgItem(IDC_VARBUTTON2).EnableWindow(TRUE);
			}
			else
			{
				GetDlgItem(IDC_VARBUTTON1).EnableWindow(TRUE);
				GetDlgItem(IDC_VARBUTTON2).EnableWindow(FALSE);
			}
		}
		else if (m_strOpName == "ViewInstallDir")	// 显示安装目录
		{
			if (strncmp(szName, "[D]", 3) == 0)
				GetDlgItem(IDC_VARBUTTON2).EnableWindow(TRUE);
			else
				GetDlgItem(IDC_VARBUTTON2).EnableWindow(FALSE);
		}		
		else if (m_strOpName == "MonitorLog")		// 监控日志
		{
			CEntityRunInfo info = {};
			auto pFunc = m_pGUITask->GetEntity()->GetFunction();
			pFunc->GetEntityRunInfo(szName, info);
			if (info.eDebugLevel >0)
			{
				GetDlgItem(IDC_VARBUTTON3).EnableWindow(FALSE);
				GetDlgItem(IDC_VARBUTTON4).EnableWindow(TRUE);
			}
			else
			{
				GetDlgItem(IDC_VARBUTTON3).EnableWindow(TRUE);
				GetDlgItem(IDC_VARBUTTON4).EnableWindow(FALSE);
			}
		}
	}

	return 0;
}

// 监控日志处理
void CSysInfoView::OnMonitorLogSubCmd(int nID)
{
	if (nID == IDC_VARBUTTON1)		// 开始监控
	{
		auto rc = m_pGUITask->SubscribeLog();
		if (rc == Error_Succeed)
		{
			GetDlgItem(IDC_VARBUTTON1).EnableWindow(FALSE);
			GetDlgItem(IDC_VARBUTTON2).EnableWindow(TRUE);
			OutputMsg("开始监控日志成功\r\n");
		}
		else
		{
			OutputMsg(CSimpleStringA::Format("开始监控日志失败: 0x%X\r\n", rc));
		}
	}
	else if (nID == IDC_VARBUTTON2)		// 停止监控
	{
		auto rc = m_pGUITask->UnSubscribeLog();
		if (rc == Error_Succeed)
		{
			GetDlgItem(IDC_VARBUTTON1).EnableWindow(TRUE);
			GetDlgItem(IDC_VARBUTTON2).EnableWindow(FALSE);
			OutputMsg("结束监控日志成功\r\n");
		}
		else
		{
			OutputMsg(CSimpleStringA::Format("结束监控日志失败: 0x%X\r\n", rc));
		}
	}
	else if (nID == IDC_VARBUTTON3)		// 监控实体
	{
		int nSelected = m_listView1.GetSelectedIndex();
		if (nSelected <0)
			return;

		char szName[64] = {};
		m_listView1.GetItemText(nSelected, 0, szName, sizeof(szName));

		auto rc = m_pGUITask->SetDebugLevel(szName, 1);
		if (rc == Error_Succeed)
		{
			CEntityRunInfo info = {};
			auto pFunc = m_pGUITask->GetEntity()->GetFunction();
			pFunc->GetEntityRunInfo(szName, info);
			assert(info.eDebugLevel >0);
			m_listView1.SetItemText(nSelected, 1, "Y");

			GetDlgItem(IDC_VARBUTTON3).EnableWindow(FALSE);
			GetDlgItem(IDC_VARBUTTON4).EnableWindow(TRUE);
			OutputMsg(CSimpleStringA::Format("监控实体{%s}日志成功\r\n", szName));
		}
		else
		{
			OutputMsg(CSimpleStringA::Format("监控实体{%s}日志失败: 0x%X\r\n", szName, rc));
		}
	}
	else if (nID == IDC_VARBUTTON4)		// 停止监控实体
	{
		int nSelected = m_listView1.GetSelectedIndex();
		if (nSelected <0)
			return;

		char szName[64] = {};
		m_listView1.GetItemText(nSelected, 0, szName, sizeof(szName));

		auto rc = m_pGUITask->SetDebugLevel(szName, 0);
		if (rc == Error_Succeed)
		{
			CEntityRunInfo info = {};
			auto pFunc = m_pGUITask->GetEntity()->GetFunction();
			pFunc->GetEntityRunInfo(szName, info);
			assert(info.eDebugLevel ==0);
			m_listView1.SetItemText(nSelected, 1, "N");

			GetDlgItem(IDC_VARBUTTON3).EnableWindow(TRUE);
			GetDlgItem(IDC_VARBUTTON4).EnableWindow(FALSE);
			OutputMsg(CSimpleStringA::Format("取消监控实体{%s}日志成功\r\n", szName));
		}
		else
		{
			OutputMsg(CSimpleStringA::Format("取消监控实体{%s}日志失败: 0x%X\r\n", szName, rc));
		}
	}
}

// 查看已下载文件
void CSysInfoView::OnViewDownloadFile(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	ResetListAndButtons("ViewDownload", "已下载文件", NULL, NULL, NULL, NULL, NULL);

	auto pFunc = m_pGUITask->GetEntity()->GetFunction();
	CSimpleStringA strPath;
	pFunc->GetPath("Downloads", strPath);
	
	auto pFileList = fileutil_get_sub_files2_a(strPath, 50);
	for (int i = 0; i < pFileList->nelts; ++i) 
	{
		char *pszFileName = ARRAY_IDX(pFileList, i, char*);

		char *p = strrchr(pszFileName, '\\');
		if (p == NULL)
			p = pszFileName;
		else
			p++;

		m_listView1.InsertItem(	i, p);
	}
	toolkit_array_free2(pFileList);
}

void CSysInfoView::OnVarButton(UINT /*uNotifyCode*/, int nID, CWindow /*wnd*/)
{
	if (m_strOpName == "ViewLog")
	{
		OnViewLogSubCmd(nID);
	}
	else if (m_strOpName == "ViewConfig")
	{
		OnViewConfigSubCmd(nID);
	}
	else if (m_strOpName == "ViewUpgradeLog")
	{
		OnViewUpgradeLogSubCmd(nID);
	}
	else if (m_strOpName == "ViewInstallDir")
	{
		OnViewInstallDirSubCmd(nID);
	}
	else if (m_strOpName == "ViewSysVar")
	{
		OnViewSysVarSubCmd(nID);
	}
	else if (m_strOpName == "MonitorLog")
	{
		OnMonitorLogSubCmd(nID);
	}
}

LRESULT CSysInitView::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	DoDataExchange(FALSE);
	InitMessage();
	changeMessageFilter(TRUE);

	InitRect();
	InitWidget();
	InitDll();
	CheckSystemInit();
	return 0;
}


void CSysInitView::InitRect()
{
	CRect tempRect;
	GetClientRect(tempRect);
	m_systemInitBtnRect = CRect(tempRect.Width() / 3 - 55, tempRect.top + 25, tempRect.Width() / 3 + 55, tempRect.top + 40);
	m_systemRetoreBtnRect = CRect(tempRect.Width() / 6 * 5 - 55, tempRect.top + 25, tempRect.Width() / 6 * 5 + 55, tempRect.top + 40);

	m_accountConfigCheckRect = CRect(m_systemInitBtnRect.left - 165, m_systemInitBtnRect.bottom + 10
		, m_systemInitBtnRect.left - 55, m_systemInitBtnRect.bottom + 30);
	m_voiceConfigCheckRect = CRect(m_accountConfigCheckRect.right, m_systemInitBtnRect.bottom + 10
		, m_accountConfigCheckRect.right + 110, m_systemInitBtnRect.bottom + 30);
	m_closeWifiCheckRect = CRect(m_voiceConfigCheckRect.right, m_systemInitBtnRect.bottom + 10
		, m_voiceConfigCheckRect.right + 110, m_systemInitBtnRect.bottom + 30);
	m_closeAutoRotationCheckRect = CRect(m_closeWifiCheckRect.right, m_systemInitBtnRect.bottom + 10, m_closeWifiCheckRect.right + 110, m_systemInitBtnRect.bottom + 30);
	
	m_defaultDixCheckRect = CRect(m_accountConfigCheckRect.left, m_accountConfigCheckRect.bottom + 5
		, m_accountConfigCheckRect.right, m_accountConfigCheckRect.bottom + 25);
	m_minDPICheckRect = CRect(m_voiceConfigCheckRect.left, m_voiceConfigCheckRect.bottom + 5
		, m_voiceConfigCheckRect.right, m_voiceConfigCheckRect.bottom + 25);

	m_systemMainIntiCheckRect = CRect(m_closeWifiCheckRect.left, m_closeWifiCheckRect.bottom + 5, m_closeWifiCheckRect.right, m_closeWifiCheckRect.bottom + 25);
	m_systemMainRestoreCheckRect = CRect(m_systemRetoreBtnRect.left, m_systemRetoreBtnRect.bottom + 5, m_systemRetoreBtnRect.left + 110, m_systemRetoreBtnRect.bottom + 25);

	m_initStaticRect = CRect(m_accountConfigCheckRect.left - 5, m_systemInitBtnRect.top - 17,
		m_closeAutoRotationCheckRect.right + 5, m_systemMainIntiCheckRect.bottom + 5);
	m_restoreStaticRect = CRect(m_systemRetoreBtnRect.left - 5, m_systemRetoreBtnRect.top - 17,
		m_systemRetoreBtnRect.right + 5, m_systemMainRestoreCheckRect.bottom + 5);

	m_msgListRect = CRect(10, m_systemMainIntiCheckRect.bottom + 10, tempRect.right - 10, tempRect.bottom - 10);
}

void CSysInitView::InitWidget()
{
	m_systemInitBtn.MoveWindow(m_systemInitBtnRect);
	m_systemRetoreBtn.MoveWindow(m_systemRetoreBtnRect);
	m_accountConfigCheck.MoveWindow(&m_accountConfigCheckRect);
	m_voiceConfigCheck.MoveWindow(&m_voiceConfigCheckRect);
	m_closeWifiCheck.MoveWindow(&m_closeWifiCheckRect);
	m_closeAutoRotationCheck.MoveWindow(&m_closeAutoRotationCheckRect);
	m_systemMainIntiCheck.MoveWindow(&m_systemMainIntiCheckRect);
	m_defaultDixCheck.MoveWindow(&m_defaultDixCheckRect);
	m_minDPICheck.MoveWindow(&m_minDPICheckRect);
	m_systemMainRestoreCheck.MoveWindow(&m_systemMainRestoreCheckRect);
	m_msgList.MoveWindow(&m_msgListRect);

	m_initStatic.MoveWindow(&m_initStaticRect);
	m_restoreStatic.MoveWindow(&m_restoreStaticRect);

	m_systemInitBtn.SetCheck(1);
	m_systemMainRestoreCheck.SetCheck(1);

	CRect  m_rect;
	GetClientRect(&m_rect);  //获取对话框的大小

	m_msgList.AddColumn(_T("初始化步骤"), 0);
	m_msgList.AddColumn(_T("结果"), 1);

	RECT rc = {};
	m_msgList.GetClientRect(&rc);
	m_msgList.SetColumnWidth(0, (rc.right-rc.left)* 15 / 20);
	m_msgList.SetColumnWidth(1, LVSCW_AUTOSIZE_USEHEADER);

	ListView_SetExtendedListViewStyle(m_msgList.m_hWnd, m_msgList.GetStyle() | LVS_EX_GRIDLINES);
}

void CSysInitView::InitDll()
{
	CString dllPath =CString(_T("libSysInit.dll"));
	m_dllWrc = LoadLibrary(dllPath);

	RVCInit_SetLogPath = (RVCINIT_SETLOGPATH)GetProcAddress(m_dllWrc, RVCINITSETLOGPATH);
	RVCInit_sysInitBegin = (RVCINIT_SYSINITBEGIN)GetProcAddress(m_dllWrc, RVCINITSYSINITBEGIN);
	RVCInit_isSystemx64 = (RVCINIT_ISSYSTEMX64)GetProcAddress(m_dllWrc, RVCINITISSYSTEMX64);
	RVCInit_sysTypeCheck = (RVCINIT_SYSTYPECHECK)GetProcAddress(m_dllWrc, RVCINITSYSTYPECHECK);
	RVCInit_EnableAdmin = (RVCINIT_ENABLEADMIN)GetProcAddress(m_dllWrc, RVCINITENABLEADMIN);
	RVCInit_RemoveOtherAccouts = (RVCINIT_REMOVEOTHERACCOUTS)GetProcAddress(m_dllWrc, RVCINITREMOVEOTHERACCOUTS);
	RVCInit_AddCmbUser = (RVCINIT_ADDCMBUSER)GetProcAddress(m_dllWrc, RVCINITADDCMBUSER);
	RVCInit_checkAccounts = (RVCINIT_CHECKACCOUNTS)GetProcAddress(m_dllWrc, RVCINITCHECKACCOUNTS);
	RVCInit_VoiceConfigDefault = (RVCINIT_VOICECONFIGDEFAULT)GetProcAddress(m_dllWrc, RVCINITVOICECONFIGDEFAULT);
	RVCInit_CheckVoiceDefault = (RVCINIT_CHECKVOICEDEFAULT)GetProcAddress(m_dllWrc, RVCINITCHECKVOICEDEFAULT);
	RVCInit_CloseWifi = (RVCINIT_CLOSEWIFI)GetProcAddress(m_dllWrc, RVCINITCLOSEWIFI);
	RVCInit_CheckWifi = (RVCINIT_CHECKWIFI)GetProcAddress(m_dllWrc, RVCINITCHECKWIFI);
	RVCInit_CheckWifiExist = (RVCINIT_CHECKWIFIEXIST)GetProcAddress(m_dllWrc, RVCINITCHECKWIFIEXIST);
	RVCInit_CloseAutoRotation = (RVCINIT_CLOSEAUTOROTATION)GetProcAddress(m_dllWrc, RVCINITCLOSEAUTOROTATION);

	RVCInit_checkAutoRotation = (RVCINIT_CHECKAUTOROTATION)GetProcAddress(m_dllWrc, RVCINITCHECKAUTOROTATION);
	RVCInit_setScreen = (RVCINIT_SETSCREEN)GetProcAddress(m_dllWrc, RVCINITSETSCREEN);
	RVCInit_checkScreen = (RVCINIT_CHECKSCREEN)GetProcAddress(m_dllWrc, RVCINITCHECKSCREEN);
	RVCInit_SetMinDPI = (RVCINIT_SETMINDPI)GetProcAddress(m_dllWrc, RVCINITSETMINDPI);
	RVCInit_checkMinDPI = (RVCINIT_CHECKMINDPI)GetProcAddress(m_dllWrc, RVCINITCHECKMINDPI);
	RVCInit_InitAdmin = (RVCINIT_INITADMIN)GetProcAddress(m_dllWrc, RVCINITINITADMIN);
	RVCInit_InitCmbUser = (RVCINIT_INITCMBUSER)GetProcAddress(m_dllWrc, RVCINITINITCMBUSER);
	RVCInit_checkMainInit = (RVCINIT_CHECKMAININIT)GetProcAddress(m_dllWrc, RVCINITCHECKMAININIT);
	RVCInit_mainInit = (RVCINIT_MAININIT)GetProcAddress(m_dllWrc, RVCINITMAININIT);
	RVCInit_endInit = (RVCINIT_ENDINIT)GetProcAddress(m_dllWrc, RVCINITENDINIT);
	RVCInit_InitRestore = (RVCINIT_INITRESTORE)GetProcAddress(m_dllWrc, RVCINITINITRESTORE);

	if (NULL == m_dllWrc || NULL == RVCInit_SetLogPath || NULL == RVCInit_sysInitBegin || NULL == RVCInit_EnableAdmin || NULL == RVCInit_RemoveOtherAccouts 
		|| NULL == RVCInit_AddCmbUser || NULL == RVCInit_checkAccounts || NULL == RVCInit_VoiceConfigDefault || NULL == RVCInit_CheckVoiceDefault
		|| NULL == RVCInit_CloseWifi || NULL == RVCInit_CloseAutoRotation || NULL == RVCInit_checkAutoRotation || NULL == RVCInit_setScreen 
		|| NULL == RVCInit_checkScreen || NULL == RVCInit_SetMinDPI || NULL == RVCInit_checkMinDPI || NULL == RVCInit_mainInit
		|| NULL == RVCInit_endInit || NULL == RVCInit_InitRestore || NULL == RVCInit_InitAdmin || NULL == RVCInit_InitCmbUser
		|| NULL == RVCInit_isSystemx64 || NULL == RVCInit_sysTypeCheck || NULL == RVCInit_checkMainInit || NULL == RVCInit_CheckWifi
		|| NULL == RVCInit_CheckWifiExist)
	{
		MessageBox(_T("加载libSysInit.dll失败，请检查文件"));
	}

	CSimpleStringA strDbgPath;
	auto pFunc = m_pGUITask->GetEntity()->GetFunction();
	pFunc->GetPath("Dbg", strDbgPath);

	char logPath[300] = "";

	sprintf(logPath, "%s\\SysInit", strDbgPath.GetData());

	RVCInit_SetLogPath(logPath);
}

void CSysInitView::OutputMsg(const char *pMsg)
{
	::PostMessage(GetTopLevelParent().m_hWnd, WM_SHOW_MSG, 0, (LPARAM) strdup(pMsg));
}

void CSysInitView::AddMsgToListView(CString item, CString result)
{
	m_msgList.InsertItem(nItemCount, item);
	m_msgList.SetItemText(nItemCount, 1, result);
	nItemCount++;
}

void CSysInitView::EasyAddMsgToListView(CString item, BOOL isSuccess)
{
	AddMsgToListView(item, isSuccess ? _T("成功") : _T("失败"));
}

void CSysInitView::CleanListView()
{
	m_msgList.DeleteAllItems();//清空上一次显示内容
	nItemCount = 0;
}

void CSysInitView::CheckSystemInit()
{
	int checkSysInit = 0; 
	if (1 == checkSysInit) {
        CloseHandle((HANDLE)_beginthreadex(NULL, 0, (unsigned int(__stdcall*)(void*))SysInitCheck, this, 0, NULL));
	}
}

void CSysInitView::modifyCheckStatus(DWORD status)
{
	m_accountConfigCheck.SetCheck(1);
	/*默认必须设置账户
	if (ENABLE_ACCOUNT_CONFIG == (status & ENABLE_ACCOUNT_CONFIG))
		m_accountConfigCheck.SetCheck(1);
	else
		m_accountConfigCheck.SetCheck(0);
	*/
	if (ENABLE_VOICE_CONFIG == (status & ENABLE_VOICE_CONFIG))
		m_voiceConfigCheck.SetCheck(1);
	else
		m_voiceConfigCheck.SetCheck(0);

	if (ENABLE_CLOSE_WIFI == (status & ENABLE_CLOSE_WIFI))
		m_closeWifiCheck.SetCheck(1);
	else
		m_closeWifiCheck.SetCheck(0);

	if (ENABLE_CLOSE_ROTATION == (status & ENABLE_CLOSE_ROTATION))
		m_closeAutoRotationCheck.SetCheck(1);
	else
		m_closeAutoRotationCheck.SetCheck(0);

	if (ENABLE_DEFAULT_DIX == (status & ENABLE_DEFAULT_DIX))
		m_defaultDixCheck.SetCheck(1);
	else
		m_defaultDixCheck.SetCheck(0);

	if(ENABLE_MIN_DPI == (status & ENABLE_MIN_DPI))
		m_minDPICheck.SetCheck(1);
	else
		m_minDPICheck.SetCheck(0);

	if(ENABLE_MAIN_INIT == (status & ENABLE_MAIN_INIT))
		m_systemMainIntiCheck.SetCheck(1);
	else
		m_systemMainIntiCheck.SetCheck(0);
}

DWORD SysInitCheck(LPVOID lpv)
{
	CSysInitView *sysInit = (CSysInitView *)lpv;
	DWORD result = 0;
	if (RVCInit_checkAccounts())
		sysInit->AddMsgToListView(_T("操作系统定制：检查账户状态"), _T("已定制"));
	else
	{
		result |= ENABLE_ACCOUNT_CONFIG;
		sysInit->AddMsgToListView(_T("操作系统定制：检查账户状态"), _T("未定制"));
	}
	if (RVCInit_CheckVoiceDefault())
		sysInit->AddMsgToListView(_T("操作系统定制：检查声音配置"), _T("已定制"));
	else
	{
		result |= ENABLE_VOICE_CONFIG;
		sysInit->AddMsgToListView(_T("操作系统定制：检查声音配置"), _T("未定制"));
	}

	if (RVCInit_CheckWifiExist())
	{
		if (RVCInit_CheckWifi())
		{
			result |= ENABLE_CLOSE_WIFI;
			sysInit->AddMsgToListView(_T("操作系统定制：检查是否关闭无线网卡"), _T("未定制"));
		}
		else
			sysInit->AddMsgToListView(_T("操作系统定制：检查是否关闭无线网卡"), _T("已定制"));
	}
	else
		sysInit->AddMsgToListView(_T("操作系统定制：未检测到无线网卡！！"), _T(""));
	

	if (RVCInit_checkAutoRotation())
	{
		result |= ENABLE_CLOSE_ROTATION;
		sysInit->AddMsgToListView(_T("操作系统定制：检查是否关闭自动旋转"), _T("未定制"));
	}
	else
		sysInit->AddMsgToListView(_T("操作系统定制：检查是否关闭自动旋转"), _T("已定制"));

	if (RVCInit_checkScreen(1920, 1080))
		sysInit->AddMsgToListView(_T("操作系统定制：检查屏幕分辨率设置为1920*1080"), _T("已定制"));
	else
	{
		result |= ENABLE_DEFAULT_DIX;
		sysInit->AddMsgToListView(_T("操作系统定制：检查屏幕分辨率设置为1920*1080"), _T("未定制"));
	}


	TCHAR userName[256];
	DWORD nameLen = 256;

	if (!GetUserName(userName, &nameLen))
		return FALSE;
	
	CString showMsg;
	showMsg.Format(_T("操作系统定制：检查当前账户%s设置为最小项目"), userName);

	if (RVCInit_checkMinDPI(NULL, userName))
		sysInit->AddMsgToListView(showMsg, _T("已定制"));
	else
	{
		result |= ENABLE_MIN_DPI;
		sysInit->AddMsgToListView(showMsg, _T("未定制"));
	}

	TCHAR errMsg[1024] = _T("");
	if (RVCInit_checkMainInit(errMsg))
		sysInit->AddMsgToListView(_T("操作系统定制：框架初始化"), _T("已定制"));
	else
	{
		result |= ENABLE_MAIN_INIT;
		sysInit->AddMsgToListView(errMsg, _T("未定制"));
	}

	sysInit->modifyCheckStatus(result);

	if (ENABLE_NONE_CONFIG != result)
	{
		//检查失败，需要进行定制
		::PostMessage(sysInit->GetParent(), WM_CHECK_SYSINIT_FAIL, NULL, NULL);
		sysInit->OutputMsg("检测到未完成系统定制，请先进行系统定制");
	}
	else
		::PostMessageA(sysInit->GetParent(), WM_CHECK_SYSINIT_SUCCESS, NULL, NULL);

	return result;
}

BOOL CSysInitView::CheckThreadRunning()
{
	DWORD initCode = 0, restoreCode = 0;
	if (NULL == m_initThread && NULL == m_restoreThread)
		return TRUE;

	if (NULL != m_initThread) ::GetExitCodeThread(m_initThread, &initCode);
	if (NULL != m_restoreThread) ::GetExitCodeThread(m_restoreThread, &restoreCode);
	if (STILL_ACTIVE == initCode)
	{
		MessageBox(_T("正在进行系统定制，请不要重复点击"));
		return FALSE;
	}
	else if (STILL_ACTIVE == restoreCode)
	{
		MessageBox(_T("正在进行系统定制还原，请不要重复点击"));
		return FALSE;
	}
	return TRUE;
}

void CSysInitView::TestHighLevelDbg(
	BOOL isShow, BOOL isHighLevel)
{
	::PostMessage(this->GetParent(), WM_SHOW_MAINTAIN_VIEW, isShow ? 1 : 0, isHighLevel ? 1 : 0);
}

DWORD SysInitBegin(LPVOID lpv)
{
	CSysInitView *initDlg = (CSysInitView *)lpv;

	initDlg->CleanListView();
	CString showMsg;
	TCHAR errMsg[1024] = _T("");
	char rvcInitDir[1024] = "";
	if (!getRvcInitDir(rvcInitDir))
		return 0;
	
	initDlg->AddMsgToListView(_T("正在进行文件拷贝..."), _T(""));
	if (!RVCInit_sysInitBegin(rvcInitDir, errMsg))
	{
		initDlg->EasyAddMsgToListView(_T("操作系统定制初始化"), FALSE);
		return 0;
	}
	else
	{
		initDlg->EasyAddMsgToListView(_T("Dll文件拷贝"), TRUE);
		showMsg.Format(_T("当前操作系统版本为%d位"), RVCInit_isSystemx64() ? 64 : 32);
		initDlg->AddMsgToListView(showMsg, _T(""));
	}

	if (1 == initDlg->m_accountConfigCheck.GetCheck())
	{
		showMsg.Format(_T("开启管理员账号"));
		if (!RVCInit_EnableAdmin())
		{
			initDlg->EasyAddMsgToListView(showMsg, FALSE);
			return 0;
		}
		else
			initDlg->EasyAddMsgToListView(showMsg, TRUE);

		showMsg.Format(_T("删除其他账户"));
		if (!RVCInit_RemoveOtherAccouts())
		{
			initDlg->EasyAddMsgToListView(showMsg, FALSE);
			return 0;
		}
		else
			initDlg->EasyAddMsgToListView(showMsg, TRUE);

		showMsg.Format(_T("创建CmbUser"));
		if (!RVCInit_AddCmbUser())
		{
			initDlg->EasyAddMsgToListView(showMsg, FALSE);
			return 0;
		}
		else
			initDlg->EasyAddMsgToListView(showMsg, TRUE);
	}

	if (1 == initDlg->m_voiceConfigCheck.GetCheck())
	{
		showMsg.Format(_T("声音配置"));
		if (!RVCInit_VoiceConfigDefault())
		{
			initDlg->EasyAddMsgToListView(showMsg, FALSE);
			return 0;
		}
		else
			initDlg->EasyAddMsgToListView(showMsg, TRUE);
	}

	if (1 == initDlg->m_closeWifiCheck.GetCheck())
	{
		if (RVCInit_CheckWifiExist())
		{
			if (!RVCInit_CloseWifi())
			{
				showMsg.Format(_T("未能禁用wifi，请检查是否存在无线网卡"));
				initDlg->EasyAddMsgToListView(showMsg, FALSE);
				return 0;
			}
			else
			{
				showMsg.Format(_T("禁用wifi"));
				initDlg->EasyAddMsgToListView(showMsg, TRUE);
			}
		}
		else
			initDlg->AddMsgToListView(_T("未检测到无线网卡，未进行相关设置"), _T(""));
		

	}

	if (1 == initDlg->m_closeAutoRotationCheck.GetCheck())
	{
		showMsg.Format(_T("禁用自动旋转"));
		if (PAD_LIB == RVCInit_sysTypeCheck() || PAD_FLB == RVCInit_sysTypeCheck())
		{
			if (!RVCInit_CloseAutoRotation())
			{
				initDlg->EasyAddMsgToListView(showMsg, FALSE);
				return 0;
			}
			else
				initDlg->EasyAddMsgToListView(showMsg, TRUE);
		}
		else
			initDlg->AddMsgToListView(_T("检测到当前设备不是PAD，未能禁用自动旋转功能！"), _T(""));
	}

	if (1 == initDlg->m_defaultDixCheck.GetCheck())
	{
		showMsg.Format(_T("设置分辨率为1920*1080"));
		if (!RVCInit_setScreen(1920, 1080))
		{
			initDlg->EasyAddMsgToListView(showMsg, FALSE);
			return 0;
		}
		else
			initDlg->EasyAddMsgToListView(showMsg, TRUE);
	}

	if (!RVCInit_checkAccounts())
	{
		initDlg->EasyAddMsgToListView(_T("检查到账户信息不正确，请先进行账户配置"), FALSE);
		return 0;
	}

	if (!RVCInit_InitAdmin())
	{
		initDlg->EasyAddMsgToListView(_T("初始化Administrator用户"), FALSE);
		return 0;
	}

	//等待explorer.exe初始化
	Sleep(10 * 1000);
	initDlg->EasyAddMsgToListView(_T("初始化Administrator用户"), TRUE);
	
	if (1 == initDlg->m_minDPICheck.GetCheck())
	{
		showMsg.Format(_T("为Administrator设置为最小项目"));
		if (!RVCInit_SetMinDPI(NULL, _T("Administrator")))
		{
			initDlg->EasyAddMsgToListView(showMsg, FALSE);
			return 0;
		}
		else
			initDlg->EasyAddMsgToListView(showMsg, TRUE);
	}

	if (!RVCInit_InitCmbUser())
	{
		initDlg->EasyAddMsgToListView(_T("初始化CmbUser用户"), FALSE);
		return 0;
	}

	//等待explorer.exe初始化
	Sleep(10 * 1000);
	initDlg->EasyAddMsgToListView(_T("初始化CmbUser用户"), TRUE);

	if (1 == initDlg->m_minDPICheck.GetCheck())
	{
		showMsg.Format(_T("为CmbUser设置为最小项目"));
		if (!RVCInit_SetMinDPI(NULL, _T("CmbUser")))
		{
			initDlg->EasyAddMsgToListView(showMsg, FALSE);
			return 0;
		}
		else
			initDlg->EasyAddMsgToListView(showMsg, TRUE);
	}

	if (1 == initDlg->m_systemMainIntiCheck.GetCheck())
	{
		if (!RVCInit_mainInit(errMsg))
			initDlg->EasyAddMsgToListView(errMsg, FALSE);
		else
			initDlg->EasyAddMsgToListView(_T("框架初始化"), TRUE);
	}
	if (!RVCInit_endInit())
		initDlg->EasyAddMsgToListView(_T("释放资源"), FALSE);

	initDlg->EasyAddMsgToListView(_T("系统定制初始化"), TRUE);

	if (IDOK == MessageBox(NULL, _T("系统定制初始化完成，重启后功能生效(由于账户变化，若不重启可能会影响系统使用)。点击确认重启系统。"), _T("是否重启"), MB_OKCANCEL))
		system("shutdown -f -r -t 00");
	
	return 0;
}
DWORD SysRestoreBegin(LPVOID lpv)
{
	CSysInitView *initDlg = (CSysInitView *)lpv;
	initDlg->CleanListView();
	CString showMsg;
	showMsg.Format(_T("取消系统定制功能初始化"));
	if (1 == initDlg->m_systemMainRestoreCheck.GetCheck())
	{
		if (!RVCInit_InitRestore())
			initDlg->EasyAddMsgToListView(showMsg, FALSE);
		else
		{
			initDlg->EasyAddMsgToListView(showMsg, TRUE);
			if (IDOK == MessageBox(NULL, _T("已取消系统定制，点击确认重启系统。"), _T("是否重启"), MB_OKCANCEL))
				system("shutdown -f -r -t 00");
		}
	}


	return 0;
}

BOOL getRvcInitDir(char *dirPath)
{
	char pathbuf[1024] = "";
	int  pathlen = ::GetModuleFileNameA(NULL, pathbuf, 1024);//获得GuiConsole路径

	// 替换掉单杠
	while (pathlen > 0)
	{
		if (pathbuf[pathlen--] == '\\')
			break;
	}
	pathbuf[++pathlen] = '\0';
	memcpy(dirPath, pathbuf, (pathlen + 1 > 1024 ? 1024 : pathlen + 1));
	return pathlen;
}

LRESULT CSysInitView::OnBnClickedSystemInit(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	if (0 == m_accountConfigCheck.GetCheck() && 0 == m_voiceConfigCheck.GetCheck() && 0 == m_closeWifiCheck.GetCheck() && 0 == m_closeAutoRotationCheck.GetCheck()
		&& 0 == m_defaultDixCheck.GetCheck() && 0 == m_systemMainIntiCheck.GetCheck() && 0 == m_minDPICheck.GetCheck())
	{
		AddMsgToListView(_T("请选择需要初始化的部分"), _T(""));
		return 0;
	}
	if (CheckThreadRunning())
		m_initThread = (HANDLE)_beginthreadex(NULL, 0, (unsigned int (__stdcall *)(void *))SysInitBegin, this, 0, NULL);
	return 0;
}

LRESULT CSysInitView::OnBnClickedSystemRestore(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	if (CheckThreadRunning())
		if (IDOK == MessageBox("注意：只有框架初始化功能还原，其他功能不会还原。点击确认开始还原初始化。", "警告", MB_OKCANCEL))
			m_restoreThread = (HANDLE)_beginthreadex(NULL, 0, (unsigned int (__stdcall *)(void *))SysRestoreBegin, this, 0, NULL);	
		
	return 0;
}



LRESULT CControlView::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	CComboBox cbBox =(CComboBox) GetDlgItem(IDC_COMBO1);
	cbBox.AddString("请选择物料类型");
	cbBox.AddString("[DebitCard] 普通借记卡");
	cbBox.AddString("[RetainCard] 吞卡登记");
	//cbBox.AddString("[UKey] 专业版证书");
	//cbBox.AddString("[Receipt] 回单打印卷纸");
	//cbBox.AddString("[Paper] 文件打印纸");
	//cbBox.AddString("[RFIDCard] 小额钱包卡");
	cbBox.SetCurSel(0);
	return 0;
}

// 通过健康实体重启Shell
void CControlView::OnRestartShell(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	LogEvent(Severity_Middle, EVENT_CONSOLE_REQ_RESTART_SHELL, "请求框架重启");	
}

// 通过健康实体重启电源
void CControlView::OnRestartPower(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	LogEvent(Severity_Middle, EVENT_CONSOLE_REQ_RESTART_POWER, "请求电源重启");	
}

// 通过健康实体关闭Shell
void CControlView::OnShutdownShell(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	LogEvent(Severity_Middle, EVENT_CONSOLE_REQ_SHUTDOWN_SHELL, "请求框架退出");	
}

// 退出准入
void CControlView::OnExitAccessAuth(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	auto pEntity = m_pGUITask->GetEntity();
	AccessAuthService_ClientBase *pClient = new AccessAuthService_ClientBase(pEntity);
	auto rc = pClient->Connect();
	if (rc == Error_Succeed)
	{
		AccessAuthService_Unregist_Info info = {};
		info.nReason = 4;
		info.nWay = 0;
		rc = pClient->Unregist(info);
		if (rc == Error_Succeed)
			OutputMsg("请求退出准入成功\r\n");
		else
			OutputMsg(CSimpleStringA::Format("请求退出准入失败: 0x%X\r\n", rc));
		pClient->GetFunction()->CloseSession();
	}
	else
	{
		OutputMsg(CSimpleStringA::Format("连接准入实体失败: 0x%X\r\n", rc));
		pClient->SafeDelete();
	}
	
}

// 重新准入
void CControlView::OnRestartAuth(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	auto pEntity = m_pGUITask->GetEntity();
	AccessAuthService_ClientBase *pClient = new AccessAuthService_ClientBase(pEntity);
	auto rc = pClient->Connect();
	if (rc == Error_Succeed)
	{
		rc = pClient->Regist();
		if (rc == Error_Succeed)
			OutputMsg("请求重新准入成功\r\n");
		else
			OutputMsg(CSimpleStringA::Format("请求重新准入失败: 0x%X\r\n", rc));
		pClient->GetFunction()->CloseSession();
	}
	else
	{
		OutputMsg(CSimpleStringA::Format("连接准入实体失败: 0x%X\r\n", rc));
		pClient->SafeDelete();
	}
	
}

// 物料维护
void CControlView::OnMaterialManager(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	GetDlgItem(IDC_STATIC1).ShowWindow(SW_SHOW);	
	GetDlgItem(IDC_STATIC2).ShowWindow(SW_SHOW);
	GetDlgItem(IDC_COMBO1).ShowWindow(SW_SHOW);	
}

void CControlView::OnSelectChanged(UINT uNotifyCode, int nID, CWindow wndCtl)
{	
	CComboBox cbBox =(CComboBox) GetDlgItem(IDC_COMBO1);
	int nIndex = cbBox.GetCurSel();
	if (nIndex == 0)
		return;

	// 显示相关控件
	GetDlgItem(IDC_STATIC3).ShowWindow(SW_SHOW);
	GetDlgItem(IDC_STATIC4).ShowWindow(SW_SHOW);
	GetDlgItem(IDC_STATIC5).ShowWindow(SW_SHOW);
	GetDlgItem(IDC_STATIC6).ShowWindow(SW_SHOW);
	GetDlgItem(IDC_STATIC7).ShowWindow(SW_SHOW);
	GetDlgItem(IDC_STATIC8).ShowWindow(SW_SHOW);
	GetDlgItem(IDC_STATIC9).ShowWindow(SW_SHOW);
	GetDlgItem(IDC_EDIT2).ShowWindow(SW_SHOW);
	GetDlgItem(IDC_EDIT3).ShowWindow(SW_SHOW);
	GetDlgItem(IDC_EDIT4).ShowWindow(SW_SHOW);
	GetDlgItem(IDC_EDIT5).ShowWindow(SW_SHOW);
	GetDlgItem(IDC_EDIT6).ShowWindow(SW_SHOW);
	GetDlgItem(IDC_EDIT7).ShowWindow(SW_SHOW);
	GetDlgItem(IDC_EDIT8).ShowWindow(SW_SHOW);
	GetDlgItem(IDC_COMMITRESULT).ShowWindow(SW_SHOW);
	GetDlgItem(IDC_CANCELCHECK).ShowWindow(SW_SHOW);

	auto pEntity =(CGUIConsoleEntity*) m_pGUITask->GetEntity();
	
	char szText[128] = {};
	cbBox.GetLBText(nIndex, szText);

	char *p = strchr(szText, ']');
	if (p == NULL)
	{
		OutputMsg(CSimpleStringA::Format("无效设备名：%s\r\n", szText));
		return;
	};
		
	*p = 0;

	unsigned int nCapacity = 0;
	unsigned int nBackEndCount = 0;
	unsigned int nTerminalCount = 0;
	unsigned int nRemainCount = 0;
	CSimpleStringA strDevCode = &szText[1];
	if (strDevCode == "DebitCard" || strDevCode == "RetainCard")
	{
		// 查询发卡器发卡计数\吞卡计数
		GetDlgItem(IDC_EDIT4).SetWindowTextA("0");

		CardIssuerService_ClientBase *pClient = new CardIssuerService_ClientBase(pEntity);
		auto rc = pClient->Connect();
		if (rc == Error_Succeed)
		{
			CardIssuerService_GetMaterialCount_Req req = {};
			CardIssuerService_GetMaterialCount_Ans ret = {};
			rc = pClient->GetMaterialCount(req, ret, 10000);
			if (rc == Error_Succeed)
			{
				if (strDevCode == "DebitCard")
				{
					nTerminalCount = ret.issued;
					nRemainCount = ret.remains;
					GetDlgItem(IDC_EDIT4).SetWindowTextA(CSimpleStringA::Format("%d",  nTerminalCount));
					GetDlgItem(IDC_EDIT8).SetWindowTextA(CSimpleStringA::Format("%d",  nRemainCount));
				}
				else if (strDevCode == "RetainCard")
				{
					nTerminalCount = ret.captured;
					nRemainCount = ret.captured;
					GetDlgItem(IDC_EDIT4).SetWindowTextA(CSimpleStringA::Format("%d",  nRemainCount));
					GetDlgItem(IDC_EDIT8).SetWindowTextA(CSimpleStringA::Format("%d",  nRemainCount));
				}
			}
			else
			{
				OutputMsg(CSimpleStringA::Format("调用发卡器实体失败:0x%X\r\n", rc));
			}

			pClient->GetFunction()->CloseSession();
		}
		else
		{
			OutputMsg(CSimpleStringA::Format("连接发卡器实体失败:0x%X\r\n", rc));
			pClient->SafeDelete();
		}

		
	}
	else
	{
		OutputMsg(CSimpleStringA::Format("暂不支持此设备：%s\r\n", (const char*)strDevCode));
		return;
	}

	// 通讯取后台计数
	GetDlgItem(IDC_EDIT2).SetWindowTextA("0");		// 放置数量
	GetDlgItem(IDC_EDIT3).SetWindowTextA("0");		// 使用数量
	
	CSystemStaticInfo staticInfo;
	pEntity->GetFunction()->GetSystemStaticInfo(staticInfo);

	CMaterialMgrCnn *pCnn = new CMaterialMgrCnn(pEntity);
	if (pCnn->ConnectFromCentralSetting() && pCnn->IsConnectionOK())
	{
		auto rc = pCnn->GetMaterialCounter(strDevCode, staticInfo.strTerminalID, "", nCapacity, nBackEndCount);
		if (rc == Error_Succeed)
		{
			GetDlgItem(IDC_EDIT2).SetWindowTextA(CSimpleStringA::Format("%d", nCapacity));					// 放置数量
			GetDlgItem(IDC_EDIT3).SetWindowTextA(CSimpleStringA::Format("%d", nBackEndCount));			// 后台数量
		}
		else
			OutputMsg(CSimpleStringA::Format("获取后台物料计数失败: 0x%X\r\n", rc));

		pCnn->Close();
	}
	else
		OutputMsg("连接物料管理服务失败\r\n");

	pCnn->DecRefCount();
	pCnn = NULL;	
}

// 提交复核结果
void CControlView::OnCommitResult(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	auto pEntity =(CGUIConsoleEntity*) m_pGUITask->GetEntity();
	CSystemStaticInfo staticInfo;
	auto pFunc = pEntity->GetFunction();
	pFunc->GetSystemStaticInfo(staticInfo);
	
	CComboBox cbBox =(CComboBox) GetDlgItem(IDC_COMBO1);
	char szText[32] = {};
	cbBox.GetWindowTextA(szText, sizeof(szText));

	char *p = strchr(szText, ']');
	if (p == NULL)
	{
		MessageBox(CSimpleStringA::Format("无效设备名：%s\r\n", szText));
		return;
	};
		
	*p = 0;
	CSimpleStringA strMaterialCode = &szText[1];
	CSimpleStringA strTerminalNo = staticInfo.strTerminalID;

	// 判断计数是否不符
	// 实际剩余
	memset(szText, 0, sizeof(szText));
	GetDlgItem(IDC_EDIT5).GetWindowTextA(szText, sizeof(szText));
	if (strlen(szText) == 0)
	{
		MessageBoxA("请输入实际剩余数量");
		return;
	}
	int nActRemainCount = atoi(szText);			

	// 终端剩余计数
	memset(szText, 0, sizeof(szText));
	GetDlgItem(IDC_EDIT8).GetWindowTextA(szText, sizeof(szText));
	int nDevRemainCount = atoi(szText);

	// 终端使用计数
	memset(szText, 0, sizeof(szText));
	GetDlgItem(IDC_EDIT4).GetWindowTextA(szText, sizeof(szText));
	int nUsedCounter = atoi(szText);

	// 重置数量
	memset(szText, 0, sizeof(szText));
	GetDlgItem(IDC_EDIT6).GetWindowTextA(szText, sizeof(szText));
	if (strlen(szText) == 0)
	{
		MessageBoxA("请输入重置数量");
		return;
	}
	int nResetCapacity = atoi(szText);

	// 核对意见
	char szComment[256] = {};
	GetDlgItem(IDC_EDIT7).GetWindowTextA(szComment, sizeof(szComment));
	
	if (nActRemainCount != nDevRemainCount && strlen(szComment)==0)
	{
		MessageBoxA("剩余计数不符，请输入不符原因");
		return;
	}
	
	// 重置硬件计数
	ErrorCodeEnum rc = Error_Succeed;
	if (strMaterialCode == "DebitCard" || strMaterialCode == "RetainCard")
	{
		CardIssuerService_ClientBase *pClient = new CardIssuerService_ClientBase(pEntity);
		rc = pClient->Connect();
		if (rc == Error_Succeed)
		{
			CardIssuerService_SetMaterialCount_Req req = {};
			if (strMaterialCode == "DebitCard")
			{
				req.bRemains = true;
				req.remains = nResetCapacity;
				req.bIssued = true;
				req.issued = 0;
				req.bMixed = true;
				req.mixed = 0;

				req.bCaptured = false;
			}
			else if (strMaterialCode == "RetainCard")
			{
				req.bCaptured = true;
				req.captured = 0;

				req.bRemains = false;
				req.bIssued = false;
				req.bMixed = false;
			}

			CardIssuerService_SetMaterialCount_Ans ret = {};
			rc = pClient->SetMaterialCount(req, ret, 10000);
			pClient->GetFunction()->CloseSession();
		}
		else
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("连接CardIssuer实体失败");
			pClient->SafeDelete();
		}

		
	}
	else
	{
		rc = Error_Unexpect;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("未知物料: {%s}", (const char*)strMaterialCode);
	}

	if (rc != Error_Succeed)
	{
		MessageBoxA(CSimpleStringA::Format("重置终端计数失败(0x%X)", rc));
		LogError(Severity_Middle, rc, 0, CSimpleStringA::Format("重置终端计数失败(0x%X)", rc));
		return;
	}

	// 重置后台计数
	CMaterialMgrCnn *pCnn = new CMaterialMgrCnn(pEntity);
	if (pCnn->ConnectFromCentralSetting() && pCnn->IsConnectionOK())
	{
		auto rc = pCnn->ResetMaterialCounter(strMaterialCode, strTerminalNo, pEntity->GetCurMaintainer(), nResetCapacity, nUsedCounter, nActRemainCount, szComment);
		pCnn->Close();
	}

	pCnn->DecRefCount();
	pCnn = NULL;

	if (rc == Error_Succeed)
	{
		ClearAndHideMaterialEditView();
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("重置物料{%s}计数成功", (const char*)strMaterialCode);
		MessageBoxA("重置物料计数成功");
	}
	else
	{
		MessageBoxA(CSimpleStringA::Format("重置后端计数失败(0x%X)", rc));
		LogError(Severity_Middle, rc, 0, CSimpleStringA::Format("重置后端计数失败(0x%X)", rc));
	}
}

// 取消复核
void CControlView::OnCancelCheck(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	ClearAndHideMaterialEditView();
}

void CControlView::ClearAndHideMaterialEditView()
{
	// 清空内容
	GetDlgItem(IDC_EDIT2).SetWindowTextA("");
	GetDlgItem(IDC_EDIT3).SetWindowTextA("");
	GetDlgItem(IDC_EDIT4).SetWindowTextA("");
	GetDlgItem(IDC_EDIT5).SetWindowTextA("");
	GetDlgItem(IDC_EDIT6).SetWindowTextA("");
	GetDlgItem(IDC_EDIT7).SetWindowTextA("");
	GetDlgItem(IDC_EDIT8).SetWindowTextA("");

	GetDlgItem(IDC_STATIC1).ShowWindow(SW_HIDE);
	GetDlgItem(IDC_STATIC2).ShowWindow(SW_HIDE);
	GetDlgItem(IDC_STATIC3).ShowWindow(SW_HIDE);
	GetDlgItem(IDC_STATIC4).ShowWindow(SW_HIDE);
	GetDlgItem(IDC_STATIC5).ShowWindow(SW_HIDE);
	GetDlgItem(IDC_STATIC6).ShowWindow(SW_HIDE);
	GetDlgItem(IDC_STATIC7).ShowWindow(SW_HIDE);
	GetDlgItem(IDC_STATIC8).ShowWindow(SW_HIDE);
	GetDlgItem(IDC_STATIC9).ShowWindow(SW_HIDE);
	GetDlgItem(IDC_COMBO1).ShowWindow(SW_HIDE);
	GetDlgItem(IDC_EDIT2).ShowWindow(SW_HIDE);
	GetDlgItem(IDC_EDIT3).ShowWindow(SW_HIDE);
	GetDlgItem(IDC_EDIT4).ShowWindow(SW_HIDE);
	GetDlgItem(IDC_EDIT5).ShowWindow(SW_HIDE);
	GetDlgItem(IDC_EDIT6).ShowWindow(SW_HIDE);
	GetDlgItem(IDC_EDIT7).ShowWindow(SW_HIDE);
	GetDlgItem(IDC_EDIT8).ShowWindow(SW_HIDE);
	GetDlgItem(IDC_COMMITRESULT).ShowWindow(SW_HIDE);
	GetDlgItem(IDC_CANCELCHECK).ShowWindow(SW_HIDE);

	CComboBox cbBox =(CComboBox) GetDlgItem(IDC_COMBO1);
	cbBox.SetCurSel(0);
}

void CControlView::OutputMsg(const char *pMsg)
{
	::PostMessage(GetTopLevelParent().m_hWnd, WM_SHOW_MSG, 0, (LPARAM) strdup(pMsg));
}

LRESULT CHighLevelView::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	return 0;
}

// 手工升级
void CHighLevelView::OnManualUpgrade(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	// 选择升级文件
	CFileDialog dlg(TRUE, ".zip", NULL, OFN_READONLY, "zip files\0*.zip\0all files\0*.*\0");
	if (dlg.DoModal() == IDOK)
	{
		CSimpleStringA strPackPath = dlg.m_szFileName;
		if (!strPackPath.IsEndWith(".zip"))
		{
			OutputMsg("升级包必须为zip压缩包\r\n");
			return;
		}

		CSimpleStringA strPackName = strrchr(strPackPath, '\\') +1;
		auto pEntity = m_pGUITask->GetEntity();
		auto pFunc = pEntity->GetFunction();
		CSimpleStringA strDownloadPath;
		pFunc->GetPath("Downloads", strDownloadPath);

		if (!strPackPath.IsStartWith(strDownloadPath))
		{
			strDownloadPath += strrchr(strPackPath, '\\');
			if (CopyFileA(strPackPath, strDownloadPath, FALSE))
				OutputMsg(CSimpleStringA::Format("拷贝升级包{%s}到下载目录成功\r\n", (const char*)strPackName));
			else
			{
				OutputMsg(CSimpleStringA::Format("拷贝升级包{%s}到下载目录失败\r\n", (const char*)strPackName));
				return;
			}
		}

		// 调用升级实体手工升级
		UpgradeMgrService_ClientBase *pClient = new UpgradeMgrService_ClientBase(pEntity);
		auto rc = pClient->Connect();
		if (rc == Error_Succeed)
		{
			UpgradeMgrService_RegistLocalPack_Req req = {};
			UpgradeMgrService_RegistLocalPack_Ans ans = {};
			req.strPackFile = strPackName;
			rc = pClient->RegistLocalPack(req, ans, 10000);
			if (rc == Error_Succeed)
				OutputMsg(CSimpleStringA::Format("手工注册升级包{%s}成功\r\n", (const char*)strPackName));
			else
				OutputMsg(CSimpleStringA::Format("手工注册升级包{%s}失败: 0x%X\r\n", (const char*)strPackName, rc));

			pClient->GetFunction()->CloseSession();
		}
		else
		{
			OutputMsg(CSimpleStringA::Format("连接升级实体失败: 0x%X\r\n", rc));
			pClient->SafeDelete();
		}
		
	}
}

// 设置调试级别
void CHighLevelView::OnSetDebugLevel(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	auto pEntity = m_pGUITask->GetEntity();
	auto pPrevFunc = pEntity->GetFunction()->GetPrivilegeFunction();

	if (pPrevFunc == NULL)
	{
		OutputMsg("获取IEntityFunctionPrivilege接口失败\r\n");
		return;
	}

	pPrevFunc->SetSysDebugLevel("SpShell", Debug_Middle, false);
	OutputMsg("设置框架调试级别成功\r\n");
}

// 恢复调试级别
void CHighLevelView::OnResetDebugLevel(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	auto pEntity = m_pGUITask->GetEntity();
	auto pPrevFunc = pEntity->GetFunction()->GetPrivilegeFunction();

	if (pPrevFunc == NULL)
	{
		OutputMsg("获取IEntityFunctionPrivilege接口失败\r\n");
		return;
	}

	pPrevFunc->SetSysDebugLevel("SpShell", Debug_None, false);
	OutputMsg("恢复框架调试级别成功\r\n");
}


void CControlView::OnPrintConfig(UINT, int, CWindow)
{
	char curPath[1024];
	if (!getRvcInitDir(curPath))
		return;
	strcat(curPath, "\\RvcInit\\OtherTools\\printInstall\\PrintInstall.exe");

	STARTUPINFO si = { sizeof(si) };
	PROCESS_INFORMATION pi;
	si.dwFlags = STARTF_USESHOWWINDOW;
	si.wShowWindow = TRUE; //TRUE表示显示创建的进程的窗口
	if (FALSE == ::CreateProcess(NULL, curPath, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, &si, &pi))
	{
		char errMsg[1024];
		sprintf(errMsg, "打开%s失败！", curPath);
		MessageBoxA(errMsg);
	}
}

void CControlView::OnCameraConfig(UINT, int, CWindow)
{
	char curPath[1024];
	if (!getRvcInitDir(curPath))
		return;
	strcat(curPath, "\\RvcInit\\OtherTools\\cameraInstall\\CameraInstall.exe");

	STARTUPINFO si = { sizeof(si) };
	PROCESS_INFORMATION pi;
	si.dwFlags = STARTF_USESHOWWINDOW;
	si.wShowWindow = TRUE; //TRUE表示显示创建的进程的窗口
	if (FALSE == ::CreateProcess(NULL, curPath, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, &si, &pi))
	{
		char errMsg[1024];
		sprintf(errMsg, "打开%s失败！", curPath);
		MessageBoxA(errMsg);
	}
}

// 框架版本导回
void CHighLevelView::OnRollbackUpgrade(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	if (MessageBoxA("你确定要回滚框架版本至前一版本不？", "确认", MB_OKCANCEL) != IDOK)
		return;

	auto pEntity = m_pGUITask->GetEntity();
	auto pPrevFunc = pEntity->GetFunction()->GetPrivilegeFunction();

	if (pPrevFunc == NULL)
	{
		OutputMsg("获取IEntityFunctionPrivilege接口失败\r\n");
		return;
	}

	auto rc  = pPrevFunc->RollBackToPreviousVersion();
	if (rc == Error_Succeed)
		OutputMsg("导回框架版本成功，重启框架后生效\r\n");
	else
		OutputMsg(CSimpleStringA::Format("导回框架版本失败: 0x%X\r\n", rc));
}

// 终端注销
void CHighLevelView::OnUnregTerminal(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	if (MessageBoxA("你确定要注销此终端吗？终端注销后，此终端将无法准入，不能进行联机处理！", "确认", MB_OKCANCEL) != IDOK)
		return;

	auto pEntity = m_pGUITask->GetEntity();

	// 先退出准入
	AccessAuthService_ClientBase *pClient = new AccessAuthService_ClientBase(pEntity);
	auto rc = pClient->Connect();
	if (rc == Error_Succeed)
	{
		AccessAuthService_Unregist_Info info = {};
		info.nWay = 0;
		info.nReason = 4;
		rc = pClient->Unregist(info);
		if (rc == Error_Succeed)
		{
			// 通知健康实体注销终端
			LogEvent(Severity_Middle, EVENT_CONSOLE_REQ_UNREG_TERMINAL, "终端注销成功");
		}
		else
		{
			OutputMsg(CSimpleStringA::Format("终端准入退出失败: 0x%X\r\n", rc));
		}
		pClient->GetFunction()->CloseSession();
	}
	else
	{
		OutputMsg(CSimpleStringA::Format("连接准入实体失败: 0x%X\r\n", rc));
		pClient->SafeDelete();
	}
	
}

// 修改登记信息
void CHighLevelView::OnModifyEnrollInfo(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	GetDlgItem(IDC_GROUPINFO).ShowWindow(SW_SHOW);
	GetDlgItem(IDC_LABELGPS).ShowWindow(SW_SHOW);
	GetDlgItem(IDC_LABELADDR).ShowWindow(SW_SHOW);
	GetDlgItem(IDC_EDITGPS).ShowWindow(SW_SHOW);
	GetDlgItem(IDC_EDITADDR).ShowWindow(SW_SHOW);
	GetDlgItem(IDC_MODENROLLINFO2).ShowWindow(SW_SHOW);
	GetDlgItem(IDC_MODENROLLINFO3).ShowWindow(SW_SHOW);

	// 取Root.ini信息
	auto pFunc = m_pGUITask->GetEntity()->GetFunction();
	CSmartPointer<IConfigInfo> pConfig;
	auto rc = pFunc->OpenConfig(Config_Root, pConfig);
	if (rc != Error_Succeed)
	{
		OutputMsg("读取硬件配置失败\r\n");
		return;
	}

	CSimpleStringA strValue;
	pConfig->ReadConfigValue("Terminal", "EnrolGPS",  strValue);
	if (strValue.GetLength() >0)
		GetDlgItem(IDC_EDITGPS).SetWindowTextA(strValue);

	pConfig->ReadConfigValue("Terminal", "EnrolAddr",  strValue);
	if (strValue.GetLength() >0)
		GetDlgItem(IDC_EDITADDR).SetWindowTextA(strValue);
}

// 修改登记信息2
void CHighLevelView::OnModifyEnrollInfo2(UINT /*uNotifyCode*/, int nID, CWindow /*wnd*/)
{
	GetDlgItem(IDC_GROUPINFO).ShowWindow(SW_HIDE);
	GetDlgItem(IDC_LABELGPS).ShowWindow(SW_HIDE);
	GetDlgItem(IDC_LABELADDR).ShowWindow(SW_HIDE);
	GetDlgItem(IDC_EDITGPS).ShowWindow(SW_HIDE);
	GetDlgItem(IDC_EDITADDR).ShowWindow(SW_HIDE);
	GetDlgItem(IDC_MODENROLLINFO2).ShowWindow(SW_HIDE);
	GetDlgItem(IDC_MODENROLLINFO3).ShowWindow(SW_HIDE);

	if (nID != IDC_MODENROLLINFO2)
		return;

	char szAddr[256] = {};
	char szGPS[64] = {};
	GetDlgItem(IDC_EDITGPS).GetWindowTextA(szGPS, sizeof(szGPS));
	GetDlgItem(IDC_EDITADDR).GetWindowTextA(szAddr, sizeof(szAddr));

	// 检查GPS值是否合法
	float f1 = 0;
	float f2 = 0;
	int nRet = sscanf(szGPS, "%f,%f", &f1, &f2);
	if (nRet != 2)
	{
		OutputMsg(CSimpleStringA::Format("GPS座标值无效: {%s}\r\n", szGPS));
		return;
	}

	OutputMsg("开始修改登记信息\r\n");
	auto pEntity = m_pGUITask->GetEntity();
	auto pFunc = pEntity->GetFunction();

	// 修改Root.ini
	CSimpleStringA strRootPath;
	pFunc->GetPath("HardwareCfg", strRootPath);
	strRootPath += "\\root.ini";

	inifile_write_str(strRootPath, "Terminal", "EnrolAddr", szAddr);
	inifile_format_write(strRootPath, "Terminal", "EnrolGPS", "\"%s\"", szGPS);

	// 发送到中台
	CMaterialMgrCnn *pCnn = new CMaterialMgrCnn(pEntity);
	if (pCnn->ConnectFromCentralSetting() && pCnn->IsConnectionOK())
	{
		if (pCnn->ModifyEnrolInfo(NULL, NULL, szAddr, szGPS) != Error_Succeed)
			OutputMsg("发送终端部署信息修改请求包失败\r\n");
		else
			OutputMsg("发送终端部署信息修改请求包成功\r\n");

		pCnn->Close();
	}
	else
		OutputMsg("连接物料管理服务失败\r\n");

	pCnn->DecRefCount();
	pCnn = NULL;
}

// 启动操作系统Shell
void CHighLevelView::OnStartOSShell(UINT /*uNotifyCode*/, int nID, CWindow /*wnd*/)
{
	OutputMsg("启动操作系统Shell\r\n");
}

void CHighLevelView::OutputMsg(const char *pMsg)
{
	::PostMessage(GetTopLevelParent().m_hWnd, WM_SHOW_MSG, 0, (LPARAM) strdup(pMsg));
}

BOOL CMainFrame::PreTranslateMessage( MSG* pMsg )
{
	if (WM_CHECK_SYSINIT_FAIL == pMsg->message)
	{
		if (FALSE == m_sysInitView.getPageShow())
		{
			m_tabView.AddPage(m_sysInitView, "操作系统定制");
			m_sysInitView.SetPageShow(TRUE);
		}
		m_cansysInitRm = FALSE;
	}
	else if (WM_CHECK_SYSINIT_SUCCESS == pMsg->message)
		m_cansysInitRm = TRUE;
	return CFrameWindowImpl<CMainFrame>::PreTranslateMessage(pMsg);
}

BOOL CMainFrame::OnIdle()
{
	// 控制Toolbar显示
	if (m_tabView.GetActivePage() == 0)
	{
		::ShowWindow(m_hWndToolBar, SW_SHOWNOACTIVATE);
		UpdateLayout();

		if (m_iSelectIdx != -1)
		{
			EntityEntry e = {};
			auto rc = m_pConsole->GetEntity(GetSelectedEntityName(), e);
			if (rc == Error_Succeed)
			{
				if (e.State == EntityState_NoStart || e.State == EntityState_Close || e.State == EntityState_Killed)
					UIEnable(ID_START, TRUE);
				else
					UIEnable(ID_START, FALSE);

				if (e.State >= EntityState_Idle && e.State <= EntityState_Pause)
					UIEnable(ID_STOP, TRUE);
				else
					UIEnable(ID_STOP, FALSE);

				if (e.State >= EntityState_Idle && e.State <= EntityState_Busy)
					UIEnable(ID_PAUSE, TRUE);
				else
					UIEnable(ID_PAUSE, FALSE);

				if (e.State == EntityState_Pause)
					UIEnable(ID_CONTINUE, TRUE);
				else
					UIEnable(ID_CONTINUE, FALSE);

				if (e.State >= EntityState_Starting && e.State <= EntityState_Close)
					UIEnable(ID_KILL, TRUE);
				else
					UIEnable(ID_KILL, FALSE);

				UIUpdateToolBar();
				return FALSE;
			}
		}

		UIEnable(ID_START, FALSE);
		UIEnable(ID_STOP, FALSE);
		UIEnable(ID_PAUSE, FALSE);
		UIEnable(ID_CONTINUE, FALSE);
		UIEnable(ID_KILL, FALSE);

		UIUpdateToolBar();
		return FALSE;
	}
	else
	{
		::ShowWindow(m_hWndToolBar, SW_HIDE);
		UpdateLayout();
		return FALSE;
	}
}

int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	CreateSimpleToolBar();
	UIAddToolBar(m_hWndToolBar);

	//CreateSimpleStatusBar();
	m_hWndStatusBar = m_status.Create(m_hWnd, rcDefault, NULL, WS_VISIBLE|WS_CHILD);
	int _parts[] = {400, -1};
	m_status.SetParts(sizeof(_parts)/sizeof(_parts[0]), _parts);
	RECT rc;
	m_status.GetRect(0, &rc);
	m_cmd.SetOwner(this);
	m_cmd.Create(m_hWndStatusBar, &rc, NULL, WS_CHILD|WS_VISIBLE | ES_AUTOHSCROLL | ES_LEFT, WS_EX_STATICEDGE);
	m_status.GetRect(1, &rc);
	m_progressbar.Create(m_hWndStatusBar, &rc, NULL, WS_VISIBLE|WS_CHILD);
	m_progressbar.SetRange(0, 100);
	m_progressbar.SetStep(1);
	m_progressbar.SetPos(0);
		
	m_hWndClient = m_splitter.Create(m_hWnd, rcDefault, NULL, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN);
	UpdateLayout();

	// output
	m_output.Create(m_splitter, rcDefault, NULL, 
		WS_CHILD|WS_VISIBLE|ES_AUTOVSCROLL|ES_LEFT|ES_MULTILINE|WS_VSCROLL, WS_EX_STATICEDGE);
	m_output_font.CreateFont(12,0,0,0,FALSE,FALSE,FALSE,0,DEFAULT_CHARSET,
		OUT_CHARACTER_PRECIS, CLIP_CHARACTER_PRECIS,DEFAULT_QUALITY, DEFAULT_PITCH,NULL);
	m_output.SetFont(m_output_font);
	m_wndOutput.SubclassWindow(m_output.m_hWnd);			
	
	CRect rect;
	GetClientRect(rect);
	m_splitter.SetSplitterPos(rect.Height()*3/5);
	
	// TabView
	m_tabView.Create(m_splitter, rcDefault, NULL, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN, WS_EX_CLIENTEDGE);
	//m_tabView.SetTitleBarWindow(m_hWnd);	
	
	m_splitter.SetSplitterPanes(m_tabView, m_output);
	
	m_verticalSplitter.Create(m_tabView, rcDefault, NULL, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN);
	m_tabView.AddPage(m_verticalSplitter, "实体状态");
	m_tabView.SetActivePage(0);
	m_sysInitView.Create(m_tabView, rcDefault);

		
	m_left_list.Create(m_verticalSplitter, rcDefault, NULL, 
		WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | 
		LVS_REPORT | LVS_AUTOARRANGE | LVS_SHOWSELALWAYS | LVS_SINGLESEL, 0, IDC_LIST1);
	m_left_list.SetExtendedListViewStyle(LVS_EX_GRIDLINES | LVS_EX_FULLROWSELECT, 0);

	m_right_list.Create(m_verticalSplitter, rcDefault, NULL,
		WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | 
		LVS_REPORT | LVS_AUTOARRANGE | LVS_SHOWSELALWAYS | LVS_SINGLESEL, 0, IDC_LIST2);
	m_right_list.SetExtendedListViewStyle(LVS_EX_GRIDLINES | LVS_EX_FULLROWSELECT, 0);

	m_verticalSplitter.SetSplitterPos((rect.Width()-10)/2);
	m_verticalSplitter.SetSplitterPanes(m_left_list, m_right_list);
	
	LVCOLUMN col = {0};
	col.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT;
	col.fmt = LVCFMT_LEFT;
	col.cx = 3*rect.Width() / 10-20;
	col.pszText = _T("entity");
	m_left_list.InsertColumn(0, &col);
	m_right_list.InsertColumn(0, &col);

	col.pszText = _T("type");
	col.cx = 3*rect.Width() / 40-1;
	m_left_list.InsertColumn(1, &col);
	m_right_list.InsertColumn(1, &col);

	col.pszText = _T("state");
	col.cx = 3*rect.Width() / 40-1;
	m_left_list.InsertColumn(2, &col);
	m_right_list.InsertColumn(2, &col);

	col.pszText = _T("pid");
	col.cx = rect.Width() / 20-1;
	m_left_list.InsertColumn(3, &col);
	m_right_list.InsertColumn(3, &col);
		
	CMessageLoop* pLoop = _Module.GetMessageLoop();
	pLoop->AddMessageFilter(this);
	pLoop->AddIdleHandler(this);

	// load all entity
	CAutoArray<EntityEntry> Entities;
	m_pConsole->GetAllEntity(Entities);

	// order by entity name
	int arrOrderIndex[255] = {};
	for(int i=0; i<Entities.GetCount(); i++)
	{
		int nIndex = 0;
		for(int j=0; j<i; j++)
		{
			if (Entities[j].Name .Compare(Entities[i].Name) < 0)
				nIndex++;
			else
				arrOrderIndex[j]++;
		}

		arrOrderIndex[i] = nIndex;
	}

	for (int i = 0; i < Entities.GetCount(); ++i) 
	{
		int nIndex = 0;
		for(; nIndex<Entities.GetCount(); nIndex++)
		{
			if (arrOrderIndex[nIndex] == i)
				break;
		}

		LoadEntity(i, Entities[nIndex], Entities.GetCount());
	}

	// load start menu items
#if _DEBUG
	CAutoArray<StartMenuEntry> StartMenus;
	ErrorCodeEnum Error = m_pConsole->GetCustomizeStartMenuList(StartMenus);
	if (Error == Error_Succeed && StartMenus.GetCount() > 0) {
		CMenuHandle menuMain = GetMenu();
		
		int i;
		CMenuHandle menuStartList = menuMain.GetSubMenu(2);
		
		if (menuStartList == NULL) {
			menuStartList.CreatePopupMenu();		
			menuMain.AppendMenuA(MF_BYPOSITION, menuStartList, "&StartEntity");
		}
		for (i = 0; i < StartMenus.GetCount(); ++i) {
			char content[512];
			if (i < 9) {
				wsprintfA(content, "%s %s\tctrl+%d", (LPCSTR)StartMenus[i].strEntity, (LPCSTR)StartMenus[i].strCmdLine, i+1);
			} else {
				wsprintfA(content, "%s %s", (LPCSTR)StartMenus[i].strEntity, (LPCSTR)StartMenus[i].strCmdLine);
			}
			menuStartList.AppendMenuA(MF_STRING, ID_STARTMENU_BEGIN+i, content);
		}
	}
#endif

	::AtlLoadAccelerators(MAKEINTRESOURCE(IDR_MAINFRAME));
		
	m_pConsole->SubscribeLog();

	// 标题显示版本和终端号
	CSimpleStringA strInfo;
	auto nRet = m_pConsole->GetFrameworkInfo(strInfo);
	if (nRet == Error_Succeed)
	{
		char szBuf[256] = {};
		GetWindowText(szBuf, 255);
		SetWindowText(CSimpleStringA::Format("%s - %s", szBuf, strInfo));
	}

	CenterWindow();

#ifdef ALL_FUNCTION_SHOW
	OnShowMaintainView(1, 1, 1);
	OnShowMaintainView(1, 1, 1);
#endif
		
	return 0;
}

void CMainFrame::OnSysCommand(UINT nID, CPoint point)
{
	if (nID == SC_CLOSE || nID == SC_MINIMIZE)
	{
		SetMsgHandled(TRUE);

		// bring back window
		//SetWindowPos(HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
		ShowWindow(SW_MINIMIZE);
	}
	else
		SetMsgHandled(FALSE);
}

//LRESULT CMainFrame::OnClose(UINT uMsg, WPARAM wParam, LPARAM lParam)
//{
//	if (wParam != -1 || lParam != -1) {
//		//output_printf("cannot close self!\r\n");
//		ShowWindow(SW_MINIMIZE);
//	} else {
//		SetMsgHandled(FALSE);
//	}
//	return 0;
//}

int CMainFrame::FindEntitylistItemIndex(int entity_id)
{
	int i;
	for (i = 0; i < m_left_list.GetItemCount(); ++i) {
		int id = ((int)m_left_list.GetItemData(i)) >> 16;
		if (id == entity_id)
			return i*2;
	}
	for (i = 0; i < m_right_list.GetItemCount(); ++i) {
		int id = ((int)m_right_list.GetItemData(i)) >> 16;
		if (id == entity_id)
			return i*2+1;
	}
	return -1;
}

int CMainFrame::FindEntitylistItemIndex(const char *entity_name)
{
	int i;
	for (i = 0; i < m_left_list.GetItemCount(); ++i) {
		char str[128];
		m_left_list.GetItemText(i, 0, str, sizeof(str));
		char *p = strchr(str, ':');
		if (p)
			*p = 0;
		if (_stricmp(entity_name, str) == 0)
			return i*2;
	}
	for (i = 0; i < m_right_list.GetItemCount(); ++i) {
		char str[128];
		m_right_list.GetItemText(i, 0, str, sizeof(str));
		char *p = strchr(str, ':');
		if (p)
			*p = 0;
		if (_stricmp(entity_name, str) == 0)
			return i*2+1;
	}
	return -1;
}

void CMainFrame::SetEntityState(int entity_id, int state, int pid)
{
	int idx = FindEntitylistItemIndex(entity_id);
	if (idx != -1) {
		char tmp[16];
		wsprintfA(tmp, "%d", pid);
		if (idx & 1) {
			m_right_list.SetItem((idx-1)/2, 2, LVIF_TEXT, (LPCSTR)EntityEntry::GetStateName(state), 0, 0, 0, NULL);
			m_right_list.SetItem((idx-1)/2, 3, LVIF_TEXT, tmp, 0, 0, 0, NULL);
		} else {
			m_left_list.SetItem(idx/2, 2, LVIF_TEXT, (LPCSTR)EntityEntry::GetStateName(state), 0, 0, 0, NULL);
			m_left_list.SetItem(idx/2, 3, LVIF_TEXT, tmp, 0, 0, 0, NULL);
		}
	}
}

void CMainFrame::SetEntityState(const char *entity_name, int state, int pid)
{
	int idx = FindEntitylistItemIndex(entity_name);
	if (idx != -1) {
		char tmp[16];
		wsprintfA(tmp, "%d", pid);
		if (idx & 1) {
			m_right_list.SetItem((idx-1)/2, 2, LVIF_TEXT, (LPCSTR)EntityEntry::GetStateName(state), 0, 0, 0, NULL);
			m_right_list.SetItem((idx-1)/2, 3, LVIF_TEXT, tmp, 0, 0, 0, NULL);
		} else {
			m_left_list.SetItem(idx/2, 2, LVIF_TEXT, (LPCSTR)EntityEntry::GetStateName(state), 0, 0, 0, NULL);
			m_left_list.SetItem(idx/2, 3, LVIF_TEXT, tmp, 0, 0, 0, NULL);
		}
	}
}

void CMainFrame::LoadEntity( int nIndex, EntityEntry &e, int nTotal)
{
	char tmp[16];
	wsprintfA(tmp, "%d", e.Pid);
	CSimpleStringA strName = CSimpleStringA::Format("%s:%s", (LPCSTR)e.Name, (LPCSTR)e.ModuleName);
	//if (idx & 1) {
	if (nIndex >= (nTotal+1)/2) {
		//idx = (idx-1)/2;
		nIndex = nIndex - (nTotal+1)/2;
		m_right_list.InsertItem(LVIF_PARAM|LVIF_TEXT, nIndex, (LPCSTR)strName, 0, 0, 0, (e.Id & 0xFFFF) << 16 | (e.DebugLevel & 0xFFFF));
		m_right_list.AddItem(nIndex, 1, (LPCSTR)EntityEntry::GetTypeName(e.Type));
		m_right_list.AddItem(nIndex, 2, (LPCSTR)EntityEntry::GetStateName(e.State));
		m_right_list.AddItem(nIndex, 3, tmp);
	} else {
		//idx = idx / 2;
		m_left_list.InsertItem(LVIF_PARAM|LVIF_TEXT, nIndex, (LPCSTR)strName, 0, 0, 0, (e.Id & 0xFFFF) << 16 | (e.DebugLevel & 0xFFFF));
		m_left_list.AddItem(nIndex, 1, (LPCSTR)EntityEntry::GetTypeName(e.Type));
		m_left_list.AddItem(nIndex, 2, (LPCSTR)EntityEntry::GetStateName(e.State));
		m_left_list.AddItem(nIndex, 3, tmp);
	}
}

void CMainFrame::OnStartEntityFinished(ErrorCodeEnum ErrorResult, const char *entity_name, void *pData)
{
	if (ErrorResult == Error_Succeed) {
		output_printf("start %s entity ok!\r\n", entity_name);
	} else {
		output_printf("start %s entity failed! Error = 0x%08X \r\n", entity_name, ErrorResult);
	}
	m_bOperationPending = FALSE;
	KillTimer(0);
	m_progressbar.SetPos(0);
}

void CMainFrame::OnStopEntityFinished(ErrorCodeEnum ErrorResult, const char *entity_name, void *pData)
{
	if (ErrorResult == Error_Succeed) {
		output_printf("stop %s entity ok!\r\n", entity_name);
	} else {
		output_printf("stop %s entity failed! Error = 0x%08X\r\n", entity_name, ErrorResult);
	}
	m_bOperationPending = FALSE;
	KillTimer(0);
	m_progressbar.SetPos(0);
}

void CMainFrame::OnPauseEntityFinished(ErrorCodeEnum ErrorResult, const char *entity_name, void *pData)
{
	if (ErrorResult == Error_Succeed) {
		output_printf("pause %s entity ok!\r\n", entity_name);
	} else {
		output_printf("pause %s entity failed! Error = 0x%08X\r\n", entity_name, ErrorResult);
	}
	m_bOperationPending = FALSE;
	KillTimer(0);
	m_progressbar.SetPos(0);
}

void CMainFrame::OnContinueEntityFinished(ErrorCodeEnum ErrorResult, const char *entity_name, void *pData)
{
	if (ErrorResult == Error_Succeed) {
		output_printf("continue %s entity ok!\r\n", entity_name);
	} else {
		output_printf("continue %s entity failed! Error = 0x%08X\r\n", entity_name, ErrorResult);
	}
	m_bOperationPending = FALSE;
	KillTimer(0);
	m_progressbar.SetPos(0);
}

void CMainFrame::OnTerminateEntityFinished(ErrorCodeEnum ErrorResult, const char *entity_name, void *pData)
{
	if (ErrorResult == Error_Succeed) {
		output_printf("terminate %s entity ok!\r\n", entity_name);
	} else {
		output_printf("terminate %s entity failed! Error = 0x%08X\r\n", entity_name, ErrorResult);
	}
	m_bOperationPending = FALSE;
	KillTimer(0);
	m_progressbar.SetPos(0);
}

void CMainFrame::OnEntityStateChanged(const char *entity_name, int new_state, int pid)
{
	SetEntityState(entity_name, new_state, pid);
}

#define PREFIX_LEN	15
// [16:13:23.123] 
void CMainFrame::output_printf(const char *fmt, ...)
{
	int len;
	va_list arg;
	va_start(arg, fmt);
	len = _vscprintf(fmt, arg);
	if (len > 0) {
		SYSTEMTIME st;
		char *buf;
		GetLocalTime(&st);
		buf = (char*)malloc(PREFIX_LEN + len+1);
		sprintf(buf, "[%02d:%02d:%02d.%03d] ", st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
		vsprintf(buf+PREFIX_LEN, fmt, arg);
		m_strOuput += buf;
		m_nLineCount++;

		// 检测最大长度
		CheckOutputMaxLen();
		
		if (!m_bVScrolling)
		{
			m_output.SetWindowText(m_strOuput);
		
			//m_output.SetFocus();
			//m_output.ShowCaret();
			m_output.SetSel(m_strOuput.GetLength(), m_strOuput.GetLength());
			m_output.LineScroll(-1);
		}
		
		free(buf);
	}
	va_end(arg);
}

void CMainFrame::CheckOutputMaxLen()
{
	if (m_nLineCount > 200)
	{
		int count = 0;
		int index = 0;
		while(count < 50 && index < m_strOuput.GetLength())
		{
			index = m_strOuput.Find("\r\n", index);
			if (index == -1)
				break;

			index += 2;
			count++;
		}

		if (index >0 && index < m_strOuput.GetLength())
		{
			m_strOuput.Delete(0, index);
			m_nLineCount -= count;
		}
		else
		{
			m_strOuput = "";
			m_nLineCount = 0;
		}
	}
}

#undef PREFIX_LEN
LRESULT CMainFrame::OnShowMaintainView( UINT uMsg, WPARAM wParam, LPARAM lParam )
{
	int nPageCount = m_tabView.GetPageCount();
	bool bShowView = wParam == 1;
	bool bHighLevel = lParam == 1;
	int nCurPageIndex = m_tabView.GetActivePage();
	int extendPage = m_sysInitView.getPageShow() ? 1 : 0;

	if (!bShowView)
	{
		while (nPageCount > 1 + (m_cansysInitRm ? 0 : extendPage))
		{
			m_tabView.RemovePage(--nPageCount);
		}
		if (m_cansysInitRm)
		{
			m_sysInitView.SetPageShow(FALSE);
		}
	}
	else
	{
		if (nPageCount == 1 + extendPage)
		{
			if (FALSE == m_sysInitView.getPageShow())
			{
				static BOOL firstTime = TRUE;
				if (!firstTime)
					m_sysInitView.Create(m_tabView, rcDefault);
				else
					firstTime = FALSE;
				m_tabView.AddPage(m_sysInitView.m_hWnd, "操作系统定制");
				m_sysInitView.SetPageShow(TRUE);
			}
			m_sysInfoView.Create(m_tabView); 
			m_tabView.AddPage(m_sysInfoView.m_hWnd, "信息浏览");
		
			m_controlView.Create(m_tabView); 
			m_tabView.AddPage(m_controlView.m_hWnd, "常规维护");
		}
		else if (nPageCount == 3 + extendPage && bHighLevel)
		{
			m_highLevelView.Create(m_tabView); 
			m_tabView.AddPage(m_highLevelView.m_hWnd, "高级维护");
		}
		else if (nPageCount == 4 + extendPage && !bHighLevel)
		{
			m_tabView.RemovePage(4);
		}
	}

	if (nCurPageIndex <m_tabView.GetPageCount())
		m_tabView.SetActivePage(nCurPageIndex);	

	return 0;
}

LRESULT CMainFrame::OnShowBeginInitView( UINT uMsg, WPARAM wParam, LPARAM lParam )
{
	bool bShowView = wParam == 1;
	
	//初始化按钮显示，add by zl 20170227
	CMenuHandle menuMain = GetMenu();
	if (bShowView)
	{
		menuMain.EnableMenuItem(ID_FILE_INITIALIZE, MF_ENABLED);
	}
	else 
	{
		menuMain.EnableMenuItem(ID_FILE_INITIALIZE, MF_GRAYED);
	}

	return 0;
}


LRESULT CMainFrame::OnShowMobileDialView( UINT uMsg, WPARAM wParam, LPARAM lParam )
{
	bool bShowView = wParam == 1;
	CMenuHandle menuMain = GetMenu();
	if (bShowView) {
		menuMain.EnableMenuItem(ID_SETTINGS_DIAL, MF_ENABLED);
	}
	else {
		menuMain.EnableMenuItem(ID_SETTINGS_DIAL, MF_GRAYED);
	}

	return 0;
}

LRESULT CMainFrame::OnShowMsg( UINT uMsg, WPARAM wParam, LPARAM lParam )
{
	char *pMsg = (char*)lParam;
	output_printf(pMsg);
	delete pMsg;
	return 0;
}

LRESULT CMainFrame::OnGuiConsole( UINT uMsg, WPARAM wParam, LPARAM lParam )
{
	callback_entry *entry = static_cast<callback_entry*>((void*)lParam);
	LOG_ASSERT(entry);
	switch (entry->op) {
	case OP_START_ENTITY:
		OnStartEntityFinished(entry->ErrorResult, entry->EntityName, entry->pRawData);
		break;
	case OP_STOP_ENTITY:
		OnStopEntityFinished(entry->ErrorResult, entry->EntityName, entry->pRawData);
		break;
	case OP_PAUSE_ENTITY:
		OnPauseEntityFinished(entry->ErrorResult, entry->EntityName, entry->pRawData);
		break;
	case OP_CONTINUE_ENTITY:
		OnContinueEntityFinished(entry->ErrorResult, entry->EntityName, entry->pRawData);
		break;
	case OP_TERMINATE_ENTITY:
		OnTerminateEntityFinished(entry->ErrorResult, entry->EntityName, entry->pRawData);
		break;
	case OP_FIRE_ENTITY_STATE:
		OnEntityStateChanged(entry->EntityName, entry->state, wParam);
		break;
	default:
		LOG_ASSERT(0);
		break;
	}
	delete entry;
	return 0;
}

LRESULT CMainFrame::OnListLeftItemchanged(NMHDR* phdr)
{
	NMLISTVIEW* pnmlv = (NMLISTVIEW*) phdr;
	m_iSelectIdx = m_left_list.GetSelectedIndex();
	if (m_iSelectIdx != -1) {
		m_iSelectIdx = m_iSelectIdx * 2;
	}
	return 0;
}

LRESULT CMainFrame::OnListRightItemchanged(NMHDR* phdr)
{
	NMLISTVIEW* pnmlv = (NMLISTVIEW*) phdr;
	m_iSelectIdx = m_right_list.GetSelectedIndex();
	if (m_iSelectIdx != -1) {
		m_iSelectIdx = m_iSelectIdx * 2+1;
	}
	return 0;
}

LRESULT CMainFrame::OnListLeftItemclicked(NMHDR* phdr)
{
	m_iSelectIdx = m_left_list.GetSelectedIndex();
	if (m_iSelectIdx != -1) {
		m_iSelectIdx = m_iSelectIdx * 2;
	}
	return 0;
}

LRESULT CMainFrame::OnListRightItemclicked(NMHDR* phdr)
{
	m_iSelectIdx = m_right_list.GetSelectedIndex();
	if (m_iSelectIdx != -1) {
		m_iSelectIdx = m_iSelectIdx * 2+1;
	}
	return 0;
}

void CMainFrame::OnTimer(UINT_PTR nIDEvent)
{
	if (CSmallDateTime::GetNow() - m_OperationBeginTime >= 5)
	{
		output_printf("last operation timeout!\r\n");
		m_bOperationPending = FALSE;
		KillTimer(0);
		m_progressbar.SetPos(0);
	}
	else
	{
		if (m_bOperationPending) 
		{
			m_progressbar.StepIt();
		}
	}
}

void CMainFrame::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar pScrollBar)
{
	m_bVScrolling = (nSBCode != SB_ENDSCROLL);
	if(!m_bVScrolling)
	{
		m_output.SetWindowText(m_strOuput);

		m_output.SetFocus();
		m_output.ShowCaret();
		m_output.SetSel(m_strOuput.GetLength(), m_strOuput.GetLength());
		m_output.LineScroll(-1);
	}

	SetMsgHandled(FALSE);
}

int CMainFrame::GetEntityDebugLevel(const char *pszEntity)
{
	int nIndex = FindEntitylistItemIndex(pszEntity);
	if (nIndex != -1)
	{
		if (nIndex & 1) 
		{
			return ((int)m_right_list.GetItemData((nIndex-1)/2)) & 0xFFFF;
		}
		else
		{
			return ((int)m_left_list.GetItemData(nIndex/2)) & 0xFFFF;
		}
	}

	return 0;
}

CSimpleStringA CMainFrame::GetSelectedEntityName()
{
	if (m_iSelectIdx == -1)
		return "";

	char entity_name[80];
	if (m_iSelectIdx & 1) 
	{
		m_right_list.GetItemText((m_iSelectIdx-1)/2, 0, entity_name, sizeof(entity_name));
	}
	else
	{
		m_left_list.GetItemText(m_iSelectIdx/2, 0, entity_name, sizeof(entity_name));
	}

	char *p = strchr(entity_name, ':');
	if (p)
		*p=0;

	return entity_name;
}

void CMainFrame::OnStart(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	if (m_iSelectIdx == -1)
		return;

	if (m_bOperationPending) {
		output_printf("operation is doing now, please wait for a result!\r\n");
	} else {
		StartEntity(GetSelectedEntityName(), NULL);
	}
}

void CMainFrame::OnStop(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	if (m_iSelectIdx == -1)
		return;
	if (m_bOperationPending) {
		output_printf("operation is doing now, please wait for a result!\r\n");
	} else {		
		StopEntity(GetSelectedEntityName());
	}
}

void CMainFrame::OnPause(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	if (m_iSelectIdx == -1)
		return;
	if (m_bOperationPending) {
		output_printf("operation is doing now, please wait for a result!\r\n");
	} else {
		PauseEntity(GetSelectedEntityName());
	}
}

void CMainFrame::OnContinue(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	if (m_iSelectIdx == -1)
		return;
	if (m_bOperationPending) {
		output_printf("operation is doing now, please wait for a result!\r\n");
	} else {
		ContinueEntity(GetSelectedEntityName());
	}
}

void CMainFrame::OnKill(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	if (m_iSelectIdx == -1)
		return;
	if (m_bOperationPending) {
		output_printf("operation is doing now, please wait for a result!\r\n");
	} else {
		TerminateEntity(GetSelectedEntityName());
	}
}

void CMainFrame::OnFresh(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	CAutoArray<EntityEntry> Entities;
	m_pConsole->GetAllEntity(Entities);
	for (int i = 0; i < Entities.GetCount(); ++i) {
		SetEntityState(Entities[i].Name, Entities[i].State, Entities[i].Pid);
	}
}

void CMainFrame::OnAbout(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	/*ATL::CSimpleDialog<IDD_ABOUTBOX> dlg;
	dlg.DoModal();*/

	CAboutDlg dlg(m_pConsole);
	dlg.DoModal();
}

void CMainFrame::OnInitialize(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("begin initialize...");
	m_pConsole->BeginInitialize();	
}

void CMainFrame::OnMobileDial(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("begin show mobiledial dialog...");
	m_pConsole->ShowMobileDialog();	
}

void CMainFrame::OnDeleteKeySet(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("delete keyset...");
	m_pConsole->DeleteKeySet();
}

void CMainFrame::OnMaintain(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("begin maintain, validate user now");
	CLoginDlg dlg;
	if (dlg.DoModal() == IDOK)
	{

		CMenuHandle menuMain = GetMenu();
		menuMain.EnableMenuItem(ID_FILE_HIGHLEVEL, MF_GRAYED);

		auto pEntity = m_pConsole->GetEntity();
		CMaterialMgrCnn *pCnn = new CMaterialMgrCnn(pEntity);
		if (pCnn->ConnectFromCentralSetting() && pCnn->IsConnectionOK())
		{
			auto rc = pCnn->MaintainerLogin(dlg.m_strUserID, dlg.m_strPassword);
			if (rc == Error_Succeed)
			{
				MessageBoxA("维护用户登录验证通过");

				menuMain.EnableMenuItem(ID_FILE_HIGHLEVEL, MF_ENABLED);

				auto pGUIEntity = (CGUIConsoleEntity*)pEntity;
				pGUIEntity->PostUserLoginEvent(dlg.m_strUserID);
			}
			else
				MessageBoxA(CSimpleStringA::Format("维护用户登录验证失败(0x%X)", rc));

			pCnn->Close();
		}
		else
			MessageBoxA("连接物料管理服务失败");

		pCnn->DecRefCount();
		pCnn = NULL;
	}
}

void CMainFrame::OnHighLevel(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	auto pEntity = m_pConsole->GetEntity();
	auto pGUIEntity = (CGUIConsoleEntity*)pEntity;
	pGUIEntity->Empower(pGUIEntity->GetCurMaintainer());
}

//void CMainFrame::OnReboot(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
//{
//	m_pConsole->ReqFrameworkQuit();
//}

void CMainFrame::OnShellExit(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	m_pConsole->ReqFrameworkQuit(false);
	//ShowWindow(SW_MINIMIZE);
}

void CMainFrame::OnOSRestart(UINT /*uNotifyCode*/, int /*nID*/, CWindow /*wnd*/)
{
	m_pConsole->ReqFrameworkQuit(true);
	//ShowWindow(SW_MINIMIZE);
}


void CMainFrame::SetEntityDebugLevel(const char *pszEntity, int nDebugLevel)
{
	m_pConsole->SetDebugLevel(pszEntity, nDebugLevel);
}

void CMainFrame::StartEntity(const char *entity_name, const char *cmdline)
{
	ErrorCodeEnum Error = m_pConsole->AsyncStartEntity(entity_name, cmdline, NULL);
	if (Error == Error_Succeed) {
		output_printf("starting %s\r\n", entity_name);
		m_bOperationPending = TRUE;
		m_OperationBeginTime = CSmallDateTime::GetNow();
		SetTimer(0, 100, NULL);
	} else {
		output_printf("start %s failed, error = 0x%08X\r\n", entity_name, Error);
	}
}

void CMainFrame::StopEntity(const char *entity_name)
{
	ErrorCodeEnum Error = m_pConsole->AsyncStopEntity(entity_name, NULL);
	if (Error == Error_Succeed) {
		output_printf("stopping %s\r\n", entity_name);
		m_bOperationPending = TRUE;
		m_OperationBeginTime = CSmallDateTime::GetNow();
		SetTimer(0, 100, NULL);
	} else {
		output_printf("stop %s failed, error = 0x%08X\r\n", entity_name, Error);
	}
}

void CMainFrame::PauseEntity(const char *entity_name)
{
	ErrorCodeEnum Error = m_pConsole->AsyncPauseEntity(entity_name, NULL);
	if (Error == Error_Succeed) {
		output_printf("pausing %s\r\n", entity_name);
		m_bOperationPending = TRUE;
		m_OperationBeginTime = CSmallDateTime::GetNow();
		SetTimer(0, 100, NULL);
	} else {
		output_printf("pause %s failed, error = %d\r\n", entity_name, Error);
	}
}

void CMainFrame::ContinueEntity(const char *entity_name)
{
	ErrorCodeEnum Error = m_pConsole->AsyncContinueEntity(entity_name, NULL);
	if (Error == Error_Succeed) {
		output_printf("continuing %s\r\n", entity_name);
		m_bOperationPending = TRUE;
		m_OperationBeginTime = CSmallDateTime::GetNow();
		SetTimer(0, 100, NULL);
	} else {
		output_printf("continue %s failed, error = %d\r\n", entity_name, Error);
	}
}

void CMainFrame::TerminateEntity(const char *entity_name)
{
	ErrorCodeEnum Error = m_pConsole->AsyncTerminateEntity(entity_name, NULL);
	if (Error == Error_Succeed) {
		output_printf("terminating %s\r\n", entity_name);
		m_bOperationPending = TRUE;
		m_OperationBeginTime = CSmallDateTime::GetNow();
		SetTimer(0, 100, NULL);
	} else {
		output_printf("terminate %s failed, error = %d\r\n", entity_name, Error);
	}
}

void CMainFrame::OnEditEnter(const char *tmp)
{
	char entity[128];
	if (_strnicmp(tmp, "start", 5) == 0) { /* start entity */
		const char *p = tmp+5;
		while (*p == ' ') p++;
		if (sscanf(p, "%s", entity) == 1) {
			const char *cmdline = p + strlen(entity);
			while (*cmdline == ' ') cmdline++;
			StartEntity(entity, cmdline);
		} else {
			output_printf("invalid input format!\r\n");
		}
	} else if (_strnicmp(tmp, "stop", 4) == 0) { /* stop entity */
		const char *p = tmp+4;
		while (*p == ' ') p++;
		if (sscanf(p, "%s", entity) == 1) {
			StopEntity(entity);
		} else {
			output_printf("invalid input format!\r\n");
		}
	} else if (_strnicmp(tmp, "pause", 5) == 0) { /* pause entity */
		const char *p = tmp+5;
		while (*p == ' ') p++;
		if (sscanf(p, "%s", entity) == 1) {
			PauseEntity(entity);
		} else {
			output_printf("invalid input format!\r\n");
		}
	} else if (_strnicmp(tmp, "continue", 8) == 0) { /* continue entity */
		const char *p = tmp+8;
		while (*p == ' ') p++;
		if (sscanf(p, "%s", entity) == 1) {
			ContinueEntity(entity);
		} else {
			output_printf("invalid input format!\r\n");
		}
	} else if (_strnicmp(tmp, "terminate", 9) == 0) { /* terminate entity */
		const char *p = tmp+9;
		while (*p == ' ') p++;
		if (sscanf(p, "%s", entity) == 1) {
			TerminateEntity(entity);
		} else {
			output_printf("invalid input format!\r\n");
		}
	} else if (_stricmp(tmp, "help") == 0 || _stricmp(tmp, "?") == 0) {
		Usage();
	}
	else if (_stricmp(tmp, "show console") == 0)
	{
		m_pConsole->ShowOutputConsole();
	}
	else if (_stricmp(tmp, "close console") == 0)
	{
		m_pConsole->CloseOutputConsole();
	}
	m_cmd.SetWindowText(NULL);
}

void CMainFrame::Usage()
{
	output_printf("help -- display help usage\r\n");
	output_printf("start <Entity_Name> [arg1] [arg2] ... [argn] -- start entity with args[optional] \r\n");
	output_printf("stop <Entity_Name> -- stop entity\r\n");
	output_printf("pause <Entity_Name> -- pause entity\r\n");
	output_printf("continue <Entity_Name> -- pause entity\r\n");
	output_printf("terminate <Entity_Name> -- terminate entity\r\n");
	output_printf("show console -- output running info into console\r\n");
	output_printf("close console -- close output console\r\n");
}

HBRUSH CMainFrame::OnCtlColorEdit( CDCHandle dc, CEdit edit )
{
	if (m_output.m_hWnd == edit.m_hWnd) 
	{
		dc.SetTextColor(RGB(0, 255, 0));
		dc.SetBkColor(RGB(0,0,0));
		return (HBRUSH)GetStockObject(BLACK_BRUSH);
	} else {
		SetMsgHandled(FALSE);
		return 0;
	}
}

HBRUSH CMainFrame::OnCtlColorStatic( CDCHandle dc, CStatic wndStatic )
{
	if (m_output.m_hWnd == wndStatic.m_hWnd) {
		dc.SetTextColor(RGB(0, 255, 0));
		dc.SetBkColor(RGB(0, 0, 0));
		return (HBRUSH)GetStockObject(BLACK_BRUSH);
	} else {
		SetMsgHandled(FALSE);
		return 0;
	}
}

void CMainFrame::OnOutputChanged( UINT uNotifyCode, int nID, CWindow wndCtl )
{
	int n = m_output.GetWindowTextLength();
	m_strOuput.GetBufferSetLength(n); 
	m_output.GetWindowText(m_strOuput.GetBufferSetLength(n), n+1);
}

void CMainFrame::OnStartMenuRange(UINT uNotifyCode, int nID, CWindow wndCtl)
{
	CMenuHandle menuMain = GetMenu();
	CMenuHandle menuStartList = menuMain.GetSubMenu(2);
	WTL::CString strText;
	menuStartList.GetMenuStringA(nID, strText, MF_BYCOMMAND);
	if (strText.GetLength() > 0) {
		int m = strText.Find("\t", 0);
		if (m > 0) {
			strText = strText.Left(m);
		}
		const char *p = strchr(strText, ' ');
		if (p) {
			char name[128];
			memcpy(name, strText, p-(LPCSTR)strText);
			name[p-(LPCSTR)strText] = 0;
			p++;
			StartEntity(name, p);
		}
	}
}

void CCommandEdit::OnChar( UINT nChar, UINT nRepCnt, UINT nFlags )
{
	if (nChar == VK_RETURN) {
		char tmp[512];
		int n = GetWindowText(tmp, sizeof(tmp));
		if (n <= 0)
			return;
		if (m_nHistorySize) {
			int last = (m_nHistoryHead + m_nHistorySize-1) % MAX_HISTORY;
			if (strcmp(tmp, m_strHistoryList[last]) != 0) {
				m_nHistoryCursor = (m_nHistoryHead + m_nHistorySize) % MAX_HISTORY;
				m_strHistoryList[m_nHistoryCursor] = tmp;
				m_nHistorySize = (m_nHistorySize + 1) % MAX_HISTORY;
			}
		} else {
			m_nHistoryCursor = (m_nHistoryHead + m_nHistorySize) % MAX_HISTORY;
			m_strHistoryList[m_nHistoryCursor] = tmp;
			m_nHistorySize = (m_nHistorySize + 1) % MAX_HISTORY;
		}
		m_frm->OnEditEnter(tmp);
		SetWindowText(NULL);
	} else {
		SetMsgHandled(FALSE);
	}
}

void CCommandEdit::OnKeyDown( UINT nChar, UINT nRepCnt, UINT nFlags )
{
	int last = m_nHistoryCursor; 

	if (nChar == VK_UP) {
		if (m_nHistoryCursor != m_nHistoryHead)
			m_nHistoryCursor = (m_nHistoryCursor + MAX_HISTORY - 1) % MAX_HISTORY;
		SetWindowText(m_strHistoryList[last]);
	} else if (nChar == VK_DOWN) {
		if (m_nHistorySize && (m_nHistoryCursor != (m_nHistoryHead+m_nHistorySize-1) % MAX_HISTORY))
			m_nHistoryCursor = (m_nHistoryCursor + 1) % MAX_HISTORY;
		SetWindowText(m_strHistoryList[last]);
	} else {
		SetMsgHandled(FALSE);
	}
}