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

#include "stdafx.h"
#include "GeoMative.h"
#include "OnLineSynTdDlg.h"
#include "afxdialogex.h"
#include "DialLoopTaskCancel.h"
#include "DialUploadLoopTask.h"
#include "DialLoopTaskQuery.h"

extern int g_UIOffset;
extern int g_iUILanguage;
extern CString g_szMacAddress;
extern CGeoMativeApp theApp;
extern float tcp_htonf(float f);
extern float tcp_ntohf(float f);
extern CString OnLineTask(BYTE ucTaskStats);
extern CString Tm2GmtStr(time_t t);
extern CString Tm2LocalStr(time_t t);
extern time_t Str2LocalTm(CString szTime);
extern time_t Str2GmtTm(CString szTime);
BEGIN_EASYSIZE_MAP(OnLineSynTdDlg)
	//list 框 EASYSIZE(control,left,top,right,bottom,options)ES_KEEPSIZE
	EASYSIZE(IDC_LIST_SYN_SEV_OL, ES_BORDER, ES_BORDER, ES_KEEPSIZE, ES_BORDER, 0)
	EASYSIZE(IDC_LIST_SYN_LA_OL, ES_BORDER, ES_BORDER, ES_KEEPSIZE, ES_BORDER, 0)
	
	//EASYSIZE(IDC_STATIC_TD_SV_OL, ES_KEEPSIZE, ES_BORDER, ES_BORDER, ES_KEEPSIZE, 0)
	//EASYSIZE(IDC_STATIC_SYN_SEV_TOTAL, IDC_STATIC_TD_SV_OL, ES_BORDER, ES_KEEPSIZE, ES_KEEPSIZE, 0)

	//EASYSIZE(IDC_STATIC_TD_LO_OL, ES_KEEPSIZE, ES_BORDER, ES_BORDER, ES_KEEPSIZE, 0)
	//EASYSIZE(IDC_STATIC_SYN_LA_TOTAL, ES_KEEPSIZE, ES_BORDER, ES_BORDER, ES_KEEPSIZE, 0)
	//同步按键
	/*EASYSIZE(IDC_SYN_OL_DOWN, ES_BORDER, IDC_STATIC_TD_SV_OL, ES_BORDER, ES_BORDER, 0)
	EASYSIZE(IDC_SYN_OL_UPLOAD, ES_BORDER, ES_BORDER, ES_BORDER, ES_BORDER, ES_HCENTER )
	EASYSIZE(IDC_SYN_OL_TASK, ES_BORDER, ES_BORDER, ES_BORDER, ES_BORDER, ES_HCENTER )
	EASYSIZE(IDC_SYN_OL_DATE, ES_BORDER, ES_BORDER, ES_BORDER, ES_BORDER, ES_HCENTER )
	EASYSIZE(IDC_SYN_OL_ARG, ES_BORDER, ES_BORDER, ES_BORDER, ES_BORDER, ES_HCENTER)
	EASYSIZE(IDC_SYN_OL_TRUSTEE, ES_BORDER, ES_BORDER, ES_BORDER, ES_BORDER, ES_HCENTER )
	EASYSIZE(IDC_BUTTON_DEL, ES_BORDER, ES_BORDER, ES_BORDER, ES_BORDER, ES_HCENTER )*/
	/*EASYSIZE(IDC_SYN_OL_UPLOAD, ES_KEEPSIZE, ES_KEEPSIZE, ES_KEEPSIZE, ES_KEEPSIZE, ES_HCENTER)
	EASYSIZE(IDC_SYN_OL_TASK, ES_KEEPSIZE, ES_KEEPSIZE, ES_KEEPSIZE, ES_KEEPSIZE, ES_HCENTER)
	EASYSIZE(IDC_SYN_OL_DATE, ES_KEEPSIZE, ES_KEEPSIZE, ES_KEEPSIZE, ES_KEEPSIZE, ES_HCENTER)
	EASYSIZE(IDC_SYN_OL_ARG, ES_KEEPSIZE, ES_KEEPSIZE, ES_KEEPSIZE, ES_KEEPSIZE, ES_HCENTER)
	EASYSIZE(IDC_SYN_OL_TRUSTEE, ES_KEEPSIZE, ES_KEEPSIZE, ES_KEEPSIZE, ES_KEEPSIZE, ES_HCENTER)
	EASYSIZE(IDC_BUTTON_DEL, ES_KEEPSIZE, ES_KEEPSIZE, ES_KEEPSIZE, ES_KEEPSIZE, ES_HCENTER)*/
END_EASYSIZE_MAP

// OnLineSynTdDlg 对话框

IMPLEMENT_DYNAMIC(OnLineSynTdDlg, CDialog)

OnLineSynTdDlg::OnLineSynTdDlg(CWnd* pParent /*=NULL*/)
	: CDialog(OnLineSynTdDlg::IDD, pParent)
{
	m_ptTaskTableInfo = NULL;
}

OnLineSynTdDlg::~OnLineSynTdDlg()
{
	if (NULL != m_ptTaskTableInfo) { free(m_ptTaskTableInfo); };
}

void OnLineSynTdDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_LIST_SYN_SEV_OL, m_SevTdList);
	DDX_Control(pDX, IDC_LIST_SYN_LA_OL, m_LocalTdList);
	DDX_Control(pDX, IDC_STATIC_SYN_SEV_TOTAL, m_SevTotalNum);
	DDX_Control(pDX, IDC_STATIC_SYN_LA_TOTAL, m_LocalTotalNum);
}


BEGIN_MESSAGE_MAP(OnLineSynTdDlg, CDialog)
	ON_WM_SIZE()
	ON_WM_SIZING()
	ON_BN_CLICKED(IDC_SYN_OL_UPLOAD, &OnLineSynTdDlg::OnBnClickedSynOlUpload)
	ON_BN_CLICKED(IDC_SYN_OL_DOWN, &OnLineSynTdDlg::OnBnClickedSynOlDown)
	ON_BN_CLICKED(IDC_SYN_OL_TASK, &OnLineSynTdDlg::OnBnClickedSynOlTask)
	ON_BN_CLICKED(IDC_SYN_OL_ARG, &OnLineSynTdDlg::OnBnClickedSynOlArg)
	ON_BN_CLICKED(IDC_SYN_OL_DATE, &OnLineSynTdDlg::OnBnClickedSynOlDate)
	ON_BN_CLICKED(IDC_SYN_OL_TRUSTEE, &OnLineSynTdDlg::OnBnClickedSynOlTrustee)
	ON_BN_CLICKED(IDC_SYN_OL_DEL, &OnLineSynTdDlg::OnBnClickedButtonDel)
	ON_BN_CLICKED(IDC_SYN_OL_NO_TRUST, &OnLineSynTdDlg::OnBnClickedSynOlNoTrust)
END_MESSAGE_MAP()


// OnLineSynTdDlg 消息处理程序


void OnLineSynTdDlg::OnSize(UINT nType, int cx, int cy)
{
	CDialog::OnSize(nType, cx, cy);
	UPDATE_EASYSIZE;
	// TODO:  在此处添加消息处理程序代码

	//CRect rect;
	//GetClientRect(&rect);
	//int iWidth = rect.Width()*0.42;
	//int iHeight = rect.Height()-40;
	//CPoint cpoint = rect.CenterPoint();
	//m_LocalTdList.SetWindowPos(NULL, cpoint.x + 100, cpoint.y - 260, iWidth, iHeight, SWP_NOZORDER);// SWP_NOZORDER | SWP_NOSIZE);
	////m_LocalTdList.SetWindowPos(NULL, cpoint.x + 100, cpoint.y - 260, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
	//
	//m_SevTdList.SetWindowPos(NULL, cpoint.x-650, cpoint.y - 260, iWidth, iHeight, SWP_NOZORDER);

}


