// DitGlassRawMessengerDlg.cpp : ±¸Çö ÆÄÀÏ
//

#include "stdafx.h"
#include "DitGlassRawMessenger.h"
#include "DitGlassRawMessengerDlg.h"
#include <process.h>

#include "GlassRawCSOT.h"
#include "GlassRawCEC.h"
#include "GlassRawDemo.h"
#include "GlassRawCPJT.h"

#include "akCore/akFileUtil.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

#define GRID_FIX_COLOR			RGB(115,187,43)
#define GRID_COLOR				RGB(242,242,242)
#define GRID_TEXT_COLOR			RGB(255,255,255)
#define GRID_ALARM_TEXT_COLOR	RGB(255,0,0)
#define GRID_LINE_COLOR			GRID_FIX_COLOR
// ÀÀ¿ë ÇÁ·Î±×·¥ Á¤º¸¿¡ »ç¿ëµÇ´Â CAboutDlg ´ëÈ­ »óÀÚÀÔ´Ï´Ù.

class CAboutDlg : public CDialog
{
public:
	CAboutDlg();

// ´ëÈ­ »óÀÚ µ¥ÀÌÅÍÀÔ´Ï´Ù.
	enum { IDD = IDD_ABOUTBOX };

	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV Áö¿øÀÔ´Ï´Ù.

// ±¸ÇöÀÔ´Ï´Ù.
protected:
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
END_MESSAGE_MAP()


// CDitGlassRawMessengerDlg ´ëÈ­ »óÀÚ




CDitGlassRawMessengerDlg::CDitGlassRawMessengerDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CDitGlassRawMessengerDlg::IDD, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);

	m_pGlassRawMaker = NULL;

	m_vecStrGridGlassHeader.push_back("No");
	m_vecStrGridGlassHeader.push_back("GlassID");
	m_vecStrGridGlassHeader.push_back("Judge");
	m_vecStrGridGlassHeader.push_back("VCR");
	m_vecStrGridGlassHeader.push_back("FileName");
	m_vecStrGridGlassHeader.push_back("GlassLoading");
	m_vecStrGridGlassHeader.push_back("InspectEnd");
	m_vecStrGridGlassHeader.push_back("Path");
	
	
	m_vecStrGridCellHeader.push_back("No");
	m_vecStrGridCellHeader.push_back("Idx");
	m_vecStrGridCellHeader.push_back("Name");
	m_vecStrGridCellHeader.push_back("Rect");
	m_vecStrGridCellHeader.push_back("Judge");
	m_vecStrGridCellHeader.push_back("Loc_Active");
	m_vecStrGridCellHeader.push_back("Loc_Pad");
	m_vecStrGridCellHeader.push_back("Loc_Crack");
	m_vecStrGridCellHeader.push_back("Size_Small");
	m_vecStrGridCellHeader.push_back("Size_Mid");
	m_vecStrGridCellHeader.push_back("Size_Large");
	m_vecStrGridCellHeader.push_back("Size_Huge");
	m_vecStrGridCellHeader.push_back("Size_Ultra");
	m_vecStrGridCellHeader.push_back("Type_TB");
	m_vecStrGridCellHeader.push_back("Type_TW");
	m_vecStrGridCellHeader.push_back("Type_RB");
	m_vecStrGridCellHeader.push_back("Type_RW");
	m_vecStrGridCellHeader.push_back("Type_MD");
	m_vecStrGridCellHeader.push_back("Type_CD");
	m_vecStrGridCellHeader.push_back("Type_MC");



	m_vecStrGridDefectHeader.push_back("No");
	m_vecStrGridDefectHeader.push_back("Idx");
	m_vecStrGridDefectHeader.push_back("Loc");
	m_vecStrGridDefectHeader.push_back("Classification");
	m_vecStrGridDefectHeader.push_back("Code");
	m_vecStrGridDefectHeader.push_back("Type");
	m_vecStrGridDefectHeader.push_back("SubType");
	m_vecStrGridDefectHeader.push_back("Length");
	m_vecStrGridDefectHeader.push_back("XSize(um)");
	m_vecStrGridDefectHeader.push_back("YSize(um)");
	m_vecStrGridDefectHeader.push_back("Area(um)");
	m_vecStrGridDefectHeader.push_back("Zone");
	m_vecStrGridDefectHeader.push_back("DMax");
	m_vecStrGridDefectHeader.push_back("DMin");
	m_vecStrGridDefectHeader.push_back("DAvg");
	m_vecStrGridDefectHeader.push_back("Peak");
	m_vecStrGridDefectHeader.push_back("Step");
	m_vecStrGridDefectHeader.push_back("Cam");
	m_vecStrGridDefectHeader.push_back("Scan");
	m_vecStrGridDefectHeader.push_back("RMax");
	m_vecStrGridDefectHeader.push_back("RMin");
	m_vecStrGridDefectHeader.push_back("RAvg");
	m_vecStrGridDefectHeader.push_back("Xpos(mm)");
	m_vecStrGridDefectHeader.push_back("Ypos(mm)");
	m_vecStrGridDefectHeader.push_back("CellX(mm)");
	m_vecStrGridDefectHeader.push_back("CellY(mm)");
	m_vecStrGridDefectHeader.push_back("ScrtRatio");
	m_vecStrGridDefectHeader.push_back("Density");
	//201207 CJH - Merge ¿©ºÎ È®ÀÎ
	m_vecStrGridDefectHeader.push_back("MergeState");

}

void CDitGlassRawMessengerDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_LIST_LOG, m_ctrlLoggerList);
}

BEGIN_MESSAGE_MAP(CDitGlassRawMessengerDlg, CDialog)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	//}}AFX_MSG_MAP
	ON_WM_DROPFILES()
	ON_CBN_SELCHANGE(IDC_COMBO_RAWTYPE, &CDitGlassRawMessengerDlg::OnCbnSelchangeComboRawtype)
//	ON_WM_DESTROY()
	ON_MESSAGE(UM_TRAYICON_MSG, TrayIconMSG)
	ON_MESSAGE(UM_UPDATE_LOGGER, OnLoggerDataUpdate)
	ON_MESSAGE(UM_GLASSRAW_CLIENTMESSAGE, OnClientMessage)
	ON_BN_CLICKED(IDOK, &CDitGlassRawMessengerDlg::OnBnClickedOk)
	ON_BN_CLICKED(IDC_BTN_EXPORT_RAW, &CDitGlassRawMessengerDlg::OnBnClickedBtnExportRaw)
	ON_NOTIFY(LVN_GETDISPINFO, IDC_LIST_LOG, &CDitGlassRawMessengerDlg::OnLvnGetdispinfoListLog)
	ON_BN_CLICKED(IDC_TEST_LOG1, &CDitGlassRawMessengerDlg::OnBnClickedTestLog1)
	ON_BN_CLICKED(IDC_TEST_LOG2, &CDitGlassRawMessengerDlg::OnBnClickedTestLog2)
	ON_BN_CLICKED(IDC_LOG_CLEAR, &CDitGlassRawMessengerDlg::OnBnClickedLogClear)
	ON_BN_CLICKED(IDC_LOG_FILEOPEN, &CDitGlassRawMessengerDlg::OnBnClickedLogFileopen)
	ON_BN_CLICKED(IDC_CHK_ADMINMODE, &CDitGlassRawMessengerDlg::OnBnClickedChkAdminmode)
	ON_BN_CLICKED(IDC_BTN_REFRESH, &CDitGlassRawMessengerDlg::OnBnClickedBtnRefresh)
	ON_BN_CLICKED(IDC_BTN_EXPORT_BIN, &CDitGlassRawMessengerDlg::OnBnClickedBtnExportBin)
	ON_BN_CLICKED(IDC_BTN_IMPORT_BIN, &CDitGlassRawMessengerDlg::OnBnClickedBtnImportBin)
	ON_BN_CLICKED(IDC_BTN_IMPORT_RAW, &CDitGlassRawMessengerDlg::OnBnClickedBtnImportRaw)
	ON_BN_CLICKED(IDC_TEST1, &CDitGlassRawMessengerDlg::OnBnClickedTest1)
	ON_BN_CLICKED(IDC_TEST2, &CDitGlassRawMessengerDlg::OnBnClickedTest2)
	ON_BN_CLICKED(IDC_BTN_STACKAPPLY, &CDitGlassRawMessengerDlg::OnBnClickedBtnStackapply)
	ON_BN_CLICKED(IDC_TEST_CMD, &CDitGlassRawMessengerDlg::OnBnClickedTestCmd)
	ON_BN_CLICKED(IDC_BTN_FTP_MANUALUPLOAD, &CDitGlassRawMessengerDlg::OnBnClickedBtnFtpManualupload)
END_MESSAGE_MAP()

