// DlgControl.cpp : 구현 파일입니다.
//

#include "stdafx.h"
#include "ReviewSystem.h"
#include "DlgControl.h"
#include "afxdialogex.h"
#include "MainFrm.h"
#include "DlgKeyJogLogin.h"
#include "CHReviewSetting/SystemInfo.h"
#include "CHReviewSetting/NetworkInfo.h"
#include "DlgDefectList.h"
#include "DlgDefectInfo.h" //taek 20.12.04
#pragma comment(lib, "uxtheme.lib") 

// CDlgControl 대화 상자입니다.
IMPLEMENT_DYNAMIC(CDlgControl, CDialog)

	CDlgControl::CDlgControl(CWnd* pParent /*=NULL*/)
	: CDialog(CDlgControl::IDD, pParent)
{
	m_pDC2P				= NULL;
	m_nModuleIndex		= -1;
	m_nJogDown			= -1;
	m_bCheckKeyJog		= FALSE;
	m_nKeyBoardCommand = -1;
	m_bMoveKeyJogCheck = TRUE;
	m_nKeyJogDownIndex = -1;
	m_nMoveMode			= MoveMode_Review;
	m_nMoveAxis			= MoveAxis_Center;
	m_nGlassGridViewIndex = 0;
	pDlgContol          = NULL;
	m_bAlignCamGrab		= FALSE;
}

#define ENABLE_RADIO_TIMER

CDlgControl::~CDlgControl()
{
	delete KeyboardCommandMode;
	KeyboardCommandMode = NULL;
}

void CDlgControl::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_STATIC_X_JOG_PLUS, m_ctrlJogCommand[JogCommand_Right]);
	DDX_Control(pDX, IDC_STATIC_Y_JOG_PLUS, m_ctrlJogCommand[JogCommand_Top]);
	DDX_Control(pDX, IDC_STATIC_R_JOG_PLUS, m_ctrlJogCommand[JogCommand_AntiClock]);
	DDX_Control(pDX, IDC_STATIC_X_JOG_MINUS, m_ctrlJogCommand[JogCommand_Left]);
	DDX_Control(pDX, IDC_STATIC_Y_JOG_MINUS, m_ctrlJogCommand[JogCommand_Bottom]);
	DDX_Control(pDX, IDC_STATIC_R_JOG_MINUS, m_ctrlJogCommand[JogCommand_Clock]);
	DDX_Control(pDX, IDC_SLIDER_JOG_SPEED, m_ctrlSliderJogSpeed);

	DDX_Control(pDX, IDC_SLIDER_LIGHT_LEVEL, m_ctrlLightLevel);
	//DDX_Control(pDX, IDC_BNT_CHECK_CAMERA_CONTROL,	m_ctrlCameraControl);
	//DDX_Control(pDX, IDC_CHECK_AFM_TRACK,			m_ctrlAFMTracking);

	DDX_Control(pDX, IDC_GRID_MOTOR_POS, m_ctrlMotorPos);
	DDX_Control(pDX, IDC_GRID_GLASS_POS, m_ctrlGlassPos);
	DDX_Control(pDX, IDC_GRID_GLASSCENTER_POS, m_ctrlGlassCenterPos);

	//DDX_Control(pDX, IDC_BUTTON_JOG_DOWN,			m_ctrlJogDown);
	//DDX_Control(pDX, IDC_BUTTON_JOG_UP,				m_ctrlJogUp);

	//DDX_Control(pDX, IDC_BUTTON_UI_LEFT,			m_btnLeft);

	DDX_Control(pDX, IDC_RADIO_ZOOM_LEVEL_0, m_ctrlRadioSet[0]);
	DDX_Control(pDX, IDC_RADIO_ZOOM_LEVEL_1, m_ctrlRadioSet[1]);
	DDX_Control(pDX, IDC_RADIO_ZOOM_LEVEL_2, m_ctrlRadioSet[2]);
	DDX_Control(pDX, IDC_RADIO_ZOOM_LEVEL_3, m_ctrlRadioSet[3]);
	DDX_Control(pDX, IDC_RADIO_ZOOM_LEVEL_4, m_ctrlRadioSet[4]);

	DDX_Control(pDX, IDC_KEY_JOG_MOVE, m_ctrlKeyMoveJog);
	//DDX_Control(pDX, IDC_CHECK_UI_REDUCE, m_chekreduce);
	//DDX_Control(pDX, IDC_CHECK_USE_WSI_CONTROL, m_ctrlUseWSICon);
	//DDX_Control(pDX, IDC_SELECT_OFFSET_ON, SelectOffSetOn);
	//  DDX_Control(pDX, IDC_NOT_USE_CENTER_POS, m_ctlNotUseCenterPos);
	//DDX_Control(pDX, IDC_BUTTON_UI_RIGHT1, m_btnRight);
}


BEGIN_MESSAGE_MAP(CDlgControl, CDialog)
	ON_BN_CLICKED(IDOK, &CDlgReviewCamera::OnBnClickedOk)
	ON_NOTIFY(NM_RELEASEDCAPTURE, IDC_SLIDER_JOG_SPEED, &CDlgControl::OnNMReleasedcaptureSliderJogSpeed)
	ON_WM_HSCROLL()
	ON_NOTIFY(NM_RELEASEDCAPTURE, IDC_SLIDER_LIGHT_LEVEL, &CDlgControl::OnNMReleasedcaptureSliderLightLevel)
	ON_BN_CLICKED(IDC_RADIO_ZOOM_LEVEL_0, &CDlgControl::OnBnClickedRadioZoomLevel)
	ON_BN_CLICKED(IDC_RADIO_ZOOM_LEVEL_1, &CDlgControl::OnBnClickedRadioZoomLevel)
	ON_BN_CLICKED(IDC_RADIO_ZOOM_LEVEL_2, &CDlgControl::OnBnClickedRadioZoomLevel)
	ON_BN_CLICKED(IDC_RADIO_ZOOM_LEVEL_3, &CDlgControl::OnBnClickedRadioZoomLevel)
	ON_BN_CLICKED(IDC_RADIO_ZOOM_LEVEL_4, &CDlgControl::OnBnClickedRadioZoomLevel)
	ON_BN_CLICKED(IDC_BNT_CHECK_CAMERA_CONTROL, &CDlgControl::OnBnClickedCheckCameraControl)
	ON_BN_CLICKED(IDC_BUTTON_MOTOR_GO_XY, &CDlgControl::OnBnClickedButtonMotorGoXy)
	ON_BN_CLICKED(IDC_BUTTON_GLASS_GO_XY, &CDlgControl::OnBnClickedButtonGlassGoXy)
	ON_BN_CLICKED(IDC_BUTTON_GLASSCENTER_GO_XY, &CDlgControl::OnBnClickedButtonGlasscenterGoXy)
	ON_BN_CLICKED(IDC_CHECK_AFM_TRACK, &CDlgControl::OnBnClickedCheckAfmTrack)	
	ON_MESSAGE(UM_CAMERA_STATUS_UPDATE,		&CDlgControl::OnCameraStatusUpdate)
	ON_MESSAGE(UM_SELECTED_MODULE_INDEX_UPDATE,		&CDlgControl::OnUpdateSelectedModuleIndex)
	ON_WM_TIMER()
	ON_BN_CLICKED(IDC_BUTTON_TEST2, &CDlgControl::OnBnClickedButtonTest2)
	ON_BN_CLICKED(IDC_KEY_JOG_MOVE, &CDlgControl::OnBnClickedUseKeyboardCommand)
	ON_WM_KEYDOWN()
	ON_BN_CLICKED(IDC_CHECK_UI_REDUCE, &CDlgControl::OnBnClickedButtonUiExpand)
	ON_BN_CLICKED(IDC_BUTTON_UI_LEFT, &CDlgControl::OnBnClickedButtonUiLeft)
	ON_BN_CLICKED(IDC_BUTTON_UI_RIGHT1, &CDlgControl::OnBnClickedButtonUiRight1)
	//	ON_BN_CLICKED(IDC_BUTTON_UI_RIGHT, &CDlgControl::OnBnClickedButtonUiRight)
	ON_BN_CLICKED(IDC_CHECK_USE_WSI_CONTROL, &CDlgControl::OnBnClickedCheckUseWsiControl)
	ON_BN_CLICKED(IDC_SELECT_OFFSET_ON, &CDlgControl::OnBnClickedSelectOffsetOn)
	ON_WM_ERASEBKGND()
	ON_WM_CTLCOLOR()
	ON_BN_CLICKED(IDC_BT_REVIEW_POPUP, &CDlgControl::OnBnClickedBtReviewPopup)
	ON_BN_CLICKED(IDC_CHECK_USE_SIMULATION, &CDlgControl::OnBnClickedCheckUseSimulation)
	ON_STN_DBLCLK(IDC_STATIC_MAGNIFICATION, &CDlgControl::OnDblclkStaticMagnification)
	ON_BN_CLICKED(IDC_BUTTON_ALIGNCAM_GRAB, &CDlgControl::OnBnClickedButtonAligncamGrab)
