// ReviewSystemView.cpp : CReviewSystemView 클래스의 구현
#include "stdafx.h"
#include "ReviewSystem.h"

#include "ReviewSystemDoc.h"
#include "ReviewSystemView.h"
#include "MainFrm.h"

#include "CHMotorControls/MotorControlInfo.h"
#include "CHReviewSetting/SystemInfo.h"
#include "ReviewData.h"


#ifdef _DEBUG
#define new DEBUG_NEW
#endif

#define ID_TIMER_IMAGE_DATA			1009

// CReviewSystemView

IMPLEMENT_DYNCREATE(CReviewSystemView, CFormView)

BEGIN_MESSAGE_MAP(CReviewSystemView, CFormView)
	ON_WM_DESTROY()
	ON_MESSAGE(UM_LONG_RUN_COUNT_UPDATE, &CReviewSystemView::OnLongRunCountUpdate)
	ON_WM_KEYDOWN()
	ON_WM_SYSCHAR()
	ON_WM_ERASEBKGND()
	ON_WM_CTLCOLOR()
END_MESSAGE_MAP()

// CReviewSystemView 생성/소멸
CReviewSystemView::CReviewSystemView()
	: CFormView(CReviewSystemView::IDD)
{
	// TODO: 여기에 생성 코드를 추가합니다.
	m_vecDlgReviewCamera.clear();

	m_pDlgUserCmd = NULL;
	m_pDlgCommand = NULL;

	m_pDlgGraph = NULL;
	
	m_pDlgReviewCamera = NULL;
	m_pDlgAlignCamera = NULL;
	m_pDlgDefectMap = NULL;
	m_pDlgDefectFilter = NULL;
	m_pDlgTab = NULL;
	m_pDlgTapCtrl = NULL;
	m_pDlgDefectList = NULL;
	m_pDlgLog = NULL;
	m_pDlgResultGraph_Dx = NULL;
	m_pDlgResultGraph_Dy = NULL;
	m_pDlgLongRun = NULL;
	m_pDlgAFMInfo = NULL;
	m_pDlgGlassAndNetworkInfo = NULL;
	m_pDlgModuleInfo = NULL;
	m_pDlgControl = NULL;
	m_pDlgLogo = NULL;
	m_pDlgDefectInfo = NULL; //taek 20.12.04
}

CReviewSystemView::~CReviewSystemView()
{	
	//if(UninstallHook())
	//	AfxMessageBox(_T("UnInstalled Hook"));
}

void CReviewSystemView::DoDataExchange(CDataExchange* pDX)
{
	CFormView::DoDataExchange(pDX);	
}

BOOL CReviewSystemView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: CREATESTRUCT cs를 수정하여 여기에서
	//  Window 클래스 또는 스타일을 수정합니다.

	return CFormView::PreCreateWindow(cs);
}

void CReviewSystemView::OnInitialUpdate()
{
	CFormView::OnInitialUpdate();
	GetParentFrame()->RecalcLayout();
	ResizeParentToFit();

}

void CReviewSystemView::OnRButtonUp(UINT nFlags, CPoint point)
{
	ClientToScreen(&point);
	OnContextMenu(this, point);
}

void CReviewSystemView::OnContextMenu(CWnd* pWnd, CPoint point)
{
	theApp.GetContextMenuManager()->ShowPopupMenu(IDR_POPUP_EDIT, point.x, point.y, this, TRUE);
}


// CReviewSystemView 진단

#ifdef _DEBUG
void CReviewSystemView::AssertValid() const
{
	CFormView::AssertValid();
}

void CReviewSystemView::Dump(CDumpContext& dc) const
{
	CFormView::Dump(dc);
}

CReviewSystemDoc* CReviewSystemView::GetDocument() const // 디버그되지 않은 버전은 인라인으로 지정됩니다.
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CReviewSystemDoc)));
	return (CReviewSystemDoc*)m_pDocument;
}
#endif //_DEBUG


