OTS/OTS_GB/OTSModel/Measure/DlgProgMgrInfo.cpp

// DlgProgMgrInfo.cpp : implementation 
//
#pragma once
#include "stdafx.h"
#include "OTSModel.h"
#include "DlgProgMgrInfo.h"
#include "OTSProgMgr.h"
#include "afxdialogex.h"
#include "DlgStageMgr.h"

namespace OTSMODEL {

	const int STAGE_LIST_NEED_FOUCS_NUM = 1;
	
	COTSProjMgrFilePtr ShowProgMgrEditDialog(OTS_SOFT_PACKAGE_ID a_nPackId, BOOL a_bInUse)
	{
		AFX_MANAGE_STATE(AfxGetStaticModuleState());

		LogInfoTrace(__FILE__, __LINE__, _T("ShowProgMgrEditDialog: load information form program manger file."));

		// load program manager file data
		COTSProgMgrParamFilePtr pMgrParamFile = COTSProgMgrParamFilePtr(new COTSProgMgrParamFile());
		pMgrParamFile = COTSProgMgr::LoadInfoFromProgMgrFile(a_nPackId);
		
		ASSERT(pMgrParamFile);
		if (pMgrParamFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("ShowProgMgrEditDialog: load information form program manger failded."));
			return nullptr;
		}

		// set program manager dialog data
		CDlgProgMgrInfo dlg;
		dlg.SetStageData(pMgrParamFile->GetStageData());
		dlg.SetGenParam(pMgrParamFile->GetGenParam());
		dlg.SetImageScanParam(pMgrParamFile->GetImageScanParam());
		dlg.SetImageProcParam(pMgrParamFile->GetImageProcParam());
		dlg.SetXRayParam(pMgrParamFile->GetXRayParam());
		dlg.SetPackId(a_nPackId);
		dlg.SetInUse(a_bInUse);
		// load stage data
		dlg.m_pStageFile->SetStageData(pMgrParamFile->GetStageData());
		dlg.m_pStageFile->SetInUse(a_bInUse);

		LogInfoTrace(__FILE__, __LINE__, _T("ShowProgMgrEditDialog: load working stage form stage file."));

		if (dlg.m_pStageFile->Load(a_nPackId))
		{
			dlg.m_pStageFile->SetModify();
		}
		else
		{
			LogErrorTrace(__FILE__, __LINE__, _T("ShowProgMgrEditDialog: load stage failded."));
			return nullptr;
		}

		//return the project manger file
		if (dlg.DoModal() == IDOK)
		{
			// there is stage
			if (dlg.m_pStageFile->GetStagesList().size() > 0)
			{

				LogInfoTrace(__FILE__, __LINE__, _T("ShowProgMgrEditDialog: create a new measure working file."));

				COTSProjMgrFilePtr pProjMgrFile = COTSProjMgrFilePtr(new COTSProjMgrFile());

				// system should have program manager file
				//pProjMgrFile->GetSystemValidationState(a_nPackId);

				if (pProjMgrFile->IsValid())
				{
					// return a valid new file
					CStagePtr pStage = CStagePtr(new CStage());
					pStage = dlg.m_pStageFile->GetWorkingStage();
					ASSERT(pStage);
					if (!pStage)
					{
						LogErrorTrace(__FILE__, __LINE__, _T("ShowProgMgrEditDialog: get working stage failed."));
						return nullptr;
					}

					LogInfoTrace(__FILE__, __LINE__, _T("ShowProgMgrEditDialog: set measure working file information with system file information."));

					pProjMgrFile->SetStage(pStage);
					pProjMgrFile->SetSEMStageData(pMgrParamFile->GetStageData());
					pProjMgrFile->SetGenParam(pMgrParamFile->GetGenParam());
					pProjMgrFile->SetImageScanParam(pMgrParamFile->GetImageScanParam());
					pProjMgrFile->SetImageProcParam(pMgrParamFile->GetImageProcParam());
					pProjMgrFile->SetXRayParam(pMgrParamFile->GetXRayParam());
					return pProjMgrFile;
				}
				else
				{
					LogErrorTrace(__FILE__, __LINE__, _T("ShowProgMgrEditDialog: there is no invalid system file"));
					return nullptr;
				}
			}
			else
			{
				LogErrorTrace(__FILE__, __LINE__, _T("ShowProgMgrEditDialog: there is no invalid stage file"));
				return nullptr;
			}
		}