END_MESSAGE_MAP()



// CDlgControl 메시지 처리기입니다.

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

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

	// TODO:  여기에 추가 초기화 작업을 추가합니다.	
	//skin
	{
		{
			{
				_GroupCtrlOption op = m_ctrlGroupCtrl.getCtrlOption();
				op.nStyle = 1;
				op.nStyleSub = 0;
				op.nFontSize = 15;
				op.nTextPosX = 20;
				op.nTextPosY = 3;
				op.clrTitle = RGB(50,50,50);
				op.clrOutline = RGB(86,86,86);
				op.clrFontNormal = RGB(255,255,255);
				op.nTitleHeight = 24;
				m_ctrlGroupCtrl.setCtrlOption(op);
				m_ctrlGroupCtrl.addControl(IDC_STATIC_CONTROLBOX, this);


				op.nTitleHeight = 0;
				m_ctrlGroupCtrl.setCtrlOption(op);
				//m_ctrlGroupCtrl.addControl(IDC_STATIC_VIEWMODE, this);
			}
			{
			
				_ColorButtonOption  op = m_ctrlButtonColorCtrl.getCtrlOption();
				op.nStyle = 1;
				op.nEdgeStyle = 1;
				op.clrButtonShow = RGB(50,50,50);
				op.clrFontNormal = RGB(255,255,255);
				op.clrFontPush   = RGB(255,255,255);
				m_ctrlButtonColorCtrl.setCtrlOption(op);


				m_ctrlButtonColorCtrl.addControl(IDC_BUTTON_GLASS_GO_XY, this);
				m_ctrlButtonColorCtrl.addControl(IDC_BUTTON_GLASSCENTER_GO_XY, this);
				m_ctrlButtonColorCtrl.addControl(IDC_BUTTON_MOTOR_GO_XY, this);

				m_ctrlButtonColorCtrl.addControl(IDC_CHECK_AFM_TRACK, this);

				m_ctrlButtonColorCtrl.addControl(IDC_BUTTON_JOG_UP, this);

				m_ctrlButtonColorCtrl.addControl(IDC_BUTTON_JOG_DOWN,this);

				m_ctrlButtonColorCtrl.addControl(IDC_CHECK_UI_REDUCE,this);

				m_ctrlButtonColorCtrl.addControl(IDC_BUTTON_UI_LEFT,this);

				m_ctrlButtonColorCtrl.addControl(IDC_BUTTON_UI_RIGHT1,this);

				m_ctrlButtonColorCtrl.addControl(IDC_CHECK_USE_WSI_CONTROL,this);

				m_ctrlButtonColorCtrl.addControl(IDC_SELECT_OFFSET_ON,this);

				m_ctrlButtonColorCtrl.addControl(IDC_BT_REVIEW_POPUP, this);

				m_ctrlButtonColorCtrl.addControl(IDC_CHECK_USE_SIMULATION, this);
				//#3561 CF AOI Review Align 카메라 끊김 현상 조치 ADD START
				m_ctrlButtonColorCtrl.addControl(IDC_BUTTON_ALIGNCAM_GRAB, this);
				//#3561 CF AOI Review Align 카메라 끊김 현상 조치 ADD END
				



				op = m_ctrlCheckBoxColorCtrl.getCtrlOption();
				op.nStyle = 1;
				op.nEdgeStyle = 1;
				op.nTextPushX = op.nTextPushY = 0;
				op.clrButtonShow = RGB(50,50,50);
				op.clrButtonPush =  RGB(37, 190, 86);
				op.clrFontNormal = RGB(255,255,255);
				op.clrFontPush   = RGB(255,255,255);
				m_ctrlCheckBoxColorCtrl.setCtrlOption(op);

				m_ctrlCheckBoxColorCtrl.addControl(IDC_BNT_CHECK_CAMERA_CONTROL, this);

				
				
				// 			m_ctrlCheckBoxColorCtrl.addControl(IDC_BUTTON_DRAW_PATTERN_INS, this);
				// 			m_ctrlCheckBoxColorCtrl.addControl(IDC_BUTTON_DRAW_ASG, this);

// 				m_ctrlRadioColorCtrl[0].setCtrlOption(op);
// 				m_ctrlRadioColorCtrl[0].addControl(IDC_RADIO_ZOOM_LEVEL_0,this);
// 				m_ctrlRadioColorCtrl[1].setCtrlOption(op);
//			    m_ctrlRadioColorCtrl[1].addControl(IDC_RADIO_ZOOM_LEVEL_1,this);
// 				m_ctrlRadioColorCtrl[2].setCtrlOption(op);
// 				m_ctrlRadioColorCtrl[2].addControl(IDC_RADIO_ZOOM_LEVEL_2,this);
// 				m_ctrlRadioColorCtrl[3].setCtrlOption(op);
//				m_ctrlRadioColorCtrl[3].addControl(IDC_RADIO_ZOOM_LEVEL_3,this);
// 				m_ctrlRadioColorCtrl[4].setCtrlOption(op);
// 				m_ctrlRadioColorCtrl[4].addControl(IDC_RADIO_ZOOM_LEVEL_4,this);


			}
			{
				_StaticTextCtrlOption op = m_ctrlStaticTextCtrl.getCtrlOption();
				op.clrTitle = RGB(255,255,255);
				op.nFontSize = 12;
				op.clrBack = RGB(53,83,113);

				m_ctrlStaticTextCtrl.setCtrlOption(op);

				m_ctrlStaticTextCtrl.addControl(IDC_STATIC_MAGNIFICATION			, this);



			}
		}
	}
	InitGridCameraPos();

	CString strFont = _T("MS Sans Serif");

	m_ctrlJogCommand[JogCommand_Right].SetFontStatic(strFont, 15, RGB(0,0,0), FS_CENTER);
	m_ctrlJogCommand[JogCommand_Right].SetBackground(RGB(80,80,80));
	m_ctrlJogCommand[JogCommand_Right].SetWindowText(_T("▶"));

	m_ctrlJogCommand[JogCommand_Top].SetFontStatic(strFont, 15, RGB(0,0,0), FS_CENTER);
	m_ctrlJogCommand[JogCommand_Top].SetBackground(RGB(80,80,80));
	m_ctrlJogCommand[JogCommand_Top].SetWindowText(_T("▲"));

	m_ctrlJogCommand[JogCommand_AntiClock].SetFontStatic(strFont, 15, RGB(0,0,0), FS_CENTER);
	m_ctrlJogCommand[JogCommand_AntiClock].SetBackground(RGB(80,80,80));
	m_ctrlJogCommand[JogCommand_AntiClock].SetWindowText(_T("↘"));

	m_ctrlJogCommand[JogCommand_Left].SetFontStatic(strFont, 15, RGB(0,0,0), FS_CENTER);
	m_ctrlJogCommand[JogCommand_Left].SetBackground(RGB(80,80,80));
	m_ctrlJogCommand[JogCommand_Left].SetWindowText(_T("◀"));

	m_ctrlJogCommand[JogCommand_Bottom].SetFontStatic(strFont, 15, RGB(0,0,0), FS_CENTER);
	m_ctrlJogCommand[JogCommand_Bottom].SetBackground(RGB(80,80,80));
	m_ctrlJogCommand[JogCommand_Bottom].SetWindowText(_T("▼"));

	m_ctrlJogCommand[JogCommand_Clock].SetFontStatic(strFont, 15, RGB(0,0,0), FS_CENTER);
	m_ctrlJogCommand[JogCommand_Clock].SetBackground(RGB(80,80,80));
	m_ctrlJogCommand[JogCommand_Clock].SetWindowText(_T("↙"));

	//m_ctrlRadioSet[0].SetFontStatic(strFont, 15, RGB(0,0,0), FS_CENTER);

	// slider jog speed
	m_ctrlSliderJogSpeed.SetRange(0, 100);
	m_ctrlSliderJogSpeed.SetRangeMin(0);
	m_ctrlSliderJogSpeed.SetRangeMax(100);
	m_ctrlSliderJogSpeed.SetTicFreq(1);
	m_ctrlSliderJogSpeed.SetLineSize(1);
	m_ctrlSliderJogSpeed.SetPageSize(1);
	m_ctrlSliderJogSpeed.SetPos(20);

	m_ctrlLightLevel.SetRange(0, 100);
	m_ctrlLightLevel.SetRangeMin(0);
	m_ctrlLightLevel.SetRangeMax(100);
	m_ctrlLightLevel.SetTicFreq(1);
	m_ctrlLightLevel.SetLineSize(1);
	m_ctrlLightLevel.SetPageSize(1);
	m_ctrlLightLevel.SetPos(20);

	m_pCtrlCameraControl = m_ctrlCheckBoxColorCtrl.GetDlgItem(IDC_BNT_CHECK_CAMERA_CONTROL);
	//m_ctrlCameraControl.SetWindowText(_T("Grab"));
	m_pCtrlCameraControl->SetWindowText(_T("Grab"));

	m_ctrlAFMTracking = m_ctrlButtonColorCtrl.GetDlgItem(IDC_CHECK_AFM_TRACK);
	m_ctrlAFMTracking->SetWindowText(_T("Tracking"));
	//m_pCtrlCameraControl->SetWindowText(_T(""))

	m_ctrlJogUp     = m_ctrlButtonColorCtrl.GetDlgItem(IDC_BUTTON_JOG_UP);
	m_ctrlJogDown   =  m_ctrlButtonColorCtrl.GetDlgItem(IDC_BUTTON_JOG_DOWN);


	m_chekreduce=m_ctrlButtonColorCtrl.GetDlgItem(IDC_CHECK_UI_REDUCE);
	m_btnLeft=m_ctrlButtonColorCtrl.GetDlgItem(IDC_BUTTON_UI_LEFT);
	m_btnRight=m_ctrlButtonColorCtrl.GetDlgItem(IDC_BUTTON_UI_RIGHT1);

	//버그 때문에 이거 넣어야지 바뀜 ;;; 
	SetWindowTheme(GetDlgItem(IDC_RADIO_ZOOM_LEVEL_0)->GetSafeHwnd(), (LPCWSTR)TEXT(""), (LPCWSTR)TEXT(""));
	SetWindowTheme(GetDlgItem(IDC_RADIO_ZOOM_LEVEL_1)->GetSafeHwnd(), (LPCWSTR)TEXT(""), (LPCWSTR)TEXT(""));
	SetWindowTheme(GetDlgItem(IDC_RADIO_ZOOM_LEVEL_2)->GetSafeHwnd(), (LPCWSTR)TEXT(""), (LPCWSTR)TEXT(""));
	SetWindowTheme(GetDlgItem(IDC_RADIO_ZOOM_LEVEL_3)->GetSafeHwnd(), (LPCWSTR)TEXT(""), (LPCWSTR)TEXT(""));
	SetWindowTheme(GetDlgItem(IDC_RADIO_ZOOM_LEVEL_4)->GetSafeHwnd(), (LPCWSTR)TEXT(""), (LPCWSTR)TEXT(""));

	//m_ctrlRadioSet[0] = (CButton*)/*m_ctrlRadioColorCtrl[0].*/GetDlgItem(IDC_RADIO_ZOOM_LEVEL_0);
	//m_ctrlRadioSet[1] = (CButton*)/*m_ctrlRadioColorCtrl[1].*/GetDlgItem(IDC_RADIO_ZOOM_LEVEL_1);
	//m_ctrlRadioSet[2] = (CButton*)/*m_ctrlRadioColorCtrl[2].*/GetDlgItem(IDC_RADIO_ZOOM_LEVEL_2);
	//m_ctrlRadioSet[3] = (CButton*)/*m_ctrlRadioColorCtrl[3].*/GetDlgItem(IDC_RADIO_ZOOM_LEVEL_3);
	//m_ctrlRadioSet[4] = (CButton*)/*m_ctrlRadioColorCtrl[4].*/GetDlgItem(IDC_RADIO_ZOOM_LEVEL_4);

	m_ctrlUseWSICon = m_ctrlButtonColorCtrl.GetDlgItem(IDC_CHECK_USE_WSI_CONTROL);
	SelectOffSetOn = m_ctrlButtonColorCtrl.GetDlgItem(IDC_SELECT_OFFSET_ON);
	m_ctrlUserSimulation = m_ctrlButtonColorCtrl.GetDlgItem(IDC_CHECK_USE_SIMULATION);


	CString tmp;
	tmp.Format(_T("%d%%"), m_ctrlSliderJogSpeed.GetPos());

	SetDlgItemText(IDC_STATIC_JOG_SPEED, tmp);

	tmp.Format(_T("%d%%"), m_ctrlLightLevel.GetPos());

	SetDlgItemText(IDC_STATIC_LIGHT_LEVEL, tmp);

	(GetDlgItem(IDC_KEY_JOG_MOVE))->ShowWindow(FALSE);
	m_ctrlKeyMoveJog.SetFontStatic(strFont, 15, RGB(0,0,0), FS_CENTER);
	m_ctrlKeyMoveJog.SetBackground(RGB(240,240,240));
	m_ctrlKeyMoveJog.SetWindowText(_T("Key Jog시작"));

	KeyboardCommandMode = new CDlgKeyJogLogin;
	
	return FALSE;  // return TRUE unless you set the focus to a control
	// 예외: OCX 속성 페이지는 FALSE를 반환해야 합니다.
}

