#include "StdAfx.h"
#include "CHReviewRecipe/Rcp_RsReviewManager.h"

CRcp_RsReviewManager::CRcp_RsReviewManager(void)
{
}

CRcp_RsReviewManager::~CRcp_RsReviewManager(void)
{
}

void CRcp_RsReviewManager::SetFlanFile(CMacroFile& macroFile)//0117 �����޸� �÷�
{
	int nPlanIdx, nSlotIdx, nLightIdx, nAFMRecipeIdx, nUserDefectIdx, nReflowParameterIdx, nLightIdxWsi, nAFMRecipeIdxWsi;
	int nPlanCount, nLightCount, nAFMRecipeCount, nUserDefectCount, nLightCountWsi, nAFMRecipeCountWsi;
	int nTopReview;
	CString strItem;
	//d  u wsi	cd  re wsire
	m_rsRcpReviewInfo.GetRcpPlanInfoCount();
	for(nPlanIdx = 0; nPlanIdx < nPlanCount; nPlanIdx++)
	{
		const CRcpPlanInfo *pRcpPlanInfo = m_rsRcpReviewInfo.GetRcpPlanInfo(nPlanIdx);
		if (pRcpPlanInfo==NULL) continue;
		if(pRcpPlanInfo->m_nReviewType == 4){//reflow 

			strItem.Format(_T("2"));
			macroFile.SetItem(strItem, m_rsRcpReviewInfo.m_nGlassTypeIdx);
		}
		else if(pRcpPlanInfo->m_nReviewType == 2){ //wsi
			strItem.Format(_T("3"));
			macroFile.SetItem(strItem,strItem);
		}
		else if(pRcpPlanInfo->m_nReviewType == 1){
			strItem.Format(_T("1"));
			macroFile.SetItem(strItem,strItem);
		}
		else {
			strItem.Format(_T("0"));
			macroFile.SetItem(strItem,strItem);

			for(nUserDefectIdx = 0; nUserDefectIdx < nUserDefectCount; nUserDefectIdx++)
			{
				const CRcpUserDefectInfo* pRcpUserDefectInfo = m_rsRcpReviewInfo.GetRcpUserDefectInfo(nUserDefectIdx);
				if(pRcpUserDefectInfo == NULL) continue;

				strItem.Format(_T(""), pRcpUserDefectInfo->m_dPosX);
				macroFile.SetItem(strItem, pRcpUserDefectInfo->m_dPosX);

				strItem.Format(_T(""), nUserDefectIdx);
				macroFile.SetItem(strItem, pRcpUserDefectInfo->m_dPosY);

				strItem.Format(_T("RCP_REVIEW_REFLOW_CELLSIDE_%02d"), nUserDefectIdx);
				macroFile.SetItem(strItem, pRcpUserDefectInfo->m_nCellSide);

				strItem.Format(_T("RCP_REVIEW_REFLOW_INSPECTIONMODE_%02d"), nUserDefectIdx);
				macroFile.SetItem(strItem, pRcpUserDefectInfo->m_nInspectionMode);

				strItem.Format(_T("RCP_REVIEW_USER_DEFECT_CELLID_%02d"), nUserDefectIdx);
				macroFile.SetItem(strItem, pRcpUserDefectInfo->m_strCellId);

				strItem.Format(_T("RCP_REVIEW_USER_DEFECT_CELLID2_%02d"), nUserDefectIdx);
				macroFile.SetItem(strItem, pRcpUserDefectInfo->m_strCellId2);

			}

		}

		
	
	}


}


