// CDialTaskManager.cpp : implementation file
//

#include "stdafx.h"
#include "GeoMative.h"
#include "DialTaskManager.h"
#include "DialUploadLoopTask.h"
#include "DialManageLoopTask.h"
#include "DialMeasureData.h"
#include "DialDeleteTaskOption.h"
#include "Lock\AutoLock.h"
#include "DownloadDataProgressDlg.h"
#include "FileOperTools.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

extern int g_UIOffset;
extern int g_iUILanguage;
extern CGeoMativeApp theApp;
extern CString g_strSaveTestingTaskID;
extern CString g_strSaveSuspendedTaskID;
extern BOOL g_bIsOnlineTransfer;
extern EN_TASK_TESTING_METHOD g_eTestingMethod;
extern CString OnLineTask(BYTE ucTaskStats);
extern CString OnLineLocalTaskState(BYTE ucTaskStats);
extern float tcp_ntohf(float f);
extern int GetSigTxPeriod(int iTestType, int iTestPeriod);
extern CString Tm2LocalStr(time_t t);
extern time_t Str2GmtTm(CString szTime);
extern time_t g_i64SaveQueryTaskStartTime;
extern time_t g_i64SaveQueryTaskEndTime;
extern char* U2G(const char* utf8);
extern CString GetTestFailedReason(UINT32 uiTestFailedReason);
#define				MODULE_NAME					_T("CDialTaskManager")
/////////////////////////////////////////////////////////////////////////////
// CDialTaskManager dialog


CDialTaskManager::CDialTaskManager(CWnd* pParent /*=NULL*/)
	: CNetRequestDialog(CDialTaskManager::IDD, pParent), m_dialNew1DTask(&m_taskOper), m_dialNew2DTask(&m_taskOper), m_dialNew3DTask(&m_taskOper), m_dialRealTimeMeasuData(this)
{
	//{{AFX_DATA_INIT(CDialTaskManager)
		// NOTE: the ClassWizard will add member initialization here
	//}}AFX_DATA_INIT
	InitializeCriticalSection(&m_cs);
	m_iSelTaskType = 0;
	m_iTestType = -1;
	m_dwDeviceSN = 0;
	m_dwPLCID = 0;
	m_bLastCancelTask = FALSE;
	//m_bThreadIsRunning = false;
	//m_bThreadIsPause = false;
	//m_bThreadIsExit = false;	
}

CDialTaskManager::~CDialTaskManager()
{
	//KillTimer(ID_TIMER_HEARTBEAT_PACKET);
	//重置保存的时间
	g_i64SaveQueryTaskStartTime = 0;
	g_i64SaveQueryTaskEndTime = 0;
	DeleteCriticalSection(&m_cs);
}

void CDialTaskManager::DoDataExchange(CDataExchange* pDX)
{
	CNetRequestDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CDialTaskManager)
	DDX_Control(pDX, IDC_LIST_TASK_ATTR, m_listTaskAttr);
	DDX_Control(pDX, IDC_LIST_TASK_DATA, m_listTaskData);
	DDX_Control(pDX, IDC_TAB_TASK_CHG, m_tabTaskChg);
	DDX_Control(pDX, IDC_DATETIMEPICKER_STARTTIME, m_StartTime);
	DDX_Control(pDX, IDC_DATETIMEPICKER_ENDTIME, m_EndTime);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CDialTaskManager, CNetRequestDialog)
	//{{AFX_MSG_MAP(CDialTaskManager)
	ON_BN_CLICKED(IDC_BUTTON_CREATE_TASK, OnButtonCreateTask)
	ON_BN_CLICKED(IDC_BUTTON_DEL_TASK, OnButtonDelTask)
	ON_MESSAGE(WM_CLICK_TASK_TREE, OnClickTaskTree)
	ON_MESSAGE(WM_MSG_DELETE_TASK, OnMsgDeleteTask)
	ON_MESSAGE(WM_MSG_UPDATE_TASK_LIST, OnMsgTaskRefreshList)
	ON_MESSAGE(WM_MSG_UPDATE_REALTIME_WND_BTN_STATUS, OnMsgUpdateRealTimeWndBtnStatus)
	ON_MESSAGE(WM_MSG_SET_CURRENT_SELECT_TASK, OnMsgSetCurrentSelectTask)
	//ON_MESSAGE(WM_TASK_LIST_TASK_INFO_SYN, OnMsgTaskListTaskInfoSyn)
	ON_MESSAGE(WM_TASK_LIST_TASK_DATA_SYN, OnMsgTaskListTaskDataSyn)
	ON_MESSAGE(WM_NET_RECV_REAL_TIME_DATA, OnRecvRealTimeDataResponse)
	ON_NOTIFY(TCN_SELCHANGE, IDC_TAB_TASK_CHG, OnSelchangeTabTaskChg)
//	ON_BN_CLICKED(IDC_BUTTON_EXP_TASK, OnButtonExpTask)
	ON_BN_CLICKED(IDC_BUTTON_MEASURE_TASK, OnButtonMeasureTask)
	ON_BN_CLICKED(IDC_BTN_DATA_DOWNLOAD, OnBtnDataDownload)
	ON_BN_CLICKED(IDC_BTN_CREATE_TIMER_TASK, OnBtnCreateTimerTask)
	ON_BN_CLICKED(IDC_BTN_MANAGER_TIMER_TASK, OnBtnManageTimerTask)
	ON_BN_CLICKED(IDC_BTN_QUREY_TASK_LIST, OnBtnQueryTaskList)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

