// DlgBurn.cpp : implementation file
//

#include "stdafx.h"
#include "udpadmintool.h"
#include "DlgBurn.h"

#include <direct.h>		// _chdir()
#include <io.h>		// _access()
#include <process.h>

#include "./util_source/util.hpp"
#include "./util_source/util_path.hpp"

#include "util_local.h"


#include "UDPAdminToolDlg.h"
#include "common.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#define LOG(MSG, COLOR)	mm.msg = (MSG); mm.color = (COLOR); SendMessage(WM_BURN_STATUS, eLog, (LPARAM)&mm)
#define TOTAL_LOG(info, rsOcx, rsWeb, rsFW, rsBL) log.info = &info; log.bProtect = FALSE; log.bRsOCX = rsOcx; log.bRsWeb = bRsWeb; log.bRsFW = bRsFW; log.bRsBL = bRsBL; SendMessage(WM_BURN_STATUS, eTotalLog, (LPARAM)&log)
#define TOTAL_LOG_PROTECT(info, rsProtect) log.info = &info; log.bProtect = TRUE; log.bRsProtect = rsProtect; SendMessage(WM_BURN_STATUS, eTotalLog, (LPARAM)&log)
#define RED		RGB(255,0,0)
#define BLUE	RGB(0,0,255)
#define BLACK	RGB(0,0,0)
#define GREEN	RGB(0,155,0)

#define ITEM_INDEX_PKG		4
#define ITEM_INDEX_OCX		4
#define ITEM_INDEX_WEB		5
#define ITEM_INDEX_FW		6
#define ITEM_INDEX_BL		7

struct Msg {
	CString ip;
	CString msg;
	int color;
};

struct TotalLog {
	ClientInformation* info;
	BOOL bProtect;
	BOOL bRsOCX;
	BOOL bRsWeb;
	BOOL bRsFW;
	BOOL bRsBL;
	BOOL bRsProtect;
	int iIndex;
	BOOL bUpdateFW;
	BOOL bUpdateBL;
};

struct ListDeviceItem {
	ClientInformation* info;
	int nIndex;
	BOOL bUpdateFW;
	BOOL bUpdateBL;
};

struct ItemInfo {
	int nIndex;
	char szName[32];
};

// 2007-05-15 18:44:20 ÇüÅÂÀÇ ¹®ÀÚ¿­·Î ¹Ýȯ
CString str_time()
{
	CTime tt = CTime::GetCurrentTime();

	return tt.Format("%Y-%m-%d %H:%M:%S");
}

void emul_progress(CTextProgressCtrl& prog, int sleep = 10)
{

// update ui
// ÇÁ·Î±×·¡½º¹Ù ¿¡¹Ä·¹À̼Ç
	int lo, hi;
	prog.GetRange(lo, hi);

	for(int i = prog.GetPos(); i < hi; ++i)
	{
		prog.SetPos(i);

		PumpMessages();	// SendMessage·Î ³¯¶ó¿Â ¸Þ½ÃÁö¸¦ ó¸®Çϴµ¥ ÀÌ°ÉÇϴϱî Á׳×..
		Sleep(sleep);
	}

	prog.SetPos(hi);
	prog.RedrawWindow();
}

/////////////////////////////////////////////////////////////////////////////
// CDlgBurn dialog


CDlgBurn::CDlgBurn(CWnd* pParent /*=NULL*/)
	: CDialog(CDlgBurn::IDD, pParent)
{
	//{{AFX_DATA_INIT(CDlgBurn)
	m_sStCount = _T("");
	m_bChkAutoReboot = FALSE;
	m_sEdLoop = _T("");
	m_sEdToggle = _T("");
	m_bChkSaveLog = FALSE;
	//}}AFX_DATA_INIT
}


void CDlgBurn::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CDlgBurn)
	DDX_Control(pDX, IDC_CHECK_FORCE_UPDATE, m_btnForce);
	DDX_Control(pDX, IDC_RICHEDIT_LOG, m_richLog);
	DDX_Control(pDX, IDC_LIST_DEVICE, m_lstDevice);
	DDX_Text(pDX, IDC_STATIC_COUNT, m_sStCount);
	DDX_Check(pDX, IDC_CHECK_AUTO_REBOOT, m_bChkAutoReboot);
	DDX_Text(pDX, IDC_EDIT_LOOP, m_sEdLoop);
	DDX_Text(pDX, IDC_EDIT_TOGGLE, m_sEdToggle);
	DDX_Check(pDX, IDC_CHECK_SAVE_LOG, m_bChkSaveLog);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CDlgBurn, CDialog)
	//{{AFX_MSG_MAP(CDlgBurn)
	ON_BN_CLICKED(IDC_BUTTON_START, OnButtonStart)
	ON_WM_CLOSE()
	ON_NOTIFY(NM_CLICK, IDC_LIST_DEVICE, OnClickListDevice)
	ON_WM_TIMER()
	ON_BN_CLICKED(IDC_BUTTON_LOG, OnButtonLog)
	ON_WM_DESTROY()
	//}}AFX_MSG_MAP
	ON_MESSAGE(WM_BURN_WORK_START, OnBurnWorkStart)
	ON_MESSAGE(WM_BURN_STATUS, OnBurnStatus)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CDlgBurn message handlers
BOOL CDlgBurn::OnInitDialog() 
{
	CDialog::OnInitDialog();
	
	// TODO: Add extra initialization here
	ZeroMemory(m_uItemIndex, sizeof(m_uItemIndex));
	ZeroMemory(m_hThreadBurn, sizeof(m_hThreadBurn));
	ZeroMemory(m_threadUp, sizeof(m_threadUp));
	ZeroMemory(m_uElapsed, sizeof(m_uElapsed));
	m_bCancel = FALSE;

// device list
	m_lstDevice.SetExtendedStyle(LVS_EX_FULLROWSELECT | LVS_EX_HEADERDRAGDROP | LVS_EX_INFOTIP | LVS_EX_LABELTIP);
	m_lstDevice.KeepLabelLeft	 ();
	m_lstDevice.EnableSubItemTips();
	//m_lstDevice.SetC
  
// sort
	InitHeaderItem();
	refresh_server_list();

	UpdateData();

	m_bChkAutoReboot = FALSE;	// auto reboot when upgrade complete

	m_sEdLoop = "1";	// default loop count

	CString strValue;
	strValue = theApp.get_value("ENV", "save_log");
	m_bChkSaveLog = atoi((LPSTR)(LPCSTR)strValue);

	UpdateData(FALSE);

	if(!theApp.bTestMode_)
	{
		GetDlgItem(IDC_EDIT_LOOP)->ShowWindow(false);
		GetDlgItem(IDC_STATIC_LOOP)->ShowWindow(false);

		GetDlgItem(IDC_EDIT_TOGGLE)->ShowWindow(false);
		GetDlgItem(IDC_STATIC_TOGGLE)->ShowWindow(false);
	}

	InitializeCriticalSection(&m_CritSec);
	
	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}