void GetCompileTime(tm& timestruct)
{
    CString strMonth[]={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
	CString date,time;
	date.Format("%s", __DATE__);
	time.Format("%s", __TIME__);

	timestruct.tm_hour = atoi(time.Left(2));
	timestruct.tm_min = atoi(time.Mid(3,2));
	timestruct.tm_sec = atoi(time.Right(2));

	timestruct.tm_mday = atoi(date.Mid(4,2));
	timestruct.tm_year = atoi(date.Right(4))-1900;

	timestruct.tm_mon = -1;
	for (int i=0;i<12;i++)
	{
		if (date.Left(3)==strMonth[i])
			timestruct.tm_mon =i;
	}

	if (timestruct.tm_mon>11 || timestruct.tm_mon<0 )
		ASSERT(FALSE);
}
// CDitGlassRawMessengerDlg ¸Þ½ÃÁö 󸮱â

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

	DragAcceptFiles(TRUE);
	// ½Ã½ºÅÛ ¸Þ´º¿¡ "Á¤º¸..." ¸Þ´º Ç׸ñÀ» Ãß°¡ÇÕ´Ï´Ù.

	// IDM_ABOUTBOX´Â ½Ã½ºÅÛ ¸í·É ¹üÀ§¿¡ ÀÖ¾î¾ß ÇÕ´Ï´Ù.
	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);

	CMenu* pSysMenu = GetSystemMenu(FALSE);
	if (pSysMenu != NULL)
	{
		BOOL bNameValid;
		CString strAboutMenu;
		bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
		ASSERT(bNameValid);
		if (!strAboutMenu.IsEmpty())
		{
			pSysMenu->AppendMenu(MF_SEPARATOR);
			pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
		}
	}

	// ÀÌ ´ëÈ­ »óÀÚÀÇ ¾ÆÀÌÄÜÀ» ¼³Á¤ÇÕ´Ï´Ù. ÀÀ¿ë ÇÁ·Î±×·¥ÀÇ ÁÖ Ã¢ÀÌ ´ëÈ­ »óÀÚ°¡ ¾Æ´Ò °æ¿ì¿¡´Â
	//  ÇÁ·¹ÀÓ¿öÅ©°¡ ÀÌ ÀÛ¾÷À» ÀÚµ¿À¸·Î ¼öÇàÇÕ´Ï´Ù.
	SetIcon(m_hIcon, TRUE);			// Å« ¾ÆÀÌÄÜÀ» ¼³Á¤ÇÕ´Ï´Ù.
	SetIcon(m_hIcon, FALSE);		// ÀÛÀº ¾ÆÀÌÄÜÀ» ¼³Á¤ÇÕ´Ï´Ù.

	//Æ®·¹À̾ÆÀÌÄÜ ±¸¼º
	m_TrayIcon = FALSE;
	ResTrayIcon();

	//ºôµå Á¤º¸
	{
		CString strBuild;
		tm tmBuild;
		GetCompileTime(tmBuild);
		strBuild.Format("Build. %04d-%02d-%02d", tmBuild.tm_year+1900, tmBuild.tm_mon+1, tmBuild.tm_mday);
		SetDlgItemText(IDC_BUILDDATE, strBuild);
	}

	//¼³Á¤ÆÄÀÏ Á¤º¸ ÀÐ¾î ¿À±â [±èÅÂÇö 2018/11/20]
	{
		m_strConfigFile;
		{
			GetModuleFileName(NULL, m_strConfigFile, MAX_PATH);
			char* ext = CakFileUtil::getFileExt(m_strConfigFile);
			strcpy(ext, "ini");
		}

		CakFileDB akFileDB;
		akFileDB.openfile(m_strConfigFile);
		akFileDB.getItem("DataMaxNumCell", &m_ConfigOption.m_nMaxDataNumCell, 200);
		akFileDB.getItem("DataMaxNumDefect", &m_ConfigOption.m_nMaxDataNumDefect, 50000);
		akFileDB.getItem("SelectRawType", &m_ConfigOption.m_nSelectRawType, 0);
		akFileDB.getItem("LogFilePath", m_ConfigOption.m_strLogFilePath, "c:\\AOIServer\\LogRawMessenger\\LogRawMessenger");
		akFileDB.getItem("Stack_Use", &m_ConfigOption.m_bUseStack, 0);
		akFileDB.getItem("Stack_LocalPath", m_ConfigOption.m_strStackLocalPath, "D:\\DIT_ResultData\\Stack");
		akFileDB.getItem("RawMerge_Use", &m_ConfigOption.m_bUseRawMerge, 0);
		akFileDB.getItem("RawMerge_LocalPath", m_ConfigOption.m_strRawMergeLocalPath, "D:\\DIT_ResultData\\RawMerge");
		akFileDB.getItem("Stack_EquipID",m_ConfigOption.m_strStackEquipID, "AAAAA");
		akFileDB.getItem("Stack_Param1",m_ConfigOption.m_strStackParam1, "");
		akFileDB.getItem("Stack_Param2",m_ConfigOption.m_strStackParam2, "");

		SetDlgItemInt(IDC_EDIT_MAXDATANUMCELL, m_ConfigOption.m_nMaxDataNumCell);
		SetDlgItemInt(IDC_EDIT_MAXDATANUMDEFECT, m_ConfigOption.m_nMaxDataNumDefect);

		((CButton*)GetDlgItem(IDC_CHECK_STACKFILEREAD))->SetCheck(m_ConfigOption.m_bUseStack);
		SetDlgItemText(IDC_EDIT_STACK_LOCALSAVEPATH, m_ConfigOption.m_strStackLocalPath);
		((CButton*)GetDlgItem(IDC_CHECK_RAWMERGEFILEREAD))->SetCheck(m_ConfigOption.m_bUseRawMerge);
		SetDlgItemText(IDC_EDIT_RAWMERGE_LOCALSAVEPATH, m_ConfigOption.m_strRawMergeLocalPath);
		SetDlgItemText(IDC_EDIT_STACK_EQUIPID, m_ConfigOption.m_strStackEquipID);
		SetDlgItemText(IDC_EDIT_STACK_PARAM1, m_ConfigOption.m_strStackParam1);
		SetDlgItemText(IDC_EDIT_STACK_PARAM2, m_ConfigOption.m_strStackParam2);
	}

	//·Î±× °ü·Ã [±èÅÂÇö 2018/11/20]
	{
		CakFileUtil fileutil;
		char strPath[256];
		fileutil.getPath(strPath, 256, m_ConfigOption.m_strLogFilePath);

		CreateDirectory(strPath, NULL);
		//CakLoggerExt::getInstance()->setWriteFileMode(m_ConfigOption.m_strLogFilePath);
		CakLoggerExt::getInstance()->setWriteFileMode2("C:\\DIT_LogData\\", "logGlassRawMessenger");
		CakLoggerExt::getInstance()->m_hParent = GetSafeHwnd();

		m_ctrlLoggerList;
		{
			CListCtrl* pCtrl = &m_ctrlLoggerList;
			CRect rectClient;
			pCtrl->GetClientRect(&rectClient);
			pCtrl->SetRedraw(FALSE);

			LV_COLUMN column;
			int col= 3;
			pCtrl->SetExtendedStyle(LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES);

			int i;
			for(i= 0; i< col; i++)
			{
				pCtrl->DeleteColumn(0);
			}

			CString	strTitle;

			column.mask= LVCF_FMT | LVCF_TEXT | LVCF_SUBITEM | LVCF_WIDTH;
			column.fmt= LVCFMT_CENTER;
			column.pszText = "No.";
			column.iSubItem= 0+10;
			column.cx= 60;
			pCtrl->InsertColumn(1, &column);

			column.fmt= LVCFMT_CENTER;
			column.pszText = "Time";
			column.iSubItem= 1+10;
			column.cx= 90;
			pCtrl->InsertColumn(2, &column);

			column.fmt= LVCFMT_LEFT;
			column.pszText = "Text";
			column.iSubItem= 2+10;
			column.cx= rectClient.Width()-90-60;
			pCtrl->InsertColumn(3, &column);

			//pCtrl->SetColumnWidth(2,LVSCW_AUTOSIZE);


			pCtrl->SetRedraw(TRUE);
		}
	}
	
	
	

	{
		CString strValue;
		FILE* pf = fopen(m_strConfigFile, "r");
		if(pf)
		{
			char buffer[512]={};
			fgets(buffer, 512, pf);	
			if(buffer[strlen(buffer)-1] == '\n') buffer[strlen(buffer)-1] = 0;
			SetDlgItemText(IDC_EDIT_RAWFILENAME, buffer);
			buffer[0] = 0;fgets(buffer, 512, pf);	
			if(buffer[strlen(buffer)-1] == '\n') buffer[strlen(buffer)-1] = 0;
			SetDlgItemText(IDC_EDIT_IMAGEPATH, buffer);
			fclose(pf);
		}
	}

	initGridGlassInfo(&m_gridGlassInfo, IDC_RECT_GRIDGLASS);
	initGridCellInfo(&m_gridCellInfo, IDC_RECT_GRIDCELL);
	initGridDefectInfo(&m_gridDefectInfo, IDC_RECT_GRIDDEFECT);
	
	
	
	m_pGlassRawMaker;
	{
		CComboBox* pCombo = (CComboBox*)GetDlgItem(IDC_COMBO_RAWTYPE);
		pCombo->ResetContent();
		pCombo->AddString(CGlassRawDemo::GetClassName());
		pCombo->AddString(CGlassRawCPJT::GetClassName());
		pCombo->AddString(CGlassRawCSOT::GetClassName());
		pCombo->AddString(CGlassRawCEC::GetClassName());

		if(m_ConfigOption.m_nSelectRawType >= pCombo->GetCount())
		{
			m_ConfigOption.m_nSelectRawType = 0;
		}
		
		pCombo->SetCurSel(m_ConfigOption.m_nSelectRawType);

		OnCbnSelchangeComboRawtype();
	}
	

	if(m_Server.CreateServer(m_ConfigOption.m_nMaxDataNumCell, m_ConfigOption.m_nMaxDataNumDefect) == FALSE)
	{
		AfxMessageBox("¼­¹ö »ý¼º ½ÇÆÐ Á¾·á ÇÕ´Ï´Ù.");
		exit(0);
	}

	//ÇöÀç°ª Àû¿ë [±èÅÂÇö 2019/1/12]
	{
		CDitGlassRawServer* pServer = (CDitGlassRawServer*) &m_Server;
		CgrmGlassRawData* pRawDataBuffer = &m_GlassRawDataBuffer;
		pRawDataBuffer->ImportGlassRaw(pServer->GetGlassRawInfo(), (char*)pServer->GetGlassData());
	}
	
	//ÀÛ¾÷ ¾²·¹µå »ý¼º [±èÅÂÇö 2018/11/13]
	{
		_beginthread(threadMain, NULL, this);
	}
	
	PostMessage(UM_GLASSRAW_CLIENTMESSAGE);

	return TRUE;  // Æ÷Ä¿½º¸¦ ÄÁÆ®·Ñ¿¡ ¼³Á¤ÇÏÁö ¾ÊÀ¸¸é TRUE¸¦ ¹ÝȯÇÕ´Ï´Ù.
}