// CReviewSystemView 메시지 처리기
void CReviewSystemView::CreateDialogs(int nLineType, int nMachineType, BOOL bUseVisionAlign)
{
	CMainFrame *pMainFrame=(CMainFrame *)AfxGetMainWnd();  //View 2 MainFrm 

	if (pMainFrame==NULL) return;

	// Review Camera
	WINDOWPLACEMENT placement;
	m_pDlgReviewCamera = new CDlgReviewCamera(this, 0);
	if (m_pDlgReviewCamera) // 520
	{
		// main frame interface
		m_pDlgReviewCamera->SetDRC2P(static_cast<IDialogReviewCamera2Parent*>(pMainFrame));
		m_pDlgReviewCamera->SetCIV2P(static_cast<ICameraImageView2Parent*>(pMainFrame));

		// create
		m_pDlgReviewCamera->Create(CDlgReviewCamera::IDD, this);
		placement.rcNormalPosition.left		= 5;
		placement.rcNormalPosition.top		= 5; 
		placement.rcNormalPosition.right	= placement.rcNormalPosition.left + CAMERA_WINDOW_SIZE_X;
		placement.rcNormalPosition.bottom	= placement.rcNormalPosition.top + CAMERA_WINDOW_SIZE_Y - 40;
		m_pDlgReviewCamera->SetWindowPlacement(&placement);
		m_pDlgReviewCamera->ShowWindow(SW_SHOW);

		// camera status observer
		m_vecDlgReviewCamera.push_back(m_pDlgReviewCamera);
	}
	

	// defect filter dialog
	m_pDlgDefectFilter = CDlgDefectFilter::GetInstance(this);//new CDlgDefectFilter(this);
	if (m_pDlgDefectFilter) 
	{
		// main frame interface
		m_pDlgDefectFilter->SetDDF2P(static_cast<IDialogDefectFilter2Parent*>(pMainFrame));

		// create
		m_pDlgDefectFilter->SetMachineType(nMachineType);
		m_pDlgDefectFilter->Create(CDlgDefectFilter::IDD, this);

		placement.rcNormalPosition.left		= CAMERA_WINDOW_SIZE_X + 6;
		placement.rcNormalPosition.top		= 0; 
		placement.rcNormalPosition.right	= placement.rcNormalPosition.left + OPTION_WINDOW_SIZE_X + 10;
		placement.rcNormalPosition.bottom	= placement.rcNormalPosition.top + OPTION_WINDOW_SIZE_Y+20;///2 + 30;

		m_pDlgDefectFilter->SetWindowPlacement(&placement);
		m_pDlgDefectFilter->ShowWindow(SW_SHOW);

		// defect filter observer
		pMainFrame->AddObserverUpdateDefectFilter(static_cast<IUpdateDefectFilter*>(m_pDlgDefectFilter));

		// review result observer
		pMainFrame->AddObserverUpdateReviewResult(static_cast<IUpdateReviewResult*>(m_pDlgDefectFilter));
	}

	// 기존 logo
	m_pDlgLogo = new CDlgLogo(this);
	if (m_pDlgLogo)
	{
		m_pDlgLogo->Create(CDlgLogo::IDD, this);
		placement.rcNormalPosition.left       = CAMERA_WINDOW_SIZE_X +5;
		placement.rcNormalPosition.top        = OPTION_WINDOW_SIZE_Y +20; 
		placement.rcNormalPosition.right      = placement.rcNormalPosition.left + 150;
		placement.rcNormalPosition.bottom     = placement.rcNormalPosition.top + 130;
		m_pDlgLogo->SetWindowPlacement(&placement);

		m_pDlgLogo->SetDL2P(static_cast<IDialogLogo2Parent*>(pMainFrame));

		m_pDlgLogo->ShowWindow(SW_SHOW);
	}

	// command dialog
	if (bUseVisionAlign)
	{
		m_pDlgCommand = new CDlgCommand(this);
		if (m_pDlgCommand)
		{
			// main frame interface
			m_pDlgCommand->SetDC2P(static_cast<IDialogCommand2Parent*>(pMainFrame));

			// create
			m_pDlgCommand->SetLineType(nLineType);
			m_pDlgCommand->SetMachineType(nMachineType);
			m_pDlgCommand->Create(CDlgCommand::IDD, this);

			placement.rcNormalPosition.left		= CAMERA_WINDOW_SIZE_X + OPTION_WINDOW_SIZE_X + 9;
			placement.rcNormalPosition.top		= 0; 
			placement.rcNormalPosition.right	= placement.rcNormalPosition.left + CMD_WINDOW_SIZE_X;
			placement.rcNormalPosition.bottom	= placement.rcNormalPosition.top + CMD_WINDOW_SIZE_Y;

			m_pDlgCommand->SetWindowPlacement(&placement);
			m_pDlgCommand->ShowWindow(SW_SHOW);

			// process status observer
			pMainFrame->AddObserverUpdateProcessStatus(static_cast<IUpdateProcessStatus*>(m_pDlgCommand));
		}
	}
	else
	{
		m_pDlgUserCmd = new CDlgUserCmd(this);
		if (m_pDlgUserCmd)
		{
			// main frame interface
			m_pDlgUserCmd->SetDUC2P(static_cast<IDialogUserCmd2Parent*>(pMainFrame));

			// create
			m_pDlgUserCmd->Create(CDlgUserCmd::IDD, this);
			placement.rcNormalPosition.left		= CAMERA_WINDOW_SIZE_X + OPTION_WINDOW_SIZE_X + 9;
			placement.rcNormalPosition.top		= 0; 
			placement.rcNormalPosition.right	= placement.rcNormalPosition.left + CMD_WINDOW_SIZE_X;
			placement.rcNormalPosition.bottom	= placement.rcNormalPosition.top + CMD_WINDOW_SIZE_Y;
			m_pDlgUserCmd->SetWindowPlacement(&placement);
			m_pDlgUserCmd->ShowWindow(SW_SHOW);

			// process status observer
			pMainFrame->AddObserverUpdateProcessStatus(static_cast<IUpdateProcessStatus*>(m_pDlgUserCmd));
		}
	}
	
	// defect map dialog
	m_pDlgDefectMap = new CDlgDefectMap(this);
	if (m_pDlgDefectMap)
	{
		// main frame interface
		m_pDlgDefectMap->SetDDM2P(static_cast<IDialogDefectMap2Parent*>(pMainFrame));

		// create
		m_pDlgDefectMap->Create(CDlgDefectMap::IDD, this);
		placement.rcNormalPosition.left		= CAMERA_WINDOW_SIZE_X + OPTION_WINDOW_SIZE_X + 9;//+ OPTION_WINDOW_SIZE_X + 9 + 10;
		placement.rcNormalPosition.top		= CMD_WINDOW_SIZE_Y; 
		placement.rcNormalPosition.right	= placement.rcNormalPosition.left + MAP_WINDOW_SIZE_X + 100;// - OPTION_WINDOW_SIZE_X - 15;
		placement.rcNormalPosition.bottom	= placement.rcNormalPosition.top + MAP_WINDOW_SIZE_Y;
		m_pDlgDefectMap->SetWindowPlacement(&placement);
		m_pDlgDefectMap->ShowWindow(SW_SHOW);

		// process status observer
		pMainFrame->AddObserverUpdateProcessStatus(static_cast<IUpdateProcessStatus*>(m_pDlgDefectMap));

		// defect filter observer
		pMainFrame->AddObserverUpdateDefectFilter(static_cast<IUpdateDefectFilter*>(m_pDlgDefectMap));
		
		// review result observer
		pMainFrame->AddObserverUpdateReviewResult(static_cast<IUpdateReviewResult*>(m_pDlgDefectMap));
		pMainFrame->AddObserverUpdateReviewResult(static_cast<IUpdateReviewResult*>( m_pDlgDefectMap->GetDefectMap() ));

		// motor position observer
		pMainFrame->AddObserverUpdateMotorPosition(static_cast<IUpdateMotorPosition*>(m_pDlgDefectMap));
	}

	//정보 출력 부
	m_pDlgModuleInfo = new CDlgModuleInfo(this);
	if(m_pDlgModuleInfo)
	{
		// main interface
		m_pDlgModuleInfo->SetDMI2P(static_cast<IDialogModuleInfo2Parent*>(pMainFrame));
		
		//m_pDlgModuleInfo->SetCameraNumber(m_nGantryNumber, m_nVecHeaderNumber, m_nVecCameraNumber, m_nTotalCameraNumber);
		
		// create
		m_pDlgModuleInfo->Create(CDlgModuleInfo::IDD, this);

		placement.rcNormalPosition.left		=	5;
		placement.rcNormalPosition.top		=	715;

		placement.rcNormalPosition.right	=	placement.rcNormalPosition.left + 878;//728;//800;//960;
		placement.rcNormalPosition.bottom	=	placement.rcNormalPosition.top + 75;

		m_pDlgModuleInfo->SetWindowPlacement(&placement);
		m_pDlgModuleInfo->ShowWindow(SW_SHOW);

		// theta motor info observer
		pMainFrame->AddObserverUpdateThetaMotorInfo(static_cast<IUpdateThetaMotorInfo*>(m_pDlgModuleInfo));

		// motor position observer
		pMainFrame->AddObserverUpdateMotorPosition(static_cast<IUpdateMotorPosition*>(m_pDlgModuleInfo));

		// motor status observer
		pMainFrame->AddObserverUpdateMotorStatus(static_cast<IUpdateMotorStatus*>(m_pDlgModuleInfo));

		// camera control observer
		pMainFrame->AddObserverUpdateCameraControl(static_cast<IUpdateCameraControl*>(m_pDlgModuleInfo));

		// selected module index
		pMainFrame->AddObserverUpdateSelectedModuleIndex(static_cast<IUpdateSelectedModuleIndex*>(m_pDlgModuleInfo));

		//review defect count
		pMainFrame->AddObserverUpdateReviewResult(static_cast<IUpdateReviewResult*>(m_pDlgModuleInfo));
	}	

	m_pDlgGlassAndNetworkInfo = new CDlgGlassAndConnectionInfo(this);
	if(m_pDlgGlassAndNetworkInfo)
	{
		m_pDlgGlassAndNetworkInfo->SetLineType(nLineType);
		m_pDlgGlassAndNetworkInfo->Create(CDlgGlassAndConnectionInfo::IDD, this);
		placement.rcNormalPosition.left		=	CAMERA_WINDOW_SIZE_X + 5;
		placement.rcNormalPosition.top		=	715;//CAMERA_WINDOW_SIZE_Y - 100;//715;

		placement.rcNormalPosition.right	=	placement.rcNormalPosition.left + 150;
		placement.rcNormalPosition.bottom	=	placement.rcNormalPosition.top + 500;

		m_pDlgGlassAndNetworkInfo->SetWindowPlacement(&placement);
		m_pDlgGlassAndNetworkInfo->ShowWindow(SW_SHOW);

		pMainFrame->AddObserverUpdateProcessStatus(static_cast<IUpdateProcessStatus*>(m_pDlgGlassAndNetworkInfo));
		pMainFrame->AddObserverUpdateConnectionStatus(static_cast<IUpdateConnectionStatus*>(m_pDlgGlassAndNetworkInfo));
	}


	m_pDlgTab = new CDlgTab(this);
	if (m_pDlgTab)
	{
		m_pDlgTab->Create(CDlgTab::IDD, this);
		placement.rcNormalPosition.left		= CAMERA_WINDOW_SIZE_X + OPTION_WINDOW_SIZE_X + 10;// + INFO_WINDOW_SIZE_X + 10;
		placement.rcNormalPosition.top		= CMD_WINDOW_SIZE_Y + MAP_WINDOW_SIZE_Y; 
		placement.rcNormalPosition.right	= placement.rcNormalPosition.left + TAB_WINDOW_SIZE_X;
		placement.rcNormalPosition.bottom	= placement.rcNormalPosition.top + TAB_WINDOW_SIZE_Y;
		m_pDlgTab->SetWindowPlacement(&placement);
		m_pDlgTab->ShowWindow(SW_SHOW);
		placement.rcNormalPosition.left		= 0;
		placement.rcNormalPosition.top		= 0;
 		placement.rcNormalPosition.right	= placement.rcNormalPosition.left + TAB_WINDOW_SIZE_X;
 		placement.rcNormalPosition.bottom	= placement.rcNormalPosition.top + TAB_WINDOW_SIZE_Y-25;

		pMainFrame->AddObserverUpdateProcessStatus(static_cast<IUpdateProcessStatus*>(m_pDlgTab));
	}

	    //기존 Defect List
		m_pDlgDefectList = new CDlgDefectList();//CDlgDefectList::GetInstance();//
		if (m_pDlgDefectList)
		{
			m_pDlgDefectList->Create(CDlgDefectList::IDD, this);
			m_pDlgDefectList->SetWindowPlacement(&placement);
			m_pDlgDefectList->ShowWindow(SW_SHOW);

			m_pDlgTab->AddWndPtr(static_cast<CWnd*>(m_pDlgDefectList), _T("Defect List"));

			// main frame interface
			m_pDlgDefectList->SetDDL2P(static_cast<IDialogDefectList2Parent*>(pMainFrame));

			// process status observer
			pMainFrame->AddObserverUpdateProcessStatus(static_cast<IUpdateProcessStatus*>(m_pDlgDefectList));

			// defect filter observer
			pMainFrame->AddObserverUpdateDefectFilter(static_cast<IUpdateDefectFilter*>(m_pDlgDefectList));
		}

		//Defect Info //taek 20.12.04
		m_pDlgDefectInfo = new CDlgDefectInfo();
		if (m_pDlgDefectInfo)
		{
			m_pDlgDefectInfo->Create(CDlgDefectInfo::IDD, this);
			m_pDlgDefectInfo->SetWindowPlacement(&placement);
			m_pDlgDefectInfo->ShowWindow(SW_SHOW);

			m_pDlgTab->AddWndPtr(static_cast<CWnd*>(m_pDlgDefectInfo), _T("Defect Info"));
		}

		//신규 DLG_TAP_CTRL KWH
		m_pDlgTapCtrl = new DlgTapCtrl(this);

		if (m_pDlgTapCtrl)
		{
			m_pDlgTapCtrl->SetDC2P(static_cast<IDialogTabCtrl2Parent*>(pMainFrame));

			m_pDlgTapCtrl->Create(DlgTapCtrl::IDD, this);
			placement.rcNormalPosition.left		= 10;// + INFO_WINDOW_SIZE_X + 10;
			placement.rcNormalPosition.top		= 800; 
			placement.rcNormalPosition.right	=	placement.rcNormalPosition.left + 900;//735;//800;//960;
			placement.rcNormalPosition.bottom	=	placement.rcNormalPosition.top + 400;
			m_pDlgTapCtrl->SetWindowPlacement(&placement);
			m_pDlgTapCtrl->ShowWindow(SW_SHOW);

			placement.rcNormalPosition.left		= 0;
			placement.rcNormalPosition.top		= 0;
			placement.rcNormalPosition.right	= placement.rcNormalPosition.left + TAB_WINDOW_SIZE_X+30;
			placement.rcNormalPosition.bottom	= placement.rcNormalPosition.top + TAB_WINDOW_SIZE_Y-250;

			pMainFrame->AddObserverUpdateProcessStatus(static_cast<IUpdateProcessStatus*>(m_pDlgTapCtrl));

			//	// create
			m_pDlgControl = CDlgControl::GetInstance();
			if (m_pDlgControl)
			{
				m_pDlgControl->SetDC2P(static_cast<IDialogControl2Parent*>(pMainFrame));

				m_pDlgControl->Create(CDlgControl::IDD, this);
				m_pDlgControl->SetWindowPlacement(&placement);
				m_pDlgControl->ShowWindow(SW_SHOW);

				m_pDlgTapCtrl->AddWndPtr(static_cast<CWnd*>(m_pDlgControl), _T("Jog Control"));
			}

			// camera status observer
			pMainFrame->AddObserverUpdateCameraControl(static_cast<IUpdateCameraControl*>(m_pDlgControl));

			pMainFrame->AddObserverUpdateSelectedModuleIndex(static_cast<IUpdateSelectedModuleIndex*>(m_pDlgControl));

		}
		//LOG
		m_pDlgLog = new CDlgLog();
		if (m_pDlgLog)
		{
			m_pDlgLog->Create(CDlgLog::IDD, this);
			m_pDlgLog->SetWindowPlacement(&placement);
			m_pDlgLog->ShowWindow(SW_HIDE);

			m_pDlgTapCtrl->AddWndPtr(static_cast<CWnd*>(m_pDlgLog), _T("System Log"));
		}

		if (bUseVisionAlign)
		{
			// align camera dialog
			m_pDlgAlignCamera = new CDlgAlignCamera(this);
			if (m_pDlgAlignCamera) 
			{
				m_pDlgAlignCamera->Create(CDlgAlignCamera::IDD, this);			
				m_pDlgAlignCamera->SetWindowPlacement(&placement);
				m_pDlgAlignCamera->ShowWindow(SW_SHOW);
				m_pDlgTapCtrl->AddWndPtr(static_cast<CWnd*>(m_pDlgAlignCamera), _T("Align Camera"));

				//// main frame interface
				m_pDlgAlignCamera->SetDAC2P(static_cast<IDialogAlignCamera2Parent*>(pMainFrame));			

				pMainFrame->AddObserverUpdateProcessStatus(static_cast<IUpdateProcessStatus*>(m_pDlgAlignCamera));
			}
		}

		m_pDlgDefocus = CDlgDefocusList::GetInstance();
		if (m_pDlgDefocus)
		{
			m_pDlgDefocus->Create(CDlgDefocusList::IDD, this);
			m_pDlgDefocus->SetWindowPlacement(&placement);
			m_pDlgDefocus->ShowWindow(SW_HIDE);
			
			m_pDlgTapCtrl->AddWndPtr(static_cast<CWnd*>(m_pDlgDefocus), _T("DL"));
			m_pDlgDefocus->SetDDL2P(static_cast<IDialogDefocusList2Parent*>(pMainFrame));	
			//pMainFrame->AddObserverUpdateDefocusList(static_cast<IUpdateDefocusList*>(m_pDlgDefocus));
		
		}

		//Review PopUp 생성
		m_DlgReviewPopUp = new DlgReviewPopUp(this, 1);
		m_DlgReviewPopUp->Create(IDD_DLG_REVIEW_POPUP, this);
		isReviewPopUp = FALSE;

		m_DlgReviewPopUp->SetDRC2P(static_cast<IDialogReviewPopUP2Parent*>(pMainFrame));
		m_DlgReviewPopUp->SetCIV2P(static_cast<ICameraImageView2Parent*>(pMainFrame));

		//m_DlgReviewPopUp->ShowWindow(SW_SHOW);
		m_vecDlgReviewPopUp.push_back(m_DlgReviewPopUp);


		//Review OffsetTool 생성
		m_DlgOffSetTool = new DlgReviewOffSetTool(this);
		m_DlgOffSetTool->Create(IDD_DLG_REVIEW_OFFSET_TOOL, this);
		m_DlgOffSetTool->SetDDL2P(static_cast<IDialogReviewOffSet2Parent*>(pMainFrame));

		/*< LYW 20211112 - #3708 ADD Start >*/
		m_DlgHardWareSettingMode = new DlgHardwareSettingMode(this);
		m_DlgHardWareSettingMode->Create(IDD_DLG_HARDWARE_SETTING_MODE, this);
		m_DlgHardWareSettingMode->SetDHM2P(static_cast<IDialogHardwareSettingMode2Parent*>(pMainFrame));
		/*< LYW 20211112 - #3708 ADD End >*/

		/*< LYW 20211109 - #3662 Delete Start >*/
		////Review HistoryTool 생성
		//m_DlgHistoryTool = new CDlgReviewHistoryTool(this);
		//m_DlgHistoryTool->Create(IDD_DLG_REVIEW_HISTORY_TOOL, this);
		//m_DlgHistoryTool->SetDDL2P(static_cast<IDialogReviewHistory2Parent*>(pMainFrame));
		/*< LYW 20211109 - #3662 Delete End >*/

	//	m_DlgOffSetTool->ShowWindow(SW_SHOW);

		/* < KEJ 20230621 - #4528 ADD Start > */

		//Motor OffsetTool 생성
		m_DlgMotorOffSetTool = new CDlgMotorOffSetTool(this);
		m_DlgMotorOffSetTool->Create(IDD_DLG_MOTOR_OFFSET_TOOL, this);
		m_DlgMotorOffSetTool->SetDMO2P(static_cast<IDialogMotorOffSet2Parent*>(pMainFrame));
		/* < KEJ 20230621 - #4528 ADD End > */
	}


