// DlgReviewHistoryTool.cpp: 구현 파일
//

#include "stdafx.h"
#include "ReviewSystem.h"
#include "DlgReviewHistoryTool.h"
#include "SequenceProcessor_CPJT.h"
#include "DlgDeffectHistroy.h"
#include "DlgDefectHistoryMap.h"
#include "DlgAlignHistory.h"
#include "afxdialogex.h"


// CDlgReviewHistoryTool 대화 상자

IMPLEMENT_DYNAMIC(CDlgReviewHistoryTool, CDialogEx)

CDlgReviewHistoryTool::CDlgReviewHistoryTool(CWnd* pParent /*=nullptr*/)
	: CDialogEx(IDD_DLG_REVIEW_HISTORY_TOOL, pParent)
{
	m_pDlgDefectHistory = NULL;
	m_pHistoryTemp = NULL;
	m_pDlgAlignHistory = NULL;
	m_bHistory = false;
}

CDlgReviewHistoryTool::~CDlgReviewHistoryTool()
{
	m_vecWndPtr.clear();
	m_vecString.clear();
}

void CDlgReviewHistoryTool::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_LIST1, m_ctrlHistoryList);
	DDX_Control(pDX, IDC_TAB_HISTORY_CONTROL, m_ctrlHistoryTab);
	DDX_Control(pDX, IDC_STATIC_MAP, m_ctrlDefectMap);
	DDX_Control(pDX, IDC_PICTURECTRL, m_PictureControl_AOI);
	DDX_Control(pDX, IDC_PICTURECTRL2, m_PictureControl_Review);
	DDX_Control(pDX, IDC_PICTURECTRL3, m_PictureControl_Align);
	DDX_Control(pDX, IDC_PICTURECTRL4, m_PictureControl_Align2);
	DDX_Control(pDX, IDC_ALIGN_GRID_ORIGIN_INFO, m_ctrlOriginInfo);
	DDX_Control(pDX, IDC_ALIGN_GRID_ALIGN_INFO, m_ctrlAlignInfo);
}

BEGIN_MESSAGE_MAP(CDlgReviewHistoryTool, CDialogEx)
	ON_BN_CLICKED(IDOK, &CDlgReviewHistoryTool::OnBnClickedOk)
	ON_LBN_DBLCLK(IDC_LIST1, &CDlgReviewHistoryTool::OnDblclkList1)
	ON_LBN_SELCHANGE(IDC_LIST1, &CDlgReviewHistoryTool::OnSelchangeList1)
	ON_NOTIFY(TCN_SELCHANGE, IDC_TAB_HISTORY_CONTROL, &CDlgReviewHistoryTool::OnSelchangeTabHistoryControl)
	ON_WM_TIMER()
	ON_WM_PAINT()
	ON_BN_CLICKED(IDC_USE_DEFECT, &CDlgReviewHistoryTool::OnBnClickedUseDefect)
	ON_BN_CLICKED(IDC_IMAGE_ROTATION, &CDlgReviewHistoryTool::OnBnClickedImageRotation)
	ON_BN_CLICKED(IDC_IMAGE_FLIP, &CDlgReviewHistoryTool::OnBnClickedImageFlip)
END_MESSAGE_MAP()


// CDlgReviewHistoryTool 메시지 처리기

void CDlgReviewHistoryTool::OnBnClickedOk()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	CDialogEx::OnOK();
}


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

	CreateTabDlg();
	InitTabControl();

	InitGridOriginInfo();
	InitGridAlignInfo();

	GetDlgItem(IDC_PICTURECTRL)->GetWindowRect(m_picture_rect);
	GetDlgItem(IDC_PICTURECTRL2)->GetWindowRect(m_picture_rect2);
	GetDlgItem(IDC_PICTURECTRL3)->GetWindowRect(m_picture_rect3);
	GetDlgItem(IDC_PICTURECTRL4)->GetWindowRect(m_picture_rect4);

	ScreenToClient(m_picture_rect);
	ScreenToClient(m_picture_rect2);
	ScreenToClient(m_picture_rect3);
	ScreenToClient(m_picture_rect4);

	SetIcon(m_hIcon, TRUE);
	SetIcon(m_hIcon, FALSE);
	DrawnoImage(); //taek 0318
	SetTimer(1020, 1000, NULL); //taek 0318

	SetActiveDialog(0);
	// TODO:  여기에 추가 초기화 작업을 추가합니다.
	return TRUE;  // return TRUE unless you set the focus to a control
				  // 예외: OCX 속성 페이지는 FALSE를 반환해야 합니다.
}