void OnLineSynTdDlg::OnSizing(UINT fwSide, LPRECT pRect)
{
	CDialog::OnSizing(fwSide, pRect);
	UPDATE_EASYSIZE;
	// TODO:  在此处添加消息处理程序代码
}


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

	//ModifyStyle(0, WS_SIZEBOX);
	//CRect rect;
	//GetClientRect(&rect);
	//CPoint cpoint = rect.CenterPoint();
	////GetWindowRect(&rect);
	///*rect.top += 400;
	//rect.bottom -= 300;
	//rect.left += 120;
	//rect.right -= 400;*/
	////((CWnd*)GetDlgItem(IDC_SYN_OL_DOWN))->MoveWindow(&rect);   //CenterWindow();
	//((CWnd*)GetDlgItem(IDC_SYN_OL_DATE))->SetWindowPos(NULL, cpoint.x+100, cpoint.y, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
	/*CRect rect;
	GetClientRect(&rect);
	CPoint cpoint = rect.CenterPoint();
	((CWnd*)GetDlgItem(IDC_SYN_OL_DOWN))->SetWindowPos(NULL, cpoint.x + 125, cpoint.y-120, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
	((CWnd*)GetDlgItem(IDC_SYN_OL_UPLOAD))->SetWindowPos(NULL, cpoint.x + 125, cpoint.y-80, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
	((CWnd*)GetDlgItem(IDC_SYN_OL_TASK))->SetWindowPos(NULL, cpoint.x + 125, cpoint.y-40, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
	((CWnd*)GetDlgItem(IDC_SYN_OL_DATE))->SetWindowPos(NULL, cpoint.x + 125, cpoint.y, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
	((CWnd*)GetDlgItem(IDC_SYN_OL_ARG))->SetWindowPos(NULL, cpoint.x + 125, cpoint.y+40, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
	((CWnd*)GetDlgItem(IDC_SYN_OL_TRUSTEE))->SetWindowPos(NULL, cpoint.x + 125, cpoint.y+80, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
	((CWnd*)GetDlgItem(IDC_BUTTON_DEL))->SetWindowPos(NULL, cpoint.x + 125, cpoint.y+120, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
	(CWnd*)GetDlgItem(IDC_STATIC_TD_LO_OL)->SetWindowPos(NULL, cpoint.x + 295, cpoint.y-240, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
	(CWnd*)GetDlgItem(IDC_STATIC_SYN_LA_TOTAL)->SetWindowPos(NULL, cpoint.x + 380, cpoint.y-240, 0, 0, SWP_NOZORDER | SWP_NOSIZE);*/
	//EASYSIZE(IDC_STATIC_TD_LO_OL, ES_KEEPSIZE, ES_BORDER, ES_BORDER, ES_KEEPSIZE, 0)
	//EASYSIZE(IDC_STATIC_SYN_LA_TOTAL, ES_KEEPSIZE, ES_BORDER, ES_BORDER, ES_KEEPSIZE, 0)

	CString strColTitle;
	int iColIndex = (int)VAL_ZERO;

	m_SevTdList.SetExtendedStyle(LVS_EX_FULLROWSELECT | LVS_EX_HEADERDRAGDROP | LVS_EX_ONECLICKACTIVATE | LVS_EX_GRIDLINES);
	//g_iCurrListColIndex = (int)VAL_ZERO;
	//g_iCurrListColOrder = (int)VAL_ZERO;

	m_SevTotalNum.SetWindowTextA(_T("0"));
	//m_SevTdList.SetBkColor(RGB(172, 199, 235));
	//m_SevTdList.SetTextBkColor(RGB(172, 199, 235));//(126, 206, 183));

	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_TDNAME + g_UIOffset);
	m_SevTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 110);

	iColIndex++;
	strColTitle.Empty();
	if (LANG_ZHCN == g_iUILanguage)	{ strColTitle += _T("任务状态"); }
	else{ strColTitle += _T("Task status"); }
	m_SevTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 80);

	iColIndex++;
	strColTitle.Empty();
	if (LANG_ZHCN == g_iUILanguage)	{ strColTitle += _T("任务ID"); }
	else{ strColTitle += _T("Task ID"); }
	m_SevTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 150);

	iColIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_SNAME + g_UIOffset);
	m_SevTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 100);

	iColIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_TTYPE + g_UIOffset);
	m_SevTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 100);

	iColIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_TRFREQUENCY + g_UIOffset);
	m_SevTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 100);

	iColIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_TMODE + g_UIOffset);
	m_SevTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 100);

	iColIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_CLAYOUT + g_UIOffset);
	m_SevTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 100);

	iColIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_N + g_UIOffset);
	m_SevTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 100);

	iColIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_SAFREQUENCY + g_UIOffset);
	m_SevTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 100);

	iColIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_STYPE + g_UIOffset);
	m_SevTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 100);

	iColIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_EDISTANCE + g_UIOffset);
	m_SevTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 100);

	iColIndex++;
	strColTitle.Empty();
	if (LANG_ZHCN == g_iUILanguage)	{ strColTitle += _T("开始电极"); }
	else{ strColTitle += _T("Start electrode"); }
	m_SevTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 115);

	iColIndex++;
	strColTitle.Empty();
	if (LANG_ZHCN == g_iUILanguage)	{ strColTitle += _T("结束电极"); }
	else{ strColTitle += _T("End electrode"); }
	m_SevTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 115);

	iColIndex++;
	strColTitle.Empty();
	if (LANG_ZHCN == g_iUILanguage)	{ strColTitle += _T("开始层数"); }
	else{ strColTitle += _T("Start layer"); }
	m_SevTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 115);

	iColIndex++;
	strColTitle.Empty();
	if (LANG_ZHCN == g_iUILanguage)	{ strColTitle += _T("结束层数"); }
	else{ strColTitle += _T("End layer"); }
	m_SevTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 115);

	iColIndex++;
	strColTitle.Empty();
	if (LANG_ZHCN == g_iUILanguage)	{ strColTitle += _T("开始测试时间"); }
	else{ strColTitle += _T("Start Test_time"); }
	m_SevTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 150);

	iColIndex++;
	strColTitle.Empty();
	if (LANG_ZHCN == g_iUILanguage)	{ strColTitle += _T("结束测试时间"); }
	else{ strColTitle += _T("End Test_time"); }
	m_SevTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 150);

	iColIndex++;
	strColTitle.Empty();
	if (LANG_ZHCN == g_iUILanguage)	{ strColTitle += _T("定时时间"); }
	else{ strColTitle += _T("Timer time"); }
	m_SevTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 115);

	iColIndex++;
	strColTitle.Empty();
	if (LANG_ZHCN == g_iUILanguage)	{ strColTitle += _T("总测点数"); }
	else{ strColTitle += _T("Total point"); }
	m_SevTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 50);

	iColIndex++;
	strColTitle.Empty();
	if (LANG_ZHCN == g_iUILanguage)	{ strColTitle += _T("Org标志"); }
	else{ strColTitle += _T("Org Flg"); }
	m_SevTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 50);
	////////////////////////////////////////本地框显示/////////////////////////////////////////////////
	m_LocalTdList.SetExtendedStyle(LVS_EX_FULLROWSELECT | LVS_EX_HEADERDRAGDROP | LVS_EX_ONECLICKACTIVATE | LVS_EX_GRIDLINES);
	//m_LocalTdList.SetBkColor(RGB(172, 199, 235));
	//m_LocalTdList.SetTextBkColor(RGB(172, 199, 235));//(126, 206, 183));

	m_LocalTotalNum.SetWindowTextA(_T("0"));

	iColIndex = (int)VAL_ZERO;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_TDNAME + g_UIOffset);
	m_LocalTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 110);

	iColIndex++;
	strColTitle.Empty();
	if (LANG_ZHCN == g_iUILanguage)	{ strColTitle += _T("任务状态"); }
	else{ strColTitle += _T("Task status"); }
	m_LocalTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 80);

	iColIndex++;
	strColTitle.Empty();
	if (LANG_ZHCN == g_iUILanguage)	{ strColTitle += _T("任务ID"); }
	else{ strColTitle += _T("Task ID"); }
	m_LocalTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 150);

	iColIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_SNAME + g_UIOffset);
	m_LocalTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 100);

	iColIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_TTYPE + g_UIOffset);
	m_LocalTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 100);

	iColIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_TRFREQUENCY + g_UIOffset);
	m_LocalTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 100);

	iColIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_TMODE + g_UIOffset);
	m_LocalTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 100);

	iColIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_CLAYOUT + g_UIOffset);
	m_LocalTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 100);

	iColIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_N + g_UIOffset);
	m_LocalTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 100);

	iColIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_SAFREQUENCY + g_UIOffset);
	m_LocalTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 100);

	iColIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_STYPE + g_UIOffset);
	m_LocalTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 100);

	iColIndex++;
	strColTitle.Empty();
	strColTitle.LoadString(IDS_DB_TD_EDISTANCE + g_UIOffset);
	m_LocalTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 100);

	iColIndex++;
	strColTitle.Empty();
	if (LANG_ZHCN == g_iUILanguage)	{ strColTitle += _T("开始电极"); }
	else{ strColTitle += _T("Start electrode"); }
	m_LocalTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 115);

	iColIndex++;
	strColTitle.Empty();
	if (LANG_ZHCN == g_iUILanguage)	{ strColTitle += _T("结束电极"); }
	else{ strColTitle += _T("End electrode"); }
	m_LocalTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 115);

	iColIndex++;
	strColTitle.Empty();
	if (LANG_ZHCN == g_iUILanguage)	{ strColTitle += _T("开始层数"); }
	else{ strColTitle += _T("Start layer"); }
	m_LocalTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 115);

	iColIndex++;
	strColTitle.Empty();
	if (LANG_ZHCN == g_iUILanguage)	{ strColTitle += _T("结束层数"); }
	else{ strColTitle += _T("End layer"); }
	m_LocalTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 115);

	iColIndex++;
	strColTitle.Empty();
	if (LANG_ZHCN == g_iUILanguage)	{ strColTitle += _T("开始测试时间"); }
	else{ strColTitle += _T("Start Test_time"); }
	m_LocalTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 150);

	iColIndex++;
	strColTitle.Empty();
	if (LANG_ZHCN == g_iUILanguage)	{ strColTitle += _T("结束测试时间"); }
	else{ strColTitle += _T("End Test_time"); }
	m_LocalTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 150);

	iColIndex++;
	strColTitle.Empty();
	if (LANG_ZHCN == g_iUILanguage)	{ strColTitle += _T("定时时间"); }
	else{ strColTitle += _T("Timer time"); }
	m_LocalTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 115);

	iColIndex++;
	strColTitle.Empty();
	if (LANG_ZHCN == g_iUILanguage)	{ strColTitle += _T("总测点数"); }
	else{ strColTitle += _T("Total point"); }
	m_LocalTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 115);
	
	iColIndex++;
	strColTitle.Empty();
	if (LANG_ZHCN == g_iUILanguage)	{ strColTitle += _T("Org标志"); }
	else{ strColTitle += _T("Org Flg"); }
	m_LocalTdList.InsertColumn(iColIndex, strColTitle, LVCFMT_LEFT, 50);
	// TODO:  在此添加额外的初始化
	INIT_EASYSIZE;
	//ShowWindow(SW_MAXIMIZE);
	return TRUE;  // return TRUE unless you set the focus to a control
	// 异常:  OCX 属性页应返回 FALSE
}
void OnLineSynTdDlg::OnInitLocalList()
{
	UINT32 uiTotalNum;
	theApp.m_pTdManager->InitialTDListByOnLineForSyn(this->m_LocalTdList, this->m_szDeSN, uiTotalNum);
	CString szTotalNum;
	szTotalNum.Format("%u",uiTotalNum);
	m_LocalTotalNum.SetWindowTextA(_T(szTotalNum));
}
void OnLineSynTdDlg::OnSynAndInitSevTdList()
{
	char chMsgSyn[4095] = { 0 };
	UINT32 *uiRevData = NULL;
	char chSendStr[210] = {0};
	int iLen = 0;
	CString szDevID = m_szDeSN.Mid(2);
	UINT32 uiDevID = atoi(szDevID);
	STRemTaskTable *ptTaskTable = NULL;
	CString lsStatus = "";
	UINT32 uiTaskNum = 0;
	STRemTaskArg *ptTaskArg = NULL;

	//SYSTEMTIME sysTm;
	time_t tm;
	//GetSystemTime(&sysTm);
	int uiCurTime = (int)time(&tm);
	int uiStartTime = uiCurTime - 30 * 24 * 3600;

	theApp.m_NetWorkOper.SetSuspendForThread(true);

	///////////////////////////////////////////////////////同步任务列表////////////////////////////////////////////////
	uiDevID = htonl(uiDevID);
	uiCurTime = htonl(uiCurTime);
	uiStartTime = htonl(uiStartTime);
	memcpy(chSendStr, &uiDevID, sizeof(UINT32));
	memcpy(&chSendStr[sizeof(UINT32)], &uiStartTime, sizeof(UINT32));
	memcpy(&chSendStr[2 * sizeof(UINT32)], &uiCurTime, sizeof(UINT32));
	chSendStr[3 * sizeof(UINT32)] = 1;
	if (!theApp.m_NetWorkOper.SendCtrlMsgDirect(EN_REQ_DOWNLOAD_TASK_TABLE, 0xFFFFFFFF, 1, chSendStr, 3*sizeof(UINT32)+sizeof(BYTE)))
	{
		theApp.m_NetWorkOper.SetSuspendForThread(false);
		if (LANG_ZHCN == g_iUILanguage)
			AfxMessageBox(_T("同步任务信息发送失败"));
		else
			MessageBoxEx(NULL, _T("Synchronization task table send failed."), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		return;
	}

	if (EN_RECV_SUCCESS == theApp.m_NetWorkOper.RecvMsgDirect(chMsgSyn, &iLen, sizeof(chMsgSyn), 5000))
	{
		uiRevData = (UINT32*)(chMsgSyn);
		uiTaskNum = ntohl(uiRevData[0]);
		if ((uiRevData[0] < 1) || (iLen < (sizeof(UINT32)+uiTaskNum * sizeof(STRemTaskTable))))
		{
			theApp.m_NetWorkOper.SetSuspendForThread(false);
			if (uiRevData[0] > 0)
			{ 
				if (LANG_ZHCN == g_iUILanguage)
					AfxMessageBox(_T("同步任务列表接收失败，接收长度错误"));
				else
					MessageBoxEx(NULL, _T("Synchronization task table recv failed. recv length is error!"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
			}
			return;
		}
		m_SevTdList.DeleteAllItems(); 
		CString str;str.Format(_T("%d"),uiTaskNum);
		m_SevTotalNum.SetWindowTextA((LPCTSTR)(_bstr_t)str);
		ptTaskTable = (STRemTaskTable *) (&chMsgSyn[sizeof(UINT32)]);
		int i = (int)VAL_ZERO;
		for (i = 0; i < uiTaskNum; i++)
		{
			//if (0 <= ptTaskTable[i].ucTaskStats && ptTaskTable[i].ucTaskStats <= 3)
			{
				lsStatus = OnLineTask(ptTaskTable[i].ucTaskStats);
				m_SevTdList.InsertItem(i, _T(""));
				m_SevTdList.SetItemText(i, 0, (LPCTSTR)(_bstr_t)_T(" "));
				m_SevTdList.SetItemText(i, 1, (LPCTSTR)(_bstr_t)lsStatus); //ptTaskTable[i].ucTaskStats);
				m_SevTdList.SetItemText(i, 2, (LPCTSTR)(_bstr_t)ptTaskTable[i].ucTaskID);
				//m_SevTdList.UpdateWindow();
			}
		}
		//m_SevTdList.UpdateWindow(); //UpdateData();
		//存入结构体供后面的任务上传作检查
		if (uiTaskNum >= 1)
		{
			if (NULL != m_ptTaskTableInfo) { free(m_ptTaskTableInfo); };
			m_ptTaskTableInfo = (STRemTaskTable *)malloc(uiTaskNum*sizeof(STRemTaskTable));
			m_uiSevTaskNum = uiTaskNum;
			memcpy(m_ptTaskTableInfo, ptTaskTable, uiTaskNum*sizeof(STRemTaskTable));
		}
	}

	/////////////////////////////////////同步任务参数/////////////////////////////////////////////////
	int j = 0;
	UINT32 uiRemainNum = 0;
	UINT32 uiGetNum = 0;
	for (j = 0; j < uiTaskNum; j++)//=5)
	{
		/*uiRemainNum = uiTaskNum - j;
		if (uiRemainNum < 5)
		{
			uiGetNum = uiRemainNum;
		}
		else
		{
			uiGetNum = 5;
		}*/
		uiGetNum = 1;
		chSendStr[0] = 0; chSendStr[1] = 0; chSendStr[2] = 0; chSendStr[3] = uiGetNum;
	    CString TmpStr = m_SevTdList.GetItemText(j,2);
		strncpy(&chSendStr[4], TmpStr,MAX_NAME_LEN*sizeof(BYTE));
		/*TmpStr = m_SevTdList.GetItemText(j+1, 2);
		strncpy(&chSendStr[4 + MAX_NAME_LEN], TmpStr, MAX_NAME_LEN * sizeof(BYTE));
		TmpStr = m_SevTdList.GetItemText(j+2, 2);
		strncpy(&chSendStr[4 + 80], TmpStr, MAX_NAME_LEN * sizeof(BYTE));
		TmpStr = m_SevTdList.GetItemText(j+3, 2);
		strncpy(&chSendStr[4 + 120], TmpStr, MAX_NAME_LEN * sizeof(BYTE));
		TmpStr = m_SevTdList.GetItemText(j+4, 2);
		strncpy(&chSendStr[4 + 160], TmpStr, MAX_NAME_LEN * sizeof(BYTE));
		*/
		int iSendLen = sizeof(UINT32)+sizeof(BYTE)*MAX_NAME_LEN*uiGetNum;
		if (!theApp.m_NetWorkOper.SendCtrlMsgDirect(EN_REQ_DOWNLOAD_TASK_ARG, 0xFFFFFFFF, 1, chSendStr,iSendLen))
		{
			theApp.m_NetWorkOper.SetSuspendForThread(false);
			if (LANG_ZHCN == g_iUILanguage)
				AfxMessageBox(_T("同步任务参数发送失败"));
			else
				MessageBoxEx(NULL, _T("Synchronization task arguments send failed."), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
			return;
		}

		if (EN_RECV_SUCCESS == theApp.m_NetWorkOper.RecvMsgDirect(chMsgSyn, &iLen, 1000, 5000))
		{
			uiRevData = (UINT32*)(chMsgSyn);
			UINT32 uiRevDataNum = ntohl(uiRevData[0]);
			if ((uiRevDataNum < 1) || (iLen < (sizeof(UINT32)+uiRevDataNum * sizeof(STRemTaskArg))))
			{
				theApp.m_NetWorkOper.SetSuspendForThread(false);
				return;
			}
			ptTaskArg = (STRemTaskArg *)(chMsgSyn + sizeof(UINT32));
			int iIndex = (int)VAL_ZERO;
			for (iIndex = 0; iIndex < uiRevDataNum; iIndex++)
			{
				ptTaskArg[iIndex].stMeasuArg.iSAInterval = ntohl(ptTaskArg[iIndex].stMeasuArg.iSAInterval);
				ptTaskArg[iIndex].stMeasuArg.fXElecDistance = tcp_ntohf(ptTaskArg[iIndex].stMeasuArg.fXElecDistance);
				ptTaskArg[iIndex].stMeasuArg.fYElecDistance = tcp_ntohf(ptTaskArg[iIndex].stMeasuArg.fYElecDistance);
				ptTaskArg[iIndex].stMeasuArg.fXElecStep = tcp_ntohf(ptTaskArg[iIndex].stMeasuArg.fXElecStep);
				ptTaskArg[iIndex].stMeasuArg.fYElecStep = tcp_ntohf(ptTaskArg[iIndex].stMeasuArg.fYElecStep);
				ptTaskArg[iIndex].stMeasuArg.rcGridSize.left = ntohl(ptTaskArg[iIndex].stMeasuArg.rcGridSize.left);
				ptTaskArg[iIndex].stMeasuArg.rcGridSize.top = ntohl(ptTaskArg[iIndex].stMeasuArg.rcGridSize.top);
				ptTaskArg[iIndex].stMeasuArg.rcGridSize.right = ntohl(ptTaskArg[iIndex].stMeasuArg.rcGridSize.right);
				ptTaskArg[iIndex].stMeasuArg.rcGridSize.bottom = ntohl(ptTaskArg[iIndex].stMeasuArg.rcGridSize.bottom);
				ptTaskArg[iIndex].stMeasuArg.byLineDirection = ntohl(ptTaskArg[iIndex].stMeasuArg.byLineDirection);

				ptTaskArg[iIndex].uiStartElec = ntohl(ptTaskArg[iIndex].uiStartElec);
				ptTaskArg[iIndex].uiEndElec = ntohl(ptTaskArg[iIndex].uiEndElec);
				ptTaskArg[iIndex].uiStartLayer = ntohl(ptTaskArg[iIndex].uiStartLayer);
				ptTaskArg[iIndex].uiEndLayer = ntohl(ptTaskArg[iIndex].uiEndLayer);
				ptTaskArg[iIndex].uiStartTime = ntohl(ptTaskArg[iIndex].uiStartTime);
				ptTaskArg[iIndex].uiEndTime = ntohl(ptTaskArg[iIndex].uiEndTime);
				ptTaskArg[iIndex].uiTimerTime = ntohl(ptTaskArg[iIndex].uiTimerTime);
				ptTaskArg[iIndex].uiTotalNum = ntohl(ptTaskArg[iIndex].uiTotalNum);

				time_t tmTime = ptTaskArg[iIndex].uiStartTime;
				CString szTimeStart = Tm2LocalStr(tmTime);//Tm2GmtStr(tmTime);
				//szTimeStart.Format(_T("%d-%d-%d %d:%d:%d"), p->tm_year + 1900, p->tm_mon + 1, p->tm_mday, p->tm_hour,p->tm_min,p->tm_sec);
			    
				tmTime = ptTaskArg[iIndex].uiEndTime;
				CString szTimeEnd = Tm2LocalStr(tmTime);//Tm2GmtStr(tmTime);
				//p = localtime(&tmTime);
				//szTimeStart.Format(_T("%d-%d-%d %d:%d:%d"), p->tm_year + 1900, p->tm_mon + 1, p->tm_mday, p->tm_hour, p->tm_min, p->tm_sec);
				
				tmTime = ptTaskArg[iIndex].uiTimerTime;
				CString szTimeTimer = Tm2LocalStr(tmTime);//Tm2GmtStr(tmTime);
				//p = localtime(&tmTime);
				//szTimeStart.Format(_T("%d-%d-%d %d:%d:%d"), p->tm_year + 1900, p->tm_mon + 1, p->tm_mday, p->tm_hour, p->tm_min, p->tm_sec);

				m_SevTdList.SetItemText(j+iIndex, 0, (LPCTSTR)(_bstr_t)ptTaskArg[iIndex].ucTDName);
				m_SevTdList.SetItemText(j+iIndex, 3, (LPCTSTR)(_bstr_t)ptTaskArg[iIndex].ucSciptName);
				m_SevTdList.SetItemText(j+iIndex, 4, (LPCTSTR)(_bstr_t)ptTaskArg[iIndex].stMeasuArg.ucTestType);
				m_SevTdList.SetItemText(j+iIndex, 5, (LPCTSTR)(_bstr_t)ptTaskArg[iIndex].stMeasuArg.ucTxPeriod);
				m_SevTdList.SetItemText(j+iIndex, 6, (LPCTSTR)(_bstr_t)ptTaskArg[iIndex].stMeasuArg.ucArrayType);
				m_SevTdList.SetItemText(j+iIndex, 7, (LPCTSTR)(_bstr_t)ptTaskArg[iIndex].stMeasuArg.ucCableLayout);
				m_SevTdList.SetItemText(j+iIndex, 8, (LPCTSTR)(_bstr_t)ptTaskArg[iIndex].stMeasuArg.ucStacking);
				CString str;str.Format(_T("%d"),ptTaskArg[iIndex].stMeasuArg.iSAInterval);
				m_SevTdList.SetItemText(j+iIndex, 9, (LPCTSTR)(_bstr_t)str);
				m_SevTdList.SetItemText(j+iIndex, 10, (LPCTSTR)(_bstr_t)ptTaskArg[iIndex].stMeasuArg.ucSptType);
				//m_SevTdList.SetItemText(j+iIndex, 11, (LPCTSTR)(_bstr_t)ptTaskArg[iIndex].stMeasuArg.fElecSpace);
				str.Empty(); str.Format(_T("%d"),ptTaskArg[iIndex].uiStartElec);
				m_SevTdList.SetItemText(j+iIndex, 12, (LPCTSTR)(_bstr_t)str);
				str.Empty(); str.Format(_T("%d"),ptTaskArg[iIndex].uiEndElec);
				m_SevTdList.SetItemText(j+iIndex, 13, (LPCTSTR)(_bstr_t)str);
				str.Empty(); str.Format(_T("%d"),ptTaskArg[iIndex].uiStartLayer);
				m_SevTdList.SetItemText(j+iIndex, 14, (LPCTSTR)(_bstr_t)str);
				str.Empty(); str.Format(_T("%d"),ptTaskArg[iIndex].uiEndLayer);
				m_SevTdList.SetItemText(j+iIndex, 15, (LPCTSTR)(_bstr_t)str);
				m_SevTdList.SetItemText(j+iIndex, 16, (LPCTSTR)(_bstr_t)szTimeStart);
				m_SevTdList.SetItemText(j+iIndex, 17, (LPCTSTR)(_bstr_t)szTimeEnd);
				m_SevTdList.SetItemText(j+iIndex, 18, (LPCTSTR)(_bstr_t)szTimeTimer);
				str.Empty(); str.Format(_T("%d"),ptTaskArg[iIndex].uiTotalNum);
				m_SevTdList.SetItemText(j+iIndex, 19, (LPCTSTR)(_bstr_t)str);
				str.Empty(); str.Format(_T("%d"),ptTaskArg[iIndex].ucOrgFlg);
				m_SevTdList.SetItemText(j+iIndex, 20, (LPCTSTR)(_bstr_t)str);
			}
		}
	}
	theApp.m_NetWorkOper.SetSuspendForThread(false);

	return;
}
BYTE OnLineSynTdDlg::ReturnServerTaskState(CString szTaskID)
{
	if (NULL == m_ptTaskTableInfo)
	{
		return -1;
	}

	for (int i = 0; i < m_uiSevTaskNum; i++)
	{
		if (m_ptTaskTableInfo[i].ucTaskID == szTaskID)
		{
			return m_ptTaskTableInfo[i].ucTaskStats;
		}
	}

	return -1;
}

void OnLineSynTdDlg::OnBnClickedSynOlUpload()
{
	// TODO:  在此添加控件通知处理程序代码
	CString szListStr = "";
	char chSendStr[210] = { 0 };
	char chMsgSyn[10] = { 0 };
	int iLen = 0;
	UINT32 uiTaskNum;
	STRemTaskArg stTaskArg;
	//比对是否上传过
	POSITION pos = m_LocalTdList.GetFirstSelectedItemPosition();
	if (pos == NULL)
	{
		if (LANG_ZHCN == g_iUILanguage)
			AfxMessageBox(_T("请选择本地的任务上传"));
		else
			MessageBoxEx(NULL, _T("Please select Local's list the task to upload !"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		return;
	}
	theApp.m_NetWorkOper.SetSuspendForThread(true);
	while (pos)
	{
		int nItem = m_LocalTdList.GetNextSelectedItem(pos);
		CString szTaskStatus = m_LocalTdList.GetItemText(nItem, 1);
		uiTaskNum = 1;
		szListStr.Empty();
		szListStr = m_LocalTdList.GetItemText(nItem, 0);
		strncpy(stTaskArg.ucTDName, szListStr, 60 * sizeof(BYTE));
		szListStr.Empty();
		szListStr = m_LocalTdList.GetItemText(nItem, 2);
		strncpy(stTaskArg.ucTaskID, szListStr, MAX_NAME_LEN* sizeof(BYTE));
		
		CString szStrMsg;
		BYTE ucSevTaskState = ReturnServerTaskState(stTaskArg.ucTaskID);
		if (0<= ucSevTaskState && ucSevTaskState <=3)
		{
			if (EN_TASK_STATE_NO_TRUST == ucSevTaskState)
			{
				szStrMsg.Empty();
				szStrMsg.Format(_T("Task %s has been uploaded! whether to overwrite?"), stTaskArg.ucTDName);
				//AfxMessageBox(szStrMsg);
				if (IDYES != ::MessageBox(NULL, szStrMsg, "Notice", MB_YESNO))
				{
					continue;
				}
			}
			else if (EN_TASK_STATE_FINISH == ucSevTaskState)
			{
				szStrMsg.Empty();
				szStrMsg.Format(_T("Task %s has been completed at server! whether to overwrite?"), stTaskArg.ucTDName);
				//AfxMessageBox(szStrMsg);
				if (IDYES != ::MessageBox(NULL, szStrMsg, "Notice", MB_YESNO))
				{
					continue;
				}
			}
			else 
			{
				szStrMsg.Empty();
				
				if (LANG_ZHCN == g_iUILanguage)
				{
					szStrMsg.Format(_T("任务%s已由服务器管理或测试!上传前请取消信任"), stTaskArg.ucTDName);
					AfxMessageBox(szStrMsg);
				}
				else
				{
					szStrMsg.Format(_T("Task %s has been managed or testing by server!Please cancel trust before uploading"), stTaskArg.ucTDName);
					MessageBoxEx(NULL, szStrMsg, STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
				}
				continue;
			}
		}

		szListStr.Empty();
		szListStr = m_LocalTdList.GetItemText(nItem, 3);
		strncpy(stTaskArg.ucSciptName, szListStr, MAX_NAME_LEN*sizeof(BYTE));
		szListStr.Empty();
		szListStr = m_LocalTdList.GetItemText(nItem, 4);
		stTaskArg.stMeasuArg.ucTestType = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_LocalTdList.GetItemText(nItem, 5);
		stTaskArg.stMeasuArg.ucTxPeriod = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_LocalTdList.GetItemText(nItem, 6);
		stTaskArg.stMeasuArg.ucArrayType = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_LocalTdList.GetItemText(nItem, 7);
		stTaskArg.stMeasuArg.ucCableLayout = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_LocalTdList.GetItemText(nItem, 8);
		stTaskArg.stMeasuArg.ucStacking = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_LocalTdList.GetItemText(nItem, 9);
		stTaskArg.stMeasuArg.iSAInterval = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_LocalTdList.GetItemText(nItem, 10);
		stTaskArg.stMeasuArg.ucSptType = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_LocalTdList.GetItemText(nItem, 11);
		//stTaskArg.stMeasuArg.fElecSpace = atof(szListStr);
		szListStr.Empty();
		szListStr = m_LocalTdList.GetItemText(nItem, 12);
		stTaskArg.uiStartElec = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_LocalTdList.GetItemText(nItem, 13);
		stTaskArg.uiEndElec = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_LocalTdList.GetItemText(nItem, 14);
		stTaskArg.uiStartLayer = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_LocalTdList.GetItemText(nItem, 15);
		stTaskArg.uiEndLayer = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_LocalTdList.GetItemText(nItem, 16);
		stTaskArg.uiStartTime = Str2GmtTm(szListStr);//atoi(szListStr);
		szListStr.Empty();
		szListStr = m_LocalTdList.GetItemText(nItem, 17);
		stTaskArg.uiEndTime = Str2GmtTm(szListStr);
		szListStr.Empty();
		szListStr = m_LocalTdList.GetItemText(nItem, 18);
		stTaskArg.uiTimerTime = Str2GmtTm(szListStr);
		szListStr.Empty();
		szListStr = m_LocalTdList.GetItemText(nItem, 19);
		stTaskArg.uiTotalNum = atoi(szListStr);
		//Org上传标志
		szListStr.Empty();
		szListStr = m_LocalTdList.GetItemText(nItem, 20);
		stTaskArg.ucOrgFlg = atoi(szListStr);
		//////////////////////////////////////////////////////发送任务和任务参数到云端////////////////////////////////////////////////
		uiTaskNum = htonl(uiTaskNum);
		stTaskArg.stMeasuArg.iSAInterval=htonl(stTaskArg.stMeasuArg.iSAInterval);
		//stTaskArg.stMeasuArg.fElecSpace = tcp_htonf(stTaskArg.stMeasuArg.fElecSpace);
		stTaskArg.uiStartElec = htonl(stTaskArg.uiStartElec);
		stTaskArg.uiEndElec = htonl(stTaskArg.uiEndElec);
		stTaskArg.uiStartLayer = htonl(stTaskArg.uiStartLayer);
		stTaskArg.uiEndLayer = htonl(stTaskArg.uiEndLayer);
		stTaskArg.uiStartTime = htonl(stTaskArg.uiStartTime);
		stTaskArg.uiEndTime = htonl(stTaskArg.uiEndTime);
		stTaskArg.uiTimerTime = htonl(stTaskArg.uiTimerTime);
		stTaskArg.uiTotalNum = htonl(stTaskArg.uiTotalNum);
		memcpy(chSendStr, &uiTaskNum, sizeof(UINT32));
		memcpy(&chSendStr[sizeof(UINT32)], &stTaskArg, sizeof(stTaskArg));
		if (!theApp.m_NetWorkOper.SendCtrlMsgDirect(EN_UPLOAD_TASK_ARG, 0xFFFFFFFF, 1, (char*)chSendStr, sizeof(UINT32)+sizeof(stTaskArg)))
		{
			theApp.m_NetWorkOper.SetSuspendForThread(false);
			if (LANG_ZHCN == g_iUILanguage)
				AfxMessageBox(_T("上传任务参数发送失败"));
			else
				MessageBoxEx(NULL, _T("Upload task parameter send to failed."), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
			return;
		}

		if (EN_RECV_SUCCESS == theApp.m_NetWorkOper.RecvMsgDirect(chMsgSyn, &iLen, sizeof(chMsgSyn), 5000))
		{
			if ((iLen != sizeof(BYTE)) || (EN_RECV_SUCCESS != chMsgSyn[0]))
			{
				theApp.m_NetWorkOper.SetSuspendForThread(false);
				if (LANG_ZHCN == g_iUILanguage)
					AfxMessageBox(_T("上传任务参数接收失败"));
				else
					MessageBoxEx(NULL, _T("Upload task parameter recv to failed."), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
				//return;
			}			
		}
		
		/////////////////////////////////////////////////////////发送接地电阻信息到云端////////////////////////////////////////////////
		szListStr.Empty();
		szListStr = m_LocalTdList.GetItemText(nItem, 2);
		strncpy(stTaskArg.ucTaskID, szListStr, MAX_NAME_LEN * sizeof(BYTE));
		szListStr.Empty();
		szListStr = m_LocalTdList.GetItemText(nItem, 12);
		stTaskArg.uiStartElec = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_LocalTdList.GetItemText(nItem, 13);
		stTaskArg.uiEndElec = atoi(szListStr);
		//stTaskArg.uiEndElec = 95;
		//stTaskArg.uiStartElec = 1;
		stTaskArg.uiStartElec = htonl(stTaskArg.uiStartElec);
		stTaskArg.uiEndElec = htonl(stTaskArg.uiEndElec);
		memcpy(chSendStr, &stTaskArg.ucTaskID, MAX_NAME_LEN * sizeof(BYTE));
		memcpy(&chSendStr[MAX_NAME_LEN * sizeof(BYTE)], &stTaskArg.uiStartElec, sizeof(UINT32));
		memcpy(&chSendStr[MAX_NAME_LEN * sizeof(BYTE)+ sizeof(UINT32)], &stTaskArg.uiEndElec, sizeof(UINT32));
		if (!theApp.m_NetWorkOper.SendCtrlMsgDirect(EN_UPLOAD_RG_INF, 0xFFFFFFFF, 1, (char*)chSendStr, MAX_NAME_LEN * sizeof(BYTE)+2*sizeof(UINT32)))
		{
			theApp.m_NetWorkOper.SetSuspendForThread(false);
			if (LANG_ZHCN == g_iUILanguage)
				AfxMessageBox(_T("上传任务接地电阻发送失败"));
			else
				MessageBoxEx(NULL, _T("Upload task Rg send to failed."), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
			return;
		}

		if (EN_RECV_SUCCESS == theApp.m_NetWorkOper.RecvMsgDirect(chMsgSyn, &iLen, sizeof(chMsgSyn), 5000))
		{
			if ((iLen != sizeof(BYTE)) || (EN_RECV_SUCCESS != chMsgSyn[0]))
			{
				theApp.m_NetWorkOper.SetSuspendForThread(false);
				if (LANG_ZHCN == g_iUILanguage)
					AfxMessageBox(_T("上传任务接地电阻接收失败"));
				else
					MessageBoxEx(NULL, _T("Upload task Rg recv to failed."), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
				//return;
			}
		}

		/////////////////////////////////////////////////////////发送数据到云端////////////////////////////////////////////////////////
		if (FALSE != UploadRes2DData((char*)stTaskArg.ucTaskID))
		{
			//TrusteeLocalTaskToSev(nItem);
			//移动本地任务到服务栏状态框
			Sleep(30000);
			//m_SevTdList.SetRedraw(FALSE);
			//更新内容
			OnSynAndInitSevTdList();
			//m_SevTdList.SetRedraw(TRUE);
			//m_SevTdList.Invalidate();
			//m_SevTdList.UpdateWindow();

		}
	}
	if (LANG_ZHCN == g_iUILanguage)
		AfxMessageBox(_T("上传任务完成"));
	else
		MessageBoxEx(NULL, _T("Upload task finished."), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
	theApp.m_NetWorkOper.SetSuspendForThread(false);
}

#define MAX_DOWNLOCAD_POINT  (50)
void OnLineSynTdDlg::SynOlDownData(char *chStr, int iSendLen, int iStartPoint, int iEndPoint, bool bTaskExistFlg, STRemTaskArg stTaskArg, DWORD iTdChannelID)
{
	int iLen = 0;

	if (NULL == chStr)
	{
		return;
	}

	if (!theApp.m_NetWorkOper.SendCtrlMsgDirect(EN_REQ_DOWNLOAD_DATA_INFO, 0xFFFFFFFF, 1, (char*)chStr, iSendLen))
	{
		theApp.m_NetWorkOper.SetSuspendForThread(false);
		AfxMessageBox(_T("Download task data send failed."));
		return;
	}
	int iTotalPoint = (iEndPoint - iStartPoint + 1);
	int iRevLen = MAX_NAME_LEN*sizeof(BYTE)+sizeof(UINT32)+iTotalPoint*(11*sizeof(float)+2*sizeof(BYTE));
	if (EN_RECV_SUCCESS == theApp.m_NetWorkOper.RecvMsgDirect(chStr, &iLen, iRevLen, 6000))
	{
		STSynTaskDataRes *ptTaskDataHeader = (STSynTaskDataRes *)chStr;
		if ((iLen < iRevLen) || (iTotalPoint != ntohl(ptTaskDataHeader->dwPointNum)))
		{
			theApp.m_NetWorkOper.SetSuspendForThread(false);
			AfxMessageBox(_T("Download task data recv failed."));
			return;
		}

		///////存入数据库tdcon表中
		if (!bTaskExistFlg)
		{
			//任务存在
			for (int i = 0; i < iTotalPoint; i++)
			{
				STTaskDataRes *ptTaskData = (STTaskDataRes *)(chStr + MAX_NAME_LEN * sizeof(BYTE)+sizeof(UINT32)+i*sizeof(STTaskDataRes));
				STMeasuDataResBasic stMeasuBasicData;
				stMeasuBasicData.iID = ntohl(ptTaskData->dwID);
				stMeasuBasicData.fV  = tcp_ntohf(ptTaskData->fV);
				stMeasuBasicData.fI = tcp_ntohf(ptTaskData->fI);
				stMeasuBasicData.fR0 = tcp_ntohf(ptTaskData->fR0);
				stMeasuBasicData.fSP = tcp_ntohf(ptTaskData->fSP);
				stMeasuBasicData.fK = tcp_ntohf(ptTaskData->fK);
				stMeasuBasicData.ucAlram = ptTaskData ->ucAlram;
				stMeasuBasicData.ucStack = ptTaskData ->ucStack;
				stMeasuBasicData.fR0_LC = tcp_ntohf(ptTaskData->fR0_LC);
				int iAttachLen = (1 == stTaskArg.stMeasuArg.ucTestType) ? sizeof(STMeasuDataResAttachIP) : 0;
				m_TaskdDBOper.UpdateTdBasicData(stTaskArg.stMeasuArg.ucSptType, stTaskArg.stMeasuArg.ucTestType,\
					iTdChannelID, stMeasuBasicData.iID, &stMeasuBasicData, ptTaskData + 1 + (i + 1)*sizeof(STMeasuDataResBasic)+i*iAttachLen);
			}
		}
		else
		{
			//任务不存在
			for (int i = 0; i < iTotalPoint; i++)
			{
				STTaskDataRes *ptTaskData = (STTaskDataRes *)(chStr + MAX_NAME_LEN * sizeof(BYTE)+sizeof(UINT32)+i*sizeof(STTaskDataRes));
				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(ptTaskData->fK);
				stMeasuBasicData.fV = tcp_ntohf(ptTaskData->fV);
				stMeasuBasicData.fI = tcp_ntohf(ptTaskData->fI);
				stMeasuBasicData.fR0 = tcp_ntohf(ptTaskData->fR0);
				stMeasuBasicData.fSP = tcp_ntohf(ptTaskData->fSP);
				stMeasuBasicData.fK = tcp_ntohf(ptTaskData->fK);
				stMeasuBasicData.ucAlram = ptTaskData->ucAlram;
				stMeasuBasicData.ucStack = ptTaskData->ucStack;
				stMeasuBasicData.fR0_LC = tcp_ntohf(ptTaskData->fR0_LC);
				//m_TaskdDBOper.OnlineDownloadRes2DData(&stMeasuBasicData, iTdChannelID);
			}
			
		}
	}
	return;
}

void OnLineSynTdDlg::OnBnClickedSynOlDown()
{
	// TODO:  在此添加控件通知处理程序代码
	//下发接地电阻信息和测试数据信息
	CString szListStr = "";
	//char chSendStr[210] = { 0 };
	int iLen = 0;
	STRemTaskArg stTaskArg;
	DWORD dwTdID = 0;
	CString szTdID = "";

	//比对是否上传过
	POSITION pos = m_SevTdList.GetFirstSelectedItemPosition();
	if (pos == NULL)
	{
		AfxMessageBox(_T("Please select the task to download!"));
		return;
	}
	theApp.m_NetWorkOper.SetSuspendForThread(true);
	while (pos)
	{
		int nItem = m_SevTdList.GetNextSelectedItem(pos);
		CString szTaskStatus = m_SevTdList.GetItemText(nItem, 1);
		if (szTaskStatus == "")
		{
			continue;
		}

		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 0);
		strncpy(stTaskArg.ucTDName, szListStr, 60 * sizeof(BYTE));
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 2);
		strncpy(stTaskArg.ucTaskID, szListStr, MAX_NAME_LEN* sizeof(BYTE));
		szTdID = szListStr;
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 3);
		strncpy(stTaskArg.ucSciptName, szListStr, MAX_NAME_LEN * sizeof(BYTE));
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 4);
		stTaskArg.stMeasuArg.ucTestType = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 5);
		stTaskArg.stMeasuArg.ucTxPeriod = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 6);
		stTaskArg.stMeasuArg.ucArrayType = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 7);
		stTaskArg.stMeasuArg.ucCableLayout = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 8);
		stTaskArg.stMeasuArg.ucStacking = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 9);
		stTaskArg.stMeasuArg.iSAInterval = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 10);
		stTaskArg.stMeasuArg.ucSptType = atoi(szListStr);
		/*szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 11);
		stTaskArg.stMeasuArg.fElecSpace = atof(szListStr);*/
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 12);
		stTaskArg.uiStartElec = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 13);
		stTaskArg.uiEndElec = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 14);
		stTaskArg.uiStartLayer = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 15);
		stTaskArg.uiEndLayer = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 16);
		stTaskArg.uiStartTime = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 17);
		stTaskArg.uiEndTime = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 18);
		stTaskArg.uiTimerTime = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 19);
		stTaskArg.uiTotalNum = atoi(szListStr);
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 20);
		stTaskArg.ucOrgFlg = atoi(szListStr);
		/////////////////////////////////////////////////////云端任务和任务参数存到数据库////////////////////////////////////////////////
		//判断任务是否存在
		BOOL bTaskExistFlg = theApp.m_pTdManager->OnlineCheckTdExist(szTdID, m_szDeSN, &dwTdID);
		if (!bTaskExistFlg)
		{
			//删掉原有任务
			/*if      (_T("VESR") == szTdName.Left(4))        { theApp.m_pTdManager->DeleteRspCETd(dwTdID); }
			else if (_T("ERIR") == szTdName.Left(4))     	{theApp.m_pTdManager->DeleteRsp2DTd(dwTdID); }
			else if (_T("ERTR") == szTdName.Left(4))		{theApp.m_pTdManager->DeleteRsp3DTd(dwTdID); }
			else if (_T("VESI") == szTdName.Left(4))		{theApp.m_pTdManager->DeleteIpspCETd(dwTdID);}
			else if (_T("ERII") == szTdName.Left(4))		{theApp.m_pTdManager->DeleteIpsp2DTd(dwTdID);}
			else if (_T("ERTI") == szTdName.Left(4))		{theApp.m_pTdManager->DeleteIpsp3DTd(dwTdID);}
			else if (_T("VESS") == szTdName.Left(4))		{theApp.m_pTdManager->DeleteSPCETd(dwTdID);  }
			else if (_T("ERIS") == szTdName.Left(4))		{theApp.m_pTdManager->DeleteSP2DTd(dwTdID);  }
			else if (_T("ERTS") == szTdName.Left(4))		{theApp.m_pTdManager->DeleteSP3DTd(dwTdID);  }*/

			//更新任务参数信息	
			theApp.m_pTdManager->OnlineSevTDListSynToDB(&stTaskArg, m_szDeSN);
		}
		else
		{
			//新建任务并插入任务参数信息
			dwTdID = theApp.m_pTdManager->OnLineImportTdHeadToDB(&stTaskArg, m_szDeSN);
		}
		/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		
		///////////////////////////////////////云端接地电阻信息存到数据库////////////////////////////////////////////////
		char chStr[2700] = { 0 };
		memcpy(chStr, &stTaskArg.ucTaskID, MAX_NAME_LEN* sizeof(BYTE));
		UINT32 uiStartElec = htonl(stTaskArg.uiStartElec); //转网络字节序给云端
		UINT32 uiEndElec = htonl(stTaskArg.uiEndElec);
		memcpy(&chStr[MAX_NAME_LEN* sizeof(BYTE)], &uiStartElec, sizeof(UINT32));
		memcpy(&chStr[MAX_NAME_LEN* sizeof(BYTE)+sizeof(UINT32)], &uiEndElec, sizeof(UINT32));
		int iSendLen = MAX_NAME_LEN * sizeof(BYTE)+2 * sizeof(UINT32);
		if (!theApp.m_NetWorkOper.SendCtrlMsgDirect(EN_REQ_DOWNLOAD_RG_INFO, 0xFFFFFFFF, 1, (char*)chStr,iSendLen))
		{
			theApp.m_NetWorkOper.SetSuspendForThread(false);
			AfxMessageBox(_T("Download task ag send failed."));
			return;
		}
		INT32 cTotalElec = (stTaskArg.uiEndElec - stTaskArg.uiStartElec + 1);
		int iRevLen = cTotalElec * sizeof(STMeasuSigGRResult) + sizeof(INT32) + MAX_NAME_LEN;
		if (EN_RECV_SUCCESS == theApp.m_NetWorkOper.RecvMsgDirect(chStr, &iLen, iRevLen, 5000))
		{
			INT32* pTotalElec = (INT32*)(&chStr[MAX_NAME_LEN]);
			INT32 chRecElenNum = ntohl(*pTotalElec);
			if ((iLen < iRevLen) || (cTotalElec  != chRecElenNum))
			{
				theApp.m_NetWorkOper.SetSuspendForThread(false);
				AfxMessageBox(_T("Download task Rg recv failed."));
				//return;
			}
			else
			{
				///////存入数据库RG表中
				if (!bTaskExistFlg)
				{
					/*for (int i = 0; i < cTotalElec; i++)
					{
						char *pData = (&chStr[sizeof(INT32) + MAX_NAME_LEN + i*sizeof(STMeasuSigGRResult)]);
						m_TaskdDBOper.UpdateGrData(dwTdID, pData, stTaskArg.stMeasuArg.ucSptType, 1);
					}*/
					m_TaskdDBOper.UpdateGrData(dwTdID, &chStr[sizeof(INT32) + MAX_NAME_LEN], stTaskArg.stMeasuArg.ucSptType, 1);
				}
				else
				{
					m_TaskdDBOper.InsertGrData(dwTdID, (DWORD)cTotalElec, &chStr[sizeof(INT32) + MAX_NAME_LEN], stTaskArg.stMeasuArg.ucSptType);
				}
			}
		}
		////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		
		//////////////////////////////////////////////云端测试点数据到数据库////////////////////////////////////////////////////////
		int i = 0;
		UINT32 uiStartPoint;
		UINT32 uiEndPoint;
		STQueryTaskBasicInfo stTaskBasicInfo;
		m_TaskdDBOper.QueryTdBasicInfo(dwTdID, &stTaskBasicInfo);
		for (i = MAX_DOWNLOCAD_POINT; i < stTaskArg.uiTotalNum; i++)
		{
			if (stTaskArg.uiTotalNum - i < MAX_DOWNLOCAD_POINT)
			{
				break;
			}

			if (i >= MAX_DOWNLOCAD_POINT && 0 != i % MAX_DOWNLOCAD_POINT)
			{
				continue;
			}
			memcpy(chStr, &stTaskArg.ucTaskID, MAX_NAME_LEN * sizeof(BYTE));
			uiStartPoint = i - MAX_DOWNLOCAD_POINT + 1;
			uiEndPoint   = i;
			UINT32 uiNetStartPoint = htonl(uiStartPoint); //转网络序给云端
			UINT32 uiNetEndPoint = htonl(uiEndPoint);
			memcpy(&chStr[MAX_NAME_LEN * sizeof(BYTE)], &uiNetStartPoint, sizeof(UINT32));
			memcpy(&chStr[MAX_NAME_LEN * sizeof(BYTE)+sizeof(UINT32)], &uiNetEndPoint, sizeof(UINT32));
			SynOlDownData(chStr, MAX_NAME_LEN * sizeof(BYTE)+2 * sizeof(UINT32), uiStartPoint, uiEndPoint, bTaskExistFlg, stTaskArg, stTaskBasicInfo.iTdChannelID);
		}
		//////少于50个点或剩余不足50个点的数据传输////
		//UINT32 uiNoSendPoint = (stTaskArg.uiTotalNum % MAX_DOWNLOCAD_POINT);
		//if (50 > stTaskArg.uiTotalNum || 0 < uiNoSendPoint)
		if (MAX_DOWNLOCAD_POINT > stTaskArg.uiTotalNum) { i = 0;}
		for (; i <= stTaskArg.uiTotalNum; i++)
		{
			memcpy(chStr, &stTaskArg.ucTaskID, MAX_NAME_LEN * sizeof(BYTE));
			uiStartPoint = i;// stTaskArg.uiTotalNum - uiNoSendPoint + 1;
			uiEndPoint = i;// stTaskArg.uiTotalNum;
			UINT32 uiNetStartPoint = htonl(uiStartPoint); //转网络序给云端
			UINT32 uiNetEndPoint = htonl(uiEndPoint);
			memcpy(&chStr[MAX_NAME_LEN * sizeof(BYTE)], &uiNetStartPoint, sizeof(UINT32));
			memcpy(&chStr[MAX_NAME_LEN * sizeof(BYTE)+sizeof(UINT32)], &uiNetEndPoint, sizeof(UINT32));
			SynOlDownData(chStr, MAX_NAME_LEN * sizeof(BYTE)+2 * sizeof(UINT32), uiStartPoint, uiEndPoint, bTaskExistFlg, stTaskArg, stTaskBasicInfo.iTdChannelID);
		}
		////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		
		/////////////////////////////////////////////刷新表格任务状态//////////////////////////////////////////////////////////////
		UINT32 uiTotalNum;
		CString szTotalNum;
		theApp.m_pTdManager->InitialTDListByOnLineForSyn(this->m_LocalTdList, this->m_szDeSN,uiTotalNum);
		szTotalNum.Format("%u",uiTotalNum);
		m_LocalTotalNum.SetWindowTextA(_T(szTotalNum));
	}
	AfxMessageBox(_T("Task download to succeed"));
	theApp.m_NetWorkOper.SetSuspendForThread(false);
}