void CReviewSystemView::SetAcitveDialog(int nIndex)
{
	if (m_pDlgTab)
	{
		m_pDlgTab->SetActiveDialog(nIndex);
	}
	if (m_pDlgTapCtrl)
	{
		m_pDlgTapCtrl->SetActiveDialog(nIndex);
	}
}

void CReviewSystemView::DeleteDialogs()
{
	TRACE(_T("[A2E]DeleteDialogs 시작\n"));

	CMainFrame *pMainFrame=(CMainFrame *)AfxGetMainWnd();  //View 2 MainFrm 

	// graph dialog
	if (m_pDlgGraph) 
	{
		m_pDlgGraph->DestroyWindow();
		delete m_pDlgGraph;
		m_pDlgGraph = NULL;
	}

	// review camera dialog
	int nCount = (int)m_vecDlgReviewCamera.size();
	for (VectorDlgReviewCameraIt it=m_vecDlgReviewCamera.begin(); it!=m_vecDlgReviewCamera.end(); it++)
	{
		CDlgReviewCamera *pDialog = static_cast<CDlgReviewCamera*>(*it);
		if (pDialog) 
		{
			pDialog->DestroyWindow();
			delete pDialog;
			pDialog = NULL;
		}
	}
	m_vecDlgReviewCamera.clear();

	// align camera dialog
	if (m_pDlgAlignCamera) 
	{
		m_pDlgAlignCamera->DestroyWindow();
		delete m_pDlgAlignCamera;
		m_pDlgAlignCamera = NULL;
	}

	// command dialog
	if (m_pDlgCommand)
	{
		m_pDlgCommand->DestroyWindow();
		delete m_pDlgCommand;
		m_pDlgCommand = NULL;
	}

	// defect map dialog
	if (m_pDlgDefectMap) 
	{
		m_pDlgDefectMap->DestroyWindow();
		delete m_pDlgDefectMap;
		m_pDlgDefectMap = NULL;
	}


	// defect filter dialog
	if (m_pDlgDefectFilter) 
	{
		m_pDlgDefectFilter->DestroyWindow();
		delete m_pDlgDefectFilter;
		m_pDlgDefectFilter = NULL;
	}

	// AFM dialog
	if(m_pDlgAFMInfo)
	{
		m_pDlgAFMInfo->DestroyWindow();
		delete m_pDlgAFMInfo;
		m_pDlgAFMInfo = NULL;
	}

	// tab control dialog
	if (m_pDlgTab) 
	{
		m_pDlgTab->DestroyWindow();
		delete m_pDlgTab;
		m_pDlgTab = NULL;
	}

	// tab control dialog
	if (m_pDlgTapCtrl) 
	{
		m_pDlgTapCtrl->DestroyWindow();
		delete m_pDlgTapCtrl;
		m_pDlgTapCtrl = NULL;
	}


	// defect list dialog
	if (m_pDlgDefectList) 
	{
		m_pDlgDefectList->DestroyWindow();
		delete m_pDlgDefectList;
		m_pDlgDefectList = NULL;
	}

	// defect info dialog //taek 20.12.04
	if (m_pDlgDefectInfo)
	{
		m_pDlgDefectInfo->DestroyWindow();
		delete m_pDlgDefectInfo;
		m_pDlgDefectInfo = NULL;
	}

	// log dialog
	if (m_pDlgLog) 
	{
		m_pDlgLog->DestroyWindow();
		delete m_pDlgLog;
		m_pDlgLog = NULL;
	}

	if(m_pDlgLogo)
	{
		m_pDlgLogo->DestroyWindow();
		delete m_pDlgLogo;
		m_pDlgLogo = NULL;
	}


	if(m_pDlgLongRun)
	{
		m_pDlgLongRun->DestroyWindow();
		delete m_pDlgLongRun;
		m_pDlgLongRun = NULL;
	}

	if(m_pDlgResultGraph_Dx)
	{
		m_pDlgResultGraph_Dx->DestroyWindow();
		delete m_pDlgResultGraph_Dx;
		m_pDlgResultGraph_Dx = NULL;
	}

	if(m_pDlgResultGraph_Dy)
	{
		m_pDlgResultGraph_Dy->DestroyWindow();
		delete m_pDlgResultGraph_Dy;
		m_pDlgResultGraph_Dy = NULL;
	}

	if(m_pDlgUserCmd)
	{
		m_pDlgUserCmd->DestroyWindow();
		delete m_pDlgUserCmd;
		m_pDlgUserCmd = NULL;
	}

	if(m_pDlgModuleInfo)
	{
		m_pDlgModuleInfo->DestroyWindow();
		delete m_pDlgModuleInfo;
		m_pDlgModuleInfo = NULL;
	}

	if(m_pDlgControl)
	{
		m_pDlgControl->DestroyWindow();
		delete m_pDlgControl;
		m_pDlgControl = NULL;
	}

	if(m_pDlgGlassAndNetworkInfo)
	{
		m_pDlgGlassAndNetworkInfo->DestroyWindow();
		delete m_pDlgGlassAndNetworkInfo;
		m_pDlgGlassAndNetworkInfo = NULL;
	}
	if (m_DlgReviewPopUp)
	{
		m_DlgReviewPopUp->DestroyWindow();
		delete m_DlgReviewPopUp;
		m_DlgReviewPopUp = NULL;
	}

	if (m_DlgOffSetTool)
	{
		m_DlgOffSetTool->DestroyWindow();
		delete m_DlgOffSetTool;
		m_DlgOffSetTool = NULL;
	}

	if (m_DlgHistoryTool)
	{
		m_DlgHistoryTool->DestroyWindow();
		delete m_DlgHistoryTool;
		m_DlgHistoryTool = NULL;
	}
	/* < KEJ 20230621 - #4528 ADD Start > */
	if (m_DlgMotorOffSetTool)
	{
		m_DlgMotorOffSetTool->DestroyWindow();
		delete m_DlgMotorOffSetTool;
		m_DlgMotorOffSetTool = NULL;
	}
	/* < KEJ 20230621 - #4528 ADD End > */

	TRACE(_T("[A2E]DeleteDialogs 종료\n"));
}