void CDitGlassRawMessengerDlg::OnBnClickedOk()
{
	// TODO: ¿©±â¿¡ ÄÁÆ®·Ñ ¾Ë¸² 󸮱â Äڵ带 Ãß°¡ÇÕ´Ï´Ù.
	OnOK();
}


void CDitGlassRawMessengerDlg::ResTrayIcon()
{
	NOTIFYICONDATA nid;
	nid.cbSize = sizeof(nid);
	nid.hWnd = m_hWnd; // ¸ÞÀÎ À©µµ¿ì ÇÚµé
	nid.uID = IDR_MAINFRAME; // ¾ÆÀÌÄÜ ¸®¼Ò½º ID
	nid.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP; // Ç÷¡±× ¼³Á¤
	nid.uCallbackMessage = UM_TRAYICON_MSG; // Äݹé¸Þ½ÃÁö ¼³Á¤
	nid.hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME); // ¾ÆÀÌÄÜ ·Îµå

	char strTitle[256];
	GetWindowText(strTitle, sizeof(strTitle)); // ĸ¼Ç¹Ù¿¡ Ãâ·ÂµÈ ¹®ÀÚ¿­ ¾òÀ½
	lstrcpy(nid.szTip, strTitle);
	Shell_NotifyIcon(NIM_ADD, &nid);
	SendMessage(WM_SETICON, (WPARAM)TRUE, (LPARAM)nid.hIcon);
	m_TrayIcon = TRUE;


}


LRESULT CDitGlassRawMessengerDlg::TrayIconMSG(WPARAM wParam, LPARAM lParam)
{
	if(lParam==WM_LBUTTONDBLCLK)
	{
		ShowWindow(SW_SHOW);
	}
	if(lParam==WM_RBUTTONDOWN)
	{
		POINT pos;

		GetCursorPos(&pos);
		{
			HMENU hMenu = CreatePopupMenu();
			AppendMenu(hMenu, MF_STRING, 0, "¿¬±¸¼Ò2ÆÄÆ®ÀÛÇ°");
			AppendMenu(hMenu, MF_STRING, WM_DESTROY, "Exit");
			TrackPopupMenu(hMenu, TPM_LEFTALIGN | TPM_RIGHTBUTTON, pos.x, pos.y, 0, GetSafeHwnd(), NULL);
		}
		

	}

	return 0;
}

void CDitGlassRawMessengerDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else if(nID==SC_MINIMIZE || nID == SC_CLOSE)
	{
		ShowWindow(SW_HIDE);
	}
	else
	{
		CDialog::OnSysCommand(nID, lParam);
	}
}

// ´ëÈ­ »óÀÚ¿¡ ÃÖ¼ÒÈ­ ´ÜÃ߸¦ Ãß°¡ÇÒ °æ¿ì ¾ÆÀÌÄÜÀ» ±×¸®·Á¸é
//  ¾Æ·¡ Äڵ尡 ÇÊ¿äÇÕ´Ï´Ù. ¹®¼­/ºä ¸ðµ¨À» »ç¿ëÇÏ´Â MFC ÀÀ¿ë ÇÁ·Î±×·¥ÀÇ °æ¿ì¿¡´Â
//  ÇÁ·¹ÀÓ¿öÅ©¿¡¼­ ÀÌ ÀÛ¾÷À» ÀÚµ¿À¸·Î ¼öÇàÇÕ´Ï´Ù.

void CDitGlassRawMessengerDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); // ±×¸®±â¸¦ À§ÇÑ µð¹ÙÀ̽º ÄÁÅؽºÆ®

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		// Ŭ¶óÀ̾ðÆ® »ç°¢Çü¿¡¼­ ¾ÆÀÌÄÜÀ» °¡¿îµ¥¿¡ ¸ÂÃä´Ï´Ù.
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// ¾ÆÀÌÄÜÀ» ±×¸³´Ï´Ù.
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialog::OnPaint();
	}
}

// »ç¿ëÀÚ°¡ ÃÖ¼ÒÈ­µÈ âÀ» ²ô´Â µ¿¾È¿¡ Ä¿¼­°¡ Ç¥½ÃµÇµµ·Ï ½Ã½ºÅÛ¿¡¼­
//  ÀÌ ÇÔ¼ö¸¦ È£ÃâÇÕ´Ï´Ù.
HCURSOR CDitGlassRawMessengerDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}


void CDitGlassRawMessengerDlg::OnDropFiles(HDROP hDropInfo)
{
	int nFiles;
	char szPathName[MAX_PATH];  // ÆÄÀÏ °æ·Î¸éÀÌ µé¾î°£´Ù.
	CString strFileName;

	// µå·ÓµÈ ÆÄÀÏÀÇ °¹¼ö
	nFiles = ::DragQueryFile( hDropInfo, 0xFFFFFFFF, szPathName, MAX_PATH );

	for(int i = nFiles-1 ; i >= 0; i--)  //µå·ÓµÈ ÆÄÀÏ °¹¼ö¸¸Å­ ·çÇÁ¸¦ µ¹¸é¼­ ÆÄÀÏ °æ·Î¸¦ ¸Þ¼¼Áö ¹Ú½º·Î Ãâ·Â
	{
		// ÆÄÀÏÀÇ °æ·Î ¾ò¾î¿È
		::DragQueryFile(hDropInfo, i, szPathName, MAX_PATH);

		SetDlgItemText(IDC_EDIT_RAWFILENAME, szPathName);
		((CEdit*)GetDlgItem(IDC_EDIT_RAWFILENAME))->SetSel((int)strlen(szPathName),(int)strlen(szPathName), FALSE);
		break;
	}

	::DragFinish(hDropInfo);
	CDialog::OnDropFiles(hDropInfo);
}

LRESULT CDitGlassRawMessengerDlg::OnLoggerDataUpdate( WPARAM wParam, LPARAM lParam )
{
	//m_ctrlLoggerList.SetRedraw(FALSE);
	int nItemCount = CakLoggerExt::getInstance()->GetLogDataNum();
	
	if(nItemCount != m_ctrlLoggerList.GetItemCount() ) m_ctrlLoggerList.SetItemCount(nItemCount);
	
	if(CakLoggerExt::getInstance()->m_bScrollAuto)
	{
		
		int nEnsureIdx = nItemCount-1;
		//m_ctrlLoggerList.SetSelectionMark(nEnsureIdx);
		//m_ctrlLoggerList.SetItemState(i, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
		m_ctrlLoggerList.EnsureVisible(nEnsureIdx, FALSE);
		
	}
	m_ctrlLoggerList.Invalidate(FALSE);
	//m_ctrlLoggerList.SetRedraw(TRUE);
	return 0;
}

