From 03152a241b9463c582b56896f5f5f73717497ab4 Mon Sep 17 00:00:00 2001
From: LYW <leeyeanwoo@diteam.co.kr>
Date: 수, 25 8월 2021 11:20:43 +0900
Subject: [PATCH] Ongoing100 #3486 CF AOI Review Review History 프로그램 테스트 및 적용

---
 ReviewHistory/ReveiwHistory/ReveiwHistoryDlg.cpp | 3830 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 3,830 insertions(+), 0 deletions(-)

diff --git a/ReviewHistory/ReveiwHistory/ReveiwHistoryDlg.cpp b/ReviewHistory/ReveiwHistory/ReveiwHistoryDlg.cpp
new file mode 100644
index 0000000..20870db
--- /dev/null
+++ b/ReviewHistory/ReveiwHistory/ReveiwHistoryDlg.cpp
@@ -0,0 +1,3830 @@
+癤�
+// 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)
+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.nWidthPixel*m_sROIInfo.nWidthPixel + m_sROIInfo.nHeightPixel*m_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.dWidthRealUM*m_sROIInfo.dWidthRealUM) + (m_sROIInfo.dHeightRealUM*m_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)
+		{
+			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)
+		{
+			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();
+}

--
Gitblit v1.9.3