void CReviewSystemView::CreateLongRunDialog()
{
	m_pDlgLongRun = new CDlgLongRun;

	if(m_pDlgLongRun)
	{
		m_pDlgLongRun->Create(IDD_DLG_LONG_RUN);
		m_pDlgLongRun->ShowWindow(SW_SHOW);
	}
}

void CReviewSystemView::OnDestroy()
{
	DeleteDialogs();

	CFormView::OnDestroy();
}

void CReviewSystemView::SetDefaultGlassType(const CGlassResult* pGlassResult)
{
	if(m_pDlgDefectMap)
	{
		m_pDlgDefectMap->SetDefaultGlassType(pGlassResult);
	}
}

void CReviewSystemView::SetAlignResult(int nResultCode, double dDX, double dDy, double dTheta)
{
	if (m_pDlgAlignCamera)
	{
		m_pDlgAlignCamera->SetAlignResult(nResultCode, dDX, dDy, dTheta);
	}
}

void CReviewSystemView::DisplayMessage(const CString& strMessage)
{
	if(m_pDlgLog)
	{
		m_pDlgLog->DisplayMessage(strMessage);
	}
}

BOOL CReviewSystemView::DestroyWindow()
{
	// TODO: 여기에 특수화된 코드를 추가 및/또는 기본 클래스를 호출합니다.

	return __super::DestroyWindow();
}