//trust loop tasks to cloud server 
void OnLineSynTdDlg::OnBnClickedSynOlTask()
{
	CString szListStr;
	STTaskListItem stTaskArg;
	// TODO:  在此添加控件通知处理程序代码
	POSITION pos = m_SevTdList.GetFirstSelectedItemPosition();
	if (pos == NULL)
	{
		AfxMessageBox(_T("Please select Sever's list the task to trust !"));
		return;
	}

	DialUploadLoopTask * dlg;
	dlg = new DialUploadLoopTask();
	CString szDevID = m_szDeSN.Mid(2);
	dlg->m_uiGD10ID = atoi(szDevID);
	dlg->m_uiPLCID = m_uiPlcID;
	//CList<STRemTaskArg, STRemTaskArg> stTaskArglist;
	while (pos)
	{
		int nItem = m_SevTdList.GetNextSelectedItem(pos);
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 0);
		strncpy(stTaskArg.szTDName, szListStr, 60 * sizeof(BYTE));
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 2);
		strncpy(stTaskArg.szTaskID, szListStr, MAX_NAME_LEN* sizeof(BYTE));
		szListStr.Empty();
		//szListStr = m_SevTdList.GetItemText(nItem, 19);
		//stTaskArg.eSynStatus = atoi(szListStr);

		dlg->m_TaskList.AddTail(stTaskArg);
	}
	//dlg->m_stTaskArglist = stTaskArglist;
	dlg->DoModal();
}