void CDlgReviewHistoryTool::SetDefectImage(CString strReview, CGlassResult* pHistoryResult)
{
/*	KillTimer(1020);*/
	//Defect index 넘버에 따라서 다른 이미지를 불러 온다.
	Invalidate(TRUE);
	CPaintDC dc(this);
	CString DeftectPath, DeftectPath2, DeftectPath3, DeftectPath4;
	CFileStatus FileOn;
	TCHAR chFilePath[256] = { 0, };
	GetModuleFileName(NULL, chFilePath, 256);
	CString strFolderPath(chFilePath);
	strFolderPath = strFolderPath.Left(strFolderPath.ReverseFind('\\'));
	bool bSkip = false;

	m_DefectImage.Destroy();
	m_ReviewImage.Destroy(); 
	m_AlignImage.Destroy();
	m_AlignImage2.Destroy();

	if (m_pHistoryTemp == NULL) return;

	DeftectPath3.Format(_T("%s"), m_strFirstImage); //taek 210316 둘중에 하나
	DeftectPath4.Format(_T("%s"), m_strSecondImage); //taek 210316 둘중에 하나

	if (CFile::GetStatus(DeftectPath3, FileOn) && m_strFirstImage != "") //파일이 있을 때
	{

		m_AlignImage.Load(DeftectPath3);
		HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), strFolderPath,
			IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);


		InvalidateRect(m_picture_rect3, FALSE);
		dc.SetStretchBltMode(COLORONCOLOR);
		m_AlignImage.Draw(dc, m_picture_rect3);

	}
	else //파일이 없을 때.. 노 이미지 파일로 보여준다
	{
		bSkip = true;
	}

	if (CFile::GetStatus(DeftectPath4, FileOn) && m_strSecondImage != "") //파일이 있을 때
	{
		m_AlignImage2.Load(DeftectPath4);
		HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), strFolderPath,
			IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);


		InvalidateRect(m_picture_rect4, FALSE);
		dc.SetStretchBltMode(COLORONCOLOR);
		m_AlignImage2.Draw(dc, m_picture_rect4);

		if (bSkip)
		{
			strFolderPath = strFolderPath + "\\no-image.png";
			m_AlignImage.Load(strFolderPath);
			HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), strFolderPath,
				IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);

			InvalidateRect(m_picture_rect3, FALSE);
			dc.SetStretchBltMode(COLORONCOLOR);
			m_AlignImage.Draw(dc, m_picture_rect3);
		}
	}
	else //파일이 없을 때.. 노 이미지 파일로 보여준다
	{
		if (bSkip)
		{
			AlignnoImage();
		}
		else
		{
			strFolderPath = strFolderPath + "\\no-image.png";
			m_AlignImage2.Load(strFolderPath);
			HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), strFolderPath,
				IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);

			InvalidateRect(m_picture_rect4, FALSE);
			dc.SetStretchBltMode(COLORONCOLOR);
			m_AlignImage2.Draw(dc, m_picture_rect4);
		}
	}

	if (pDefectInfo == NULL)
	{
		return;
	}

	if (!pDefectInfo->strInspectImgFileName)
	{
		return;
	}
	if (!pDefectInfo->strGlassID)
	{
		return;
	}
	if (pHistoryResult == NULL)
	{
		return;
	}
	DeftectPath.Format(_T("\\\\126.100.100.1\\D\\Image\\Defect\\%s\\%s"), pDefectInfo->strGlassID, pDefectInfo->strInspectImgFileName);
	DeftectPath2.Format(_T("%s\\%s"), pHistoryResult->m_strUploadImgFileName, strReview);

	if (CFile::GetStatus(DeftectPath, FileOn) && pDefectInfo->strInspectImgFileName != "") //파일이 있을 때
	{

		m_DefectImage.Load(DeftectPath);
		HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), strFolderPath,
			IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);


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

	}
	else //파일이 없을 때.. 노 이미지 파일로 보여준다
	{
		bSkip = true;
	}

	if (CFile::GetStatus(DeftectPath2, FileOn) && strReview != "") //파일이 있을 때
	{
		m_ReviewImage.Load(DeftectPath2);
		HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), strFolderPath,
			IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);


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

		if (bSkip)
		{
			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);
			m_DefectImage.Draw(dc, m_picture_rect);
		}

	}
	else //파일이 없을 때.. 노 이미지 파일로 보여준다
	{
		if (bSkip)
		{
			DefectnoImage();
		}
		else
		{
			strFolderPath = strFolderPath + "\\no-image.png";
			m_ReviewImage.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_ReviewImage.Draw(dc, m_picture_rect2);
		}
	}

	bSkip = false;

	
	//Invalidate(TRUE);
}