void CReviewSystemView::UpdateSelectDefectHistoryMap(CDefectResult* pDefectResult)
{
	if (m_DlgHistoryTool)
	{
		m_DlgHistoryTool->UpdateSelect(pDefectResult);
	}
}


//taek 20.12.04
void CReviewSystemView::UpdateSelectDefectInfoMap(CDefectResult* pDefectResult)
{
	if (m_pDlgDefectInfo)
	{
		m_pDlgDefectInfo->UpdateSelectDefectMap(pDefectResult);
	}
}

void CReviewSystemView::UpdateSelectDefectInfo(int nDefectIdx)
{
	if (m_pDlgDefectInfo)
	{
		m_pDlgDefectInfo->SetDefectImage(nDefectIdx);
	}
}

void CReviewSystemView::UpdateSelectDefectList(int nDefectIdx)
{
	if(m_pDlgDefectList)
	{
		m_pDlgDefectList->UpdateSelectDefectList(nDefectIdx);
	}
}

void CReviewSystemView::UpdateSelectDefectMap(CDefectResult* pDefectResult)
{
	if(m_pDlgDefectMap)
	{
		m_pDlgDefectMap->UpdateSelectDefectMap(pDefectResult);
	}
}

BOOL CReviewSystemView::UpdateSelectDefectList2(int nDefectIdx)
{       
	if (m_DlgHistoryTool)
	{
		return m_DlgHistoryTool->UpdateSelectDefectInfoMap2(nDefectIdx);
	}
	return FALSE;
}