//Synchronization loop task's parameter to local.
void OnLineSynTdDlg::OnBnClickedSynOlArg()
{
	// TODO:  在此添加控件通知处理程序代码

	char chMsgSyn[1024] = { 0 };
	char chSendStr[210] = { 0 };
	int iLen = 0;
	CString szDevID = m_szDeSN.Mid(2);
	UINT32 uiDevID = atoi(szDevID);
	UINT32 uiTaskNum = 0;
	//SYSTEMTIME sysTm;
	time_t tm;
	//GetSystemTime(&sysTm);
	int uiCurTime = (int)time(&tm);
	uiCurTime += 3600 * 8;
	int uiStartTime = uiCurTime - 30 * 24 * 3600;
	STLoopTaskTable *pstLoopTask = NULL;
	UINT32 uiLoopTaskNum = 0;
	theApp.m_NetWorkOper.SetSuspendForThread(true);

	///////////////////////////////////////////////////////同步任务列表////////////////////////////////////////////////
	uiDevID = htonl(uiDevID);
	uiCurTime = htonl(uiCurTime);
	uiStartTime = htonl(uiStartTime);
	memcpy(chSendStr, &uiDevID, sizeof(UINT32));
	memcpy(&chSendStr[sizeof(UINT32)], &uiStartTime, sizeof(UINT32));
	memcpy(&chSendStr[2 * sizeof(UINT32)], &uiCurTime, sizeof(UINT32));
	if (!theApp.m_NetWorkOper.SendCtrlMsgDirect(EN_REQ_DOWNLOAD_LOOP_TABLE, 0xFFFFFFFF, 1, chSendStr, 3 * sizeof(UINT32)))
	{
		theApp.m_NetWorkOper.SetSuspendForThread(false);
		AfxMessageBox(_T("Synchronization loop task table send failed."));
		return;
	}

	if (EN_RECV_SUCCESS == theApp.m_NetWorkOper.RecvMsgDirect(chMsgSyn, &iLen, 1023, 5000))
	{
		memcpy(&uiLoopTaskNum, chMsgSyn, sizeof(uiLoopTaskNum));
		uiLoopTaskNum = ntohl(uiLoopTaskNum);
		if (iLen < 3 && uiLoopTaskNum < 1)
		{
			AfxMessageBox(_T("Synchronization loop task table to failed. Can't find loop task."));
			theApp.m_NetWorkOper.SetSuspendForThread(false);
			return;
		}
	}

	DialLoopTaskQuery * dlg;
	dlg = new DialLoopTaskQuery();
	CString strTaskID;
	for (int i = 0; i < uiLoopTaskNum; i++)
	{
		pstLoopTask = (STLoopTaskTable*)&chMsgSyn[sizeof(uiLoopTaskNum)+i*sizeof(STLoopTaskTable)];
		strTaskID.Empty();
		strTaskID += pstLoopTask->ucTaskID;
		if (strTaskID.FindOneOf("LOOP") == -1)
		{
			continue;
		}
		pstLoopTask->uiStartTime = ntohl(pstLoopTask->uiStartTime);
		pstLoopTask->uiEndTime = ntohl(pstLoopTask->uiEndTime);
		dlg->m_szArrayLoopTaskID.Add(strTaskID);
		dlg->m_LoopTablelist.AddTail(*pstLoopTask);
	}
	dlg->DoModal();

	if (dlg->m_szArrayLoopTaskID.GetSize() <= 0)
	{
		return;
	}

	CString szTaskID;
	CStringArray szArrayID;
	STLoopTaskInfo stLoopTaskInfo;
	STLoopTaskInfo *pstLoopTaskInfo = &stLoopTaskInfo;
	char *pcTaskID = NULL;
	//for (int i = 0; i < uiLoopTaskNum; i++)
	for(int i = 0; i < dlg->m_szArrayLoopTaskID.GetSize(); i++)
	{
		//pstLoopTask = (STLoopTaskTable*)&chMsgSyn[sizeof(uiLoopTaskNum)+i*sizeof(STLoopTaskTable)];
		memcpy(pstLoopTask->ucTaskID, dlg->m_szArrayLoopTaskID.GetAt(i), sizeof(pstLoopTask->ucTaskID));
		szTaskID.Empty(); 
		szTaskID += pstLoopTask->ucTaskID;
		if (szTaskID.FindOneOf("LOOP") == -1)
		{
			continue;
		}
	    
		if (!theApp.m_NetWorkOper.SendCtrlMsgDirect(EN_REQ_DOWNLOAD_LOOP_SUB_TABLE, 0xFFFFFFFF, 1, pstLoopTask->ucTaskID, sizeof(pstLoopTask->ucTaskID)))
		{
			theApp.m_NetWorkOper.SetSuspendForThread(false);
			AfxMessageBox(_T("Synchronization loop sub task send failed."));
			return;
		}

		if (EN_RECV_SUCCESS == theApp.m_NetWorkOper.RecvMsgDirect(chMsgSyn, &iLen, 1023, 5000))
		{
			pstLoopTaskInfo = (STLoopTaskInfo *)chMsgSyn;
			if (iLen < (sizeof(STLoopTaskInfo)+pstLoopTaskInfo->uiSubTaskNum*sizeof(pstLoopTaskInfo->ucTaskID)))
			{
				AfxMessageBox(_T("Synchronization loop sub task table to failed. Receiv Length is error."));
				theApp.m_NetWorkOper.SetSuspendForThread(false);
				return;
			}

			if (0 != memcmp(pstLoopTask->ucTaskID,pstLoopTaskInfo->ucTaskID,sizeof(pstLoopTaskInfo->ucTaskID)))
			{
				AfxMessageBox(_T("Synchronization loop sub task table to failed. Receiv loop task name is error."));
				theApp.m_NetWorkOper.SetSuspendForThread(false);
				return;
			}

			//取子任务名字
			pcTaskID = (char*)&chMsgSyn[sizeof(STLoopTaskInfo)];
			for (int j = 0; j < pstLoopTaskInfo->uiSubTaskNum; j++)
			{
				szTaskID.Empty();
				pcTaskID = (char*)&pcTaskID[sizeof(char)*40*j];
				memcpy(&szTaskID, pcTaskID, sizeof(char)* 40);
				szArrayID.Add(szTaskID);
			}
			//写入数据库


			//查询子任务信息
			int iListIndex  = m_SevTdList.GetItemCount();
			UINT32 *uiRevData = NULL;
			STRemTaskArg * ptTaskArg = NULL;
			for (int j = 0; j < pstLoopTaskInfo->uiSubTaskNum; j++)
			{
				iListIndex += j;
				chSendStr[0] = 0; chSendStr[1] = 0; chSendStr[2] = 0; chSendStr[3] = 1;// uiGetNum;
				strncpy(&chSendStr[4], szArrayID.GetAt(j), MAX_NAME_LEN*sizeof(BYTE));
				int iSendLen = sizeof(UINT32)+sizeof(BYTE)*MAX_NAME_LEN;// *uiGetNum;
				if (!theApp.m_NetWorkOper.SendCtrlMsgDirect(EN_REQ_DOWNLOAD_TASK_ARG, 0xFFFFFFFF, 1, chSendStr, iSendLen))
				{
					theApp.m_NetWorkOper.SetSuspendForThread(false);
					AfxMessageBox(_T("Synchronization task arguments send failed."));
					return;
				}

				if (EN_RECV_SUCCESS == theApp.m_NetWorkOper.RecvMsgDirect(chMsgSyn, &iLen, 1000, 5000))
				{
					uiRevData = (UINT32*)(chMsgSyn);
					UINT32 uiRevDataNum = ntohl(uiRevData[0]);
					if ((uiRevDataNum < 1) || (iLen < (sizeof(UINT32)+uiRevDataNum * sizeof(STRemTaskArg))))
					{
						theApp.m_NetWorkOper.SetSuspendForThread(false);
						return;
					}
					ptTaskArg = (STRemTaskArg *)(chMsgSyn + sizeof(UINT32));
					int iIndex = (int)VAL_ZERO;
					CString str;
					for (iIndex = 0; iIndex < uiRevDataNum; iIndex++)
					{
						ptTaskArg[iIndex].stMeasuArg.iSAInterval = ntohl(ptTaskArg[iIndex].stMeasuArg.iSAInterval);
						//ptTaskArg[iIndex].stMeasuArg.fElecSpace = tcp_ntohf(ptTaskArg[iIndex].stMeasuArg.fElecSpace);
						ptTaskArg[iIndex].uiStartElec = ntohl(ptTaskArg[iIndex].uiStartElec);
						ptTaskArg[iIndex].uiEndElec = ntohl(ptTaskArg[iIndex].uiEndElec);
						ptTaskArg[iIndex].uiStartLayer = ntohl(ptTaskArg[iIndex].uiStartLayer);
						ptTaskArg[iIndex].uiEndLayer = ntohl(ptTaskArg[iIndex].uiEndLayer);
						ptTaskArg[iIndex].uiStartTime = ntohl(ptTaskArg[iIndex].uiStartTime);
						ptTaskArg[iIndex].uiEndTime = ntohl(ptTaskArg[iIndex].uiEndTime);
						ptTaskArg[iIndex].uiTimerTime = ntohl(ptTaskArg[iIndex].uiTimerTime);
						ptTaskArg[iIndex].uiTotalNum = ntohl(ptTaskArg[iIndex].uiTotalNum);

						time_t tmTime = ptTaskArg[iIndex].uiStartTime;
						CString szTimeStart = Tm2GmtStr(tmTime);
						//szTimeStart.Format(_T("%d-%d-%d %d:%d:%d"), p->tm_year + 1900, p->tm_mon + 1, p->tm_mday, p->tm_hour,p->tm_min,p->tm_sec);

						tmTime = ptTaskArg[iIndex].uiEndTime;
						CString szTimeEnd = Tm2GmtStr(tmTime);
						//p = localtime(&tmTime);
						//szTimeStart.Format(_T("%d-%d-%d %d:%d:%d"), p->tm_year + 1900, p->tm_mon + 1, p->tm_mday, p->tm_hour, p->tm_min, p->tm_sec);

						tmTime = ptTaskArg[iIndex].uiTimerTime;
						CString szTimeTimer = Tm2GmtStr(tmTime);
						//p = localtime(&tmTime);
						//szTimeStart.Format(_T("%d-%d-%d %d:%d:%d"), p->tm_year + 1900, p->tm_mon + 1, p->tm_mday, p->tm_hour, p->tm_min, p->tm_sec);
						m_SevTdList.InsertItem(i, _T(""));
						m_SevTdList.SetItemText(iIndex + iListIndex, 0, (LPCTSTR)(_bstr_t)ptTaskArg[iIndex].ucTDName);
						m_SevTdList.SetItemText(iIndex + iListIndex, 1, (LPCTSTR)(_bstr_t)_T("LOOP"));
						m_SevTdList.SetItemText(iIndex + iListIndex, 2, (LPCTSTR)(_bstr_t)szArrayID.GetAt(j));
						m_SevTdList.SetItemText(iIndex + iListIndex, 3, (LPCTSTR)(_bstr_t)ptTaskArg[iIndex].ucSciptName);
						m_SevTdList.SetItemText(iIndex + iListIndex, 4, (LPCTSTR)(_bstr_t)ptTaskArg[iIndex].stMeasuArg.ucTestType);
						m_SevTdList.SetItemText(iIndex + iListIndex, 5, (LPCTSTR)(_bstr_t)ptTaskArg[iIndex].stMeasuArg.ucTxPeriod);
						m_SevTdList.SetItemText(iIndex + iListIndex, 6, (LPCTSTR)(_bstr_t)ptTaskArg[iIndex].stMeasuArg.ucArrayType);
						m_SevTdList.SetItemText(iIndex + iListIndex, 7, (LPCTSTR)(_bstr_t)ptTaskArg[iIndex].stMeasuArg.ucCableLayout);
						m_SevTdList.SetItemText(iIndex + iListIndex, 8, (LPCTSTR)(_bstr_t)ptTaskArg[iIndex].stMeasuArg.ucStacking);
						str.Empty(); str.Format(_T("%u"),ptTaskArg[iIndex].stMeasuArg.iSAInterval);
						m_SevTdList.SetItemText(iIndex + iListIndex, 9, (LPCTSTR)(_bstr_t)str);
						m_SevTdList.SetItemText(iIndex + iListIndex, 10, (LPCTSTR)(_bstr_t)ptTaskArg[iIndex].stMeasuArg.ucSptType);
						//m_SevTdList.SetItemText(iIndex + iListIndex, 11, (LPCTSTR)(_bstr_t)ptTaskArg[iIndex].stMeasuArg.fElecSpace);
						str.Empty(); str.Format(_T("%u"),ptTaskArg[iIndex].uiStartElec);
						m_SevTdList.SetItemText(iIndex + iListIndex, 12, (LPCTSTR)(_bstr_t)str);
						str.Empty(); str.Format(_T("%u"),ptTaskArg[iIndex].uiEndElec);
						m_SevTdList.SetItemText(iIndex + iListIndex, 13, (LPCTSTR)(_bstr_t)str);
						str.Empty(); str.Format(_T("%u"),ptTaskArg[iIndex].uiStartLayer);
						m_SevTdList.SetItemText(iIndex + iListIndex, 14, (LPCTSTR)(_bstr_t)str);
						str.Empty(); str.Format(_T("%u"),ptTaskArg[iIndex].uiEndLayer);
						m_SevTdList.SetItemText(iIndex + iListIndex, 15, (LPCTSTR)(_bstr_t)str);
						m_SevTdList.SetItemText(iIndex + iListIndex, 16, (LPCTSTR)(_bstr_t)szTimeStart);
						m_SevTdList.SetItemText(iIndex + iListIndex, 17, (LPCTSTR)(_bstr_t)szTimeEnd);
						m_SevTdList.SetItemText(iIndex + iListIndex, 18, (LPCTSTR)(_bstr_t)szTimeTimer);
						str.Empty(); str.Format(_T("%u"),ptTaskArg[iIndex].uiTotalNum);
						m_SevTdList.SetItemText(iIndex + iListIndex, 19, (LPCTSTR)(_bstr_t)str);
						m_SevTdList.SetItemText(iIndex + iListIndex, 20, (LPCTSTR)(_bstr_t)ptTaskArg[iIndex].ucOrgFlg);
					}
				}
			}
		}
	}
	dlg->m_szArrayLoopTaskID.RemoveAll();
	theApp.m_NetWorkOper.SetSuspendForThread(false);
}