void CDlgControl::OnNMReleasedcaptureSliderJogSpeed(NMHDR *pNMHDR, LRESULT *pResult)
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	if (m_pDC2P==NULL) return;

	double dValue = double(m_ctrlSliderJogSpeed.GetPos()) / 100.0;

	m_pDC2P->DC2P_JogSpeed(dValue);

	*pResult = 0;
}

BOOL CDlgControl::PreTranslateMessage(MSG* pMsg)
{
	if(m_bCheckKeyJog)
	{
		m_ctrlKeyMoveJog.SetFocus();
		KeyboardXYJogMove(pMsg);
		return __super::PreTranslateMessage(pMsg);
	}

	if (m_nJogDown != -1)
	{
		CRect rtRect;
		m_ctrlJogCommand[m_nJogDown].GetWindowRect(rtRect);

		if(!rtRect.PtInRect(pMsg->pt))
		{
			m_ctrlJogCommand[m_nJogDown].SetBackground(RGB(80,80,80));
			m_pDC2P->DC2P_JogCommand(m_nModuleIndex, m_nJogDown, 0);
			m_nJogDown = -1;
		}
	}

	if( pMsg->message == WM_CHAR )
	{
		if(pMsg->wParam == VK_RETURN || pMsg->wParam == VK_ESCAPE )
		{
			::TranslateMessage(pMsg);
			::DispatchMessage(pMsg);
			return TRUE;
		}
	}

	if( pMsg->message!=WM_LBUTTONDOWN && pMsg->message!=WM_LBUTTONUP)
	{
		return CDialog::PreTranslateMessage(pMsg);
	}

	if (m_pDC2P==NULL) 
	{
		return CDialog::PreTranslateMessage(pMsg);
	}


	for (int nIdx=0; nIdx<JogCommand_Count; nIdx++)
	{
		CRect rtRect;
		m_ctrlJogCommand[nIdx].GetWindowRect(rtRect);

		if(rtRect.PtInRect(pMsg->pt))
		{
			if(pMsg->message == WM_LBUTTONDOWN)
			{
				m_ctrlJogCommand[nIdx].SetBackground(RGB(0,255,0));
				m_pDC2P->DC2P_JogCommand(m_nModuleIndex, nIdx, 1);
				m_nJogDown = nIdx;
			}
			else if(pMsg->message == WM_LBUTTONUP)
			{
				m_ctrlJogCommand[nIdx].SetBackground(RGB(80,80,80));
				m_pDC2P->DC2P_JogCommand(m_nModuleIndex, nIdx, 0);
			}

			m_ctrlJogCommand[nIdx].Invalidate(TRUE);

			return __super::PreTranslateMessage(pMsg);
		}

		m_ctrlJogCommand[nIdx].SetBackground(RGB(80,80,80));
		m_ctrlJogCommand[nIdx].Invalidate(TRUE);
	}

	CRect rtJogUp;
	m_ctrlJogUp->GetWindowRect(rtJogUp);
	if(rtJogUp.PtInRect(pMsg->pt))
	{
		if(pMsg->message == WM_LBUTTONDOWN)
		{
			m_pDC2P->DC2P_SetJogCommand(m_nModuleIndex, 1); 
		}

		if (pMsg->message == WM_LBUTTONUP)
		{
			m_pDC2P->DC2P_SetJogCommand(m_nModuleIndex, 0);
		}
	}

	CRect rtJogDown;
	m_ctrlJogDown->GetWindowRect(rtJogDown);
	if(rtJogDown.PtInRect(pMsg->pt))
	{		
		if(pMsg->message == WM_LBUTTONDOWN)
		{
			m_pDC2P->DC2P_SetJogCommand(m_nModuleIndex, 2);
		}

		if (pMsg->message == WM_LBUTTONUP)
		{
			m_pDC2P->DC2P_SetJogCommand(m_nModuleIndex, 0);
		}
	}
	return CDialog::PreTranslateMessage(pMsg);
}