BOOL CDialTaskManager::DestroyWindow()
{
	// TODO:  在此添加专用代码和/或调用基类
	theApp.m_NetWorkOper.UnRegeditRealMsgCall(this->m_hWnd);
	return CDialog::DestroyWindow();
}
/////////////////////////////////////////////////////////////////////////////
// CDialTaskManager message handlers
LRESULT CDialTaskManager::OnMsgDeleteTask(WPARAM wParam, LPARAM lParam)
{
	//SetPauseThread(true);
	//删除本地及树型控件列表数据
	m_taskOper.DeleteTaskArray(m_vtNeedDelLocalTaskID);
// 	int iFailedCount = m_vtFailedDelTaskID.size();
// 	if (iFailedCount > 0)
// 	{
// 		CString strMsg;
// 		if (LANG_ZHCN == g_iUILanguage)
// 			strMsg = _T("删除任务失败");
// 		else
// 			strMsg = _T("Failed to delete test task");
// 		
// 		for (int i = 0; i < iFailedCount; i++)
// 		{
// 			strMsg += m_vtFailedDelTaskID.at(i);
// 			if (i + 1 != iFailedCount)
// 			{
// 				strMsg += _T(",");
// 			}
// 		}
// 		AfxMessageBox(strMsg);		
// 	}
// 	else
// 	{
// 		if (LANG_ZHCN == g_iUILanguage)
// 			AfxMessageBox(_T("删除任务成功"));
// 		else
// 			AfxMessageBox("Succeed to delete test task");
// 
// 	}

	//strLog.Empty();
	CString strLog;
// 	int iDelTaskRunningCount = m_vtDelTaskRunning.size();
// 	if (m_vtDelTaskRunning.size() > 0)
// 	{
// 		if (g_iUILanguage == LANG_ZHCN)
// 			strLog = _T("任务正在运行中：");
// 		else
// 			strLog = _T("task is running: ");
// 
// 		for (int i = 0; i < iDelTaskRunningCount; i++)
// 		{
// 			strLog += m_vtDelTaskRunning.at(i);
// 			if (i != iDelTaskRunningCount - 1)
// 			{
// 				strLog += _T(",");
// 			}
// 			else
// 			{
// 				strLog += _T(";");
// 			}
// 		}		
// 	}

	int iDelNoCancelTestCount = m_vtDelNoCancelTest.size();
	if (m_vtDelNoCancelTest.size() > 0)
	{
		if (g_iUILanguage == LANG_ZHCN)
			strLog += _T("请取消测试后删除任务：");
		else
			strLog += _T("Please cancel the test and delete the task: ");

		for (int i = 0; i < iDelNoCancelTestCount; i++)
		{
			strLog += m_vtDelNoCancelTest.at(i);
			if (i != iDelNoCancelTestCount - 1)
			{
				strLog += _T(",");
			}
			else
			{
				strLog += _T(";");
			}
		}
	}

	int iFailedDelTaskIDCount = m_vtFailedDelTaskID.size();
	if (m_vtFailedDelTaskID.size() > 0)
	{
		if (g_iUILanguage == LANG_ZHCN)
			strLog += _T("未知错误：");
		else
			strLog += _T("unknown error: ");

		for (int i = 0; i < iFailedDelTaskIDCount; i++)
		{
			strLog += m_vtFailedDelTaskID.at(i);
			if (i != iFailedDelTaskIDCount - 1)
			{
				strLog += _T(",");
			}
			else
			{
				strLog += _T(";");
			}
		}
	}

	if (iDelNoCancelTestCount <= 0 && iFailedDelTaskIDCount <= 0)
	{
		if (g_iUILanguage == LANG_ZHCN)
			AfxMessageBox(_T("删除任务成功"));
		else
			MessageBoxEx(NULL, _T("Delete task success"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
	}
	else
	{
		CString strTips;
		if (g_iUILanguage == LANG_ZHCN)
		{
			strTips.Format(_T("删除云端任务失败,%s"), strLog);
			AfxMessageBox(strTips);
		}			
		else
		{
			strTips.Format(_T("Delete cloud task failed,%s"), strLog);
			MessageBoxEx(NULL, strTips, STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		}
	}
	OnMsgTaskRefreshList(0,0);
	return 0;
}

void CDialTaskManager::OnButtonCreateTask()
{
	//SetPauseThread(true);
	// TODO: Add your control notification handler code here
	memset(&m_TaskArg, 0, sizeof(STRemTaskArg));
	int iRet = -1;
	CString strTaskCN = _T("");
	CString strTmp;
	//m_taskOper.m_uiDevID = m_uiDstDevID;
	/*if (0 == m_iSelTaskType)
	{
		iRet = m_dialNew1DTask.DoModal();
		if (IDOK == iRet)
		{
			strTaskCN = m_dialNew1DTask.m_strTaskCN;
			//strcpy(m_TaskArg.ucTaskID, m_dialNew1DTask.m_strTaskCN);
			strTmp.Format("%d", m_dialNew1DTask.m_iNewTaskID);
			strcpy(m_TaskArg.ucTaskID, strTmp);
			strcpy(m_TaskArg.ucTDName, m_dialNew1DTask.m_strTaskName);
			strcpy(m_TaskArg.ucSciptName, m_dialNew1DTask.m_strSptName);
			m_TaskArg.stMeasuArg.ucTestType = m_dialNew1DTask.m_iTestType;
			m_TaskArg.stMeasuArg.ucArrayType = m_dialNew1DTask.m_iAR;
			m_TaskArg.stMeasuArg.ucStacking = m_dialNew1DTask.m_iStacking;
			m_TaskArg.stMeasuArg.ucTxPeriod = m_dialNew1DTask.m_iTxPeriod;
			m_TaskArg.stMeasuArg.iSAInterval = m_dialNew1DTask.m_iSAInterval;
			m_TaskArg.ucOrgFlg = 0;
		}
	}
	else*/ 
	if (0 == m_iSelTaskType)
	{
		iRet = m_dialNew2DTask.DoModal();
		if (IDOK == iRet)
		{
			strTaskCN = m_dialNew2DTask.m_strTaskCN;
			//strcpy(m_TaskArg.ucTaskID, m_dialNew2DTask.m_strTaskCN);
			strTmp.Format("%d", m_dialNew2DTask.m_iNewTaskID);
			strcpy(m_TaskArg.ucTaskID, strTmp);
			strcpy(m_TaskArg.ucTDName, m_dialNew2DTask.m_strTaskName);
			strcpy(m_TaskArg.ucSciptName, m_dialNew2DTask.m_strSptName);
			m_TaskArg.uiStartElec = m_dialNew2DTask.m_iStartElec;
			m_TaskArg.uiEndElec = m_dialNew2DTask.m_iEndElec;
			m_TaskArg.uiStartLayer = m_dialNew2DTask.m_iStatrLayer;
			m_TaskArg.uiEndLayer = m_dialNew2DTask.m_iEndLayer;
			m_TaskArg.stMeasuArg.ucTestType = m_dialNew2DTask.m_iTestType;
			m_TaskArg.stMeasuArg.ucTxPeriod = m_dialNew2DTask.m_iTxPeriod;
			m_TaskArg.stMeasuArg.ucSptType = m_dialNew2DTask.m_iSptID;
			m_TaskArg.stMeasuArg.ucCableLayout = m_dialNew2DTask.m_iCableLayout;
			m_TaskArg.stMeasuArg.ucStacking = m_dialNew2DTask.m_iStacking;
			m_TaskArg.stMeasuArg.iSAInterval = m_dialNew2DTask.m_iSAInterval;
			m_TaskArg.stMeasuArg.ucArrayType = m_dialNew2DTask.m_iAR;
			//m_TaskArg.stMeasuArg.fElecSpace = m_dialNew2DTask.m_fEelcSpace;
			m_TaskArg.stMeasuArg.fXElecDistance = m_dialNew2DTask.m_fEelcSpace;
			m_TaskArg.stMeasuArg.fYElecDistance = 1;
			m_TaskArg.stMeasuArg.fXElecStep = 1;
			m_TaskArg.stMeasuArg.fYElecStep = 1;
			m_TaskArg.stMeasuArg.rcGridSize = {0};
			m_TaskArg.stMeasuArg.byLineDirection = 0;//二维只有X方向

			m_TaskArg.ucOrgFlg = 0;
		}
	}
	else if (1 == m_iSelTaskType)
	{
		iRet = m_dialNew3DTask.DoModal();
		if (IDOK == iRet)
		{
			strTaskCN = m_dialNew3DTask.m_strTaskCN;
			strTmp.Format("%d", m_dialNew3DTask.m_iNewTaskID);
			strcpy(m_TaskArg.ucTaskID, strTmp);
			strcpy(m_TaskArg.ucTDName, m_dialNew3DTask.m_strTaskName);
			strcpy(m_TaskArg.ucSciptName, m_dialNew3DTask.m_strSptName);
			m_TaskArg.uiStartElec = m_dialNew3DTask.m_iStartElec;
			m_TaskArg.uiEndElec = m_dialNew3DTask.m_iEndElec;
			m_TaskArg.uiStartLayer = m_dialNew3DTask.m_iStatrLayer;
			m_TaskArg.uiEndLayer = m_dialNew3DTask.m_iEndLayer;
			m_TaskArg.stMeasuArg.ucTestType = m_dialNew3DTask.m_iTestType;
			m_TaskArg.stMeasuArg.ucTxPeriod = m_dialNew3DTask.m_iTxPeriod;
			m_TaskArg.stMeasuArg.ucSptType = m_dialNew3DTask.m_iSptID;
			m_TaskArg.stMeasuArg.ucSptType = m_dialNew3DTask.m_ucSptType;
			m_TaskArg.stMeasuArg.ucCableLayout = m_dialNew3DTask.m_iCableLayout;
			m_TaskArg.stMeasuArg.ucStacking = m_dialNew3DTask.m_iStacking;
			m_TaskArg.stMeasuArg.iSAInterval = m_dialNew3DTask.m_iSAInterval;
			m_TaskArg.stMeasuArg.ucArrayType = m_dialNew3DTask.m_iAR;

			m_TaskArg.stMeasuArg.fXElecDistance = m_dialNew3DTask.m_fXElecDistance;
			m_TaskArg.stMeasuArg.fYElecDistance = m_dialNew3DTask.m_fYElecDistance;
			m_TaskArg.stMeasuArg.fXElecStep = m_dialNew3DTask.m_fXElecStep;
			m_TaskArg.stMeasuArg.fYElecStep = m_dialNew3DTask.m_fYElecStep;
			m_TaskArg.stMeasuArg.rcGridSize = m_dialNew3DTask.m_rcGridSize;
			m_TaskArg.stMeasuArg.byLineDirection = m_dialNew3DTask.m_byLineDirection;

			m_TaskArg.ucOrgFlg = 0;
		}
	}
	else
	{
		CString strErr = _T("");
		strErr.Format(_T("Unknow task type(%d)"), m_iSelTaskType);
		MessageBoxEx(NULL, strErr, STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		return;
	}

	if (IDOK == iRet)
	{
		//上传数据
		CDownloadDataProgressDlg uploadDlg(&m_TaskArg, &m_taskOper,this);
		uploadDlg.SetDeviceID(m_dwDeviceSN);
		uploadDlg.DoModal();
	}
}

void CDialTaskManager::UpdateRealTimeTaskListData(STRemTaskArg* ptTaskArg, STTaskListItem* pTaskItem)
{
	//获取第一个任务信息
	CString strLog;
	strLog.Format(_T("zm:CDialTaskManager::UpdateRealTimeTaskListData begin"));
	CFileOperTools::GetInstance()->WriteComLog(strLog);
	m_stRealTimeTaskArg = *ptTaskArg;
	if (EN_MEASURE_DATA != m_dialRealTimeMeasuData.GetMeasureType())
	{
		//从本地数据库获取GR
		//m_dialRealTimeMeasuData.InitGrList(m_dialRealTimeMeasuData.m_dialListMeasuGR.m_listData, m_stRealTimeTaskArg.ucTaskID);
		//实时从云端获取GR
		m_dialRealTimeMeasuData.m_dialListMeasuGR.GetGRRequest(m_stRealTimeTaskArg);
		return;
	}
	m_dialRealTimeMeasuData.m_dialListMeasuTask.m_listData.DeleteAllItems();
	
	//只显示测试成功的数据
	if (EN_TASK_STATE_FINISH == pTaskItem->byTestStatus || EN_TASK_STATE_STOP_TEST == pTaskItem->byTestStatus)
	{
		strLog.Format(_T("zm:taskid=%s, taskname=%s,syn status = %d,test status=%d"), pTaskItem->szTaskID, pTaskItem->szTDName, pTaskItem->eSynStatus, pTaskItem->byTestStatus);
		CFileOperTools::GetInstance()->WriteComLog(strLog);

		//实时窗口未测试中的任务，50个点同步线程
		std::vector<STTaskDetailBasicData> vtData;
		m_taskOper.QueryOnLineTdDataToCtrl(m_stRealTimeTaskArg, vtData);
		SendMessage(WM_TASK_LIST_TASK_DATA_SYN, (WPARAM)&vtData, 0);
	}

	strLog.Format(_T("zm:CDialTaskManager::UpdateRealTimeTaskListData end"));
	CFileOperTools::GetInstance()->WriteComLog(strLog);
}

void CDialTaskManager::OnButtonDelTask()
{
	SetPauseThread(true);
	m_vtNeedDelLocalTaskID.clear();
	m_vtNeedDelClounTaskID.clear();
	m_vtFailedDelTaskID.clear();
	m_vtDelNoCancelTest.clear();
	//m_vtNeedDelTreeItem.clear();
	CString strLog;
	CDialDeleteTaskOption taskOptionDlg;
	if (IDOK == taskOptionDlg.DoModal())
	{
		if (!taskOptionDlg.m_DeleteLocal && !taskOptionDlg.m_DeleteCloud)
		{
			return;
		}

		//遍历所有节点，判断是否勾选		
		CTreeCtrl* pTreeCtrl = m_iTaskTree->GetTaskTreePtr();
		HTREEITEM rootItem = pTreeCtrl->GetRootItem();
		if (pTreeCtrl->ItemHasChildren(rootItem))
		{
			HTREEITEM childItem = pTreeCtrl->GetChildItem(rootItem);
			STTaskListItem* pTaskItem = NULL;
			while (childItem != NULL)
			{
				if (pTreeCtrl->GetCheck(childItem))
				{
					pTaskItem = (STTaskListItem*)pTreeCtrl->GetItemData(childItem);
					if (NULL == pTaskItem)
					{
						if (LANG_ZHCN == g_iUILanguage)
							AfxMessageBox(_T("获取任务数据ID错误"));
						else
							MessageBoxEx(NULL, _T("Can not find the test task.please select the task firstly"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
						return;
					}
					//m_vtNeedDelTreeItem.push_back(childItem);					
					if (EN_TASK_NO_UPLOAD != pTaskItem->eSynStatus)
					{
						std::vector<CString>::iterator iter = m_vtNeedDelClounTaskID.begin();
						iter = find(m_vtNeedDelClounTaskID.begin(), m_vtNeedDelClounTaskID.end(), pTaskItem->szTaskID);
						if (iter != m_vtNeedDelClounTaskID.end())
						{
							strLog.Format(_T("zm:Add cloud delete tasks to the collection, Cloud filter repeat  taskid=%s"), pTaskItem->szTaskID);
						}
						else
						{
							strLog.Format(_T("zm:Add cloud delete tasks to the collection taskid=%s"), pTaskItem->szTaskID);
							m_vtNeedDelClounTaskID.push_back(pTaskItem->szTaskID);
						}
						CFileOperTools::GetInstance()->WriteComLog(strLog);
					}
					if (EN_TASK_NO_DOWNLOAD != pTaskItem->eSynStatus)
					{
						std::vector<CString>::iterator iter = m_vtNeedDelLocalTaskID.begin();
						iter = find(m_vtNeedDelLocalTaskID.begin(), m_vtNeedDelLocalTaskID.end(), pTaskItem->szTaskID);
						if (iter != m_vtNeedDelLocalTaskID.end())
						{
							strLog.Format(_T("zm:Add local database delete tasks to the collection, Cloud filter repeat  taskid=%s"), pTaskItem->szTaskID);
						}
						else
						{
							strLog.Format(_T("zm:Add local database delete tasks to the collection taskid=%s"), pTaskItem->szTaskID);
							m_vtNeedDelLocalTaskID.push_back(pTaskItem->szTaskID);
						}
						CFileOperTools::GetInstance()->WriteComLog(strLog);
					}
				}
				childItem = pTreeCtrl->GetNextSiblingItem(childItem);
			}			
		}

		//删除云端数据
		if (taskOptionDlg.m_DeleteCloud && taskOptionDlg.m_DeleteLocal)//勾选云端和本地
		{
			if (m_vtNeedDelLocalTaskID.size() == 0 && m_vtNeedDelClounTaskID.size() == 0)
			{
				if (LANG_ZHCN == g_iUILanguage)
					AfxMessageBox(_T("请先勾选数据"));
				else
					MessageBoxEx(NULL, _T("Please choose one task first"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
				return;
			}
			DeleteTask();
			OnMsgDeleteTask(0, 0);
		}
		else 
		{
			if (taskOptionDlg.m_DeleteCloud)
			{
				if (m_vtNeedDelClounTaskID.size() == 0)
				{
					if (LANG_ZHCN == g_iUILanguage)
						AfxMessageBox(_T("未勾选云端的任务"));
					else
						MessageBoxEx(NULL, _T("The cloud task is not checked"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
					return;
				}
				else
				{
					DeleteTask();
					CString strLog;
					int iDelNoCancelTestCount = m_vtDelNoCancelTest.size();
					if (m_vtDelNoCancelTest.size() > 0)
					{
						if (g_iUILanguage == LANG_ZHCN)
							strLog += _T("请取消测试后删除任务：");
						else
							strLog += _T("Please cancel the test and delete the task: ");

						for (int i = 0; i < iDelNoCancelTestCount; i++)
						{
							strLog += m_vtDelNoCancelTest.at(i);
							if (i != iDelNoCancelTestCount - 1)
							{
								strLog += _T(",");
							}
							else
							{
								strLog += _T(";");
							}
						}
					}

					int iFailedDelTaskIDCount = m_vtFailedDelTaskID.size();
					if (m_vtFailedDelTaskID.size() > 0)
					{
						if (g_iUILanguage == LANG_ZHCN)
							strLog += _T("未知错误：");
						else
							strLog += _T("unknown error: ");

						for (int i = 0; i < iFailedDelTaskIDCount; i++)
						{
							strLog += m_vtFailedDelTaskID.at(i);
							if (i != iFailedDelTaskIDCount - 1)
							{
								strLog += _T(",");
							}
							else
							{
								strLog += _T(";");
							}
						}
					}

					if (iDelNoCancelTestCount <= 0 && iFailedDelTaskIDCount <= 0)
					{
						if (g_iUILanguage == LANG_ZHCN)
							AfxMessageBox(_T("删除任务成功"));
						else
							MessageBoxEx(NULL, _T("Delete task success"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
					}
					else
					{
						CString strTips;
						if (g_iUILanguage == LANG_ZHCN)
						{
							strTips.Format(_T("删除云端任务失败,%s"), strLog);
							AfxMessageBox(strTips);
						}							
						else
						{
							strTips.Format(_T("Delete cloud task failed,%s"), strLog);
							MessageBoxEx(NULL, strTips, STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
						}
					}
					OnMsgTaskRefreshList(0, 0);
				}
			}

			if (taskOptionDlg.m_DeleteLocal)//删除本地数据
			{
				//传递删除的参数，判断是否还需要删除
				if (m_vtNeedDelLocalTaskID.size() == 0)
				{
					if (LANG_ZHCN == g_iUILanguage)
						AfxMessageBox(_T("未勾选本地的任务"));
					else
						MessageBoxEx(NULL, _T("Local task not checked"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
					return;
				}
				else
				{
					OnMsgDeleteTask(0, 0);
				}
			}
		}
	}
}

extern SYSTEMTIME g_sysCurTime;
UINT CDialTaskManager::DeleteTask()
{
	CAutoLock clsAutoLock(theApp.m_NetWorkOper.GetNetCriticalSection());
	CString strLog;
	CString strTaskID;
	char chStr[20] = { 0 };
	char chSendStr[MAX_NAME_LEN + 1] = { 0 };
	int iLen = 0;
	theApp.m_NetWorkOper.SetSuspendForThread(true);
	m_vtFailedDelTaskID.clear();
	//m_vtDelTaskRunning.clear();
	m_vtDelNoCancelTest.clear();
	//获取云端需要删除的TaskID

	CString strTime;
	strTime.Format("%04d%02d%02d%02d%02d%02d", g_sysCurTime.wYear, g_sysCurTime.wMonth, g_sysCurTime.wDay, \
		g_sysCurTime.wHour, g_sysCurTime.wMinute, g_sysCurTime.wSecond);
	for (int i = 0; i < m_vtNeedDelClounTaskID.size(); i++)
	{
		strTaskID = m_vtNeedDelClounTaskID.at(i);
		strncpy(chSendStr, strTaskID, MAX_NAME_LEN * sizeof(BYTE));
		if (!theApp.m_NetWorkOper.SendCtrlMsgDirect(EN_REQ_TASK_DEL, 0xFFFFFFFF, 1, (char*)chSendStr, MAX_NAME_LEN))
		{
			theApp.m_NetWorkOper.SetSuspendForThread(false);
			if (LANG_ZHCN == g_iUILanguage)
				AfxMessageBox(_T("删除任务发送失败"));
			else
				MessageBoxEx(NULL, _T("Msg delete task send failed"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
			return 0;
		}
		strLog.Format(_T("zm:system time=%s request delete task count(%d),Num(%d) taskID=%s\n"),strTime, m_vtNeedDelClounTaskID.size(), i, chSendStr);
		CFileOperTools::GetInstance()->WriteComLog(strLog);
		if (EN_RECV_SUCCESS == theApp.m_NetWorkOper.RecvMsgDirect(chStr, &iLen, 20, 5000))
		{
			switch (chStr[0])
			{
			case FAILED_NO_ERROR:
			break;
// 			case FAILED_TASK_IS_RUNNING:
// 			{
// 				strLog.Format(_T("zm:cloud delete task failed, task is running error=%d taskid=%s"), chStr[0], strTaskID);
// 				CFileOperTools::GetInstance()->WriteComLog(strLog);
// 				m_vtDelTaskRunning.push_back(strTaskID);
// 			}
// 			break;
			case FAILED_LOOP_TASK_NO_CANCEL_TEST://正在测试中的任务和在等待的定时任务都是返回4
			{
				strLog.Format(_T("zm:cloud delete task failed, loop task is waitting  error=%d taskid=%s"), chStr[0], strTaskID);
				CFileOperTools::GetInstance()->WriteComLog(strLog);
				m_vtDelNoCancelTest.push_back(strTaskID);
			}
			break;
			default:
			{				
				strLog.Format(_T("zm:cloud delete task failed, unknown error=%d taskid=%s"), chStr[0], strTaskID);
				CFileOperTools::GetInstance()->WriteComLog(strLog);
				m_vtFailedDelTaskID.push_back(strTaskID);
			}
			break;
			}
		}
	}	
	theApp.m_NetWorkOper.SetSuspendForThread(false);
	return 0;
}

void CDialTaskManager::InitTaskTree()
{
	CRect rcTaskTree;
	m_tabTaskChg.GetClientRect(&rcTaskTree);
	rcTaskTree.top += 2;
	rcTaskTree.left += 2;
	rcTaskTree.right -= 2;
	rcTaskTree.bottom -= 23;

	/*m_Dial1DTaskTree.m_uiGD10DevID = m_uiDstDevID;
	m_Dial1DTaskTree.Create(IDD_DIALOG_TASK_TREE, &m_tabTaskChg);
	m_Dial1DTaskTree.RegisterWnd(this);
	m_Dial1DTaskTree.MoveWindow(&rcTaskTree);*/

	m_Dial2DTaskTree.m_uiGD10DevID = m_dwDeviceSN;
	m_Dial2DTaskTree.Create(IDD_DIALOG_TASK_TREE, &m_tabTaskChg);
	m_Dial2DTaskTree.RegisterWnd(this);
	m_Dial2DTaskTree.MoveWindow(&rcTaskTree);

	m_Dial3DTaskTree.m_uiGD10DevID = m_dwDeviceSN;
	m_Dial3DTaskTree.Create(IDD_DIALOG_TASK_TREE, &m_tabTaskChg);
	m_Dial3DTaskTree.RegisterWnd(this);
	m_Dial3DTaskTree.MoveWindow(&rcTaskTree);
}

void CDialTaskManager::SelectShowTaskTree(int iSelType)
{
	switch (iSelType)
	{
	/*case EN_1D_TASK_TREE:
	{
		m_Dial2DTaskTree.ShowWindow(SW_HIDE);
		m_Dial3DTaskTree.ShowWindow(SW_HIDE);
		m_Dial1DTaskTree.ShowWindow(SW_SHOW);
		m_iTaskTree = &m_Dial1DTaskTree;
		m_iTaskTree->ShowTaskTree(EN_1D_TASK_TREE);
	}
	break;*/
	case 0://二维
	{
		//m_Dial1DTaskTree.ShowWindow(SW_HIDE);
		CFileOperTools::GetInstance()->WriteComLog(_T("zm:CDialTaskManager::SelectShowTaskTree show 2d task list"));
		m_Dial3DTaskTree.ShowWindow(SW_HIDE);
		m_Dial2DTaskTree.ShowWindow(SW_SHOW);
		m_Dial2DTaskTree.ShowTaskTree(EN_2D_TASK_TREE);
		m_iTaskTree = &m_Dial2DTaskTree;
	}
	break;
	case 1://三维
	{
		CFileOperTools::GetInstance()->WriteComLog(_T("zm:CDialTaskManager::SelectShowTaskTree show 3d task list"));
		//m_Dial1DTaskTree.ShowWindow(SW_HIDE);
		m_Dial2DTaskTree.ShowWindow(SW_HIDE);
		m_Dial3DTaskTree.ShowWindow(SW_SHOW);
		m_Dial3DTaskTree.ShowTaskTree(EN_3D_TASK_TREE);
		m_iTaskTree = &m_Dial3DTaskTree;
	}
	break;
	default:
		break;
	}
}
BOOL CDialTaskManager::OnInitDialog() 
{
	CNetRequestDialog::OnInitDialog();
	CString strTitle;
	strTitle.Format(_T("SN%u"), m_dwDeviceSN);
	this->SetWindowText(strTitle);
	
	// TODO: Add extra initialization here
	//m_tabTaskChg.InsertItem(0, _T("VES TASK"));
	m_tabTaskChg.InsertItem(0, _T("2D TASK"));
	m_tabTaskChg.InsertItem(1, _T("3D TASK"));
	m_iSelTaskType = 0;//默认选中二维任务列表
	
	InitTaskTree();
	SelectShowTaskTree(m_iSelTaskType);

	CString strLog;
	strLog.Format(_T("zm://////////CDialTaskManager::OnInitDialog init task list g_strSaveTestingTaskID=%s"), g_strSaveTestingTaskID);
	CFileOperTools::GetInstance()->WriteComLog(strLog);
	m_tabTaskChg.SetCurSel(m_iSelTaskType);
	//初始化任务属性
	InitialTaskListAttr();
	
	//初始化任务数据		
	CRect rect2;
	m_listTaskData.ShowWindow(FALSE);
	m_dialRealTimeMeasuData.SetSptType(m_iSelTaskType);
	m_dialRealTimeMeasuData.SetTaksID(0);
	m_dialRealTimeMeasuData.SetDeviceID(0);
	m_dialRealTimeMeasuData.Create(IDD_DIALOG_REAL_TIME_MEASURE_DATA, this);
	m_listTaskData.GetWindowRect(&rect2);
	ScreenToClient(&rect2);
	m_dialRealTimeMeasuData.MoveWindow(&rect2);
// 	m_dialRealTimeMeasuData.SetBtnStatus(EN_MEASU_BTN_NOT_SELECT_TASK);
	m_dialRealTimeMeasuData.ShowWindow(SW_SHOW);
	m_strTaskStatusTips = _T("Task Data: ");
	if (LANG_ZHCN == g_iUILanguage)
	{
		GetDlgItem(IDC_STATIC_START_TIME)->SetWindowTextA(_T("开始时间:"));
		GetDlgItem(IDC_STATIC_END_TIME)->SetWindowTextA(_T("结束时间:"));
		GetDlgItem(IDC_STATIC_TASK_LIST)->SetWindowText(_T("查询时间:"));
		GetDlgItem(IDC_BTN_QUREY_TASK_LIST)->SetWindowTextA(_T("查询"));
		m_strTaskStatusTips = _T("任务数据: ");
		GetDlgItem(IDC_STATIC_TASK_DATA)->SetWindowText(m_strTaskStatusTips);

		GetDlgItem(IDC_BUTTON_CREATE_TASK)->SetWindowText(_T("创建任务"));
		GetDlgItem(IDC_BUTTON_DEL_TASK)->SetWindowText(_T("删除任务"));
		GetDlgItem(IDC_BUTTON_MEASURE_TASK)->SetWindowText(_T("调试测量"));

		GetDlgItem(IDC_BTN_DATA_DOWNLOAD)->SetWindowText(_T("数据下载"));
		GetDlgItem(IDC_BTN_CREATE_TIMER_TASK)->SetWindowText(_T("新建定时任务"));
		GetDlgItem(IDC_BTN_MANAGER_TIMER_TASK)->SetWindowText(_T("定时任务管理"));
	}

	CTime time;
	CTime TDate;
	time_t tTime;
	CString strTime;
	CString strDate;
	m_StartTime.GetTime(TDate);
	//strDate = TDate.Format("%Y-%m-%d");     //获取到的为日期 如：2010-03-05
	strDate.Format("%4d-%2d-%2d", TDate.GetYear(), TDate.GetMonth(), TDate.GetDay() - 7);
	strTime = time.Format(" 00:00:00");
	strDate += strTime;
	tTime = Str2GmtTm(strDate);
	m_StartTime.SetTime(tTime);

	m_EndTime.GetTime(TDate);
	//strDate.Format(_T("%d-%d-%d"), TDate.GetYear(), TDate.GetMonth(), TDate.GetDay() + 3);     //获取到的为日期 如：2010-03-05
	strDate = TDate.Format("%Y-%m-%d");
	strTime = time.Format(" 23:59:59");
	strDate += strTime;
	tTime = Str2GmtTm(strDate);
	m_EndTime.SetTime(tTime);

	m_taskOper.m_uiDevID = m_dwDeviceSN;
	CString str;
	str.Format(_T("zm:---------------theApp.m_NetWorkOper.RegeditRealMsgCall(this->m_hWnd=%0x)"), this->m_hWnd);
	CFileOperTools::GetInstance()->WriteComLog(str);
	theApp.m_NetWorkOper.RegeditRealMsgCall(this->m_hWnd);
	//180s刷新一次任务列表
	//SetTimer(ID_TIMER_HEARTBEAT_PACKET, HEARTBEAT_INTERVAL, NULL);
	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

/*void CDialTaskManager::InitialTaskListData(int iTestType)
{
	if (iTestType == m_iTestType)
	{
		return;
	}
	m_listTaskData.DeleteAllItems();
	int iColumnCount =  m_listTaskData.GetHeaderCtrl()->GetItemCount();   
	for(int i=0; i < iColumnCount; i++)   
	{   
        m_listTaskData.DeleteColumn(0);   
	}   
    m_iTestType = iTestType;
	int iColIndex = 0;
	m_listTaskData.InsertColumn(iColIndex++, _T("A"), LVCFMT_CENTER, 80);
	m_listTaskData.InsertColumn(iColIndex++, _T("B"), LVCFMT_CENTER, 80);
	m_listTaskData.InsertColumn(iColIndex++, _T("M"), LVCFMT_CENTER, 80);
	m_listTaskData.InsertColumn(iColIndex++, _T("N"), LVCFMT_CENTER, 80);
	m_listTaskData.InsertColumn(iColIndex++, _T("Stack"), LVCFMT_CENTER, 80);
	m_listTaskData.InsertColumn(iColIndex++, "K", LVCFMT_CENTER, 120);
    m_listTaskData.InsertColumn(iColIndex++, "V(mV)", LVCFMT_CENTER, 120);
	m_listTaskData.InsertColumn(iColIndex++, "I(mA)", LVCFMT_CENTER, 120);
	if (0 == iTestType)
	{
		m_listTaskData.InsertColumn(iColIndex++, "R(Ohm)", LVCFMT_CENTER, 120);
	}
    m_listTaskData.InsertColumn(iColIndex++, "R0(Ohm*m)", LVCFMT_CENTER, 120);
	m_listTaskData.InsertColumn(iColIndex++, "SP(mV)", LVCFMT_CENTER, 120);
}
*/
void CDialTaskManager::InitialTaskListAttr()
{
	CString strColTitle;
	m_listTaskAttr.SetExtendedStyle(LVS_EX_FULLROWSELECT | LVS_EX_HEADERDRAGDROP 
		| LVS_EX_ONECLICKACTIVATE | LVS_EX_GRIDLINES);
	CRect rectTask;
	m_listTaskAttr.GetClientRect(&rectTask);
	int iListWidth = rectTask.right - rectTask.left;
	m_listTaskAttr.InsertColumn(0, _T(""), LVCFMT_RIGHT, 1);
	if (LANG_ENUS == g_iUILanguage)
	{
		m_listTaskAttr.InsertColumn(1, _T("Attribute"), LVCFMT_RIGHT, 150);
		m_listTaskAttr.InsertColumn(2, _T("Value"), LVCFMT_LEFT, iListWidth-170);
	}
	else 
	{
		m_listTaskAttr.InsertColumn(1, _T("任务属性"), LVCFMT_RIGHT, 150);
		m_listTaskAttr.InsertColumn(2, _T("属性值"), LVCFMT_LEFT, iListWidth - 170);
	}

	int iItemIndex = 0;
	
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_TDNAME + g_UIOffset);
	m_listTaskAttr.InsertItem(iItemIndex, _T(""));
	m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);

	iItemIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_CN + g_UIOffset);
	m_listTaskAttr.InsertItem(iItemIndex, _T(""));
	m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);

	iItemIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_SCON_SNAME + g_UIOffset);
	m_listTaskAttr.InsertItem(iItemIndex, _T(""));
	m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);

	iItemIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_SCON_STYPE + g_UIOffset);
	m_listTaskAttr.InsertItem(iItemIndex, _T(""));
	m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);

	iItemIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_TMODE + g_UIOffset);
	m_listTaskAttr.InsertItem(iItemIndex, _T(""));
	m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);

	iItemIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_ARRAY_TYPE + g_UIOffset);
	m_listTaskAttr.InsertItem(iItemIndex, _T(""));
	m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);

	iItemIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_SCON_EAMOUNT + g_UIOffset);
	m_listTaskAttr.InsertItem(iItemIndex, _T(""));
	m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);

	iItemIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_SCON_TPAMOUNT + g_UIOffset);
	m_listTaskAttr.InsertItem(iItemIndex, _T(""));
	m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);

	iItemIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_SCRIPT_N + g_UIOffset);
	m_listTaskAttr.InsertItem(iItemIndex, _T(""));
	m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);

	iItemIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_TRWAVE + g_UIOffset);
	m_listTaskAttr.InsertItem(iItemIndex, _T(""));
	m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);

	iItemIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_TRFREQUENCY + g_UIOffset);
	m_listTaskAttr.InsertItem(iItemIndex, _T(""));
	m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);

	iItemIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_CLAYOUT + g_UIOffset);
	m_listTaskAttr.InsertItem(iItemIndex, _T(""));
	m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);

	iItemIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_EDISTANCE + g_UIOffset);
	m_listTaskAttr.InsertItem(iItemIndex, _T(""));
	m_listTaskAttr.SetItemText(iItemIndex, 1, strColTitle);

	if (LANG_ZHCN == g_iUILanguage)
	{
		iItemIndex++;
		m_listTaskAttr.InsertItem(iItemIndex, _T(""));
		m_listTaskAttr.SetItemText(iItemIndex, 1, _T("数据下载记录"));

		iItemIndex++;
		m_listTaskAttr.InsertItem(iItemIndex, _T(""));
		m_listTaskAttr.SetItemText(iItemIndex, 1, _T("最近任务下载时间"));

		iItemIndex++;
		m_listTaskAttr.InsertItem(iItemIndex, _T(""));
		m_listTaskAttr.SetItemText(iItemIndex, 1, _T("云端最近测试时间"));

		iItemIndex++;
		m_listTaskAttr.InsertItem(iItemIndex, _T(""));
		m_listTaskAttr.SetItemText(iItemIndex, 1, _T("创建任务时间"));

		iItemIndex++;
		m_listTaskAttr.InsertItem(iItemIndex, _T(""));
		m_listTaskAttr.SetItemText(iItemIndex, 1, _T("是否测试接地电阻"));

		iItemIndex++;
		m_listTaskAttr.InsertItem(iItemIndex, _T(""));
		m_listTaskAttr.SetItemText(iItemIndex, 1, _T("测试失败的原因"));
	}
	else
	{	
		iItemIndex++;
		m_listTaskAttr.InsertItem(iItemIndex, _T(""));
		m_listTaskAttr.SetItemText(iItemIndex, 1, _T("Data download record"));

		iItemIndex++;
		m_listTaskAttr.InsertItem(iItemIndex, _T(""));
		m_listTaskAttr.SetItemText(iItemIndex, 1, _T("Latest download time"));

		iItemIndex++;
		m_listTaskAttr.InsertItem(iItemIndex, _T(""));
		m_listTaskAttr.SetItemText(iItemIndex, 1, _T("Clouding lastest time"));

		iItemIndex++;
		m_listTaskAttr.InsertItem(iItemIndex, _T(""));
		m_listTaskAttr.SetItemText(iItemIndex, 1, _T("Create time"));

		iItemIndex++;
		m_listTaskAttr.InsertItem(iItemIndex, _T(""));
		m_listTaskAttr.SetItemText(iItemIndex, 1, _T("Whether the GR  test?"));

		iItemIndex++;
		m_listTaskAttr.InsertItem(iItemIndex, _T(""));
		m_listTaskAttr.SetItemText(iItemIndex, 1, _T("Test failed reason"));
	}
	
}