//Cancel loop tasks 
void OnLineSynTdDlg::OnBnClickedSynOlDate()
{
	// TODO:  在此添加控件通知处理程序代码
	char chMsgSyn[4000] = { 0 };
	char chSendStr[50] = { 0 };
	int iLen = 0;
	CString szDevID = m_szDeSN.Mid(2);
	UINT32 uiDevID = atoi(szDevID);
	UINT32 uiTaskNum = 0;
	//SYSTEMTIME sysTm;
	time_t tm;
	//GetSystemTime(&sysTm);
	int uiCurTime = (int)time(&tm);
	uiCurTime += 3600 * 8;
	int uiStartTime = uiCurTime - 30 * 24 * 3600;
	STLoopTaskTable *pstLoopTask = NULL;
	UINT32 uiLoopTaskNum = 0;

	if (NULL == chMsgSyn)
	{
		AfxMessageBox(_T("There is not enough available memory."));
		return;
	}

	theApp.m_NetWorkOper.SetSuspendForThread(true);

	///////////////////////////////////////////////////////同步任务列表////////////////////////////////////////////////
	uiDevID = htonl(uiDevID);
	uiCurTime = htonl(uiCurTime);
	uiStartTime = htonl(uiStartTime);
	memcpy(chSendStr, &uiDevID, sizeof(UINT32));
	memcpy(&chSendStr[sizeof(UINT32)], &uiStartTime, sizeof(UINT32));
	memcpy(&chSendStr[2 * sizeof(UINT32)], &uiCurTime, sizeof(UINT32));
	if (!theApp.m_NetWorkOper.SendCtrlMsgDirect(EN_REQ_DOWNLOAD_LOOP_TABLE, 0xFFFFFFFF, 1, chSendStr, 3 * sizeof(UINT32)))
	{
		theApp.m_NetWorkOper.SetSuspendForThread(false);
		AfxMessageBox(_T("Synchronization loop task table send failed."));
		return;
	}

	if (EN_RECV_SUCCESS == theApp.m_NetWorkOper.RecvMsgDirect(chMsgSyn, &iLen, sizeof(chMsgSyn), 5000))
	{
		memcpy(&uiLoopTaskNum, chMsgSyn, sizeof(uiLoopTaskNum));
		uiLoopTaskNum = ntohl(uiLoopTaskNum);
		if (iLen < 3 && uiLoopTaskNum < 1)
		{
			AfxMessageBox(_T("Synchronization loop task table to failed. Can't find loop task."));
			theApp.m_NetWorkOper.SetSuspendForThread(false);
			return;
		}
	}

	CString szTaskID;
	CStringArray szArrayID;
	//STLoopTaskInfo *pstLoopTaskInfo;
	DialLoopTaskCancel * dlg;
	dlg = new DialLoopTaskCancel();

	//CList<STLoopTaskTable,STLoopTaskTable> LoopTablelist;
	char *pcTaskID = NULL;
	for (int i = 0; i < uiLoopTaskNum; i++)
	{
		pstLoopTask = (STLoopTaskTable*)&chMsgSyn[sizeof(uiLoopTaskNum)+i*sizeof(STLoopTaskTable)];
		szTaskID.Empty();
		szTaskID += pstLoopTask->ucTaskID;
		if (szTaskID.FindOneOf("LOOP") == -1)
		{
			continue;
		}
		pstLoopTask->uiStartTime = ntohl(pstLoopTask->uiStartTime);
		pstLoopTask->uiEndTime = ntohl(pstLoopTask->uiEndTime);
		//pstLoopTask->ucTaskName
		//LoopTablelist.AddTail(*pstLoopTask);
		dlg->m_LoopTablelist.AddTail(*pstLoopTask);
	}
	
	//dlg->m_LoopTablelist = LoopTablelist;
	dlg->DoModal();
}