void CDlgReviewHistoryTool::UpdateSelectDefectMap(CDefectResult * pDefectResult)
{
	SetDefectIndexInfo(pDefectResult->nDefectIdx);
	pDefectInfo = pDefectResult;
// 	CGlassResult* pHistoryResult = NULL;
// 	pHistoryResult = m_pDDL2P->ISP2P_GetHistoryResult(GetSelectIndex());


	if (m_pHistoryTemp == NULL)
	{
		return;
	}

	SetDefectImage(GetReviewName(), m_pHistoryTemp); //taek 0318
	//Invalidate(FALSE);
}

void CDlgReviewHistoryTool::SetDefectIndexInfo(int nIndex)
{
	m_nDefectIndex = nIndex;
}

void CDlgReviewHistoryTool::DefectnoImage()
{
	//Invalidate(TRUE);
	CPaintDC dc(this);

	m_DefectImage.Destroy();
	m_ReviewImage.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);
	m_ReviewImage.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);

	dc.SetStretchBltMode(COLORONCOLOR);
	m_DefectImage.Draw(dc, m_picture_rect);
	m_ReviewImage.Draw(dc, m_picture_rect2);
}

void CDlgReviewHistoryTool::DrawnoImage()
{
	Invalidate(TRUE);
	CPaintDC dc(this);

	m_DefectImage.Destroy();
	m_ReviewImage.Destroy();
	m_AlignImage.Destroy();
	m_AlignImage2.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);
	m_ReviewImage.Load(strFolderPath);
	m_AlignImage.Load(strFolderPath);
	m_AlignImage2.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_picture_rect3, FALSE);
	InvalidateRect(m_picture_rect4, FALSE);

	dc.SetStretchBltMode(COLORONCOLOR);
	m_DefectImage.Draw(dc, m_picture_rect);
	m_ReviewImage.Draw(dc, m_picture_rect2);
	m_DefectImage.Draw(dc, m_picture_rect3);
	m_ReviewImage.Draw(dc, m_picture_rect4);
}

void CDlgReviewHistoryTool::AlignnoImage()
{
	CPaintDC dc(this);

	m_AlignImage.Destroy();
	m_AlignImage2.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_AlignImage.Load(strFolderPath);
	m_AlignImage2.Load(strFolderPath);

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

	InvalidateRect(m_picture_rect3, FALSE);
	InvalidateRect(m_picture_rect4, FALSE);

	dc.SetStretchBltMode(COLORONCOLOR);
	m_AlignImage.Draw(dc, m_picture_rect3);
	m_AlignImage2.Draw(dc, m_picture_rect4);
}

void CDlgReviewHistoryTool::GetHistoryList()
{
	m_ctrlHistoryList.ResetContent();

	CGlassResult* pHistoryResult = m_pDDL2P->ISP2P_GetHistoryResult(0);

	if (pHistoryResult != NULL)
	{
		CString strGlassID = _T("");

		for (int i = 0; i < MAX_GLASS_RESULT_SIZE; i++)
		{
			pHistoryResult = m_pDDL2P->ISP2P_GetHistoryResult(i);

			if (pHistoryResult == NULL)
			{
				break;
			}

			strGlassID.Format(_T("%s_%s(%s)"), *pHistoryResult->GetGlassID(),*pHistoryResult->GetStepID(),*pHistoryResult->GetUnLoadingTime());
			m_ctrlHistoryList.AddString(strGlassID);
		}
	}

	UpdateData(TRUE);
}

void CDlgReviewHistoryTool::SetHistoryTemp(int nIndex)
{
	m_pHistoryTemp = m_pDDL2P->ISP2P_GetHistoryResult(GetSelectIndex());
}

void CDlgReviewHistoryTool::SelectDefect(int nDefectPosX, int nDefectPosY, int nDefectMarginX, int nDefectMarginY)
{
// 	CGlassResult* pHistoryResult = NULL;
	//pHistoryResult = m_pDDL2P->ISP2P_GetHistoryResult(GetSelectIndex());
	const SDefectFilter *pDefectFilter = m_pDDL2P->ISP2P_GetDefectFilter(); //taek 210213


	m_pDDL2P->DDM2P_SelectDefect2(nDefectPosX, nDefectPosY, nDefectMarginX, nDefectMarginY, m_pHistoryTemp);
}