LRESULT CDialTaskManager::OnClickTaskTree(WPARAM wParam, LPARAM lParam)
{
	//SetPauseThread(true);
	m_vtNeedSynTaskID.clear();
	STTaskListItem* pTaskItem = (STTaskListItem*)wParam;
	if (NULL == pTaskItem)
	{
		return 0;
	}
	m_dialRealTimeMeasuData.SetTaksID(pTaskItem->szTaskID);
	m_dialRealTimeMeasuData.SetTaskListSelectItem(pTaskItem);
	m_dialRealTimeMeasuData.SetTestingTaskID(g_strSaveTestingTaskID);
	CString strLog;
	strLog.Format(_T("zm://////////CDialTaskManager::OnClickTaskTree select task Item g_strSaveTestingTaskID=%s"), g_strSaveTestingTaskID);
	CFileOperTools::GetInstance()->WriteComLog(strLog);
	m_dialRealTimeMeasuData.m_uiPlcID = m_dwPLCID;
	m_dialRealTimeMeasuData.m_uiDevID = m_dwDeviceSN;
	if (g_strSaveTestingTaskID.IsEmpty())
	{
		//调试测量按钮状态可点击
		GetDlgItem(IDC_STATIC_TASK_DATA)->SetWindowTextA(m_strTaskStatusTips);
		GetDlgItem(IDC_BUTTON_MEASURE_TASK)->EnableWindow(TRUE);
		m_dialRealTimeMeasuData.SetBtnStatus(EN_MEASU_BTN_SELECT_TASK);
	}
	else
	{
		//调试测量按钮状态不可点击		
		GetDlgItem(IDC_BUTTON_MEASURE_TASK)->EnableWindow(FALSE);
		if (strcmp(g_strSaveTestingTaskID, pTaskItem->szTaskID) != 0)
		{
			GetDlgItem(IDC_STATIC_TASK_DATA)->SetWindowTextA(m_strTaskStatusTips);
			m_dialRealTimeMeasuData.SetBtnStatus(EN_MEASU_BTN_NOT_TESTING_TASK);
		}
		else
		{
			//正在测试中的任务清空实时窗口之前的数据
			if (pTaskItem->byTestStatus == 10)//任务初始化状态
			{
				if (LANG_ZHCN == g_iUILanguage)
				{
					GetDlgItem(IDC_STATIC_TASK_DATA)->SetWindowTextA(m_strTaskStatusTips + _T("任务初始化..."));
				}
				else
				{
					GetDlgItem(IDC_STATIC_TASK_DATA)->SetWindowTextA(m_strTaskStatusTips + _T("Task initialization..."));
				}
			}
			else if (pTaskItem->byTestStatus == 11)
			{
				if (LANG_ZHCN == g_iUILanguage)
				{
					GetDlgItem(IDC_STATIC_TASK_DATA)->SetWindowTextA(m_strTaskStatusTips + _T("测试接地电阻和测试数据中..."));
				}
				else
				{
					GetDlgItem(IDC_STATIC_TASK_DATA)->SetWindowTextA(m_strTaskStatusTips + _T("Test ground resistance and test data..."));
				}
			}
			else
			{
				GetDlgItem(IDC_STATIC_TASK_DATA)->SetWindowTextA(m_strTaskStatusTips);
			}
			
			m_dialRealTimeMeasuData.m_dialListMeasuTask.m_listData.DeleteAllItems();
			m_dialRealTimeMeasuData.SetBtnStatus(EN_MEASU_BTN_MEASU_ALL);
		}
	}

	memcpy(&m_dialRealTimeMeasuData.m_stTaskItem, pTaskItem, sizeof(STTaskListItem));
	if (EN_TASK_NO_UPLOAD == pTaskItem->eSynStatus)//本地未上传任务
	{
		m_taskOper.QueryTdAttrToCtrl(m_listTaskAttr, atoi(pTaskItem->szTaskID));
		//int iTtype = m_taskOper.GetCurSelTdTestType();

		//InitialTaskListData(iTtype);
		//m_taskOper.QueryTdDataToCtrl(m_listTaskData, atoi(pTaskItem->szTaskID), m_iSelTaskType, iTtype);
	}
	else
	{
		//点击任务列表某个任务，同步任务信息		
		m_vtNeedSynTaskID.push_back(*pTaskItem);
		//AfxBeginThread(DealTaskInfoSynThread, this);		
		OnSynCouldTaskInfoRequest(m_vtNeedSynTaskID);
	}
	return 0;
}