void CDitGlassRawMessengerDlg::OnLvnGetdispinfoListLog(NMHDR *pNMHDR, LRESULT *pResult)
{
	NMLVDISPINFO *pDispInfo = reinterpret_cast<NMLVDISPINFO*>(pNMHDR);

	char buffer[256]={};

	if(pDispInfo->item.iItem >= 0) 
	{
		int nDataIndex = pDispInfo->item.iItem;
		CakLogger::_LoggerData* pData = CakLoggerExt::getInstance()->GetLogData(nDataIndex);

		if(pData)
		{
			switch(pDispInfo->item.iSubItem)
			{
			case 0:
				sprintf(buffer, "%d", pData->nIndex); 
				pDispInfo->item.pszText = buffer;
				break;
			case 1:
				sprintf(buffer, "%02d:%02d:%02d.%03d", pData->stTime.wHour, pData->stTime.wMinute, pData->stTime.wSecond, pData->stTime.wMilliseconds); 
				pDispInfo->item.pszText = buffer;
				break;
			case 2:
				pDispInfo->item.pszText = pData->pData;
				break;
			}
		}
		else 
		{
			pDispInfo->item.pszText = "";
		}

	}


	*pResult = 0;
}


void CDitGlassRawMessengerDlg::threadMain( void* arg )
{
	CDitGlassRawMessengerDlg* pThis = (CDitGlassRawMessengerDlg*) arg;
	pThis->m_nThreadMainFlag = 1;
	while(pThis->m_nThreadMainFlag == 1)
	{
		pThis->MainProcess();

		Sleep(10);
	}
	pThis->m_nThreadMainFlag = 0;
}

void CDitGlassRawMessengerDlg::MainProcess()
{
	_grmDitGlassRawInfo* pRawInfo = m_Server.GetGlassRawInfo();

	if(pRawInfo->m_nCommandIdxWrite != pRawInfo->m_nCommandIdxRead)
	{
		int nReadIdx = (pRawInfo->m_nCommandIdxRead+1)%COMMAND_MAXCOUNT; //ÇöÀç´Â ÀÐÀº ¸¶Áö¸· Æ÷ÀÎÆ®ÀÓÀ¸·Î Çϳª Áõ°¡½ÃÄѼ­ Àд´Ù. [±èÅÂÇö 2018/11/13]
		_grmDitCommand::_grmCommand* pCommand = &pRawInfo->m_nCommandBuffer[nReadIdx];
		AKLOG("Recv Command ID:%d(r%d/w%d)", pCommand->nCommand, nReadIdx, pRawInfo->m_nCommandIdxWrite);
		pRawInfo->m_nCommandIdxRead = nReadIdx;

		if(pCommand->nResult == -1) //¸í·É ¼öÇà Àü [±èÅÂÇö 2018/11/13]
		{
			pCommand->nResult = ProcessCommand( (emGlassRawCommand)pCommand->nCommand, pCommand->strParam );
		}
		else
		{
			//ÀÌ¹Ì Ã³¸® µÈ°Å [±èÅÂÇö 2018/11/13]
		}

		AKLOG("Recv Command ID:%d(r%d/w%d) Process End(Result:%d)", pCommand->nCommand, nReadIdx, pRawInfo->m_nCommandIdxWrite, pCommand->nResult);
	}
}


char* CDitGlassRawMessengerDlg::GetAOIProcStepToString( emAOIProcStep nCmd )
{
	switch(nCmd)
	{
	case grcSequenceGlassLoading:   return "SequenceGlassLoading";
	case grcSequenceInspectEnd:		return "SequenceInspectEnd";
	case grcSequenceReviewStart:	return "SequenceReviewStart";
	case grcSequenceReviewEnd:		return "SequenceReviewEnd";
	case grcWriteRaw:				return "WriteRaw";
	case grcReadRaw:				return "ReadRaw";
	case grcWriteBin:				return "WriteBin";
	case grcReadBin:				return "ReadBin";
	}
	return "";
}


int CDitGlassRawMessengerDlg::ProcessCommand( emGlassRawCommand nCmd, char* pParam )
{
	int nResult = 0;
	CDitGlassRawServer* pServer = (CDitGlassRawServer*) &m_Server;

	CgrmGlassRawData* pRawDataBuffer = &m_GlassRawDataBuffer;
	pRawDataBuffer->ImportGlassRaw(pServer->GetGlassRawInfo(), (char*)pServer->GetGlassData(), true);
	
	switch(nCmd)
	{
	case grcSequenceGlassLoading:
		{
			nResult = m_pGlassRawMaker->SequenceGlassLoading(pRawDataBuffer);
			pServer->GetGlassRawInfo()->m_ServerProcStep = APS_GlassLoading;
			pServer->GetGlassRawInfo()->m_nGlassLoadingCount++;
			break;
		}
	case grcSequenceInspectEnd:
		{
			nResult = m_pGlassRawMaker->SequenceInspectEnd(pRawDataBuffer);
			pServer->GetGlassRawInfo()->m_ServerProcStep = APS_InspectEnd;
			//Stack Á¤º¸¸¦ °øÀ¯¸Þ¸ð¸®¿¡ ¹Ý¿µ Çϱâ À§ÇÑ Export
			//pRawDataBuffer->ExportGlassRaw(pServer->GetGlassRawInfo(), (char*)pServer->GetGlassData());
			break;
		}
	case grcSequenceReviewStart:
		{
			nResult = m_pGlassRawMaker->SequenceReviewStart(pRawDataBuffer);
			pServer->GetGlassRawInfo()->m_ServerProcStep = APS_ReviewStart;
			break;
		}
	case grcSequenceReviewEnd:
		{
			nResult = m_pGlassRawMaker->SequenceReviewEnd(pRawDataBuffer);
			pServer->GetGlassRawInfo()->m_ServerProcStep = APS_ReviewEnd;
			break;
		}
	case grcSequenceCustomReviewDataRead:
		{
			nResult = m_pGlassRawMaker->SequenceCustomizeReview(pRawDataBuffer);
			////Customize Review¸¦ À§ÇÑ ¾÷µ¥ÀÌÆ®
			//{
			//	memcpy(pServer->GetDefectData(0), pRawDataBuffer->GetDefectData(0), sizeof(_grmDefectData)*pServer->GetGlassRawInfo()->m_nDefectMaxDataNum);
			//	memcpy(pServer->GetCellData(0), pRawDataBuffer->GetCellData(0), sizeof(_grmCellData)*pServer->GetGlassRawInfo()->m_nCellMaxDataNum);
			//	memcpy(pServer->GetBlockData(), pRawDataBuffer->GetBlockData(0), sizeof(_grmBlockData));
			//	memcpy(pServer->GetGlassData(), pRawDataBuffer->GetGlassData(), sizeof(_grmGlassData));
			//}
			//pServer->GetGlassRawInfo()->m_ServerProcStep = APS_CustomReviewRead;
			break;
		}
	case grcWriteRaw:
		{
			nResult = m_pGlassRawMaker->WriteAOIFile(pRawDataBuffer);
			break;
		}
	case grcReadRaw:
		{
			nResult = m_pGlassRawMaker->ReadAOIFile(pRawDataBuffer);
			break;
		}
	case grcWriteBin:
		{
			nResult = m_pGlassRawMaker->WriteBinFile(pRawDataBuffer);
			break;
		}
	case grcReadBin:
		{
			nResult = m_pGlassRawMaker->ReadBinFile(pRawDataBuffer);
			break;
		}
	case grcReviewWriteBIn:
		{
			nResult = m_pGlassRawMaker->ReviewWriteBin(pRawDataBuffer);
			break;
		}
 
	}
	
	PostMessage(UM_GLASSRAW_CLIENTMESSAGE, nCmd);

	return nResult;
}

void CDitGlassRawMessengerDlg::OnCbnSelchangeComboRawtype()
{
	CComboBox* pCombo = (CComboBox*)GetDlgItem(IDC_COMBO_RAWTYPE);

	if(m_pGlassRawMaker && m_ConfigOption.m_nSelectRawType == pCombo->GetCurSel()) return ;

	CGlassRawBase* pNewRawMaker = NULL;

	int nIndex = pCombo->GetCurSel();
	CString strText;
	pCombo->GetLBText(nIndex, strText);
	if(nIndex < 0 || strText.IsEmpty()) return ;
	
	if(strText.Compare(CGlassRawDemo::GetClassName()) == 0)
	{
		pNewRawMaker = new CGlassRawDemo;
	}
	else if(strText.Compare(CGlassRawCSOT::GetClassName()) == 0)
	{
		pNewRawMaker = new CGlassRawCSOT;
	}
	else if(strText.Compare(CGlassRawCEC::GetClassName()) == 0)
	{
		pNewRawMaker = new CGlassRawCEC;
	}
	else if (strText.Compare(CGlassRawCPJT::GetClassName()) == 0)
	{
		pNewRawMaker = new CGlassRawCPJT;
	}
	else
	{
		pNewRawMaker = new CGlassRawCSOT;
	}

	if(m_pGlassRawMaker) delete m_pGlassRawMaker;
	
	m_pGlassRawMaker = pNewRawMaker;

	m_ConfigOption.m_nSelectRawType = nIndex;
	WriteConfigFile();

}