void CDlgBurn::OnButtonStart() 
{
	// TODO: Add your control notification handler code here
	UpdateData();

	((CButton*)GetDlgItem(IDC_BUTTON_START))->EnableWindow(FALSE);

	// loop count
	int nloop = atoi(m_sEdLoop);
	int cnt = m_lstDevice.GetItemCount();

	CString strValue;
	strValue.Format("%d", m_bChkSaveLog);
	theApp.set_value("ENV", "save_log", strValue);

// check burn item
	BOOL bOcx = m_bUpdateOcx;
	BOOL bWeb = m_bUpdateWeb;
	BOOL bFirmware = m_bUpdateFirmware;
	BOOL bBootloader = m_bUpdateBootloader;
	ULONG uProtect = atoi((LPSTR)(LPCSTR)theApp.get_value("ENV", "Protect"));

	if (!uProtect) {
		if( !(bOcx || bWeb || bFirmware || bBootloader) )
		{
			// invalid 
			AfxMessageBox("select upgrade type");
			goto EXIT;
		}
	}

	if (m_lstDevice.GetItemCount() == 0) {
		AfxMessageBox("No device to update");
		goto EXIT;
	}
	
// log??
	m_bSaveLog = m_bChkSaveLog;

// deselect all item
	int i;
	for(i = 0; i < m_lstDevice.GetItemCount(); ++i)
	{
		m_lstDevice.SetItemState(i, ~LVIS_SELECTED, LVIS_SELECTED);
	}

// work~
	for(i = 0; i < nloop; ++i)
	{
		int hr = upgrade_thread(i);

		if(cnt == 1)
		{	// Àåºñ°¡ ÇÑ°³ÀÌ°í...
			if(i < nloop-1)
			{	// ¸¶Áö¸·ÀÌ ¾Æ´Ï¶ó¸é...

				CString msg;
				msg.Format("%s - [GLOBAL] - Sleep 90 sec for waiting device restart\n\n", str_time());

				Msg mm;
				mm.msg = msg;
				mm.color = BLACK;
				SendMessage(WM_BURN_STATUS, eLog, (LPARAM)&mm);

				// µô·¹ÀÌ 90ÃÊ
				Sleep(90*1000);
			}
		}
	}

// finish
	UpdateData(FALSE);	

	if (!m_bCancel) {
		AfxMessageBox("All device burning finished");
	} else {
		AfxMessageBox("Burning is cancelled");
	}

EXIT:
	EnableControl(TRUE);

	for (i=0; i<parent_->m_ctlListCtrl.GetItemCount(); i++) {
		parent_->m_ctlListCtrl.SetCheck(i, FALSE);
	}
}

void CDlgBurn::OnCancel() 
{
	// TODO: Add extra cleanup here
	m_bCancel = TRUE;
	int nCnt = m_lstDevice.GetItemCount();
	for (int i=0; i<nCnt; i++) {
		if (m_hThreadBurn[i]) {
			ULONG uExitCode;

			//GetExitCodeThread(m_hThreadBurn[i], &uExitCode);
			//TerminateThread(m_hThreadBurn[i], uExitCode);
			//m_hThreadBurn[i] = NULL;

		// CWinThreadÀ̹ǷΠÀÌ·¸°Ô~  - cjy, 08_0108 16:23
			GetExitCodeThread(m_hThreadBurn[i]->m_hThread, &uExitCode);
			TerminateThread(m_hThreadBurn[i]->m_hThread, uExitCode);
			m_hThreadBurn[i] = NULL;
		}
	}
	
	CDialog::OnCancel();
}

void CDlgBurn::InitHeaderItem()
{
	LV_COLUMN		lvcolumn;

	if (atoi((LPSTR)(LPCSTR)theApp.get_value("ENV", "Protect"))) {
		TCHAR rgtsz1[5][12] = {_T("Device Name"), _T("IP address"), _T("Firmware"), _T("Bootloader"), _T("Status") };

		int i;
		for(i = 0; i < 5; i++)  
		{
			lvcolumn.mask = LVCF_FMT | LVCF_SUBITEM | LVCF_TEXT | LVCF_WIDTH | LVCF_ORDER;
			lvcolumn.fmt = LVCFMT_LEFT;
			lvcolumn.pszText = rgtsz1[i];
			lvcolumn.iSubItem = i;
			lvcolumn.iOrder = i;

			switch(i)
			{
			case 0:		lvcolumn.cx = 95;		break;
			case 1:		lvcolumn.cx = 115;		break;
			case 2:		lvcolumn.cx = 70;		break;
			case 3:		lvcolumn.cx = 80;		break;
			case 4:		lvcolumn.cx = 115;		break;
			}

			m_lstDevice.InsertColumn(i, &lvcolumn);
		}

		return;
	}

// device
	TCHAR rgtsz1[8][12] = {_T("Device Name"), _T("IP address"), _T("Firmware"), _T("Bootloader"), _T("OCX Status"), _T("Web Status"), _T("FW Status"), _T("BL Status") };


	int i;
	for(i = 0; i < 8; i++)  
	{
		lvcolumn.mask = LVCF_FMT | LVCF_SUBITEM | LVCF_TEXT | LVCF_WIDTH | LVCF_ORDER;
		lvcolumn.fmt = LVCFMT_LEFT;
		lvcolumn.pszText = rgtsz1[i];
		lvcolumn.iSubItem = i;
		lvcolumn.iOrder = i;

		switch(i)
		{
		case 0:		lvcolumn.cx = 95;		break;
		case 1:		lvcolumn.cx = 115;		break;
		case 2:		lvcolumn.cx = 70;		break;
		case 3:		lvcolumn.cx = 80;		break;
		case 4:		lvcolumn.cx = 110;		break;
		case 5:		lvcolumn.cx = 110;		break;
		case 6:		lvcolumn.cx = 110;		break;
		case 7:		lvcolumn.cx = 110;		break;
		}

		m_lstDevice.InsertColumn(i, &lvcolumn);
	}

}