//实时接收测试中任务点信息
/*UINT CDialTaskManager::DealTaskTestingSynThread(LPVOID pParam)
{
	return 1;


	CDialTaskManager* pThis = (CDialTaskManager*)pParam;
	if (NULL == pThis)
	{
		return 0;
	}

	Sleep(200);
	//CAutoLock autoLock(&pThis->m_cs);
	int iMaxSynNum = 50;
	char chStr[500];
	int iLen = 0;
	UINT32 uiStartID = 0;
	BYTE ucPointNum = 0;
	char szTaskID[MAX_NAME_LEN];
	STRemTaskArg stTaskArg; //记录上一次任务以防任务变更
	bool bPauseFlg = false; //记录上一次线程暂停标志
	char *pData = (char *)malloc(sizeof(char)*4096);
	if (NULL == pData)
	{
		return 0;
	}

	std::vector<STTaskDetailBasicData> vtData;
	theApp.m_NetWorkOper.SetSuspendForThread(true);
	while (pThis->m_bThreadIsRunning)
	{
		if (pThis->m_bThreadIsPause)
		{
			bPauseFlg = true;
			theApp.m_NetWorkOper.SetSuspendForThread(false);
			Sleep(30);
			continue;
		}
		if (true == bPauseFlg)
		{
			theApp.m_NetWorkOper.SetSuspendForThread(true);
			bPauseFlg = false;
		}
// 		if (pThis->m_bThreadIsExit)
// 		{
// 			break;
// 		}

		if (0 != strcmp(stTaskArg.ucTaskID, pThis->m_stRealTimeTaskArg.ucTaskID))
		{
			memcpy(&stTaskArg, &pThis->m_stRealTimeTaskArg, sizeof(STRemTaskArg));
		}

		if (EN_RECV_SUCCESS == theApp.m_NetWorkOper.RecvMsgDirect(chStr, &iLen, sizeof(chStr), 1000))
		{
			ucPointNum = chStr[sizeof(char)*MAX_NAME_LEN];
			int iPackLen = (ucPointNum*sizeof(STMeasuDataResBasic))+sizeof(char)*MAX_NAME_LEN + sizeof(char);
			if (0 >= iLen || iLen != iPackLen || 0 >= ucPointNum) //长度和转发点数判断
			{
				Sleep(10);
				continue;
			}
			STMeasuDataResBasic *pMeasuDataRes = (STMeasuDataResBasic *)&chStr[sizeof(char)*MAX_NAME_LEN + sizeof(char)];
			memcpy(szTaskID, chStr, sizeof(sizeof(char)*MAX_NAME_LEN));
			if ((0 >= ntohl(pMeasuDataRes->iID) || 100000 <  ntohl(pMeasuDataRes->iID))
				|| 0 != strcmp(szTaskID, stTaskArg.ucTaskID))//点数ID和任务ID判断
			{
				Sleep(10);
				continue;
			}

			if (0 == uiStartID || ntohl(pMeasuDataRes->iID) > uiStartID + iMaxSynNum) //从云端获取ABMN信息，便于动态显示，每50点获取一次
			{
				int i;
				for (i = 0; i < 3; i++)//失败获取三次
				{
					if (true == pThis->m_taskOper.QueryOnLineTdDataFromSev(stTaskArg, pMeasuDataRes->iID, pMeasuDataRes->iID + iMaxSynNum, pData))
					{
						uiStartID = ntohl(pMeasuDataRes->iID);
						break;
					}
					Sleep(10);
				}
				theApp.m_NetWorkOper.SetSuspendForThread(true);
				if (3 <= i) //未获取数据信息
				{
					break;
				}
			}
			vtData.clear();
			for (int i = 0; i < ucPointNum; i++)
			{
				int iSevDataIndex = pMeasuDataRes->iID - uiStartID + i;
				STTaskDataRes *ptTaskData = (STTaskDataRes *)&pData[MAX_NAME_LEN * sizeof(BYTE)+sizeof(UINT32)+iSevDataIndex*sizeof(STTaskDataRes)];
				STMeasuDataResBasic *pMeasuData = &pMeasuDataRes[sizeof(STMeasuDataResBasic)*i];
				STTaskDataRes stMeasuBasicData;
				stMeasuBasicData.dwID = ntohl(ptTaskData->dwID);
				stMeasuBasicData.fA = tcp_ntohf(ptTaskData->fA);
				stMeasuBasicData.fB = tcp_ntohf(ptTaskData->fB);
				stMeasuBasicData.fM = tcp_ntohf(ptTaskData->fM);
				stMeasuBasicData.fN = tcp_ntohf(ptTaskData->fN);
				stMeasuBasicData.fK = tcp_ntohf(stMeasuBasicData.fK);
				stMeasuBasicData.fV = tcp_ntohf(stMeasuBasicData.fV);
				stMeasuBasicData.fI = tcp_ntohf(stMeasuBasicData.fI);
				stMeasuBasicData.fR0 = tcp_ntohf(stMeasuBasicData.fR0);
				stMeasuBasicData.fSP = tcp_ntohf(stMeasuBasicData.fSP);
				stMeasuBasicData.ucAlram = stMeasuBasicData.ucAlram;
				stMeasuBasicData.ucStack = stMeasuBasicData.ucStack;
				stMeasuBasicData.fR0_LC = tcp_ntohf(stMeasuBasicData.fR0_LC);

				STTaskDetailBasicData stTaskDetailData;
				stTaskDetailData.iID = stMeasuBasicData.dwID;
				stTaskDetailData.iA = stMeasuBasicData.fA;
				stTaskDetailData.iB = stMeasuBasicData.fB;
				stTaskDetailData.iM = stMeasuBasicData.fM;
				stTaskDetailData.iN = stMeasuBasicData.fN;
				stTaskDetailData.fK = stMeasuBasicData.fK;
				stTaskDetailData.fV = stMeasuBasicData.fV;
				stTaskDetailData.fI = stMeasuBasicData.fI;
				stTaskDetailData.fR0 = stMeasuBasicData.fR0;
				stTaskDetailData.fSP = stMeasuBasicData.fSP;
				stTaskDetailData.ucStack = stMeasuBasicData.ucStack;
				stTaskDetailData.ucIsUse = 1;// stMeasuBasicData.ucAlram;
				vtData.push_back(stTaskDetailData);
			}
			pThis->SendMessage(WM_TASK_LIST_TASK_DATA_SYN, (WPARAM)&vtData, 1);
		}
		Sleep(10);
	}
	theApp.m_NetWorkOper.SetSuspendForThread(false);
	if (NULL != pData)
	{
		free(pData);
	}
	return 0;
}*/
LRESULT CDialTaskManager::OnMsgTaskListTaskDataSyn(WPARAM wParam, LPARAM lParam)
{
	std::vector<STTaskDetailBasicData>* vtData = (std::vector<STTaskDetailBasicData>*)wParam;
	int iTeatingFlg = (int)lParam;//==1为测试中的任务

	int iTaskCount = vtData->size();
	if (iTaskCount <= 0)
	{
		return 0;
	}
	if (1 != iTeatingFlg)
	{
		m_dialRealTimeMeasuData.m_dialListMeasuTask.OnShowTdData(*vtData);
	}
	else
	{
		CFileOperTools::GetInstance()->WriteComLog(_T("zm: CDialTaskManager::OnMsgTaskListTaskDataSyn iTeatingFlg == 1 testing data"));
		m_dialRealTimeMeasuData.m_dialListMeasuTask.SetRealTimeCurrentTaskArg(this->m_hWnd, m_stRealTimeTaskArg);
		//EN_TASK_TESTING_METHOD eTestting = m_dialRealTimeMeasuData.GetTestingMethod();
		if (g_eTestingMethod == EN_TASK_FROM_CURRENT_POINT_TEST || g_eTestingMethod == EN_TASK_CURRENT_ONE_POINT_TEST)//单点测量和从当前测量，如果已经测了的点，直接修改值
		{
			//遍历修改点			
			//m_dialRealTimeMeasuData.m_dialListMeasuTask.SetTestingMethod(g_eTestingMethod);
			m_dialRealTimeMeasuData.m_dialListMeasuTask.OnShowTdDataUpdate(*vtData);			
		}
		else
		{
			//追加
			m_dialRealTimeMeasuData.m_dialListMeasuTask.OnShowTdDataAppend(*vtData);
		}
	}
	return 0;
}