BOOL CReviewSystemView::UpdateSelectDefectList3(int nDefectIdx)
{
	if (m_DlgHistoryTool)
	{
		return m_DlgHistoryTool->UpdateSelectDefectInfoMap3(nDefectIdx);
	}
	return FALSE;
}

BOOL CReviewSystemView::AllDefect()
{
	if (m_DlgHistoryTool)
	{
		return m_DlgHistoryTool->GetAllDefect();
	}
	return FALSE;
}

CString CReviewSystemView::UpdateSelectImageName()
{
	return  m_DlgHistoryTool->GetReviewName();
}

void CReviewSystemView::UpdateSelectDefectMap2(CDefectResult* pDefectResult)
{
	if (m_DlgHistoryTool)
	{
		m_DlgHistoryTool->UpdateSelectDefectMap2(pDefectResult);
	}
}


void CReviewSystemView::UpdateLongRunCount(CString strLongRunCount)
{
	if(m_pDlgLongRun)
	{
		m_pDlgLongRun->UpdateLongRunCount(strLongRunCount);
	}
}
void CReviewSystemView::UpdateMeasureGraph(CGlassResult* pGlassResult)
{
	if(m_pDlgResultGraph_Dx)
	{
		m_pDlgResultGraph_Dx->DrawMeasureGraph(Graph_Dx, pGlassResult);
	}
	if(m_pDlgResultGraph_Dy)
	{
		m_pDlgResultGraph_Dy->DrawMeasureGraph(Graph_Dy, pGlassResult);
	}
}