void CDlgBurn::refresh_server_list()
{
	// fill !
	int iTotalCnt = parent_->m_ctlListCtrl.GetItemCount();
	int iCheckedCnt = 0;

	for(int i = 0; i < iTotalCnt; ++i)
	{
		if (!parent_->m_ctlListCtrl.GetCheck(i)) {
			continue;
		}

	// get
		ListDeviceItem* item = (ListDeviceItem*)parent_->m_ctlListCtrl.GetItemData(i);
		ListDeviceItem *newItem = new ListDeviceItem;
		CopyMemory(newItem, item, sizeof(ListDeviceItem));

		ClientInformation* info = newItem->info;

		if (m_bUpdateFirmware) {
			newItem->bUpdateFW = TRUE;
		} else {
			newItem->bUpdateFW = FALSE;
		}

		if (m_bUpdateBootloader) {
			newItem->bUpdateBL = TRUE;
		} else {
			newItem->bUpdateBL = FALSE;
		}
		
		ULONG uFWVer = atoi(&info->FirmwareVersion[strlen(info->FirmwareVersion)-3]);
		if (parent_->m_bUpperVer[UPDATE_ITEM_FW] && uFWVer < parent_->m_uItemVer[UPDATE_ITEM_FW]) 
		{
			newItem->bUpdateFW = FALSE;
		} 
		else if (!parent_->m_bUpperVer[UPDATE_ITEM_FW] && uFWVer > parent_->m_uItemVer[UPDATE_ITEM_FW]) 
		{
			newItem->bUpdateFW = FALSE;
		}

		ULONG uBLVer = atoi(&info->ubootver[strlen(info->ubootver)-2]);
		if (parent_->m_bUpperVer[UPDATE_ITEM_BL] && uBLVer < parent_->m_uItemVer[UPDATE_ITEM_BL]) 
		{
			newItem->bUpdateBL = FALSE;
		} 
		else if (!parent_->m_bUpperVer[UPDATE_ITEM_BL] && uBLVer > parent_->m_uItemVer[UPDATE_ITEM_BL]) 
		{
			newItem->bUpdateBL = FALSE;
		}

		iCheckedCnt++;

	//TRACE("Add-0 %d, IP:%s\n", index, info->sIp);

	// add item
		LV_ITEM lvitem;
		lvitem.iItem = m_lstDevice.GetItemCount();
		lvitem.mask = LVIF_TEXT|LVIF_IMAGE|LVIF_INDENT|LVIF_PARAM;
		lvitem.iSubItem = 0;
		lvitem.iImage = -1;
		lvitem.stateMask = LVIS_STATEIMAGEMASK;
		lvitem.state = INDEXTOSTATEIMAGEMASK(1);

	// content
		lvitem.lParam = (long)(newItem);	// save index  - cjy, 07_0402 16:16

		lvitem.pszText = (LPSTR)(LPCTSTR)info->Name;

#ifdef _DEBUG
		// check same ip address
		for(int j = 0; j < m_lstDevice.GetItemCount(); ++j)
		{
			CString ipip = m_lstDevice.GetItemText(j, 1);
			ASSERT(ipip != info->sIp);
		}

#endif

	// add
		m_lstDevice.InsertItem(&lvitem);
		m_lstDevice.SetItemText(lvitem.iItem, 1, info->sIp);
		m_lstDevice.SetItemText(lvitem.iItem, 2, &info->FirmwareVersion[strlen(info->FirmwareVersion)-3]);
		m_lstDevice.SetItemText(lvitem.iItem, 3, &info->ubootver[strlen(info->ubootver)-2]);

		if (atoi((LPSTR)(LPCSTR)theApp.get_value("ENV", "Protect"))) 
		{
			m_lstDevice.SetItemText(lvitem.iItem, ITEM_INDEX_PKG, "Ready");
		} 
		else 
		{
			if(m_bUpdateOcx) 
			{
				m_lstDevice.SetItemText(lvitem.iItem, ITEM_INDEX_OCX, "Ready");
			} 
			else 
			{
				m_lstDevice.SetItemText(lvitem.iItem, ITEM_INDEX_OCX, "---");
			}

			if(m_bUpdateWeb) {
				m_lstDevice.SetItemText(lvitem.iItem, ITEM_INDEX_WEB, "Ready");
			} 
			else 
			{
				m_lstDevice.SetItemText(lvitem.iItem, ITEM_INDEX_WEB, "---");
			}

			if(newItem->bUpdateFW)
			{
				CString strVer = "Ready ";
				strVer += &parent_->m_szItemPath[UPDATE_ITEM_FW][strlen(parent_->m_szItemPath[UPDATE_ITEM_FW])-3];
				m_lstDevice.SetItemText(lvitem.iItem, ITEM_INDEX_FW, strVer);
			} 
			else 
			{
				m_lstDevice.SetItemText(lvitem.iItem, ITEM_INDEX_FW, "---");
			}

			if(newItem->bUpdateBL) 
			{
				CString strVer = "Ready ";
				strVer += &parent_->m_szItemPath[UPDATE_ITEM_BL][strlen(parent_->m_szItemPath[UPDATE_ITEM_BL])-6];
				strVer.Delete(strlen("Ready ")+2, 4);
				m_lstDevice.SetItemText(lvitem.iItem, ITEM_INDEX_BL, strVer);
			} 
			else 
			{
				m_lstDevice.SetItemText(lvitem.iItem, ITEM_INDEX_BL, "---");
			}
		}
	}

// ui
	UpdateData();
	m_sStCount.Format("%d", iCheckedCnt);
	UpdateData(FALSE);

}

void CDlgBurn::clear_list()
{
	int cnt = m_lstDevice.GetItemCount();

	for(int i = 0; i < cnt; i++)
	{
		ListDeviceItem* item = (ListDeviceItem*)m_lstDevice.GetItemData(i);
		delete item;
	}

	m_lstDevice.DeleteAllItems();
	ASSERT(m_lstDevice.GetItemCount() == 0);

}

void CDlgBurn::OnClose() 
{
	// TODO: Add your message handler code here and/or call default
	CDialog::OnClose();
}