void CDlgControl::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
	// TODO: 여기에 메시지 처리기 코드를 추가 및/또는 기본값을 호출합니다.

	CDialog::OnHScroll(nSBCode, nPos, pScrollBar);

	CString tmp;
	tmp.Format(_T("%d%%"), m_ctrlSliderJogSpeed.GetPos());

	SetDlgItemText(IDC_STATIC_JOG_SPEED, tmp);

	tmp.Format(_T("%d%%"), m_ctrlLightLevel.GetPos());

	SetDlgItemText(IDC_STATIC_LIGHT_LEVEL, tmp);	
}

void CDlgControl::OnNMReleasedcaptureSliderLightLevel(NMHDR *pNMHDR, LRESULT *pResult)
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	if (m_pDC2P==NULL) return;

	CModuleStatus* pModuleStatus = m_pDC2P->DC2P_Get_Selected_module_Status();
	if(pModuleStatus == NULL) return ;

	SCameraControl* pCameraControl = pModuleStatus->GetCameraControl();
	if(pCameraControl == NULL) return ;

	int nLightLevelMax = pCameraControl->nLightLevelMax;
	int nLightLevelMin = pCameraControl->nLightLevelMin;
	int CalculateLightLevel = (nLightLevelMax - nLightLevelMin) * m_ctrlLightLevel.GetPos() / 100 + nLightLevelMin; 

	m_pDC2P->DC2P_SetLightLevel(m_nModuleIndex, CalculateLightLevel);

	this->PostMessage(UM_LIGHT_LEVEL_UPDATE);

	*pResult = 0;
}

void CDlgControl::OnBnClickedCheckCameraControl()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	if (m_pDC2P==NULL) return;
	if (m_pCtrlCameraControl->GetCheck()) 
	{
		m_pDC2P->DC2P_SetCameraControl(m_nModuleIndex, CameraControlLive);
		
	}
	else
	{
		m_pDC2P->DC2P_SetCameraControl(m_nModuleIndex, CameraControlStop);
	}
}

LRESULT	CDlgControl::OnCameraStatusUpdate(WPARAM wParam, LPARAM lParam)
{
	//	if (m_pCameraControl==NULL) return 0;		
	SCameraControl* pCameraControl = (SCameraControl*)lParam;
	if(pCameraControl == NULL) return 0;

	CModuleStatus* pModueStatus = m_pDC2P->DC2P_Get_Selected_module_Status();
	if(pCameraControl->nCameraControl==CameraControlStop)
	{
		m_pCtrlCameraControl->SetWindowText(_T("Stop"));
		m_pCtrlCameraControl->SetCheck(FALSE);
	}
	else
	{
		m_pCtrlCameraControl->SetWindowText(_T("Grab"));
		m_pCtrlCameraControl->SetCheck(TRUE);
	}

	if (pCameraControl->bAFMTracking)
	{
		m_ctrlAFMTracking->SetWindowText(_T("Tracking"));
		m_ctrlAFMTracking->SetCheck(TRUE);
	}
	else
	{
		m_ctrlAFMTracking->SetWindowText(_T("Stop"));
		m_ctrlAFMTracking->SetCheck(FALSE);
	}

	int nLightLevelMax = pCameraControl->nLightLevelMax;
	int nLightLevelMin = pCameraControl->nLightLevelMin;
	int CalculateLightLevel = ((pCameraControl->nLightLevel - nLightLevelMin) * 100) / (nLightLevelMax - nLightLevelMin); 

	m_ctrlLightLevel.SetPos(CalculateLightLevel);

	CString tmp;
	tmp.Format(_T("%d%%"), m_ctrlLightLevel.GetPos());
	SetDlgItemText(IDC_STATIC_LIGHT_LEVEL, tmp);

	for (int i=0; i<5; i++)
	{
		if (pCameraControl->nZoomLevel==i)
		{
			m_ctrlRadioSet[i].SetCheck(1);
		}
		else
		{
			m_ctrlRadioSet[i].SetCheck(0);
		}
	}

	UpdateData(FALSE);

	return 1;
}