LRESULT CDialTaskManager::OnMsgTaskRefreshList(WPARAM wParam, LPARAM lParam)
{
	CString strLog;
	strLog.Format(_T("zm:CDialTaskManager::OnMsgTaskRefreshList显示%dD列表"), m_iSelTaskType+1);
	CFileOperTools::GetInstance()->WriteComLog(strLog);
	SelectShowTaskTree(m_iSelTaskType);
	OnMsgUpdateRealTimeWndBtnStatus(0, 0);
	return 0;
}


/*
*lParam 0需要更新实时窗口的按钮状态，反之非0
*/
LRESULT CDialTaskManager::OnMsgUpdateRealTimeWndBtnStatus(WPARAM wParam, LPARAM lParam)
{
	CString strLog;
	CWnd* pWnd = GetDlgItem(IDC_BUTTON_MEASURE_TASK);
	strLog.Format(_T("zm:update realtime wnd button status g_strSaveTestingTaskID=%s"), g_strSaveTestingTaskID);
	CFileOperTools::GetInstance()->WriteComLog(strLog);
	if (lParam == 0)
	{
		if (g_strSaveTestingTaskID.IsEmpty())
		{
			//调试测量按钮状态可点击
			
			if (NULL != pWnd)
				pWnd->EnableWindow(TRUE);
			m_dialRealTimeMeasuData.SetBtnStatus(EN_MEASU_BTN_SELECT_TASK);
		}
		else
		{
			//调试测量按钮状态不可点击
			if (NULL != pWnd)
				pWnd->EnableWindow(FALSE);
			if (g_eTestingMethod == EN_TASK_SUSPENDED)
			{
				//调试测量按钮状态可点击
				if (NULL != pWnd)
					pWnd->EnableWindow(TRUE);
				m_dialRealTimeMeasuData.SetBtnStatus(EN_MEASU_BTN_SELECT_TASK);
			}
			else
			{
				CString strSelectTask = _T("");
				HTREEITEM hSelectItem = m_iTaskTree->GetTaskTreePtr()->GetSelectedItem();
				if (hSelectItem != NULL)
				{
					STTaskListItem* pTaskItem = (STTaskListItem*)m_iTaskTree->GetTaskTreePtr()->GetItemData(hSelectItem);
					if (pTaskItem != NULL)
					{
						strSelectTask = pTaskItem->szTaskID;
					}
				}

				if (strcmp(g_strSaveTestingTaskID, strSelectTask) != 0)
				{
					m_dialRealTimeMeasuData.SetBtnStatus(EN_MEASU_BTN_NOT_TESTING_TASK);
				}
				else
				{
					//正在测试中的任务清空实时窗口之前的数据
					m_dialRealTimeMeasuData.SetBtnStatus(EN_MEASU_BTN_MEASU_ALL);
				}
			}
		}
	}
	else
	{
		//本地操作后服务器没有那么快响应
// 		if (g_strSaveTestingTaskID.IsEmpty())
// 		{
// 			//调试测量按钮状态可点击
//		if (NULL != pWnd)
// 			pWnd->EnableWindow(TRUE);
// 		}
// 		else
// 		{
			//调试测量按钮状态不可点击
			pWnd->EnableWindow(FALSE);
//		}
	}
	return 0;
}

LRESULT CDialTaskManager::OnMsgSetCurrentSelectTask(WPARAM wParam, LPARAM lParam)
{
	if (wParam == NULL)
	{
		ASSERT(wParam != NULL);
		return 0;
	}
	STTaskListItem* pTaskItem = (STTaskListItem*)wParam;
	if (pTaskItem != NULL)
	{
		//memcpy(&m_SelectTaskItem, pTaskItem, sizeof(STTaskListItem));
		m_dialRealTimeMeasuData.SetTaksID(pTaskItem->szTaskID);
		m_dialRealTimeMeasuData.SetTaskListSelectItem(pTaskItem);
		m_dialRealTimeMeasuData.SetTestingTaskID(g_strSaveTestingTaskID);
		CString strLog;
		strLog.Format(_T("zm:CDialTaskManager::OnMsgSetCurrentSelectTask select task notify realtime wnd g_strSaveTestingTaskID=%s，test status =%d"), g_strSaveTestingTaskID,pTaskItem->szTaskID);
		CFileOperTools::GetInstance()->WriteComLog(strLog);
		m_dialRealTimeMeasuData.m_uiPlcID = m_dwPLCID;
		m_dialRealTimeMeasuData.m_uiDevID = m_dwDeviceSN;
	}
	return 0;
}