//void OnLineSynTdDlg::TrusteeLocalTaskToSev(int iListItm)
//{
//	// TODO:  在此添加控件通知处理程序代码
//	CString szListStr = "";
//	STTrusteeTaskTable stTaskTable;
//	char chStr[20] = { 0 };
//	char chTaskID[41] = { 0 };
//	int iLen = 0;
//	theApp.m_NetWorkOper.SetSuspendForThread(true);
//
//	CString szDevSN = m_szDeSN;
//	UINT32 uiDevID = htonl(atoi(szDevSN.Mid(2)));
//	stTaskTable.uiGD10Id = uiDevID;
//	stTaskTable.uiPlcId = htonl(m_uiPlcID);
//	stTaskTable.ucTeatMode = EN_MANUAL_TASK;
//	//while (pos)
//	{
//		int nItem = iListItm;
//		CString szTaskStatus = m_LocalTdList.GetItemText(nItem, 1);
//		if (szTaskStatus != "")
//		{
//			AfxMessageBox(_T("Task trustee to failed! The task has been uploaded, whether the server data has been overwritten"));
//			return;
//		}
//
//		if (EN_MANUAL_TASK == stTaskTable.ucTeatMode)
//		{
//			szListStr.Empty();
//			szListStr = m_LocalTdList.GetItemText(nItem, 2);
//			strncpy(stTaskTable.Task.stManualTask.ucTaskID, szListStr, MAX_NAME_LEN * sizeof(BYTE));
//			stTaskTable.Task.stManualTask.uiStartPoint = htonl(1);
//			szListStr.Empty();
//			szListStr = m_LocalTdList.GetItemText(nItem, 19);
//			stTaskTable.Task.stManualTask.uiEndPoint = htonl(atoi(szListStr));
//
//			if (!theApp.m_NetWorkOper.SendCtrlMsgDirect(EN_REQ_COLLOCATION, 0xFFFFFFFF, 1, (char*)&stTaskTable, sizeof(STTrusteeTaskTable)))
//			{
//				theApp.m_NetWorkOper.SetSuspendForThread(false);
//				AfxMessageBox(_T("Download task ag send failed."));
//				return;
//			}
//			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);
//					CString szMsg;
//					szMsg.Format(_T("Task '%s' trustee to failed."), stTaskTable.Task.stManualTask.ucTaskID);
//					AfxMessageBox(szMsg);
//					return;
//				}
//			}
//		}
//		else if (EN_TIMER_TASK == stTaskTable.ucTeatMode)
//		{
//			time_t tm;
//			int uiTime = htonl((int)time(&tm));
//			stTaskTable.Task.stTimerTask.uiCurTime = uiTime;
//			stTaskTable.Task.stTimerTask.uiTaksNum = htonl(1);
//			stTaskTable.Task.stTimerTask.ucTimerType = 0;
//			stTaskTable.Task.stTimerTask.ucLoopNum = 0;
//			stTaskTable.Task.stTimerTask.uiTaskInterval = 0;
//
//			szListStr.Empty();
//			szListStr = m_LocalTdList.GetItemText(nItem, 2);
//			strncpy(chTaskID, szListStr, MAX_NAME_LEN * sizeof(BYTE));
//			stTaskTable.Task.stTimerTask.ucTaskID = chTaskID;
//
//			if (!theApp.m_NetWorkOper.SendCtrlMsgDirect(EN_REQ_COLLOCATION, 0xFFFFFFFF, 1, (char*)&stTaskTable, sizeof(STTrusteeTaskTable)))
//			{
//				theApp.m_NetWorkOper.SetSuspendForThread(false);
//				AfxMessageBox(_T("Download task ag send failed."));
//				return;
//			}
//			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);
//					CString szMsg;
//					szMsg.Format(_T("Task '%s' trustee to failed."), stTaskTable.Task.stManualTask.ucTaskID);
//					AfxMessageBox(szMsg);
//					return;
//				}
//			}
//		}
//	}
//	AfxMessageBox(_T("Task trustee to succeed"));
//	theApp.m_NetWorkOper.SetSuspendForThread(false);
//}