void CRcp_RsReviewManager::SetProfile(CMacroFile& macroFile)
{
	int nPlanIdx, nSlotIdx, nLightIdx, nAFMRecipeIdx, nUserDefectIdx, nReflowParameterIdx, nLightIdxWsi, nAFMRecipeIdxWsi;
	int nPlanCount, nLightCount, nAFMRecipeCount, nUserDefectCount, nLightCountWsi, nAFMRecipeCountWsi;
	int nTopReview;
	CString strItem;

	strItem.Format(_T("RCP_REVIEW_GLASS_TYPE"));
	macroFile.SetItem(strItem, m_rsRcpReviewInfo.m_nGlassTypeIdx);

	strItem.Format(_T("RCP_REVIEW_GLASS_GLASSORIGIN"));
	macroFile.SetItem(strItem, m_rsRcpReviewInfo.m_nGlassOrigion);

	//Plan
	nPlanCount = m_rsRcpReviewInfo.GetRcpPlanInfoCount();
	strItem.Format(_T("RCP_REVIEW_PLAN_COUNT"));
	macroFile.SetItem(strItem, nPlanCount);

	nTopReview = m_rsRcpReviewInfo.GetTopReview();
	strItem.Format(_T("RCP_REVIEW_TOP_REVIEW"));
	macroFile.SetItem(strItem, nTopReview);

	for(nPlanIdx = 0; nPlanIdx < nPlanCount; nPlanIdx++)
	{
		const CRcpPlanInfo *pRcpPlanInfo = m_rsRcpReviewInfo.GetRcpPlanInfo(nPlanIdx);
		if (pRcpPlanInfo==NULL) continue;
		
		strItem.Format(_T("RCP_REVIEW_PLAN_REVIEW_TYPE_%02d"), nPlanIdx);
		macroFile.SetItem(strItem, pRcpPlanInfo->m_nReviewType);

		for(nSlotIdx = 0; nSlotIdx < TOTAL_GLASS_SLOT_COUNT; nSlotIdx++)
		{
			strItem.Format(_T("RCP_REVIEW_PLAN_%02d_SELECT_SLOT_%02d"), nPlanIdx, nSlotIdx);
			macroFile.SetItem(strItem, (int)pRcpPlanInfo->m_bSelectSlot[nSlotIdx]);
		}
	}

	// Priority
	int nPriorityCount = m_rsRcpReviewInfo.GetRcpPriorityInfoCount();
	strItem.Format(_T("RCP_REVIEW_PRIORITY_COUNT"));
	macroFile.SetItem(strItem, nPriorityCount);

	for(int nPriorityIdx = 0; nPriorityIdx < nPriorityCount; nPriorityIdx++)
	{
		const CRcpPriorityInfo *pRcpPriorityInfo = m_rsRcpReviewInfo.GetRcpPriorityInfo(nPriorityIdx);
		if (pRcpPriorityInfo==NULL) continue;

		/*	strItem.Format(_T("RCP_REVIEW_PRIORITY_OPTIC_DATA_%02d"), nPriorityIdx);
			macroFile.SetItem(strItem, pRcpPriorityInfo->GetPriorityOpticData());*/
		strItem.Format(_T("RCP_REVIEW_PRIORITY_DEFECTCODE_DATA_%02d"), nPriorityIdx);
		macroFile.SetItem(strItem, pRcpPriorityInfo->GetPriorityDefectCode());
		

		strItem.Format(_T("RCP_REVIEW_PRIORITY_USE_SIZEOPTION_%02d"), nPriorityIdx);
		macroFile.SetItem(strItem, pRcpPriorityInfo->GetPriorityDefectSizeOption());

		strItem.Format(_T("RCP_REVIEW_PRIORITY_MINSIZE_DATA_%02d"), nPriorityIdx);
		macroFile.SetItem(strItem, pRcpPriorityInfo->GetPriorityDefectMinSize());

		strItem.Format(_T("RCP_REVIEW_PRIORITY_MAXSIZE_DATA_%02d"), nPriorityIdx);
		macroFile.SetItem(strItem, pRcpPriorityInfo->GetPriorityDefectMaxSize());

		strItem.Format(_T("RCP_REVIEW_PRIORITY_GRAY_DATA_%02d"), nPriorityIdx);
		macroFile.SetItem(strItem, pRcpPriorityInfo->GetPriorityGrayData());

		strItem.Format(_T("RCP_REVIEW_PRIORITY_STACK_DATA_%02d"), nPriorityIdx);
		macroFile.SetItem(strItem, pRcpPriorityInfo->GetPriorityStackData());

		strItem.Format(_T("RCP_REVIEW_PRIORITY_MODEL_DATA_%02d"), nPriorityIdx);
		macroFile.SetItem(strItem, pRcpPriorityInfo->GetPriorityModelData());

		strItem.Format(_T("RCP_REVIEW_PRIORITY_GRADE_DATA_%02d"), nPriorityIdx);
		macroFile.SetItem(strItem, pRcpPriorityInfo->GetPriorityGradeData());
	}

	// review filer info
	int nFilterCount = m_rsRcpReviewInfo.GetRcpReviewFilterInfoCount();
	strItem.Format(_T("RCP_REVIEW_FILTER_COUNT"));
	macroFile.SetItem(strItem, nFilterCount);
	for (int nFilterIdx=0; nFilterIdx<nFilterCount; nFilterIdx++)
	{
		const CRcpFilteringInfo *pFilterInfo = m_rsRcpReviewInfo.GetRcpReviewFilterInfo(nFilterIdx);
		if (pFilterInfo==NULL) continue;
		
		// Judge
		strItem.Format(_T("RCP_REVIEW_FILTER_JUDGE_%02d"), nFilterIdx);
		macroFile.SetItem(strItem, pFilterInfo->m_FilterJudge);
		
		// SubType
		strItem.Format(_T("RCP_REVIEW_FILTER_SUBTYPE_%02d"), nFilterIdx);
		macroFile.SetItem(strItem, pFilterInfo->m_FilterSubType);

		// Code
		strItem.Format(_T("RCP_REVIEW_FILTER_CODE_%02d"), nFilterIdx);
		macroFile.SetItem(strItem, pFilterInfo->m_FilterCode);
	}

	// review sort info
	const CRcpSortingInfo *pReviewSortInfo = m_rsRcpReviewInfo.GetRcpReviewSortInfo();
	if (pReviewSortInfo)
	{
		strItem.Format(_T("RCP_REVIEW_SORT_TYPE"));
		macroFile.SetItem(strItem, pReviewSortInfo->m_nSortType);

		strItem.Format(_T("RCP_REVIEW_SORT_DATA"));
		macroFile.SetItem(strItem, pReviewSortInfo->m_nSortData);

		strItem.Format(_T("RCP_REVIEW_SORT_PRIORITY"));
		macroFile.SetItem(strItem, pReviewSortInfo->m_nSortPriority);
	}
	
	// Review Defocus 
	strItem.Format(_T("RCP_REVIEW_USE_DEFOCUS_ALARM"));
	macroFile.SetItem(strItem, m_rsRcpReviewInfo.GetDefocusUse());
	strItem.Format(_T("RCP_REVIEW_DEFOCUS_VALUE"));
	macroFile.SetItem(strItem, m_rsRcpReviewInfo.GetDefocusValue());

	// wsi �켱����
	// Priority
	int nWsiPriorityCount = m_rsRcpReviewInfo.GetRcpWsiPriorityInfoCount();
	strItem.Format(_T("RCP_WSI_PRIORITY_COUNT"));
	macroFile.SetItem(strItem, nWsiPriorityCount);

	for(int nPriorityIdx = 0; nPriorityIdx < nWsiPriorityCount; nPriorityIdx++)
	{
		const CRcpPriorityInfo *pRcpPriorityInfo = m_rsRcpReviewInfo.GetRcpWsiPriorityInfo(nPriorityIdx);
		if (pRcpPriorityInfo==NULL) continue;

		//strItem.Format(_T("RCP_WSI_PRIORITY_DEFECT_TYPE_%02d"), nPriorityIdx);
		//macroFile.SetItem(strItem, pRcpPriorityInfo->GetPriorityOpticData());
		
		strItem.Format(_T("RCP_WSI_PRIORITY_DEFECTCODE_DATA_%02d"), nPriorityIdx);//20210608
		macroFile.SetItem(strItem, pRcpPriorityInfo->GetPriorityDefectCode());

		strItem.Format(_T("RCP_WSI_PRIORITY_USE_SIZEOPTION_%02d"), nPriorityIdx);
		macroFile.SetItem(strItem, pRcpPriorityInfo->GetPriorityDefectSizeOption());

		strItem.Format(_T("RCP_WSI_PRIORITY_MINSIZE_DATA_%02d"), nPriorityIdx);
		macroFile.SetItem(strItem, pRcpPriorityInfo->GetPriorityDefectMinSize());
		
		strItem.Format(_T("RCP_WSI_PRIORITY_MAXSIZE_DATA_%02d"), nPriorityIdx);
		macroFile.SetItem(strItem, pRcpPriorityInfo->GetPriorityDefectMaxSize());

		strItem.Format(_T("RCP_WSI_PRIORITY_STACK_DATA_%02d"), nPriorityIdx);
		macroFile.SetItem(strItem, pRcpPriorityInfo->GetPriorityStackData());

		strItem.Format(_T("RCP_WSI_PRIORITY_GRAY_DATA_%02d"), nPriorityIdx);
		macroFile.SetItem(strItem, pRcpPriorityInfo->GetPriorityGrayData());

		strItem.Format(_T("RCP_WSI_PRIORITY_MODEL_DATA_%02d"), nPriorityIdx);
		macroFile.SetItem(strItem, pRcpPriorityInfo->GetPriorityModelData());

		strItem.Format(_T("RCP_WSI_PRIORITY_GRADE_DATA_%02d"), nPriorityIdx);
		macroFile.SetItem(strItem, pRcpPriorityInfo->GetPriorityGradeData());

	}

	// wsi filer info
	nFilterCount = m_rsRcpReviewInfo.GetRcpWSIFilterInfoCount();
	strItem.Format(_T("RCP_WSI_FILTER_COUNT"));
	macroFile.SetItem(strItem, nFilterCount);
	for (int nFilterIdx=0; nFilterIdx<nFilterCount; nFilterIdx++)
	{
		const CRcpFilteringInfo *pFilterInfo = m_rsRcpReviewInfo.GetRcpWSIFilterInfo(nFilterIdx);
		if (pFilterInfo==NULL) continue;

		// Judge
		strItem.Format(_T("RCP_WSI_FILTER_JUDGE_%02d"), nFilterIdx);
		macroFile.SetItem(strItem, pFilterInfo->m_FilterJudge);

		// SubType
		strItem.Format(_T("RCP_WSI_FILTER_SUBTYPE_%02d"), nFilterIdx);
		macroFile.SetItem(strItem, pFilterInfo->m_FilterSubType);

		// Code
		strItem.Format(_T("RCP_WSI_FILTER_CODE_%02d"), nFilterIdx);
		macroFile.SetItem(strItem, pFilterInfo->m_FilterCode);
	}

	// wsi sort info
	const CRcpSortingInfo *pWSISortInfo = m_rsRcpReviewInfo.GetRcpWSISortInfo();
	if (pWSISortInfo)
	{
		strItem.Format(_T("RCP_WSI_SORT_TYPE"));
		macroFile.SetItem(strItem, pWSISortInfo->m_nSortType);

		strItem.Format(_T("RCP_WSI_SORT_DATA"));
		macroFile.SetItem(strItem, pWSISortInfo->m_nSortData);

		strItem.Format(_T("RCP_WSI_SORT_PRIORITY"));
		macroFile.SetItem(strItem, pWSISortInfo->m_nSortPriority);
	}

	//Light
	nLightCount = m_rsRcpReviewInfo.GetRcpLightInfoCount();
	strItem.Format(_T("RCP_REVIEW_LIGHT_COUNT"));
	macroFile.SetItem(strItem, nLightCount);

	for(nLightIdx = 0; nLightIdx < nLightCount; nLightIdx++)
	{
		const CRcpLightInfo* pRcpLightInfo = m_rsRcpReviewInfo.GetRcpLightInfo(nLightIdx);
		if(pRcpLightInfo == NULL) continue;

		strItem.Format(_T("RCP_REVIEW_LIGHT_LEVEL_%02d"), nLightIdx);
		macroFile.SetItem(strItem, pRcpLightInfo->m_nLightLevel);

		strItem.Format(_T("RCP_REVIEW_MIN_THRES_LEVEL_%02d"), nLightIdx);
		macroFile.SetItem(strItem, pRcpLightInfo->m_nMinThresLevel);
		
		strItem.Format(_T("RCP_REVIEW_MAX_THRES_LEVEL_%02d"), nLightIdx);
		macroFile.SetItem(strItem, pRcpLightInfo->m_nMaxThresLevel);

		strItem.Format(_T("RCP_REVIEW_AUTO_LIGHT_STEP_%02d"), nLightIdx);
		macroFile.SetItem(strItem, pRcpLightInfo->m_nAutoLightStep);
	}

	//AFM Recipe
	nAFMRecipeCount = m_rsRcpReviewInfo.GetRcpAFMRecipeInfoCount();
	strItem.Format(_T("RCP_REVIEW_AFM_RECIPE_COUNT"));
	macroFile.SetItem(strItem, nAFMRecipeCount);

	for(nAFMRecipeIdx = 0; nAFMRecipeIdx < nAFMRecipeCount; nAFMRecipeIdx++)
	{
		const CRcpAFMRecipeInfo* pRcpAFMRecipeInfo = m_rsRcpReviewInfo.GetRcpAFMRecipeInfo(nAFMRecipeIdx);
		if(pRcpAFMRecipeInfo == NULL) continue;

		strItem.Format(_T("RCP_REVIEW_AFM_RECIPE_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.SetItem(strItem, pRcpAFMRecipeInfo->m_nRecipeIndex);

		strItem.Format(_T("RCP_REVIEW_AFM_ZOOM_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.SetItem(strItem, pRcpAFMRecipeInfo->m_nZoomIndex);

		strItem.Format(_T("RCP_REVIEW_AFM_BASEOFFSET_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.SetItem(strItem, pRcpAFMRecipeInfo->m_dZPosOffset);

		strItem.Format(_T("RCP_REVIEW_AFM_AFMOFFMODE_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.SetItem(strItem, pRcpAFMRecipeInfo->m_nAFMOffMode);
	
		strItem.Format(_T("RCP_REVIEW_AFM_AFMHOMEOFFMODE_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.SetItem(strItem, pRcpAFMRecipeInfo->m_bAFMHomeOffMode);
	}

	//LightWsi
	nLightCountWsi = m_rsRcpReviewInfo.GetRcpWsiLightInfoCount();
	strItem.Format(_T("RCP_WSI_LIGHT_COUNT"));
	macroFile.SetItem(strItem, nLightCountWsi);

	for(nLightIdxWsi = 0; nLightIdxWsi < nLightCountWsi; nLightIdxWsi++)
	{
		const CRcpLightInfo* pRcpLightInfoWsi = m_rsRcpReviewInfo.GetRcpWsiLightInfo(nLightIdxWsi);
		if(pRcpLightInfoWsi == NULL) continue;

		strItem.Format(_T("RCP_WSI_LIGHT_LEVEL_%02d"), nLightIdxWsi);
		macroFile.SetItem(strItem, pRcpLightInfoWsi->m_nLightLevel);

		strItem.Format(_T("RCP_WSI_MIN_THRES_LEVEL_%02d"), nLightIdxWsi);
		macroFile.SetItem(strItem, pRcpLightInfoWsi->m_nMinThresLevel);

		strItem.Format(_T("RCP_WSI_MAX_THRES_LEVEL_%02d"), nLightIdxWsi);
		macroFile.SetItem(strItem, pRcpLightInfoWsi->m_nMaxThresLevel);

		strItem.Format(_T("RCP_WSI_AUTO_LIGHT_STEP_%02d"), nLightIdxWsi);
		macroFile.SetItem(strItem, pRcpLightInfoWsi->m_nAutoLightStep);
	}

	//AFM RecipeWsi
	nAFMRecipeCountWsi = m_rsRcpReviewInfo.GetRcpWsiAFMRecipeInfoCount();
	strItem.Format(_T("RCP_WSI_AFM_RECIPE_COUNT"));
	macroFile.SetItem(strItem, nAFMRecipeCountWsi);
	for(nAFMRecipeIdxWsi = 0; nAFMRecipeIdxWsi < nAFMRecipeCountWsi; nAFMRecipeIdxWsi++)
	{
		const CRcpAFMRecipeInfo* pRcpAFMRecipeInfoWsi = m_rsRcpReviewInfo.GetRcpWsiAFMRecipeInfo(nAFMRecipeIdxWsi);
		if(pRcpAFMRecipeInfoWsi == NULL) continue;

		strItem.Format(_T("RCP_WSI_AFM_RECIPE_INDEX_%02d"), nAFMRecipeIdxWsi);
		macroFile.SetItem(strItem, pRcpAFMRecipeInfoWsi->m_nRecipeIndex);

		strItem.Format(_T("RCP_WSI_AFM_ZOOM_INDEX_%02d"), nAFMRecipeIdxWsi);
		macroFile.SetItem(strItem, pRcpAFMRecipeInfoWsi->m_nZoomIndex);

		strItem.Format(_T("RCP_WSI_AFM_BASEOFFSET_INDEX_%02d"), nAFMRecipeIdxWsi);
		macroFile.SetItem(strItem, pRcpAFMRecipeInfoWsi->m_dZPosOffset);

		strItem.Format(_T("RCP_WSI_AFM_AFMOFFMODE_INDEX_%02d"), nAFMRecipeIdxWsi);
		macroFile.SetItem(strItem, pRcpAFMRecipeInfoWsi->m_nAFMOffMode);
	}

	//Light User
	int nLightCountUser = m_rsRcpReviewInfo.GetRcpUserLightInfoCount();
	strItem.Format(_T("RCP_USER_LIGHT_COUNT"));
	macroFile.SetItem(strItem, nLightCountUser);
	for(nLightIdx = 0; nLightIdx < nLightCountUser; nLightIdx++)
	{
		const CRcpLightInfo* pRcpLightInfo = m_rsRcpReviewInfo.GetRcpUserLightInfo(nLightIdx);
		if(pRcpLightInfo == NULL) continue;

		strItem.Format(_T("RCP_USER_LIGHT_LEVEL_%02d"), nLightIdx);
		macroFile.SetItem(strItem, pRcpLightInfo->m_nLightLevel);

		strItem.Format(_T("RCP_USER_MIN_THRES_LEVEL_%02d"), nLightIdx);
		macroFile.SetItem(strItem, pRcpLightInfo->m_nMinThresLevel);

		strItem.Format(_T("RCP_USER_MAX_THRES_LEVEL_%02d"), nLightIdx);
		macroFile.SetItem(strItem, pRcpLightInfo->m_nMaxThresLevel);

		strItem.Format(_T("RCP_USER_AUTO_LIGHT_STEP_%02d"), nLightIdx);
		macroFile.SetItem(strItem, pRcpLightInfo->m_nAutoLightStep);
	}

	//AFM Recipe User
	int nAFMRecipeCountUser = m_rsRcpReviewInfo.GetRcpUserAFMRecipeInfoCount();
	strItem.Format(_T("RCP_USER_AFM_RECIPE_COUNT"));
	macroFile.SetItem(strItem, nAFMRecipeCountUser);
	for(nAFMRecipeIdx = 0; nAFMRecipeIdx < nAFMRecipeCountUser; nAFMRecipeIdx++)
	{
		const CRcpAFMRecipeInfo* pRcpAFMRecipeInfo = m_rsRcpReviewInfo.GetRcpUserAFMRecipeInfo(nAFMRecipeIdx);
		if(pRcpAFMRecipeInfo == NULL) continue;

		strItem.Format(_T("RCP_USER_AFM_RECIPE_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.SetItem(strItem, pRcpAFMRecipeInfo->m_nRecipeIndex);

		strItem.Format(_T("RCP_USER_AFM_ZOOM_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.SetItem(strItem, pRcpAFMRecipeInfo->m_nZoomIndex);

		strItem.Format(_T("RCP_USER_AFM_BASEOFFSET_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.SetItem(strItem, pRcpAFMRecipeInfo->m_dZPosOffset);

		strItem.Format(_T("RCP_USER_AFM_AFMOFFMODE_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.SetItem(strItem, pRcpAFMRecipeInfo->m_nAFMOffMode);

		strItem.Format(_T("RCP_USER_AFM_AFMHOMEOFFMODE_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.SetItem(strItem, pRcpAFMRecipeInfo->m_bAFMHomeOffMode);
	}

	// light
	strItem.Format(_T("RCP_REVIEW_AUTO_LIGHT"));
	macroFile.SetItem(strItem, (int)m_rsRcpReviewInfo.m_bAutoLight);

	strItem.Format(_T("RCP_WSI_AUTO_LIGHT"));
	macroFile.SetItem(strItem, (int)m_rsRcpReviewInfo.m_bAutoLightWsi);

	// schedule
	const CRcpSchedulingInfo* pScheduleInfo = m_rsRcpReviewInfo.GetRcpSchedulingInfo();
	if (pScheduleInfo)
	{
		strItem.Format(_T("RCP_REVIEW_TAC_TIME_FREE"));
		macroFile.SetItem(strItem, int(pScheduleInfo->GetTacTimeFree()));


		strItem.Format(_T("RCP_REVIEW_MAX_PAD_POINT_COUNT"));
		macroFile.SetItem(strItem, pScheduleInfo->GetMaxPadPointCount());

		///*strItem.Format(_T("RCP_REVIEW_TACT_TIME"));
		//macroFile.SetItem(strItem, pScheduleInfo->GetTacTime());*/

		strItem.Format(_T("RCP_REVIEW_MAX_POINT_COUNT"));
		macroFile.SetItem(strItem, pScheduleInfo->GetMaxPointCount());

		strItem.Format(_T("RCP_REVIEW_MAX_WSI_POINT_COUNT"));
		macroFile.SetItem(strItem, pScheduleInfo->GetMaxWsiPointCount());

		strItem.Format(_T("RCP_REVIEW_SHORTEST_PATH"));
		macroFile.SetItem(strItem, pScheduleInfo->GetShortestPath());

		strItem.Format(_T("RCP_REVIEW_SINGLE_GANRTY_PATH"));
		macroFile.SetItem(strItem, pScheduleInfo->GetSingleGantryPath());

		// range point count
		strItem.Format(_T("RCP_REVIEW_RANGE_USE"));
		macroFile.SetItem(strItem, int(pScheduleInfo->GetUseRangeCntInfo()));

		strItem.Format(_T("RCP_REVIEW_RANGE_LEFT_POINT_COUNT"));
		macroFile.SetItem(strItem, pScheduleInfo->GetRangePointCount(Range_Left));

		strItem.Format(_T("RCP_REVIEW_RANGE_MID_POINT_COUNT"));
		macroFile.SetItem(strItem, pScheduleInfo->GetRangePointCount(Range_Middle));

		strItem.Format(_T("RCP_REVIEW_RANGE_RIGHT_POINT_COUNT"));
		macroFile.SetItem(strItem, pScheduleInfo->GetRangePointCount(Range_Right));
	}

	//User Defect
	nUserDefectCount = m_rsRcpReviewInfo.GetRcpUserDefectInfoCount();
	strItem.Format(_T("RCP_REVIEW_USER_DEFECT_COUNT"));
	macroFile.SetItem(strItem, nUserDefectCount);

	for(nUserDefectIdx = 0; nUserDefectIdx < nUserDefectCount; nUserDefectIdx++)
	{
		const CRcpUserDefectInfo* pRcpUserDefectInfo = m_rsRcpReviewInfo.GetRcpUserDefectInfo(nUserDefectIdx);
		if(pRcpUserDefectInfo == NULL) continue;

		strItem.Format(_T("RCP_REVIEW_USER_DEFECT_POSITION_X_%02d"), nUserDefectIdx);
		macroFile.SetItem(strItem, pRcpUserDefectInfo->m_dPosX);

		strItem.Format(_T("RCP_REVIEW_USER_DEFECT_POSITION_Y_%02d"), nUserDefectIdx);
		macroFile.SetItem(strItem, pRcpUserDefectInfo->m_dPosY);

		strItem.Format(_T("RCP_REVIEW_REFLOW_CELLSIDE_%02d"), nUserDefectIdx);
		macroFile.SetItem(strItem, pRcpUserDefectInfo->m_nCellSide);

		strItem.Format(_T("RCP_REVIEW_REFLOW_INSPECTIONMODE_%02d"), nUserDefectIdx);
		macroFile.SetItem(strItem, pRcpUserDefectInfo->m_nInspectionMode);

		strItem.Format(_T("RCP_REVIEW_USER_DEFECT_CELLID_%02d"), nUserDefectIdx);
		macroFile.SetItem(strItem, pRcpUserDefectInfo->m_strCellId);

		strItem.Format(_T("RCP_REVIEW_USER_DEFECT_CELLID2_%02d"), nUserDefectIdx);
		macroFile.SetItem(strItem, pRcpUserDefectInfo->m_strCellId2);

		strItem.Format(_T("RCP_REVIEW_USER_DEFECT_CELLINDEX_%02d"), nUserDefectIdx);
		macroFile.SetItem(strItem, pRcpUserDefectInfo->m_nReflowCellIndex);

	}

	for(nReflowParameterIdx = 0; nReflowParameterIdx < 3; nReflowParameterIdx++)
	{
		CRcpReflowParameter* pRcpReflowParameter = m_rsRcpReviewInfo.GetRcpReflowParameter(nReflowParameterIdx);
		if (pRcpReflowParameter == NULL) continue;

		strItem.Format(_T("RCP_REVIEW_REFLOW_A_PIXEL_%02d"), nReflowParameterIdx);
		macroFile.SetItem(strItem, pRcpReflowParameter->m_nAPixel);

		strItem.Format(_T("RCP_REVIEW_REFLOW_B_PIXEL_%02d"), nReflowParameterIdx);
		macroFile.SetItem(strItem, pRcpReflowParameter->m_nBPixel);

		strItem.Format(_T("RCP_REVIEW_REFLOW_C_PIXEL_%02d"), nReflowParameterIdx);
		macroFile.SetItem(strItem, pRcpReflowParameter->m_nCPixel);

		strItem.Format(_T("RCP_REVIEW_REFLOW_D_PIXEL_%02d"), nReflowParameterIdx);
		macroFile.SetItem(strItem, pRcpReflowParameter->m_nDPixel);

// 		strItem.Format(_T("RCP_REVIEW_REFLOW_DAM1_%02d"), nReflowParameterIdx);
// 		macroFile.SetItem(strItem, pRcpReflowParameter->m_nDam1);
// 
// 
// 		strItem.Format(_T("RCP_REVIEW_REFLOW_BASETH_%02d"), nReflowParameterIdx);
// 		macroFile.SetItem(strItem, pRcpReflowParameter->m_nBaseTh);
// 
 		strItem.Format(_T("RCP_REVIEW_REFLOW_DAM1TH_%02d"), nReflowParameterIdx);
 		macroFile.SetItem(strItem, pRcpReflowParameter->m_nDam1Th);

		strItem.Format(_T("RCP_REVIEW_REFLOW_DAM2TH_%02d"), nReflowParameterIdx);
		macroFile.SetItem(strItem, pRcpReflowParameter->m_nDam2Th);

		strItem.Format(_T("RCP_REVIEW_REFLOW_DAM3TH_%02d"), nReflowParameterIdx);
		macroFile.SetItem(strItem, pRcpReflowParameter->m_nDam3Th);

		strItem.Format(_T("RCP_REVIEW_REFLOW_DAM4TH_%02d"), nReflowParameterIdx);
		macroFile.SetItem(strItem, pRcpReflowParameter->m_nDam4Th);

		strItem.Format(_T("RCP_REVIEW_REFLOW_MASTER_FILENAME_%02d"), nReflowParameterIdx);
		macroFile.SetItem(strItem, pRcpReflowParameter->m_strMasterFileName);

		strItem.Format(_T("RCP_REVIEW_REFLOW_PIXEL_SCALE_%02d"), nReflowParameterIdx);
		macroFile.SetItem(strItem, pRcpReflowParameter->m_nPixelScale);

	}

	// zone info
	int nZoneCount = m_rsRcpReviewInfo.GetRcpZoneInfoCount();
	strItem.Format(_T("RCP_REVIEW_ZONE_COUNT"));
	macroFile.SetItem(strItem, nZoneCount);
	for (int nZoneIdx = 0; nZoneIdx < nZoneCount; nZoneIdx++)
	{
		const CRcpZoneInfo *pZoneInfo = m_rsRcpReviewInfo.GetRcpZoneInfo(nZoneIdx);
		if (pZoneInfo == NULL) continue;

		// zone text
		strItem.Format(_T("RCP_REVIEW_ZONE_STRING_%02d"), nZoneIdx);
		macroFile.SetItem(strItem, pZoneInfo->GetZoneString());
	}

	// review filer info _TR
     nFilterCount = m_rsRcpReviewInfo.GetRcpZoneFilterInfoCount();
	strItem.Format(_T("RCP_ZONE_FILTER_COUNT"));
	macroFile.SetItem(strItem, nFilterCount);
	for (int nFilterIdx = 0; nFilterIdx < nFilterCount; nFilterIdx++)
	{
		const CRcpZoneFilteringInfo *pFilterInfo = m_rsRcpReviewInfo.GetRcpZoneFilteringInfo(nFilterIdx);
		if (pFilterInfo == NULL) continue;

		// Judge
		strItem.Format(_T("RCP_ZONE_FILTER_JUDGE_%02d"), nFilterIdx);
		macroFile.SetItem(strItem, pFilterInfo->m_nFilterJudge);

		// Type
		strItem.Format(_T("RCP_ZONE_FILTER_TYPE_%02d"), nFilterIdx);
		macroFile.SetItem(strItem, pFilterInfo->m_nFilterType);

		// review count
		//strItem.Format(_T("RCP_REVIEW_FILTER_COUNT_%02d"), nFilterIdx);
		//macroFile.SetItem(strItem, pFilterInfo->m_nReviewCount);

		// judge height
		strItem.Format(_T("RCP_ZONE_FILTER_HEIGHT_%02d"), nFilterIdx);
		macroFile.SetItem(strItem, pFilterInfo->m_dJudgeHeight);
	}

	// review filer info _PR
	nFilterCount = m_rsRcpReviewInfo.GetRcpZoneFilterInfoCount_PR();
	strItem.Format(_T("RCP_ZONE_FILTER_COUNT_PR"));
	macroFile.SetItem(strItem, nFilterCount);
	for (int nFilterIdx = 0; nFilterIdx < nFilterCount; nFilterIdx++)
	{
		const CRcpZoneFilteringInfo *pFilterInfo = m_rsRcpReviewInfo.GetRcpZoneFilteringInfo_PR(nFilterIdx);
		if (pFilterInfo == NULL) continue;

		// Judge
		strItem.Format(_T("RCP_ZONE_FILTER_JUDGE_PR_%02d"), nFilterIdx);
		macroFile.SetItem(strItem, pFilterInfo->m_nFilterJudge);

		// Type
		strItem.Format(_T("RCP_ZONE_FILTER_TYPE_PR_%02d"), nFilterIdx);
		macroFile.SetItem(strItem, pFilterInfo->m_nFilterType);

		// review count
		//strItem.Format(_T("RCP_REVIEW_FILTER_COUNT_%02d"), nFilterIdx);
		//macroFile.SetItem(strItem, pFilterInfo->m_nReviewCount);

		// judge height
		strItem.Format(_T("RCP_ZONE_FILTER_HEIGHT_PR_%02d"), nFilterIdx);
		macroFile.SetItem(strItem, pFilterInfo->m_dJudgeHeight);
	}


	// review filer info _TR
	nFilterCount = m_rsRcpReviewInfo.GetRcpZoneFilterInfoCount_CODE();
	strItem.Format(_T("RCP_ZONE_FILTER_COUNT_CODE"));
	macroFile.SetItem(strItem, nFilterCount);
	for (int nFilterIdx = 0; nFilterIdx < nFilterCount; nFilterIdx++)
	{
		const CRcpZoneFilteringInfo *pFilterInfo = m_rsRcpReviewInfo.GetRcpZoneFilteringInfo_CODE(nFilterIdx);
		if (pFilterInfo == NULL) continue;

		// CODE
		strItem.Format(_T("RCP_ZONE_FILTER_CODE_%02d"), nFilterIdx);
		macroFile.SetItem(strItem, pFilterInfo->m_FilterCode);

		// Judge
		strItem.Format(_T("RCP_ZONE_FILTER_JUDGE_CODE_%02d"), nFilterIdx);
		macroFile.SetItem(strItem, pFilterInfo->m_nFilterJudge);

	}



	//210215
	strItem.Format(_T("RCP_REVIEW_JUDGE_FILTER_AOI_PIXEL_SIZE"));
	macroFile.SetItem(strItem, m_rsRcpReviewInfo.m_nJudgeFilterAoiPixel);


	// judge cell (defect)
	int nJudgeCount = m_rsRcpReviewInfo.GetRcpJudgeCellDefectCount();
	strItem.Format(_T("RCP_REVIEW_JUDGE_CELL_DEFECT_COUNT"));
	macroFile.SetItem(strItem, nJudgeCount);

	for (int nIdx = 0; nIdx < nJudgeCount; nIdx++)
	{
		const CRcpJudgeInfo* pRcpJudgeInfo = m_rsRcpReviewInfo.GetRcpJudgeCellDefectInfo(nIdx);
		if (pRcpJudgeInfo == NULL) continue;

		strItem.Format(_T("RCP_REVIEW_JUDGE_CELL_DEFECT_TYPE_%02d"), nIdx);
		macroFile.SetItem(strItem, pRcpJudgeInfo->GetJudgeType());

		strItem.Format(_T("RCP_REVIEW_JUDGE_CELL_DEFECT_COUNT_%02d"), nIdx);
		macroFile.SetItem(strItem, pRcpJudgeInfo->GetJudgeCount());

		strItem.Format(_T("RCP_REVIEW_JUDGE_CELL_DEFECT_SUB_TYPE_%02d"), nIdx);
		macroFile.SetItem(strItem, pRcpJudgeInfo->GetSubJudgeType());

		strItem.Format(_T("RCP_REVIEW_JUDGE_CELL_DEFECT_SUB_COUNT_%02d"), nIdx);
		macroFile.SetItem(strItem, pRcpJudgeInfo->GetSubJudgeCount());

		strItem.Format(_T("RCP_REVIEW_JUDGE_CELL_DEFECT_REJUDGE_TYPE_%02d"), nIdx);
		macroFile.SetItem(strItem, pRcpJudgeInfo->GetReJudgeType());

		strItem.Format(_T("RCP_REVIEW_JUDGE_CELL_DEFECT_REJUDGE_CODE_%02d"), nIdx);
		macroFile.SetItem(strItem, pRcpJudgeInfo->GetReJudgeCode());
	}

	// judge glass (defect)
	nJudgeCount = m_rsRcpReviewInfo.GetRcpJudgeGlassDefectCount();
	strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_DEFECT_COUNT"));
	macroFile.SetItem(strItem, nJudgeCount);

	for (int nIdx = 0; nIdx < nJudgeCount; nIdx++)
	{
		const CRcpJudgeInfo* pRcpJudgeInfo = m_rsRcpReviewInfo.GetRcpJudgeGlassDefectInfo(nIdx);
		if (pRcpJudgeInfo == NULL) continue;

		strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_DEFECT_TYPE_%02d"), nIdx);
		macroFile.SetItem(strItem, pRcpJudgeInfo->GetJudgeType());

		strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_DEFECT_COUNT_%02d"), nIdx);
		macroFile.SetItem(strItem, pRcpJudgeInfo->GetJudgeCount());

		strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_DEFECT_SUB_TYPE_%02d"), nIdx);
		macroFile.SetItem(strItem, pRcpJudgeInfo->GetSubJudgeType());

		strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_DEFECT_SUB_COUNT_%02d"), nIdx);
		macroFile.SetItem(strItem, pRcpJudgeInfo->GetSubJudgeCount());

		strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_DEFECT_REJUDGE_TYPE_%02d"), nIdx);
		macroFile.SetItem(strItem, pRcpJudgeInfo->GetReJudgeType());

		strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_DEFECT_REJUDGE_CODE_%02d"), nIdx);
		macroFile.SetItem(strItem, pRcpJudgeInfo->GetReJudgeCode());
	}

	// judge glass (cell)
	nJudgeCount = m_rsRcpReviewInfo.GetRcpJudgeGlassCellCount();
	strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_CELL_COUNT"));
	macroFile.SetItem(strItem, nJudgeCount);

	for (int nIdx = 0; nIdx < nJudgeCount; nIdx++)
	{
		const CRcpJudgeInfo* pRcpJudgeInfo = m_rsRcpReviewInfo.GetRcpJudgeGlassCellInfo(nIdx);
		if (pRcpJudgeInfo == NULL) continue;

		strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_CELL_TYPE_%02d"), nIdx);
		macroFile.SetItem(strItem, pRcpJudgeInfo->GetJudgeType());

		strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_CELL_COUNT_%02d"), nIdx);
		macroFile.SetItem(strItem, pRcpJudgeInfo->GetJudgeCount());

		strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_CELL_SUB_TYPE_%02d"), nIdx);
		macroFile.SetItem(strItem, pRcpJudgeInfo->GetSubJudgeType());

		strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_CELL_SUB_COUNT_%02d"), nIdx);
		macroFile.SetItem(strItem, pRcpJudgeInfo->GetSubJudgeCount());

		strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_CELL_REJUDGE_TYPE_%02d"), nIdx);
		macroFile.SetItem(strItem, pRcpJudgeInfo->GetReJudgeType());

		strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_CELL_REJUDGE_CODE_%02d"), nIdx);
		macroFile.SetItem(strItem, pRcpJudgeInfo->GetReJudgeCode());
	}


}

void CRcp_RsReviewManager::GetProfile(CMacroFile& macroFile)
{
	int nPlanIdx, nSlotIdx, nLightIdx, nAFMRecipeIdx, nUserDefectIdx, nReflowParameterIdx;
	int nPlanCount, nLightCount, nAFMRecipeCount, nUserDefectCount, nLightCountWsi, nAFMRecipeCountWsi;
	int nTopReview;
/*	CRcpPlanInfo rcpPlanInfo;
	CRcpDefectPriorityInfo rcpDefectPriorityInfo;
	CRcpSortingPriorityInfo rcpSortingPriorityInfo;
	CRcpLightInfo rcpLightInfo;
	CRcpAFMRecipeInfo rcpAFMRecipeInfo;
	CRcpUserDefectInfo rcpUserDefectInfo;*/
	CString strItem;

	m_rsRcpReviewInfo.Reset();

	strItem.Format(_T("RCP_REVIEW_GLASS_TYPE"));
	macroFile.GetItem(strItem, m_rsRcpReviewInfo.m_nGlassTypeIdx);

	strItem.Format(_T("RCP_REVIEW_GLASS_GLASSORIGIN"));
	macroFile.GetItem(strItem, m_rsRcpReviewInfo.m_nGlassOrigion, 4);

	//Plan
	strItem.Format(_T("RCP_REVIEW_PLAN_COUNT"));
	macroFile.GetItem(strItem, nPlanCount);
	strItem.Format(_T("RCP_REVIEW_TOP_REVIEW"));
	macroFile.GetItem(strItem, nTopReview);
	m_rsRcpReviewInfo.SetTopReview(nTopReview);

	m_rsRcpReviewInfo.SetRcpPlanInfoCount(nPlanCount);

	for(nPlanIdx = 0; nPlanIdx < nPlanCount; nPlanIdx++)
	{
		CRcpPlanInfo* pRcpPlanInfo = m_rsRcpReviewInfo.GetRcpPlanInfo(nPlanIdx);
		if(pRcpPlanInfo == NULL) continue;

		strItem.Format(_T("RCP_REVIEW_PLAN_REVIEW_TYPE_%02d"), nPlanIdx);
		macroFile.GetItem(strItem, pRcpPlanInfo->m_nReviewType);

		for(nSlotIdx = 0; nSlotIdx < TOTAL_GLASS_SLOT_COUNT; nSlotIdx++)
		{
			strItem.Format(_T("RCP_REVIEW_PLAN_%02d_SELECT_SLOT_%02d"), nPlanIdx, nSlotIdx);
			macroFile.GetItem(strItem, pRcpPlanInfo->m_bSelectSlot[nSlotIdx]);
		}
	}

	// Priority
	int nPriorityCount = 0;
	strItem.Format(_T("RCP_REVIEW_PRIORITY_COUNT"));
	macroFile.GetItem(strItem, nPriorityCount);
	m_rsRcpReviewInfo.SetRcpPriorityInfoCount(nPriorityCount);

	for(int nPriorityIdx = 0; nPriorityIdx < nPriorityCount; nPriorityIdx++)
	{
		CRcpPriorityInfo* pRcpPriorityInfo = m_rsRcpReviewInfo.GetRcpPriorityInfo(nPriorityIdx);
		if(pRcpPriorityInfo == NULL) continue;
		CString strData = _T("");
		int nData = 0;
		/*strItem.Format(_T("RCP_REVIEW_PRIORITY_OPTIC_DATA_%02d"), nPriorityIdx); //210608
		macroFile.GetItem(strItem, nData);
		pRcpPriorityInfo->SetPriorityOpticData(nData);*/
		strItem.Format(_T("RCP_REVIEW_PRIORITY_DEFECTCODE_DATA_%02d"), nPriorityIdx); //210608
		macroFile.GetItem(strItem, strData);
		pRcpPriorityInfo->SetPriorityDefectCode(strData);

		strItem.Format(_T("RCP_REVIEW_PRIORITY_USE_SIZEOPTION_%02d"), nPriorityIdx);
		macroFile.GetItem(strItem, nData);
		pRcpPriorityInfo->SetPriorityDefectSizeOption(nData);

		strItem.Format(_T("RCP_REVIEW_PRIORITY_MINSIZE_DATA_%02d"), nPriorityIdx);
		macroFile.GetItem(strItem, nData);
		pRcpPriorityInfo->SetPriorityDefectMinSize(nData);

		strItem.Format(_T("RCP_REVIEW_PRIORITY_MAXSIZE_DATA_%02d"), nPriorityIdx);
		macroFile.GetItem(strItem, nData);
		pRcpPriorityInfo->SetPriorityDefectMaxSize(nData);

		strItem.Format(_T("RCP_REVIEW_PRIORITY_GRAY_DATA_%02d"), nPriorityIdx);
		macroFile.GetItem(strItem, nData);
		pRcpPriorityInfo->SetPriorityGrayData(nData);

		strItem.Format(_T("RCP_REVIEW_PRIORITY_STACK_DATA_%02d"), nPriorityIdx);
		macroFile.GetItem(strItem, nData);
		pRcpPriorityInfo->SetPriorityStackData(nData);

		strItem.Format(_T("RCP_REVIEW_PRIORITY_MODEL_DATA_%02d"), nPriorityIdx);
		macroFile.GetItem(strItem, nData);
		pRcpPriorityInfo->SetPriorityModelData(nData);

		strItem.Format(_T("RCP_REVIEW_PRIORITY_GRADE_DATA_%02d"), nPriorityIdx);
		macroFile.GetItem(strItem, nData);
		pRcpPriorityInfo->SetPriorityGradeData(nData);
	
	}

	// review filer info
	int nFilterCount;

	strItem.Format(_T("RCP_REVIEW_FILTER_COUNT"));
	macroFile.GetItem(strItem, nFilterCount);
	m_rsRcpReviewInfo.SetRcpFilterCount(nFilterCount);
	m_rsRcpReviewInfo.SetRcpReviewFilterInfoCount(nFilterCount);

	for (int nFilterIdx=0; nFilterIdx<nFilterCount; nFilterIdx++)
	{
		CRcpFilteringInfo *pFilterInfo = m_rsRcpReviewInfo.GetRcpReviewFilterInfo(nFilterIdx);
		if (pFilterInfo==NULL) continue;

		// Judge
		strItem.Format(_T("RCP_REVIEW_FILTER_JUDGE_%02d"), nFilterIdx);
		macroFile.GetItem(strItem,pFilterInfo->m_FilterJudge);

		// Subtype
		strItem.Format(_T("RCP_REVIEW_FILTER_SUBTYPE_%02d"), nFilterIdx);
		macroFile.GetItem(strItem,pFilterInfo->m_FilterSubType);

		// Code
		strItem.Format(_T("RCP_REVIEW_FILTER_CODE_%02d"), nFilterIdx);
		macroFile.GetItem(strItem,pFilterInfo->m_FilterCode);
	}

	// review sort info
	CRcpSortingInfo *pReviewSortInfo = m_rsRcpReviewInfo.GetRcpReviewSortInfo();
	if (pReviewSortInfo)
	{
		strItem.Format(_T("RCP_REVIEW_SORT_TYPE"));
		macroFile.GetItem(strItem, pReviewSortInfo->m_nSortType);

		strItem.Format(_T("RCP_REVIEW_SORT_DATA"));
		macroFile.GetItem(strItem, pReviewSortInfo->m_nSortData);

		strItem.Format(_T("RCP_REVIEW_SORT_PRIORITY"));
		macroFile.GetItem(strItem, pReviewSortInfo->m_nSortPriority);
	}

	// review Defocus

	strItem.Format(_T("RCP_REVIEW_USE_DEFOCUS_ALARM"));
	macroFile.GetItem(strItem, m_rsRcpReviewInfo.m_bDefocusUse);
	strItem.Format(_T("RCP_REVIEW_DEFOCUS_VALUE"));
	macroFile.GetItem(strItem, m_rsRcpReviewInfo.m_dDefocusValue);

	// wsi filer info
	//nFilterCount = m_rsRcpReviewInfo.GetRcpWSIFilterInfoCount();

	int nWsiPriorityCount = 0;
	strItem.Format(_T("RCP_WSI_PRIORITY_COUNT"));
	macroFile.GetItem(strItem, nWsiPriorityCount);
	m_rsRcpReviewInfo.SetRcpWsiPriorityInfoCount(nWsiPriorityCount);

	for(int nPriorityIdx = 0; nPriorityIdx < nWsiPriorityCount; nPriorityIdx++)
	{
		CRcpPriorityInfo* pRcpPriorityInfo = m_rsRcpReviewInfo.GetRcpWsiPriorityInfo(nPriorityIdx);
		if(pRcpPriorityInfo == NULL) continue;
		CString strData = _T("");
		int nData = 0;
		/*strItem.Format(_T("RCP_WSI_PRIORITY_DEFECT_TYPE_%02d"), nPriorityIdx);
		macroFile.GetItem(strItem, nData);
		pRcpPriorityInfo->SetPriorityOpticData(nData);*/
		strItem.Format(_T("RCP_WSI_PRIORITY_DEFECTCODE_DATA_%02d"), nPriorityIdx);	//210608
		macroFile.GetItem(strItem, strData);
		pRcpPriorityInfo->SetPriorityDefectCode(strData);

		strItem.Format(_T("RCP_WSI_PRIORITY_USE_SIZEOPTION_%02d"), nPriorityIdx);
		macroFile.GetItem(strItem, nData);
		pRcpPriorityInfo->SetPriorityDefectSizeOption(nData);

		strItem.Format(_T("RCP_WSI_PRIORITY_MINSIZE_DATA_%02d"), nPriorityIdx);
		macroFile.GetItem(strItem, nData);
		pRcpPriorityInfo->SetPriorityDefectMinSize(nData);

		strItem.Format(_T("RCP_WSI_PRIORITY_MAXSIZE_DATA_%02d"), nPriorityIdx);
		macroFile.GetItem(strItem, nData);
		pRcpPriorityInfo->SetPriorityDefectMaxSize(nData);

		strItem.Format(_T("RCP_WSI_PRIORITY_STACK_DATA_%02d"), nPriorityIdx);
		macroFile.GetItem(strItem, nData);
		pRcpPriorityInfo->SetPriorityStackData(nData);

		strItem.Format(_T("RCP_WSI_PRIORITY_GRAY_DATA_%02d"), nPriorityIdx);
		macroFile.GetItem(strItem, nData);
		pRcpPriorityInfo->SetPriorityGrayData(nData);

		strItem.Format(_T("RCP_WSI_PRIORITY_MODEL_DATA_%02d"), nPriorityIdx);
		macroFile.GetItem(strItem, nData);
		pRcpPriorityInfo->SetPriorityModelData(nData);

		strItem.Format(_T("RCP_WSI_PRIORITY_GRADE_DATA_%02d"), nPriorityIdx);
		macroFile.GetItem(strItem, nData);
		pRcpPriorityInfo->SetPriorityGradeData(nData);

	}

	strItem.Format(_T("RCP_WSI_FILTER_COUNT"));
	macroFile.GetItem(strItem, nFilterCount);
	m_rsRcpReviewInfo.SetRcpFilterCountWsi(nFilterCount);
	m_rsRcpReviewInfo.SetRcpWSIFilterInfoCount(nFilterCount);

	for (int nFilterIdx=0; nFilterIdx<nFilterCount; nFilterIdx++)
	{
		CRcpFilteringInfo *pFilterInfo = m_rsRcpReviewInfo.GetRcpWSIFilterInfo(nFilterIdx);
		if (pFilterInfo==NULL) continue;

		// Judge
		strItem.Format(_T("RCP_WSI_FILTER_JUDGE_%02d"), nFilterIdx);
		macroFile.GetItem(strItem, pFilterInfo->m_FilterJudge);

		// SubType
		strItem.Format(_T("RCP_WSI_FILTER_SUBTYPE_%02d"), nFilterIdx);
		macroFile.GetItem(strItem, pFilterInfo->m_FilterSubType);

		// Code
		strItem.Format(_T("RCP_WSI_FILTER_CODE_%02d"), nFilterIdx);
		macroFile.GetItem(strItem, pFilterInfo->m_FilterCode);
	}

	// wsi sort info
	CRcpSortingInfo *pWSISortInfo = m_rsRcpReviewInfo.GetRcpWSISortInfo();
	if (pWSISortInfo)
	{
		strItem.Format(_T("RCP_WSI_SORT_TYPE"));
		macroFile.GetItem(strItem, pWSISortInfo->m_nSortType);

		strItem.Format(_T("RCP_WSI_SORT_DATA"));
		macroFile.GetItem(strItem, pWSISortInfo->m_nSortData);

		strItem.Format(_T("RCP_WSI_SORT_PRIORITY"));
		macroFile.GetItem(strItem, pWSISortInfo->m_nSortPriority);
	}

	//Light
	strItem.Format(_T("RCP_REVIEW_LIGHT_COUNT"));
	macroFile.GetItem(strItem, nLightCount);
	m_rsRcpReviewInfo.SetRcpLightInfoCount(nLightCount);

	for(nLightIdx = 0; nLightIdx < nLightCount; nLightIdx++)
	{
		CRcpLightInfo* pPcpLightInfo = m_rsRcpReviewInfo.GetRcpLightInfo(nLightIdx);
		if(pPcpLightInfo == NULL) continue;

		strItem.Format(_T("RCP_REVIEW_LIGHT_LEVEL_%02d"), nLightIdx);
		macroFile.GetItem(strItem, pPcpLightInfo->m_nLightLevel);

		strItem.Format(_T("RCP_REVIEW_MIN_THRES_LEVEL_%02d"), nLightIdx);
		macroFile.GetItem(strItem, pPcpLightInfo->m_nMinThresLevel);

		strItem.Format(_T("RCP_REVIEW_MAX_THRES_LEVEL_%02d"), nLightIdx);
		macroFile.GetItem(strItem, pPcpLightInfo->m_nMaxThresLevel);

		strItem.Format(_T("RCP_REVIEW_AUTO_LIGHT_STEP_%02d"), nLightIdx);
		macroFile.GetItem(strItem, pPcpLightInfo->m_nAutoLightStep);
	}

	//AFM Recipe
	strItem.Format(_T("RCP_REVIEW_AFM_RECIPE_COUNT"));
	macroFile.GetItem(strItem, nAFMRecipeCount);
	m_rsRcpReviewInfo.SetRcpAFMRecipeInfoCount(nAFMRecipeCount);

	for(nAFMRecipeIdx = 0; nAFMRecipeIdx < nAFMRecipeCount; nAFMRecipeIdx++)
	{
		CRcpAFMRecipeInfo* pRcpAFMRecipeInfo = m_rsRcpReviewInfo.GetRcpAFMRecipeInfo(nAFMRecipeIdx);
		if(pRcpAFMRecipeInfo == NULL) continue;

		strItem.Format(_T("RCP_REVIEW_AFM_RECIPE_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.GetItem(strItem, pRcpAFMRecipeInfo->m_nRecipeIndex);

		strItem.Format(_T("RCP_REVIEW_AFM_ZOOM_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.GetItem(strItem, pRcpAFMRecipeInfo->m_nZoomIndex);

		strItem.Format(_T("RCP_REVIEW_AFM_BASEOFFSET_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.GetItem(strItem, pRcpAFMRecipeInfo->m_dZPosOffset);

		strItem.Format(_T("RCP_REVIEW_AFM_AFMOFFMODE_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.GetItem(strItem, pRcpAFMRecipeInfo->m_nAFMOffMode);

		strItem.Format(_T("RCP_REVIEW_AFM_AFMHOMEOFFMODE_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.GetItem(strItem, pRcpAFMRecipeInfo->m_bAFMHomeOffMode);
	}

	//Light Wsi
	strItem.Format(_T("RCP_WSI_LIGHT_COUNT"));
	macroFile.GetItem(strItem, nLightCountWsi);
	m_rsRcpReviewInfo.SetRcpWsiLightInfoCount(nLightCountWsi);

	for(nLightIdx = 0; nLightIdx < nLightCountWsi; nLightIdx++)
	{
		CRcpLightInfo* pPcpLightInfoWsi = m_rsRcpReviewInfo.GetRcpWsiLightInfo(nLightIdx);
		if(pPcpLightInfoWsi == NULL) continue;

		strItem.Format(_T("RCP_WSI_LIGHT_LEVEL_%02d"), nLightIdx);
		macroFile.GetItem(strItem, pPcpLightInfoWsi->m_nLightLevel);

		strItem.Format(_T("RCP_WSI_MIN_THRES_LEVEL_%02d"), nLightIdx);
		macroFile.GetItem(strItem, pPcpLightInfoWsi->m_nMinThresLevel);

		strItem.Format(_T("RCP_WSI_MAX_THRES_LEVEL_%02d"), nLightIdx);
		macroFile.GetItem(strItem, pPcpLightInfoWsi->m_nMaxThresLevel);

		strItem.Format(_T("RCP_WSI_AUTO_LIGHT_STEP_%02d"), nLightIdx);
		macroFile.GetItem(strItem, pPcpLightInfoWsi->m_nAutoLightStep);
	}

	//AFM RecipeWsi
	strItem.Format(_T("RCP_WSI_AFM_RECIPE_COUNT"));
	macroFile.GetItem(strItem, nAFMRecipeCountWsi);
	m_rsRcpReviewInfo.SetRcpWsiAFMRecipeInfoCount(nAFMRecipeCountWsi);

	for(nAFMRecipeIdx = 0; nAFMRecipeIdx < nAFMRecipeCountWsi; nAFMRecipeIdx++)
	{
		CRcpAFMRecipeInfo* pRcpAFMRecipeInfoWsi = m_rsRcpReviewInfo.GetRcpWsiAFMRecipeInfo(nAFMRecipeIdx);
		if(pRcpAFMRecipeInfoWsi == NULL) continue;

		strItem.Format(_T("RCP_WSI_AFM_RECIPE_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.GetItem(strItem, pRcpAFMRecipeInfoWsi->m_nRecipeIndex);

		strItem.Format(_T("RCP_WSI_AFM_ZOOM_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.GetItem(strItem, pRcpAFMRecipeInfoWsi->m_nZoomIndex);

		strItem.Format(_T("RCP_WSI_AFM_BASEOFFSET_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.GetItem(strItem, pRcpAFMRecipeInfoWsi->m_dZPosOffset);

		strItem.Format(_T("RCP_WSI_AFM_AFMOFFMODE_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.GetItem(strItem, pRcpAFMRecipeInfoWsi->m_nAFMOffMode);

		strItem.Format(_T("RCP_WSI_AFM_AFMHOMEOFFMODE_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.GetItem(strItem, pRcpAFMRecipeInfoWsi->m_bAFMHomeOffMode);
	}
	
	//Light User
	int nLightCountUser = 0;
	strItem.Format(_T("RCP_USER_LIGHT_COUNT"));
	macroFile.GetItem(strItem, nLightCountUser);
	m_rsRcpReviewInfo.SetRcpUserLightInfoCount(nLightCountUser);
	for(nLightIdx = 0; nLightIdx < nLightCountUser; nLightIdx++)
	{
		CRcpLightInfo* pRcpLightInfo = m_rsRcpReviewInfo.GetRcpUserLightInfo(nLightIdx);
		if(pRcpLightInfo == NULL) continue;

		strItem.Format(_T("RCP_USER_LIGHT_LEVEL_%02d"), nLightIdx);
		macroFile.GetItem(strItem, pRcpLightInfo->m_nLightLevel);

		strItem.Format(_T("RCP_USER_MIN_THRES_LEVEL_%02d"), nLightIdx);
		macroFile.GetItem(strItem, pRcpLightInfo->m_nMinThresLevel);

		strItem.Format(_T("RCP_USER_MAX_THRES_LEVEL_%02d"), nLightIdx);
		macroFile.GetItem(strItem, pRcpLightInfo->m_nMaxThresLevel);

		strItem.Format(_T("RCP_USER_AUTO_LIGHT_STEP_%02d"), nLightIdx);
		macroFile.GetItem(strItem, pRcpLightInfo->m_nAutoLightStep);
	}

	//AFM Recipe User
	int nAFMRecipeCountUser = 0;
	strItem.Format(_T("RCP_USER_AFM_RECIPE_COUNT"));
	macroFile.GetItem(strItem, nAFMRecipeCountUser);
	m_rsRcpReviewInfo.SetRcpUserAFMRecipeInfoCount(nAFMRecipeCountUser);
	for(nAFMRecipeIdx = 0; nAFMRecipeIdx < nAFMRecipeCountUser; nAFMRecipeIdx++)
	{
		CRcpAFMRecipeInfo* pRcpAFMRecipeInfo = m_rsRcpReviewInfo.GetRcpUserAFMRecipeInfo(nAFMRecipeIdx);
		if(pRcpAFMRecipeInfo == NULL) continue;

		strItem.Format(_T("RCP_USER_AFM_RECIPE_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.GetItem(strItem, pRcpAFMRecipeInfo->m_nRecipeIndex);

		strItem.Format(_T("RCP_USER_AFM_ZOOM_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.GetItem(strItem, pRcpAFMRecipeInfo->m_nZoomIndex);

		strItem.Format(_T("RCP_USER_AFM_BASEOFFSET_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.GetItem(strItem, pRcpAFMRecipeInfo->m_dZPosOffset);

		strItem.Format(_T("RCP_USER_AFM_AFMOFFMODE_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.GetItem(strItem, pRcpAFMRecipeInfo->m_nAFMOffMode);

		strItem.Format(_T("RCP_USER_AFM_AFMHOMEOFFMODE_INDEX_%02d"), nAFMRecipeIdx);
		macroFile.GetItem(strItem, pRcpAFMRecipeInfo->m_bAFMHomeOffMode);
	
	}

	// auto light
	strItem.Format(_T("RCP_REVIEW_AUTO_LIGHT"));
	macroFile.GetItem(strItem, (int)m_rsRcpReviewInfo.m_bAutoLight);

	strItem.Format(_T("RCP_WSI_AUTO_LIGHT"));
	macroFile.GetItem(strItem, (int)m_rsRcpReviewInfo.m_bAutoLightWsi);

	// schedule
	CRcpSchedulingInfo* pScheduleInfo = m_rsRcpReviewInfo.GetRcpSchedulingInfo();
	if (pScheduleInfo)
	{
		int nData = 0;
		strItem.Format(_T("RCP_REVIEW_TAC_TIME_FREE"));
		macroFile.GetItem(strItem, nData);
		pScheduleInfo->SetTacTimeFree(nData);


		strItem.Format(_T("RCP_REVIEW_MAX_PAD_POINT_COUNT"));
		macroFile.GetItem(strItem, nData);
		pScheduleInfo->SetMaxPadPointCount(nData);

		/*strItem.Format(_T("RCP_REVIEW_TACT_TIME"));
		macroFile.GetItem(strItem, nData);
		pScheduleInfo->SetTacTime(nData);*/

		strItem.Format(_T("RCP_REVIEW_MAX_POINT_COUNT"));
		macroFile.GetItem(strItem, nData);
		pScheduleInfo->SetMaxPointCount(nData);

		strItem.Format(_T("RCP_REVIEW_SINGLE_GANRTY_PATH"));
		macroFile.GetItem(strItem, nData);
		pScheduleInfo->SetSingleGantryPath(nData);


		strItem.Format(_T("RCP_REVIEW_MAX_WSI_POINT_COUNT"));
		macroFile.GetItem(strItem, nData);
		pScheduleInfo->SetMaxWsiPointCount(nData);

		strItem.Format(_T("RCP_REVIEW_SHORTEST_PATH"));
		macroFile.GetItem(strItem, nData);
		pScheduleInfo->SetShortestPath(nData);

		// range point count
		strItem.Format(_T("RCP_REVIEW_RANGE_USE"));
		macroFile.GetItem(strItem, nData);
		pScheduleInfo->SetUseRangeCntInfo(nData);

		strItem.Format(_T("RCP_REVIEW_RANGE_LEFT_POINT_COUNT"));
		macroFile.GetItem(strItem, nData);
		pScheduleInfo->SetRangePointCount(Range_Left, nData);

		strItem.Format(_T("RCP_REVIEW_RANGE_MID_POINT_COUNT"));
		macroFile.GetItem(strItem, nData);
		pScheduleInfo->SetRangePointCount(Range_Middle, nData);

		strItem.Format(_T("RCP_REVIEW_RANGE_RIGHT_POINT_COUNT"));
		macroFile.GetItem(strItem, nData);
		pScheduleInfo->SetRangePointCount(Range_Right, nData);
	}
	
	//User Defect
	strItem.Format(_T("RCP_REVIEW_USER_DEFECT_COUNT"));
	macroFile.GetItem(strItem, nUserDefectCount);
	m_rsRcpReviewInfo.SetRcpUserDefectInfoCount(nUserDefectCount);

	for(nUserDefectIdx = 0; nUserDefectIdx < nUserDefectCount; nUserDefectIdx++)
	{
		CRcpUserDefectInfo* pRcpUserDefectInfo = m_rsRcpReviewInfo.GetRcpUserDefectInfo(nUserDefectIdx);

		strItem.Format(_T("RCP_REVIEW_USER_DEFECT_POSITION_X_%02d"), nUserDefectIdx);
		macroFile.GetItem(strItem, pRcpUserDefectInfo->m_dPosX);

		strItem.Format(_T("RCP_REVIEW_USER_DEFECT_POSITION_Y_%02d"), nUserDefectIdx);
		macroFile.GetItem(strItem, pRcpUserDefectInfo->m_dPosY);

		strItem.Format(_T("RCP_REVIEW_REFLOW_CELLSIDE_%02d"), nUserDefectIdx);
		macroFile.GetItem(strItem, pRcpUserDefectInfo->m_nCellSide);

		strItem.Format(_T("RCP_REVIEW_REFLOW_INSPECTIONMODE_%02d"), nUserDefectIdx);
		macroFile.GetItem(strItem, pRcpUserDefectInfo->m_nInspectionMode);

		strItem.Format(_T("RCP_REVIEW_USER_DEFECT_CELLID_%02d"), nUserDefectIdx);
		macroFile.GetItem(strItem, pRcpUserDefectInfo->m_strCellId);

		strItem.Format(_T("RCP_REVIEW_USER_DEFECT_CELLID2_%02d"), nUserDefectIdx);
		macroFile.GetItem(strItem, pRcpUserDefectInfo->m_strCellId2);

		strItem.Format(_T("RCP_REVIEW_USER_DEFECT_CELLINDEX_%02d"), nUserDefectIdx);
		macroFile.GetItem(strItem, pRcpUserDefectInfo->m_nReflowCellIndex);
	}

	m_rsRcpReviewInfo.SetRcpReflowParameterCount(3);
	for(nReflowParameterIdx = 0; nReflowParameterIdx < 3; nReflowParameterIdx++)
	{
		CRcpReflowParameter* pRcpReflowParameter = m_rsRcpReviewInfo.GetRcpReflowParameter(nReflowParameterIdx);
		if (pRcpReflowParameter == NULL) continue;

		strItem.Format(_T("RCP_REVIEW_REFLOW_A_PIXEL_%02d"), nReflowParameterIdx);
		macroFile.GetItem(strItem, pRcpReflowParameter->m_nAPixel);

		strItem.Format(_T("RCP_REVIEW_REFLOW_B_PIXEL_%02d"), nReflowParameterIdx);
		macroFile.GetItem(strItem, pRcpReflowParameter->m_nBPixel);

		strItem.Format(_T("RCP_REVIEW_REFLOW_C_PIXEL_%02d"), nReflowParameterIdx);
		macroFile.GetItem(strItem, pRcpReflowParameter->m_nCPixel);

		strItem.Format(_T("RCP_REVIEW_REFLOW_D_PIXEL_%02d"), nReflowParameterIdx);
		macroFile.GetItem(strItem, pRcpReflowParameter->m_nDPixel);

// 		strItem.Format(_T("RCP_REVIEW_REFLOW_DAM1_%02d"), nReflowParameterIdx);
// 		macroFile.GetItem(strItem, pRcpReflowParameter->m_nDam1);
// 
// 
// 		strItem.Format(_T("RCP_REVIEW_REFLOW_BASETH_%02d"), nReflowParameterIdx);
// 		macroFile.GetItem(strItem, pRcpReflowParameter->m_nBaseTh);
// 
 		strItem.Format(_T("RCP_REVIEW_REFLOW_DAM1TH_%02d"), nReflowParameterIdx);
 		macroFile.GetItem(strItem, pRcpReflowParameter->m_nDam1Th);

		strItem.Format(_T("RCP_REVIEW_REFLOW_DAM2TH_%02d"), nReflowParameterIdx);
		macroFile.GetItem(strItem, pRcpReflowParameter->m_nDam2Th);

		strItem.Format(_T("RCP_REVIEW_REFLOW_DAM3TH_%02d"), nReflowParameterIdx);
		macroFile.GetItem(strItem, pRcpReflowParameter->m_nDam3Th);

		strItem.Format(_T("RCP_REVIEW_REFLOW_DAM4TH_%02d"), nReflowParameterIdx);
		macroFile.GetItem(strItem, pRcpReflowParameter->m_nDam4Th);

		strItem.Format(_T("RCP_REVIEW_REFLOW_MASTER_FILENAME_%02d"), nReflowParameterIdx);
		macroFile.GetItem(strItem, pRcpReflowParameter->m_strMasterFileName);


		strItem.Format(_T("RCP_REVIEW_REFLOW_PIXEL_SCALE_%02d"), nReflowParameterIdx);
		macroFile.GetItem(strItem, pRcpReflowParameter->m_nPixelScale);

	}


	CString strItemText;
	// zone info
	int nZoneCount = 0;
	strItem.Format(_T("RCP_REVIEW_ZONE_COUNT"));
	macroFile.GetItem(strItem, nZoneCount, 2);
	m_rsRcpReviewInfo.SetRcpZoneInfoCount(nZoneCount);

	for (int nZoneIdx = 0; nZoneIdx < nZoneCount; nZoneIdx++)
	{
		CRcpZoneInfo *pZoneInfo = m_rsRcpReviewInfo.GetRcpZoneInfo(nZoneIdx);
		if (pZoneInfo == NULL) continue;

		pZoneInfo->m_nZoneType = nZoneIdx;

		// zone text
		strItem.Format(_T("RCP_REVIEW_ZONE_STRING_%02d"), nZoneIdx);
		macroFile.GetItem(strItem, strItemText);
		pZoneInfo->SetZoneString(strItemText);
	}

	// review filer info
	nFilterCount = 0;
	strItem.Format(_T("RCP_ZONE_FILTER_COUNT"));
	macroFile.GetItem(strItem, nFilterCount, 0);
	m_rsRcpReviewInfo.SetRcpZoneFilterInfoCount(nFilterCount);
	for (int nFilterIdx = 0; nFilterIdx < nFilterCount; nFilterIdx++)
	{
		CRcpZoneFilteringInfo *pFilterInfo = m_rsRcpReviewInfo.GetRcpZoneFilteringInfo(nFilterIdx);
		if (pFilterInfo == NULL) continue;
		int nData = 0;
		// Judge
		strItem.Format(_T("RCP_ZONE_FILTER_JUDGE_%02d"), nFilterIdx);
		macroFile.GetItem(strItem, pFilterInfo->m_nFilterJudge);
		

		// Type
		strItem.Format(_T("RCP_ZONE_FILTER_TYPE_%02d"), nFilterIdx);
		macroFile.GetItem(strItem, pFilterInfo->m_nFilterType);

		// review count
		//strItem.Format(_T("RCP_REVIEW_FILTER_COUNT_%02d"), nFilterIdx);
		//macroFile.SetItem(strItem, pFilterInfo->m_nReviewCount);

		// judge height
		strItem.Format(_T("RCP_ZONE_FILTER_HEIGHT_%02d"), nFilterIdx);
		macroFile.GetItem(strItem, pFilterInfo->m_dJudgeHeight);
	}

	// review filer info
	nFilterCount = 0;
	strItem.Format(_T("RCP_ZONE_FILTER_COUNT_PR"));
	macroFile.GetItem(strItem, nFilterCount, 0);
	m_rsRcpReviewInfo.SetRcpZoneFilterInfoCount_PR(nFilterCount);
	for (int nFilterIdx = 0; nFilterIdx < nFilterCount; nFilterIdx++)
	{
		CRcpZoneFilteringInfo *pFilterInfo = m_rsRcpReviewInfo.GetRcpZoneFilteringInfo_PR(nFilterIdx);
		if (pFilterInfo == NULL) continue;
		int nData = 0;
		// Judge
		strItem.Format(_T("RCP_ZONE_FILTER_JUDGE_PR_%02d"), nFilterIdx);
		macroFile.GetItem(strItem, pFilterInfo->m_nFilterJudge);


		// Type
		strItem.Format(_T("RCP_ZONE_FILTER_TYPE_PR_%02d"), nFilterIdx);
		macroFile.GetItem(strItem, pFilterInfo->m_nFilterType);

		// review count
		//strItem.Format(_T("RCP_REVIEW_FILTER_COUNT_%02d"), nFilterIdx);
		//macroFile.SetItem(strItem, pFilterInfo->m_nReviewCount);

		// judge height
		strItem.Format(_T("RCP_ZONE_FILTER_HEIGHT_PR_%02d"), nFilterIdx);
		macroFile.GetItem(strItem, pFilterInfo->m_dJudgeHeight);
	}


	// review filer info
	nFilterCount = 0;
	strItem.Format(_T("RCP_ZONE_FILTER_COUNT_CODE"));
	macroFile.GetItem(strItem, nFilterCount, 0);
	m_rsRcpReviewInfo.SetRcpZoneFilterInfoCount_CODE(nFilterCount);
	for (int nFilterIdx = 0; nFilterIdx < nFilterCount; nFilterIdx++)
	{
		CRcpZoneFilteringInfo *pFilterInfo = m_rsRcpReviewInfo.GetRcpZoneFilteringInfo_CODE(nFilterIdx);
		if (pFilterInfo == NULL) continue;
		int nData = 0;
		// CODE
		strItem.Format(_T("RCP_ZONE_FILTER_CODE_%02d"), nFilterIdx);
		macroFile.GetItem(strItem, pFilterInfo->m_FilterCode);

		// judge
		strItem.Format(_T("RCP_ZONE_FILTER_JUDGE_CODE_%02d"), nFilterIdx);
		macroFile.GetItem(strItem, pFilterInfo->m_nFilterJudge);
	}


	//210215
	strItem.Format(_T("RCP_REVIEW_JUDGE_FILTER_AOI_PIXEL_SIZE"));
	macroFile.GetItem(strItem, m_rsRcpReviewInfo.m_nJudgeFilterAoiPixel);

	// judge cell (defect)
	int nJudgeCount = 0;
	strItem.Format(_T("RCP_REVIEW_JUDGE_CELL_DEFECT_COUNT"));
	macroFile.GetItem(strItem, nJudgeCount, 0);
	m_rsRcpReviewInfo.SetRcpJudgeCellDefectCount(nJudgeCount);

	for (int nIdx = 0; nIdx < nJudgeCount; nIdx++)
	{
		CRcpJudgeInfo* pRcpJudgeInfo = m_rsRcpReviewInfo.GetRcpJudgeCellDefectInfo(nIdx);
		if (pRcpJudgeInfo == NULL) continue;

		int nData = 0;
		CString strData = _T("");
		strItem.Format(_T("RCP_REVIEW_JUDGE_CELL_DEFECT_TYPE_%02d"), nIdx);
		macroFile.GetItem(strItem, nData);
		pRcpJudgeInfo->SetJudgeType(nData);

		strItem.Format(_T("RCP_REVIEW_JUDGE_CELL_DEFECT_COUNT_%02d"), nIdx);
		macroFile.GetItem(strItem, nData);
		pRcpJudgeInfo->SetJudgeCount(nData);

		strItem.Format(_T("RCP_REVIEW_JUDGE_CELL_DEFECT_SUB_TYPE_%02d"), nIdx);
		macroFile.GetItem(strItem, nData);
		pRcpJudgeInfo->SetSubJudgeType(nData);

		strItem.Format(_T("RCP_REVIEW_JUDGE_CELL_DEFECT_SUB_COUNT_%02d"), nIdx);
		macroFile.GetItem(strItem, nData);
		pRcpJudgeInfo->SetSubJudgeCount(nData);

		strItem.Format(_T("RCP_REVIEW_JUDGE_CELL_DEFECT_REJUDGE_TYPE_%02d"), nIdx);
		macroFile.GetItem(strItem, nData);
		pRcpJudgeInfo->SetReJudgeType(nData);

		strItem.Format(_T("RCP_REVIEW_JUDGE_CELL_DEFECT_REJUDGE_CODE_%02d"), nIdx);
		macroFile.GetItem(strItem, strData);
		pRcpJudgeInfo->SetReJudgeCode(strData);
	}

	// judge glass (defect)
	strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_DEFECT_COUNT"));
	macroFile.GetItem(strItem, nJudgeCount, 0);
	m_rsRcpReviewInfo.SetRcpJudgeGlassDefectCount(nJudgeCount);

	for (int nIdx = 0; nIdx < nJudgeCount; nIdx++)
	{
		CRcpJudgeInfo* pRcpJudgeInfo = m_rsRcpReviewInfo.GetRcpJudgeGlassDefectInfo(nIdx);
		if (pRcpJudgeInfo == NULL) continue;

		int nData = 0;
		CString strData = _T("");
		strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_DEFECT_TYPE_%02d"), nIdx);
		macroFile.GetItem(strItem, nData);
		pRcpJudgeInfo->SetJudgeType(nData);

		strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_DEFECT_COUNT_%02d"), nIdx);
		macroFile.GetItem(strItem, nData);
		pRcpJudgeInfo->SetJudgeCount(nData);

		strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_DEFECT_SUB_TYPE_%02d"), nIdx);
		macroFile.GetItem(strItem, nData);
		pRcpJudgeInfo->SetSubJudgeType(nData);

		strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_DEFECT_SUB_COUNT_%02d"), nIdx);
		macroFile.GetItem(strItem, nData);
		pRcpJudgeInfo->SetSubJudgeCount(nData);

		strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_DEFECT_REJUDGE_TYPE_%02d"), nIdx);
		macroFile.GetItem(strItem, nData);
		pRcpJudgeInfo->SetReJudgeType(nData);

		strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_DEFECT_REJUDGE_CODE_%02d"), nIdx);
		macroFile.GetItem(strItem, strData);
		pRcpJudgeInfo->SetReJudgeCode(strData);
	}

	// judge glass (cell)
	strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_CELL_COUNT"));
	macroFile.GetItem(strItem, nJudgeCount, 0);
	m_rsRcpReviewInfo.SetRcpJudgeGlassCellCount(nJudgeCount);

	for (int nIdx = 0; nIdx < nJudgeCount; nIdx++)
	{
		CRcpJudgeInfo* pRcpJudgeInfo = m_rsRcpReviewInfo.GetRcpJudgeGlassCellInfo(nIdx);
		if (pRcpJudgeInfo == NULL) continue;

		int nData = 0;
		CString strData = _T("");
		strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_CELL_TYPE_%02d"), nIdx);
		macroFile.GetItem(strItem, nData);
		pRcpJudgeInfo->SetJudgeType(nData);

		strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_CELL_COUNT_%02d"), nIdx);
		macroFile.GetItem(strItem, nData);
		pRcpJudgeInfo->SetJudgeCount(nData);

		strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_CELL_SUB_TYPE_%02d"), nIdx);
		macroFile.GetItem(strItem, nData);
		pRcpJudgeInfo->SetSubJudgeType(nData);

		strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_CELL_SUB_COUNT_%02d"), nIdx);
		macroFile.GetItem(strItem, nData);
		pRcpJudgeInfo->SetSubJudgeCount(nData);

		strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_CELL_REJUDGE_TYPE_%02d"), nIdx);
		macroFile.GetItem(strItem, nData);
		pRcpJudgeInfo->SetReJudgeType(nData);

		strItem.Format(_T("RCP_REVIEW_JUDGE_GLASS_CELL_REJUDGE_CODE_%02d"), nIdx);
		macroFile.GetItem(strItem, strData);
		pRcpJudgeInfo->SetReJudgeCode(strData);
	}
}