void CDlgControl::UpdateCameraControl(int nModuleIndex, const SCameraControl* pCameraControl, const SCameraInfo* pCameraInfo)
{
	if (pCameraControl==NULL) return;

	if (m_nModuleIndex!=nModuleIndex) return;

	this->PostMessage(UM_CAMERA_STATUS_UPDATE, (WPARAM) nModuleIndex, (LPARAM) pCameraControl);
}

void CDlgControl::OnBnClickedRadioZoomLevel()
{
	if (m_pDC2P==NULL) return;

	//UpdateData(TRUE);

	int nZoomLevel = -1;
	for (int i=0; i<5; i++)
	{
		if (m_ctrlRadioSet[i].GetCheck())
		{
			nZoomLevel = i;
			break;
		}
	}
	for (int i = 0; i < 5; i++)
	{
		m_ctrlRadioSet[i].EnableWindow(FALSE);
	}
	SetTimer(ID_TIMER_DISABLE_MAG_BUTTON, 1000, NULL);

	m_pDC2P->DC2P_SetZoomLevel(m_nModuleIndex, nZoomLevel);

	m_pDC2P->DC2P_SetSelectedCamera(m_nModuleIndex, nZoomLevel);
}

void CDlgControl::InitGridCameraPos()
{
	enum { POS_GRID_ROW_COUNT = 1, POS_GRID_COL_COUNT = 2 };

	int nRowIdx, nColIdx, nRows, nCols;
	CString strTemp = _T("");
	CRect rt;

	nRows = POS_GRID_ROW_COUNT;
	nCols = POS_GRID_COL_COUNT;
	m_ctrlMotorPos.GetClientRect(&rt);
	m_ctrlMotorPos.GetDefaultCell(TRUE, FALSE)->SetBackClr(RGB(180, 210, 247));
	m_ctrlMotorPos.GetDefaultCell(FALSE, TRUE)->SetBackClr(RGB(180, 210, 247));;
	m_ctrlMotorPos.GetDefaultCell(FALSE, FALSE)->SetBackClr(RGB(255, 255, 255));
	m_ctrlMotorPos.SetRowCount(nRows);
	m_ctrlMotorPos.SetColumnCount(nCols);
	m_ctrlMotorPos.SetFixedRowCount(0);
	m_ctrlMotorPos.SetFixedColumnCount(0);

	m_ctrlMotorPos.SetColumnWidth(0, rt.Width()/2);
	m_ctrlMotorPos.SetColumnWidth(1, rt.Width()/2);

	m_ctrlGlassPos.GetClientRect(&rt);
	m_ctrlGlassPos.GetDefaultCell(TRUE, FALSE)->SetBackClr(RGB(180, 210, 247));
	m_ctrlGlassPos.GetDefaultCell(FALSE, TRUE)->SetBackClr(RGB(180, 210, 247));;
	m_ctrlGlassPos.GetDefaultCell(FALSE, FALSE)->SetBackClr(RGB(255, 255, 255));
	m_ctrlGlassPos.SetRowCount(nRows);
	m_ctrlGlassPos.SetColumnCount(nCols);
	m_ctrlGlassPos.SetFixedRowCount(0);
	m_ctrlGlassPos.SetFixedColumnCount(0);

	m_ctrlGlassPos.SetColumnWidth(0, rt.Width()/2);
	m_ctrlGlassPos.SetColumnWidth(1, rt.Width()/2);

	m_ctrlGlassCenterPos.GetClientRect(&rt);
	m_ctrlGlassCenterPos.GetDefaultCell(TRUE, FALSE)->SetBackClr(RGB(180, 210, 247));
	m_ctrlGlassCenterPos.GetDefaultCell(FALSE, TRUE)->SetBackClr(RGB(180, 210, 247));;
	m_ctrlGlassCenterPos.GetDefaultCell(FALSE, FALSE)->SetBackClr(RGB(255, 255, 255));
	m_ctrlGlassCenterPos.SetRowCount(nRows);
	m_ctrlGlassCenterPos.SetColumnCount(nCols);
	m_ctrlGlassCenterPos.SetFixedRowCount(0);
	m_ctrlGlassCenterPos.SetFixedColumnCount(0);

	m_ctrlGlassCenterPos.SetColumnWidth(0, rt.Width()/2);
	m_ctrlGlassCenterPos.SetColumnWidth(1, rt.Width()/2);


	GV_ITEM Item;

	nRowIdx = 0;
	nColIdx = 0;

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

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


	nRowIdx = 0;
	nColIdx = 0;

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

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

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

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

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

	//CDialog::OnCancel();
}

void CDlgControl::OnBnClickedButtonMotorGoXy()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	CString strValue = m_ctrlMotorPos.GetItemText(0, 0);
	if (strValue.GetLength()<1) return;
	m_dGoPosX = _tcstod(strValue, NULL);

	strValue = m_ctrlMotorPos.GetItemText(0, 1);
	if (strValue.GetLength()<1) return;
	m_dGoPosY = _tcstod(strValue, NULL);

	if (m_pDC2P)
	{		
		m_pDC2P->DC2P_MoveCommand(m_nModuleIndex, MOVE_CMD_X+MOVE_CMD_Y, m_dGoPosX, m_dGoPosY, 0);
	}
}

void CDlgControl::OnBnClickedButtonGlassGoXy()
{
	if (m_pDC2P==NULL) return;

	CString strValue = m_ctrlGlassPos.GetItemText(0, 0);
	if (strValue.GetLength()<1) return;
	m_dGoPosX = _tcstod(strValue, NULL);

	strValue = m_ctrlGlassPos.GetItemText(0, 1);
	if (strValue.GetLength()<1) return;
	m_dGoPosY = _tcstod(strValue, NULL);

	m_pDC2P->DC2P_SetCameraGo(m_nModuleIndex, m_nMoveAxis, m_dGoPosX, m_dGoPosY);
}



void CDlgControl::OnBnClickedButtonGlasscenterGoXy()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	if (m_pDC2P==NULL) return;
	
	CString strValue = m_ctrlGlassCenterPos.GetItemText(0, 0);
	if (strValue.GetLength()<1) return;
	m_dGoPosX = _tcstod(strValue, NULL);

	strValue = m_ctrlGlassCenterPos.GetItemText(0, 1);
	if (strValue.GetLength()<1) return;
	m_dGoPosY = _tcstod(strValue, NULL);

	m_pDC2P->DC2P_SetCameraCenterGo(m_nModuleIndex, m_nMoveAxis, m_dGoPosX, m_dGoPosY);
}

void CDlgControl::OnBnClickedCheckAfmTrack()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	if (m_pDC2P==NULL) return;

	m_ctrlAFMTracking->EnableWindow(FALSE);
	SetTimer(ID_TIMER_DISABLE_AF_TRACKING_BUTTON, 1000, NULL);

	m_pDC2P->DC2P_SetAFMTracking(m_nModuleIndex, m_ctrlAFMTracking->GetCheck());

	this->PostMessage(UM_AFM_LEVEL_UPDATE);
}

void CDlgControl::SetModuleIndex(int nModuleIndex)
{
	m_nModuleIndex = nModuleIndex;

	CModuleStatus* pModuleStatus = m_pDC2P->DC2P_Get_Selected_module_Status();
	if(pModuleStatus == NULL) return ;

	pModuleStatus->GetCameraControl();

	VectorSMagnificInfo* pvMagnificInfo = pModuleStatus->GetVectorSMagnificInfo();
	if(pvMagnificInfo == NULL) return ;

	for(int i = 0; i < 5; i++)
	{
		if(i < pvMagnificInfo->size())		
		{
			m_ctrlRadioSet[i].SetWindowText(pvMagnificInfo->at(i).strMagnificName);
			m_ctrlRadioSet[i].ShowWindow(SW_SHOW);
		}
		else
		{
			m_ctrlRadioSet[i].ShowWindow(SW_HIDE);
		}
	}
}