LRESULT CDlgBurn::OnBurnStatus(WPARAM wp, LPARAM lp)
{
	int type = wp;
	switch(type)
	{
		case eStatus:
		{
			UpdateData();
			char* msg = (char*)lp;
			UpdateData(FALSE);
			break;
		}

		case eEnumProgress:
		{
			CTextProgressCtrl* prog = (CTextProgressCtrl*)lp;

			emul_progress(*prog);
			break;
		}

		case eLog:
		{
			Msg* mm = (Msg*)lp;

			m_richLog.SetSel(99999, 99999);		// move cursor

			m_richLog.SetColor(mm->color);		// color
			m_richLog.ReplaceSel(mm->msg);

		// check log message edit
			if(m_richLog.GetLineCount() > 1000)
			{
				m_richLog.SetWindowText("");
			}

		// save log to the file
			CString msgstr;
			switch(mm->color)
			{
			case RED:
				msgstr = " ### ";
				break;

			case GREEN:
				msgstr = " +++ ";
				break;

			case BLUE:
				msgstr = " --- ";
				break;

			case BLACK:
				msgstr = "     ";
				break;
			}
			msgstr += mm->msg;

			// save log
			if(m_bSaveLog && strcmp(mm->ip, "") != 0)
			{
				CString strLogName = LOG_PATH + mm->ip + ".txt";
				CString name = path_program2(strLogName);

				FILE* fp = fopen(name, "a");
				fwrite(msgstr, 1, msgstr.GetLength(), fp);
				fclose(fp);
			}

			break;
		}
		case eTotalLog:
		{
			if (!m_bSaveLog) {
				break;
			}

			TotalLog* log = (TotalLog*)lp;
			char szMsg[1024];

			SYSTEMTIME localTime;
			GetLocalTime(&localTime);

			CString strPath = path_program2(LOG_PATH);
			CString strName;
			strName.Format("%s\\%04d%02d%02d_%s", strPath, 
				localTime.wYear, localTime.wMonth, localTime.wDay, TOTAL_LOG_NAME);
			
			FILE* fp = fopen(strName, "r");
			if (!fp) {
				fp = fopen(strName, "w");
				if (!fp) {
					break;
				}

				if (log->bProtect) {
					_snprintf(szMsg, sizeof(szMsg), "Date\t\t\tName\t\tIP\t\tStatus\n");
				} else {
					_snprintf(szMsg, sizeof(szMsg), "Date\t\t\tName\t\tIP\t\tOCX\t\tWeb\t\tFirmware\tBootloader\n");
				}
				fwrite(szMsg, strlen(szMsg), 1, fp);
			}

			fclose(fp);
			fp = fopen(strName, "a");
			if (!fp) {
				break;
			}

			CString strRsOcx = "---      ";
			CString strRsWeb = "---      ";
			CString strRsFW = "---      ";
			CString strRsBL = "---      ";
			CString strRsProtect = "---      ";

			if (m_bUpdateOcx) {
				strRsOcx = log->bRsOCX?"Succeeded":"Failed   ";
			}

			if (m_bUpdateWeb) {
				strRsWeb = log->bRsWeb?"Succeeded":"Failed   ";
			}

			if (log->bUpdateFW) {
				strRsFW = log->bRsFW?"Succeeded":"Failed   ";
			}

			if (log->bUpdateBL) {
				strRsBL = log->bRsBL?"Succeeded":"Failed   ";
			}

			if (log->bProtect) {
				strRsProtect = log->bRsProtect?"Succeeded":"Failed   ";
			}

			char szName[32];
			char szIP[32];

			strcpy(szName, "               ");
			strcpy(szIP, "               ");

			memcpy(szName, log->info->Name, strlen(log->info->Name));
			memcpy(szIP, log->info->sIp, strlen(log->info->sIp));

			if (log->bProtect) {
				_snprintf(szMsg, sizeof(szMsg), "%04d-%02d-%02d %02d:%02d\t%s\t%s\t%s\n", 
					localTime.wYear, localTime.wMonth, localTime.wDay, localTime.wHour, localTime.wMinute,
					szName, szIP,
					strRsProtect);
			} else {
				_snprintf(szMsg, sizeof(szMsg), "%04d-%02d-%02d %02d:%02d\t%s\t%s\t%s\t%s\t%s\t%s\n", 
					localTime.wYear, localTime.wMonth, localTime.wDay, localTime.wHour, localTime.wMinute,
					szName, szIP,
					strRsOcx, strRsWeb, strRsFW, strRsBL);
			}

			fwrite(szMsg, strlen(szMsg), 1, fp);
			fclose(fp);

			break;
		}
		case eItem:
		{
			// ÇÑ°³ÀÇ Àåºñ¿¡¼­ web, ocx, firmware ¾÷µ¥ÀÌÆ® ½ÃÀÛµÈ °æ¿ì~
			ItemInfo *item = (ItemInfo*)lp;

			UpdateData();
			if(strcmp(item->szName, "WEB") == 0)
			{
				m_uItemIndex[item->nIndex] = ITEM_WEB;
				start_prog(item->nIndex, 1000);
			}
			else if(strcmp(item->szName, "OCX") == 0)
			{
				m_uItemIndex[item->nIndex] = ITEM_OCX;
				start_prog(item->nIndex, 1000);
			}
			else if(strcmp(item->szName, "FIRMWARE") == 0)
			{
				m_uItemIndex[item->nIndex] = ITEM_FW;
				start_prog(item->nIndex, 1000);
			}
			else if(strcmp(item->szName, "BOOTLOADER") == 0)
			{
				m_uItemIndex[item->nIndex] = ITEM_BL;
				start_prog(item->nIndex, 1000);
			}
			else if(strcmp(item->szName, "END") == 0)
			{
				end_prog(item->nIndex);

			}
			UpdateData(FALSE);

			break;
		}

	}

	return 1;

}


LRESULT CDlgBurn::OnBurnWorkStart(WPARAM wp, LPARAM lp)
{
	Clientinfo* info = (Clientinfo*)wp;
	int i = lp;

// control
	show_info(i);
	if(i != 0)
		m_lstDevice.SetItemState(i-1, ~LVIS_SELECTED, LVIS_SELECTED);

	m_lstDevice.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);

// for auto scroll
	m_richLog.SetFocus();

	return 1;
}

UINT WINAPI CDlgBurn::ThreadBrunStub(LPVOID lpParam)
{
	THREAD_PARAM *tg = (THREAD_PARAM*)lpParam;

	return static_cast<CDlgBurn*>(tg->dlg_)->ThreadBrun(tg);
}

CDlgBurn* gdlg;

void ProcessStatus(const char* ip, int cur, int total)
{
	TRACE("Progress %s: %d / %d\n", ip, cur, total);

	gdlg->SetProgress(ip, cur);
}