BOOL CDlgReviewHistoryTool::Mathching(CDefectResult* pDefectResult)
{
	if (m_pHistoryTemp == NULL) return FALSE;
	
	m_pMapDefectResult = m_pHistoryTemp->GetMapDefectResult();

	int nDefectIdx = 0;

	for (int i = 0; i < 2; i++)
	{
		CReviewResult* pReviewResult = m_pHistoryTemp->GetReviewResult(i);

		if (pReviewResult == NULL)
		{
			continue;
		}

		for (int j = 0; j < pReviewResult->GetSReviewResultCount(); j++)
		{
			nDefectIdx = pReviewResult->GetSReviewResult(j)->nDefectIdx;

			if (pReviewResult->GetSReviewResult(j)->nDefectIdx == pDefectResult->nDefectIdx)
			{
				CString strReview;

				strReview = pReviewResult->GetSReviewResult(j)->strUploadImgFileName;

				if (strReview == "***")
				{
					return FALSE;
				}
				else if (strReview == "")
				{
					return FALSE;
				}
				else
				{
					return TRUE;
				}
			}
		}
	}

	return FALSE;
}

void CDlgReviewHistoryTool::UpdateProcess(const CGlassResult* pGlassResult)
{
	if (pGlassResult == NULL) return;

	CString strValue = _T("");

	// glass pos
	int nRowIdx = 1;
	int nColIdx = 1;

	m_strFirstImage.Empty();
	m_strSecondImage.Empty();

	nRowIdx = 1;
	nColIdx = 1;
	strValue.Format(_T("%d"), pGlassResult->GetAlignResult()->nResultCode);
	m_ctrlOriginInfo.SetItemText(nRowIdx, nColIdx++, strValue);

	strValue.Format(_T("%.3lf"), pGlassResult->GetAlignResult()->dFindScore[0]);
	m_ctrlOriginInfo.SetItemText(nRowIdx, nColIdx++, strValue);

	strValue.Format(_T("%.3lf"), pGlassResult->GetAlignResult()->dFindScore[1]);
	m_ctrlOriginInfo.SetItemText(nRowIdx, nColIdx++, strValue);

/*	pGlassResult->m_AlignResult*/

	// find camera pos
	nRowIdx = 1;
	nColIdx = 1;
	strValue.Format(_T("%.3lf"), pGlassResult->GetAlignResult()->dFindPixelX[0]);
	m_ctrlAlignInfo.SetItemText(nRowIdx, nColIdx++, strValue);

	strValue.Format(_T("%.3lf"), pGlassResult->GetAlignResult()->dFindPixelY[0]);
	m_ctrlAlignInfo.SetItemText(nRowIdx, nColIdx++, strValue);

	strValue.Format(_T("%.3lf"), pGlassResult->GetAlignResult()->dFindPixelX[1]);
	m_ctrlAlignInfo.SetItemText(nRowIdx, nColIdx++, strValue);

	strValue.Format(_T("%.3lf"), pGlassResult->GetAlignResult()->dFindPixelY[1]);
	m_ctrlAlignInfo.SetItemText(nRowIdx, nColIdx++, strValue);

	// find motor pos
	nRowIdx = 2;
	nColIdx = 1;
	strValue.Format(_T("%.3lf"), pGlassResult->GetAlignResult()->dFindPositionX[0]);
	m_ctrlAlignInfo.SetItemText(nRowIdx, nColIdx++, strValue);

	strValue.Format(_T("%.3lf"), pGlassResult->GetAlignResult()->dFindPositionY[0]);
	m_ctrlAlignInfo.SetItemText(nRowIdx, nColIdx++, strValue);

	strValue.Format(_T("%.3lf"), pGlassResult->GetAlignResult()->dFindPositionX[1]);
	m_ctrlAlignInfo.SetItemText(nRowIdx, nColIdx++, strValue);

	strValue.Format(_T("%.3lf"), pGlassResult->GetAlignResult()->dFindPositionY[1]);
	m_ctrlAlignInfo.SetItemText(nRowIdx, nColIdx++, strValue);

	m_ctrlAlignInfo.Invalidate(FALSE);

	m_strFirstImage = pGlassResult->GetAlignResult()->strAlignFirest; //image file name
	m_strSecondImage = pGlassResult->GetAlignResult()->strAlignSecond;
}

