SDC/A5_QD_CF_REVIEW.git

»õ ÆÄÀÏ
			@@ -0,0 +1,3839 @@
			ï»¿
			// ReveiwHistoryDlg.cpp: êµ¬í íì¼
			//

			#include "stdafx.h"
			#include "ReveiwHistory.h"
			#include "ReveiwHistoryDlg.h"
			#include "PathSettingDlg.h"
			#include "DitGlassRawStruct.h"
			#include "afxdialogex.h"
			#include "GlassRawCPJT.h"
			#include "akGridCtrl/GridCellCheck.h"
			#include "akImageView.h"
			#include <algorithm>

			#ifdef _DEBUG
			#define new DEBUG_NEW
			#endif

			// ìì© íë¡ê·¸ë¨ ì ë³´ì ì¬ì©ëë CAboutDlg ëí ìììëë¤.

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

			// ëí ìì ë°ì´í°ìëë¤.
			#ifdef AFX_DESIGN_TIME
			enum { IDD = IDD_ABOUTBOX };
			#endif

			protected:
			virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV ì§ììëë¤.

			// êµ¬íìëë¤.
			protected:
			DECLARE_MESSAGE_MAP()
			};

			CAboutDlg::CAboutDlg() : CDialogEx(IDD_ABOUTBOX)
			{
			}

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

			BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
			END_MESSAGE_MAP()

			// CReveiwHistoryDlg ëí ìì

			CReveiwHistoryDlg::CReveiwHistoryDlg(CWnd* pParent /=nullptr/)
			: CDialogEx(IDD_DLG_REVIEWHISTORY, pParent)
			, m_nFileCount(0)
			{
			m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);

			AddVecFileHeader();
			AddVecGlassHeader();
			AddVecDefectHeader();

			m_nSelectedRow = 0;
			m_nSelectedCol = 0;
			m_nCount = 0;
			m_nGlassSelect = 0;
			m_bDefectAll = false;
			m_bFirst = false;
			m_nSizeDefect = 0;
			m_nSizeImage = 0;
			m_nDefectCount = 0;
			m_nImageCount = 0;
			m_nCellCount = 0;
			m_bAsending = FALSE;

			for (int i = 0; i < 105; i++)
			{
			m_nSelectFile[i] = 0;
			m_nDefectSize[i] = 0;
			m_nCellSize[i] = 0;
			m_nCellSizeTemp[i] = m_nCellSize[i];
			m_nImageSize[i] = 0;
			}
			}

			void CReveiwHistoryDlg::DoDataExchange(CDataExchange* pDX)
			{
			CDialogEx::DoDataExchange(pDX);
			DDX_Control(pDX, IDC_SLIDER_IMG, m_sldImg);
			DDX_Control(pDX, IDC_EDIT_COUNT, m_ctrCount);
			DDX_Control(pDX, IDC_CHK_All_DEFECT, m_chkAllDefect);
			DDX_Control(pDX, IDC_CHK_REVIEW_DEFECT, m_chkReviewDefect);
			DDX_Control(pDX, IDC_CHK_MUTI, m_chkMuti);
			DDX_Control(pDX, IDC_CHK_SINGLE, m_chkSingle);
			DDX_Control(pDX, IDC_STATIC_IMG_REVIEW, m_ctrReviewImage);
			DDX_Text(pDX, IDC_EDIT_FILE_COUNT, m_nFileCount);
			DDX_Control(pDX, IDC_EDIT_FILE_COUNT, m_ctlFileCount);
			DDX_Control(pDX, IDC_PROGRESS_LOAD, m_ctlProgress);
			}

			BEGIN_MESSAGE_MAP(CReveiwHistoryDlg, CDialogEx)
			ON_WM_SYSCOMMAND()
			ON_WM_PAINT()
			ON_WM_QUERYDRAGICON()
			ON_WM_DESTROY()
			ON_WM_SIZE()
			ON_WM_HSCROLL()
			ON_BN_CLICKED(IDC_BUTTON_MAPVIEW_FIT, &CReveiwHistoryDlg::OnBnClickedButtonMapviewFit)
			ON_MESSAGE(UM_FORMMAP_DEFECTSELECT, OnMapDefectSelected)
			ON_MESSAGE(UM_FORMMAP_DEFECTMOUSEOVER, OnMapDefectMouseOver)
			ON_COMMAND(ID_OPTION_PATHSETTING, &CReveiwHistoryDlg::OnOptionPathsetting)
			ON_COMMAND(ID_VIEW_ALLDEFECT, &CReveiwHistoryDlg::OnViewAlldefect)
			ON_COMMAND(ID_VIEW_REVIEWDEFECT, &CReveiwHistoryDlg::OnViewReviewdefect)
			ON_COMMAND(ID_ALIGN_VIEW, &CReveiwHistoryDlg::OnAlignView)
			ON_BN_CLICKED(IDC_BTN_FIND_BIN, &CReveiwHistoryDlg::OnBnClickedBtnFindBin)
			ON_EN_CHANGE(IDC_EDIT_COUNT, &CReveiwHistoryDlg::OnChangeEditCount)
			ON_BN_CLICKED(IDC_BUTTON3, &CReveiwHistoryDlg::OnBnClickedButton3)
			ON_BN_CLICKED(IDC_CHK_All_DEFECT, &CReveiwHistoryDlg::OnClickedChkAllDefect)
			ON_BN_CLICKED(IDC_CHK_MUTI, &CReveiwHistoryDlg::OnClickedChkMuti)
			ON_BN_CLICKED(IDC_CHK_REVIEW_DEFECT, &CReveiwHistoryDlg::OnClickedChkReviewDefect)
			ON_BN_CLICKED(IDC_CHK_SINGLE, &CReveiwHistoryDlg::OnClickedChkSingle)
			ON_EN_CHANGE(IDC_EDIT_FILE_COUNT, &CReveiwHistoryDlg::OnChangeEditFileCount)
			ON_WM_KEYDOWN()
			END_MESSAGE_MAP()

			// CReveiwHistoryDlg ë©ìì§ ì²ë¦¬ê¸°

			BOOL CReveiwHistoryDlg::OnInitDialog()
			{
			CDialogEx::OnInitDialog();

			// ìì¤í ë©ë´ì "ì ë³´..." ë©ë´ íëª©ì ì¶ê°í©ëë¤.

			// IDM_ABOUTBOXë ìì¤í ëªë ¹ ë²ìì ìì´ì¼ í©ëë¤.
			ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
			ASSERT(IDM_ABOUTBOX < 0xF000);

			CMenu* pSysMenu = GetSystemMenu(FALSE);
			if (pSysMenu != nullptr)
			{
			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); // ìì ìì´ì½ì ì¤ì í©ëë¤.

			GetDlgItem(IDC_STATIC_FORMATIONMAP2)->GetWindowRect(m_picture_rect);
			GetDlgItem(IDC_STATIC_IMG_INSPECTOR)->GetWindowRect(m_picture_rect2);

			ScreenToClient(m_picture_rect);
			ScreenToClient(m_picture_rect2);

			GetDlgItem(IDC_STATIC_IMG_ALIGN1)->GetWindowRect(m_Align_rect);
			GetDlgItem(IDC_STATIC_IMG_ALIGN2)->GetWindowRect(m_Align_rect2);

			ScreenToClient(m_Align_rect);
			ScreenToClient(m_Align_rect2);

			m_ImageView.CreateGraph(this, m_picture_rect);
			m_ImageView.SetAutoScale();


			// TODO: ì¬ê¸°ì ì¶ê° ì´ê¸°í ììì ì¶ê°í©ëë¤.
			if (1)
			{
			CRect rectTemp;
			GetDlgItem(IDC_STATIC_FORMATIONMAP)->GetWindowRect(rectTemp);
			ScreenToClient(rectTemp);

			m_FormationMap.CreateGraph(this, rectTemp);
			}

			m_WndArrange.setParentWnd(this);
			m_WndArrange.addChildWnd(&m_FormationMap, WA_RESIZE_WIDTH \| WA_RESIZE_HEIGHT);

			GetDlgItem(IDC_STATIC_FORMATIONMAP)->BringWindowToTop();

			LOG(Dbg, _T("[Processe] Review History Start"));

			CreateUserDirectory();
			CreateUserClass();

			InitGridReviewLIst(&m_gridReviewList, IDC_STATIC_GRID_GLASS);
			InitGridDefectLIst(&m_gridDefectInfo, IDC_STATIC_GRID_DEFECT);
			InitGridGlassLIst(&m_gridGlassInfo, IDC_STATIC_GRID_GLASS_INFO);

			OnViewReviewdefect();

			m_chkReviewDefect.SetCheck(TRUE);
			m_chkSingle.SetCheck(TRUE);

			////////////////////////////////////////////////////////////////////////////////////////////////////////////
			m_ConfigOption.m_nMaxDataNumCell = 200;
			m_ConfigOption.m_nMaxDataNumDefect = 50000;

			if (m_Server.CreateServer(m_ConfigOption.m_nMaxDataNumCell, m_ConfigOption.m_nMaxDataNumDefect) == FALSE)
			{
			LOG(Dbg, _T("[Processe]ìë² ìì± ì¤í¨ ì¢ë£ í©ëë¤."));
			exit(0);
			}

			m_pGlassRawMaker = NULL;
			m_ConfigOption.m_nSelectRawType = 3;
			OnCbnSelchangeComboRawtype();
			//////////////////////////////////////////////////////////////////////////////////////////////////

			SlideInit();
			Imagenoload();

			m_ctlProgress.SetRange(0, 100);
			m_ctlProgress.ShowWindow(FALSE);

			return TRUE; // í¬ì»¤ì¤ë¥¼ ì»¨í¸ë¡¤ì ì¤ì íì§ ìì¼ë©´ TRUEë¥¼ ë°íí©ëë¤.
			}

			void CReveiwHistoryDlg::OnDestroy()
			{
			CDialogEx::OnDestroy();

			DestroyUserClass();

			m_Filelistfont.DeleteObject();
			m_Defectfont.DeleteObject();

			LOG(Dbg, _T("[Processe] Review History End"));
			}

			void CReveiwHistoryDlg::OnSysCommand(UINT nID, LPARAM lParam)
			{
			if ((nID & 0xFFF0) == IDM_ABOUTBOX)
			{
			CAboutDlg dlgAbout;
			dlgAbout.DoModal();
			}
			else
			{
			CDialogEx::OnSysCommand(nID, lParam);
			}
			}

			// ëí ììì ìµìí ë¨ì¶ë¥¼ ì¶ê°í ê²½ì° ìì´ì½ì ê·¸ë¦¬ë ¤ë©´
			// ìë ì½ëê° íìí©ëë¤. ë¬¸ì/ë·° ëª¨ë¸ì ì¬ì©íë MFC ìì© íë¡ê·¸ë¨ì ê²½ì°ìë
			// íë ììí¬ìì ì´ ììì ìëì¼ë¡ ìíí©ëë¤.

			void CReveiwHistoryDlg::OnPaint()
			{
			CPaintDC dc(this); // ê·¸ë¦¬ê¸°ë¥¼ ìí ëë°ì´ì¤ ì»¨íì¤í¸ìëë¤.

			if (IsIconic())
			{
			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
			{
			// if (!m_ReviewImage.IsNull())
			// {
			// dc.SetStretchBltMode(COLORONCOLOR);
			// // ê·¸ë¦¼ì Picture Control í¬ê¸°ë¡ íë©´ì ì¶ë ¥íë¤.
			// m_ReviewImage.Draw(dc, m_picture_rect);
			// }
			//LYW 20210825 #3486 ADD START
			if (!m_DefectRotateImage.IsNull())
			{
			dc.SetStretchBltMode(COLORONCOLOR);
			// ê·¸ë¦¼ì Picture Control í¬ê¸°ë¡ íë©´ì ì¶ë ¥íë¤.
			m_DefectRotateImage.Draw(dc, m_picture_rect2);
			}
			//LYW 20210825 #3486 ADD END
			else if (!m_DefectImage.IsNull())
			{
			dc.SetStretchBltMode(COLORONCOLOR);
			// ê·¸ë¦¼ì Picture Control í¬ê¸°ë¡ íë©´ì ì¶ë ¥íë¤.
			m_DefectImage.Draw(dc, m_picture_rect2);
			}

			if (!m_AlignFirst.IsNull())
			{
			dc.SetStretchBltMode(COLORONCOLOR);
			m_AlignFirst.Draw(dc, m_Align_rect);
			}
			if (!m_AlignSecend.IsNull())
			{
			dc.SetStretchBltMode(COLORONCOLOR);
			m_AlignSecend.Draw(dc, m_Align_rect2);
			}
			CDialogEx::OnPaint();
			}
			}

			// ì¬ì©ìê° ìµìíë ì°½ì ëë ëìì ì»¤ìê° íìëëë¡ ìì¤íìì
			// ì´ í¨ìë¥¼ í¸ì¶í©ëë¤.
			HCURSOR CReveiwHistoryDlg::OnQueryDragIcon()
			{
			return static_cast<HCURSOR>(m_hIcon);
			}

			BOOL CReveiwHistoryDlg::PreTranslateMessage(MSG * pMsg)
			{
			POINT pt;

			pt.x = GET_X_LPARAM(pMsg->lParam);
			pt.y = GET_Y_LPARAM(pMsg->lParam);

			switch (pMsg->message)
			{
			case WM_MOUSEHWHEEL:
			{

			}
			break;
			case WM_MOUSEMOVE:
			{

			}
			break;
			case WM_LBUTTONDOWN:
			{

			// if (m_picture_rect.left < pt.x && m_picture_rect.right > pt.x && m_picture_rect.top < pt.y && m_picture_rect.bottom > pt.y)
			// {
			// if (m_pParentWnd == NULL \|\| !GetImageExist()) return;
			//
			// if (pt.x > -1 && pt.x < GetScaleWidth() &&
			// pt.y > -1 && pt.y < GetScaleHeight())
			// {
			// if (m_rectTracker.HitTest(pt) < 0)
			// {
			// // just to demonstrate CRectTracker::TrackRubberBand
			// if (m_rectTracker.TrackRubberBand(this, pt, TRUE))
			// {
			// Invalidate();
			// }
			// }
			// else if (m_rectTracker.Track(this, pt, TRUE))
			// {
			// Invalidate();
			// }
			// }
			//
			// CRect rect;
			// this->GetClientRect(rect);
			//
			// pt.x += m_nHScroll;
			// pt.y += m_nVScroll;
			// m_pParentWnd->SendMessage(WM_LBUTTONDOWN, static_cast<WPARAM>(nFlags), MAKELPARAM(pt.x, pt.y));
			// }
			}
			break;
			case WM_LBUTTONUP:
			{
			// int a = 1;
			// return 0;
			// if (m_picture_rect.left < pt.x && m_picture_rect.right > pt.x && m_picture_rect.top < pt.y && m_picture_rect.bottom > pt.y)
			// {
			// if (m_pParentWnd == NULL) return;
			//
			// CRect rect;
			// this->GetClientRect(rect);
			//
			// pt.x += m_nHScroll;
			// pt.y += m_nVScroll;
			// m_pParentWnd->SendMessage(WM_LBUTTONUP, static_cast<WPARAM>(nFlags), MAKELPARAM(pt.x, pt.y));
			//
			// if (GetTrackerRect(m_rtROIRect))
			// {
			// m_sROIInfo.nWidthPixel = m_rtROIRect.Width();
			// m_sROIInfo.nHeightPixel = m_rtROIRect.Height();
			// m_sROIInfo.dDiagonalPixel = sqrt(double(m_sROIInfo.nWidthPixelm_sROIInfo.nWidthPixel + m_sROIInfo.nHeightPixelm_sROIInfo.nHeightPixel));
			//
			// m_sROIInfo.dWidthRealUM = m_sROIInfo.nWidthPixel * (m_dResolution / m_dWidthScale);
			// m_sROIInfo.dHeightRealUM = m_sROIInfo.nHeightPixel * (m_dResolution / m_dHeightScale);
			// m_sROIInfo.dDiagonalRealUM = sqrt((m_sROIInfo.dWidthRealUMm_sROIInfo.dWidthRealUM) + (m_sROIInfo.dHeightRealUMm_sROIInfo.dHeightRealUM));
			//
			// Invalidate(TRUE);
			// }
			// }
			//Drow ì ë³´ë¥¼ ë³´ë¸ë¤.
			}
			break;
			case WM_KEYDOWN:
			{
			if (pMsg->wParam == VK_RETURN)
			return TRUE;
			else if (pMsg->wParam == VK_ESCAPE)
			return TRUE;
			}
			break;
			}

			return __super::PreTranslateMessage(pMsg);
			}

			void CReveiwHistoryDlg::CreateUserDirectory()
			{
			CString str;

			str.Format(_T("%s\\Config\\"), GetExePath());
			CreateDirectory(str, NULL);

			str.Format(_T("%s\\Log\\"), GetExePath());
			CreateDirectory(str, NULL);

			LOG(Dbg, _T("[Processe] CreateUserDirectory"));
			}

			void CReveiwHistoryDlg::CreateUserClass()
			{
			CPathSettingDlg::CreateClass();
			CPathSettingDlg::GetMgr()->Create(this);
			CPathSettingDlg::GetMgr()->PathSettingLoad();

			CAlignDlg::CreateClass();
			CAlignDlg::GetMgr()->Create(this);

			akDefectFormation::CreateClass();

			LOG(Dbg, _T("[Processe] CreateUserClass"));
			}

			void CReveiwHistoryDlg::DestroyUserClass()
			{
			CPathSettingDlg::GetMgr()->DestroyWindow();
			CPathSettingDlg::DestroyClass();

			CAlignDlg::GetMgr()->DestroyWindow();
			CAlignDlg::DestroyClass();

			akDefectFormation::DestroyClass();

			LOG(Dbg, _T("[Processe] DestroyUserClass"));
			}


			void CReveiwHistoryDlg::AddVecFileHeader()
			{
			m_vecStrGridReviewHeader.push_back(" NO ");
			m_vecStrGridReviewHeader.push_back(" Time ");
			m_vecStrGridReviewHeader.push_back("ì´ê¸°");
			m_vecStrGridReviewHeader.push_back("PPID");
			m_vecStrGridReviewHeader.push_back("GLASS ID");
			m_vecStrGridReviewHeader.push_back("ì´ ê²°í¨ ê°¯ì");
			m_vecStrGridReviewHeader.push_back("ë¦¬ë·° ê°¯ì");
			m_vecStrGridReviewHeader.push_back("Judge");
			m_vecStrGridReviewHeader.push_back("File Name");
			}
			void CReveiwHistoryDlg::AddVecGlassHeader()
			{
			m_vecStrGridGlassHeader.push_back("No");
			m_vecStrGridGlassHeader.push_back("PPID");
			m_vecStrGridGlassHeader.push_back("Glass ID");
			m_vecStrGridGlassHeader.push_back("ì´ ê²°í¨ ê°¯ì");
			m_vecStrGridGlassHeader.push_back("ë¦¬ë·° ê²°í¨ ê°¯ì");
			m_vecStrGridGlassHeader.push_back("Glass Judge");
			m_vecStrGridGlassHeader.push_back("Lot ID");
			m_vecStrGridGlassHeader.push_back("Slot ID");
			m_vecStrGridGlassHeader.push_back("Slot Number");
			m_vecStrGridGlassHeader.push_back("Cell Number");
			m_vecStrGridGlassHeader.push_back("Glass Height");
			m_vecStrGridGlassHeader.push_back("Glass Width");
			}
			void CReveiwHistoryDlg::AddVecDefectHeader()
			{
			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");
			m_vecStrGridDefectHeader.push_back("MergeState");
			}

			void CReveiwHistoryDlg::SlideInit()
			{
			m_sldImg.SetRange(-1, -1);
			m_sldImg.SetPos(-1);
			m_sldImg.SetLineSize(3);
			m_sldImg.SetPageSize(10);

			int nPos = m_sldImg.GetPos();
			CString strPos;
			strPos.Format(_T("%d"), nPos);
			m_ctrCount.SetWindowText(strPos);

			CString strCount;
			m_ctlFileCount.SetWindowText("100");
			m_ctlFileCount.GetWindowText(strCount);

			m_nFileCount = _ttoi(strCount);
			}

			void CReveiwHistoryDlg::InitGridReviewLIst(CakGridCtrl* pGrid, UINT nRectCtrlID)
			{
			std::vector<CString>* pVecHeader = &m_vecStrGridReviewHeader;

			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(FALSE);
			pGrid->SetCallbackFunc(NULL, 0);
			pGrid->AllowReorderColumn(FALSE);
			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->SetHeaderSort(FALSE);

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

			int nRowIdx, nColIdx, nRows, nCols, nFixRows, nFixCols;
			CString strTemp;

			GV_ITEM Item;
			nRowIdx = 0;
			nColIdx = 0;
			Item.mask = GVIF_TEXT;

			Item.row = nRowIdx;
			Item.col = nColIdx++;
			strTemp.Format(_T(" No "));
			Item.strText = strTemp;
			pGrid->SetItem(&Item);

			Item.row = nRowIdx;
			Item.col = nColIdx++;
			strTemp.Format(_T(" Time "));
			Item.strText = strTemp;
			pGrid->SetItem(&Item);

			Item.row = nRowIdx;
			Item.col = nColIdx++;
			strTemp.Format(_T("ì´ê¸°"));
			Item.strText = strTemp;
			pGrid->SetItem(&Item);

			Item.row = nRowIdx;
			Item.col = nColIdx++;
			strTemp.Format(_T("PPID"));
			Item.strText = strTemp;
			pGrid->SetItem(&Item);

			Item.row = nRowIdx;
			Item.col = nColIdx++;
			strTemp.Format(_T("GLASS ID"));
			Item.strText = strTemp;
			pGrid->SetItem(&Item);

			Item.row = nRowIdx;
			Item.col = nColIdx++;
			strTemp.Format(_T("ì´ ê²°í¨ ê°¯ì"));
			Item.strText = strTemp;
			pGrid->SetItem(&Item);

			Item.row = nRowIdx;
			Item.col = nColIdx++;
			strTemp.Format(_T("ë¦¬ë·° ê°¯ì"));
			Item.strText = strTemp;
			pGrid->SetItem(&Item);

			Item.row = nRowIdx;
			Item.col = nColIdx++;
			strTemp.Format(_T("Judge"));
			Item.strText = strTemp;
			pGrid->SetItem(&Item);

			Item.row = nRowIdx++;
			Item.col = nColIdx;
			strTemp.Format(_T("File Name"));
			Item.strText = strTemp;
			pGrid->SetItem(&Item);

			Item.row = 1;
			Item.col = 0;
			strTemp.Format(_T(" "));
			Item.strText = strTemp;
			pGrid->SetItem(&Item);

			pGrid->SetCellType(1, 0, RUNTIME_CLASS(CGridCellCheck));

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

			m_WndArrange.setParentWnd(this);
			m_WndArrange.addChildWnd(&m_gridReviewList, WA_RESIZE_WIDTH \| WA_RESIZE_HEIGHT);
			}

			void CReveiwHistoryDlg::InitGridGlassLIst(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->SetVirtualMode(TRUE);
			pGrid->SetCallbackFunc(NULL, 0);
			pGrid->AllowReorderColumn(FALSE);
			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->SetHeaderSort(FALSE);

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

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

			m_WndArrange.setParentWnd(this);
			m_WndArrange.addChildWnd(&m_gridGlassInfo, WA_RESIZE_WIDTH \| WA_RESIZE_HEIGHT);
			}

			void CReveiwHistoryDlg::InitGridDefectLIst(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);
			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->SetHeaderSort(FALSE);

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

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

			m_WndArrange.setParentWnd(this);
			m_WndArrange.addChildWnd(&m_gridDefectInfo, WA_RESIZE_WIDTH \| WA_RESIZE_HEIGHT);
			}

			BOOL CReveiwHistoryDlg::OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult)
			{
			if (m_gridReviewList.GetSafeHwnd() && wParam == (WPARAM)m_gridReviewList.GetDlgCtrlID())
			{
			*pResult = 1;
			GV_DISPINFO pDispInfo = (GV_DISPINFO)lParam;
			if (GVN_GETDISPINFO == pDispInfo->hdr.code)
			{
			getDispInfoGlass(pDispInfo->item.col, pDispInfo->item.row, &pDispInfo->item.strText);

			return TRUE;
			}
			else if (NM_CLICK == pDispInfo->hdr.code \|\| LVN_ITEMCHANGING == pDispInfo->hdr.code)
			{
			if (pDispInfo->item.row == 0)
			{
			m_gridReviewList.Refresh();
			}
			else if (pDispInfo->item.row > 0)
			{
			CGridCellCheck* pCellCheck = NULL;
			pCellCheck = (CGridCellCheck*)m_gridReviewList.GetCell(pDispInfo->item.row, 0);
			BOOL bMultiCheck = pCellCheck->GetCheck();

			if (m_nCount == pDispInfo->item.row)
			{
			if (m_chkSingle.GetCheck())
			{
			if (pCellCheck != NULL)
			{
			pCellCheck->SetCheck(FALSE);
			}
			}
			else
			{
			if (pCellCheck != NULL)
			{
			pCellCheck->SetCheck(!bMultiCheck);
			}
			}
			return TRUE;
			}
			m_nCount = pDispInfo->item.row;
			m_nGlassSelect = pDispInfo->item.row;

			CGridCellCheck* pCellCheck2 = NULL;
			pCellCheck2 = (CGridCellCheck*)m_gridReviewList.GetCell(m_nGlassSelect, 0);
			BOOL bMultiCheck2 = pCellCheck->GetCheck();

			if (m_chkSingle.GetCheck())
			{
			if (pCellCheck != NULL)
			{
			pCellCheck->SetCheck(FALSE);
			}
			GlassInfoRest();
			BinFileOpen(pDispInfo->item.row);
			}
			else if(m_chkMuti.GetCheck())
			{
			if (bMultiCheck2 == TRUE)
			{
			// if (MultiSelectCheck(pDispInfo->item.row))
			// {
			//if(pDispInfo->item.row)
			bool bCheck = false;
			for (int i = 0; i < 105; i++)
			{
			if (m_nSelectFile[i] == pDispInfo->item.row)
			{
			bCheck = true;
			}
			}
			if (!bCheck)
			{
			InitSelectGlass(pDispInfo->item.row);
			BinFileOpen(pDispInfo->item.row);
			}
			/* }*/
			}
			else if(bMultiCheck == FALSE)
			{
			MultiSelectCheck(pDispInfo->item.row);
			SetScrollSetting();
			}
			}
			}
			// if (!m_chkSingle.GetCheck())
			// {
			// for (int i = 0; i < MAX_COUNT + 1; i++)
			// {
			// for (int iCol = 0; iCol < m_gridReviewList.GetColumnCount(); iCol++)
			// {
			// m_gridReviewList.SetItemState(m_nSelectFile[i], iCol, LVIS_SELECTED);
			// }
			// }
			// m_gridReviewList.Invalidate();
			// }
			m_nSelectedCol = pDispInfo->item.col;
			}
			else if (GVN_ODCACHEHINT == pDispInfo->hdr.code)
			{
			GV_CACHEHINT pCacheHint = (GV_CACHEHINT)pDispInfo;
			}
			}
			else if (m_gridGlassInfo.GetSafeHwnd() && wParam == (WPARAM)m_gridGlassInfo.GetDlgCtrlID())
			{
			*pResult = 1;
			GV_DISPINFO pDispInfo = (GV_DISPINFO)lParam;
			if (GVN_GETDISPINFO == pDispInfo->hdr.code)
			{
			getDispInfoGlassInfo(pDispInfo->item.col, pDispInfo->item.row, &pDispInfo->item.strText);
			return TRUE;
			}
			else if (NM_CLICK == pDispInfo->hdr.code)
			{
			//ë©í° ëª¨ë ì¼ë ì íí ëì cell ê°ì ë³´ì¬ ì¤ë¤
			if (!m_chkSingle.GetCheck())
			{
			SelectCell(pDispInfo->item.row);
			}
			}

			else if (GVN_ODCACHEHINT == pDispInfo->hdr.code)
			{
			GV_CACHEHINT pCacheHint = (GV_CACHEHINT)pDispInfo;
			}
			}
			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 (NM_CLICK == pDispInfo->hdr.code \|\| LVN_ITEMCHANGING == pDispInfo->hdr.code)
			{
			if (pDispInfo->item.row == 0)
			{
			SortListDefect(pDispInfo->item.col);
			m_gridDefectInfo.Refresh();
			}
			else if (pDispInfo->item.row > 0)
			{
			if (pDispInfo->item.row <= m_Formation.m_vecDefects.size())
			{
			_akDefect* pDefectInfo = &m_Formation.m_vecDefects[pDispInfo->item.row - 1];

			m_FormationMap.setSelectDefect(pDefectInfo->m_nDefectID);
			//ImageShow(pDefectInfo->m_nDefectID);
			if (!m_bDefectAll)
			{
			ImageShow(pDispInfo->item.row - 1);
			}
			else
			{
			ImageShow(pDefectInfo->m_nDefectID);
			}
			//ë©í° ëª¨ë¸ì¼ ëì ìë ë êµ¬ë¶ì íì
			//ì ë ¬ ììë¥¼ ì¬ì©ìê° ìíë ìì¼ë¡ íì
			if (!m_bDefectAll)
			{
			m_sldImg.SetPos(pDispInfo->item.row - 1);

			int nPos = m_sldImg.GetPos();
			CString strPos;
			strPos.Format(_T("%d"), nPos);
			m_ctrCount.SetWindowText(strPos);
			}
			}
			}
			m_nSelectedCol = pDispInfo->item.col;
			}

			else if (GVN_ODCACHEHINT == pDispInfo->hdr.code)
			{
			GV_CACHEHINT pCacheHint = (GV_CACHEHINT)pDispInfo;
			}
			}

			return CDialog::OnNotify(wParam, lParam, pResult);
			}

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

			if (nRow == 0)
			{
			*pStrData = m_vecStrGridReviewHeader[nCol];
			}
			else
			{
			CString strItem;
			int nDataIndex = nRow - 1;

			if (nDataIndex >= m_vecStrGridReviewList.size()) return;

			_akReviewHeader* pDefectInfo = &m_Formation.m_vecHeader[nRow - 1];

			switch (nCol)
			{
			case 0: strItem.Format("%d", nRow); break;
			case 1: strItem.Format("%s", pDefectInfo->m_strFileTime); break;
			case 2: strItem.Format("%s", pDefectInfo->m_strLoading); break;
			case 3: strItem.Format("%s", pDefectInfo->m_strPPID); break;
			case 4: strItem.Format("%s", pDefectInfo->m_strGlassID); break;
			case 5: strItem.Format("%d", pDefectInfo->m_nDefectIdx); break;
			case 6: strItem.Format("%d", pDefectInfo->m_nReviewIdx); break;
			case 7: strItem.Format("%s", pDefectInfo->m_strJudge); break;
			case 8: strItem.Format("%s", pDefectInfo->m_strFileName); break;
			}
			*pStrData = strItem;
			}
			}

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

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

			if (nDataIndex >= m_Formation.m_vecGlassInfo.size()) return;

			_akGlassInfo* pGlassInfo = &m_Formation.m_vecGlassInfo[nRow - 1];

			if (pGlassInfo == NULL) return;

			switch (nCol)
			{
			case 0: strItem.Format("%d", pGlassInfo->m_nGlassSelect); break; //"No");
			case 1: strItem.Format("%s", pGlassInfo->m_strPPID); break; //"GlassID");
			case 2: strItem.Format("%s", pGlassInfo->m_strGlassID); break; //PPID
			case 3: strItem.Format("%d", pGlassInfo->m_nDefectNum); break; //LOT ID
			case 4: strItem.Format("%d", pGlassInfo->m_nReviewNum); break; //SLOT ID
			case 5: strItem.Format("%s", pGlassInfo->m_strGlassJudge); break; //Glass Judge
			case 6: strItem.Format("%s", pGlassInfo->m_strLotID); break; //SLOT NUMBER
			case 7: strItem.Format("%s", pGlassInfo->m_strSLotID); break; //Cell NUmber
			case 8: strItem.Format("%d", pGlassInfo->m_nSlot_No); break; //Defect Count
			case 9: strItem.Format("%d", pGlassInfo->m_nCellNum); break; //Glass size H
			case 10: strItem.Format("%d", pGlassInfo->m_nGlassSizeHeight); break; //Glass Judge
			case 11: strItem.Format("%d", pGlassInfo->m_nGlassSizeWidth); break; //Glass size W
			}
			*pStrData = strItem;
			}
			}

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

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

			if (nDataIndex >= m_Formation.m_vecDefects.size())
			{
			return;
			}

			_akDefect* pDefectInfo = &m_Formation.m_vecDefects[nRow - 1];

			if (pDefectInfo == NULL)
			return;

			CString strItem;

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

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

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

			// Panel xì¶, yì¶ì ê¸ë¼ì¤ì ë°ë [6/9/2017 bhs]
			if (1)//g_pBasic->GetScanCoordination() == SC_XCoord)
			str.Format("% 5.3f", (double)pDefectInfo->m_nUMCellX / 1000.0);
			else
			str.Format("% 5.3f", (double)pDefectInfo->m_nUMCellY / 1000.0);

			strItem.Insert(9 - str.GetLength(), str);
			strItem.TrimRight(" ");
			}
			break;
			case 25:
			{
			CString str;
			strItem = _T(" ");

			// Panel xì¶, yì¶ì ê¸ë¼ì¤ì ë°ë [6/9/2017 bhs]
			if (1)//g_pBasic->GetScanCoordination() == SC_XCoord)
			str.Format("% 5.3f", (double)pDefectInfo->m_nUMCellY / 1000.0);
			else
			str.Format("% 5.3f", (double)pDefectInfo->m_nUMCellX / 1000.0);

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

			*pStrData = strItem;
			}
			}

			LRESULT CReveiwHistoryDlg::OnMapDefectSelected(WPARAM wParam, LPARAM lParam)
			{
			int nSelectMode = static_cast<int>(lParam);
			int nSelectDefect = static_cast<int>(wParam);

			if (nSelectMode == 0)
			{
			setDefectShow(nSelectDefect, 1);
			//ImageShow(nSelectDefect);

			if (m_Formation.m_vecImage.size() < 0) return 0;

			for (int i = 0; i < m_Formation.m_vecImage.size(); i++)
			{
			if (m_Formation.m_vecImage[i].m_nDefectID == nSelectDefect)
			{
			ImageShow(i);
			break;
			}
			}

			if (!m_bDefectAll)
			{
			m_sldImg.SetPos(m_nSelectedRow - 1);

			int nPos = m_sldImg.GetPos();
			CString strPos;
			strPos.Format(_T("%d"), nPos);
			m_ctrCount.SetWindowText(strPos);
			}
			}
			else if (nSelectMode == 1)
			{
			CAlignDlg* lpDlg = CAlignDlg::GetMgr();
			m_pDlgAlign->setFormShow(nSelectDefect, 1);
			}

			return 0;
			}

			LRESULT CReveiwHistoryDlg::OnListDefectSelected(WPARAM wParam, LPARAM lParam)
			{
			int nSelectDefect = static_cast<int>(wParam);
			int nMode = static_cast<int>(lParam);

			m_FormationMap.setSelectDefect(nSelectDefect);

			return 0;
			}

			LRESULT CReveiwHistoryDlg::OnMapDefectMouseOver(WPARAM wParam, LPARAM lParam)
			{
			int nSelectDefect = static_cast<int>(wParam);
			int nMode = static_cast<int>(lParam);

			return 0;
			}

			void CReveiwHistoryDlg::OnBnClickedButtonMapviewFit()
			{
			m_FormationMap.SetAutoScale();
			}

			void CReveiwHistoryDlg::OnSize(UINT nType, int cx, int cy)
			{
			CDialogEx::OnSize(nType, cx, cy);

			m_WndArrange.process(cx, cy);
			m_FormationMap.SetAutoScale();
			m_ImageView.SetResize();
			}

			void CReveiwHistoryDlg::OnOptionPathsetting()
			{
			// TODO: ì¬ê¸°ì ëªë ¹ ì²ë¦¬ê¸° ì½ëë¥¼ ì¶ê°í©ëë¤.
			CPathSettingDlg::GetMgr()->PathSettingLoad();
			CPathSettingDlg* lpDlg = CPathSettingDlg::GetMgr();
			lpDlg->ShowWindow(SW_SHOW);

			LOG(Dbg, _T("[Processe] PathSetting Click"));
			}


			void CReveiwHistoryDlg::OnViewAlldefect()
			{
			// TODO: ì¬ê¸°ì ëªë ¹ ì²ë¦¬ê¸° ì½ëë¥¼ ì¶ê°í©ëë¤.
			CMenu *hMenu = GetMenu();
			if (hMenu->GetMenuState(ID_VIEW_ALLDEFECT, MF_BYCOMMAND) != MF_CHECKED)
			{
			hMenu->CheckMenuItem(ID_VIEW_ALLDEFECT, MF_CHECKED);
			hMenu->CheckMenuItem(ID_VIEW_REVIEWDEFECT, MF_UNCHECKED);
			m_bDefectAll = true;
			}
			else
			{
			hMenu->CheckMenuItem(ID_VIEW_REVIEWDEFECT, MF_CHECKED);
			hMenu->CheckMenuItem(ID_VIEW_ALLDEFECT, MF_UNCHECKED);
			m_bDefectAll = false;
			}

			if (m_chkSingle.GetCheck())
			{
			GlassInfoRest();
			BinFileOpen(m_nCount);
			}
			else
			{
			for(int i=0; i< 105; i++)
			{
			int nSelect = m_nSelectFile[i];
			BinFileOpen(nSelect);
			}
			}
			}


			void CReveiwHistoryDlg::OnViewReviewdefect()
			{
			// TODO: ì¬ê¸°ì ëªë ¹ ì²ë¦¬ê¸° ì½ëë¥¼ ì¶ê°í©ëë¤.
			CMenu *hMenu = GetMenu();
			if (hMenu->GetMenuState(ID_VIEW_REVIEWDEFECT, MF_BYCOMMAND) != MF_CHECKED)
			{
			hMenu->CheckMenuItem(ID_VIEW_REVIEWDEFECT, MF_CHECKED);
			hMenu->CheckMenuItem(ID_VIEW_ALLDEFECT, MF_UNCHECKED);
			m_bDefectAll = false;
			}
			else
			{
			hMenu->CheckMenuItem(ID_VIEW_REVIEWDEFECT, MF_UNCHECKED);
			hMenu->CheckMenuItem(ID_VIEW_ALLDEFECT, MF_CHECKED);
			m_bDefectAll = true;
			}

			if (m_chkSingle.GetCheck())
			{
			GlassInfoRest();
			BinFileOpen(m_nCount);
			}
			else
			{
			BinFileOpen(m_nCount);
			}
			}

			void CReveiwHistoryDlg::OnAlignView()
			{
			// TODO: ì¬ê¸°ì ëªë ¹ ì²ë¦¬ê¸° ì½ëë¥¼ ì¶ê°í©ëë¤.
			CRect rectWindow;
			GetClientRect(&rectWindow);
			ClientToScreen(&rectWindow);

			CAlignDlg* lpDlg = CAlignDlg::GetMgr();

			lpDlg->SetWindowPos(NULL, rectWindow.right + 5, rectWindow.top - 50, 0, 0, SWP_NOZORDER \| SWP_NOSIZE);
			lpDlg->ShowWindow(SW_SHOW);
			lpDlg->DrawnoImage();
			}

			void CReveiwHistoryDlg::FileTime(CString strPath)
			{
			HANDLE h_File = CreateFile(_T(strPath), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

			if (h_File != INVALID_HANDLE_VALUE)
			{
			//** create_time : ìì± ë ì§, access_time : ë§ì§ë§ ì ê·¼ë ì§, write_time : ë§ì§ë§ ìì ë ì§
			FILETIME create_time, access_time, write_time;
			//** System Time ì·¨ë
			GetFileTime(h_File, &create_time, &access_time, &write_time);

			//** SystemTimeì UTCíì(Universal Time Coordinated)ì´ê¸° ëë¬¸ì ê·¸ë¥ ì¬ì© ë¶ê°ë¥
			//** ì§ììê°ì¼ë¡ ë³ê²½(ì¼ë°ì ì¸ ìê° ê³ì°ë² 2015/11/09 21:18:35)
			SYSTEMTIME write_system_time, write_local_time;
			FileTimeToSystemTime(&write_time, &write_system_time);

			//** write_local_timeë³ìì ë³íëì´ ì ì¥ë¨
			//** ì ì¥ë ííë WORDí(short)
			//** wYear, wMonth, wDay, wHour, wMinute, wSecondë¥¼ íì©íì¬ ì¬ì©íë©´ ë¨
			SystemTimeToTzSpecificLocalTime(NULL, &write_system_time, &write_local_time);

			int nYear, nMonth, nDay, nHour, nMinute, nSecond;
			nYear = write_local_time.wYear;
			nMonth = write_local_time.wMonth;
			nDay = write_local_time.wDay;
			nHour = write_local_time.wHour;
			nMinute = write_local_time.wMinute;
			nSecond = write_local_time.wSecond;
			CString strTime;
			strTime.Format("%04d-%02d-%02d-%02d-%02d-%02d", nYear, nMonth, nDay, nHour, nMinute, nSecond);

			m_vecStrGridTimeList.push_back(strTime);
			}
			}

			CgrmGlassRawData g_RawData;
			void CReveiwHistoryDlg::OpenFileHeader(CString strPath, CString strFullPath)
			{
			if (strPath == "") return;

			CgrmGlassRawData* pRawData = &g_RawData;

			if (m_vecStrGridReviewList.size() < 1) return;

			CPathSettingDlg* pReivewSetting = CPathSettingDlg::GetMgr();
			CString strBinPath;
			strBinPath = pReivewSetting->GetBinPath();

			pRawData->ImportGlassRaw(m_Server.GetGlassRawInfo(), NULL);

			strcpy_s(pRawData->GetGlassData()->m_strFileName,64, strPath.GetBuffer());
			strcpy_s(pRawData->GetGlassData()->m_strPath,256, strBinPath.GetBuffer());

			BOOL bRetReadBin = m_pGlassRawMaker->ReadBinFile(pRawData);

			m_Formation.AddDefectHeaderTemp();
			_akReviewHeader* pDefectInfo = &m_Formation.m_vecHeaderTemp[m_Formation.m_vecHeaderTemp.size() - 1];

			pDefectInfo->m_nReviewIdx = 0;
			pDefectInfo->m_strFileTime = m_vecStrGridTimeList[m_Formation.m_vecHeaderTemp.size() - 1];
			pDefectInfo->m_strFileName = m_vecStrGridReviewList[m_Formation.m_vecHeaderTemp.size() - 1];
			pDefectInfo->m_strFilePath = strFullPath;

			if (bRetReadBin == FALSE)
			{
			pDefectInfo->m_nDefectIdx = 0;
			pDefectInfo->m_strGlassID = "";
			pDefectInfo->m_strPPID = "";
			pDefectInfo->m_nReviewIdx = 0;
			pDefectInfo->m_strJudge = "";
			pDefectInfo->m_strLoading = "X";

			return;
			}

			pDefectInfo->m_strLoading = "O";

			//pRawData->ExportGlassRaw(m_Server.GetGlassRawInfo(), (char*)m_Server.GetGlassData());

			int nDataCount = pRawData->GetGlassData()->m_nDefectNum;

			_grmDefectData* pDefect;
			_grmGlassData* pGlass;

			CString strTemp;
			CString strReviewImageName;
			for (int i = 0; i < pRawData->GetGlassData()->m_nDefectNum; i++)
			{
			pDefect = pRawData->GetDefectData(i);//m_Server.GetDefectData(i);
			pGlass = pRawData->GetGlassData(); //m_Server.GetGlassData();

			pDefectInfo->m_nDefectIdx = pGlass->m_nDefectNum;
			pDefectInfo->m_strGlassID = pGlass->m_strGlassID;
			pDefectInfo->m_strPPID = pGlass->m_strPPID;
			pDefectInfo->m_strJudge = pGlass->m_strGlassJudge;


			strReviewImageName = pDefect->m_ReviewDefect.m_strRevImageName;

			if (strReviewImageName == "" \|\| strReviewImageName == "*")
			{
			continue;
			}
			else
			{
			pDefectInfo->m_nReviewIdx = pDefectInfo->m_nReviewIdx + 1;
			}
			}
			}

			void CReveiwHistoryDlg::BinFileOpen(int nCount)
			{
			BOOL bNewFile = TRUE;
			if (nCount < 1) return;

			if (m_vecStrGridReviewPath.size() <= 0) return;

			if (m_vecStrGridReviewPath[nCount-1] == m_strRawFilePath) bNewFile = FALSE;

			if (m_Formation.m_vecHeader.size() < 1) return;

			CString strFileName = m_vecStrGridReviewList[nCount-1];
			CPathSettingDlg* pReivewSetting = CPathSettingDlg::GetMgr();
			CString strBinPath;
			strBinPath = pReivewSetting->GetBinPath();

			CgrmGlassRawData RawData;

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

			strcpy(RawData.GetGlassData()->m_strFileName, strFileName.GetBuffer());
			strcpy(RawData.GetGlassData()->m_strPath, strBinPath.GetBuffer());

			BOOL bRetReadBin = m_pGlassRawMaker->ReadBinFile(&RawData);

			CGridCellCheck* pCellCheck = NULL;
			pCellCheck = (CGridCellCheck*)m_gridReviewList.GetCell(nCount, 0);

			if (bRetReadBin == FALSE)
			{
			AfxMessageBox(_T("ë¡ë ì¤í¨ íììµëë¤."), MB_OK \| MB_ICONERROR);
			m_FormationMap.SetAutoScale();
			LOG(Dbg, _T("[Processe] File Open False"));
			pCellCheck->SetCheck(FALSE);
			Imagenoload();
			return;
			}

			if (bNewFile && m_chkSingle.GetCheck())
			{
			m_FormationMap.m_vecCellRect.clear();
			m_FormationMap.m_vecTempCellRect.clear();
			m_FormationMap.clear();
			m_Formation.Clear();
			m_Formation.m_vecTempDefects.clear();
			m_Formation.m_vecTempImage.clear();
			SetScrollRest();
			}
			else if (bNewFile && !m_chkSingle.GetCheck())
			{
			if (m_bFirst)
			{
			m_bFirst = false;
			m_FormationMap.m_vecCellRect.clear();
			}
			m_FormationMap.clear();
			m_Formation.m_vecFormation.clear();
			SetScrollRest();
			}
			else if (!bNewFile && !m_chkSingle.GetCheck())
			{
			m_FormationMap.clear();
			m_Formation.m_vecFormation.clear();
			SetScrollRest();
			}
			else
			{
			m_FormationMap.clear();
			m_Formation.m_vecDefects.clear();
			m_Formation.m_vecFormation.clear();
			m_Formation.m_vecImage.clear();
			SetScrollRest();
			}

			RawData.ExportGlassRaw(m_Server.GetGlassRawInfo(), (char*)m_Server.GetGlassData());

			int nDataCount = RawData.GetGlassData()->m_nDefectNum;
			int nCellCount = RawData.GetGlassData()->m_nCellNum;

			m_strRawFilePath = m_vecStrGridReviewPath[nCount-1];

			_grmGlassData* pGlass = m_Server.GetGlassData();

			m_FormationMap.m_dGlassSizeWidth = pGlass->m_nGlassSizeWidth / 1000;
			m_FormationMap.m_dGlassSizeHeight = pGlass->m_nGlassSizeHeight / 1000;

			if (m_bDefectAll == false && m_chkSingle.GetCheck())
			{
			AddVecDataDefct(nDataCount);
			}
			else if (m_bDefectAll == false && !m_chkSingle.GetCheck())
			{
			if(m_Formation.m_vecTempDefects.size() > 0)
			{
			int nCount2;
			nCount2 = MultiInsert(nCount, nDataCount);
			if (nCount2 == -1)
			{
			AddVecDataDefct2(nDataCount);
			}
			}
			else
			{
			AddVecDataDefct2(nDataCount);
			}
			/AddVecDataDefct2(nDataCount, nCount);/
			}
			else if (m_bDefectAll == true && !m_chkSingle.GetCheck())
			{
			if (m_Formation.m_vecTempDefects.size() > 0)
			{
			int nCount2;
			nCount2 = MultiInsert(nCount, nDataCount);
			if (nCount2 == -1)
			{
			AddVecDataDefectAll2(nDataCount);
			}
			}
			else
			{
			AddVecDataDefectAll2(nDataCount);
			}
			/AddVecDataDefectAll2(nDataCount, nCount);/
			}
			else
			{
			AddVecDataDefectAll(nDataCount);
			}

			AddVecDataImage(nDataCount);
			AddVecCellData(nCellCount);
			AddVecGlassData(nCount);

			AddVecDateSorting(nDataCount);
			AddVecImageSorting(nDataCount);
			AddVecCellSorting(nCellCount);

			m_gridDefectInfo.SetRowCount(m_Formation.m_vecDefects.size() + 1);
			m_gridDefectInfo.Invalidate();

			m_gridGlassInfo.SetRowCount(m_Formation.m_vecGlassInfo.size() + 1);
			m_gridGlassInfo.Invalidate();

			int nDefectSize = 0;
			int nImageSize = 0;
			int nCellSize = 0;
			int nNext = MAX_COUNT;

			if (m_chkSingle.GetCheck())
			{
			m_nDefectSize[0] = GetDefectCount();//m_Formation.m_vecDefects.size();
			m_nImageSize[0] = GetImageCount();//m_Formation.m_vecImage.size();
			m_nCellSize[0] = GetCellCount();

			m_nCellSizeTemp[0] = m_nCellSize[0];

			m_nImageCount = 0;
			m_nDefectCount = 0;
			m_nCellCount = 0;
			}
			else
			{

			for (int i = 0; i <= MAX_COUNT; i++)
			{
			nDefectSize = GetDefectCount();
			nImageSize = GetImageCount();
			nCellSize = GetCellCount();

			//1.ê°ì ììëë¡ ë£ëë¤
			if (nDefectSize > 0 \|\| nImageSize > 0 \|\| nCellSize > 0)
			{
			if (m_nDefectSize[i] == 0 && m_nImageSize[i] == 0 && m_nCellSize[i] == 0)
			{
			m_nDefectSize[i] = GetDefectCount();//m_Formation.m_vecDefects.size();
			m_nImageSize[i] = GetImageCount();//m_Formation.m_vecImage.size();
			m_nCellSize[i] = GetCellCount();

			m_nImageCount = 0;
			m_nDefectCount = 0;
			m_nCellCount = 0;
			break;
			}
			}
			//2.ë§ì§ë§ ê°ì´ë©´ 2ë²ì§¸ê° ì²«ë²ì§¸ë¡ ì¬ë¦° í ë£ëë¤.
			if (nNext == i)
			{
			for (int j = 0; j < MAX_COUNT; j++)
			{
			m_nDefectSize[j] = m_nDefectSize[j + 1];
			m_nImageSize[j] = m_nImageSize[j + 1];
			m_nCellSize[j] = m_nCellSize[j + 1];
			m_nCellSizeTemp[j] = m_nCellSize[j];
			}
			m_nDefectSize[i] = GetDefectCount();//m_Formation.m_vecDefects.size();
			m_nImageSize[i] = GetImageCount();//m_Formation.m_vecImage.size();
			m_nCellSize[i] = GetCellCount();

			m_nCellSizeTemp[i] = m_nCellSize[i];

			m_nImageCount = 0;
			m_nDefectCount = 0;
			m_nCellCount = 0;
			}
			//3.ì¤ê°ì ê°ì´ ë¹ ì§ë©´ ì¤ê° ë²ì§¸ ê°ì ì¬ë¦° í ë£ëë¤.


			// if (i != 0) //iê° 0 ì´ ìëë©´ countë¥¼ ëì¸ë¤.
			// {
			// nDefectSize += m_nDefectSize[i];
			// nImageSize += m_nImageSize[i];
			// nCellSize += m_nCellSize[i];
			// }
			// else if (i == 0 && m_nDefectSize[0] > 0) //iê° 0ì¸ë° ëíì´ ìì¼ë©´ ì¹´ì´í°ë¥¼ ëì¸ë¤.
			// {
			// nDefectSize += m_nDefectSize[i];
			// nImageSize += m_nImageSize[i];
			// nCellSize += m_nCellSize[i];
			// }

			// if (m_nDefectSize[0] == 0)
			// {
			// m_nDefectSize[i] = GetDefectCount();//m_Formation.m_vecDefects.size();
			// m_nImageSize[i] = GetImageCount();//m_Formation.m_vecImage.size();
			// m_nCellSize[i] = GetCellCount();
			//
			// m_nImageCount = 0;
			// m_nDefectCount = 0;
			// m_nCellCount = 0;
			// break;
			// }
			// else if(i != 0 && m_nDefectSize[i] == 0)
			// {
			// m_nDefectSize[i] = GetDefectCount(); //m_Formation.m_vecDefects.size() - nDefectSize;
			// m_nImageSize[i] = GetImageCount(); //m_Formation.m_vecImage.size() - nImageSize;
			// m_nCellSize[i] = GetCellCount();
			//
			// m_nImageCount = 0;
			// m_nDefectCount = 0;
			// m_nCellCount = 0;
			// break;
			// }
			}
			}

			m_FormationMap.m_pDefectFormation = &m_Formation;
			m_DefectDisplayOption.m_nShowLabel = -1;
			m_FormationMap.m_pDefectDisplayOption = &m_DefectDisplayOption;

			CAlignDlg* lpDlg = CAlignDlg::GetMgr();
			lpDlg->m_pDefectFormation = &m_Formation;
			lpDlg->m_pDefectDisplayOption = &m_DefectDisplayOption;

			if(bNewFile) m_FormationMap.SetAutoScale();
			else m_FormationMap.ReDraw(TRUE);

			int nDefectNum = m_Server.GetGlassData()->m_nDefectNum;
			int nNoneGroupDefect = m_Formation.m_vecImage.size();

			if (m_Formation.m_vecImage.size() > 0)
			{
			SetScrollSetting();
			}
			}

			void CReveiwHistoryDlg::OnCbnSelchangeComboRawtype()
			{
			CGlassRawBase* pNewRawMaker = NULL;

			pNewRawMaker = new CGlassRawCPJT;

			if (m_pGlassRawMaker) delete m_pGlassRawMaker;

			m_pGlassRawMaker = pNewRawMaker;

			m_ConfigOption.m_nSelectRawType = 3;

			}

			void CReveiwHistoryDlg::OnBnClickedBtnFindBin()
			{
			// TODO: ì¬ê¸°ì ì»¨í¸ë¡¤ ìë¦¼ ì²ë¦¬ê¸° ì½ëë¥¼ ì¶ê°í©ëë¤.


			m_vecStrGridReviewList.clear();
			m_vecStrGridTimeList.clear();
			m_vecStrGridReviewPath.clear();
			m_Formation.m_vecHeader.clear();
			m_FormationMap.clear();
			m_Formation.Clear();
			GlassInfoRest();

			// m_ProgressFile.ModifyStyle(0, PBS_MARQUEE);
			// m_ProgressFile.ShowWindow(TRUE);
			// pProgressBar->SetMarquee(TRUE, 30);


			CPathSettingDlg* pReivewSetting = CPathSettingDlg::GetMgr();
			CString strBinPath;
			strBinPath = pReivewSetting->GetBinPath();

			if (strBinPath == "")
			{
			return;
			}
			strBinPath += _T("\\.");

			CFileFind finder;
			BOOL bWorking = finder.FindFile(strBinPath);

			// CakFileUtil akFile;
			// akFile.FindFile(strBinPath.GetBuffer());
			// VECFINDDATA* pVecFindData = akFile.getFindData();
			//
			// for (int i = 0; i < pVecFindData->size(); i++)
			// {
			// _DefectList akDefect;
			// m_vecStrDefectList.push_back(akDefect);
			// _DefectList* pDefectList = &m_vecStrDefectList[i];
			//
			//
			// TRACE("Craete Time : %d, %s \n", (pVecFindData)[i].time_create, (pVecFindData)[i].name);
			// pDefectList->m_nFileTime = (*pVecFindData)[i].time_create;
			// pDefectList->m_strFileName = (*pVecFindData)[i].name;
			// // m_vecStrGridReviewList.push_back((*pVecFindData)[i].name);
			// // m_vecStrGridTimeList.push_back((*pVecFindData)[i].time_create;
			// OpenFileHeader((*pVecFindData)[i].name);
			// }



			CString fileName;
			CString DirName;
			int nCount = 1;
			m_ctlProgress.ShowWindow(TRUE);
			int nPersent = 0;

			while (bWorking)
			{
			m_ctlProgress.SetPos(nPersent);
			nPersent++;

			if (nPersent >= 100)
			{
			nPersent = 0;
			}

			//ë¤ì íì¼ / í´ë ê° ì¡´ì¬íë©´ë¤ë©´ TRUE ë°í
			bWorking = finder.FindNextFile();
			//íì¼ ì¼ë
			if (finder.IsArchived())
			{
			//íì¼ì ì´ë¦
			CString _fileName = finder.GetFileName();

			// íì¬í´ë ììí´ë ì¸ë¤ì¼íì¼ì ì ì¸
			if (_fileName == _T(".") \|\|
			_fileName == _T("..") \|\|
			_fileName == _T("Thumbs.db")) continue;

			CString strFindName = ".bin";
			CString strFileName, strFileName2;
			strFileName = _fileName.Right(4); //bin íì¼ë§

			if (strFileName.Compare(strFindName) == 0)
			{
			/if(nCount > m_nFileCount) break; //count ì¬ê¸°ì ë§ê³ ì ì²´ íì¼ì ë¤ ì½ì íì ë¤ì ìííì/
			m_vecStrGridReviewList.push_back(_fileName);
			strFileName2 = strBinPath.Left(strBinPath.GetLength() - 3);
			strFileName2 += _fileName;
			m_vecStrGridReviewPath.push_back(strFileName2);
			FileTime(strFileName2);
			OpenFileHeader(_fileName, strFileName2);
			/nCount++;/
			}
			}
			}

			//ì¬ê¸°ìì ì¬ ìí íì íìí ë§í¼ë§ ë£ì
			{
			//vecë¥¼ ì ë ¬ íë¤.
			SortFileList(1);
			//ê°¯ìë§í¼ë§ ë³µì¬ë¥¼ íë¤
			//ë³µì¬í ê²ì ë£ëë¤.

			}
			CGridCellCheck* pCellCheck = NULL;
			//
			// m_gridReviewList.SetCellType(1, 0, RUNTIME_CLASS(CGridCellCheck));
			//
			m_gridReviewList.SetRowCount(m_Formation.m_vecHeader.size() + 1);

			{
			GV_ITEM Item;
			int nRowIdx = 0;
			int nColIdx = 0;
			CString strTemp;
			Item.mask = GVIF_TEXT;

			_akReviewHeader *pReview = NULL;

			for (int i = 0; i < m_Formation.m_vecHeader.size(); i++)
			{
			m_gridReviewList.SetCellType(i + 1, 0, RUNTIME_CLASS(CGridCellCheck));

			// pCellCheck = (CGridCellCheck*)m_ctrlGridGlassList.GetCell(nRowIdx, nColIdx);
			//
			// pCellCheck->SetCheck();

			nColIdx = 0;
			pReview = &m_Formation.m_vecHeader[i];
			Item.row = i + 1;
			Item.col = nColIdx++;
			strTemp.Format(_T("%d"), i + 1);
			Item.strText = strTemp;
			m_gridReviewList.SetItem(&Item);

			Item.row = i + 1;
			Item.col = nColIdx++;
			strTemp.Format(_T("%s"), pReview->m_strFileTime);
			Item.strText = strTemp;
			m_gridReviewList.SetItem(&Item);

			Item.row = i + 1;
			Item.col = nColIdx++;
			strTemp.Format(_T("%s"), pReview->m_strLoading);
			Item.strText = strTemp;
			m_gridReviewList.SetItem(&Item);

			Item.row = i + 1;
			Item.col = nColIdx++;
			strTemp.Format(_T("%s"), pReview->m_strPPID);
			Item.strText = strTemp;
			m_gridReviewList.SetItem(&Item);

			Item.row = i + 1;
			Item.col = nColIdx++;
			strTemp.Format(_T("%s"), pReview->m_strGlassID);
			Item.strText = strTemp;
			m_gridReviewList.SetItem(&Item);

			Item.row = i + 1;
			Item.col = nColIdx++;
			strTemp.Format(_T("%d"), pReview->m_nDefectIdx);
			Item.strText = strTemp;
			m_gridReviewList.SetItem(&Item);

			Item.row = i + 1;
			Item.col = nColIdx++;
			strTemp.Format(_T("%d"), pReview->m_nReviewIdx);
			Item.strText = strTemp;
			m_gridReviewList.SetItem(&Item);

			Item.row = i + 1;
			Item.col = nColIdx++;
			strTemp.Format(_T("%s"), pReview->m_strJudge);
			Item.strText = strTemp;
			m_gridReviewList.SetItem(&Item);

			Item.row = i + 1;
			Item.col = nColIdx++;
			strTemp.Format(_T("%s"), pReview->m_strFileName);
			Item.strText = strTemp;
			m_gridReviewList.SetItem(&Item);
			}

			}
			m_gridReviewList.Invalidate();

			m_ctlProgress.ShowWindow(FALSE);
			}

			void CReveiwHistoryDlg::ShowProgressBar()
			{

			}

			void CReveiwHistoryDlg::setDefectShow(int nDefectID, BOOL bEnsureVisible)
			{
			const int nDefectCol = 1;

			if (nDefectID >= 0)
			{
			int sajfklwe;
			sajfklwe = m_gridDefectInfo.GetColumnCount();
			if (m_nSelectedRow > m_gridDefectInfo.GetColumnCount())
			{
			m_nSelectedRow = 0;
			}

			if(!m_bDefectAll)
			{
			if (m_nSelectedRow > m_Formation.m_vecImage.size())
			{
			m_nSelectedRow = 0;
			}
			}
			int iRow = m_nSelectedRow;

			for (int iCol = 0; iCol < m_gridDefectInfo.GetColumnCount(); iCol++)
			{
			m_gridDefectInfo.SetItemState(iRow, iCol, m_gridDefectInfo.GetItemState(iRow, iCol) & ~GVIS_SELECTED);
			}
			}

			for (int i = 0; i < m_Formation.m_vecDefects.size(); i++)
			{
			_akDefect* pDefectInfo = &m_Formation.m_vecDefects[i];

			if (pDefectInfo == NULL)
			return;

			if (pDefectInfo->m_nDefectID == nDefectID)
			{
			int iRow = i + 1;
			for (int iCol = 0; iCol < m_gridDefectInfo.GetColumnCount(); iCol++)
			{
			m_gridDefectInfo.SetItemState(iRow, iCol, LVIS_SELECTED);
			}
			m_nSelectedRow = iRow;
			if (bEnsureVisible)
			{
			m_gridDefectInfo.EnsureVisible(iRow, m_nSelectedCol);
			}
			break;
			}
			}

			m_gridDefectInfo.Invalidate();
			}

			void CReveiwHistoryDlg::ImageShow(int nDefectID)
			{
			CPaintDC dc(this);

			if (nDefectID < 0) return;

			m_DefectImage.Destroy();
			m_ReviewImage.Destroy();
			//LYW 20210825 #3486 ADD START
			m_DefectRotateImage.Destroy();
			//LYW 20210825 #3486 ADD END

			m_AlignFirst.Destroy();
			m_AlignSecend.Destroy();

			CString DeftectPath, DeftectPath2, AlignPath, AlignPath2;
			CFileStatus FileOn;
			TCHAR chFilePath[256] = { 0, };
			GetModuleFileName(NULL, chFilePath, 256);
			if (chFilePath == NULL \|\| chFilePath == "") return;

			CString strFolderPath(chFilePath);
			strFolderPath = strFolderPath.Left(strFolderPath.ReverseFind('\\'));

			strFolderPath = strFolderPath + "\\no-image.png";


			//DefectDataê° ì§ê¸ ì íë DefectDataë¥¼ ê°ì ¸ ì¨ë¤. ì´ê±° ìì ...

			// _grmDefectData* pDefect = m_Server.GetDefectData(nDefectID);
			// _grmGlassData* pGlass = m_Server.GetGlassData();
			int nIndex = 0;
			//ëí ì¸ë±ì¤ì ê°ì ëì ì°¾ìë¼
			for (int i = 0; i < m_Formation.m_vecImage.size(); i++)
			{
			_akReviewList* pImage = NULL;
			pImage = &m_Formation.m_vecImage[i];

			if (!m_bDefectAll)
			{
			nIndex = nDefectID;
			break;
			}
			else
			{
			if (pImage->m_nDefectID == nDefectID)
			{
			nIndex = i;
			break;
			}
			}
			}
			_akReviewList* pImageInfo = &m_Formation.m_vecImage[nIndex];
			//ëª ë²ì§¸ ì¸ì§ ëì§ë¤.

			CString wekfjlwe = pImageInfo->m_strReviewImageName;
			CString wjkflwe = pImageInfo->m_strAoiImageName;
			CString jkefawlj = pImageInfo->m_strReviewImagePath;
			//í´ë¹ countë¥¼ í¸ì¶ íë¤.
			//íì¼ ì´ë¯¸ì§ë¥¼ ë¶ë¬ ì¨ë¤
			//íííë¤.


			/* if (pGlass == NULL) return;*/

			//_akReviewList* pDfect2 = &m_Formation.m_vecImage[nDefectID];

			// CString wefjklwef;
			// wefjklwef = pDfect2->m_strRevewImageName;

			CString strReviewImageName, strInspectorName, strReviewImagePath, strAlignName, strAlignName2;
			// strReviewImageName = pDefect->m_ReviewDefect.m_strRevImageName;
			// strInspectorName = pDefect->m_strAoiImageName;
			// strReviewImagePath = pDefect->m_ReviewDefect.m_strRevImagePath;

			/* pDefect->m_ReviewDefect.m_strRevImagePath*/

			strReviewImageName = wekfjlwe;
			strInspectorName = wjkflwe;
			strReviewImagePath = jkefawlj;
			strAlignName = pImageInfo->m_strAlignFirst; //Glass ê° ê°ì ¸ìë¼
			strAlignName2 = pImageInfo->m_strAlignSecond;

			// strAlignName.Format(_T("1.jpg"));
			// strAlignName2.Format(_T("2.jpg"));

			CString strReviewPath;
			CString strInspectorPath;
			CString strAlignPath;

			CPathSettingDlg* lpDlg = CPathSettingDlg::GetMgr();
			strInspectorPath = lpDlg->GetInspectorPath();
			strReviewPath = lpDlg->GetReviewPath();
			strAlignPath = lpDlg->GetAlignPath();

			DeftectPath.Format(_T("%s\\%s\\%s"), strReviewPath, strReviewImagePath, strReviewImageName);
			//DeftectPath2.Format(_T("%s\\%s"), strInspectorPath, strInspectorName);
			if (strInspectorName == "" \|\| strInspectorName == "" \|\| strInspectorName == "**") strInspectorName = "";
			DeftectPath2.Format(_T("%s\\%s\\%s"), strInspectorPath, pImageInfo->m_strGlassID, strInspectorName);

			AlignPath.Format(_T("%s\\%s\\%s"), strAlignPath, pImageInfo->m_strGlassID, strAlignName);
			AlignPath2.Format(_T("%s\\%s\\%s"), strAlignPath, pImageInfo->m_strGlassID, strAlignName2);

			if (CFile::GetStatus(DeftectPath, FileOn) && strReviewImageName != "") //íì¼ì´ ìì ë
			{
			CString strTest;
			strTest = DeftectPath;
			strcpy(m_strConfigFile, strTest.GetBuffer(0));
			m_ImageView.SetImageData(m_strConfigFile);
			m_ImageView.ReDraw();
			// m_ReviewImage.Load(DeftectPath);
			// HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), DeftectPath,
			// IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE \| LR_CREATEDIBSECTION);
			//
			//
			// InvalidateRect(m_picture_rect, FALSE);
			// dc.SetStretchBltMode(COLORONCOLOR);
			// m_ReviewImage.Draw(dc, m_picture_rect);
			}
			else
			{
			CString strTest;
			strTest = strFolderPath;
			strcpy(m_strConfigFile, strTest.GetBuffer(0));
			m_ImageView.SetImageData(m_strConfigFile);
			m_ImageView.ReDraw();

			// m_ReviewImage.Load(strFolderPath);
			// HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), strFolderPath,
			// IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE \| LR_CREATEDIBSECTION);
			//
			// InvalidateRect(m_picture_rect, FALSE);
			// dc.SetStretchBltMode(COLORONCOLOR);
			// m_ReviewImage.Draw(dc, m_picture_rect);
			}

			if (CFile::GetStatus(DeftectPath2, FileOn) && strInspectorName != "") //íì¼ì´ ìì ë
			{
			m_DefectImage.Load(DeftectPath2);
			//LYW 20210825 #3486 ADD START
			m_DefectRotateImage.Create(m_DefectImage.GetWidth(), m_DefectImage.GetHeight(), m_DefectImage.GetBPP(), 0);
			ImageRotate(m_DefectImage, m_DefectRotateImage);
			//LYW 20210825 #3486 ADD END
			HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), DeftectPath2,
			IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE \| LR_CREATEDIBSECTION);


			InvalidateRect(m_picture_rect2, FALSE);
			dc.SetStretchBltMode(COLORONCOLOR);
			//LYW 20210825 #3486 MOD START
			m_DefectRotateImage.Draw(dc, m_picture_rect2);
			//LYW 20210825 #3486 MOD END
			//original
			//m_DefectImage.Draw(dc, m_picture_rect2);
			}
			else
			{
			m_DefectImage.Load(strFolderPath);
			HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), strFolderPath,
			IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE \| LR_CREATEDIBSECTION);

			InvalidateRect(m_picture_rect2, FALSE);
			dc.SetStretchBltMode(COLORONCOLOR);
			m_DefectImage.Draw(dc, m_picture_rect2);
			}

			if (CFile::GetStatus(AlignPath, FileOn) && strAlignName != "") //íì¼ì´ ìì ë
			{
			m_AlignFirst.Load(AlignPath);
			HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), AlignPath,
			IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE \| LR_CREATEDIBSECTION);


			InvalidateRect(m_Align_rect, FALSE);
			dc.SetStretchBltMode(COLORONCOLOR);
			m_AlignFirst.Draw(dc, m_Align_rect);
			}
			else
			{
			m_AlignFirst.Load(strFolderPath);
			HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), strFolderPath,
			IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE \| LR_CREATEDIBSECTION);

			InvalidateRect(m_Align_rect, FALSE);
			dc.SetStretchBltMode(COLORONCOLOR);
			m_AlignFirst.Draw(dc, m_Align_rect);
			}

			if (CFile::GetStatus(AlignPath2, FileOn) && strAlignName2 != "") //íì¼ì´ ìì ë
			{
			m_AlignSecend.Load(AlignPath2);
			HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), AlignPath2,
			IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE \| LR_CREATEDIBSECTION);


			InvalidateRect(m_Align_rect2, FALSE);
			dc.SetStretchBltMode(COLORONCOLOR);
			m_AlignSecend.Draw(dc, m_Align_rect2);
			}
			else
			{
			m_AlignSecend.Load(strFolderPath);
			HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), strFolderPath,
			IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE \| LR_CREATEDIBSECTION);

			InvalidateRect(m_Align_rect2, FALSE);
			dc.SetStretchBltMode(COLORONCOLOR);
			m_AlignSecend.Draw(dc, m_Align_rect2);
			}
			}

			void CReveiwHistoryDlg::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
			{
			// TODO: ì¬ê¸°ì ë©ìì§ ì²ë¦¬ê¸° ì½ëë¥¼ ì¶ê° ë°/ëë ê¸°ë³¸ê°ì í¸ì¶í©ëë¤.
			if (IDC_SLIDER_IMG == pScrollBar->GetDlgCtrlID())
			{
			int nCount = m_sldImg.GetPos();

			CString strPos;
			strPos.Format(_T("%d"), nCount);
			m_ctrCount.SetWindowText(strPos);

			if (nCount > -1)
			{
			if (m_Formation.m_vecImage.size() <= 0)
			{
			SetScrollRest();
			return;
			}
			_akReviewList* pImageInfo = &m_Formation.m_vecImage[nCount];

			m_FormationMap.setSelectDefect(pImageInfo->m_nDefectID);
			//ImageShow(pImageInfo->m_nDefectID);
			setDefectShow(pImageInfo->m_nDefectID, 1);
			}
			}
			}


			void CReveiwHistoryDlg::OnChangeEditCount()
			{
			// TODO: RICHEDIT ì»¨í¸ë¡¤ì¸ ê²½ì°, ì´ ì»¨í¸ë¡¤ì
			// CDialogEx::OnInitDialog() í¨ìë¥¼ ì¬ì§ì
			//íê³ ë§ì¤í¬ì OR ì°ì°íì¬ ì¤ì ë ENM_CHANGE íëê·¸ë¥¼ ì§ì íì¬ CRichEditCtrl().SetEventMask()ë¥¼ í¸ì¶íì§ ìì¼ë©´
			// ì´ ìë¦¼ ë©ìì§ë¥¼ ë³´ë´ì§ ììµëë¤.

			// TODO: ì¬ê¸°ì ì»¨í¸ë¡¤ ìë¦¼ ì²ë¦¬ê¸° ì½ëë¥¼ ì¶ê°í©ëë¤.

			CString strPos;
			m_ctrCount.GetWindowText(strPos);

			if (strPos == "") return;

			int nPos = _ttoi(strPos);

			if (nPos < -1)
			{
			m_ctrCount.SetWindowText(0);
			nPos = 0;
			}
			else if (nPos > m_Formation.m_vecImage.size()-1)
			{
			nPos = m_Formation.m_vecImage.size() - 1;
			CString strCount;
			strCount.Format(_T("%d"),nPos);
			m_ctrCount.SetWindowText(strCount);
			}

			m_sldImg.SetPos(nPos);

			if (nPos > -1)
			{
			if (m_Formation.m_vecImage.size() <= 0)
			{
			SetScrollRest();
			return;
			}
			_akReviewList* pImageInfo = &m_Formation.m_vecImage[nPos];

			m_FormationMap.setSelectDefect(pImageInfo->m_nDefectID);
			//ImageShow(pImageInfo->m_nDefectID/nPos/);
			ImageShow(nPos);
			setDefectShow(pImageInfo->m_nDefectID, 1);
			}
			}

			void CReveiwHistoryDlg::SetScrollSetting()
			{
			if (m_Formation.m_vecImage.size() <= 0) return;
			_akReviewList* pImageInfo = &m_Formation.m_vecImage[m_Formation.m_vecImage.size() - 1];

			int nMinRange = m_Formation.m_vecImage.size()0.03, nMaxRange = m_Formation.m_vecImage.size()0.1;

			if (nMinRange <= 0) nMinRange = 1;
			if (nMaxRange <= 0) nMaxRange = 1;

			m_sldImg.SetRange(0, m_Formation.m_vecImage.size()-1); //ë²ì ì¤ì ìµë ì´ë¯¸ì§ ê°¯ì
			m_sldImg.SetPos(0); //íì¬ í¬ì§ì
			m_sldImg.SetLineSize(nMinRange); //ì´ëí ë²ì 3%
			m_sldImg.SetPageSize(nMaxRange); //íì´ì§ ìë¤ì´ ì´ë ë²ì ë²ì 10%

			int nPos = m_sldImg.GetPos();
			CString strPos;
			strPos.Format(_T("%d"), nPos);
			m_ctrCount.SetWindowText(strPos);
			}

			void CReveiwHistoryDlg::SetScrollRest()
			{
			m_sldImg.SetRange(-1, -1);
			m_sldImg.SetPos(-1);
			m_sldImg.SetLineSize(3);
			m_sldImg.SetPageSize(10);

			int nPos = m_sldImg.GetPos();
			CString strPos;
			strPos.Format(_T("%d"), nPos);
			m_ctrCount.SetWindowText(strPos);
			}

			void CReveiwHistoryDlg::OnBnClickedButton3()
			{
			// // TODO: ì¬ê¸°ì ì»¨í¸ë¡¤ ìë¦¼ ì²ë¦¬ê¸° ì½ëë¥¼ ì¶ê°í©ëë¤.
			// CPaintDC dc(this);
			// HDC hMemDC;
			//
			// hMemDC = CreateCompatibleDC(dc);
			//
			// m_DefectImage.Destroy();
			//
			// CString DeftectPath;
			// CFileStatus FileOn;
			// TCHAR chFilePath[256] = { 0, };
			// GetModuleFileName(NULL, chFilePath, 256);
			// CString strFolderPath(chFilePath);
			// strFolderPath = strFolderPath.Left(strFolderPath.ReverseFind('\\'));
			//
			// strFolderPath = strFolderPath + "\\no-image.png";
			// m_DefectImage.Load(strFolderPath);
			//
			// HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), strFolderPath,
			// IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE \| LR_CREATEDIBSECTION);
			//
			// InvalidateRect(m_picture_rect, FALSE);
			//
			// dc.SetStretchBltMode(COLORONCOLOR);
			// //StretchBlt(dc, 500, 400, 300, 200, hMemDC, 105, 105, 120, 123, SRCCOPY);
			// //m_DefectImage.StretchBlt(dc, 0, 0, 100, 100, SRCCOPY);
			// m_DefectImage.StretchBlt(dc, 0, 0, 500, 200, SRCCOPY);
			// m_DefectImage.Draw(dc, m_picture_rect);
			}


			void CReveiwHistoryDlg::OnClickedChkAllDefect()
			{
			// TODO: ì¬ê¸°ì ì»¨í¸ë¡¤ ìë¦¼ ì²ë¦¬ê¸° ì½ëë¥¼ ì¶ê°í©ëë¤.
			if (m_chkAllDefect.GetCheck())
			{
			if (IDYES == AfxMessageBox(_T("ì ë ¬í ê°ì´ ëª¨ë ì´ê¸°í ë©ëë¤"), MB_YESNO \| MB_ICONWARNING))
			{
			m_chkAllDefect.SetCheck(TRUE);
			m_chkReviewDefect.SetCheck(FALSE);
			OnViewAlldefect();
			}
			else
			{
			m_chkAllDefect.SetCheck(FALSE);
			m_chkReviewDefect.SetCheck(TRUE);
			}
			}
			else
			{
			if (IDYES == AfxMessageBox(_T("ì ë ¬í ê°ì´ ëª¨ë ì´ê¸°í ë©ëë¤"), MB_YESNO \| MB_ICONWARNING))
			{
			m_chkAllDefect.SetCheck(FALSE);
			m_chkReviewDefect.SetCheck(TRUE);
			OnViewReviewdefect();
			}
			else
			{
			m_chkAllDefect.SetCheck(TRUE);
			m_chkReviewDefect.SetCheck(FALSE);
			}
			}
			}

			void CReveiwHistoryDlg::OnClickedChkReviewDefect()
			{
			// TODO: ì¬ê¸°ì ì»¨í¸ë¡¤ ìë¦¼ ì²ë¦¬ê¸° ì½ëë¥¼ ì¶ê°í©ëë¤.
			if (m_chkReviewDefect.GetCheck())
			{
			if (IDYES == AfxMessageBox(_T("ì ë ¬í ê°ì´ ëª¨ë ì´ê¸°í ë©ëë¤"), MB_YESNO \| MB_ICONWARNING))
			{
			m_chkAllDefect.SetCheck(FALSE);
			m_chkReviewDefect.SetCheck(TRUE);
			OnViewAlldefect();
			}
			else
			{
			m_chkAllDefect.SetCheck(TRUE);
			m_chkReviewDefect.SetCheck(FALSE);
			}
			}
			else
			{
			if (IDYES == AfxMessageBox(_T("ì ë ¬í ê°ì´ ëª¨ë ì´ê¸°í ë©ëë¤"), MB_YESNO \| MB_ICONWARNING))
			{
			m_chkAllDefect.SetCheck(TRUE);
			m_chkReviewDefect.SetCheck(FALSE);
			OnViewReviewdefect();
			}
			else
			{
			m_chkAllDefect.SetCheck(FALSE);
			m_chkReviewDefect.SetCheck(TRUE);
			}
			}
			}

			void CReveiwHistoryDlg::OnClickedChkMuti()
			{
			// TODO: ì¬ê¸°ì ì»¨í¸ë¡¤ ìë¦¼ ì²ë¦¬ê¸° ì½ëë¥¼ ì¶ê°í©ëë¤.
			if (m_chkMuti.GetCheck())
			{
			if (IDYES == AfxMessageBox(_T("ì íí íëª© ëª¨ëê° ì§ì ì§ëë¤"), MB_YESNO \| MB_ICONWARNING))
			{
			m_chkSingle.SetCheck(FALSE);
			m_chkMuti.SetCheck(TRUE);

			GlassInfoRest();
			for (int i = 0; i < 105; i++)
			{
			m_nSelectFile[i] = 0;
			m_nDefectSize[i] = 0;
			m_nCellSize[i] = 0;
			m_nImageSize[i] = 0;
			m_nCellSizeTemp[i] = m_nCellSize[i];
			}
			m_Formation.Clear();
			m_bFirst = true;
			}
			else
			{
			m_chkSingle.SetCheck(TRUE);
			m_chkMuti.SetCheck(FALSE);
			}
			}
			else
			{
			if (IDYES == AfxMessageBox(_T("ì íí íëª© ëª¨ëê° ì§ì ì§ëë¤"), MB_YESNO \| MB_ICONWARNING))
			{
			m_chkSingle.SetCheck(TRUE);
			m_chkMuti.SetCheck(FALSE);
			GlassInfoRest();
			}
			else
			{
			m_chkSingle.SetCheck(FALSE);
			m_chkMuti.SetCheck(TRUE);
			GlassInfoRest();
			for (int i = 0; i < 105; i++)
			{
			m_nSelectFile[i] = 0;
			m_nDefectSize[i] = 0;
			m_nCellSize[i] = 0;
			m_nImageSize[i] = 0;
			m_nCellSizeTemp[i] = m_nCellSize[i];
			}
			m_Formation.Clear();
			}
			}
			}

			void CReveiwHistoryDlg::OnClickedChkSingle()
			{
			// TODO: ì¬ê¸°ì ì»¨í¸ë¡¤ ìë¦¼ ì²ë¦¬ê¸° ì½ëë¥¼ ì¶ê°í©ëë¤.
			if (m_chkSingle.GetCheck())
			{
			if (IDYES == AfxMessageBox(_T("ì íí íëª© ëª¨ëê° ì§ì ì§ëë¤"), MB_YESNO \| MB_ICONWARNING))
			{
			m_chkMuti.SetCheck(FALSE);
			m_chkSingle.SetCheck(TRUE);
			GlassInfoRest();

			int nRow = 0;
			nRow = m_gridReviewList.GetRowCount();
			for (int i = 1; i < nRow; i++)
			{
			CGridCellCheck* pCellCheck = NULL;
			pCellCheck = (CGridCellCheck*)m_gridReviewList.GetCell(i, 0);
			pCellCheck->SetCheck(FALSE);
			}
			m_gridReviewList.Refresh();
			}
			else
			{
			m_chkSingle.SetCheck(FALSE);
			m_chkMuti.SetCheck(TRUE);
			GlassInfoRest();
			for (int i = 0; i < 105; i++)
			{
			m_nSelectFile[i] = 0;
			m_nDefectSize[i] = 0;
			m_nCellSize[i] = 0;
			m_nImageSize[i] = 0;
			m_nCellSizeTemp[i] = m_nCellSize[i];
			}
			}
			}
			else
			{
			if (IDYES == AfxMessageBox(_T("ì íí íëª© ëª¨ëê° ì§ì ì§ëë¤"), MB_YESNO \| MB_ICONWARNING))
			{
			m_chkMuti.SetCheck(TRUE);
			m_chkSingle.SetCheck(FALSE);
			GlassInfoRest();
			for (int i = 0; i < 105; i++)
			{
			m_nSelectFile[i] = 0;
			m_nDefectSize[i] = 0;
			m_nCellSize[i] = 0;
			m_nImageSize[i] = 0;
			m_nCellSizeTemp[i] = m_nCellSize[i];
			}
			m_bFirst = true;
			}
			else
			{
			m_chkMuti.SetCheck(FALSE);
			m_chkSingle.SetCheck(TRUE);
			}
			}
			}

			void CReveiwHistoryDlg::Imagenoload()
			{
			// TODO: ì¬ê¸°ì ì»¨í¸ë¡¤ ìë¦¼ ì²ë¦¬ê¸° ì½ëë¥¼ ì¶ê°í©ëë¤.
			CPaintDC dc(this);

			// m_ReviewImage.Destroy();
			m_DefectImage.Destroy();
			//LYW 20210825 #3486 ADD START
			m_DefectRotateImage.Destroy();
			//LYW 20210825 #3486 ADD END
			m_AlignFirst.Destroy();
			m_AlignSecend.Destroy();

			CString DeftectPath;
			CFileStatus FileOn;
			TCHAR chFilePath[256] = { 0, };
			GetModuleFileName(NULL, chFilePath, 256);
			CString strFolderPath(chFilePath);
			strFolderPath = strFolderPath.Left(strFolderPath.ReverseFind('\\'));

			strFolderPath = strFolderPath + "\\no-image.png";

			strcpy(m_strConfigFile, strFolderPath.GetBuffer(0));

			m_ImageView.SetImageData(m_strConfigFile);
			// m_ReviewImage.Load(strFolderPath);
			m_DefectImage.Load(strFolderPath);
			m_AlignFirst.Load(strFolderPath);
			m_AlignSecend.Load(strFolderPath);

			HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), strFolderPath,
			IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE \| LR_CREATEDIBSECTION);

			// InvalidateRect(m_picture_rect, FALSE);
			InvalidateRect(m_picture_rect2, FALSE);
			InvalidateRect(m_Align_rect, FALSE);
			InvalidateRect(m_Align_rect2, FALSE);

			dc.SetStretchBltMode(COLORONCOLOR);

			m_ImageView.ReDraw();
			// m_ReviewImage.Draw(dc, m_picture_rect);
			m_DefectImage.Draw(dc, m_picture_rect2);
			m_AlignFirst.Draw(dc, m_Align_rect);
			m_AlignSecend.Draw(dc, m_Align_rect2);
			}

			//LYW 20210825 #3486 ADD START
			void CReveiwHistoryDlg::ImageRotate(CImage & SrcImage, CImage & DstImage, double degree/* = 180.0 */)
			{
			int Height = SrcImage.GetHeight(); // ì¸ë¡ ê¸¸ì´ ì ì¥
			int Width = SrcImage.GetWidth(); // ê°ë¡ ê¸¸ì´ ì ì¥
			int new_x, new_y;
			int R, G, B;
			int center_x = (SrcImage.GetWidth() / 2); // íì ì¤ì¬ì
			int center_y = (SrcImage.GetHeight() / 2); // íì ì¤ì¬ì

			double seta = 3.14 / (180.0 / degree); // ë¼ëì
			double CosSeta = cos(seta);
			double SinSeta = sin(seta);

			for (int y = 0; y < Height; y++)
			{
			for (int x = 0; x < Width; x++)
			{
			new_x = (int)((x - center_x) * CosSeta - (y - center_y) * SinSeta + center_x);
			new_y = (int)((x - center_x) * SinSeta + (y - center_y) * CosSeta + center_y);

			if ((new_x < 0) \|\| (new_x > Width) \|\| (new_y < 0) \|\| (new_y > Height))
			//ì´ë¯¸ì§ ë²ìë¥¼ ë²ì´ëë©´ 0 ê°
			{
			R = 0;
			G = 0;
			B = 0;
			}
			else
			{
			R = GetRValue(SrcImage.GetPixel(new_x, new_y));
			G = GetGValue(SrcImage.GetPixel(new_x, new_y));
			B = GetBValue(SrcImage.GetPixel(new_x, new_y));
			}
			DstImage.SetPixel((int)x, (int)y, RGB(R, G, B));
			new_x = 0; new_y = 0;
			}
			}

			}
			//LYW 20210825 #3486 ADD END

			void CReveiwHistoryDlg::OnChangeEditFileCount()
			{
			// TODO: RICHEDIT ì»¨í¸ë¡¤ì¸ ê²½ì°, ì´ ì»¨í¸ë¡¤ì
			// CDialogEx::OnInitDialog() í¨ìë¥¼ ì¬ì§ì
			//íê³ ë§ì¤í¬ì OR ì°ì°íì¬ ì¤ì ë ENM_CHANGE íëê·¸ë¥¼ ì§ì íì¬ CRichEditCtrl().SetEventMask()ë¥¼ í¸ì¶íì§ ìì¼ë©´
			// ì´ ìë¦¼ ë©ìì§ë¥¼ ë³´ë´ì§ ììµëë¤.

			// TODO: ì¬ê¸°ì ì»¨í¸ë¡¤ ìë¦¼ ì²ë¦¬ê¸° ì½ëë¥¼ ì¶ê°í©ëë¤.
			CString strCount;
			m_ctlFileCount.GetWindowText(strCount);
			m_nFileCount = _ttoi(strCount);
			}

			BOOL CReveiwHistoryDlg::GetCheckFileLoad(int nCount)
			{
			BOOL bNewFile = TRUE;
			if (nCount == 0) return FALSE;

			if (m_vecStrGridReviewPath.size() <= 0) return FALSE;

			if (m_vecStrGridReviewPath[nCount - 1] == m_strRawFilePath) bNewFile = FALSE;

			if (m_vecStrGridReviewList.size() < 1) return FALSE;

			CString strFileName = m_vecStrGridReviewList[nCount - 1];
			CPathSettingDlg* pReivewSetting = CPathSettingDlg::GetMgr();
			CString strBinPath;
			strBinPath = pReivewSetting->GetBinPath();

			CgrmGlassRawData RawData;

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

			strcpy(RawData.GetGlassData()->m_strFileName, strFileName.GetBuffer());
			strcpy(RawData.GetGlassData()->m_strPath, strBinPath.GetBuffer());

			BOOL bRetReadBin = m_pGlassRawMaker->ReadBinFile(&RawData);

			if (bRetReadBin == FALSE)
			{
			m_FormationMap.SetAutoScale();
			LOG(Dbg, _T("[Processe] File Open False"));
			Imagenoload();
			return FALSE;
			}
			return TRUE;
			}

			void CReveiwHistoryDlg::GlassInfoRest()
			{
			m_Formation.m_vecGlassInfo.clear();

			for (int i = 0; i < 105; i++)
			{
			m_nSelectFile[i] = 0;
			m_nDefectSize[i] = 0;
			m_nImageSize[i] = 0;
			}
			m_gridGlassInfo.SetRowCount(2);
			m_gridGlassInfo.Invalidate();
			}

			BOOL CReveiwHistoryDlg::MultiSelectCheck(int nSelectCount)
			{
			if (nSelectCount <= 0) return FALSE;

			//if (m_Formation.m_vecGlassInfo.size() > MAX_COUNT) return FALSE;

			int nDefectSize = 0;
			int nImageSize = 0;
			int nCellSize = 0;

			for (int i = 0; i < MAX_COUNT+1; i++)
			{
			nDefectSize += m_nDefectSize[i];
			nImageSize += m_nImageSize[i];
			nCellSize += m_nCellSize[i];

			if (nSelectCount == m_nSelectFile[i])
			{
			for (int j = 0; j < m_Formation.m_vecGlassInfo.size(); j++)
			{
			_akGlassInfo* pGlassInfo = &m_Formation.m_vecGlassInfo[j];

			if (pGlassInfo->m_nGlassSelect == m_nSelectFile[i])
			{
			m_Formation.m_vecGlassInfo.erase(m_Formation.m_vecGlassInfo.begin() + j);

			if (i == 0)
			{
			m_Formation.m_vecDefects.erase(m_Formation.m_vecDefects.begin(), m_Formation.m_vecDefects.begin() + m_nDefectSize[i]);
			m_Formation.m_vecImage.erase(m_Formation.m_vecImage.begin(), m_Formation.m_vecImage.begin() + m_nImageSize[i]);
			m_FormationMap.m_vecCellRect.erase(m_FormationMap.m_vecCellRect.begin(), m_FormationMap.m_vecCellRect.begin() + m_nCellSize[i]);
			m_nCellSize[i] = 0;
			m_nDefectSize[i] = 0;
			m_nImageSize[i] = 0;
			}
			else if (i != 0 && m_nDefectSize[i] == 0)
			{

			}
			else if (i != 0 && m_nDefectSize[i] > 0)
			{
			if (m_Formation.m_vecDefects.size() == nDefectSize)
			{
			m_Formation.m_vecDefects.clear();
			//m_Formation.m_vecDefects.erase(m_Formation.m_vecDefects.begin(), m_Formation.m_vecDefects.begin() + m_nDefectSize[i]);
			}
			// else
			// {
			// m_Formation.m_vecDefects.erase(m_Formation.m_vecDefects.begin() + nDefectSize-1, m_Formation.m_vecDefects.begin() + nDefectSize-1 + m_nDefectSize[i]);
			// }
			if (m_Formation.m_vecImage.size() == nImageSize)
			{
			m_Formation.m_vecImage.clear();
			//m_Formation.m_vecImage.erase(m_Formation.m_vecImage.begin(), m_Formation.m_vecImage.begin() + m_nImageSize[i]);
			}
			// else
			// {
			// m_Formation.m_vecImage.erase(m_Formation.m_vecImage.begin() + nImageSize-1, m_Formation.m_vecImage.begin() + nImageSize-1 + m_nImageSize[i]);
			// }
			if (m_FormationMap.m_vecCellRect.size() == nCellSize)
			{
			m_FormationMap.m_vecCellRect.clear();
			//m_FormationMap.m_vecCellRect.erase(m_FormationMap.m_vecCellRect.begin(), m_FormationMap.m_vecCellRect.begin() + m_nCellSize[i]);
			}
			// else
			// {
			// m_FormationMap.m_vecCellRect.erase(m_FormationMap.m_vecCellRect.begin() + nCellSize, m_FormationMap.m_vecCellRect.begin() + nCellSize + m_nCellSize[i]);
			// }

			int nCellCount = 0;
			int nDefectCount = 0;
			int nImageCount = 0;

			/* int nCount = 0;*/
			int nCellCount2 = m_nCellSize[i];
			int nDefectCount2 = m_nDefectSize[i];
			int nImageCount2 = m_nImageSize[i];

			int nCellCount3 = 0;
			int nDefectCount3 = 0;
			int nImageCount3 = 0;


			m_nCellSize[i] = 0;
			m_nDefectSize[i] = 0;
			m_nImageSize[i] = 0;



			for (int k = 0; k < MAX_COUNT; k++)
			{
			// if (m_nCellSize[k] != 0)
			// {
			// nCount++;
			// }
			nCellCount = m_nCellSize[k];
			nDefectCount = m_nDefectSize[k];
			nImageCount = m_nImageSize[k];

			if (k == 0)
			{
			nCellCount3 = 0;
			nDefectCount3 = 0;
			nImageCount3 = 0;
			}
			else
			{
			nCellCount3 += m_nCellSize[k];
			nDefectCount3 += m_nDefectSize[k];
			nImageCount3 += m_nImageSize[k];
			}
			}

			m_Formation.m_vecDefects.clear();
			for (int j = 0; j < nDefectSize - nDefectCount2; j++)
			{
			_akDefect *pDefectInfo = &m_Formation.m_vecTempDefects[j];
			double dDefectPosX = pDefectInfo->m_nUMCenterAlignX / 1000.0;
			double dDefectPosY = pDefectInfo->m_nUMCenterAlignY / 1000.0;

			m_Formation.AddDefect(dDefectPosX, dDefectPosY);
			m_Formation.m_vecDefects[j] = m_Formation.m_vecTempDefects[j];
			//ëí ìì í¬ê¸° ë§í¼ë§ ë³µì¬ íë¤
			}
			if (m_nDefectSize[i + 1] != 0)
			{
			int nCount = m_Formation.m_vecDefects.size();
			for (int j = 0; j < m_Formation.m_vecTempDefects.size() - nDefectSize; j++)
			{
			_akDefect *pDefectInfo = &m_Formation.m_vecTempDefects[nDefectSize + j];
			double dDefectPosX = pDefectInfo->m_nUMCenterAlignX / 1000.0;
			double dDefectPosY = pDefectInfo->m_nUMCenterAlignY / 1000.0;

			m_Formation.AddDefect(dDefectPosX, dDefectPosY);
			m_Formation.m_vecDefects[nCount + j] = m_Formation.m_vecTempDefects[nDefectSize +j];
			}
			}

			m_Formation.m_vecImage.clear();
			for (int j = 0; j < nImageSize - nImageCount2; j++)
			{
			m_Formation.AddDefectImage();
			m_Formation.m_vecImage[j] = m_Formation.m_vecTempImage[j];
			//ëí ìì í¬ê¸° ë§í¼ë§ ë³µì¬ íë¤
			}
			if (m_nImageSize[i + 1] != 0)
			{
			int nCount = m_Formation.m_vecImage.size();
			for (int j = 0; j < m_Formation.m_vecTempImage.size() - nImageSize; j++)
			{
			m_Formation.AddDefectImage();
			m_Formation.m_vecImage[nCount + j] = m_Formation.m_vecTempImage[nImageSize + j];
			}
			}

			m_FormationMap.m_vecCellRect.clear();
			for (int j = 0; j < nCellSize - nCellCount2; j++)
			{
			m_FormationMap.AddCell();
			m_FormationMap.m_vecCellRect[j] = m_FormationMap.m_vecTempCellRect[j];
			//ëí ìì í¬ê¸° ë§í¼ë§ ë³µì¬ íë¤
			}

			if (m_nCellSize[i + 1] != 0)
			{
			int nCount = m_FormationMap.m_vecCellRect.size();
			for (int j = 0; j < m_FormationMap.m_vecTempCellRect.size() - nCellSize; j++)
			{
			m_FormationMap.AddCell();
			m_FormationMap.m_vecCellRect[nCount + j] = m_FormationMap.m_vecTempCellRect[nCellSize + j];
			}
			}
			}

			m_nSelectFile[i] = 0;

			// for (int i = 0; i < MAX_COUNT + 1; i++)
			// {
			// for (int iCol = 0; iCol < m_gridReviewList.GetColumnCount(); iCol++)
			// {
			// m_gridReviewList.SetItemState(m_nSelectFile[i], iCol, LVIS_SELECTED);
			// }
			// }
			//
			// m_gridReviewList.Invalidate();

			// int nSelect = i;
			// bool bMax = false;
			// for (nSelect; nSelect < MAX_COUNT; nSelect++)
			// {
			// m_nSelectFile[nSelect] = m_nSelectFile[nSelect + 1];
			// bMax = true;
			// }
			// if (bMax)
			// {
			// m_nSelectFile[nSelect] = 0;
			// }
			// m_nDefectSize[i] = 0;
			// m_nImageSize[i] = 0;
			/* m_nCellSize[i] = 0;*/
			// for (j = 0; j < MAX_COUNT; j++)
			// {
			// if (i <= j)
			// {
			// m_nCellSize[j] = m_nCellSize[j + 1];
			// }
			// }
			AddVecCellSorting(0);
			AddVecDateSorting(0);
			m_gridGlassInfo.SetRowCount(m_Formation.m_vecGlassInfo.size() + 1);
			m_gridDefectInfo.SetRowCount(m_Formation.m_vecDefects.size() + 1);
			m_FormationMap.ReDraw(TRUE);
			return FALSE;
			}
			}
			}
			}

			if (m_Formation.m_vecGlassInfo.size() >= MAX_COUNT + 1) // 1 base
			{
			m_Formation.m_vecGlassInfo.erase(m_Formation.m_vecGlassInfo.begin());

			if (m_nDefectSize[0] != 0)
			{
			m_Formation.m_vecDefects.erase(m_Formation.m_vecDefects.begin(), m_Formation.m_vecDefects.begin() + m_nDefectSize[0]);
			}
			if (m_nImageSize[0] != 0)
			{
			m_Formation.m_vecImage.erase(m_Formation.m_vecImage.begin(), m_Formation.m_vecImage.begin() + m_nImageSize[0]);
			}
			if (m_nCellSize[0] != 0)
			{
			m_FormationMap.m_vecCellRect.erase(m_FormationMap.m_vecCellRect.begin(), m_FormationMap.m_vecCellRect.begin() + m_nCellSize[0]);
			}
			}
			return TRUE;
			}

			int CReveiwHistoryDlg::MultiInsert(int nSelectCount, int nDataCount)
			{
			if (nSelectCount <= 0) return FALSE;

			//if (m_Formation.m_vecGlassInfo.size() > MAX_COUNT) return FALSE;

			if (m_Formation.m_vecGlassInfo.size() >= MAX_COUNT+1) //1base
			{
			m_Formation.m_vecGlassInfo.erase(m_Formation.m_vecGlassInfo.begin());

			if (m_nDefectSize[0] != 0)
			{
			m_Formation.m_vecDefects.erase(m_Formation.m_vecDefects.begin(), m_Formation.m_vecDefects.begin() + m_nDefectSize[0]);
			}
			if (m_nImageSize[0] != 0)
			{
			m_Formation.m_vecImage.erase(m_Formation.m_vecImage.begin(), m_Formation.m_vecImage.begin() + m_nImageSize[0]);
			}
			if (m_nCellSize[0] != 0)
			{
			m_FormationMap.m_vecCellRect.erase(m_FormationMap.m_vecCellRect.begin(), m_FormationMap.m_vecCellRect.begin() + m_nCellSize[0]);
			}
			}

			int nDefectSize = 0;
			int nImageSize = 0;
			int nCellSize = 0;

			for (int i = 0; i < MAX_COUNT; i++)
			{
			nDefectSize += m_nDefectSize[i];
			nImageSize += m_nImageSize[i];
			nCellSize += m_nCellSize[i];

			if (nSelectCount == m_nSelectFile[i])
			{
			for (int j = 0; j < m_Formation.m_vecGlassInfo.size(); j++)
			{
			_akGlassInfo* pGlassInfo = &m_Formation.m_vecGlassInfo[j];

			if (pGlassInfo->m_nGlassSelect == m_nSelectFile[i])
			{
			m_Formation.m_vecGlassInfo.erase(m_Formation.m_vecGlassInfo.begin() + j);

			if (i == 0)
			{
			m_Formation.m_vecDefects.erase(m_Formation.m_vecDefects.begin(), m_Formation.m_vecDefects.begin() + m_nDefectSize[i]);
			m_Formation.m_vecDefects.clear();
			m_Formation.m_vecImage.erase(m_Formation.m_vecImage.begin(), m_Formation.m_vecImage.begin() + m_nImageSize[i]);
			m_Formation.m_vecImage.clear();
			m_FormationMap.m_vecCellRect.erase(m_FormationMap.m_vecCellRect.begin(), m_FormationMap.m_vecCellRect.begin() + m_nCellSize[i]);

			if (m_bDefectAll == false && !m_chkSingle.GetCheck())
			{
			AddVecDataDefct2(nDataCount/, nCount/);
			}
			else if (m_bDefectAll == true && !m_chkSingle.GetCheck())
			{
			AddVecDataDefectAll2(nDataCount/, nCount/);
			}
			}
			else if (i != 0 && m_nDefectSize[i] == 0)
			{
			if (m_bDefectAll == false && !m_chkSingle.GetCheck())
			{
			AddVecDataDefct2(nDataCount/, nCount/);
			}
			else if (m_bDefectAll == true && !m_chkSingle.GetCheck())
			{
			AddVecDataDefectAll2(nDataCount/, nCount/);
			}
			}
			else if (i != 0 && m_nDefectSize[i] > 0)
			{
			if (m_Formation.m_vecDefects.size() == nDefectSize)
			{
			m_Formation.m_vecDefects.erase(m_Formation.m_vecDefects.begin(), m_Formation.m_vecDefects.begin() + m_nDefectSize[i]);
			}
			// else
			// {
			Sleep(1);
			//nê° ê¹ì§ë§ ë³µì¬ íë¤. í´ë¦¬ì´ í ì
			m_Formation.m_vecDefects.clear();
			for (int j = 0; j < nDefectSize-m_nDefectSize[i]; j++)
			{
			_akDefect *pDefectInfo = &m_Formation.m_vecTempDefects[j];
			double dDefectPosX = pDefectInfo->m_nUMCenterAlignX / 1000.0;
			double dDefectPosY = pDefectInfo->m_nUMCenterAlignY / 1000.0;

			m_Formation.AddDefect(dDefectPosX, dDefectPosY);
			m_Formation.m_vecDefects[j] = m_Formation.m_vecTempDefects[j];
			//ëí ìì í¬ê¸° ë§í¼ë§ ë³µì¬ íë¤
			}
			//ìì±ë ëíì ì¶ê° íë¤
			if (m_bDefectAll == false && !m_chkSingle.GetCheck())
			{
			AddVecDataDefct2(nDataCount/, nCount/);
			}
			else if (m_bDefectAll == true && !m_chkSingle.GetCheck())
			{
			AddVecDataDefectAll2(nDataCount/, nCount/);
			}

			// Sleep(1);
			//
			// //ì¶ê°í ëí ë¤ì ë¶ì¬ ë£ëë¤
			// if (m_nDefectSize[i + 1] != 0)
			// {
			// for (int j = 0; j < m_nDefectSize[i + 1]; j++)
			// {
			// int nCount = m_nDefectSize[i - 1];
			// _akDefect *pDefectInfo = &m_Formation.m_vecTempDefects[nDefectSize + j];
			// double dDefectPosX = pDefectInfo->m_nUMCenterAlignX / 1000.0;
			// double dDefectPosY = pDefectInfo->m_nUMCenterAlignY / 1000.0;
			//
			// m_Formation.AddDefect(dDefectPosX, dDefectPosY);
			// m_Formation.m_vecDefects[nCount + j] = m_Formation.m_vecTempDefects[nDefectSize + j];
			// }
			// }

			Sleep(1);
			m_Formation.m_vecImage.clear();
			for (int j = 0; j < nImageSize - m_nImageSize[i]; j++)
			{
			m_Formation.AddDefectImage();
			m_Formation.m_vecImage[j] = m_Formation.m_vecTempImage[j];
			//ëí ìì í¬ê¸° ë§í¼ë§ ë³µì¬ íë¤
			}
			if (m_nImageSize[i + 1] != 0)
			{
			int nSize = m_Formation.m_vecTempImage.size() - m_Formation.m_vecImage.size();
			//ìì ë¶í° ëê¹ì§ ë³µì¬ë¥¼ íë¤
			for (int j = 0; j < nSize; j++)
			{
			int nCount = m_nImageSize[i - 1];

			m_Formation.AddDefectImage();
			m_Formation.m_vecImage[nCount + j] = m_Formation.m_vecTempImage[nCount + j];
			}
			}

			Sleep(1);
			m_FormationMap.m_vecCellRect.clear();
			for (int j = 0; j < nCellSize - m_nCellSize[i]; j++)
			{
			m_FormationMap.AddCell();
			m_FormationMap.m_vecCellRect[j] = m_FormationMap.m_vecTempCellRect[j];
			//ëí ìì í¬ê¸° ë§í¼ë§ ë³µì¬ íë¤
			}
			if (m_nCellSize[i + 1] != 0)
			{
			int nSize = m_FormationMap.m_vecTempCellRect.size() - m_FormationMap.m_vecCellRect.size();
			for (int j = 0; j < nSize; j++)
			{
			int nCount = m_nCellSize[i - 1];

			m_FormationMap.AddCell();
			m_FormationMap.m_vecCellRect[nCount + j] = m_FormationMap.m_vecTempCellRect[nCount + j];
			//m_FormationMap.m_vecCellRect[nCount + j] = m_FormationMap.m_vecTempCellRect[nCellSize + j];
			}
			}

			//m_Formation.m_vecDefects.erase(m_Formation.m_vecDefects.begin() + nDefectSize, m_Formation.m_vecDefects.begin() + nDefectSize + m_nDefectSize[i]);

			// if (m_Formation.m_vecImage.size() == nImageSize)
			// {
			// m_Formation.m_vecImage.erase(m_Formation.m_vecImage.begin(), m_Formation.m_vecImage.begin() + m_nImageSize[i]);
			// }
			// else
			// {
			// m_Formation.m_vecImage.erase(m_Formation.m_vecImage.begin() + nImageSize, m_Formation.m_vecImage.begin() + nImageSize + m_nImageSize[i]);
			// }
			}

			//m_nSelectFile[i] = 0;
			m_nDefectSize[i] = 0;
			m_nImageSize[i] = 0;
			m_nCellSize[i] = 0;
			// for (j = 0; j < MAX_COUNT; j++)
			// {
			// if (i <= j)
			// {
			// m_nCellSize[j] = m_nCellSize[j + 1];
			// }
			// }

			if (m_Formation.m_vecGlassInfo.size() > 0)
			{
			m_gridGlassInfo.SetRowCount(m_Formation.m_vecGlassInfo.size() + 1);
			m_gridDefectInfo.SetRowCount(m_Formation.m_vecDefects.size() + 1);
			return i;
			}
			else
			{
			m_gridGlassInfo.SetRowCount(2);
			m_gridDefectInfo.SetRowCount(2);
			return i;
			}
			return i;
			}
			}
			}
			}

			// if (m_bDefectAll == false && !m_chkSingle.GetCheck())
			// {
			// AddVecDataDefct2(nDataCount/, nCount/);
			// }
			// else if (m_bDefectAll == true && !m_chkSingle.GetCheck())
			// {
			// AddVecDataDefectAll2(nDataCount/, nCount/);
			// }
			return -1;
			}

			void CReveiwHistoryDlg::InitSelectGlass(int nSelectCount)
			{
			int nCountMax = MAX_COUNT+1;
			bool bMax = false;
			for (int i = 0; i < MAX_COUNT+1; i++)
			{
			if (nSelectCount != m_nSelectFile[i] && m_nSelectFile[i] == 0)
			{
			if (!GetCheckFileLoad(nSelectCount)) return;
			m_nSelectFile[i] = nSelectCount;
			bMax = true;
			break;
			}
			}
			if (!bMax)
			{
			for (int j = 0; j < MAX_COUNT; j++)
			{
			if (!GetCheckFileLoad(nSelectCount)) return;
			m_nSelectFile[j] = m_nSelectFile[j + 1];
			}
			m_nSelectFile[MAX_COUNT] = nSelectCount;
			}
			}

			void CReveiwHistoryDlg::AddVecDataImage(int nDataCount)
			{
			for (int i = 0; i < nDataCount; i++)
			{
			_grmDefectData* pDefect = m_Server.GetDefectData(i);
			_grmGlassData* pGlass = m_Server.GetGlassData();

			CString strTemp;
			int nInfoCount = 0;

			CString strReviewImageName;
			strReviewImageName = pDefect->m_ReviewDefect.m_strRevImageName;

			if (strReviewImageName == "" \|\| strReviewImageName == "*")
			{
			continue;
			}
			else
			{
			m_Formation.AddDefectImage();
			SetImageCount();
			_akReviewList* pImageInfo = &m_Formation.m_vecImage[m_Formation.m_vecImage.size() - 1];

			pImageInfo->m_nDefectID = pDefect->m_nDefectID;
			strcpy(pImageInfo->m_strAoiImageName, pDefect->m_strAoiImageName);
			pImageInfo->m_nDefectIdx = pDefect->m_nDefectIdx;
			pImageInfo->m_strReviewImageName = strReviewImageName;

			strcpy(pImageInfo->m_strAoiImagePath, pDefect->m_strAoiImagePath);
			strcpy(pImageInfo->m_strReviewImagePath, pDefect->m_ReviewDefect.m_strRevImagePath);
			strcpy(pImageInfo->m_strAlignFirst, pGlass->m_strAlignFirst);
			strcpy(pImageInfo->m_strAlignSecond, pGlass->m_strAlignSecond);
			pImageInfo->m_strGlassID = pGlass->m_strGlassID;
			}
			}
			}

			void CReveiwHistoryDlg::AddVecDataDefct(int nDataCount)
			{
			for (int i = 0; i < nDataCount; i++)
			{
			_grmDefectData* pDefect = m_Server.GetDefectData(i);

			int nInfoCount = 0;

			CString strReviewImageName;
			strReviewImageName = pDefect->m_ReviewDefect.m_strRevImageName;

			if (strReviewImageName == "" \|\| strReviewImageName == "*")
			{
			continue;
			}
			else
			{
			double dDefectPosX = pDefect->m_nUMCenterAlignX / 1000.0;
			double dDefectPosY = pDefect->m_nUMCenterAlignY / 1000.0;

			m_Formation.AddDefect(dDefectPosX, dDefectPosY);
			SetDefectCount();
			_akDefect* pDefectInfo = &m_Formation.m_vecDefects[m_Formation.m_vecDefects.size() - 1];

			pDefectInfo->m_nDefectID = pDefect->m_nDefectID;
			pDefectInfo->m_sDefectLoc = pDefect->m_sDefectLoc;
			strcpy(pDefectInfo->m_strDefectType, pDefect->m_strDefectType);
			strcpy(pDefectInfo->m_strDefectCode, pDefect->m_strDefectCode);
			pDefectInfo->m_DefectType = pDefect->m_DefectType;
			pDefectInfo->m_DefectSubType = pDefect->m_DefectSubType;
			pDefectInfo->m_nDefectRScale = pDefect->m_nDefectRScale;
			pDefectInfo->m_nUMSizeX = pDefect->m_nUMSizeX;
			pDefectInfo->m_nUMSizeY = pDefect->m_nUMSizeY;
			pDefectInfo->m_nUMSize = pDefect->m_nUMSize;
			memcpy(pDefectInfo->m_sZonePixelCount, pDefect->m_sZonePixelCount, sizeof(pDefect->m_sZonePixelCount));
			pDefectInfo->m_nLevelSrcMax = pDefect->m_nLevelSrcMax;
			pDefectInfo->m_nLevelSrcMin = pDefect->m_nLevelSrcMin;
			pDefectInfo->m_nLevelSrcAvg = pDefect->m_nLevelSrcAvg;
			pDefectInfo->m_sDefectPeak = pDefect->m_sDefectPeak;
			strcpy(pDefectInfo->m_strStackFirst, pDefect->m_strStackFirst);
			pDefectInfo->m_nCameraID = pDefect->m_nCameraID;
			pDefectInfo->m_nScanIdx = pDefect->m_nScanIdx;
			pDefectInfo->m_nLevelRefMax = pDefect->m_nLevelRefMax;
			pDefectInfo->m_nLevelRefMin = pDefect->m_nLevelRefMin;
			pDefectInfo->m_nLevelRefAvg = pDefect->m_nLevelRefAvg;
			pDefectInfo->m_nUMCenterAlignX = pDefect->m_nUMCenterAlignX;
			pDefectInfo->m_nUMCenterAlignY = pDefect->m_nUMCenterAlignY;
			pDefectInfo->m_nUMCellX = pDefect->m_nUMCellX;
			pDefectInfo->m_nUMCellY = pDefect->m_nUMCellY;
			pDefectInfo->m_nScratchRatio = pDefect->m_nScratchRatio;
			pDefectInfo->m_nDensity = pDefect->m_nDensity;
			pDefectInfo->m_bMergeState = pDefect->m_bMergeState;
			pDefectInfo->m_nShotIdx = pDefect->m_ReviewDefect.m_nShotIndex;
			pDefectInfo->m_nModelIdx = pDefect->m_ReviewDefect.m_nModuleIndex;

			for (int j = 0; j < nInfoCount; j++) pDefectInfo->m_strInfos[j].Trim();
			}
			}
			}

			void CReveiwHistoryDlg::AddVecDataDefectAll(int nDataCount)
			{
			for (int i = 0; i < nDataCount; i++)
			{
			_grmDefectData* pDefect = m_Server.GetDefectData(i);
			int nInfoCount = 0;

			double dDefectPosX = pDefect->m_nUMCenterAlignX / 1000.0;
			double dDefectPosY = pDefect->m_nUMCenterAlignY / 1000.0;

			m_Formation.AddDefect(dDefectPosX, dDefectPosY);
			SetDefectCount();
			_akDefect* pDefectInfo = &m_Formation.m_vecDefects[m_Formation.m_vecDefects.size() - 1];

			pDefectInfo->m_nDefectID = pDefect->m_nDefectID;
			pDefectInfo->m_sDefectLoc = pDefect->m_sDefectLoc;
			strcpy(pDefectInfo->m_strDefectType, pDefect->m_strDefectType);
			strcpy(pDefectInfo->m_strDefectCode, pDefect->m_strDefectCode);
			pDefectInfo->m_DefectType = pDefect->m_DefectType;
			pDefectInfo->m_DefectSubType = pDefect->m_DefectSubType;
			pDefectInfo->m_nDefectRScale = pDefect->m_nDefectRScale;
			pDefectInfo->m_nUMSizeX = pDefect->m_nUMSizeX;
			pDefectInfo->m_nUMSizeY = pDefect->m_nUMSizeY;
			pDefectInfo->m_nUMSize = pDefect->m_nUMSize;
			memcpy(pDefectInfo->m_sZonePixelCount, pDefect->m_sZonePixelCount, sizeof(pDefect->m_sZonePixelCount));
			pDefectInfo->m_nLevelSrcMax = pDefect->m_nLevelSrcMax;
			pDefectInfo->m_nLevelSrcMin = pDefect->m_nLevelSrcMin;
			pDefectInfo->m_nLevelSrcAvg = pDefect->m_nLevelSrcAvg;
			pDefectInfo->m_sDefectPeak = pDefect->m_sDefectPeak;
			strcpy(pDefectInfo->m_strStackFirst, pDefect->m_strStackFirst);
			pDefectInfo->m_nCameraID = pDefect->m_nCameraID;
			pDefectInfo->m_nScanIdx = pDefect->m_nScanIdx;
			pDefectInfo->m_nLevelRefMax = pDefect->m_nLevelRefMax;
			pDefectInfo->m_nLevelRefMin = pDefect->m_nLevelRefMin;
			pDefectInfo->m_nLevelRefAvg = pDefect->m_nLevelRefAvg;
			pDefectInfo->m_nUMCenterAlignX = pDefect->m_nUMCenterAlignX;
			pDefectInfo->m_nUMCenterAlignY = pDefect->m_nUMCenterAlignY;
			pDefectInfo->m_nUMCellX = pDefect->m_nUMCellX;
			pDefectInfo->m_nUMCellY = pDefect->m_nUMCellY;
			pDefectInfo->m_nScratchRatio = pDefect->m_nScratchRatio;
			pDefectInfo->m_nDensity = pDefect->m_nDensity;
			pDefectInfo->m_bMergeState = pDefect->m_bMergeState;

			CString strReviewImageName;
			strReviewImageName = pDefect->m_ReviewDefect.m_strRevImageName;

			if (strReviewImageName == "" \|\| strReviewImageName == "*")
			{
			pDefectInfo->m_nShotIdx = -1;
			pDefectInfo->m_nModelIdx = -1;
			}
			else
			{
			pDefectInfo->m_nShotIdx = pDefect->m_ReviewDefect.m_nShotIndex;
			pDefectInfo->m_nModelIdx = pDefect->m_ReviewDefect.m_nModuleIndex;
			}


			for (int j = 0; j < nInfoCount; j++) pDefectInfo->m_strInfos[j].Trim();
			}
			}

			void CReveiwHistoryDlg::AddVecDataDefct2(int nDataCount/, int nRawCount/)
			{
			// int nCount = MultiInsert(m_nCount, nDataCount);

			// if(nCount < 0) return;
			//
			for (int i = 0; i < nDataCount; i++)
			{
			_grmDefectData* pDefect = m_Server.GetDefectData(i);

			int nInfoCount = 0;

			CString strReviewImageName;
			strReviewImageName = pDefect->m_ReviewDefect.m_strRevImageName;

			if (strReviewImageName == "" \|\| strReviewImageName == "*")
			{
			continue;
			}
			else
			{
			double dDefectPosX = pDefect->m_nUMCenterAlignX / 1000.0;
			double dDefectPosY = pDefect->m_nUMCenterAlignY / 1000.0;

			m_Formation.AddDefect(dDefectPosX, dDefectPosY);
			SetDefectCount();

			_akDefect* pDefectInfo = NULL;

			// if (nCount == 0)
			// {
			pDefectInfo = &m_Formation.m_vecDefects[m_Formation.m_vecDefects.size() - 1];
			// }
			// else
			// {
			// //ì¤ê°ì ê° ì½ì
			// pDefectInfo = &m_Formation.m_vecDefects[m_Formation.m_vecDefects.size() - 1];
			// //pDefectInfo = &m_Formation.m_vecDefects[nCount + i];
			// }

			pDefectInfo->m_nDefectID = pDefect->m_nDefectID;
			pDefectInfo->m_sDefectLoc = pDefect->m_sDefectLoc;
			strcpy(pDefectInfo->m_strDefectType, pDefect->m_strDefectType);
			strcpy(pDefectInfo->m_strDefectCode, pDefect->m_strDefectCode);
			pDefectInfo->m_DefectType = pDefect->m_DefectType;
			pDefectInfo->m_DefectSubType = pDefect->m_DefectSubType;
			pDefectInfo->m_nDefectRScale = pDefect->m_nDefectRScale;
			pDefectInfo->m_nUMSizeX = pDefect->m_nUMSizeX;
			pDefectInfo->m_nUMSizeY = pDefect->m_nUMSizeY;
			pDefectInfo->m_nUMSize = pDefect->m_nUMSize;
			memcpy(pDefectInfo->m_sZonePixelCount, pDefect->m_sZonePixelCount, sizeof(pDefect->m_sZonePixelCount));
			pDefectInfo->m_nLevelSrcMax = pDefect->m_nLevelSrcMax;
			pDefectInfo->m_nLevelSrcMin = pDefect->m_nLevelSrcMin;
			pDefectInfo->m_nLevelSrcAvg = pDefect->m_nLevelSrcAvg;
			pDefectInfo->m_sDefectPeak = pDefect->m_sDefectPeak;
			strcpy(pDefectInfo->m_strStackFirst, pDefect->m_strStackFirst);
			pDefectInfo->m_nCameraID = pDefect->m_nCameraID;
			pDefectInfo->m_nScanIdx = pDefect->m_nScanIdx;
			pDefectInfo->m_nLevelRefMax = pDefect->m_nLevelRefMax;
			pDefectInfo->m_nLevelRefMin = pDefect->m_nLevelRefMin;
			pDefectInfo->m_nLevelRefAvg = pDefect->m_nLevelRefAvg;
			pDefectInfo->m_nUMCenterAlignX = pDefect->m_nUMCenterAlignX;
			pDefectInfo->m_nUMCenterAlignY = pDefect->m_nUMCenterAlignY;
			pDefectInfo->m_nUMCellX = pDefect->m_nUMCellX;
			pDefectInfo->m_nUMCellY = pDefect->m_nUMCellY;
			pDefectInfo->m_nScratchRatio = pDefect->m_nScratchRatio;
			pDefectInfo->m_nDensity = pDefect->m_nDensity;
			pDefectInfo->m_bMergeState = pDefect->m_bMergeState;

			for (int j = 0; j < nInfoCount; j++) pDefectInfo->m_strInfos[j].Trim();
			}
			}
			}

			void CReveiwHistoryDlg::AddVecDataDefectAll2(int nDataCount/, int nRawCount/)
			{
			for (int i = 0; i < nDataCount; i++)
			{
			_grmDefectData* pDefect = m_Server.GetDefectData(i);

			int nInfoCount = 0;

			CString strReviewImageName;
			strReviewImageName = pDefect->m_ReviewDefect.m_strRevImageName;

			double dDefectPosX = pDefect->m_nUMCenterAlignX / 1000.0;
			double dDefectPosY = pDefect->m_nUMCenterAlignY / 1000.0;

			m_Formation.AddDefect(dDefectPosX, dDefectPosY);
			SetDefectCount();

			_akDefect* pDefectInfo = NULL;

			pDefectInfo = &m_Formation.m_vecDefects[m_Formation.m_vecDefects.size() - 1];

			pDefectInfo->m_nDefectID = pDefect->m_nDefectID;
			pDefectInfo->m_sDefectLoc = pDefect->m_sDefectLoc;
			strcpy(pDefectInfo->m_strDefectType, pDefect->m_strDefectType);
			strcpy(pDefectInfo->m_strDefectCode, pDefect->m_strDefectCode);
			pDefectInfo->m_DefectType = pDefect->m_DefectType;
			pDefectInfo->m_DefectSubType = pDefect->m_DefectSubType;
			pDefectInfo->m_nDefectRScale = pDefect->m_nDefectRScale;
			pDefectInfo->m_nUMSizeX = pDefect->m_nUMSizeX;
			pDefectInfo->m_nUMSizeY = pDefect->m_nUMSizeY;
			pDefectInfo->m_nUMSize = pDefect->m_nUMSize;
			memcpy(pDefectInfo->m_sZonePixelCount, pDefect->m_sZonePixelCount, sizeof(pDefect->m_sZonePixelCount));
			pDefectInfo->m_nLevelSrcMax = pDefect->m_nLevelSrcMax;
			pDefectInfo->m_nLevelSrcMin = pDefect->m_nLevelSrcMin;
			pDefectInfo->m_nLevelSrcAvg = pDefect->m_nLevelSrcAvg;
			pDefectInfo->m_sDefectPeak = pDefect->m_sDefectPeak;
			strcpy(pDefectInfo->m_strStackFirst, pDefect->m_strStackFirst);
			pDefectInfo->m_nCameraID = pDefect->m_nCameraID;
			pDefectInfo->m_nScanIdx = pDefect->m_nScanIdx;
			pDefectInfo->m_nLevelRefMax = pDefect->m_nLevelRefMax;
			pDefectInfo->m_nLevelRefMin = pDefect->m_nLevelRefMin;
			pDefectInfo->m_nLevelRefAvg = pDefect->m_nLevelRefAvg;
			pDefectInfo->m_nUMCenterAlignX = pDefect->m_nUMCenterAlignX;
			pDefectInfo->m_nUMCenterAlignY = pDefect->m_nUMCenterAlignY;
			pDefectInfo->m_nUMCellX = pDefect->m_nUMCellX;
			pDefectInfo->m_nUMCellY = pDefect->m_nUMCellY;
			pDefectInfo->m_nScratchRatio = pDefect->m_nScratchRatio;
			pDefectInfo->m_nDensity = pDefect->m_nDensity;
			pDefectInfo->m_bMergeState = pDefect->m_bMergeState;

			for (int j = 0; j < nInfoCount; j++) pDefectInfo->m_strInfos[j].Trim();
			}

			// for (int i = 0; i < nDataCount; i++)
			// {
			// _grmDefectData* pDefect = m_Server.GetDefectData(i);
			// int nInfoCount = 0;
			//
			// double dDefectPosX = pDefect->m_nUMCenterAlignX / 1000.0;
			// double dDefectPosY = pDefect->m_nUMCenterAlignY / 1000.0;
			//
			// m_Formation.AddDefect(dDefectPosX, dDefectPosY);
			// SetDefectCount();
			//
			// _akDefect* pDefectInfo = NULL;
			//
			// // if (nCount == 0)
			// // {
			// pDefectInfo = &m_Formation.m_vecDefects[m_Formation.m_vecDefects.size() - 1];
			// // }
			// // else
			// // {
			// // pDefectInfo = &m_Formation.m_vecDefects[nCount + i];
			// // }
			//
			// //m_Formation.m_vecDefects.insert(m_Formation.m_vecDefects.begin() + 1400, pDefect->m_nDefectID);
			//
			// pDefectInfo->m_nDefectID = pDefect->m_nDefectID;
			// pDefectInfo->m_sDefectLoc = pDefect->m_sDefectLoc;
			// strcpy(pDefectInfo->m_strDefectType, pDefect->m_strDefectType);
			// strcpy(pDefectInfo->m_strDefectCode, pDefect->m_strDefectCode);
			// pDefectInfo->m_DefectType = pDefect->m_DefectType;
			// pDefectInfo->m_DefectSubType = pDefect->m_DefectSubType;
			// pDefectInfo->m_nDefectRScale = pDefect->m_nDefectRScale;
			// pDefectInfo->m_nUMSizeX = pDefect->m_nUMSizeX;
			// pDefectInfo->m_nUMSizeY = pDefect->m_nUMSizeY;
			// pDefectInfo->m_nUMSize = pDefect->m_nUMSize;
			// memcpy(pDefectInfo->m_sZonePixelCount, pDefect->m_sZonePixelCount, sizeof(pDefect->m_sZonePixelCount));
			// pDefectInfo->m_nLevelSrcMax = pDefect->m_nLevelSrcMax;
			// pDefectInfo->m_nLevelSrcMin = pDefect->m_nLevelSrcMin;
			// pDefectInfo->m_nLevelSrcAvg = pDefect->m_nLevelSrcAvg;
			// pDefectInfo->m_sDefectPeak = pDefect->m_sDefectPeak;
			// strcpy(pDefectInfo->m_strStackFirst, pDefect->m_strStackFirst);
			// pDefectInfo->m_nCameraID = pDefect->m_nCameraID;
			// pDefectInfo->m_nScanIdx = pDefect->m_nScanIdx;
			// pDefectInfo->m_nLevelRefMax = pDefect->m_nLevelRefMax;
			// pDefectInfo->m_nLevelRefMin = pDefect->m_nLevelRefMin;
			// pDefectInfo->m_nLevelRefAvg = pDefect->m_nLevelRefAvg;
			// pDefectInfo->m_nUMCenterAlignX = pDefect->m_nUMCenterAlignX;
			// pDefectInfo->m_nUMCenterAlignY = pDefect->m_nUMCenterAlignY;
			// pDefectInfo->m_nUMCellX = pDefect->m_nUMCellX;
			// pDefectInfo->m_nUMCellY = pDefect->m_nUMCellY;
			// pDefectInfo->m_nScratchRatio = pDefect->m_nScratchRatio;
			// pDefectInfo->m_nDensity = pDefect->m_nDensity;
			// pDefectInfo->m_bMergeState = pDefect->m_bMergeState;
			//
			// for (int j = 0; j < nInfoCount; j++) pDefectInfo->m_strInfos[j].Trim();
			// }
			}

			void CReveiwHistoryDlg::AddVecGlassData(int nCount)
			{
			m_Formation.AddGlassInfo();

			_grmGlassData* pGlass = m_Server.GetGlassData();
			_akGlassInfo* pGlassInfo = &m_Formation.m_vecGlassInfo[m_Formation.m_vecGlassInfo.size() - 1];

			pGlassInfo->m_nGlassSelect = nCount;
			pGlassInfo->m_strPPID = pGlass->m_strPPID;
			pGlassInfo->m_strGlassID = pGlass->m_strGlassID;
			pGlassInfo->m_nDefectNum = pGlass->m_nDefectNum;
			pGlassInfo->m_nReviewNum = GetImageCount();
			pGlassInfo->m_strGlassJudge = pGlass->m_strGlassJudge;
			pGlassInfo->m_strLotID = pGlass->m_strLotID;
			pGlassInfo->m_strSLotID = pGlass->m_strSLotID;
			pGlassInfo->m_nSlot_No = pGlass->m_nSlot_No;
			pGlassInfo->m_nCellNum = pGlass->m_nCellNum;
			pGlassInfo->m_nGlassSizeHeight = pGlass->m_nGlassSizeHeight;
			pGlassInfo->m_nGlassSizeWidth = pGlass->m_nGlassSizeWidth;
			}

			void CReveiwHistoryDlg::AddVecCellData(int nCellCount)
			{
			for (int i = 0; i < nCellCount; i++)
			{
			SetCellCount();
			CakRectd rectCell;
			_grmCellData* pCellData = m_Server.GetCellData(i);
			rectCell.left = pCellData->m_rectCellLeft / 1000.0;
			rectCell.top = pCellData->m_rectCellTop / 1000.0;
			rectCell.right = pCellData->m_rectCellRight / 1000.0;
			rectCell.bottom = pCellData->m_rectCellBottom / 1000.0;
			m_FormationMap.m_vecCellRect.push_back(rectCell);
			}
			}

			void CReveiwHistoryDlg::SortListDefect(int nCol)
			{
			if (nCol == 0)
			return;

			/* if (m_pDefectFormation == NULL) return;*/

			m_bAsending = !m_bAsending;

			_akDefect *pDefect;
			std::vector< std::pair<CString, _akDefect*> > vecString;
			std::vector< std::pair<double, _akDefect*> > vecValue;
			CString strValue;
			double dValue;
			short sValue[16];

			for (int i = 0; i < m_Formation.m_vecTempDefects.size(); i++)
			{
			pDefect = &m_Formation.m_vecTempDefects[i];

			switch (nCol)
			{
			case 1: dValue = pDefect->m_nDefectID; break;
			case 2: dValue = pDefect->m_sDefectLoc; break;
			case 3: strValue = pDefect->m_strDefectType; break;
			case 4: strValue = pDefect->m_strDefectCode; break;
			case 5: dValue = pDefect->m_DefectType; break;
			case 6: dValue = pDefect->m_DefectSubType; break;
			case 7: dValue = pDefect->m_nDefectRScale; break;
			case 8: dValue = pDefect->m_nUMSizeX; break;
			case 9: dValue = pDefect->m_nUMSizeY; break;
			case 10: dValue = pDefect->m_nUMSize; break;
			//case 11: memcpy(sValue, pDefect->m_sZonePixelCount, sizeof(pDefect->m_sZonePixelCount)); break;
			case 12: dValue = pDefect->m_nLevelSrcMax; break;
			case 13: dValue = pDefect->m_nLevelSrcMin; break;
			case 14: dValue = pDefect->m_nLevelSrcAvg; break;
			case 15: dValue = pDefect->m_sDefectPeak; break;
			case 16: strValue = pDefect->m_strStackFirst; break;
			case 17: dValue = pDefect->m_nCameraID; break;
			case 18: dValue = pDefect->m_nScanIdx; break;
			case 19: dValue = pDefect->m_nLevelRefMax; break;
			case 20: dValue = pDefect->m_nLevelRefMin; break;
			case 21: dValue = pDefect->m_nLevelRefAvg; break;
			case 22: dValue = pDefect->m_nUMCenterAlignX; break;
			case 23: dValue = pDefect->m_nUMCenterAlignY; break;
			case 24: dValue = pDefect->m_nUMCellX; break;
			case 25: dValue = pDefect->m_nUMCellY; break;
			case 26: dValue = pDefect->m_nScratchRatio; break;
			case 27: dValue = pDefect->m_nDensity; break;
			case 28: dValue = pDefect->m_bMergeState; break;
			}

			if (strValue.IsEmpty() == FALSE) vecString.push_back(std::make_pair(strValue, pDefect));
			else vecValue.push_back(std::make_pair(dValue, pDefect));
			}

			if (!vecString.empty())
			{
			if (m_bAsending == TRUE) //ì¤ë¦ ì°¨ì
			std::sort(vecString.begin(), vecString.end(), std::greater< std::pair<CString, _akDefect*> >());
			else //ë´ë¦¼ ì°¨ì
			std::sort(vecString.begin(), vecString.end(), std::less< std::pair<CString, _akDefect*> >());

			m_Formation.m_vecDefects.clear();
			std::vector< std::pair<CString, _akDefect*> >::iterator itVec;

			for (itVec = vecString.begin(); itVec != vecString.end(); ++itVec)
			{
			m_Formation.m_vecDefects.push_back(*itVec->second);
			}
			}
			else//if (!vecString.empty())
			{
			if (m_bAsending == TRUE)
			std::sort(vecValue.begin(), vecValue.end(), std::greater< std::pair<double, _akDefect*> >());
			else
			std::sort(vecValue.begin(), vecValue.end(), std::less< std::pair<double, _akDefect*> >());

			m_Formation.m_vecDefects.clear();
			std::vector< std::pair<double, _akDefect*> >::iterator itVec;

			for (itVec = vecValue.begin(); itVec != vecValue.end(); ++itVec)
			{
			m_Formation.m_vecDefects.push_back(*itVec->second);
			}
			}
			}

			void CReveiwHistoryDlg::AddVecDateSorting(int nDataCount)
			{
			m_Formation.m_vecTempDefects.clear();

			for (int i = 0; i < m_Formation.m_vecDefects.size(); i++)
			{
			_akDefect* pDefect = &m_Formation.m_vecDefects[i];

			double dDefectPosX = pDefect->m_nUMCenterAlignX / 1000.0;
			double dDefectPosY = pDefect->m_nUMCenterAlignY / 1000.0;

			m_Formation.AddDefectTemp(dDefectPosX, dDefectPosY);
			_akDefect* pDefectInfo = &m_Formation.m_vecTempDefects[i];

			pDefectInfo->m_nDefectID = pDefect->m_nDefectID;
			pDefectInfo->m_sDefectLoc = pDefect->m_sDefectLoc;
			strcpy(pDefectInfo->m_strDefectType, pDefect->m_strDefectType);
			strcpy(pDefectInfo->m_strDefectCode, pDefect->m_strDefectCode);
			pDefectInfo->m_DefectType = pDefect->m_DefectType;
			pDefectInfo->m_DefectSubType = pDefect->m_DefectSubType;
			pDefectInfo->m_nDefectRScale = pDefect->m_nDefectRScale;
			pDefectInfo->m_nUMSizeX = pDefect->m_nUMSizeX;
			pDefectInfo->m_nUMSizeY = pDefect->m_nUMSizeY;
			pDefectInfo->m_nUMSize = pDefect->m_nUMSize;
			memcpy(pDefectInfo->m_sZonePixelCount, pDefect->m_sZonePixelCount, sizeof(pDefect->m_sZonePixelCount));
			pDefectInfo->m_nLevelSrcMax = pDefect->m_nLevelSrcMax;
			pDefectInfo->m_nLevelSrcMin = pDefect->m_nLevelSrcMin;
			pDefectInfo->m_nLevelSrcAvg = pDefect->m_nLevelSrcAvg;
			pDefectInfo->m_sDefectPeak = pDefect->m_sDefectPeak;
			strcpy(pDefectInfo->m_strStackFirst, pDefect->m_strStackFirst);
			pDefectInfo->m_nCameraID = pDefect->m_nCameraID;
			pDefectInfo->m_nScanIdx = pDefect->m_nScanIdx;
			pDefectInfo->m_nLevelRefMax = pDefect->m_nLevelRefMax;
			pDefectInfo->m_nLevelRefMin = pDefect->m_nLevelRefMin;
			pDefectInfo->m_nLevelRefAvg = pDefect->m_nLevelRefAvg;
			pDefectInfo->m_nUMCenterAlignX = pDefect->m_nUMCenterAlignX;
			pDefectInfo->m_nUMCenterAlignY = pDefect->m_nUMCenterAlignY;
			pDefectInfo->m_nUMCellX = pDefect->m_nUMCellX;
			pDefectInfo->m_nUMCellY = pDefect->m_nUMCellY;
			pDefectInfo->m_nScratchRatio = pDefect->m_nScratchRatio;
			pDefectInfo->m_nDensity = pDefect->m_nDensity;
			pDefectInfo->m_bMergeState = pDefect->m_bMergeState;
			}
			}

			void CReveiwHistoryDlg::AddVecImageSorting(int nDataCount)
			{
			m_Formation.m_vecTempImage.clear();

			for (int i = 0; i < m_Formation.m_vecImage.size(); i++)
			{
			_akReviewList* pDefect = &m_Formation.m_vecImage[i];

			m_Formation.AddDefectImageTemp();

			_akReviewList* pImageInfo = &m_Formation.m_vecTempImage[i];

			pImageInfo->m_nDefectID = pDefect->m_nDefectID;
			strcpy(pImageInfo->m_strAoiImageName, pDefect->m_strAoiImageName);
			pImageInfo->m_nDefectIdx = pDefect->m_nDefectIdx;
			pImageInfo->m_strReviewImageName = pDefect->m_strReviewImageName;

			strcpy(pImageInfo->m_strAoiImagePath, pDefect->m_strAoiImagePath);
			strcpy(pImageInfo->m_strReviewImagePath, pDefect->m_strReviewImagePath);

			strcpy(pImageInfo->m_strAlignFirst, pDefect->m_strAlignFirst);
			strcpy(pImageInfo->m_strAlignSecond, pDefect->m_strAlignSecond);
			}
			}

			void CReveiwHistoryDlg::AddVecCellSorting(int nCellCount)
			{
			m_FormationMap.m_vecTempCellRect.clear();

			for (int i = 0; i < m_FormationMap.m_vecCellRect.size(); i++)
			{
			m_FormationMap.AddCellData();
			m_FormationMap.m_vecTempCellRect[i] = m_FormationMap.m_vecCellRect[i];
			}
			}

			void CReveiwHistoryDlg::SelectCell(int nDataCount)
			{
			m_FormationMap.m_vecCellRect.clear();

			if (nDataCount < 1) return;

			int nCellCount = 0;
			int nCount = 0;
			int nCount2 = 0;
			int nCount3 = 0;

			if (nCount == nDataCount) return;

			if (m_Formation.m_vecGlassInfo.size() == 0) return;

			_akGlassInfo* pGlass2 = &m_Formation.m_vecGlassInfo[nDataCount-1];

			nCount2 = pGlass2->m_nCellNum;

			for (int i = 0; i < nDataCount; i++)
			{
			if (i == 0)
			{
			nCount3 = 0;
			}
			else
			{
			_akGlassInfo* pGlass = &m_Formation.m_vecGlassInfo[i-1];
			nCount3 += pGlass->m_nCellNum;
			}
			}

			CakRectd rectCell;

			if (m_FormationMap.m_vecTempCellRect.size() - 1 < nCount3) return;

			for (int i = 0; i < nCount2; i++)
			{
			CakRectd* pCellData = &m_FormationMap.m_vecTempCellRect[nCount3 + i];
			rectCell.left = pCellData->left;
			rectCell.top = pCellData->top;
			rectCell.right = pCellData->right;
			rectCell.bottom = pCellData->bottom;
			m_FormationMap.m_vecCellRect.push_back(rectCell);
			}

			// for (int i = 0; i < MAX_COUNT+1; i++)
			// {
			// if (nCount == nDataCount) break;
			//
			// if (m_nCellSize[i] != 0)
			// {
			// nCount++;
			// }
			// nCellCount = m_nCellSize[i];
			// nCount2 = i;
			//
			// if (i == 0)
			// {
			// nCount3 = 0;
			// }
			// else
			// {
			// nCount3 += m_nCellSize[i-1];
			// }
			// }
			m_FormationMap.ReDraw(TRUE);
			}

			void CReveiwHistoryDlg::SortFileList(int nCol)
			{
			if (nCol == 0)
			return;

			_akReviewHeader *pReviewHeader;
			std::vector< std::pair<CString, _akReviewHeader*> > vecString;
			std::vector< std::pair<double, _akReviewHeader*> > vecValue;
			CString strValue;
			double dValue;
			short sValue[16];

			for (int i = 0; i < m_Formation.m_vecHeaderTemp.size(); i++)
			{
			pReviewHeader = &m_Formation.m_vecHeaderTemp[i];

			switch (nCol)
			{
			case 1: strValue = pReviewHeader->m_strFileTime; break;
			case 2: strValue = pReviewHeader->m_strLoading; break;
			case 3: strValue = pReviewHeader->m_strPPID; break;
			case 4: strValue = pReviewHeader->m_strGlassID; break;
			case 5: dValue = pReviewHeader->m_nDefectIdx; break;
			case 6: dValue = pReviewHeader->m_nReviewIdx; break;
			case 7: strValue = pReviewHeader->m_strJudge; break;
			case 8: strValue = pReviewHeader->m_strFileName; break;
			}

			if (strValue.IsEmpty() == FALSE) vecString.push_back(std::make_pair(strValue, pReviewHeader));
			else vecValue.push_back(std::make_pair(dValue, pReviewHeader));
			}

			if (!vecString.empty())
			{
			std::sort(vecString.begin(), vecString.end(), std::greater< std::pair<CString, _akReviewHeader*> >());

			m_Formation.m_vecHeader.clear();
			std::vector< std::pair<CString, _akReviewHeader*> >::iterator itVec;
			// /if(nCount > m_nFileCount) break; //count ì¬ê¸°ì ë§ê³ ì ì²´ íì¼ì ë¤ ì½ì íì ë¤ì ìííì/
			int nCount = 1;
			for (itVec = vecString.begin(); itVec != vecString.end(); ++itVec)
			{
			if(nCount > m_nFileCount) break;
			m_Formation.m_vecHeader.push_back(*itVec->second);
			nCount++;
			}
			}
			else
			{
			std::sort(vecValue.begin(), vecValue.end(), std::greater< std::pair<double, _akReviewHeader*> >());

			m_Formation.m_vecHeader.clear();
			std::vector< std::pair<double, _akReviewHeader*> >::iterator itVec;
			int nCount = 1;
			for (itVec = vecValue.begin(); itVec != vecValue.end(); ++itVec)
			{
			if (nCount > m_nFileCount) break;
			m_Formation.m_vecHeader.push_back(*itVec->second);
			nCount++;
			}
			}

			_akReviewHeader *pReview;
			m_vecStrGridReviewPath.clear();
			m_vecStrGridReviewList.clear();

			GV_ITEM Item;
			int nRowIdx = 0;
			int nColIdx = 0;
			CString strTemp;
			Item.mask = GVIF_TEXT;

			for(int i=0; i< m_Formation.m_vecHeader.size(); i++)
			{
			pReview = &m_Formation.m_vecHeader[i];
			m_vecStrGridReviewPath.push_back(pReview->m_strFilePath);
			m_vecStrGridReviewList.push_back(pReview->m_strFileName);
			}
			m_Formation.m_vecHeaderTemp.clear();
			}


			void CReveiwHistoryDlg::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
			{
			// TODO: ì¬ê¸°ì ë©ìì§ ì²ë¦¬ê¸° ì½ëë¥¼ ì¶ê° ë°/ëë ê¸°ë³¸ê°ì í¸ì¶í©ëë¤.

			CDialogEx::OnKeyDown(nChar, nRepCnt, nFlags);
			}