void CDlgControl::UpdateSelectedModuleIndex(int nModuleIndex, const CModuleStatus* pModuleStatus)
{
	if (pModuleStatus==NULL) return;

	this->PostMessage(UM_SELECTED_MODULE_INDEX_UPDATE, (WPARAM) nModuleIndex, (LPARAM) pModuleStatus);
}

LRESULT CDlgControl::OnUpdateSelectedModuleIndex(WPARAM wParam, LPARAM lParam)
{
	int nModuleIndex = (int)wParam;
	const CModuleStatus* pModuleStatus = (const CModuleStatus*)lParam;

	if (nModuleIndex<0) return 0;
	if(pModuleStatus == NULL) return 0;

	m_nModuleIndex = nModuleIndex;

	const SCameraControl *pCameraControl = pModuleStatus->GetCameraControl();
	if(pCameraControl == NULL) return 0;

	int nMagIdx = 0;
	for(nMagIdx = 0; nMagIdx < pModuleStatus->GetMagnificInfoCount(); nMagIdx++)
	{
		const SMagnificInfo *pMagInfo = pModuleStatus->GetMagnificInfo(nMagIdx);
		m_ctrlRadioSet[nMagIdx].SetWindowText(pMagInfo->strMagnificName);
		m_ctrlRadioSet[nMagIdx].ShowWindow(SW_SHOW);

		if (pCameraControl->nZoomLevel==nMagIdx)
		{
			m_ctrlRadioSet[nMagIdx].SetCheck(1);
		}
		else
		{
			m_ctrlRadioSet[nMagIdx].SetCheck(0);
		}
	}

	for (; nMagIdx<5; nMagIdx++)
	{
		m_ctrlRadioSet[nMagIdx].ShowWindow(SW_HIDE);
	}	

	if(pCameraControl->nCameraControl==CameraControlStop)
	{
		m_pCtrlCameraControl->SetWindowText(_T("Stop"));
		m_pCtrlCameraControl->SetCheck(FALSE);
	}
	else
	{
		m_pCtrlCameraControl->SetWindowText(_T("Grab"));
		m_pCtrlCameraControl->SetCheck(TRUE);
	}

	if (pCameraControl->bAFMTracking)
	{
		m_ctrlAFMTracking->SetWindowText(_T("Tracking"));
		m_ctrlAFMTracking->SetCheck(TRUE);
	}
	else
	{
		m_ctrlAFMTracking->SetWindowText(_T("Stop"));
		m_ctrlAFMTracking->SetCheck(FALSE);
	}

	int nLightLevelMax = pCameraControl->nLightLevelMax;
	int nLightLevelMin = pCameraControl->nLightLevelMin;
	int CalculateLightLevel = ((pCameraControl->nLightLevel - nLightLevelMin) * 100) / (nLightLevelMax - nLightLevelMin); 

	m_ctrlLightLevel.SetPos(CalculateLightLevel);

	CString tmp;
	tmp.Format(_T("%d%%"), m_ctrlLightLevel.GetPos());
	SetDlgItemText(IDC_STATIC_LIGHT_LEVEL, tmp);

	return 1;
}

void CDlgControl::OnTimer(UINT_PTR nIDEvent)
{
	// TODO: 여기에 메시지 처리기 코드를 추가 및/또는 기본값을 호출합니다.
	KillTimer(nIDEvent);

	switch (nIDEvent)
	{
	case ID_TIMER_DISABLE_MAG_BUTTON:
		for (int i = 0; i < 5; i++)
		{
			m_ctrlRadioSet[i].EnableWindow(TRUE);
		}
		break;
	case ID_TIMER_DISABLE_AF_TRACKING_BUTTON:
		m_ctrlAFMTracking->EnableWindow(TRUE);
		break;
	}

	__super::OnTimer(nIDEvent);
}

void CDlgControl::OnBnClickedButtonTest2()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	// wsi test code : glass position
	m_pDC2P->IRP2P_GetSequenceProcessor()->TestStartWsi();
}

void CDlgControl::OnBnClickedUseKeyboardCommand()
{
	if(m_bCheckKeyJog == FALSE)
	{
		KeyboardCommandMode->DoModal();

		if(!KeyboardCommandMode->GetLoginSuccess())
			return;

		m_bCheckKeyJog = TRUE;
		m_bMoveKeyJogCheck = TRUE;

 		m_ctrlKeyMoveJog.SetWindowText(_T("Key Jog중지"));
 		m_ctrlKeyMoveJog.SetBackground(RGB(255,0,0));
 		m_ctrlKeyMoveJog.SetFontStatic(_T("MS Sans Serif"), 15, RGB(255,255,255), FS_CENTER);

		m_ctrlSliderJogSpeed.SetPos(1);

		double dValue = double(m_ctrlSliderJogSpeed.GetPos()) / 100.0;

		m_pDC2P->DC2P_JogSpeed(dValue);

		CString tmp;
		tmp.Format(_T("%d%%"), m_ctrlSliderJogSpeed.GetPos());

		SetDlgItemText(IDC_STATIC_JOG_SPEED, tmp);

		GetDlgItem( IDC_GRID_MOTOR_POS )->EnableWindow(FALSE);
		GetDlgItem( IDC_GRID_GLASS_POS )->EnableWindow(FALSE);
		GetDlgItem( IDC_GRID_GLASSCENTER_POS)->EnableWindow(FALSE);

	}
	else
	{
		m_bCheckKeyJog = FALSE;

		m_ctrlKeyMoveJog.SetWindowText(_T("Key Jog시작"));
		m_ctrlKeyMoveJog.SetBackground(RGB(240,240,240));
		m_ctrlKeyMoveJog.SetFontStatic(_T("MS Sans Serif"), 15, RGB(0,0,0), FS_CENTER);

		for (int i = 0; i<JogCommand_Count; i++)
		{
			m_pDC2P->DC2P_JogCommand(m_nModuleIndex, i, 0);
			m_ctrlJogCommand[i].SetBackground(RGB(240,240,240));
		}

		GetDlgItem( IDC_GRID_MOTOR_POS )->EnableWindow(TRUE);
		GetDlgItem( IDC_GRID_GLASS_POS )->EnableWindow(TRUE);
		GetDlgItem( IDC_GRID_GLASSCENTER_POS)->EnableWindow(TRUE);
	}


}