BOOL CDitGlassRawMessengerDlg::DestroyWindow()
{
	if(m_nThreadMainFlag != 0)
	{
		m_nThreadMainFlag = 2;
		while(m_nThreadMainFlag != 0)
		{
			Sleep(1);
		}
	}
	
	if(m_pGlassRawMaker) delete m_pGlassRawMaker;
	
	if(m_TrayIcon) // ÇöÀç Æ®·¹ÀÌ ¾ÆÀÌÄÜÀ¸·Î ¼³Á¤µÇ¾ú´ÂÁö È®ÀÎ
	{
		NOTIFYICONDATA nid;
		nid.cbSize = sizeof(nid);
		nid.hWnd = m_hWnd; // ¸ÞÀÎ À©µµ¿ì ÇÚµé
		nid.uID = IDR_MAINFRAME;

		// ÀÛ¾÷ Ç¥½ÃÁÙ(TaskBar)ÀÇ »óÅ ¿µ¿ª¿¡ ¾ÆÀÌÄÜÀ» »èÁ¦ÇÑ´Ù.
		Shell_NotifyIcon(NIM_DELETE, &nid);
	}

	return CDialog::DestroyWindow();
}

void CDitGlassRawMessengerDlg::initGridGlassInfo( CakGridCtrl* pGrid, UINT nRectCtrlID )
{
	std::vector<CString>* pVecHeader = &m_vecStrGridGlassHeader;

	CRect rectGrid;
	GetDlgItem(nRectCtrlID)->GetWindowRect(&rectGrid);
	ScreenToClient(&rectGrid);
	pGrid->Create(rectGrid, this, nRectCtrlID);


	pGrid->GetDefaultCell(TRUE, FALSE)->SetBackClr(GRID_FIX_COLOR);
	pGrid->GetDefaultCell(FALSE, TRUE)->SetBackClr(GRID_FIX_COLOR);
	pGrid->GetDefaultCell(FALSE, FALSE)->SetBackClr(GRID_COLOR);
	pGrid->SetFixedBkColor(GRID_FIX_COLOR);
	pGrid->SetGridLines(GVL_BOTH);	

	pGrid->SetColumnCount((int)pVecHeader->size());
	pGrid->SetDoubleBuffering(TRUE);	
	pGrid->SetRowCount(2);
	pGrid->SetFixedRowCount(1);
	pGrid->SetFixedColumnCount(0);

	pGrid->SetEditable(FALSE);	
	pGrid->EnableSelection(TRUE);
	pGrid->SetFixedRowSelection(TRUE);	
	//pGrid->SetSingleRowSelection(TRUE);
	//pGrid->SetSingleColSelection(TRUE);
	//pGrid->SetHeaderSort(TRUE);
	pGrid->SetHeaderSort(FALSE);

	CString str;	
	GV_ITEM Item;	
	int		nCol = 0;
	int		iLoop;

	
	Item.mask = GVIF_TEXT;	
	Item.row = 0;
	for(iLoop=0;iLoop<pVecHeader->size();iLoop++)
	{
		Item.col = nCol++;	
		
		Item.strText = (*pVecHeader)[iLoop];
		pGrid->SetItem(&Item);	
	}	
	Item.row = 1;
	Item.col = 0;
	Item.strText = " ";
	pGrid->SetItem(&Item);	

	//pGrid->Invalidate();
	pGrid->AutoSize();
}

void CDitGlassRawMessengerDlg::initGridCellInfo( CakGridCtrl* pGrid, UINT nRectCtrlID )
{
	std::vector<CString>* pVecHeader = &m_vecStrGridCellHeader;

	CRect rectGrid;
	GetDlgItem(nRectCtrlID)->GetWindowRect(&rectGrid);
	ScreenToClient(&rectGrid);
	pGrid->Create(rectGrid, this, nRectCtrlID);



	pGrid->GetDefaultCell(TRUE, FALSE)->SetBackClr(GRID_FIX_COLOR);
	pGrid->GetDefaultCell(FALSE, TRUE)->SetBackClr(GRID_FIX_COLOR);
	pGrid->GetDefaultCell(FALSE, FALSE)->SetBackClr(GRID_COLOR);
	pGrid->SetFixedBkColor(GRID_FIX_COLOR);
	pGrid->SetGridLines(GVL_BOTH);	

	pGrid->SetVirtualMode(TRUE);
	pGrid->SetCallbackFunc(NULL, 0);
	pGrid->AllowReorderColumn(FALSE); // implemented now only if m_bCallback
	pGrid->EnableDragRowMode(FALSE);

	pGrid->SetColumnCount((int)pVecHeader->size());
	pGrid->SetDoubleBuffering(TRUE);	
	pGrid->SetRowCount(2);
	pGrid->SetFixedRowCount(1);
	pGrid->SetFixedColumnCount(0);

	pGrid->SetEditable(FALSE);	
	pGrid->EnableSelection(TRUE);
	pGrid->SetFixedRowSelection(TRUE);	
	//pGrid->SetSingleRowSelection(TRUE);
	//pGrid->SetSingleColSelection(TRUE);
	//pGrid->SetHeaderSort(TRUE);
	pGrid->SetHeaderSort(FALSE);

	

	// fill it up with stuff
	pGrid->SetEditable(TRUE);
	pGrid->EnableDragAndDrop(TRUE);




	pGrid->AutoSize();
	pGrid->Invalidate();
}

void CDitGlassRawMessengerDlg::initGridDefectInfo( CakGridCtrl* pGrid, UINT nRectCtrlID )
{
	std::vector<CString>* pVecHeader = &m_vecStrGridDefectHeader;

	CRect rectGrid;
	GetDlgItem(nRectCtrlID)->GetWindowRect(&rectGrid);
	ScreenToClient(&rectGrid);
	pGrid->Create(rectGrid, this, nRectCtrlID);

	

	pGrid->GetDefaultCell(TRUE, FALSE)->SetBackClr(GRID_FIX_COLOR);
	pGrid->GetDefaultCell(FALSE, TRUE)->SetBackClr(GRID_FIX_COLOR);
	pGrid->GetDefaultCell(FALSE, FALSE)->SetBackClr(GRID_COLOR);
	pGrid->SetFixedBkColor(GRID_FIX_COLOR);
	pGrid->SetGridLines(GVL_BOTH);	


	pGrid->SetVirtualMode(TRUE);
	pGrid->SetCallbackFunc(NULL, 0);
	pGrid->AllowReorderColumn(FALSE); // implemented now only if m_bCallback
	pGrid->EnableDragRowMode(FALSE);

	pGrid->SetColumnCount((int)pVecHeader->size());
	pGrid->SetDoubleBuffering(TRUE);	
	pGrid->SetRowCount(2);
	pGrid->SetFixedRowCount(1);
	pGrid->SetFixedColumnCount(0);

	pGrid->SetEditable(FALSE);	
	pGrid->EnableSelection(TRUE);
	pGrid->SetFixedRowSelection(TRUE);	
	//pGrid->SetSingleRowSelection(TRUE);
	//pGrid->SetSingleColSelection(TRUE);
	//pGrid->SetHeaderSort(TRUE);
	pGrid->SetHeaderSort(FALSE);

	// fill it up with stuff
	pGrid->SetEditable(TRUE);
	pGrid->EnableDragAndDrop(TRUE);


	pGrid->AutoSize();
	pGrid->Invalidate();
}

BOOL CDitGlassRawMessengerDlg::OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult)
{
	// TODO: ¿©±â¿¡ Ư¼öÈ­µÈ Äڵ带 Ãß°¡ ¹×/¶Ç´Â ±âº» Ŭ·¡½º¸¦ È£ÃâÇÕ´Ï´Ù.
	if (m_gridCellInfo.GetSafeHwnd() && wParam == (WPARAM)m_gridCellInfo.GetDlgCtrlID())
	{
		*pResult = 1;
		GV_DISPINFO *pDispInfo = (GV_DISPINFO*)lParam;
		if (GVN_GETDISPINFO == pDispInfo->hdr.code)
		{
			getDispInfoCell(pDispInfo->item.col, pDispInfo->item.row, &pDispInfo->item.strText);

			return TRUE;
		}
		else if (GVN_ODCACHEHINT == pDispInfo->hdr.code)
		{
			GV_CACHEHINT *pCacheHint = (GV_CACHEHINT*)pDispInfo;
			// 			Trace(_T("Cache hint received for cell range %d,%d - %d,%d\n"),
			// 				pCacheHint->range.GetMinRow(), pCacheHint->range.GetMinCol(),
			// 				pCacheHint->range.GetMaxRow(), pCacheHint->range.GetMaxCol());
		}
	}
	else if (m_gridDefectInfo.GetSafeHwnd() && wParam == (WPARAM)m_gridDefectInfo.GetDlgCtrlID())
	{
		*pResult = 1;
		GV_DISPINFO *pDispInfo = (GV_DISPINFO*)lParam;
		if (GVN_GETDISPINFO == pDispInfo->hdr.code)
		{
			getDispInfoDefect(pDispInfo->item.col, pDispInfo->item.row, &pDispInfo->item.strText);

			return TRUE;
		}
		else if (GVN_ODCACHEHINT == pDispInfo->hdr.code)
		{
			GV_CACHEHINT *pCacheHint = (GV_CACHEHINT*)pDispInfo;
			// 			Trace(_T("Cache hint received for cell range %d,%d - %d,%d\n"),
			// 				pCacheHint->range.GetMinRow(), pCacheHint->range.GetMinCol(),
			// 				pCacheHint->range.GetMaxRow(), pCacheHint->range.GetMaxCol());
		}
	}	
	return CDialog::OnNotify(wParam, lParam, pResult);
}