BOOL CDlgReviewHistoryTool::UpdateSelectDefectInfoMap2(int nIndex)
{
	CDefectResult* pDefectResult = NULL;
// 	CGlassResult* pHistoryResult = NULL;                          
	//pHistoryResult = m_pDDL2P->ISP2P_GetHistoryResult(GetSelectIndex());
	m_pDlgDefectHistory->UpdateSelectDefectList(nIndex);
	m_pMapDefectResult = NULL;
	if (m_pHistoryTemp==NULL)
	{
		return FALSE;
	}
	m_pMapDefectResult = m_pHistoryTemp->GetMapDefectResult();
	int nDefectIdx = 0;
	int nIdx = 0;

	SetSelectDefectIndex(nIndex);

	bool bFind = false;
	if (m_pMapDefectResult == NULL)
	{
		return FALSE;
	}
	
	for (constMapDefectResultIt it = m_pMapDefectResult->begin(); it != m_pMapDefectResult->end(); it++)
	{
		pDefectResult = static_cast<CDefectResult*>(it->second);
				
		if (pDefectResult->nDefectIdx == nIndex)
		{
			nDefectIdx =pDefectResult->nDefectidx1;
			pDefectResult->strUploadImgFileName;

			for (int i = 0; i < 2; i++)
			{
				CReviewResult* pReviewResult = m_pHistoryTemp->GetReviewResult(i);
				if (pReviewResult == NULL)
				{
					continue;
				}
				else if (bFind)
				{
					break;
				}
				for (int j = 0; j < pReviewResult->GetSReviewResultCount(); j++)
				{
					if (pReviewResult->GetSReviewResult(j)->nDefectIdx == GetSelectDefectIndex())
					{
						CString strReview;

						strReview = pReviewResult->GetSReviewResult(j)->strUploadImgFileName;
						if (strReview == "***")
						{
							strReview = "";
						}
						SetReviewName(strReview);
						bFind = true;
						break;
					}
					else
					{
						SetReviewName("");
					}
				}
			}

			UpdateSelectDefectMap(pDefectResult);
			m_pDlgDefectHistoryMap->UpdateSelectDefectMap(pDefectResult);
			return TRUE;
		}
	}

	return FALSE;
}

BOOL CDlgReviewHistoryTool::UpdateSelectDefectInfoMap3(int nIndex)
{
	CDefectResult* pDefectResult = NULL;
	
	m_pMapDefectResult = m_pHistoryTemp->GetMapDefectResult();

	int nDefectIdx = 0;
	int nIdx = 0;

	SetSelectDefectIndex(nIndex);

	bool bFind = false;

	for (constMapDefectResultIt it = m_pMapDefectResult->begin(); it != m_pMapDefectResult->end(); it++)
	{
		pDefectResult = static_cast<CDefectResult*>(it->second);

		if (pDefectResult->nDefectIdx == nIndex)
		{
			nDefectIdx = pDefectResult->nDefectidx1;
			pDefectResult->strUploadImgFileName;

			for (int i = 0; i < 2; i++)
			{
				CReviewResult* pReviewResult = m_pHistoryTemp->GetReviewResult(i);
				if (pReviewResult == NULL)
				{
					continue;
				}
				else if (bFind)
				{
					break;
				}
				for (int j = 0; j < pReviewResult->GetSReviewResultCount(); j++)
				{
					if (pReviewResult->GetSReviewResult(j)->nDefectIdx == GetSelectDefectIndex())
					{
						CString strReview = NULL;

						strReview = pReviewResult->GetSReviewResult(j)->strUploadImgFileName;
						if (strReview == "***")
						{
							strReview = "";
						}
						SetReviewName(strReview);
						bFind = true;
						return TRUE;
					}
					else
					{
						SetReviewName("");
					}
				}
			}
			return FALSE;
		}
	}

	return FALSE;
}