void OnLineSynTdDlg::OnBnClickedSynOlTrustee()
{
	// TODO:  在此添加控件通知处理程序代码

	//TrusteeLocalTaskToSev(nItem);

	CString szListStr = "";
	STTrusteeTaskTable stTaskTable;
	char chStr[20] = {0};
	char chTaskName[40] = { 0 };
	int iLen = 0;
	POSITION pos = m_SevTdList.GetFirstSelectedItemPosition();
	UINT32 uiTaskNum = 0;

	if (pos == NULL)
	{
		AfxMessageBox(_T("Please select Sever's list the task to upload !"));
		return;
	}
	theApp.m_NetWorkOper.SetSuspendForThread(true);
	
	CString szDevSN = m_szDeSN;
	UINT32 uiDevID = htonl(atoi(szDevSN.Mid(2)));
	stTaskTable.uiGD10Id = uiDevID;
	stTaskTable.uiPlcId = htonl(m_uiPlcID);
	while (pos)
	{
		int nItem = m_SevTdList.GetNextSelectedItem(pos);
		CString szTaskStatus = m_SevTdList.GetItemText(nItem, 1);
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 2);
		BYTE ucSevTaskState = ReturnServerTaskState(szListStr);
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 0);
		CString szTaskName = szListStr;
		if (0)//EN_TASK_STATE_NO_TRUST != ucSevTaskState)
		{
			CString szStrMsg;
    		if (EN_TASK_STATE_FINISH != ucSevTaskState)
			{

				szStrMsg.Empty();
				szStrMsg.Format(_T("Task %s has been managed at server! Can't trust again!"), szTaskName);
				AfxMessageBox(szStrMsg);
				continue;
			}
			else
			{
				szStrMsg.Empty();
				szStrMsg.Format(_T("Task %s has been finished at server!!whether test again and overwrite?"), szTaskName);
				if (IDYES != ::MessageBox(NULL, szStrMsg, "Notice", MB_YESNO))
				{
					continue;
				}
			}
		}
		//判断是否手动任务
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 18);
		CString szTimerStr = szListStr;
		UINT32 uiTimerTime = Str2GmtTm(szListStr); //Str2LocalTm(szListStr);
		time_t tm;
		UINT32 uiCurTime =(UINT32)time(&tm);
		if (uiTimerTime > uiCurTime) //大于当前时间秒才认为是定时任务，未设置或者时间失效的都为手动任务
		{
			stTaskTable.ucTeatMode = EN_TIMER_TASK;
		}
		else
		{
			if (uiTimerTime > 0)//定时任务已过现有时间
			{
				szListStr.Empty();
				szListStr.Format(_T("Timing task[%s]'s time[%s] has overtime. Whether retest and overlay existing data?"), szTaskName, szTimerStr);
				if (IDYES != ::MessageBox(NULL, szListStr, "Notice", MB_YESNO))
				{
					continue;
				}
			}
			stTaskTable.ucTeatMode = EN_MANUAL_TASK;
		}

		if (1) //EN_MANUAL_TASK == stTaskTable.ucTeatMode)
		{
			szListStr.Empty();
			szListStr = m_SevTdList.GetItemText(nItem, 2);
			strncpy(stTaskTable.Task.stManualTask.ucTaskID, szListStr, MAX_NAME_LEN * sizeof(BYTE));
			stTaskTable.Task.stManualTask.uiStartPoint = htonl(1);
			szListStr.Empty();
			szListStr = m_SevTdList.GetItemText(nItem, 19);
			stTaskTable.Task.stManualTask.uiEndPoint = htonl(atoi(szListStr));
			
			if (!theApp.m_NetWorkOper.SendCtrlMsgDirect(EN_REQ_COLLOCATION, 0xFFFFFFFF, 1, (char*)&stTaskTable, sizeof(STTrusteeTaskTable)))
			{
				theApp.m_NetWorkOper.SetSuspendForThread(false);
				AfxMessageBox(_T("Trust task info send failed."));
				return;
			}
			if (EN_RECV_SUCCESS == theApp.m_NetWorkOper.RecvMsgDirect(chStr, &iLen, 10, 5000))
			{
				if ((iLen < iLen) || (EN_RECV_SUCCESS != chStr[0]))
				{
					theApp.m_NetWorkOper.SetSuspendForThread(false);
					CString szMsg;
					szMsg.Format(_T("Task '%s' trustee to failed."), stTaskTable.Task.stManualTask.ucTaskID);
					AfxMessageBox(szMsg);
					return;
				}
			}				
		}
		//else if (EN_TIMER_TASK == stTaskTable.ucTeatMode)
		//{
		//	stTaskTable.Task.stTimerTask.uiCurTime = htonl(uiCurTime);
		//	stTaskTable.Task.stTimerTask.uiTaksNum = htonl(1);
		//	stTaskTable.Task.stTimerTask.ucTimerType = 0;
		//	stTaskTable.Task.stTimerTask.ucLoopNum = 0;
		//	stTaskTable.Task.stTimerTask.uiTaskInterval = 0;

		//	szListStr.Empty();
		//	szListStr = m_SevTdList.GetItemText(nItem, 2);
		//	//strncpy(chTaskName, szListStr, MAX_NAME_LEN * sizeof(BYTE));
		//	strncpy(stTaskTable.Task.stTimerTask.ucTaskID, szListStr, MAX_NAME_LEN * sizeof(BYTE));
		//	uiTaskNum = 1;
		//	int iLen = sizeof(STTrusteeTaskTable);
		//	if (!theApp.m_NetWorkOper.SendCtrlMsgDirect(EN_REQ_COLLOCATION, 0xFFFFFFFF, 1, (char*)&stTaskTable, iLen))
		//	{
		//		theApp.m_NetWorkOper.SetSuspendForThread(false);
		//		AfxMessageBox(_T("Trust task info send failed."));
		//		return;
		//	}
		//	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);
		//			CString szMsg;
		//			szMsg.Format(_T("Task '%s' trustee to failed."), szTaskName);
		//			AfxMessageBox(szMsg);
		//			return;
		//		}
		//	}
		//}
	}
	AfxMessageBox(_T("Task trustee to finished"));
	theApp.m_NetWorkOper.SetSuspendForThread(false);
}