void CDitGlassRawMessengerDlg::updateGridGlassInfo()
{
	_grmGlassData* pGlass = m_Server.GetGlassData();
	CakGridCtrl* pGrid = &m_gridGlassInfo;

	CString strItem;

	strItem.Format("%d", m_Server.GetGlassRawInfo()->m_nGlassLoadingCount); pGrid->SetItemText(1, 0, strItem);//"No"
	strItem.Format("%s", pGlass->m_strGlassID); pGrid->SetItemText(1, 1, strItem);//"GlassID"
	strItem.Format("%s", pGlass->m_strGlassJudge); pGrid->SetItemText(1, 2, strItem);//"Judge"
	strItem.Format("%s", pGlass->m_strVCRResult); pGrid->SetItemText(1, 3, strItem);//"VCR"
	strItem.Format("%s", pGlass->m_strFileName); pGrid->SetItemText(1, 4, strItem);//"FileName"
	strItem.Format("%d", 0); pGrid->SetItemText(1, 5, strItem);//"GlassLoading"
	strItem.Format("%d", 0); pGrid->SetItemText(1, 6, strItem);//"InspectEnd"
	strItem.Format("%s", pGlass->m_strPath); pGrid->SetItemText(1, 7, strItem);//"FileName"

	
	SetDlgItemText(IDC_STATIC_CLIENTCMD, GetAOIProcStepToString(m_Server.GetGlassRawInfo()->m_ClientProcStep));
	SetDlgItemText(IDC_STATIC_SERVERCMD, GetAOIProcStepToString(m_Server.GetGlassRawInfo()->m_ServerProcStep));

	pGrid->AutoSize();
	
}


void CDitGlassRawMessengerDlg::getDispInfoCell( int nCol, int nRow, CString* pStrData )
{
	if(nRow < 0) return;

	if(nRow == 0) //header
	{
		*pStrData = m_vecStrGridCellHeader[nCol];
	}
	else
	{
		CString		strItem;

		int nDataIndex = nRow -1;

		if(nDataIndex >= m_Server.GetGlassData()->m_nCellNum) return;

		_grmCellData* pCell = m_Server.GetCellData(nDataIndex);

		if(pCell == NULL)
			return;


		switch(nCol)
		{
		case  0: strItem.Format("%d",nRow); break;	//"No");
		case  1: strItem.Format("%d",pCell->m_nCellID); break;	//"Idx");
		case  2: strItem.Format("%s",pCell->m_strCellName); break;	//"Name");
		case  3: strItem.Format("%d,%d,%d,%d",pCell->m_rectCellLeft, pCell->m_rectCellTop, pCell->m_rectCellRight, pCell->m_rectCellBottom); break;	//"Rect");
		case  4: strItem.Format("%d",pCell->m_nJudgement); break;	//"Judge");
		case  5: strItem.Format("%d",pCell->m_nDefectNumLocActive);break;
		case  6: strItem.Format("%d",pCell->m_nDefectNumLocPad);break;
		case  7: strItem.Format("%d",pCell->m_nDefectNumLocCrack);break;
		case  8: strItem.Format("%d",pCell->m_nDefectNumSizeSmall);break;
		case  9: strItem.Format("%d",pCell->m_nDefectNumSizeMid);break;
		case 10: strItem.Format("%d",pCell->m_nDefectNumSizeLarge);break;
		case 11: strItem.Format("%d",pCell->m_nDefectNumSizeHuge);break;
		case 12: strItem.Format("%d",pCell->m_nDefectNumSizeUltra);break;
		case 13: strItem.Format("%d",pCell->m_nDefectNumTypeTB); break; //"TB");
		case 14: strItem.Format("%d",pCell->m_nDefectNumTypeTW);	break; //"TW");
		case 15: strItem.Format("%d",pCell->m_nDefectNumTypeRB);	break; //"RB");
		case 16: strItem.Format("%d",pCell->m_nDefectNumTypeRW);	break; //"RW");
		case 17: strItem.Format("%d",pCell->m_nDefectNumTypeMD);	break; //"MD");
		case 18: strItem.Format("%d",pCell->m_nDefectNumTypeCD); break; //"CD");
		case 19: strItem.Format("%d",pCell->m_nDefectNumTypeMC); break; //"MC");
		}
		*pStrData = strItem;
	}
	
}