void CDlgBurn::SetProgress(const char *pszIP,  ULONG uPos)
{
	CString strStatus;

	for (int i=0; i < m_lstDevice.GetItemCount(); i++) {
		CString strIP = m_lstDevice.GetItemText(i, 1);
		if (strIP == pszIP) {
			strStatus.Format("Updating... %d%%", uPos);
			m_lstDevice.SetItemText(i, ITEM_INDEX_PKG, strStatus);
		}
	}
}

#include "message.h"
#include "login.h"

// return value
// -1 : login error occur
// 1 : others
int process_login_error(int hr)
{
	switch(hr)
	{
	case -1042: // access level error
		AfxMessageBox(MSG_LOGIN_ACCESS_LEVEL);
		theApp.clear_login_info();
		return -1;

	case -1043: // not match pw
		AfxMessageBox(MSG_LOGIN_NOT_MATCH_PW);
		theApp.clear_login_info();
		return -1;

	case -1061:	// not exists user id
		AfxMessageBox(MSG_LOGIN_NOT_EXISTS_USER);
		theApp.clear_login_info();
		return -1;

	}

	return 1;
}


UINT WINAPI CDlgBurn::ThreadBrun(LPVOID lpParam)
{
	THREAD_PARAM *tg = (THREAD_PARAM*)lpParam;

// prepare
	CString sFirmware = parent_->m_szItemPath[UPDATE_ITEM_FW];
	CString sOcx = parent_->m_szItemPath[UPDATE_ITEM_OCX];
	CString sWeb = parent_->m_szItemPath[UPDATE_ITEM_WEB];
	CString sBootloader = parent_->m_szItemPath[UPDATE_ITEM_BL];
	ULONG uProtect = atoi((LPSTR)(LPCSTR)theApp.get_value("ENV", "Protect"));

	BOOL bOcx = m_bUpdateOcx;
	BOOL bWeb = m_bUpdateWeb;

// ÀÌ°Ç Å×½ºÆ® ¸ðµåÀÏ °æ¿ì¸¸ Àǹ̰¡ ÀÖ´Ù.
	CString sToggle = m_sEdToggle;

	// test¸ðµåÀÏ °æ¿ì µÎ¹ø° ¹Ýº¹ Ƚ¼ö¸é
	if(tg->_cnt_ % 2 == 1) {
		if(sToggle != "")
		{
			sFirmware = path_append(path_parent(sFirmware), sToggle);
		}
	}

// do
	Msg mm;
	CString msg;
	int upgrade_flag;
	TotalLog log;
	BOOL bRsOCX = FALSE;
	BOOL bRsWeb = FALSE;
	BOOL bRsFW = FALSE;
	BOOL bRsBL = FALSE;
	log.iIndex = tg->index;

	// prepare
	ListDeviceItem* item = (ListDeviceItem*) m_lstDevice.GetItemData(tg->index);
	log.bUpdateFW = item->bUpdateFW;
	BOOL bFirmware = item->bUpdateFW;
	log.bUpdateBL = item->bUpdateBL;
	BOOL bBootloader = item->bUpdateBL;

	ClientInformation info;
	CopyMemory(&info, item->info, sizeof(info));

	mm.ip = info.sIp;

	msg.Format("%s - === Devices burning start =========================\n", str_time());
	LOG(msg, BLUE);

	// ui
	SendMessage(WM_BURN_WORK_START, (WPARAM)&info, tg->index);

	// Å×½ºÆ®·Î ¿©·¯¹ø µ¹ °æ¿ì Ä«¿îÆ® Âï¾îÁÖ±â
	CString sc;
	if(tg->_cnt_ != 0)
		sc.Format("[%d]", tg->_cnt_);

	msg.Format("%s - [%s] - Device burning start%s ==================\n", 
								str_time(), info.sIp, sc);
	LOG(msg, BLACK);

// print device information(try 5 loop)
	Information info2;
	int info_cnt = 0;
	for(; info_cnt < 5; info_cnt++) 
	{
		BOOL bSuccess = GetDeviceInformation(info.sIp, &info2, 5000);	// 1 sec -> 5 sec
		if(bSuccess) {
			msg.Format("Device information\n  IP : %s\n  Firmware : %s\n", info.sIp, info2.Firmware);
				LOG(msg, GREEN);
				break;
		} else {
			msg.Format("%s - [%s] - fail to get device info[%d]\nSocket Error : %d", 
				str_time(), info.sIp, info_cnt, GetLastError());
			LOG(msg, RED);

			// wait 3 sec
			Sleep(3000);
		}
	}

	// Wait 15 sec when occurs fail while get information
	if(info_cnt == 3) {
		msg.Format("%s - [%s] - FAIL TO GET DEVICE INFO\nWait 15 sec", 
			str_time(), info.sIp, info_cnt, GetLastError());

		LOG(msg, RED);
		Sleep(15000);
	}

// ÀÌ ±¸¹®Àº »õ·Î Ãß°¡µÈ ÀÎÁõ¿¡ °ü°èµÈ ÄÚµåÀÔ´Ï´Ù.
// ³»ºÎÀûÀ¸·Î login Á¤º¸ ÀԷ¹ްí hash»ý¼ºÇؼ­ ¾÷±×·¹ÀÌµå ½Ãµµ¸¦ Çߴµ¥
// ÀÎÁõ ¿À·ù°¡ ¹ÝȯµÇ¾úÀ»¶§ bTryLoop¸¦ True·Î ¼ÂÆÃÇÏ°í continue¸¦ ½ÇÇà½ÃÄѼ­
// ´Ù½Ã ½ÃµµÇÏ°Ô ÇÕ´Ï´Ù. ÃÖ´ë3ȸ - cjy, 08_0107 17:15
	BOOL bTryLoop = TRUE;
	int nTryCount = 0;
	while(bTryLoop && nTryCount < 3)
	{
		bTryLoop = FALSE;
		nTryCount++;


	// ÀÎÁõÁ¤º¸ ó¸®Çϴµ¿¾ÈÀ» Å©¸®Æ¼Äü½¼ÇÀ¸·Î °¨½Ô´Ï´Ù. Çò±ò¸®´Ï±î~  - cjy, 08_0108 11:17
	// ÀÎÁõ Á¤º¸
		EnterCriticalSection(&m_CritSec);

		char id[1024]={0,};
		char pw_hash[16]={0,};
		char out_mac[1024];
		int hr = proc_login(info.FirmwareVersion, info.MAC, info.sIp, info2name(&info),
			id, pw_hash,
			out_mac);
		LeaveCriticalSection(&m_CritSec);
		if(hr <= 0)
		{
			goto EXIT;
		}



	if (uProtect) {
		TRACE("Protect update\n");

		BOOL bRsProtect = FALSE;
		ItemInfo iInfo;
		iInfo.nIndex = tg->index;
		strcpy(iInfo.szName, "Package");
		SendMessage(WM_BURN_STATUS, eItem, (LPARAM)&iInfo);

		msg.Format("%s - [%s] - start - package upgrade[%s]\n", str_time(), info.sIp, theApp.get_value("PATH", "Package"));
		LOG(msg, BLACK);

		gdlg = this;
		SetUpgradeCallback(ProcessStatus);
		int iFlag = 0;
		if (m_btnForce.GetCheck()) {
			iFlag = 0xb1;
		} else {
			iFlag = 0xb0;
		}
		//upgrade_flag = UpGrade(TO_STR(info.sIp), TO_STR(theApp.get_value("PATH", "Package")), iFlag);
		upgrade_flag = UpGradeEx(TO_STR(info.sIp), 
			id, pw_hash,
			TO_STR(theApp.get_value("PATH", "Package")), iFlag);
		SetUpgradeCallback(NULL);

		//if(process_login_error(hr) == -1)
		if(process_login_error(upgrade_flag) == -1)
		{
			bTryLoop = TRUE;
			continue;
		}


		if(upgrade_flag < 0) {
			m_lstDevice.SetItemText(tg->index, ITEM_INDEX_PKG, "Failed");
			msg.Format("%s - [%s] - FAIL - package upgrade with error code[%d]\n",
											str_time(), info.sIp, upgrade_flag);
			LOG(msg, RED);
			bRsProtect = FALSE;
		} else {
			m_lstDevice.SetItemText(tg->index, ITEM_INDEX_PKG, "Succeeded");
			msg.Format("%s - [%s] - success - package upgrade\n", str_time(), info.sIp);
			LOG(msg, BLACK);
			bRsProtect = TRUE;
		}

		TOTAL_LOG_PROTECT(info, bRsProtect);
	} else {
// ocx upload ///////////////////////////////////////////////////
		if(bOcx) {
			m_lstDevice.SetItemText(tg->index, ITEM_INDEX_OCX, "Updating...");
			ItemInfo iInfo;
			iInfo.nIndex = tg->index;
			strcpy(iInfo.szName, "OCX");
			SendMessage(WM_BURN_STATUS, eItem, (LPARAM)&iInfo);

			msg.Format("%s - [%s] - start - ocx upgrade[%s]\n", str_time(), info.sIp, sOcx);
			LOG(msg, BLACK);

			// ocx do
			//upgrade_flag = UpGrade(TO_STR(info.sIp), TO_STR(sOcx), 0x40);
			upgrade_flag = UpGradeEx(TO_STR(info.sIp), 
				id, pw_hash,
				TO_STR(sOcx), 0x40);

			//if(process_login_error(hr) == -1)
			//	continue;

			if(upgrade_flag < 0) {
				m_lstDevice.SetItemText(tg->index, ITEM_INDEX_OCX, "Failed");
				msg.Format("%s - [%s] - FAIL - ocx upgrade with error code[%d]\n",
												str_time(), info.sIp, upgrade_flag);
				LOG(msg, RED);
			} else {
				m_lstDevice.SetItemText(tg->index, ITEM_INDEX_OCX, "Succeeded");
				msg.Format("%s - [%s] - success - ocx upgrade\n", str_time(), info.sIp);
				LOG(msg, BLACK);
				bRsOCX = TRUE;
			}
		}

// web upload ///////////////////////////////////////////////////
		if(bWeb) {
			m_lstDevice.SetItemText(tg->index, ITEM_INDEX_WEB, "Updating...");
			ItemInfo iInfo;
			iInfo.nIndex = tg->index;
			strcpy(iInfo.szName, "WEB");
			SendMessage(WM_BURN_STATUS, eItem, (LPARAM)&iInfo);

			msg.Format("%s - [%s] - start - web upgrade[%s]\n", str_time(), info.sIp, sWeb);
			LOG(msg, BLACK);

			// web do
			CString progPath = path_program();

			CString tarPath = path_append(progPath, "tar.exe");

			if(_access(tarPath, 0) == -1) {
				// fail
				msg.Format("%s - [%s] - fail - check tar.exe\n", str_time(), info.sIp);
				LOG(msg, RED);
			} else {
				// work
			
				_chdir(sWeb);
				char cmd[1024];
				sprintf(cmd, "\"%s\" cvf \"%s\\www%d.tar\" .", tarPath, progPath, tg->index);
					
				// change unix path sep
				for(int j=0; j<100; j++) {
					if(cmd[j]==92)
						cmd[j]='/';
				}
							
				int hr = WinExec(cmd, SW_HIDE);
				Sleep(5000);
				
				sprintf(cmd, "%s\\www%d.tar", progPath, tg->index);

				//upgrade_flag = UpGrade(TO_STR(info.sIp), cmd, 0x70);
				upgrade_flag = UpGradeEx(TO_STR(info.sIp), 
					id, pw_hash,
					cmd, 0x70);

				//if(process_login_error(hr) == -1)
				//	continue;

				if(upgrade_flag < 0) {
					m_lstDevice.SetItemText(tg->index, ITEM_INDEX_WEB, "Failed");
					msg.Format("%s - [%s] - FAIL - web upload with error code[%d]\n", 
						str_time(), info.sIp, upgrade_flag);
					LOG(msg, RED);
				} else {
					m_lstDevice.SetItemText(tg->index, ITEM_INDEX_WEB, "Succeeded");
					msg.Format("%s - [%s] - success - web upload\n", str_time(), info.sIp);
					LOG(msg, BLACK);
					bRsWeb = TRUE;
				}

				sprintf(cmd, "%s\\www%d.tar", progPath, tg->index);
				remove(cmd);
			}
		}

// firmware upgrade ///////////////////////////////////////////////////
		if(bFirmware) {
			m_lstDevice.SetItemText(tg->index, ITEM_INDEX_FW, "Updating...");
			ItemInfo iInfo;
			iInfo.nIndex = tg->index;
			strcpy(iInfo.szName, "FIRMWARE");
			SendMessage(WM_BURN_STATUS, eItem, (LPARAM)&iInfo);

			msg.Format("%s - [%s] - start - firmware upgrade[%s]\n", 
				str_time(), info.sIp, sFirmware);
			LOG(msg, BLACK);

			// firmware do
			//upgrade_flag = UpGrade(TO_STR(info.sIp), TO_STR(sFirmware), 0x50);
			upgrade_flag = UpGradeEx(TO_STR(info.sIp), 
				id, pw_hash,
				TO_STR(sFirmware), 0x50);


			//if(process_login_error(hr) == -1)
			//	continue;

			if(upgrade_flag < 0) {
				m_lstDevice.SetItemText(tg->index, ITEM_INDEX_FW, "Failed");
				msg.Format("%s - [%s] - FAIL - firmware upgrade with error code[%d]\n", 
					str_time(), info.sIp, upgrade_flag);
				LOG(msg, RED);
			} else {
				m_lstDevice.SetItemText(tg->index, ITEM_INDEX_FW, "Succeeded");
				msg.Format("%s - [%s] - success - firmware upgrade\n", 
					str_time(), info.sIp);
				LOG(msg, BLACK);
				bRsFW = TRUE;
			}
		}

// bootloader upgrade ///////////////////////////////////////////////////
		if(bBootloader) {
			m_lstDevice.SetItemText(tg->index, ITEM_INDEX_BL, "Updating...");
			ItemInfo iInfo;
			iInfo.nIndex = tg->index;
			strcpy(iInfo.szName, "BOOTLOADER");
			SendMessage(WM_BURN_STATUS, eItem, (LPARAM)&iInfo);

			msg.Format("%s - [%s] - start - bootloader upgrade[%s]\n", 
				str_time(), info.sIp, sFirmware);
			LOG(msg, BLACK);

			// firmware do
			//upgrade_flag = UpGrade(TO_STR(info.sIp), TO_STR(sBootloader), 0x60);
			upgrade_flag = UpGradeEx(TO_STR(info.sIp), 
				id, pw_hash,
				TO_STR(sBootloader), 0x60);

			//if(process_login_error(hr) == -1)
			//	continue;


			if(upgrade_flag < 0) {
				m_lstDevice.SetItemText(tg->index, ITEM_INDEX_BL, "Failed");
				msg.Format("%s - [%s] - FAIL - bootloader upgrade with error code[%d]\n", 
					str_time(), info.sIp, upgrade_flag);
				LOG(msg, RED);
			} else {
				m_lstDevice.SetItemText(tg->index, ITEM_INDEX_BL, "Succeeded");
				msg.Format("%s - [%s] - success - bootloader upgrade\n", 
					str_time(), info.sIp);
				LOG(msg, BLACK);
				bRsBL = TRUE;
			}
		}

		TOTAL_LOG(info, bRsOCX, bRsWeb, bRsFW, bRsBL);
	}




	// reboot?
	ItemInfo iInfo;
	iInfo.nIndex = tg->index;
	strcpy(iInfo.szName, "END");
	SendMessage(WM_BURN_STATUS, eItem, (LPARAM)&iInfo);

	Sleep(3000);	// delay 3 sec after update work before reboot

	bool bReboot = true;
	if(m_bChkAutoReboot == FALSE) {
		if (bOcx && !bWeb && !bFirmware && !bBootloader) {
			bReboot = false;
		} else {
			CString strMsg;
			strMsg.Format("[%s] You need to press 'OK' for restarting NVE/IPC series to apply new configuration, otherwise press 'Cancel'", info.sIp);
			int nn = AfxMessageBox(strMsg, MB_ICONEXCLAMATION | MB_YESNO);
			if(nn == IDNO)
				bReboot = false;
		}
	}

	if(bReboot) {
		EnterCriticalSection(&m_CritSec);
		unsigned char data[7] = "reboot";

		// server reboot
		Sleep(1000);
		//if(!CtrlDevice(info.sIp, 1, data, 5)) {
		//	Sleep(1000);
		//	CtrlDevice(info.sIp, 1, data, 5);
		//}				
		if(!CtrlDeviceEx(info.sIp, id, pw_hash, 1, data, 5)) {
			Sleep(1000);
			CtrlDeviceEx(info.sIp, id, pw_hash, 1, data, 5);
		}				

		msg.Format("%s - [%s] - REBOOT\n", str_time(), info.sIp);
		LOG(msg, BLUE);
		LeaveCriticalSection(&m_CritSec);
	} else {
		msg.Format("%s - [%s] - skip reboot\n", str_time(), info.sIp);
		LOG(msg, BLACK);
	}



	}	// while  - cjy, 08_0108 11:29

	msg.Format("%s - [%s] - Device burning finished ===============\n\n", str_time(), info.sIp);
	LOG(msg, BLACK);

// finish successfuly~
EXIT:
	//CloseHandle(m_hThreadBurn[tg->index]);
	//m_hThreadBurn[tg->index] = NULL;

// ¿©±â¼­ Á÷Á¢ Á¾·á½ÃÅ°¸é ¾ÈµË´Ï´Ù. Á¾·á ¿©ºÎ¸¦ Ç÷¯±×·Î ¾Ë·ÁÁÖ°í ó¸®ÇÕ´Ï´Ù.
// ¾Æ.. ÇÚµé·Î ÇÒ¼ö Àִµ¥.. ã¾Æº¸±â ±ÍÂù´Ù.  - cjy, 08_0923 11:02
//	CloseHandle(m_hThreadBurn[tg->index]->m_hThread);
//	m_hThreadBurn[tg->index] = NULL;

	tg->bQuit = TRUE;


	return 0;
}