void CDialTaskManager::OnCmdTaskCancelTest()
{
	CTreeCtrl* pTreeCtrl = m_iTaskTree->GetTaskTreePtr();
	HTREEITEM hItem = pTreeCtrl->GetSelectedItem();
	if (NULL == hItem)
	{
		if (LANG_ZHCN == g_iUILanguage)
			AfxMessageBox(_T("请先选择数据"));
		else
			MessageBoxEx(NULL, _T("Please select data first"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		return;
	}

	//遍历所有节点，判断是否勾选
	std::vector<CString>	vtCancelTestTaskID;
	std::vector<CString>	vtNoCancelTestTaskID;//不能取消测试的任务
	HTREEITEM rootItem = pTreeCtrl->GetRootItem();
	if (pTreeCtrl->ItemHasChildren(rootItem))
	{
		HTREEITEM childItem = pTreeCtrl->GetChildItem(rootItem);
		STTaskListItem* pTaskItem = NULL;
		while (childItem != NULL)
		{
			if (pTreeCtrl->GetCheck(childItem))
			{
				pTaskItem = (STTaskListItem*)pTreeCtrl->GetItemData(childItem);
				if (NULL == pTaskItem)
				{
					if (LANG_ZHCN == g_iUILanguage)
						AfxMessageBox(_T("获取任务数据ID错误"));
					else
						MessageBoxEx(NULL, _T("Can not find the test task.please select the task firstly"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
					return;
				}
				if (pTaskItem->byTestStatus == EN_TASK_STATE_TEST_FAILED || pTaskItem->byTestStatus == EN_TASK_STATE_FINISH) //测试完成或测试失败的不能取消测试
				{
					vtNoCancelTestTaskID.push_back(pTaskItem->szTaskID);
				}
				else
				{
					vtCancelTestTaskID.push_back(pTaskItem->szTaskID);
				}					
			}
			childItem = pTreeCtrl->GetNextSiblingItem(childItem);
		}
	}

	int iTaskCount = 0;
	//不能取消测试的任务提示
	iTaskCount = vtNoCancelTestTaskID.size();
	if (iTaskCount > 0)
	{
		if (g_iUILanguage == LANG_ZHCN)
		{
			AfxMessageBox(_T("测试完成或测试失败的任务，不能取消测试"), MB_OK);
		}
		else
		{
			MessageBoxEx(NULL, _T("Tests that complete or fail cannot be canceled"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		}		
		return;
	}
	

	iTaskCount = vtCancelTestTaskID.size();
	if (iTaskCount == 0)
	{
		if (LANG_ZHCN == g_iUILanguage)
			AfxMessageBox(_T("请先勾选数据"));
		else
			MessageBoxEx(NULL, _T("Please choose one task first"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		return;
	}

	theApp.m_NetWorkOper.SetSuspendForThread(true);
	CString strTaskCN;
	CString szMsg;
	char chStr[20] = { 0 };
	char chSendStr[MAX_NAME_LEN + sizeof(UINT32) + 1] = { 0 };
	int iLen = 0;
	m_bLastCancelTask = FALSE;
	for (int i = 0; i < iTaskCount; i++)
	{
		strTaskCN = vtCancelTestTaskID.at(i);
		if (strcmp(strTaskCN, g_strSaveTestingTaskID) == 0)
		{
			m_bCancelTestingTask = TRUE;
		}
		else
		{
			m_bCancelTestingTask = FALSE;
		}
		if (i == iTaskCount - 1)
		{
			m_bLastCancelTask = TRUE;
		}
		strncpy(chSendStr, strTaskCN, MAX_NAME_LEN * sizeof(BYTE));
		PostNetRequest(EN_CANCEL_COLLOCATION, this->m_hWnd, (char*)chSendStr, MAX_NAME_LEN);
// 		if (!theApp.m_NetWorkOper.SendCtrlMsgDirect(EN_CANCEL_COLLOCATION, 0xFFFFFFFF, 1, (char*)chSendStr, MAX_NAME_LEN))
// 		{
// 			theApp.m_NetWorkOper.SetSuspendForThread(false);
// 			AfxMessageBox(_T("Cancel task send failed."));
// 			continue;
// 		}
// 		if (EN_RECV_SUCCESS == theApp.m_NetWorkOper.RecvMsgDirect(chStr, &iLen, 20, 5000))
// 		{
// 			if ((iLen < iLen) || (EN_RECV_SUCCESS != chStr[0]))
// 			{
// 				theApp.m_NetWorkOper.SetSuspendForThread(false);
// 				szMsg.Format(_T("Task '%s' cancel trustee to failed."), strTaskCN);
// 				AfxMessageBox(szMsg);
// 				continue;
// 			}
// 		}
	}
	
	if (LANG_ZHCN == g_iUILanguage)
		AfxMessageBox(_T("任务取消测试成功"));
	else
		MessageBoxEx(NULL, _T("Task cancel trustee to succeed"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));

	theApp.m_NetWorkOper.SetSuspendForThread(false);
}

void CDialTaskManager::OnSelchangeTabTaskChg(NMHDR* pNMHDR, LRESULT* pResult) 
{
	//SetPauseThread(true);
	// TODO: Add your control notification handler code here
	if (m_iSelTaskType == m_tabTaskChg.GetCurSel())
	{
		return;
	}
	m_iSelTaskType = m_tabTaskChg.GetCurSel();
	CString strLog;
	strLog.Format(_T("zm:CDialTaskManager::OnSelchangeTabTaskChg m_iSelTaskType=%d"), m_iSelTaskType);
	CFileOperTools::GetInstance()->WriteComLog(strLog);

	OnMsgTaskRefreshList(0, 0);
	//m_dialTaskTree.ShowTaskTree(m_iSelTaskType);

	strLog.Format(_T("zm://////////CDialTaskManager::OnSelchangeTabTaskChg m_iSelTaskType=%d g_strSaveTestingTaskID=%s"), m_iSelTaskType, g_strSaveTestingTaskID);
	CFileOperTools::GetInstance()->WriteComLog(strLog);
	//m_dialRealTimeMeasuData.SetBtnStatus(EN_MEASU_BTN_NOT_SELECT_TASK);
	*pResult = 0;
}

void CDialTaskManager::OnBtnQueryTaskList()
{
	CTime time;
	CTime TStartDate,TEndData;
	time_t tStartTime,tEndTime;
	CString strTime;
	CString strStartDate,strEndData;
	UpdateData(TRUE);
	m_StartTime.GetTime(TStartDate);
	//m_CDTTimeStart.GetTime(time);
	strStartDate = TStartDate.Format("%Y-%m-%d");     //获取到的为日期 如：2010-03-05
	strTime = time.Format(" 00:00:00");
	strStartDate += strTime;
	tStartTime = Str2GmtTm(strStartDate);
	//request.uStartTime = htonl(tTime); //开始测试时间
	CString strLog;
	//strLog.Format(_T("zm:PLC status:strDate=%s,stLoopTaskInfo.uiStartTime=%u"), strDate, request.uStartTime);
	//CFileOperTools::GetInstance()->WriteComLog(strLog);

	m_EndTime.GetTime(TEndData);
	//m_CDTTimeEnd.GetTime(time);
	strEndData = TEndData.Format("%Y-%m-%d");     //获取到的为日期 如：2010-03-05
	strTime = time.Format(" 23:59:59");
	strEndData += strTime;
	tEndTime = Str2GmtTm(strEndData);

	strLog.Format(_T("查询列表开始时间%s(%d),接受时间%s(%d)"), strStartDate, tStartTime, strEndData, tEndTime);
	CFileOperTools::GetInstance()->WriteComLog(strLog);
	if (tStartTime > tEndTime)
	{
		if (g_iUILanguage == LANG_ZHCN)
			AfxMessageBox(_T("开始时间大于结束时间"));
		else
			MessageBoxEx(NULL, _T("Start time is greater than end time"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		return;
	}
	m_iTaskTree->ShowTaskTree(m_iSelTaskType, tStartTime, tEndTime);
	//request.uEndTime = htonl(tTime); //结束测试时间


}
void CDialTaskManager::OnButtonMeasureTask() 
{
	// TODO: Add your control notification handler code here
	//SetPauseThread(true);
	CTreeCtrl* pTreeCtrl = m_iTaskTree->GetTaskTreePtr();//m_dialTaskTree.m_treeTask;
	HTREEITEM hItem = pTreeCtrl->GetSelectedItem();
	if (NULL == hItem || pTreeCtrl->GetRootItem() == hItem)
	{
		if (LANG_ZHCN == g_iUILanguage)
			AfxMessageBox(_T("请先选择任务"));
		else
			MessageBoxEx(NULL, _T("Please select task firstly"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		return ;
	}
	STTaskListItem* pTaskItem = (STTaskListItem *)pTreeCtrl->GetItemData(hItem);
	if (pTaskItem == NULL)
	{
		ASSERT(pTaskItem != NULL);
		return;
	}
	
	//if ()//需区分ID进行判断
// 	{
// 		dwTdID = atoi(Task->szTaskID);
// 	}
	//else
	{
		//已同步的需查库获取ID
	}
	if (EN_TASK_NO_DOWNLOAD == pTaskItem->eSynStatus)
	{
		if (g_iUILanguage == LANG_ZHCN)
			AfxMessageBox(_T("请下载后调试"));
		else
			MessageBoxEx(NULL, _T("Please choose a downloaded task"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		return;
	}
	
	g_bIsOnlineTransfer = FALSE;
	CDialMeasureData dialMeasuData;
	dialMeasuData.SetTaksID(0);
	dialMeasuData.SetTaskID(pTaskItem->szTaskID);
	dialMeasuData.SetDeviceID(m_dwDeviceSN);

	theApp.m_NetWorkOper.UnRegeditRealMsgCall(this->m_hWnd);	
	dialMeasuData.DoModal();
	theApp.m_NetWorkOper.RegeditRealMsgCall(this->m_hWnd);

	g_bIsOnlineTransfer = TRUE;
	//m_taskOper.QueryTdDataToCtrl(m_listTaskData, dwTdID, m_iSelTaskType, m_iTestType);
}

//数据下载
void CDialTaskManager::OnBtnDataDownload()
{
	CTreeCtrl* pTreeCtrl = m_iTaskTree->GetTaskTreePtr();
	HTREEITEM hItem = pTreeCtrl->GetSelectedItem();
	if (NULL == hItem)
	{
		if (LANG_ZHCN == g_iUILanguage)
			AfxMessageBox(_T("请先选择任务"));
		else
			MessageBoxEx(NULL, _T("Please select the task first"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		return;
	}

	//遍历所有节点，判断是否勾选
	HTREEITEM rootItem = pTreeCtrl->GetRootItem();
	std::vector<STTaskListItem>		vtDownloadTaskItem;
	if (pTreeCtrl->ItemHasChildren(rootItem))
	{
		HTREEITEM childItem = pTreeCtrl->GetChildItem(rootItem);
		STTaskListItem* pTaskItem;
		std::vector<HTREEITEM> vtDelTreeItem;
		while (childItem != NULL)
		{
			if (pTreeCtrl->GetCheck(childItem))
			{
				pTaskItem = (STTaskListItem*)pTreeCtrl->GetItemData(childItem);
				if (NULL == pTaskItem)
				{
					if (LANG_ZHCN == g_iUILanguage)
						AfxMessageBox(_T("获取任务数据ID错误"));
					else
						MessageBoxEx(NULL, _T("Can not find the test task.please select the task firstly"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
					return;
				}
				vtDelTreeItem.push_back(childItem);
				vtDownloadTaskItem.push_back(*pTaskItem);
			}
			childItem = pTreeCtrl->GetNextSiblingItem(childItem);
		}

		if (vtDownloadTaskItem.size() == 0)
		{
			if (LANG_ZHCN == g_iUILanguage)
				AfxMessageBox(_T("请先勾选数据"));
			else
				MessageBoxEx(NULL, _T("Please choose one task first"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
			return;
		}

		//下载数据
		CDownloadDataProgressDlg	downloadProcessDlg(&vtDownloadTaskItem,&m_taskOper,this);
		downloadProcessDlg.SetDeviceID(m_dwDeviceSN);
		downloadProcessDlg.DoModal();
		//刷新列表
		OnMsgTaskRefreshList(0, 0);
	}

}

//新建定时任务
void CDialTaskManager::OnBtnCreateTimerTask()
{
	//SetPauseThread(true);
	CTreeCtrl* pTreeCtrl = m_iTaskTree->GetTaskTreePtr();
	HTREEITEM hItem = pTreeCtrl->GetSelectedItem();
	if (NULL == hItem)
	{
		if (LANG_ZHCN == g_iUILanguage)
			AfxMessageBox(_T("请先勾选已上传的任务"));
		else
			MessageBoxEx(NULL, _T("Please choose one task first"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
			
		return;
	}
	
	DialUploadLoopTask* pUploadLoopTaskDlg = new DialUploadLoopTask();
	if (pUploadLoopTaskDlg == NULL)
	{
		return;
	}
	
	//遍历所有节点，判断是否勾选
	HTREEITEM rootItem = pTreeCtrl->GetRootItem();
	if (pTreeCtrl->ItemHasChildren(rootItem))
	{
		HTREEITEM childItem = pTreeCtrl->GetChildItem(rootItem);
		CString strTips;
		STTaskListItem* pTaskItem = NULL;
		while (childItem != NULL)
		{
			if (pTreeCtrl->GetCheck(childItem))
			{
				pTaskItem = (STTaskListItem*)pTreeCtrl->GetItemData(childItem);
				if (pTaskItem && EN_TASK_NO_UPLOAD == pTaskItem->eSynStatus)
				{
					if (LANG_ZHCN == g_iUILanguage)
					{
						strTips.Format(_T("任务：%s未上传，创建定时任务失败"), pTaskItem->szTDName);
						AfxMessageBox(strTips);
					}
					else
					{
						strTips.Format(_T("Task：%s no upload，create timer task failed"), pTaskItem->szTDName);
						MessageBoxEx(NULL, strTips, STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
					}
					return;
				}
				pUploadLoopTaskDlg->m_TaskList.AddTail(*pTaskItem);
			}
			childItem = pTreeCtrl->GetNextSiblingItem(childItem);
		}
	}
	
	int iTaskCount = pUploadLoopTaskDlg->m_TaskList.GetCount();
	if (0 == iTaskCount)
	{
		if (LANG_ZHCN == g_iUILanguage)
		{
			AfxMessageBox(_T("请先勾选已上传的任务"));
		}
		else
		{
			MessageBoxEx(NULL, _T("Please choose one task first"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		}
		
		delete pUploadLoopTaskDlg;
		return;
	}
	else if (iTaskCount > 20)
	{
		CString strTips;
		if (LANG_ZHCN == g_iUILanguage)
		{
			strTips.Format(_T("定时任务最多不超过20个"));
			AfxMessageBox(strTips);
		}
		else
		{
			strTips.Format(_T("No more than 20 scheduled tasks"));
			MessageBoxEx(NULL, strTips, STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		}
		
		delete pUploadLoopTaskDlg;
		return;
	}

	pUploadLoopTaskDlg->SetDeviceID(m_dwDeviceSN);
	pUploadLoopTaskDlg->SetPLCID(m_dwPLCID);
	pUploadLoopTaskDlg->DoModal();
	if (pUploadLoopTaskDlg != NULL)
	{
		delete[] pUploadLoopTaskDlg;
		pUploadLoopTaskDlg = NULL;
	}
}

//管理定时任务
void CDialTaskManager::OnBtnManageTimerTask()
{
	//SetPauseThread(true);
	CDialManageLoopTask manageTimerTask;
	manageTimerTask.SetDeviceID(m_dwDeviceSN);
	manageTimerTask.SetPLCID(m_dwPLCID);
	manageTimerTask.DoModal();
}

void CDialTaskManager::PreNetResponse(WPARAM wParam, LPARAM lParam)
{
	LPRESPONSEPACKET pResponsePacket = (LPRESPONSEPACKET)lParam;
	if (pResponsePacket == NULL)
	{
		return;
	}

	switch (pResponsePacket->clsPacketBase.ucCmd)
	{
	case EN_REQ_TASK_DEL://删除任务响应
	{
		//删除本地及树型控件列表数据,如果客户端不想保存数据的话，需要服务器返回删除的ID
		OnDeleteTaskResponse(wParam, lParam);
	}
	break;
	case EN_REQ_DOWNLOAD_TASK_ARG://任务参数信息响应
	{
		OnSynCouldTaskInfoResponse(wParam, lParam);
	}
	break;
	case EN_CANCEL_COLLOCATION:
	{
		if ((pResponsePacket->wDataLen < 0) || (EN_RECV_SUCCESS != pResponsePacket->pData[0]))
		{
			if (LANG_ZHCN == g_iUILanguage)
				AfxMessageBox(_T("任务取消测试失败"));
			else
				MessageBoxEx(NULL, _T("Task cancel trustee to failed."), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
			return;
		}
		//取消测试正在运行中的任务后,更新值
		if (m_bCancelTestingTask)
		{
			g_strSaveTestingTaskID.Empty();
		}	
		//刷新列表
		if (m_bLastCancelTask)
		{
			OnMsgTaskRefreshList(0, 0);
		}
		CString strLog;
		strLog.Format(_T("zm://////////CDialTaskManager::PreNetResponse cancel trust task g_strSaveTestingTaskID=%s"), g_strSaveTestingTaskID);
		CFileOperTools::GetInstance()->WriteComLog(strLog);
	}
	break;
	/*case EN_REQ_HEART_BEAT_PACKET:
	{
		CString strLog, strTime;
		CTime t = CTime::GetCurrentTime();
		strTime = t.Format("%Y-%m-%d,%H:%M:%S:");
		strLog.Format(_T("zm:time:%s Geomative recv heart beat from Sever"), strTime);
		OutputDebugString(strLog);
	}*/
	break;
	default:
		break;
	}
}

BOOL CDialTaskManager::OnSynCouldTaskInfoRequest(std::vector<STTaskListItem> vtSynTaskID)
{	
	int iTaskNum = vtSynTaskID.size();
	if (iTaskNum <= 0)
	{
		return FALSE;
	}

	int iSendLen = sizeof(UINT32) + iTaskNum*sizeof(BYTE)*MAX_NAME_LEN;
	char chSendStr[210] = { 0 };
	chSendStr[3] = iTaskNum;
	int iLenIndex = sizeof(UINT32);
	STTaskListItem taskItem;
	for (int i = 0; i < iTaskNum; i++)
	{
		taskItem = vtSynTaskID.at(i);
		strncpy(&chSendStr[iLenIndex + i*MAX_NAME_LEN], taskItem.szTaskID, MAX_NAME_LEN*sizeof(BYTE));
	}
	CString strLog;
	strLog.Format(_T("zm:click treectrl item(taskid=%s) request download task arg"), taskItem.szTaskID);
	OutputDebugString(strLog);
	CFileOperTools::GetInstance()->WriteComLog(strLog);
	PostNetRequest(EN_REQ_DOWNLOAD_TASK_ARG, this->m_hWnd, chSendStr, iSendLen, 6000);
	return TRUE;
}

BOOL CDialTaskManager::OnSynCouldTaskInfoResponse(WPARAM wParam, LPARAM lParam)
{
	CString strLog;
	strLog.Format(_T("zm:click treectrl item response download task arg"));
	OutputDebugString(strLog);
	CFileOperTools::GetInstance()->WriteComLog(strLog);

	if (wParam != 0)
	{
		CString strLog;
		strLog.Format(_T("zm:任务信息同步报错(%d)"), wParam);
		CFileOperTools::GetInstance()->WriteComLog(strLog);
		return FALSE;
	}
	LPRESPONSEPACKET pResponsePacket = (LPRESPONSEPACKET)lParam;
	if (NULL == pResponsePacket || pResponsePacket->clsPacketBase.ucCmd != EN_REQ_DOWNLOAD_TASK_ARG)
	{
		return FALSE;
	}
	//std::vector<STRemTaskArg>		vtSaveSynTaskArg;
	char chMsgSyn[MAX_RECV_MEASURE] = { 0 };
	memcpy(chMsgSyn, pResponsePacket->pData, pResponsePacket->wDataLen);
	UINT32* uiRevData = (UINT32*)(chMsgSyn);
	UINT32 uiRevDataNum = ntohl(uiRevData[0]);
	if ((uiRevDataNum < 1) || (pResponsePacket->wDataLen < (sizeof(UINT32) + uiRevDataNum * sizeof(STRemTaskArg))))
	{
		CString strLog;
		strLog.Format(_T("[%s][%d]zm:wDataLen=%d,real recv len= %d"), MODULE_NAME, __LINE__, pResponsePacket->wDataLen, sizeof(UINT32) + uiRevDataNum * sizeof(STRemTaskArg));
		CFileOperTools::GetInstance()->WriteComLog(strLog);
		theApp.m_NetWorkOper.SetSuspendForThread(false);
		return 0;
	}
	time_t ttNormalTime = Str2GmtTm(_T("2018-01-01 00:00:00"));
	CString strCreateTime;
	CString strDownloadTime;
	CString strEndTestTime;
	UINT32 tmTime = 0;
	CString str;
	CString strSql = _T("");
	_RecordsetPtr pRecCm = NULL;
	_RecordsetPtr pRecTd = NULL;
	char chSptType[][10] = { "VES", "2D", "3D" };
	STRemTaskArg *ptTaskArg = (STRemTaskArg *)(chMsgSyn + sizeof(UINT32));
	for (int iIndex = 0; iIndex < uiRevDataNum; iIndex++)
	{
		ptTaskArg = (STRemTaskArg *)(chMsgSyn + sizeof(UINT32) + iIndex*sizeof(STRemTaskArg));
		ptTaskArg->stMeasuArg.iSAInterval = ntohl(ptTaskArg->stMeasuArg.iSAInterval);
		//ptTaskArg->stMeasuArg.fElecSpace = tcp_ntohf(ptTaskArg->stMeasuArg.fElecSpace);
		ptTaskArg->stMeasuArg.fXElecDistance = tcp_ntohf(ptTaskArg->stMeasuArg.fXElecDistance);
		ptTaskArg->stMeasuArg.fYElecDistance = tcp_ntohf(ptTaskArg->stMeasuArg.fYElecDistance);
		ptTaskArg->stMeasuArg.fXElecStep = tcp_ntohf(ptTaskArg->stMeasuArg.fXElecStep);
		ptTaskArg->stMeasuArg.fYElecStep = tcp_ntohf(ptTaskArg->stMeasuArg.fYElecStep);
		ptTaskArg->stMeasuArg.rcGridSize.left = ntohl(ptTaskArg->stMeasuArg.rcGridSize.left);
		ptTaskArg->stMeasuArg.rcGridSize.top = ntohl(ptTaskArg->stMeasuArg.rcGridSize.top);
		ptTaskArg->stMeasuArg.rcGridSize.right = ntohl(ptTaskArg->stMeasuArg.rcGridSize.right);
		ptTaskArg->stMeasuArg.rcGridSize.bottom = ntohl(ptTaskArg->stMeasuArg.rcGridSize.bottom);
		ptTaskArg->stMeasuArg.byLineDirection = ptTaskArg->stMeasuArg.byLineDirection;
		ptTaskArg->uiStartElec = ntohl(ptTaskArg->uiStartElec);
		ptTaskArg->uiEndElec = ntohl(ptTaskArg->uiEndElec);
		ptTaskArg->uiStartLayer = ntohl(ptTaskArg->uiStartLayer);
		ptTaskArg->uiEndLayer = ntohl(ptTaskArg->uiEndLayer);
		ptTaskArg->uiStartTime = ntohl(ptTaskArg->uiStartTime);
		ptTaskArg->uiEndTime = ntohl(ptTaskArg->uiEndTime);
		ptTaskArg->uiTimerTime = ntohl(ptTaskArg->uiTimerTime);
		ptTaskArg->uiTotalNum = ntohl(ptTaskArg->uiTotalNum);
		ptTaskArg->uiCurrentPoint = ntohl(ptTaskArg->uiCurrentPoint);
		ptTaskArg->uiFailedReason = ntohl(ptTaskArg->uiFailedReason);
		//ptTaskArg->ucTestGRFlag = ntohl(ptTaskArg->ucTestGRFlag);
		//pThis->m_vtSaveSynTaskArg.push_back(*ptTaskArg);

		//更新到界面任务属性
		m_listTaskAttr.SetItemText(0, 2, (LPCTSTR)(_bstr_t)U2G(ptTaskArg->ucTDName));
		m_listTaskAttr.SetItemText(1, 2, (LPCTSTR)(_bstr_t)ptTaskArg->ucTaskID);
		m_listTaskAttr.SetItemText(2, 2, (LPCTSTR)(_bstr_t)U2G(ptTaskArg->ucSciptName));
		m_listTaskAttr.SetItemText(3, 2, (LPCTSTR)(_bstr_t)chSptType[ptTaskArg->stMeasuArg.ucSptType]);
		str.Empty(); str.Format(_T("%d"), ptTaskArg->uiEndElec - ptTaskArg->uiStartElec + 1);
		m_listTaskAttr.SetItemText(6, 2, (LPCTSTR)(_bstr_t)str);
		str.Empty(); str.Format(_T("%d"), ptTaskArg->uiTotalNum);
		m_listTaskAttr.SetItemText(7, 2, (LPCTSTR)(_bstr_t)str);
		m_listTaskAttr.SetItemText(8, 2, (LPCTSTR)(_bstr_t)ptTaskArg->stMeasuArg.ucStacking);

		str.Empty();
		m_iTestType = ptTaskArg->stMeasuArg.ucTestType;
		if (0 == m_iTestType)
			str = _T("0+0-");
		else if (1 == m_iTestType)
			str = _T("+0-0");
		else
			str = _T("0");
		m_listTaskAttr.SetItemText(9, 2, str);
		//只有激电才有发射周期
		str.Empty();
		//0：电阻率，1：激电
		if (1 == ptTaskArg->stMeasuArg.ucTestType || 0 == ptTaskArg->stMeasuArg.ucTestType)
			str.Format(_T("%.1f"), GetSigTxPeriod(ptTaskArg->stMeasuArg.ucTestType, ptTaskArg->stMeasuArg.ucTxPeriod) / 1000.0);
		m_listTaskAttr.SetItemText(10, 2, str);
		//三维
		if (2 == ptTaskArg->stMeasuArg.ucSptType)
			str.Format(_T("%.2f,%.2f"), ptTaskArg->stMeasuArg.fXElecDistance, ptTaskArg->stMeasuArg.fYElecDistance);
		else
			str.Format(_T("%.2f"), ptTaskArg->stMeasuArg.fXElecDistance);

		//屏蔽跨孔电极间距属性参数
		if (AR_CROSS_HOLE_GEOMATIVE == ptTaskArg->stMeasuArg.ucArrayType
			|| AR_CROSS_HOLE_GEOMATIVE_AM == ptTaskArg->stMeasuArg.ucArrayType)
		{
			m_listTaskAttr.SetItemText(12, 2, _T(""));
		}
		else
		{
			m_listTaskAttr.SetItemText(12, 2, str);
		}
		
		//listAttr.SetItemText(5, 2, (LPCTSTR)(_bstr_t)ptTaskArg->stMeasuArg.ucArrayType);
		//listAttr.SetItemText(4, 2, (LPCTSTR)(_bstr_t)ptTaskArg->stMeasuArg.ucCableLayout(LPCTSTR)(_bstr_t)pRecCm->GetCollect(_T("Clabel")));
		//listAttr.SetItemText(11, 2, (LPCTSTR)(_bstr_t)pRecCm->GetCollect(_T("Clabel")));

		pRecCm.CreateInstance(_uuidof(Recordset));
		strSql.Empty();
		strSql.Format(_T("select MEname from medium where AR = %d and LANG = %d"), ptTaskArg->stMeasuArg.ucArrayType, g_iUILanguage);
		pRecCm->Open(strSql.AllocSysString(), _variant_t((IDispatch*)theApp.m_pConnection, true), adOpenStatic, adLockOptimistic, adCmdText);
		if (pRecCm->GetRecordCount() > 0)
		{
			m_listTaskAttr.SetItemText(5, 2, (LPCTSTR)(_bstr_t)pRecCm->GetCollect(_T("MEname")));
		}
		pRecCm->Close();

		strSql.Empty();
		strSql.Format(_T("select Clabel from cm where Cname = 'Ttype' and Cvalue = %d and LANG = %d"), m_iTestType, g_iUILanguage);
		pRecCm->Open(strSql.AllocSysString(), _variant_t((IDispatch*)theApp.m_pConnection, true), adOpenStatic, adLockOptimistic, adCmdText);
		if (pRecCm->GetRecordCount() > 0)
		{
			m_listTaskAttr.SetItemText(4, 2, (LPCTSTR)(_bstr_t)pRecCm->GetCollect(_T("Clabel")));
		}
		pRecCm->Close();

		if (ptTaskArg->stMeasuArg.ucCableLayout >= 0)
		{
			strSql.Empty();
			strSql.Format(_T("select Clabel from cm where Cname = 'Clayout' and Cvalue = %d and LANG = %d"), ptTaskArg->stMeasuArg.ucCableLayout, g_iUILanguage);
			pRecCm->Open(strSql.AllocSysString(), _variant_t((IDispatch*)theApp.m_pConnection, true), adOpenStatic, adLockOptimistic, adCmdText);
			if (pRecCm->GetRecordCount() > 0)
			{
				m_listTaskAttr.SetItemText(11, 2, (LPCTSTR)(_bstr_t)pRecCm->GetCollect(_T("Clabel")));
			}
			pRecCm->Close();
		}

		//填状态信息
		pRecTd.CreateInstance(_uuidof(Recordset));
		CString strTaskId = ptTaskArg->ucTaskID;
		strTaskId.TrimLeft(); strTaskId.TrimRight();
		strSql.Empty();
		strSql.Format(_T("select DownloadTime,CreateTime from td where TDCN = '%s'"), ptTaskArg->ucTaskID);
		pRecTd->Open(strSql.AllocSysString(), _variant_t((IDispatch*)theApp.m_pConnection, true), adOpenStatic, adLockOptimistic, adCmdText);

		strDownloadTime.Empty();
		strEndTestTime.Empty();
		strCreateTime.Empty();
		if (pRecTd->GetRecordCount() > 0)
		{
			tmTime = (VT_NULL == pRecTd->GetCollect(_T("DownloadTime")).vt) ? 0 : pRecTd->GetCollect(_T("DownloadTime")).uintVal;
			str.Format(_T("zm:task args :download time = %u\n"), tmTime);
			CFileOperTools::GetInstance()->WriteComLog(str);
			if (tmTime > ttNormalTime)
			{
				strDownloadTime = Tm2LocalStr(tmTime);
			}

			tmTime = (VT_NULL == pRecTd->GetCollect(_T("CreateTime")).vt) ? 0 : pRecTd->GetCollect(_T("CreateTime")).uintVal;
			if (tmTime > ttNormalTime)
			{				
				strCreateTime = Tm2LocalStr(tmTime);
			}
		}
		pRecTd->Close();
		
		if (ptTaskArg->uiEndTime > ttNormalTime)
		{
			strEndTestTime = Tm2LocalStr(ptTaskArg->uiEndTime);
		}

		if (strDownloadTime.IsEmpty())
		{
			if (g_iUILanguage == LANG_ZHCN)
			{
				m_listTaskAttr.SetItemText(13, 2, _T("未下载"));
			}
			else
			{
				m_listTaskAttr.SetItemText(13, 2, _T("not download"));
			}
		}
		else
		{
			if (g_iUILanguage == LANG_ZHCN)
			{
				m_listTaskAttr.SetItemText(13, 2, _T("已下载"));
			}
			else
			{
				m_listTaskAttr.SetItemText(13, 2, _T("downloaded"));
			}
		}
		m_listTaskAttr.SetItemText(14, 2, strDownloadTime);		
		
		m_listTaskAttr.SetItemText(15, 2, strEndTestTime);	

		if (!strCreateTime.IsEmpty())
		{
			m_listTaskAttr.SetItemText(16, 2, strCreateTime);
		}
		else
		{
			strCreateTime = Tm2LocalStr(ntohl(ptTaskArg->uiCreateTime));
			m_listTaskAttr.SetItemText(16, 2, strCreateTime);
		}

		if (0 == ptTaskArg->ucTestGRFlag)
		{
			if (g_iUILanguage == LANG_ZHCN)
				m_listTaskAttr.SetItemText(17, 2, _T("否"));
			else
				m_listTaskAttr.SetItemText(17, 2, _T("no"));
		}
		else if (1 == ptTaskArg->ucTestGRFlag)
		{
			if (g_iUILanguage == LANG_ZHCN)
				m_listTaskAttr.SetItemText(17, 2, _T("是"));
			else
				m_listTaskAttr.SetItemText(17, 2, _T("yes"));
		}
		
		CString strReason = GetTestFailedReason(ptTaskArg->uiFailedReason);
		m_listTaskAttr.SetItemText(18, 2, strReason);
	}

	//取最后一个Item,当前实时窗口显示的任务
	memcpy(&m_dialRealTimeMeasuData.m_stTaskArg, ptTaskArg, sizeof(STRemTaskArg));
	UpdateRealTimeTaskListData(ptTaskArg, (STTaskListItem*)&m_vtNeedSynTaskID.at(0));

	return TRUE;
}

BOOL CDialTaskManager::OnDeleteTaskResponse(WPARAM wParam, LPARAM lParam)
{
	LPRESPONSEPACKET pResponsePacket = (LPRESPONSEPACKET)lParam;
	if (pResponsePacket == NULL)
	{
		return FALSE;
	}
	
	//删除本地及树型控件列表数据
	if (EN_RECV_SUCCESS == wParam)
	{
		if (m_taskOper.DeleteTaskArray(m_CurDelTaskID))
		{
			//m_listTaskData.DeleteAllItems();
			int iItemCnt = m_listTaskAttr.GetItemCount();
			for (int i = 0; i < iItemCnt; i++)
			{
				m_listTaskAttr.SetItemText(i, 2, _T(""));
			}

			//for (int i = 0; i < m_vtNeedDelTreeItem.size(); i++)
			//	m_dialTaskTree.m_treeTask.DeleteItem(m_vtNeedDelTreeItem.at(i));
			m_iTaskTree->GetTaskTreePtr()->DeleteItem(m_CurDelTreeItem);
			if (LANG_ZHCN == g_iUILanguage)
				AfxMessageBox(_T("删除任务成功"));
			else
				MessageBoxEx(NULL, _T("Succeed to delete test task"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));

			//m_vtNeedDelTaskID.clear();
			//m_vtNeedDelTreeItem.clear();
		}
	}	
	else
	{
		if (LANG_ZHCN == g_iUILanguage)
			AfxMessageBox(_T("删除任务失败"));
		else
			MessageBoxEx(NULL, _T("Failed to delete test task"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
	}
	return TRUE;
}

LRESULT CDialTaskManager::OnRecvRealTimeDataResponse(WPARAM wParam, LPARAM lParam)
{
	CString strLog;
	CFileOperTools::GetInstance()->WriteComLog("zm:CDialTaskManager::OnRecvRealTimeDataResponse() recv real time data begin----------------");
	char *chStr = (char*)wParam;
	if (chStr == NULL)
	{
		return 0;
	}

	//获取任务名
	char szTaskID[MAX_NAME_LEN] = {0};
	memcpy(szTaskID, chStr, MAX_NAME_LEN);
	// 	if ((0 >= ntohl(pMeasuDataRes->iID) || 100000 < ntohl(pMeasuDataRes->iID))
	// 		|| 0 != strcmp(szTaskID, m_stRealTimeTaskArg.ucTaskID))//点数ID和任务ID判断
	if (0 != strcmp(szTaskID, m_stRealTimeTaskArg.ucTaskID))
	{
		strLog.Format(_T("zm:recv real time data[0 != strcmp(szTaskID=%s, m_stRealTimeTaskArg.ucTaskID=%s])"), szTaskID, m_stRealTimeTaskArg.ucTaskID);
		CFileOperTools::GetInstance()->WriteComLog(strLog);
		return 0;
	}
	strLog.Format(_T("zm:recv real time data  [uiTotalNum=%d]"), m_stRealTimeTaskArg.uiTotalNum);
	CFileOperTools::GetInstance()->WriteComLog(strLog);

	//获取总点数
	BYTE ucPointNum = chStr[MAX_NAME_LEN];
	if (ucPointNum <= 0)
	{
		CFileOperTools::GetInstance()->WriteComLog(_T("zm:recv real time data ucPointNum <= 0"));
		return 0;
	}

	//char *pData = (char *)malloc(sizeof(char) * 4096);
	std::vector<STTaskDetailBasicData> vtData;	
	int iLen = lParam;	
	UINT32 uiStartID = 0;
	//int iMaxSynNum = 50;	
	
	int iPackLen = (ucPointNum*sizeof(STMeasuDataResBasicEx)) + MAX_NAME_LEN + sizeof(char);
	if (0 >= iLen /*|| iLen != iPackLen*/ || 0 >= ucPointNum) //长度和转发点数判断
	{
		CFileOperTools::GetInstance()->WriteComLog("zm:recv real time data [0 >= iLen || iLen != iPackLen || 0 >= ucPointNum]");
		return 0;
	}

	//接收到数据后，清空状态
	GetDlgItem(IDC_STATIC_TASK_DATA)->SetWindowTextA(m_strTaskStatusTips);
	//char *pData = new char[4096];
	STMeasuDataResBasicEx *pMeasuDataRes = (STMeasuDataResBasicEx *)&chStr[sizeof(char)*MAX_NAME_LEN + sizeof(char)];

	//if (0 == uiStartID || ntohl(pMeasuDataRes->iID) > uiStartID + iMaxSynNum) //从云端获取ABMN信息，便于动态显示，每50点获取一次
	/*{
		int i;
		for (i = 0; i < 3; i++)//失败获取三次
		{
			//if (true == m_taskOper.QueryOnLineTdDataFromSev(m_stRealTimeTaskArg, pMeasuDataRes->iID, pMeasuDataRes->iID + iMaxSynNum, pData))
			if (true == m_taskOper.QueryOnLineTdDataFromSev(m_stRealTimeTaskArg, pMeasuDataRes->iID, pMeasuDataRes->iID + ucPointNum, pData))
			{
				uiStartID = ntohl(pMeasuDataRes->iID);
				break;
			}
			Sleep(10);
		}
		if (3 == i) //未获取数据信息
		{
			OutputDebugString("zm:enter CDialTaskManager::OnRecvRealTimeDataResponse 3 == i");
			if (pData != NULL)
			{
				delete[] pData;
				pData = NULL;
			}			
			return 0;
		}
	}*/
	STTaskDataRes stMeasuBasicData;
	int iSevDataIndex = 0;
	STMeasuDataResBasicEx pMeasuData;
	STTaskDetailBasicData stTaskDetailData;
	for (int i = 0; i < ucPointNum; i++)
	{
		//iSevDataIndex = pMeasuDataRes->iID - uiStartID + i;
//		STTaskDataRes *ptTaskData = (STTaskDataRes *)&pData[MAX_NAME_LEN * sizeof(BYTE) + sizeof(UINT32) + i*sizeof(STTaskDataRes)];
		memcpy(&pMeasuData, &pMeasuDataRes[i], sizeof(STMeasuDataResBasicEx));
		memset(&stMeasuBasicData, 0, sizeof(STTaskDataRes));
		stMeasuBasicData.dwID = ntohl(pMeasuData.iID);
		stMeasuBasicData.fA = tcp_ntohf(pMeasuData.fA);
		stMeasuBasicData.fB = tcp_ntohf(pMeasuData.fB);
		stMeasuBasicData.fM = tcp_ntohf(pMeasuData.fM);
		stMeasuBasicData.fN = tcp_ntohf(pMeasuData.fN);
		stMeasuBasicData.fV = tcp_ntohf(pMeasuData.fV);
		stMeasuBasicData.fI = tcp_ntohf(pMeasuData.fI);
		stMeasuBasicData.fR0 = tcp_ntohf(pMeasuData.fR0);
		stMeasuBasicData.fSP = tcp_ntohf(pMeasuData.fSP);
		stMeasuBasicData.fK = tcp_ntohf(pMeasuData.fK);
		stMeasuBasicData.ucAlram = pMeasuData.ucAlram;
		stMeasuBasicData.ucStack = pMeasuData.ucStack;
		stMeasuBasicData.fR0_LC = tcp_ntohf(pMeasuData.fR0_LC);

		memset(&stTaskDetailData, 0, sizeof(STTaskDetailBasicData));
		stTaskDetailData.iID = stMeasuBasicData.dwID;
		stTaskDetailData.iA = stMeasuBasicData.fA;
		stTaskDetailData.iB = stMeasuBasicData.fB;
		stTaskDetailData.iM = stMeasuBasicData.fM;
		stTaskDetailData.iN = stMeasuBasicData.fN;
		stTaskDetailData.fK = stMeasuBasicData.fK;
		stTaskDetailData.fV = stMeasuBasicData.fV;
		stTaskDetailData.fI = stMeasuBasicData.fI;
		stTaskDetailData.fR0 = stMeasuBasicData.fR0;
		stTaskDetailData.fSP = stMeasuBasicData.fSP;
		stTaskDetailData.ucStack = stMeasuBasicData.ucStack;
		stTaskDetailData.ucIsUse = 1;// stMeasuBasicData.ucAlram;
		strLog.Format(_T("zm:reve point num=%d, %d: id=%d,A=%.f,B=%.f,M=%.f,N=%.f,k=%.2f,v=%.2f,i=%.2f,R0=%.2f,SP=%.2f"), ucPointNum, i, stTaskDetailData.iID, stTaskDetailData.iA, stTaskDetailData.iB, stTaskDetailData.iM, stTaskDetailData.iN, stTaskDetailData.fK, stTaskDetailData.fV, stTaskDetailData.fI, stTaskDetailData.fR0, stTaskDetailData.fSP);
		CFileOperTools::GetInstance()->WriteComLog(strLog);
		vtData.push_back(stTaskDetailData);
	}
	SendMessage(WM_TASK_LIST_TASK_DATA_SYN, (WPARAM)&vtData, 1);
	
 	/*if (pData != NULL)
 	{
 		delete[] pData;
 		pData = NULL;
 	}	*/
	CFileOperTools::GetInstance()->WriteComLog("zm:CDialTaskManager::OnRecvRealTimeDataResponse() recv real time data end----------------------");
	return 0;
}