void CDitGlassRawMessengerDlg::getDispInfoDefect( int nCol, int nRow, CString* pStrData )
{
	if(nRow < 0) return;

	if(nRow == 0) //header
	{
		*pStrData = m_vecStrGridDefectHeader[nCol];
	}
	else
	{
		int nDataIndex = nRow -1;

		if(nDataIndex >= m_Server.GetGlassData()->m_nDefectNum) return;

		_grmDefectData* pDefect = m_Server.GetDefectData(nDataIndex);

		if(pDefect == NULL)
			return;

		CString		strItem;
		BOOL		bPixel = FALSE;

		switch(nCol)
		{
		case 0: strItem.Format("%d",nRow); break;
		case 1: strItem.Format("%d",pDefect->m_nDefectID); break;
		case 2:
			{
				strItem = _T("");
				if (pDefect->m_sDefectLoc == DefectLoc_Pattern)
					strItem = "Pat";
				else if (pDefect->m_sDefectLoc == DefectLoc_PAD)
					strItem = "PAD";
				else if (pDefect->m_sDefectLoc == DefectLoc_C2C)
					strItem = "C2C";
				else if (pDefect->m_sDefectLoc == DefectLoc_Crack)
					strItem = "Crk";
				else if (pDefect->m_sDefectLoc == DefectLoc_ASG)
					strItem = "ASG";
				else if (pDefect->m_sDefectLoc == DefectLoc_BM)
					strItem = "BM";
				else
					strItem = "Pat";
			}
			break;
		case 3:	strItem = pDefect->m_strDefectType;	break;
		case 4: strItem.Format("%s", pDefect->m_strDefectCode); break;
		case 5:
			{
				if(pDefect->m_DefectType == DefectType_RBlack)
					strItem.Format("RB");
				else if(pDefect->m_DefectType == DefectType_RWhite)
					strItem.Format("RW");
				else if(pDefect->m_DefectType == DefectType_TBlack)
					strItem.Format("TB");
				else if(pDefect->m_DefectType == DefectType_TWhite)
					strItem.Format("TW");
				else
					strItem = "UN";
			}
			break;
		case 6:
			{
				strItem = _T("");

				if (pDefect->m_DefectSubType == DefectSubType_MC)						// Common 05 M/N/C/S/K/*
					strItem = "MC";
				else if (pDefect->m_DefectSubType == DefectSubType_Mask)
					strItem = "MD";
				else if (pDefect->m_DefectSubType == DefectSubType_Common)
					strItem = "CD";
				else if (pDefect->m_DefectSubType == DefectSubType_NoDefect)
					strItem = "NO";
				else
					strItem = "N";
			}
			break;
		case 7: strItem.Format("%d",pDefect->m_nDefectRScale); break;
		case 8:
			{
				if (bPixel)
				{
					strItem = _T("");
					strItem.Format("% 7d", pDefect->m_sPixelWidth);
				}
				else
				{
					strItem = _T("");
					strItem.Format("% 7d", pDefect->m_nUMSizeX);
				}
			}
			break;
		case 9:
			{
				if (bPixel)
				{
					strItem = _T("");
					strItem.Format("% 7d", pDefect->m_sPixelHeight);
				}
				else
				{
					strItem = _T("");
					strItem.Format("% 7d", pDefect->m_nUMSizeY);
				}
			}
			break;
		case 10:
			if (bPixel)
				strItem.Format("%d",pDefect->m_nPixelSize);
			else
				strItem.Format("%d",pDefect->m_nUMSize);
			break;
		case 11:
			{
				int nValue = 0;
				for (int i = 15; i >= 0; i--)
				{
					if (pDefect->m_sZonePixelCount[i] > 0)
						nValue += 1;
					if (i > 0)
						nValue = nValue << 1;
				}

				strItem.Format("%04X", nValue);
			}
			break;
		case 12: strItem.Format("%d",pDefect->m_nLevelSrcMax); break;
		case 13: strItem.Format("%d",pDefect->m_nLevelSrcMin); break;
		case 14: strItem.Format("%d",pDefect->m_nLevelSrcAvg); break;
		case 15: strItem.Format("%d",pDefect->m_sDefectPeak); break;
		case 16:
			{
				strItem.Format("%s", pDefect->m_strStackFirst);
			}
			break;
		case 17:
			{
				strItem = _T("");
				strItem.Format("% 4d", pDefect->m_nCameraID);
			}
			break;
		case 18: strItem.Format("%d",pDefect->m_nScanIdx); break;
		case 19: strItem.Format("%d",pDefect->m_nLevelRefMax); break;
		case 20: strItem.Format("%d",pDefect->m_nLevelRefMin); break;
		case 21: strItem.Format("%d",pDefect->m_nLevelRefAvg); break;
		case 22:
			{
				if (bPixel)
				{
					if (1)//g_pBasic->GetScanCoordination() == SC_XCoord)
					{
						strItem = _T("");
						strItem.Format("% 7d", pDefect->m_nPixelScan);
					}
					else
					{
						strItem = _T("");
						strItem.Format("% 7d", pDefect->m_nPixelConv);
					}
				}
				else
				{
					CString		str;
					strItem = _T("          ");
					str.Format("%5.3f", (double)pDefect->m_nUMCenterAlignX / 1000.0);
					strItem.Insert(9 - str.GetLength(), str);
					strItem.TrimRight(" ");
				}
			}
			break;
		case 23:
			{
				if (bPixel)
				{
					if (1)//g_pBasic->GetScanCoordination() == SC_XCoord)
					{
						strItem = _T("");
						strItem.Format("% 7d", pDefect->m_nPixelConv);
					}
					else
					{
						strItem = _T("");
						strItem.Format("% 7d", pDefect->m_nPixelScan);
					}
				}
				else
				{
					CString		str;
					strItem = _T("          ");
					str.Format("% 5.3f", (double)pDefect->m_nUMCenterAlignY / 1000.0);
					strItem.Insert(9 - str.GetLength(), str);
					strItem.TrimRight(" ");
				}
			}
			break;
		case 24:
			{
				if (bPixel)
				{
					strItem = _T("");
					strItem.Format("% 7d", pDefect->m_nScanIdx);
				}
				else
				{
					CString		str;
					strItem = _T("          ");

					// Panel xÃà, yÃàÀº ±Û¶ó½º¿Í ¹Ý´ë [6/9/2017 bhs]
					if(1)//g_pBasic->GetScanCoordination() == SC_XCoord)
						str.Format("% 5.3f", (double)pDefect->m_nUMCellX / 1000.0);
					else
						str.Format("% 5.3f", (double)pDefect->m_nUMCellY / 1000.0);

					strItem.Insert(9 - str.GetLength(), str);
					strItem.TrimRight(" ");
				}
			}
			break;
		case 25:
			{
				if (bPixel)
				{
					strItem = _T("");
					strItem.Format("% 7d", pDefect->m_nPixelGlassStart);
				}
				else
				{
					CString		str;
					strItem = _T("          ");

					// Panel xÃà, yÃàÀº ±Û¶ó½º¿Í ¹Ý´ë [6/9/2017 bhs]
					if(1)//g_pBasic->GetScanCoordination() == SC_XCoord)
						str.Format("% 5.3f", (double)pDefect->m_nUMCellY / 1000.0);
					else
						str.Format("% 5.3f", (double)pDefect->m_nUMCellX / 1000.0);

					strItem.Insert(9 - str.GetLength(), str);
					strItem.TrimRight(" ");
				}
			}
			break;
		case 26: strItem.Format("%d", pDefect->m_nScratchRatio); break;
		case 27: strItem.Format("%d", pDefect->m_nDensity); break;
		case 28: strItem.Format("%d", pDefect->m_bMergeState); break;
		}

		*pStrData = strItem;
	}
}




void CDitGlassRawMessengerDlg::OnBnClickedTestLog1()
{
	AKLOG("Ak Logger Test ");
}

void CDitGlassRawMessengerDlg::OnBnClickedTestLog2()
{
	for(int i=0; i<50; i++)
	{
		AKLOG("Ak Logger Test %d", i);
	}
}

void CDitGlassRawMessengerDlg::OnBnClickedLogClear()
{
	CakLoggerExt::getInstance()->resetLogCount();
	OnLoggerDataUpdate(0,0);
}

void CDitGlassRawMessengerDlg::OnBnClickedLogFileopen()
{
	CakLoggerExt::getInstance()->LogFileOpen();
}

void CDitGlassRawMessengerDlg::WriteConfigFile()
{
	CakFileDB akFileDB;
	akFileDB.openfile(m_strConfigFile);
	akFileDB.setItem("DataMaxNumCell", m_ConfigOption.m_nMaxDataNumCell);
	akFileDB.setItem("DataMaxNumDefect", m_ConfigOption.m_nMaxDataNumDefect);
	akFileDB.setItem("SelectRawType", m_ConfigOption.m_nSelectRawType);
	akFileDB.setItem("LogFilePath", m_ConfigOption.m_strLogFilePath);

	akFileDB.setItem("Stack_Use", m_ConfigOption.m_bUseStack);
	akFileDB.setItem("Stack_LocalPath", m_ConfigOption.m_strStackLocalPath);
	akFileDB.setItem("RawMerge_Use", m_ConfigOption.m_bUseRawMerge);
	akFileDB.setItem("RawMerge_LocalPath", m_ConfigOption.m_strRawMergeLocalPath);
	akFileDB.setItem("Stack_EquipID", m_ConfigOption.m_strStackEquipID);
	akFileDB.setItem("Stack_Param1",m_ConfigOption.m_strStackParam1);
	akFileDB.setItem("Stack_Param2",m_ConfigOption.m_strStackParam2);

	akFileDB.savefile(m_strConfigFile);
}

void CDitGlassRawMessengerDlg::OnBnClickedChkAdminmode()
{
	CButton* pBtn = (CButton*)GetDlgItem(IDC_CHK_ADMINMODE);
	BOOL bEnable = FALSE;
	if(pBtn->GetCheck()) bEnable = TRUE;
	
	GetDlgItem(IDC_COMBO_RAWTYPE)->EnableWindow(bEnable);
	GetDlgItem(IDC_BTN_EXPORT_RAW)->EnableWindow(bEnable);
	GetDlgItem(IDC_BTN_IMPORT_RAW)->EnableWindow(bEnable);
	GetDlgItem(IDC_BTN_EXPORT_BIN)->EnableWindow(bEnable);
	GetDlgItem(IDC_BTN_IMPORT_BIN)->EnableWindow(bEnable);
	GetDlgItem(IDC_BTN_FTP_MANUALUPLOAD)->EnableWindow(bEnable);
	

	GetDlgItem(IDC_CMB_COMMAND)->EnableWindow(bEnable);
	GetDlgItem(IDC_TEST_CMD)->EnableWindow(bEnable);

	GetDlgItem(IDC_TEST1)->ShowWindow(bEnable ? SW_SHOW : SW_HIDE);
	GetDlgItem(IDC_TEST2)->ShowWindow(bEnable ? SW_SHOW : SW_HIDE);
	
}

LRESULT CDitGlassRawMessengerDlg::OnClientMessage( WPARAM wParam, LPARAM lParam )
{
	OnBnClickedBtnRefresh();

	return 0;
}

void CDitGlassRawMessengerDlg::OnBnClickedBtnRefresh()
{
	int nDefectRowNum = max(m_Server.GetGlassData()->m_nDefectNum, 2);
	int nCellRowNum = max(m_Server.GetGlassData()->m_nCellNum, 2);
	m_gridDefectInfo.SetRowCount(nDefectRowNum);
	m_gridCellInfo.SetRowCount(nCellRowNum + 1);
	m_gridDefectInfo.Invalidate();
	m_gridCellInfo.Invalidate();
	updateGridGlassInfo();
}