LRESULT CReviewSystemView::OnLongRunCountUpdate(WPARAM wParam, LPARAM lParam)
{
	CString* pStrLongRunCount = (CString*)lParam;

	if(m_pDlgLongRun)
	{
		m_pDlgLongRun->UpdateLongRunCount(*pStrLongRunCount);
	}

	return 0;
}

void CReviewSystemView::UpdateAlignResult(const CGlassResult* pGlassResult)
{
	if( m_pDlgAlignCamera )
		m_pDlgAlignCamera->UpdateAlignResult( pGlassResult );
}


void CReviewSystemView::ShowReviewPopUP()
{
	if (isReviewPopUp == FALSE)
	{
		m_DlgReviewPopUp->ShowWindow(TRUE);
		isReviewPopUp = TRUE;
	}
	else
	{
		isReviewPopUp = FALSE;
		m_DlgReviewPopUp->ShowWindow(FALSE);
	}
}

void CReviewSystemView::HideHistoryTool()
{
	m_DlgHistoryTool->ShowWindow(SW_HIDE);
	m_pDlgLogo->m_ctrlHistory.EnableWindow(FALSE);
}

void CReviewSystemView::ShowBHistoryTool()
{
	m_pDlgLogo->m_ctrlHistory.EnableWindow(TRUE);
}