void CDlgReviewHistoryTool::OnDblclkList1()
{
	/*< LYW 20211005 - #3662 ADD Start >*/
	try
	{
		// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
		CString strSelect, strGlassID, strStepID, strStepTime;
		int nTemp, nTemp2;
		int nidx = 0;

		nidx = m_ctrlHistoryList.GetCurSel();

		SetSelectIndex(nidx);
		bool bSelect = false;

		CGlassResult* pHistoryResult = m_pDDL2P->ISP2P_GetHistoryResult(0);

		pHistoryResult = m_pDDL2P->ISP2P_GetHistoryResult(GetSelectIndex());
		SetHistoryTemp(GetSelectIndex());
		const SDefectFilter *pDefectFilter = m_pDDL2P->ISP2P_GetDefectFilter(); //taek 210213

		if (pHistoryResult == NULL) return;
		if (pDefectFilter == NULL) return;

		//디펙 맵 표현 및 그리드 표현
		m_pDlgDefectHistory->UpdateProcessStatus(pHistoryResult); //그리드 표현
		m_pDlgDefectHistoryMap->UpdateDefectFilter(pDefectFilter);
		m_pDlgDefectHistoryMap->UpdateProcessStatus(pHistoryResult); //디펙 맵 표현
		UpdateProcess(pHistoryResult);
		SetDefectImage(GetReviewName(), m_pHistoryTemp);
		GetHistoryList(); //한번 갱신 해주고 처리하자
		m_bHistory = true;
	}
	catch (...)
	{
		return;
	}
	/*< LYW 20211005 - #3662 ADD End >*/


}


void CDlgReviewHistoryTool::OnSelchangeList1()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	m_nListCount = m_ctrlHistoryList.GetCurSel();
	OnDblclkList1();
}

void CDlgReviewHistoryTool::UpdateDefectFilter(const SDefectFilter * pDefectFilter)
{
	m_pDefectFilter = pDefectFilter;
}

void CDlgReviewHistoryTool::CreateTabDlg()
{
	CDlgReviewHistoryTool *pDlgReviewHistoryTool = (CDlgReviewHistoryTool *)AfxGetMainWnd();

	CRect rect;
	m_ctrlHistoryTab.GetWindowRect(&rect);

	m_pDlgDefectHistory = new CDlgDeffectHistroy;
	m_pDlgDefectHistory->Create(IDD_DLG_DEFECT_HISTORY_TAB, &m_ctrlHistoryTab);
	m_pDlgDefectHistory->ShowWindow(SW_SHOW);
	m_pDlgDefectHistory->SetDDL2P(static_cast<IDialogDefectHistoryList2Parent*>(this));

// 	m_pDlgAlignHistory = new CDlgAlignHistory;
// 	m_pDlgAlignHistory->Create(IDD_DLG_ALIGN_TAB, &m_ctrlHistoryTab);
// 	m_pDlgAlignHistory->ShowWindow(SW_SHOW);
// 	m_pDlgAlignHistory->SetDDL2P(static_cast<IDialogAlignHistoryList2Parent*>(this));

	m_pDlgDefectHistoryMap = new CDlgDefectHistoryMap;
	m_pDlgDefectHistoryMap->Create(IDD_DLG_DEFECT_MAP_TAB, &m_ctrlDefectMap);
	m_pDlgDefectHistoryMap->ShowWindow(SW_SHOW);
	m_pDlgDefectHistoryMap->SetDDM2P(static_cast<IDialogDefectHistoryMap2Parent*>(this));

	m_ctrlDefectMap.GetWindowRect(&rect);

}

void CDlgReviewHistoryTool::InitTabControl()
{
	m_ctrlHistoryTab.InsertItem(0, _T("Defect List"));
	//m_ctrlHistoryTab.InsertItem(1, _T("Align History"));
	m_ctrlHistoryTab.SetCurSel(0);
}

void CDlgReviewHistoryTool::UpdateSelectDefectMap2(CDefectResult * pDefectResult)
{
	m_pDlgDefectHistoryMap->UpdateReviewResult2(m_pHistoryTemp);
	m_pDlgDefectHistoryMap->UpdateSelectDefectMap(pDefectResult);
}

void CDlgReviewHistoryTool::UpdateSelect(CDefectResult * pDefectResult)
{
	SetDefectIndexInfo(pDefectResult->nDefectIdx);
	pDefectInfo = pDefectResult;

// 	CGlassResult* pHistoryResult = NULL; 
	//pHistoryResult = m_pDDL2P->ISP2P_GetHistoryResult(GetSelectIndex());

	if (m_pHistoryTemp == NULL)
	{
		return;
	}

	SetDefectImage(GetReviewName(), m_pHistoryTemp);
	//Invalidate(FALSE);
}