void CDitGlassRawMessengerDlg::OnBnClickedBtnImportBin()
{
	CFileDialog	filedlg( TRUE, "*.bin", NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, "AOI Bin File (*.bin)|*.bin");
	if(IDCANCEL == filedlg.DoModal())	
		return;

	CgrmGlassRawData RawData;
	RawData.ImportGlassRaw(m_Server.GetGlassRawInfo(), NULL);

	strcpy(RawData.GetGlassData()->m_strFileName, filedlg.GetFileName().GetBuffer());
	strcpy(RawData.GetGlassData()->m_strPath, filedlg.GetPathName().GetBuffer());
	RawData.GetGlassData()->m_strPath[filedlg.GetPathName().GetLength()-filedlg.GetFileName().GetLength()] = 0;


	BOOL bRetReadBin = m_pGlassRawMaker->ReadBinFile(&RawData);
	if(bRetReadBin == FALSE)
	{
		AKLOG("Bin File Import(Read Bin File Process) %s %s", bRetReadBin?"Success":"Fail",RawData.GetGlassData()->m_strFileName);
		return;
	}

	BOOL bRetValue = RawData.ExportGlassRaw(m_Server.GetGlassRawInfo(), (char*)m_Server.GetGlassData());
	AKLOG("Bin File Import %s %s", bRetValue?"Success":"Fail",RawData.GetGlassData()->m_strFileName);

	PostMessage(UM_GLASSRAW_CLIENTMESSAGE);
}

void CDitGlassRawMessengerDlg::OnBnClickedBtnExportBin()
{
	CFileDialog	filedlg( FALSE, "*.bin", NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, "AOI Bin File (*.bin)|*.bin|");
	if(IDCANCEL == filedlg.DoModal())	
		return;

	CgrmGlassRawData RawData;
	RawData.ImportGlassRaw(m_Server.GetGlassRawInfo(), (char*)m_Server.GetGlassData());
	strcpy(RawData.GetGlassData()->m_strFileName, filedlg.GetFileName().GetBuffer());
	strcpy(RawData.GetGlassData()->m_strPath, filedlg.GetPathName().GetBuffer());
	RawData.GetGlassData()->m_strPath[filedlg.GetPathName().GetLength()-filedlg.GetFileName().GetLength()] = 0;



	BOOL bRetValue = m_pGlassRawMaker->WriteBinFile(&RawData);
	AKLOG("Bin File Export %s %s", bRetValue?"Success":"Fail",RawData.GetGlassData()->m_strFileName);
}

void CDitGlassRawMessengerDlg::OnBnClickedBtnImportRaw()
{
	AKLOG("À̱â´ÉÀº °¡±ÞÀû ÇÊ¿ä°¡ ÀÖ°Ú³ª.. ½ÍÀ¸³×...");
	PostMessage(UM_GLASSRAW_CLIENTMESSAGE);
}

void CDitGlassRawMessengerDlg::OnBnClickedBtnExportRaw()
{
	CFileDialog	filedlg( TRUE, "*.txt", "D:\\DIT_ResultData\\Raw\\*.txt", OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, "AOI Txt File (*.txt)|*.txt");
	if(IDCANCEL == filedlg.DoModal())	
		return;

	CgrmGlassRawData RawData;
	RawData.ImportGlassRaw(m_Server.GetGlassRawInfo(), (char*)m_Server.GetGlassData());
	strcpy(RawData.GetGlassData()->m_strFileName, filedlg.GetFileName().GetBuffer());
	strcpy(RawData.GetGlassData()->m_strPath, filedlg.GetPathName().GetBuffer());
	RawData.GetGlassData()->m_strPath[filedlg.GetPathName().GetLength()-filedlg.GetFileName().GetLength()] = 0;

	BOOL bRetValue = m_pGlassRawMaker->WriteBinFile(&RawData);
	AKLOG("AOI File Export %s %s", bRetValue?"Success":"Fail",RawData.GetGlassData()->m_strFileName);
}

BOOL CDitGlassRawMessengerDlg::PreTranslateMessage(MSG* pMsg)
{
	if( pMsg->message == WM_KEYDOWN )
	{
		if(pMsg->wParam == VK_RETURN
			|| pMsg->wParam == VK_ESCAPE )
		{
			return TRUE;                    // DO NOT process further
		}
		if(GetKeyState(VK_CONTROL) && pMsg->wParam != VK_CONTROL)
		{
			char nChar = (char)pMsg->wParam;

// 			m_nSecretKey[0] = m_nSecretKey[1];
// 			m_nSecretKey[1] = m_nSecretKey[2];
// 			m_nSecretKey[2] = m_nSecretKey[3];
// 			m_nSecretKey[3] = nChar;
// 
// 
// 			if(!strcmp(m_nSecretKey,"KKKK"))
// 			{
// 				AKLOG("Enter Secret Mode\n");
// 				m_bSecretOn = true;
// 			}
// 			else
// 			{
// 				m_bSecretOn = false;
// 			}
		}

	}

	return CDialog::PreTranslateMessage(pMsg);
}

void CDitGlassRawMessengerDlg::OnBnClickedTest1()
{
	for(int i=5000; i>=0; i--)
	{
		_grmDefectData* pDefect = m_Server.GetDefectData(i);
		pDefect->clear();
		pDefect->m_nDefectID = i;
	}
	for(int i=0; i<5000; i++)
	{
		_grmDefectData* pDefect = m_Server.GetDefectData(i);
		
		TRACE("%d ", pDefect->m_nDefectID);
		if(i%10 == 0) TRACE("\n");
	}

	CgrmGlassRawData* pRawDataBuffer = &m_GlassRawDataBuffer;
	m_pGlassRawMaker->SequenceInspectEnd(pRawDataBuffer);
}

void CDitGlassRawMessengerDlg::OnBnClickedTest2()
{
	CgrmGlassRawData* pRawDataBuffer = &m_GlassRawDataBuffer;
	m_pGlassRawMaker->SequenceReviewEnd(pRawDataBuffer);
}

void CDitGlassRawMessengerDlg::OnBnClickedBtnStackapply()
{
	m_ConfigOption.m_bUseStack = ((CButton*)GetDlgItem(IDC_CHECK_STACKFILEREAD))->GetCheck();
	GetDlgItemText(IDC_EDIT_STACK_LOCALSAVEPATH,m_ConfigOption.m_strStackLocalPath, 256);
	m_ConfigOption.m_bUseRawMerge = ((CButton*)GetDlgItem(IDC_CHECK_RAWMERGEFILEREAD))->GetCheck();
	GetDlgItemText(IDC_EDIT_RAWMERGE_LOCALSAVEPATH, m_ConfigOption.m_strRawMergeLocalPath, 256);
	GetDlgItemText(IDC_EDIT_STACK_EQUIPID,m_ConfigOption.m_strStackEquipID, 32);
	GetDlgItemText(IDC_EDIT_STACK_PARAM1,m_ConfigOption.m_strStackParam1, 32);
	GetDlgItemText(IDC_EDIT_STACK_PARAM2,m_ConfigOption.m_strStackParam2, 32);
	
	WriteConfigFile();

	m_pGlassRawMaker->NotifyUpdateOptionInfo();
}

void CDitGlassRawMessengerDlg::OnBnClickedTestCmd()
{
	int nCmd = ((CComboBox*)GetDlgItem(IDC_CMB_COMMAND))->GetCurSel();

	CgrmGlassRawData* pRawDataBuffer = &m_GlassRawDataBuffer;

	switch (nCmd)
	{
	case 0: //Glass Loading
		{
			ProcessCommand(grcSequenceGlassLoading, NULL);
		}
		break;
	case 1: //Inspect End
		{
			ProcessCommand(grcSequenceInspectEnd, NULL);
		}
		break;
	case 2: //customize review recipe read;
		{
			ProcessCommand(grcSequenceCustomReviewDataRead, NULL);
		}
		break;
	case 3: //Review Start
		{
			ProcessCommand(grcSequenceReviewStart, NULL);
		}
		break;
	case 4: //Review End
		{
			ProcessCommand(grcSequenceReviewEnd, NULL);
		}
		break;
	}
}

void CDitGlassRawMessengerDlg::OnBnClickedBtnFtpManualupload()
{

	
	
		CString str = _T("All(*.*)|*.*|");	// ¼±ÅÃÇÒ ÆÄÀÏ Á¾·ù
		CString File;
		CString strFileList; 

		CFileDialog dlg(TRUE, NULL, NULL, OFN_ALLOWMULTISELECT, str, this);

		const int c_cMaxFiles = 400 /*¼±ÅÃÇÒ ÆÄÀÏ ¼ýÀÚ*/ ;	// ¸Þ¸ð¸® ºÎÁ·Çö»óÀ¸·Î È®Àå ¾ÈÇØÁÖ¸é ¸î°³ ¸ø¾¸
		const int c_cbBuffSize = (c_cMaxFiles * (MAX_PATH + 1)) + 1;
		dlg.GetOFN().lpstrFile = strFileList.GetBuffer(c_cbBuffSize);
		dlg.GetOFN().nMaxFile = c_cbBuffSize;
		dlg.GetOFN().lpstrInitialDir = "D:\\DIT_ResultData\\Raw\\";


		if( dlg.DoModal() == IDOK)
		{
			for(POSITION pos=dlg.GetStartPosition(); pos != NULL;)
			{
				// Àüü»èÁ¦´Â ResetContent
				File = dlg.GetNextPathName(pos);


				if(m_pGlassRawMaker)
				{
					m_pGlassRawMaker->SequenceFtpUpload(File.GetBuffer(0));
				}
			}
		}
	

	
}