void CDlgControl::KeyboardXYJogMove(MSG* pMsg)
{

	switch(pMsg->wParam)
	{
	case VK_LEFT: 
		m_nKeyBoardCommand = 0;
		break;
	case VK_RIGHT:
		m_nKeyBoardCommand = 1;
		break;
	case VK_UP: 
		m_nKeyBoardCommand = 2;
		break;
	case VK_DOWN: 
		m_nKeyBoardCommand = 3;
		break;
	case VK_INSERT:
		//KeyboardAFMJogMove(1);
		m_nKeyBoardCommand = 4;
		break;
	case VK_DELETE:
		//KeyboardAFMJogMove(2);
		m_nKeyBoardCommand = 5;
		break;
	case VK_ESCAPE:
		m_bMoveKeyJogCheck = TRUE;
		OnBnClickedUseKeyboardCommand();
		return;
	default:
		m_nKeyBoardCommand = -1;
		break;
	}

	if(pMsg->message == WM_KEYDOWN && m_bMoveKeyJogCheck == TRUE && m_nKeyBoardCommand != -1)
	{
		switch(pMsg->wParam)
		{
		case VK_INSERT:
			KeyboardAFMJogMove(1);
			break;
		case VK_DELETE:
			KeyboardAFMJogMove(2);
			break;
		}
		m_ctrlJogCommand[m_nKeyBoardCommand].SetBackground(RGB(0,255,0));
		m_pDC2P->DC2P_JogCommand(m_nModuleIndex, m_nKeyBoardCommand, 1);
		m_bMoveKeyJogCheck = FALSE;
		m_nKeyJogDownIndex = m_nKeyBoardCommand;
		m_ctrlJogCommand[m_nKeyBoardCommand].Invalidate(TRUE);
	}
	if(pMsg->message == WM_KEYUP && m_bMoveKeyJogCheck == FALSE && m_nKeyBoardCommand != -1)
	{
		Sleep(33);
		if(m_nKeyJogDownIndex != m_nKeyBoardCommand)
			return;

		m_ctrlJogCommand[m_nKeyBoardCommand].SetBackground(RGB(80,80,80));
		m_pDC2P->DC2P_JogCommand(m_nModuleIndex, m_nKeyBoardCommand, 0);
		m_bMoveKeyJogCheck = TRUE;
		m_ctrlJogCommand[m_nKeyBoardCommand].Invalidate(TRUE);
	}

	if(!m_bMoveKeyJogCheck)
		return;

	if(pMsg->message == WM_KEYUP)
	{
		KeyboardGlassXYInput(pMsg);

		switch(pMsg->wParam)
		{
		case VK_PRIOR:
			KeyboardMotionSpeedChange(TRUE);
			break;
		case VK_NEXT:
			KeyboardMotionSpeedChange(FALSE);
			break;
		case VK_HOME:
			KeyboardLightValueChange(TRUE);
			break;
		case VK_END:
			KeyboardLightValueChange(FALSE);
			break;
		case VK_INSERT:
		case VK_DELETE:
			KeyboardAFMJogMove(0);
			break;
		case VK_F1:
			m_pDC2P->DC2P_SetCameraGo(m_nModuleIndex, m_nMoveAxis, 8.0, 8.0);
			break;
		case VK_F2:
			m_pDC2P->DC2P_SetCameraGo(m_nModuleIndex, m_nMoveAxis, 1492, 8.0);
			break;
		case VK_F3:
			m_pDC2P->DC2P_SetCameraGo(m_nModuleIndex, m_nMoveAxis, 1492, 917);
			break;
		case VK_F4:
			m_pDC2P->DC2P_SetCameraGo(m_nModuleIndex, m_nMoveAxis, 8.0, 917);
			break;
		case 0x31:
			KeyboardpvMagnificChange(0);
			break;
		case 0x32:
			KeyboardpvMagnificChange(1);
			break;
		case 0x33:
			KeyboardpvMagnificChange(2);
			break;
		case 0x34:
			KeyboardpvMagnificChange(3);
			break;
		case 0x35:
			KeyboardpvMagnificChange(4);
			break;
		}
	}

}

void CDlgControl::KeyboardpvMagnificChange(int Magidx)
{
	if(!m_ctrlRadioSet[Magidx].IsWindowEnabled())
		return;

	CModuleStatus* pModuleStatus = m_pDC2P->DC2P_Get_Selected_module_Status();
	if(pModuleStatus == NULL) return ;

	VectorSMagnificInfo* pvMagnificInfo = pModuleStatus->GetVectorSMagnificInfo();
	if(pvMagnificInfo == NULL) return ;

	if(pvMagnificInfo->size() < (Magidx +1))
		return;

	for (int i = 0; i < 5; i++)
	{
		if(i == Magidx)
			m_ctrlRadioSet[i].SetCheck(1);
		else
			m_ctrlRadioSet[i].SetCheck(0);
	}

	OnBnClickedRadioZoomLevel();
}

void CDlgControl::KeyboardMotionSpeedChange(BOOL flag)
{
	Sleep(100);
	if (m_pDC2P==NULL) return;

	int temp = m_ctrlSliderJogSpeed.GetPos();

	if(flag)
		temp++;
	else
		temp--;

	if(temp == 101 || temp == -1)
		return;

	m_ctrlSliderJogSpeed.SetPos(temp);

	double dValue = double(m_ctrlSliderJogSpeed.GetPos()) / 100.0;

	m_pDC2P->DC2P_JogSpeed(dValue);

	CString tmp;
	tmp.Format(_T("%d%%"), m_ctrlSliderJogSpeed.GetPos());

	SetDlgItemText(IDC_STATIC_JOG_SPEED, tmp);
}

void CDlgControl::KeyboardLightValueChange(BOOL flag)
{
	Sleep(100);
	if (m_pDC2P==NULL) return;

	CModuleStatus* pModuleStatus = m_pDC2P->DC2P_Get_Selected_module_Status();
	if(pModuleStatus == NULL) return ;

	SCameraControl* pCameraControl = pModuleStatus->GetCameraControl();
	if(pCameraControl == NULL) return ;

	int nLightLevelMax = pCameraControl->nLightLevelMax;
	int nLightLevelMin = pCameraControl->nLightLevelMin;

	int temp = m_ctrlLightLevel.GetPos();

	if(flag)
		temp = temp + 2;
	else
		temp--;

	if(temp == 101 || temp == -1)
		return;

	m_ctrlLightLevel.SetPos(temp);

	CString tmp;
	tmp.Format(_T("%d%%"), m_ctrlLightLevel.GetPos());

	SetDlgItemText(IDC_STATIC_LIGHT_LEVEL, tmp);

	int CalculateLightLevel = (nLightLevelMax - nLightLevelMin) * m_ctrlLightLevel.GetPos() / 100 + nLightLevelMin; 

	m_pDC2P->DC2P_SetLightLevel(m_nModuleIndex, CalculateLightLevel);

	this->PostMessage(UM_LIGHT_LEVEL_UPDATE);
}

void CDlgControl::KeyboardAFMJogMove(int flag)
{
	Sleep(33);
	m_pDC2P->DC2P_SetJogCommand(m_nModuleIndex, flag); 
}

void CDlgControl::KeyboardGlassXYInput(MSG* pMsg)
{
	char num = NULL;
	switch(pMsg->wParam)
	{
	case VK_NUMPAD0: num = '0';
		break;
	case VK_NUMPAD1: num = '1';
		break;
	case VK_NUMPAD2: num = '2';
		break;
	case VK_NUMPAD3: num = '3';
		break;
	case VK_NUMPAD4: num = '4';
		break;
	case VK_NUMPAD5: num = '5';
		break;
	case VK_NUMPAD6: num = '6';
		break;
	case VK_NUMPAD7: num = '7';
		break;
	case VK_NUMPAD8: num = '8';
		break;
	case VK_NUMPAD9: num = '9';
		break;
	case VK_DECIMAL: num = '.';
		break;
	case VK_BACK:
		{
			CString strValue = m_ctrlGlassPos.GetItemText(0, m_nGlassGridViewIndex);
			strValue.Delete(strValue.GetLength()-1, 1);

			m_strGlassPos = strValue;
		}
		break;
	case VK_TAB:
		{
			if(m_nGlassGridViewIndex == 0)
				m_nGlassGridViewIndex = 1;
			else
				m_nGlassGridViewIndex = 0;

			m_strGlassPos = m_ctrlGlassPos.GetItemText(0, m_nGlassGridViewIndex);
		}

		break;
	case VK_SPACE:
		OnBnClickedButtonGlassGoXy();
		m_nGlassGridViewIndex = 0;
		break;
	}
	if(num != NULL)
		m_strGlassPos.AppendChar(num);

	m_ctrlGlassPos.SetItemText(0, m_nGlassGridViewIndex, m_strGlassPos);
	m_ctrlGlassPos.Invalidate(TRUE);
}