void CDlgBurn::start_prog(int index, int time)
{
	m_uElapsed[index] = 0;
	SetTimer(index, time, NULL);
}

void CDlgBurn::end_prog(int index)
{
	KillTimer(index);

}

// -1 : upgrade ³»ºÎ ¿À·ù
// -2 : Thread³»ºÎ¿¡¼­ ¿À·ù
// -3 : Thread WaitforsingleObject ¿À·ù

int CDlgBurn::upgrade_thread(int cnt)
{
//	DWORD dwThreadID;
	
	int cnt_device = m_lstDevice.GetItemCount();
	CString msg;
	Msg mm;
	int i;

	for(i = 0; i < cnt_device; ++i) {
// prepare
		m_threadUp[i].dlg_ = this;
		m_threadUp[i]._cnt_ = cnt;	// test¸ðµåÀÏ °æ¿ì ¾÷µ¥ÀÌÆ® ¹Ýº¹ Ƚ¼ö
		m_threadUp[i].index = i;

		m_threadUp[i].bQuit = FALSE;

// thread
		// beginthreadexÇÔ¼ö ´ë½Å¿¡ AfxBeginThread·Î º¯°æÇÕ´Ï´Ù.
		// ¾²·¹µå³»¿¡¼­ ´ÙÀ̾ó·Î±×¸¦ ¾²´Â °æ¿ì°¡ À־...  - cjy, 08_0108 16:37
		//m_hThreadBurn[i] = (HANDLE)_beginthreadex(NULL, 0, 
		//	ThreadBrunStub, &m_threadUp[i], 0, (unsigned*)&dwThreadID);
		m_hThreadBurn[i] = AfxBeginThread((AFX_THREADPROC)ThreadBrunStub, (LPVOID)&m_threadUp[i],
			0, 0, 0, NULL);

//unsigned long _beginthreadex( void *security, unsigned stack_size, 
//	unsigned ( __stdcall *start_address )( void * ), void *arglist,
//	unsigned initflag, unsigned *thrdaddr );

//CWinThread* AFXAPI AfxBeginThread(AFX_THREADPROC pfnThreadProc, LPVOID pParam,
//        int nPriority, UINT nStackSize, DWORD dwCreateFlags,
//        LPSECURITY_ATTRIBUTES lpSecurityAttrs)

	}

// loop
	int result = 0;
	BOOL bExec = TRUE;
	HANDLE hDummy;
	BOOL bStop;
	hDummy = CreateEvent(NULL, FALSE, FALSE, NULL);
	while(bExec)
	{
		PumpMessages();

		DWORD hr = WaitForSingleObject(hDummy, 50);
		switch(hr)
		{

		case WAIT_OBJECT_0:	// success
			bExec = FALSE;
			break;

		case WAIT_TIMEOUT:
			bStop = TRUE;
			for (i=0; i<cnt_device; i++) {
				//if (m_hThreadBurn[i]) {
				if(m_threadUp[i].bQuit == FALSE) {
					bStop = FALSE;
				}
			}
			
			if (bStop) {

			// thread handle cleanupÀº ¿©±â¼­ ÇÑ´Ù. - cjy, 08_0923 11:03s
				for (i=0; i<cnt_device; i++) {
					ASSERT(m_threadUp[i].bQuit);

				// close handle Çϸé invalid handle ¿À·ù³ª¿Â´Ù. À½..ÀÌ¹Ì Á¾·áµÈ ¾²·¹µå¶ó ±×·±°¡ºÎ´Ù. - cjy, 08_0923 11:24
				// ½Ã°£ÀÌ ¾øÀ¸´Ï ÀÏ´ÜÀº close handle ÇÏÁö¸»°í ÀÌÀ¯´Â ³ªÁß¿¡ È®ÀÎÇغ¸ÀÚ
					//CloseHandle(m_hThreadBurn[i]->m_hThread);
					m_hThreadBurn[i] = NULL;
				}


				bExec = FALSE;
			}
			break;
		case WAIT_ABANDONED:
		case WAIT_FAILED:
			bExec = FALSE;
			break;
		}
	}
	CloseHandle(hDummy);

	if (!m_bCancel) {
		msg.Format("%s - === All device burning finished ========================\n\n\n", str_time());
		LOG(msg, BLUE);
	} else {
		msg.Format("%s - === Burning is cancelled ========================\n\n\n", str_time());
		LOG(msg, BLUE);
	}

	return result;
}