#define MAX_SEND_POINT_NUM  (10)   //一次最多传输数据点
bool OnLineSynTdDlg::UploadRes2DData(char *cTaskName)
{
	_RecordsetPtr pRecTd = NULL;
	CString szSql = _T("");
	UINT32 dwTDID;  //任务ID
	UINT32 dwTDChId; //任务通道数据ID
	STTaskDataRes stTaskDataRes; //一次传15个点
	STSynTaskDataRes stSynTask;
	char chSendstr[MAX_NAME_LEN * sizeof(BYTE)+sizeof(UINT32)+sizeof(STTaskDataRes)*MAX_SEND_POINT_NUM] = { 0 };
	char chMsgSyn[10] = { 0 };
	INT32 iLen = 0;
	UINT32 uiTotalNum = 0;
	int iDataStart = MAX_NAME_LEN * sizeof(BYTE)+sizeof(UINT32);

	memcpy(stSynTask.ucTaskID, cTaskName, sizeof(stSynTask.ucTaskID));
	stSynTask.dwPointNum = MAX_SEND_POINT_NUM;
	stSynTask.dwPointNum = htonl(stSynTask.dwPointNum);
	//stSynTask.ptTaskData = stTaskDataRes;
	memcpy(chSendstr,&stSynTask, sizeof(STSynTaskDataRes));

	pRecTd.CreateInstance(_uuidof(Recordset));
	
	szSql.Empty();
	szSql.Format(_T("select ID,TPamount from td where TDCN = '%s'"), cTaskName);
	pRecTd->Open(szSql.AllocSysString(), _variant_t((IDispatch*)m_pConnection, true), adOpenStatic, adLockOptimistic, adCmdText);
	if (!pRecTd->adoEOF)
	{
		uiTotalNum = pRecTd->GetCollect(_T("TPamount")).iVal;
		dwTDID = pRecTd->GetCollect(_T("ID")).iVal;
	}
	pRecTd->Close();

	szSql.Empty();
	szSql.Format(_T("select ID from tdchannel where TDID = %u"), dwTDID);
	pRecTd->Open(szSql.AllocSysString(), _variant_t((IDispatch*)m_pConnection, true), adOpenStatic, adLockOptimistic, adCmdText);
	if (!pRecTd->adoEOF)
	{
		dwTDChId = pRecTd->GetCollect(_T("ID")).iVal;
	}
	pRecTd->Close();

	_RecordsetPtr pRecConList = NULL;
	pRecConList.CreateInstance(_uuidof(Recordset));

	szSql.Empty();
	szSql.Format(_T("select TSN,C1,C2,P1,P2,N,K,I,V,R0,SP,R0_LC from td2dcon where TCHID = %u"), dwTDChId);
	try
	{
		pRecConList->Open(szSql.AllocSysString(), _variant_t((IDispatch*)m_pConnection, true), adOpenStatic, adLockOptimistic, adCmdText);
	}
	catch (_com_error e)
	{
		AfxMessageBox((LPCTSTR)e.Description());
	}

	try
	{
		CString strDBVal = _T("");
		float fV = 0, fI = 0, fR = 0;
		UINT32 iSendLen = 0;
		int iIndex = (int)VAL_ZERO;
		int i=0;
		while ((short)VAL_ZERO == pRecConList->adoEOF)
		{
			stTaskDataRes.dwID = (UINT32)pRecConList->GetCollect(_T("TSN")).uintVal;
			stTaskDataRes.fA = (float)pRecConList->GetCollect(_T("C1")).iVal;//一维请用.fltVal
			stTaskDataRes.fB = (float)pRecConList->GetCollect(_T("C2")).iVal;
			stTaskDataRes.fM = (float)pRecConList->GetCollect(_T("P1")).iVal;
			stTaskDataRes.fN = (float)pRecConList->GetCollect(_T("P2")).iVal;
			stTaskDataRes.fK = (float)pRecConList->GetCollect(_T("K")).fltVal;
			stTaskDataRes.ucStack = (BYTE)pRecConList->GetCollect(_T("N")).bVal;
			stTaskDataRes.fV = (float)pRecConList->GetCollect(_T("V")).fltVal;
			stTaskDataRes.fI = (float)pRecConList->GetCollect(_T("I")).fltVal;
			stTaskDataRes.fR0 = (float)pRecConList->GetCollect(_T("R0")).fltVal;
			stTaskDataRes.fSP = (float)pRecConList->GetCollect(_T("SP")).fltVal;
			stTaskDataRes.ucAlram = 0;// (BYTE)pRecConList->GetCollect(_T("N")).bVal;  //未存数据库
			stTaskDataRes.fR0_LC = (float)pRecConList->GetCollect(_T("R0_LC")).fltVal;
			
			iSendLen = MAX_NAME_LEN * sizeof(BYTE)+sizeof(UINT32)+sizeof(STTaskDataRes)*MAX_SEND_POINT_NUM;//sizeof(STTaskDataRes);
			stTaskDataRes.dwID = htonl(stTaskDataRes.dwID);
			stTaskDataRes.fA = tcp_htonf(stTaskDataRes.fA);
			stTaskDataRes.fB = tcp_htonf(stTaskDataRes.fB);
			stTaskDataRes.fM = tcp_htonf(stTaskDataRes.fM);
			stTaskDataRes.fN = tcp_htonf(stTaskDataRes.fN);
			stTaskDataRes.fK = tcp_htonf(stTaskDataRes.fK);
			stTaskDataRes.fV = tcp_htonf(stTaskDataRes.fV);
			stTaskDataRes.fI = tcp_htonf(stTaskDataRes.fI);
			stTaskDataRes.fR0 = tcp_htonf(stTaskDataRes.fR0);
			stTaskDataRes.fSP = tcp_htonf(stTaskDataRes.fSP);
			stTaskDataRes.fR0_LC = tcp_htonf(stTaskDataRes.fR0_LC);
			memcpy(&chSendstr[iDataStart + i*sizeof(STTaskDataRes)], &stTaskDataRes, sizeof(STTaskDataRes));
			
			i = (iIndex+1)%MAX_SEND_POINT_NUM;
			if ((uiTotalNum >= MAX_SEND_POINT_NUM) && (0 == i))
			{
				//填写数据
				//memcpy(chSend, &stSynTask, MAX_NAME_LEN * sizeof(BYTE)+sizeof(UINT32));
				//memcpy(chSend, &stTaskDataRes, sizeof(stTaskDataRes));

				if (!theApp.m_NetWorkOper.SendCtrlMsgDirect(EN_UPLOAD_DATA_INF, 0xFFFFFFFF, 1, (char*)chSendstr, iSendLen))
				{
					theApp.m_NetWorkOper.SetSuspendForThread(false);
					AfxMessageBox(_T("Upload task data send failed."));
					return FALSE;
				}

				if (EN_RECV_SUCCESS == theApp.m_NetWorkOper.RecvMsgDirect(chMsgSyn, &iLen, sizeof(chMsgSyn), 5000))
				{
					if ((iLen != sizeof(BYTE)) || (EN_RECV_SUCCESS != chMsgSyn[0]))
					{
						theApp.m_NetWorkOper.SetSuspendForThread(false);
						AfxMessageBox(_T("Upload task data replay failed."));
						return FALSE;
					}
				}
			}
			if (uiTotalNum <= iIndex)
			{
				break;
			}
			iIndex++;
			pRecConList->MoveNext();
		}
		//小于15个点的数发送
		if ((uiTotalNum  < MAX_SEND_POINT_NUM) || (1 < i))
		{
			stSynTask.dwPointNum = i;
			stSynTask.dwPointNum = htonl(stSynTask.dwPointNum);
			memcpy(chSendstr, &stSynTask, iDataStart);
			iSendLen = MAX_NAME_LEN * sizeof(BYTE)+sizeof(UINT32)+sizeof(STTaskDataRes)*i;
			if (!theApp.m_NetWorkOper.SendCtrlMsgDirect(EN_UPLOAD_DATA_INF, 0xFFFFFFFF, 1, (char*)chSendstr, iSendLen))
			{
				theApp.m_NetWorkOper.SetSuspendForThread(false);
				AfxMessageBox(_T("Upload task data send failed."));
				return FALSE;
			}

			if (EN_RECV_SUCCESS == theApp.m_NetWorkOper.RecvMsgDirect(chMsgSyn, &iLen, sizeof(chMsgSyn), 5000))
			{
				if ((iLen != sizeof(BYTE)) || (EN_RECV_SUCCESS != chMsgSyn[0]))
				{
					theApp.m_NetWorkOper.SetSuspendForThread(false);
					AfxMessageBox(_T("Upload task data replay failed."));
					return FALSE;
				}
			}
		}
	}
	catch (_com_error e)
	{
		AfxMessageBox(e.Description());
	}
	pRecConList->Close();
	return true;
}


void OnLineSynTdDlg::OnBnClickedButtonDel()
{
	// TODO:  在此添加控件通知处理程序代码
	CString szListStr = "";
	char chStr[20] = { 0 };
	char chSendStr[MAX_NAME_LEN +1] = { 0 };
	int iLen = 0;
	POSITION pos = m_SevTdList.GetFirstSelectedItemPosition();
	if (pos == NULL)
	{
		AfxMessageBox(_T("Please select Sever's list the task to delete !"));
		return;
	}
	theApp.m_NetWorkOper.SetSuspendForThread(true);

	//CString szDevSN = m_szDeSN;
	//UINT32 uiDevID = htonl(atoi(szDevSN.Mid(2)));
	//memcpy(chSendStr, &uiDevID, sizeof(UINT32));
	while (pos)
	{
		int nItem = m_SevTdList.GetNextSelectedItem(pos);
		CString szTaskStatus = m_SevTdList.GetItemText(nItem, 1);
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 2);
		strncpy(chSendStr, szListStr, MAX_NAME_LEN * sizeof(BYTE));

		BYTE ucSevTaskState = ReturnServerTaskState(szListStr);
		/*if (EN_TASK_STATE_NO_TRUST != ucSevTaskState)
		{
			CString szStrMsg;
			szListStr.Empty();
			szListStr = m_LocalTdList.GetItemText(nItem, 0);
			szStrMsg.Empty();
			szStrMsg.Format(_T("Task %s was trust at server! Can't delete! please cancal trust task at first!"), szListStr);
			AfxMessageBox(szStrMsg);
			continue;
		}

		if (EN_TASK_STATE_TESTING == ucSevTaskState)
		{
			CString szStrMsg;
			szListStr.Empty();
			szListStr = m_LocalTdList.GetItemText(nItem, 0);
			szStrMsg.Empty();
			szStrMsg.Format(_T("Task %s was testing at server! Can't cancel trust!Cancel,please stop task at first!"), szListStr);
			AfxMessageBox(szStrMsg);
			continue;
		}
		*/
		if (!theApp.m_NetWorkOper.SendCtrlMsgDirect(EN_REQ_TASK_DEL, 0xFFFFFFFF, 1, (char*)chSendStr, MAX_NAME_LEN))
		{
			theApp.m_NetWorkOper.SetSuspendForThread(false);
			AfxMessageBox(_T("Msg delete task send failed."));
			return;
		}
		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);
				CString szMsg;
				szMsg.Format(_T("Task '%s' delete to failed."), szListStr);
				AfxMessageBox(szMsg);
				return;
			}
		}
	}
	AfxMessageBox(_T("Task delete to succeed"));
	theApp.m_NetWorkOper.SetSuspendForThread(false);
}


void OnLineSynTdDlg::OnBnClickedSynOlNoTrust()
{
	// TODO:  在此添加控件通知处理程序代码
	CString szListStr = "";
	char chStr[20] = { 0 };
	char chSendStr[MAX_NAME_LEN + sizeof(UINT32)+1] = { 0 };
	int iLen = 0;
	POSITION pos = m_SevTdList.GetFirstSelectedItemPosition();
	if (pos == NULL)
	{
		AfxMessageBox(_T("Please select Sever's list the task to cacal trust !"));
		return;
	}
	theApp.m_NetWorkOper.SetSuspendForThread(true);

	/*CString szDevSN = m_szDeSN;
	UINT32 uiDevID = htonl(atoi(szDevSN.Mid(2)));
	memcpy(chSendStr, &uiDevID, sizeof(UINT32));*/
	while (pos)
	{
		int nItem = m_SevTdList.GetNextSelectedItem(pos);
		CString szTaskStatus = m_SevTdList.GetItemText(nItem, 1);
		szListStr.Empty();
		szListStr = m_SevTdList.GetItemText(nItem, 2);
		strncpy(chSendStr, szListStr, MAX_NAME_LEN * sizeof(BYTE));

		BYTE ucSevTaskState = ReturnServerTaskState(szListStr);
		if (EN_TASK_STATE_NO_TRUST == ucSevTaskState)
		{
			AfxMessageBox(_T("Task don't trust."));
			continue;
		}

		//if (EN_TASK_STATE_FINISH == ucSevTaskState)
		//{
		//	CString szStrMsg;
		//	szListStr.Empty();
		//	szListStr = m_LocalTdList.GetItemText(nItem, 0);
		//	szStrMsg.Empty();
		//	szStrMsg.Format(_T("Task %s has finished at server! Can't cancel trust!"), szListStr);
		//	AfxMessageBox(szStrMsg);
		//	continue;
		//}

		//if (EN_TASK_STATE_TESTING == ucSevTaskState)
		//{
		//	CString szStrMsg;
		//	szListStr.Empty();
		//	szListStr = m_LocalTdList.GetItemText(nItem, 0);
		//	szStrMsg.Empty();
		//	szStrMsg.Format(_T("Task %s was testing at server! Can't cancel trust!Cancel,please stop task at first!"), szListStr);
		//	AfxMessageBox(szStrMsg);
		//	continue;
		//}

		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."));
			return;
		}
		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);
				CString szMsg;
				szMsg.Format(_T("Task '%s' cancel trustee to failed."), szListStr);
				AfxMessageBox(szMsg);
				return;
			}
		}
	}
	AfxMessageBox(_T("Task cancel trustee to succeed"));
	theApp.m_NetWorkOper.SetSuspendForThread(false);
}