void CDlgControl::OnBnClickedButtonUiExpand() // UI 확장
{
	CMainFrame* pMain = (CMainFrame*)(AfxGetApp()->GetMainWnd());

	CRect rt;
	CString str;
	pMain->GetWindowRect(&rt);
	m_chekreduce->GetWindowText(str);
	//m_chekreduce.GetWindowText(str);
	if( str=="Reduce")
	{
		m_chekreduce->SetWindowText( _T("Expand") );

		pMain->MoveWindow( rt.left, rt.top, rt.left+(TOTAL_WINDOW_SIZE_X-CMD_WINDOW_SIZE_X), rt.Height() );	// Move Window
		OnBnClickedButtonUiRight1();
	}
	else
	{
		m_chekreduce->SetWindowText( _T("Reduce") );

		pMain->MoveWindow( m_rtOriginal.left, m_rtOriginal.top, TOTAL_TWO_MONITOR_WINDOW_SIZE_X, TOTAL_TWO_MONITOR_WINDOW_SIZE_Y );	// Move Window
	}
}

//void CDlgControl::OnBnClickedButtonUiCenter()
//{
//	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
//	MoveMainWindow( MonitorPos_CENTER );
//}


void CDlgControl::MoveMainWindow( int nIdx )
{	
	CMainFrame* pMain = (CMainFrame*)(AfxGetApp()->GetMainWnd());

	int nMonitorCount = GetSystemMetrics(80 /*SM_CMONITORS*/);			// Get Monitor Count.
	int nXResolution  = GetSystemMetrics( SM_CXSCREEN );

	int nWidth	= 0; 
	int nHeight = 0;

	CRect rt;
	pMain->GetWindowRect(&rt);

	int nXpoint = 0;
	int nYpoint = 0;
	CString str;
	m_chekreduce->GetWindowText(str);
	//m_chekreduce.GetWindowText(str);
	if( str=="Expand")
	{
		nWidth = (TOTAL_WINDOW_SIZE_X-CMD_WINDOW_SIZE_X); 
		nHeight = TOTAL_TWO_MONITOR_WINDOW_SIZE_Y;

		switch (nIdx)
		{		
		case MonitorPos_LEFT:
			{
				if( rt.left == 0 )
					return;

				nXpoint = 0; nYpoint = 0;
			}			
			break;
		case MonitorPos_CENTER:
			{
				nXpoint = (nXResolution-nWidth)/2; nYpoint = 0;
			}
			break;
		case MonitorPos_RIGHT:
			{
				if( rt.left >= nXResolution - nWidth - 1 )
					return;

				nXpoint = nXResolution - nWidth; nYpoint = 0;
			}
			break;
		}

		::MoveWindow( pMain->m_hWnd, nXpoint, nYpoint, nWidth, nHeight, TRUE );	// Move Window
	}	
}


void CDlgControl::OnBnClickedButtonUiLeft()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	MoveMainWindow( MonitorPos_LEFT );
}



//void CDlgControl::OnBnClickedButtonUiRight()
//{
//	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다
//	MoveMainWindow( MonitorPos_RIGHT );
//}


void CDlgControl::OnBnClickedButtonUiRight1()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	MoveMainWindow( MonitorPos_RIGHT );
}

//cmark
//181218
void CDlgControl::OnBnClickedCheckUseWsiControl()
{
	//각 Dlg 인자들을 가져오기 위해서 싱글톤 기법으로 구현 
	 CDlgDefectList* pDlgdfectlist = CDlgDefectList::GetInstance();


	 pDlgdfectlist->GetSDefecFilter()->bUseWSI= m_ctrlUseWSICon->GetCheck();

	CDlgDefectFilter* pDlgDefectfilter =CDlgDefectFilter::GetInstance();
	 if (pDlgDefectfilter->GetpDDF2P())
	 {

		 pDlgDefectfilter->GetpDDF2P()->DDF2P_SetDefectFilter(pDlgdfectlist->GetSDefecFilter());

	 }
	
	
}


void CDlgControl::OnBnClickedSelectOffsetOn()
{
	
	//m_ctrlOffsetOn.GetCheck();
	m_pDC2P->DC2P_SetOffSetOn();
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
}

CDlgControl* CDlgControl::GetInstance()//컨트롤
{

	if(pDlgContol == NULL){
	pDlgContol = new CDlgControl;

	}
	return pDlgContol;
}
CDlgControl* CDlgControl::pDlgContol;

BOOL CDlgControl::OnEraseBkgnd(CDC* pDC)
{
	// TODO: 여기에 메시지 처리기 코드를 추가 및/또는 기본값을 호출합니다.
	CRect	rect;
	GetClientRect(&rect);
	__super::OnEraseBkgnd(pDC);
	pDC->FillSolidRect(rect, RGB(38,38,38) );
	return TRUE;
}


HBRUSH CDlgControl::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));
		m_brushBk.DeleteObject();
		m_brushBk.CreateSolidBrush(RGB(38,38,38));
		hbr = m_brushBk;
	}
		
	/*if (pWnd->GetSafeHwnd() == GetDlgItem(IDC_RADIO_ZOOM_LEVEL_1)->GetSafeHwnd())
	{
			pDC->SetBkMode(TRANSPARENT);
			pDC->SetTextColor(RGB(255, 255, 255));
				return hbr; 
	}*/
	// TODO:  기본값이 적당하지 않으면 다른 브러시를 반환합니다.
	return hbr;
}


void CDlgControl::OnBnClickedBtReviewPopup()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	m_pDC2P->DC2P_ShowReviewPopUP();
}


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

	m_pDC2P->DC2P_SetSimulation();
		//각 Dlg 인자들을 가져오기 위해서 싱글톤 기법으로 구현 
	CDlgDefectList* pDlgdfectlist = CDlgDefectList::GetInstance();

	pDlgdfectlist->GetSDefecFilter()->bUseSimulation = m_ctrlUserSimulation->GetCheck();

	CDlgDefectFilter* pDlgDefectfilter = CDlgDefectFilter::GetInstance();
	if (pDlgDefectfilter->GetpDDF2P())
	{

		pDlgDefectfilter->GetpDDF2P()->DDF2P_SetDefectFilter(pDlgdfectlist->GetSDefecFilter());

	}
}


void CDlgControl::OnDblclkStaticMagnification()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	if ((GetDlgItem(IDC_CHECK_USE_SIMULATION))->IsWindowVisible())
	{
		(GetDlgItem(IDC_CHECK_USE_SIMULATION))->ShowWindow(SW_HIDE);
	}
	else
	{
		(GetDlgItem(IDC_CHECK_USE_SIMULATION))->ShowWindow(SW_SHOW);
	}
}

//#3561 CF AOI Review Align 카메라 끊김 현상 조치 ADD START
void CDlgControl::OnBnClickedButtonAligncamGrab()
{
	CSequenceProcessor* pSequenceProcessor = m_pDC2P->IRP2P_GetSequenceProcessor();
	if (pSequenceProcessor == NULL) return;
	if (m_bAlignCamGrab == FALSE)
	{
		pSequenceProcessor->AlignCamera_CameraControl(CameraControlLive);
		m_bAlignCamGrab = TRUE;
	}
	else
	{
		pSequenceProcessor->AlignCamera_CameraControl(CameraControlStop);
		m_bAlignCamGrab = FALSE;
	}
	
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
}
//#3561 CF AOI Review Align 카메라 끊김 현상 조치 ADD END