void CDlgReviewHistoryTool::OnSelchangeTabHistoryControl(NMHDR *pNMHDR, LRESULT *pResult)
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.

	int nTabIdx = m_ctrlHistoryTab.GetCurSel();

	SetActiveDialog(nTabIdx);
}

void CDlgReviewHistoryTool::SetActiveDialog(int nTabIdx)
{
	if(nTabIdx == 0)
	{
		m_pDlgDefectHistory->ShowWindow(SW_SHOW);
		//m_pDlgAlignHistory->ShowWindow(SW_HIDE);
	}
	else
	{
		m_pDlgDefectHistory->ShowWindow(SW_HIDE);
		//m_pDlgAlignHistory->ShowWindow(SW_SHOW);
	}
	
	m_ctrlHistoryTab.SetCurSel(nTabIdx);
}

void CDlgReviewHistoryTool::OnTimer(UINT_PTR nIDEvent)
{
	// TODO: 여기에 메시지 처리기 코드를 추가 및/또는 기본값을 호출합니다.
	/*Invalidate(TRUE);*/ //taek 0318
	if (nIDEvent) {
		if (m_bHistory)
		{
// 			KillTimer(nIDEvent);
// 			SetDefectImage(GetReviewName(), m_pHistoryTemp);
// 			SetTimer(nIDEvent, 500, NULL);
		}
		else
		{
			KillTimer(nIDEvent);
			DrawnoImage();
			SetTimer(nIDEvent, 500, NULL);

		}
	}
}


void CDlgReviewHistoryTool::OnPaint()
{
	CPaintDC dc(this); // device context for painting
					   // TODO: 여기에 메시지 처리기 코드를 추가합니다.
					   // 그리기 메시지에 대해서는 __super::OnPaint()을(를) 호출하지 마십시오.
}

void CDlgReviewHistoryTool::OnBnClickedUseDefect()
{
	/*< LYW 20211005 - #3662 ADD Start >*/
	try
	{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
		BOOL bCheck = ((CButton*)GetDlgItem(IDC_USE_DEFECT))->GetCheck();
		// 	CGlassResult* pHistoryResult = m_pDDL2P->ISP2P_GetHistoryResult(0);
		// 	pHistoryResult = m_pDDL2P->ISP2P_GetHistoryResult(GetSelectIndex());
		SetHistoryTemp(GetSelectIndex());
		SetAllDefect(bCheck);
		m_pDlgDefectHistoryMap->SetHistoryDefect(bCheck);
		m_pDlgDefectHistoryMap->UpdateProcessStatus(m_pHistoryTemp); //디펙 맵 표현
		m_pDlgDefectHistory->UpdateProcessStatus(m_pHistoryTemp);
	}
	catch (...)
	{
		return;
	}
	/*< LYW 20211005 - #3662 ADD End >*/
}


void CDlgReviewHistoryTool::OnBnClickedImageRotation()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.

}


void CDlgReviewHistoryTool::OnBnClickedImageFlip()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
}

void CDlgReviewHistoryTool::InitGridOriginInfo()
{
	int nRowIdx, nColIdx, nRows, nCols, nFixRows, nFixCols;
	CString strTemp;
	CRect rt;

	nRows = 2;
	nCols = 4;
	nFixRows = 1;
	nFixCols = 1;
	nRowIdx = 0;
	nColIdx = 0;

	m_ctrlOriginInfo.GetClientRect(&rt);
	m_ctrlOriginInfo.GetDefaultCell(TRUE, FALSE)->SetBackClr(RGB(180, 210, 247));
	m_ctrlOriginInfo.GetDefaultCell(FALSE, TRUE)->SetBackClr(RGB(180, 210, 247));
	m_ctrlOriginInfo.GetDefaultCell(FALSE, FALSE)->SetBackClr(RGB(255, 255, 255));

	m_ctrlOriginInfo.SetRowCount(nRows);
	m_ctrlOriginInfo.SetColumnCount(nCols);
	m_ctrlOriginInfo.SetFixedRowCount(nFixRows);
	m_ctrlOriginInfo.SetFixedColumnCount(nFixCols);

	m_ctrlOriginInfo.SetColumnWidth(0, 60);
	m_ctrlOriginInfo.SetColumnWidth(1, 95);
	m_ctrlOriginInfo.SetColumnWidth(2, 95);
	m_ctrlOriginInfo.SetColumnWidth(3, 95);

	GV_ITEM Item;

	nRowIdx = 0;
	nColIdx = 1;
	Item.mask = GVIF_TEXT;
	Item.row = nRowIdx++;
	Item.col = nColIdx;
	strTemp.Format(_T(""));
	Item.strText = strTemp;
	m_ctrlOriginInfo.SetItem(&Item);

	// row
	Item.mask = GVIF_TEXT;
	Item.row = nRowIdx++;
	Item.col = nColIdx;
	strTemp.Format(_T(""));
	Item.strText = strTemp;
	m_ctrlOriginInfo.SetItem(&Item);

	// col
	nRowIdx = 0;
	nColIdx = 1;
	Item.row = nRowIdx;
	Item.col = nColIdx++;
	strTemp.Format(_T("Result"));
	Item.strText = strTemp;
	m_ctrlOriginInfo.SetItem(&Item);

	Item.col = nColIdx++;
	strTemp.Format(_T("Find Socore 1"));
	Item.strText = strTemp;
	m_ctrlOriginInfo.SetItem(&Item);

	Item.col = nColIdx++;
	strTemp.Format(_T("Find Socore 2"));
	Item.strText = strTemp;
	m_ctrlOriginInfo.SetItem(&Item);

	m_ctrlOriginInfo.SetEditable(FALSE);
}