		return nullptr;
	}
	// CDlgProgMgrInfo dialog
	IMPLEMENT_DYNAMIC(CDlgProgMgrInfo, CDialog)

	CDlgProgMgrInfo::CDlgProgMgrInfo(CWnd* pParent /*=NULL*/)
		: CDialog(IDD_PROG_MGR_INFO, pParent)
		, m_nComboXAxisDirection(0)
		, m_lEditXAxisStart(0)
		, m_lEditXAxisEnd(0)
		, m_nComboYAxisDirection(0)
		, m_lEditYAxisStart(0)
		, m_lEditYAxisEnd(0)
		, m_nEditScreenWidth(0)
		, m_sEditSampleAutoName(_T(""))
		, m_bCheckMeasSwitch(FALSE)
		, m_sEditParamFilePath(_T(""))
		, m_sEditParamFileName(_T(""))
		, m_sEditSTDLibPath(_T(""))
		, m_sEditSTDLibName(_T(""))
		, m_dEditAreaMax(0)
		, m_dEditAreaMin(0)
		, m_cEditBackMin(0)
		, m_cEditBackMax(0)
		, m_cEditPartMin(0)
		, m_cEditPartMax(0)
		, m_nComboSearchSpeed(0)
		, m_lEditSearchCount(0)
		, m_nComboSearchMode(0)
		, m_nComboAnalySpeed(0)
		, m_lEditAnalyCount(0)
		, m_nComboStopMode(0)
		, m_lEditStopTime(0)
		, m_lEditFieldNum(0)
		, m_lEditIncANum(0)
		, m_nComboFetchMode(0)
		, m_nComboScanSpeed(0)
		, m_nComboImageSize(0)
		, m_nComboStage(0)
	{
		// SEM stage data
		m_pStageData = CSEMStageDataPtr(new CSEMStageData());
		// soft pack id
		m_nPackId = OTS_SOFT_PACKAGE_ID::OTSIncA;
		// measure parameter file path
		m_sParamFileName = _T("");
		

		// general parameter
		m_pGenParam = COTSGeneralParametersPtr(new COTSGeneralParameters()) ;
		// image scan parameter
		m_pImageScanParam = COTSImageScanParamPtr(new COTSImageScanParam()) ;
		// image process parameter
		m_pImageProcParam = COTSImageProcessParamPtr(new COTSImageProcessParam()) ;
		// X-Ray parameter
		m_pXRayParam = COTSXRayParamPtr(new COTSXRayParam());
		// stage
		m_pStageFile = CStageFilePtr(new CStageFile());
		// flag if there is sample on the stage
		m_bInUse = FALSE;
	}

	CDlgProgMgrInfo::~CDlgProgMgrInfo()
	{
	}

	void CDlgProgMgrInfo::DoDataExchange(CDataExchange* pDX)
	{
		CDialog::DoDataExchange(pDX);
		DDX_Control(pDX, IDC_COMBO_XDIREC, m_ctrlComboXAxisDirection);
		DDX_CBIndex(pDX, IDC_COMBO_XDIREC, m_nComboXAxisDirection);
		DDV_MinMaxInt(pDX, m_nComboXAxisDirection, 0, 1);
		DDX_Control(pDX, IDC_EDIT_XSTART, m_ctrlEditXAxisStart);
		DDX_Text(pDX, IDC_EDIT_XSTART, m_lEditXAxisStart);
		DDX_Control(pDX, IDC_EDIT_XEND, m_ctrlEditXAxisEnd);
		DDX_Text(pDX, IDC_EDIT_XEND, m_lEditXAxisEnd);
		DDX_Control(pDX, IDC_COMBO_YDIRECT, m_ctrlComboYAxisDirection);
		DDX_CBIndex(pDX, IDC_COMBO_YDIRECT, m_nComboYAxisDirection);
		DDV_MinMaxInt(pDX, m_nComboYAxisDirection, 0, 1);
		DDX_Control(pDX, IDC_EDIT_YSTART, m_ctrlEditYAxisStart);
		DDX_Text(pDX, IDC_EDIT_YSTART, m_lEditYAxisStart);
		DDX_Control(pDX, IDC_EDIT_YEND, m_ctrlEditYAxiaEnd);
		DDX_Text(pDX, IDC_EDIT_YEND, m_lEditYAxisEnd);
		DDX_Control(pDX, IDC_EDIT_SCREENWIDTH, m_ctrlEditScreenWidth);
		DDX_Text(pDX, IDC_EDIT_SCREENWIDTH, m_nEditScreenWidth);
		DDV_MinMaxInt(pDX, m_nEditScreenWidth, 0, 10000);
		DDX_Control(pDX, IDC_EDIT_SAMPLENAME, m_ctrlEditSampleAutoName);
		DDX_Text(pDX, IDC_EDIT_SAMPLENAME, m_sEditSampleAutoName);
		DDV_MaxChars(pDX, m_sEditSampleAutoName, 20);
		DDX_Control(pDX, IDC_MEAS_SWITCH, m_ctrlCheckMeasSwitch);
		DDX_Check(pDX, IDC_MEAS_SWITCH, m_bCheckMeasSwitch);
		DDX_Control(pDX, IDC_EDIT_MEASUREPARAMPATH, m_ctrlEditParamFilePath);
		DDX_Text(pDX, IDC_EDIT_MEASUREPARAMPATH, m_sEditParamFilePath);
		DDX_Control(pDX, IDC_EDIT_MESA_PARAM_FILE, m_ctrlEditParamFileName);
		DDX_Text(pDX, IDC_EDIT_MESA_PARAM_FILE, m_sEditParamFileName);
		DDX_Control(pDX, IDC_EDIT_ANALYSESTDLIBPATH, m_ctrlEditSTDLibPath);
		DDX_Text(pDX, IDC_EDIT_ANALYSESTDLIBPATH, m_sEditSTDLibPath);
		DDX_Control(pDX, IDC_EDIT_STDLIBNAME, m_ctrlEditSTDLibName);
		DDX_Text(pDX, IDC_EDIT_STDLIBNAME, m_sEditSTDLibName);
		DDX_Control(pDX, IDC_EDIT_PARTAREAMIN, m_ctrlEditAreaMin);
		DDX_Control(pDX, IDC_EDIT_PARTAREAMAX, m_ctrlEditAreaMax);
		DDX_Text(pDX, IDC_EDIT_PARTAREAMAX, m_dEditAreaMax);
		DDX_Text(pDX, IDC_EDIT_PARTAREAMIN, m_dEditAreaMin);
		DDX_Control(pDX, IDC_EDIT_BACKMIN, m_ctrlEditBackMin);
		DDX_Text(pDX, IDC_EDIT_BACKMIN, m_cEditBackMin);
		DDX_Control(pDX, IDC_EDIT_BACKMAX, m_ctrlEditBackMax);
		DDX_Text(pDX, IDC_EDIT_BACKMAX, m_cEditBackMax);
		DDX_Text(pDX, IDC_EDIT_PARTMIN, m_cEditPartMin);
		DDX_Control(pDX, IDC_EDIT_PARTMIN, m_ctrlEditPatrMin);
		DDX_Control(pDX, IDC_EDIT_PARTMAX, m_ctrlEditPartMax);
		DDX_Text(pDX, IDC_EDIT_PARTMAX, m_cEditPartMax);
		DDX_Control(pDX, IDC_COMBO_SEARCHXRAYSPEED, m_ctrlComboSearchSpeed);
		DDX_CBIndex(pDX, IDC_COMBO_SEARCHXRAYSPEED, m_nComboSearchSpeed);
		DDX_Control(pDX, IDC_EDIT_SEARCHXRAYCOUNTLIMIT, m_ctrlEditSearchCount);
		DDX_Text(pDX, IDC_EDIT_SEARCHXRAYCOUNTLIMIT, m_lEditSearchCount);
		DDX_Control(pDX, IDC_COMBO_XRAYSCANMODE, m_ctrlComboSearchMode);
		DDX_CBIndex(pDX, IDC_COMBO_XRAYSCANMODE, m_nComboSearchMode);
		DDX_Control(pDX, IDC_COMBO_ANALYXRAYSPEED, m_ctrlComboAnalySpeed);
		DDX_CBIndex(pDX, IDC_COMBO_ANALYXRAYSPEED, m_nComboAnalySpeed);
		DDX_Control(pDX, IDC_EDIT_ANALYXRAYAIMVALUE, m_ctrlEditAnalyCount);
		DDX_Text(pDX, IDC_EDIT_ANALYXRAYAIMVALUE, m_lEditAnalyCount);
		DDX_Control(pDX, IDC_COMBO_STOPMODE, m_ctrlComboStopMode);
		DDX_CBIndex(pDX, IDC_COMBO_STOPMODE, m_nComboStopMode);
		DDX_Control(pDX, IDC_EDIT_STOP_TIME, m_ctrlEditStopTime);
		DDX_Text(pDX, IDC_EDIT_STOP_TIME, m_lEditStopTime);
		DDX_Control(pDX, IDC_EDIT_STOP_FIELD_NUM, m_ctrlEditFieldNum);
		DDX_Text(pDX, IDC_EDIT_STOP_FIELD_NUM, m_lEditFieldNum);
		DDX_Control(pDX, IDC_EDIT_STOP_INCA_NUM, m_ctrlEditIncANum);
		DDX_Text(pDX, IDC_EDIT_STOP_INCA_NUM, m_lEditIncANum);
		DDX_Control(pDX, IDC_COMBO_FETCHIMGMODE, m_ctrlComboFetchMode);
		DDX_CBIndex(pDX, IDC_COMBO_FETCHIMGMODE, m_nComboFetchMode);
		DDX_Control(pDX, IDC_COMBO_IMGSCANSPEED, m_ctrlComboScanSpeed);
		DDX_CBIndex(pDX, IDC_COMBO_IMGSCANSPEED, m_nComboScanSpeed);
		DDX_Control(pDX, IDC_COMBO_IMGSIZE, m_ctrlComboImageSize);
		DDX_CBIndex(pDX, IDC_COMBO_IMGSIZE, m_nComboImageSize);
		DDX_Control(pDX, IDC_COMBO_STAGE, m_ctrlComboStage);
		DDX_CBIndex(pDX, IDC_COMBO_STAGE, m_nComboStage);
	}


	BEGIN_MESSAGE_MAP(CDlgProgMgrInfo, CDialog)
		ON_EN_CHANGE(IDC_EDIT_SCREENWIDTH, &CDlgProgMgrInfo::OnChangeEditScreenwidth)
		ON_CBN_SELCHANGE(IDC_COMBO_XDIREC, &CDlgProgMgrInfo::OnSelchangeComboXdirec)
		ON_EN_CHANGE(IDC_EDIT_XSTART, &CDlgProgMgrInfo::OnChangeEditXstart)
		ON_EN_CHANGE(IDC_EDIT_XEND, &CDlgProgMgrInfo::OnChangeEditXend)
		ON_CBN_SELCHANGE(IDC_COMBO_YDIRECT, &CDlgProgMgrInfo::OnSelchangeComboYdirect)
		ON_EN_CHANGE(IDC_EDIT_YSTART, &CDlgProgMgrInfo::OnChangeEditYstart)
		ON_EN_CHANGE(IDC_EDIT_YEND, &CDlgProgMgrInfo::OnChangeEditYend)
		ON_BN_CLICKED(IDOK, &CDlgProgMgrInfo::OnBnClickedOk)
		ON_CBN_SELCHANGE(IDC_COMBO_STOPMODE, &CDlgProgMgrInfo::OnSelchangeComboStopmode)
		ON_EN_CHANGE(IDC_EDIT_STOP_TIME, &CDlgProgMgrInfo::OnChangeEditStopTime)
		ON_EN_CHANGE(IDC_EDIT_STOP_FIELD_NUM, &CDlgProgMgrInfo::OnChangeEditStopFieldNum)
		ON_EN_CHANGE(IDC_EDIT_STOP_INCA_NUM, &CDlgProgMgrInfo::OnChangeEditStopIncaNum)
		ON_CBN_SELCHANGE(IDC_COMBO_FETCHIMGMODE, &CDlgProgMgrInfo::OnSelchangeComboFetchimgmode)
		ON_CBN_SELCHANGE(IDC_COMBO_IMGSCANSPEED, &CDlgProgMgrInfo::OnSelchangeComboImgscanspeed)
		ON_CBN_SELCHANGE(IDC_COMBO_IMGSIZE, &CDlgProgMgrInfo::OnSelchangeComboImgsize)
		ON_EN_CHANGE(IDC_EDIT_SAMPLENAME, &CDlgProgMgrInfo::OnChangeEditSamplename)
		ON_BN_CLICKED(IDC_MEAS_SWITCH, &CDlgProgMgrInfo::OnClickedMeasSwitch)
		ON_EN_CHANGE(IDC_EDIT_MESA_PARAM_FILE, &CDlgProgMgrInfo::OnChangeEditMesaParamFile)
		ON_EN_CHANGE(IDC_EDIT_STDLIBNAME, &CDlgProgMgrInfo::OnChangeEditStdlibname)
		ON_EN_CHANGE(IDC_EDIT_PARTAREAMIN, &CDlgProgMgrInfo::OnChangeEditPartareamin)
		ON_EN_CHANGE(IDC_EDIT_PARTAREAMAX, &CDlgProgMgrInfo::OnChangeEditPartareamax)
		ON_EN_CHANGE(IDC_EDIT_BACKMIN, &CDlgProgMgrInfo::OnChangeEditBackmin)
		ON_EN_CHANGE(IDC_EDIT_BACKMAX, &CDlgProgMgrInfo::OnChangeEditBackmax)
		ON_EN_CHANGE(IDC_EDIT_PARTMIN, &CDlgProgMgrInfo::OnChangeEditPartmin)
		ON_EN_CHANGE(IDC_EDIT_PARTMAX, &CDlgProgMgrInfo::OnChangeEditPartmax)
		ON_CBN_SELCHANGE(IDC_COMBO_SEARCHXRAYSPEED, &CDlgProgMgrInfo::OnSelchangeComboSearchxrayspeed)
		ON_EN_CHANGE(IDC_EDIT_SEARCHXRAYCOUNTLIMIT, &CDlgProgMgrInfo::OnChangeEditSearchxraycountlimit)
		ON_CBN_SELCHANGE(IDC_COMBO_XRAYSCANMODE, &CDlgProgMgrInfo::OnSelchangeComboXrayscanmode)
		ON_CBN_SELCHANGE(IDC_COMBO_ANALYXRAYSPEED, &CDlgProgMgrInfo::OnSelchangeComboAnalyxrayspeed)
		ON_EN_CHANGE(IDC_EDIT_ANALYXRAYAIMVALUE, &CDlgProgMgrInfo::OnChangeEditAnalyxrayaimvalue)
		ON_BN_CLICKED(IDC_BUTTON_MEASPRAMPATHSET, &CDlgProgMgrInfo::OnClickedButtonMeasprampathset)
		ON_BN_CLICKED(IDC_BUTTON_PARTSTDLIBPATHSET, &CDlgProgMgrInfo::OnClickedButtonPartstdlibpathset)
		ON_BN_CLICKED(IDC_BUTTON_STAGE, &CDlgProgMgrInfo::OnBnClickedButtonStage)
		ON_CBN_SELCHANGE(IDC_COMBO_STAGE, &CDlgProgMgrInfo::OnSelchangeComboStage)
	END_MESSAGE_MAP()


	// CDlgProgMgrInfo message process
	BOOL CDlgProgMgrInfo::OnInitDialog()
	{
		CDialog::OnInitDialog();
		LogInfoTrace(__FILE__, __LINE__, _T("OnInitDialog: program dlg init."));
		// set control data
		SetStageControlData(m_pStageFile);
		SetStageDataControlData(m_pStageData);
		SetGenParamControlData(m_pGenParam, m_sParamFileName);
		SetImageScanParamControlData(m_pImageScanParam);
		SetImageProcParamControlData(m_pImageProcParam);
		SetXRayParamControlData(m_pXRayParam);
		return TRUE;  // return TRUE unless you set the focus to a control					  
	}
	void CDlgProgMgrInfo::OnClickedButtonMeasprampathset()
	{
		LogInfoTrace(__FILE__, __LINE__, _T("OnClickedButtonMeasprampathset: get the measure file path."));
		// set the parameter file path
		CFolderPickerDialog dlg(NULL, NULL, this, NULL);
		if (dlg.DoModal() == IDOK)
		{
			CString sPath = dlg.GetPathName();
			if (sPath.IsEmpty())
			{
				LogErrorTrace(__FILE__, __LINE__, _T("OnClickedButtonMeasprampathset: empty path."));
				return;
			}
			LogInfoTrace(__FILE__, __LINE__, _T("OnClickedButtonMeasprampathset: user have choose %s."), sPath);
			m_sEditParamFilePath = sPath;
			UpdateData(FALSE);
		}
		else
		{
			LogInfoTrace(__FILE__, __LINE__, _T("OnClickedButtonMeasprampathset: user cancled."));
			return;
		}

		UpdateGenParam();
	}
	void CDlgProgMgrInfo::OnClickedButtonPartstdlibpathset()
	{
		LogInfoTrace(__FILE__, __LINE__, _T("OnClickedButtonPartstdlibpathset: get the STD lib file path."));
		// set STD lib file path name
		CFolderPickerDialog dlg(NULL, NULL, this, NULL);
		if (dlg.DoModal() == IDOK)
		{
			CString sPath = dlg.GetPathName();
			if (sPath.IsEmpty())
			{
				LogErrorTrace(__FILE__, __LINE__, _T("OnClickedButtonPartstdlibpathset: empty path."));
				return;
			}
			LogInfoTrace(__FILE__, __LINE__, _T("OnClickedButtonPartstdlibpathset: user have choose %s."), sPath);
			m_sEditSTDLibPath = dlg.GetPathName();
			UpdateData(FALSE);
		}
		else
		{
			LogInfoTrace(__FILE__, __LINE__, _T("OnClickedButtonPartstdlibpathset: user cancled."));
			return;
		}

		UpdateGenParam();
	}
	void CDlgProgMgrInfo::OnBnClickedButtonStage()
	{
		UpdateData();

		CSEMStageDataPtr pStageData = CSEMStageDataPtr(new CSEMStageData());
		m_pStageFile->SetStageData(pStageData);
		m_pStageFile->SetStageData(m_pStageData);

		// if it is the first time to add a stage, it is need to load from stage file.
		if (m_pStageFile->GetStagesList().size() == 0)
		{
			LogInfoTrace(__FILE__, __LINE__, _T("OnBnClickedButtonStage: there is no stage now."));

			if (!m_pStageFile->Load(m_nPackId))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("OnBnClickedButtonStage: Load stage file failed."));
				return;
			}

			LogInfoTrace(__FILE__, __LINE__, _T("OnBnClickedButtonStage: load stage from stage file."));

			if (m_pStageFile->GetStagesList().size()> STAGE_LIST_NEED_FOUCS_NUM)
			{
				// there is more than one stage , need to set a working stage, the combo selected one is working stage.
				m_pStageFile->SetWorkingStageId(m_nComboStage);
				m_pStageFile->SetModify();
			}
			else
			{
				LogInfoTrace(__FILE__, __LINE__, _T("OnBnClickedButtonStage: stage list size is no bigger than 1, don't need set working stage."));
			}
		}


		LogInfoTrace(__FILE__, __LINE__, _T("OnBnClickedButtonStage: show stage manager dlg."));

		CDlgStageMgr dlg;
		dlg.SetStageFile(m_pStageFile);
		dlg.SetPackId(m_nPackId);

		dlg.DoModal();
		CStageFilePtr pStageFile = dlg.GetStageFile();
		ASSERT(pStageFile);
		if (!pStageFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("OnBnClickedButtonStage: Load stage from stage manager dlg failed."));
			return;
		}
			
		SetStageControlData(m_pStageFile);	

	}

	void CDlgProgMgrInfo::OnChangeEditScreenwidth()
	{
		UpdateStageData();
	}
	void CDlgProgMgrInfo::OnSelchangeComboXdirec()
	{
		UpdateStageData();
	}
	void CDlgProgMgrInfo::OnChangeEditXstart()
	{
		UpdateStageData();
	}
	void CDlgProgMgrInfo::OnChangeEditXend()
	{
		UpdateStageData();
	}
	void CDlgProgMgrInfo::OnSelchangeComboYdirect()
	{
		UpdateStageData();
	}
	void CDlgProgMgrInfo::OnChangeEditYstart()
	{
		UpdateStageData();
	}
	void CDlgProgMgrInfo::OnChangeEditYend()
	{
		UpdateStageData();
	}
	void CDlgProgMgrInfo::OnBnClickedOk()
	{
		// get control data from dialog
		UpdateStageData();
		UpdateGenParam();
		UpdateImageScanParam();
		UpdateImageProcParam();
		UpdateXRayParam();
		

		LogInfoTrace(__FILE__, __LINE__, _T("OnBnClickedOk: save program manager file and stage file."));
		
		//save program manager file
		if(!COTSProgMgr::SaveInfoToProgMgrFile(m_nPackId,
			m_pStageData,
			m_pGenParam,
			m_pImageScanParam,
			m_pImageProcParam,
			m_pXRayParam))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("OnBnClickedOk: save program manager file failed."));
			return;
		}

		LogInfoTrace(__FILE__, __LINE__, _T("OnBnClickedOk: save program manager file."));

		if (m_pStageFile->IsModified())
		{
			if (!m_pStageFile->Save(m_nPackId))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("OnBnClickedOk: save stage file failed."));
				return;
			}

			LogInfoTrace(__FILE__, __LINE__, _T("OnBnClickedOk: save stage file."));
		}

		CDialog::OnOK();
	}
	void CDlgProgMgrInfo::OnSelchangeComboStopmode()
	{
		UpdateImageScanParam();
	}
	void CDlgProgMgrInfo::OnChangeEditStopTime()
	{
		UpdateImageScanParam();
	}
	void CDlgProgMgrInfo::OnChangeEditStopFieldNum()
	{
		UpdateImageScanParam();
	}
	void CDlgProgMgrInfo::OnChangeEditStopIncaNum()
	{
		UpdateImageScanParam();
	}
	void CDlgProgMgrInfo::OnSelchangeComboFetchimgmode()
	{
		UpdateImageScanParam();
	}
	void CDlgProgMgrInfo::OnSelchangeComboImgscanspeed()
	{
		UpdateImageScanParam();
	}
	void CDlgProgMgrInfo::OnSelchangeComboImgsize()
	{
		UpdateImageScanParam();
	}
	void CDlgProgMgrInfo::OnChangeEditSamplename()
	{
		UpdateGenParam();
	}
	void CDlgProgMgrInfo::OnClickedMeasSwitch()
	{
		UpdateGenParam();
	}
	void CDlgProgMgrInfo::OnChangeEditMesaParamFile()
	{
		UpdateGenParam();
	}
	void CDlgProgMgrInfo::OnChangeEditStdlibname()
	{
		UpdateGenParam();
	}
	void CDlgProgMgrInfo::OnChangeEditPartareamin()
	{
		UpdateImageProcParam();
	}
	void CDlgProgMgrInfo::OnChangeEditPartareamax()
	{
		UpdateImageProcParam();
	}
	void CDlgProgMgrInfo::OnChangeEditBackmin()
	{
		UpdateImageProcParam();
	}
	void CDlgProgMgrInfo::OnChangeEditBackmax()
	{
		UpdateImageProcParam();
	}
	void CDlgProgMgrInfo::OnChangeEditPartmin()
	{
		UpdateImageProcParam();
	}
	void CDlgProgMgrInfo::OnChangeEditPartmax()
	{
		UpdateImageProcParam();
	}
	void CDlgProgMgrInfo::OnSelchangeComboSearchxrayspeed()
	{
		UpdateXRayParam();
	}
	void CDlgProgMgrInfo::OnChangeEditSearchxraycountlimit()
	{
		UpdateXRayParam();
	}
	void CDlgProgMgrInfo::OnSelchangeComboXrayscanmode()
	{
		UpdateXRayParam();
	}
	void CDlgProgMgrInfo::OnSelchangeComboAnalyxrayspeed()
	{
		UpdateXRayParam();
	}
	void CDlgProgMgrInfo::OnChangeEditAnalyxrayaimvalue()
	{
		UpdateXRayParam();
	}
	void CDlgProgMgrInfo::OnSelchangeComboStage()
	{
		UpdateStage();		
	}

	void CDlgProgMgrInfo::SetStageControlData(CStageFilePtr a_pStageFile)
	{
		m_ctrlComboStage.ResetContent();
		// send control data to dialog

		// the first stage should be the working stage, the list should be the same with the combo string list
		CStagePtr pWorkingStage = m_pStageFile->GetWorkingStage();

		LogInfoTrace(__FILE__, __LINE__, _T("SetStageControlData: create a new stage list to set the working stage at the first place."));
		
		// Update the stage list
		CStagesList listNewStage;
		listNewStage.clear();
		listNewStage.push_back(pWorkingStage);
		m_ctrlComboStage.AddString(pWorkingStage->GetName());

		int nWorkingStageId = m_pStageFile->GetWorkingStageId();
		// add other stage expcept working stage
		int nNum = 0;
		for (auto pStage : m_pStageFile->GetStagesList())
		{
			if(nNum != nWorkingStageId)
			{
				CString sCurrentName = pStage->GetName();
				m_ctrlComboStage.AddString(sCurrentName);
				listNewStage.push_back(pStage);
			}
			nNum++;
		}

		// if there is a sample on the stage , the stage can't change
		m_ctrlComboStage.EnableWindow(!m_bInUse);
		if(listNewStage.size() == m_pStageFile->GetStagesList().size())
		{
			m_pStageFile->SetStagesList(listNewStage);
			m_pStageFile->SetWorkingStageId(0);
			m_pStageFile->SetModify();
		}
		else
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetStageControlData: stage lost, put the working stage at the first place failed."));
			return;
		}
		UpdateData(FALSE);
		return;
	}
	void CDlgProgMgrInfo::SetStageDataControlData(CSEMStageDataPtr a_pStageData)
	{
		// safety check
		ASSERT(a_pStageData);
		if (!a_pStageData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetStageDataControlData: invalid stage data pointer"));
			return;
		}

		LogInfoTrace(__FILE__, __LINE__, _T("SetStageDataControlData: set SEM stage data param to dlg control."));


		// set combo boxes
		for (int i = (int)OTS_X_AXIS_DIRECTION::MIN; i <= (int)OTS_X_AXIS_DIRECTION::MAX; ++i)
		{
			CString strItem = COTSProgMgr::GetXAxisDirectionIdString((OTS_X_AXIS_DIRECTION)i);
			m_ctrlComboXAxisDirection.AddString(strItem);
		}
		for (int i = (int)OTS_Y_AXIS_DIRECTION::MIN; i <= (int)OTS_Y_AXIS_DIRECTION::MAX; ++i)
		{
			CString strItem = COTSProgMgr::GetYAxisDirectionIdString((OTS_Y_AXIS_DIRECTION)i);
			m_ctrlComboYAxisDirection.AddString(strItem);
		}

		// set control data with the stage info
		m_nEditScreenWidth = a_pStageData->GetScanFieldSize100();
		m_nComboXAxisDirection = (int)a_pStageData->GetXAxisDir();
		m_lEditXAxisStart = a_pStageData->GetXAxis()->GetStart();
		m_lEditXAxisEnd = a_pStageData->GetXAxis()->GetEnd();
		m_nComboYAxisDirection = (int)a_pStageData->GetYAxisDir();
		m_lEditYAxisStart = a_pStageData->GetYAxis()->GetStart();
		m_lEditYAxisEnd = a_pStageData->GetYAxis()->GetEnd();

		// send control data to dialog
		UpdateData(FALSE);
	}
	void CDlgProgMgrInfo::SetGenParamControlData(COTSGeneralParametersPtr a_pGenParam, CString a_sParamFileName)
	{
		// safety check
		ASSERT(a_pGenParam);
		if (!a_pGenParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetGenParamControlData: invalid pGenParam pointer"));
			return;
		}

		m_sEditSampleAutoName = a_pGenParam->GetSampleName();
		m_sEditParamFilePath = a_pGenParam->GetMsrParamFileFolderName();
		m_sEditSTDLibPath = a_pGenParam->GetPartSTDLibFolderName();
		m_bCheckMeasSwitch = a_pGenParam->GetMeasurementSwitch();
		m_sEditParamFileName = a_sParamFileName;
		m_sEditSTDLibName = a_pGenParam->GetPartSTDLibName();

		LogInfoTrace(__FILE__, __LINE__, _T("SetGenParamControlData: set general param to dlg control."));

		// send control data to dialog
		UpdateData(FALSE);
	}
	void CDlgProgMgrInfo::SetImageScanParamControlData(COTSImageScanParamPtr a_pImageScanParam)
	{
		// safety check
		ASSERT(a_pImageScanParam);
		if (!a_pImageScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageScanParamControlData: invalid stage data pointer"));
			return;
		}

		// set combo boxes
		for (int i = (int)OTS_MEASURE_STOP_MODE::MIN; i <= (int)OTS_MEASURE_STOP_MODE::MAX; ++i)
		{
			CString strItem = COTSProgMgr::GetStopModeIdString((OTS_MEASURE_STOP_MODE)i);
			m_ctrlComboStopMode.AddString(strItem);
		}


		for (int i = (int)OTS_GET_IMAGE_MODE::MIN; i <= (int)OTS_GET_IMAGE_MODE::MAX; ++i)
		{
			CString strItem = COTSProgMgr::GetGetImageIdString((OTS_GET_IMAGE_MODE)i);
			m_ctrlComboFetchMode.AddString(strItem);
		}

		for (int i = (int)OTS_THREE_TIES_OPTIONS::MIN; i <= (int)OTS_THREE_TIES_OPTIONS::MAX; ++i)
		{
			CString strItem = COTSProgMgr::GetScanSpeedString((OTS_THREE_TIES_OPTIONS)i);
			m_ctrlComboScanSpeed.AddString(strItem);
		}

		for (int i = (int)OTS_FIVE_TIES_OPTIONS::MIN; i <= (int)OTS_FIVE_TIES_OPTIONS::MAX; ++i)
		{
			CString strItem = COTSProgMgr::GetImageSizeIdString((OTS_FIVE_TIES_OPTIONS)i);
			m_ctrlComboImageSize.AddString(strItem);
		}

		// set control data with the stage info
		m_nComboStopMode = (int)a_pImageScanParam->GetStopMode();
		m_lEditStopTime = a_pImageScanParam->GetStopParamMeasTime();
		m_lEditFieldNum = a_pImageScanParam->GetStopParamFields();
		m_lEditIncANum = a_pImageScanParam->GetStopParamParticles();
		m_nComboFetchMode = (int)a_pImageScanParam->GetStartImageMode();
		m_nComboScanSpeed = (int)a_pImageScanParam->GetScanImageSpeed();
		m_nComboImageSize = (int)a_pImageScanParam->GetImagePixelSize();

		LogInfoTrace(__FILE__, __LINE__, _T("SetImageScanParamControlData: set image scan param to dlg control."));

		// send control data to dialog
		UpdateData(FALSE);
	}
	void CDlgProgMgrInfo::SetImageProcParamControlData(COTSImageProcessParamPtr a_pImageProcParam)
	{
		// safety check
		ASSERT(a_pImageProcParam);
		if (!a_pImageProcParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageProcParamControlData: invalid ImageProcParam pointer"));
			return;
		}

		m_dEditAreaMin = a_pImageProcParam->GetIncArea().GetStart();
		m_dEditAreaMax = a_pImageProcParam->GetIncArea().GetEnd();
		m_cEditBackMin = (BYTE)a_pImageProcParam->GetBGGray().GetStart();
		m_cEditBackMax = (BYTE)a_pImageProcParam->GetBGGray().GetEnd();
		m_cEditPartMin = (BYTE)a_pImageProcParam->GetParticleGray().GetStart();
		m_cEditPartMax = (BYTE)a_pImageProcParam->GetParticleGray().GetEnd();

		LogInfoTrace(__FILE__, __LINE__, _T("SetImageProcParamControlData: set image process param to dlg control."));

		// send control data to dialog
		UpdateData(FALSE);
	}
	void CDlgProgMgrInfo::SetXRayParamControlData(COTSXRayParamPtr a_pXRayParam)
	{
		// safety check
		ASSERT(a_pXRayParam);
		if (!a_pXRayParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetXRayParamControlData: invalid XRayParam pointer"));
			return;
		}

		for (int i = (int)OTS_X_RAY_SCAN_MODE::MIN; i <= (int)OTS_X_RAY_SCAN_MODE::MAX; ++i)
		{
			CString strItem = COTSProgMgr::GetXRayScanModeIdString((OTS_X_RAY_SCAN_MODE)i);
			m_ctrlComboSearchMode.AddString(strItem);
		}

		for (int i = (int)OTS_THREE_TIES_OPTIONS::MIN; i <= (int)OTS_THREE_TIES_OPTIONS::MAX; ++i)
		{
			CString strItem = COTSProgMgr::GetXRaySearchSpeedIdString((OTS_THREE_TIES_OPTIONS)i);
			m_ctrlComboSearchSpeed.AddString(strItem);
		}

		for (int i = (int)OTS_THREE_TIES_OPTIONS::MIN; i <= (int)OTS_THREE_TIES_OPTIONS::MAX; ++i)
		{
			CString strItem = COTSProgMgr::GetXRayAnalySpeedIdString((OTS_THREE_TIES_OPTIONS)i);
			m_ctrlComboAnalySpeed.AddString(strItem);
		}

		// set control data with the stage info
		m_nComboScanSpeed = (int)a_pXRayParam->GetScanMode();
		m_lEditSearchCount = a_pXRayParam->GetXRaySearchCount();
		m_nComboSearchMode = (int)a_pXRayParam->GetSearchSpeed();
		m_nComboAnalySpeed = (int)a_pXRayParam->GetAnalySpeed();
		m_lEditAnalyCount = (int)a_pXRayParam->GetAnalyExpCount();

		LogInfoTrace(__FILE__, __LINE__, _T("SetXRayParamControlData: set x ray param to dlg control."));

		// send control data to dialog
		UpdateData(FALSE);
	}
	void CDlgProgMgrInfo::UpdateStageData(BOOL a_bUpdateData /*= TRUE*/)
	{
		// get control data from dialog
		if (a_bUpdateData)
		{
			UpdateData();
		}

		// create a stage data with dialog parameters
		CSEMStageDataPtr pOTSStageData(new CSEMStageData());
		pOTSStageData->SetScanFieldSize100(m_nEditScreenWidth);
		pOTSStageData->SetXAxisDir((OTS_X_AXIS_DIRECTION)m_nComboXAxisDirection);
		CIntRangePtr pTemp = CIntRangePtr(new CIntRange(m_lEditXAxisStart, m_lEditXAxisEnd));
		pOTSStageData->SetXAxis(pTemp);
		pOTSStageData->SetYAxisDir((OTS_Y_AXIS_DIRECTION)m_nComboYAxisDirection);
		pTemp->SetStart(m_lEditYAxisStart);
		pTemp->SetEnd(m_lEditYAxisEnd);
		pOTSStageData->SetYAxis(pTemp);

		m_pStageData = pOTSStageData;

		LogInfoTrace(__FILE__, __LINE__, _T("UpdateStageData: get SEM stage data from dlg control."));

	}
	void CDlgProgMgrInfo::UpdateGenParam(BOOL a_bUpdateData /*= TRUE*/)
	{
		// get control data from dialog
		if (a_bUpdateData)
		{
			UpdateData();
		}

		// create a stage data with dialog parameters
		COTSGeneralParametersPtr pGenParam(new COTSGeneralParameters());
		pGenParam->SetMeasurementSwitch(m_bCheckMeasSwitch);
		pGenParam->SetMsrParamFileFolderName(m_sEditParamFilePath);
		pGenParam->SetPartSTDLibFolderName(m_sEditSTDLibPath);
		pGenParam->SetSampleName(m_sEditSampleAutoName);
		//pGenParam->SetPartSTDLibName(m_sEditSTDLibName);

		m_pGenParam = pGenParam;		
		m_sParamFileName = m_sEditParamFileName;
		

		LogInfoTrace(__FILE__, __LINE__, _T("UpdateStageData: get SEM stage data from dlg control."));

	}
	void CDlgProgMgrInfo::UpdateImageScanParam(BOOL a_bUpdateData /*= TRUE*/)
	{
		// get control data from dialog
		if (a_bUpdateData)
		{
			UpdateData();
		}

		// create a stage data with dialog parameters
		COTSImageScanParamPtr pImageScanParam(new COTSImageScanParam());
		pImageScanParam->SetStopMode((OTS_MEASURE_STOP_MODE)m_nComboStopMode);
		pImageScanParam->SetStopParamMeasTime(m_lEditStopTime);
		pImageScanParam->SetStopParamFields(m_lEditFieldNum);
		pImageScanParam->SetStopParamParticles(m_lEditIncANum);
		pImageScanParam->SetStartImageMode((OTS_GET_IMAGE_MODE)m_nComboFetchMode);
		pImageScanParam->SetScanImageSpeed((OTS_THREE_TIES_OPTIONS)m_nComboScanSpeed);
		pImageScanParam->SetImagePixelSize((OTS_FIVE_TIES_OPTIONS)m_nComboImageSize);

		m_pImageScanParam = pImageScanParam;

		LogInfoTrace(__FILE__, __LINE__, _T("UpdateImageScanParam: get image scan param from dlg control."));
	}
	void CDlgProgMgrInfo::UpdateImageProcParam(BOOL a_bUpdateData /*= TRUE*/)
	{
		// get control data from dialog
		if (a_bUpdateData)
		{
			UpdateData();
		}

		COTSImageProcessParamPtr pImageProcParam(new COTSImageProcessParam());
		CDoubleRange odTemp(m_dEditAreaMin, m_dEditAreaMax);
		pImageProcParam->SetIncArea(odTemp);
		odTemp.SetStart(m_cEditBackMin);
		odTemp.SetEnd(m_cEditBackMax);
		CIntRange onTemp(m_cEditPartMin, m_cEditPartMax);
		pImageProcParam->SetBGGray(onTemp);
		onTemp.SetStart(m_cEditPartMin);
		onTemp.SetEnd(m_cEditPartMax);
		pImageProcParam->SetParticleGray(onTemp);

		m_pImageProcParam = pImageProcParam;

		LogInfoTrace(__FILE__, __LINE__, _T("UpdateImageProcParam: get image proc param from dlg control."));
	}
	void CDlgProgMgrInfo::UpdateXRayParam(BOOL a_bUpdateData /*= TRUE*/)
	{
		// get control data from dialog
		if (a_bUpdateData)
		{
			UpdateData();
		}

		COTSXRayParamPtr pXRayParam(new COTSXRayParam());
		pXRayParam->SetSearchSpeed((OTS_THREE_TIES_OPTIONS)m_nComboSearchSpeed);
		pXRayParam->SetXRaySearchCount(m_lEditSearchCount);
		pXRayParam->SetScanMode((OTS_X_RAY_SCAN_MODE)m_nComboSearchMode);
		pXRayParam->SetAnalySpeed((OTS_THREE_TIES_OPTIONS)m_nComboAnalySpeed);
		pXRayParam->SetAnalyExpCount(m_lEditAnalyCount);

		m_pXRayParam = pXRayParam;

		LogInfoTrace(__FILE__, __LINE__, _T("UpdateImageProcParam: get x ray param from dlg control."));
	}
	void CDlgProgMgrInfo::UpdateStage(BOOL a_bUpdateData /*= TRUE*/)
	{
		// get control data from dialog
		if (a_bUpdateData)
		{
			UpdateData();
		}

		//set control data to stageCombo
		m_pStageFile->SetWorkingStageId(m_nComboStage);
		m_pStageFile->SetModify();

		LogInfoTrace(__FILE__, __LINE__, _T("UpdateImageProcParam: get x ray param from dlg control."));
	}
		
	// set stage data
	void CDlgProgMgrInfo::SetStageData(CSEMStageDataPtr a_pCSEMStageData)
	{
		// safety check
		ASSERT(a_pCSEMStageData);
		if (!a_pCSEMStageData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetStageData: invalid stage data pointer"));

			return;
		}
		
		m_pStageData = a_pCSEMStageData;
		

		LogInfoTrace(__FILE__, __LINE__, _T("SetStageData: set SEM stage data."));
	}
	void CDlgProgMgrInfo::SetParamFileName(CString a_sParamFileName)
	{
		m_sParamFileName = a_sParamFileName;

		LogInfoTrace(__FILE__, __LINE__, _T("SetParamFilePath: set param file path is %s."), m_sParamFileName);
	}
	void CDlgProgMgrInfo::SetGenParam(COTSGeneralParametersPtr a_pGenParam)
	{
		// safety check
		ASSERT(a_pGenParam);
		if (!a_pGenParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetGenParam: invalid GenParam pointer"));

			return;
		}
		m_pGenParam = a_pGenParam;
		
		LogInfoTrace(__FILE__, __LINE__, _T("SetGenParam: set general param data."));
	}
	void CDlgProgMgrInfo::SetImageScanParam(COTSImageScanParamPtr a_pImageScanParam)
	{
		// safety check
		ASSERT(a_pImageScanParam);
		if (!a_pImageScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageScanParam: invalid ImageScanParam pointer"));

			return;
		}
		
		m_pImageScanParam = a_pImageScanParam;

		LogInfoTrace(__FILE__, __LINE__, _T("SetImageScanParam: set image scan param data."));
		
	}
	void CDlgProgMgrInfo::SetImageProcParam(COTSImageProcessParamPtr a_pImageProcParam)
	{
		// safety check
		ASSERT(a_pImageProcParam);
		if (!a_pImageProcParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageProcParam: invalid ImageProcParam pointer"));

			return;
		}
		
		m_pImageProcParam = a_pImageProcParam;

		LogInfoTrace(__FILE__, __LINE__, _T("SetImageScanParam: set image scan param data."));
		
	}
	void CDlgProgMgrInfo::SetXRayParam(COTSXRayParamPtr a_pXRayParam)
	{
		// safety check
		ASSERT(a_pXRayParam);
		if (!a_pXRayParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetXRayParam: invalid XRayParam pointer"));

			return;
		}
		
		m_pXRayParam = a_pXRayParam;

		LogInfoTrace(__FILE__, __LINE__, _T("SetXRayParam: set x ray param data."));
		
	}


}