void CReviewSystemView::HistoryToolUpdate()
{
	m_DlgHistoryTool->GetHistoryList();
}

void CReviewSystemView::SelectedCameraIndex(int nMouleindex)
{
	if (nMouleindex == 0)
	{
		m_pDlgReviewCamera->SetModuleIndex(0);
		m_DlgReviewPopUp->SetModuleIndex(1);
	}
	else
	{
		m_pDlgReviewCamera->SetModuleIndex(1);
		m_DlgReviewPopUp->SetModuleIndex(0);
	}
}

void CReviewSystemView::ShowOffSetTool()
{
	m_DlgOffSetTool->ShowWindow(SW_SHOW);
}

void CReviewSystemView::ShowHistoryTool()
{
	m_DlgHistoryTool->ShowWindow(SW_SHOW);
	m_DlgHistoryTool->GetHistoryList();
}

void CReviewSystemView::ShowHWSettingMode()
{
	m_DlgHardWareSettingMode->ShowWindow(SW_SHOW);
}
/* < KEJ 20230621 - #4528 ADD Start > */
void CReviewSystemView::ShowMotorOffSetTool()
{
	m_DlgMotorOffSetTool->ShowWindow(SW_SHOW);
}
/* < KEJ 20230621 - #4528 ADD End > */

//181203
BOOL CReviewSystemView::SaveDefectMap( const CString& strPath )
{
	if (m_pDlgDefectMap==NULL) return FALSE;

	return m_pDlgDefectMap->SaveDefectMap(strPath);
}


BOOL CReviewSystemView::OnEraseBkgnd(CDC* pDC)
{
	CRect	rect;
	GetClientRect(&rect);
	__super::OnEraseBkgnd(pDC);
	pDC->FillSolidRect(rect, RGB(38,38,38) );

	return TRUE;
}


HBRUSH CReviewSystemView::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
{
	HBRUSH hbr = __super::OnCtlColor(pDC, pWnd, nCtlColor);

	CRect rect;
	CString strClass = _T("");
	UINT nID = pWnd->GetDlgCtrlID();

	if(nCtlColor == CTLCOLOR_STATIC)
	{
		pDC->SetTextColor(RGB(255,255,255));
		pDC->SetBkColor(RGB(38,38,38));
		hbr = (HBRUSH)GetStockObject(NULL_BRUSH);
	}


	// TODO:  기본값이 적당하지 않으면 다른 브러시를 반환합니다.
	return hbr;
}