void CDlgReviewHistoryTool::InitGridAlignInfo()
{
	int nRowIdx, nColIdx, nRows, nCols, nFixRows, nFixCols;
	CString strTemp;
	CRect rt;

	nRows = 3;
	nCols = 5;
	nFixRows = 1;
	nFixCols = 1;
	nRowIdx = 0;
	nColIdx = 0;

	m_ctrlAlignInfo.GetClientRect(&rt);
	m_ctrlAlignInfo.GetDefaultCell(TRUE, FALSE)->SetBackClr(RGB(180, 210, 247));
	m_ctrlAlignInfo.GetDefaultCell(FALSE, TRUE)->SetBackClr(RGB(180, 210, 247));
	m_ctrlAlignInfo.GetDefaultCell(FALSE, FALSE)->SetBackClr(RGB(255, 255, 255));

	m_ctrlAlignInfo.SetRowCount(nRows);
	m_ctrlAlignInfo.SetColumnCount(nCols);
	m_ctrlAlignInfo.SetFixedRowCount(nFixRows);
	m_ctrlAlignInfo.SetFixedColumnCount(nFixCols);

	m_ctrlAlignInfo.SetColumnWidth(0, 95);
	m_ctrlAlignInfo.SetColumnWidth(1, 70);
	m_ctrlAlignInfo.SetColumnWidth(2, 70);
	m_ctrlAlignInfo.SetColumnWidth(3, 70);
	m_ctrlAlignInfo.SetColumnWidth(4, 70);


	GV_ITEM Item;

	nRowIdx = 0;
	nColIdx = 0;
	Item.mask = GVIF_TEXT;
	Item.row = nRowIdx++;
	Item.col = nColIdx;
	strTemp.Format(_T(""));
	Item.strText = strTemp;
	m_ctrlAlignInfo.SetItem(&Item);

	// row
	Item.mask = GVIF_TEXT;
	Item.row = nRowIdx++;
	Item.col = nColIdx;
	strTemp.Format(_T("Pixel"));
	Item.strText = strTemp;
	m_ctrlAlignInfo.SetItem(&Item);

	Item.mask = GVIF_TEXT;
	Item.row = nRowIdx++;
	Item.col = nColIdx;
	strTemp.Format(_T("Position"));
	Item.strText = strTemp;
	m_ctrlAlignInfo.SetItem(&Item);

	// col
	nRowIdx = 0;
	nColIdx = 1;
	Item.row = nRowIdx;
	Item.col = nColIdx++;
	strTemp.Format(_T("1st X_Pos"));
	Item.strText = strTemp;
	m_ctrlAlignInfo.SetItem(&Item);

	Item.col = nColIdx++;
	strTemp.Format(_T("1st Y_Pos"));
	Item.strText = strTemp;
	m_ctrlAlignInfo.SetItem(&Item);

	Item.row = nRowIdx;
	Item.col = nColIdx++;
	strTemp.Format(_T("2nd X_Pos"));
	Item.strText = strTemp;
	m_ctrlAlignInfo.SetItem(&Item);

	Item.col = nColIdx++;
	strTemp.Format(_T("2nd Y_Pos"));
	Item.strText = strTemp;
	m_ctrlAlignInfo.SetItem(&Item);

	m_ctrlAlignInfo.SetEditable(FALSE);
}