void CDlgBurn::EnableControl(BOOL bEn)
{
	GetDlgItem(IDC_BUTTON_START)->EnableWindow(bEn);
	GetDlgItem(IDCANCEL)->EnableWindow(bEn);

	GetDlgItem(IDC_LIST_DEVICE)->EnableWindow(bEn);


	GetDlgItem(IDC_CHECK_SAVE_LOG)->EnableWindow(bEn);

}


void CDlgBurn::OnClickListDevice(NMHDR* pNMHDR, LRESULT* pResult) 
{
	// TODO: Add your control notification handler code here

	POSITION pos = m_lstDevice.GetFirstSelectedItemPosition();
	if(pos)
	{
		int nItem = m_lstDevice.GetNextSelectedItem(pos);
		show_info(nItem);
	}
	
	*pResult = 0;
}



void CDlgBurn::show_info(int nitem)
{

// prepare
	ListDeviceItem* item = (ListDeviceItem*)m_lstDevice.GetItemData(nitem);

	ClientInformation *info = item->info;
}

void CDlgBurn::OnTimer(UINT nIDEvent) 
{
	// TODO: Add your message handler code here and/or call default
	
//
	CString strStatus;

	if (m_uItemIndex[nIDEvent] == ITEM_OCX) {
		if (((m_uElapsed[nIDEvent])*100)/30 < 100) {
			strStatus.Format("Updating... %d%%", ((m_uElapsed[nIDEvent])*100)/30);
		} else {
			strStatus.Format("Updating... 100%%");
		}
		m_lstDevice.SetItemText(nIDEvent, ITEM_INDEX_OCX, strStatus);
	} else if (m_uItemIndex[nIDEvent] == ITEM_WEB) {
		if (((m_uElapsed[nIDEvent])*100)/20 < 100) {
			strStatus.Format("Updating... %d%%", ((m_uElapsed[nIDEvent])*100)/20);
		} else {
			strStatus.Format("Updating... 100%%");
		}
		m_lstDevice.SetItemText(nIDEvent, ITEM_INDEX_WEB, strStatus);
	} else if (m_uItemIndex[nIDEvent] == ITEM_FW) {
		if (((m_uElapsed[nIDEvent])*100)/100 < 100) {
			strStatus.Format("Updating... %d%%", ((m_uElapsed[nIDEvent])*100)/100);
		} else {
			strStatus.Format("Updating... 100%%");
		}
		m_lstDevice.SetItemText(nIDEvent, ITEM_INDEX_FW, strStatus);
	} else if (m_uItemIndex[nIDEvent] == ITEM_BL) {
		if (((m_uElapsed[nIDEvent])*100)/30) {
			strStatus.Format("Updating... %d%%", ((m_uElapsed[nIDEvent])*100)/30);
		} else {
			strStatus.Format("Updating... 100%%");
		}
		m_lstDevice.SetItemText(nIDEvent, ITEM_INDEX_BL, strStatus);
	}

	m_uElapsed[nIDEvent]++;

	CDialog::OnTimer(nIDEvent);
}

void CDlgBurn::OnButtonLog() 
{
	// TODO: Add your control notification handler code here
	// log clear~
	m_richLog.SetWindowText("");
}

void CDlgBurn::OnDestroy() 
{
	CDialog::OnDestroy();
	
	// TODO: Add your message handler code here
	DeleteCriticalSection(&m_CritSec);
	clear_list();
}