#include "StdAfx.h"
#include "CHResultFileManager/ResultFileManager_CPJT.h"
#include "ResultFileData_CPJT.h"
#include "ResultFileData.h"
#include <fstream>
#include <algorithm>


CResultFileManager_CPJT::CResultFileManager_CPJT(void)
{

}

CResultFileManager_CPJT::~CResultFileManager_CPJT(void)
{

}

void CResultFileManager_CPJT::ResetResultFile()
{
	CResultFileManager::ResetResultFile();
}

void CResultFileManager_CPJT::CreateRandomDefect()
{

}
//°øÀ¯¸Þ¸ð¸®
BOOL CResultFileManager_CPJT::ReadAOIRawMemory(const CString& strFilePath,CDitGlassRawClient* dit){
	
	return TRUE;
}
BOOL CResultFileManager_CPJT::ReadAOIRaw(const CString& strFilePath) 
{



	ResetResultFile();

	///////////////////////////////////////////////////////////////////////
	//Aoi ÆÄÀÏÀ» ¿­¾î¶ó !
	std::ifstream FileRaw;
	FileRaw.open(strFilePath, std::ios::in);

	if (!FileRaw.is_open())
	{
		FileRaw.close();
		return FALSE;
	}

	CString strLineHeader, strData;
	char strLine[STR_LINE_SIZE] = {0, }; 
	char strLineTemp[STR_LINE_SIZE] = {0, }; 
	char *strTemp = NULL;
	char *strType = NULL;
	int nIdx=0;

	m_nLineCount = 0;

	BOOL bHeaderBegin=FALSE, bHeaderEnd=FALSE, bGlassBegin=FALSE, bGlassEnd=FALSE, bEqpGlassBegin=FALSE, bEqpGlassEnd=FALSE,
		bBlockBegin=FALSE, bBlockEnd=FALSE, bPanelBegin=FALSE, bPanelEnd=FALSE, bDefectBegin=FALSE, bDefectEnd=FALSE;

	int nHeaderCnt=0, nGlassCnt=0, nEqpGlassCnt=0, nBlockCnt=0, nPanelCnt=0, nDefectCnt=0 ;
	


	do
	{
		// ÇÑ ¶óÀÎ Àоî¿À±â.
		ZeroMemory(strLine, STR_LINE_SIZE);
		FileRaw.getline(strLine, STR_LINE_SIZE);

		if (strLine[0] == '\0' || strLine[0] == 0)
			break;

		for(int i=0; i<STR_LINE_SIZE; i++){
			if(strLine != " "){
				strLineTemp[i]= strLine[i];
			}
			else if(strLine == " "){
				return 0 ;
			}
		}

		strTemp = strtok_s(strLine, " ",&strType);
		if (strTemp == NULL)
		{
			m_nLineCount++;
			continue;
		}

		strLineHeader = strTemp;
		//°ø¹éÀº ¹Ì¸® ´Ù Áö¿î´Ù.
		strLineHeader.Remove(' ');
	
		if (strLineHeader.Compare(STR_HEADER_BEGIN) == 0)		// header info
		{
			pDataHeader = new CDataHeader_CPJT;

			bHeaderBegin = TRUE;
			continue;
		}
		else if (strLineHeader.Compare(STR_HEADER_END) == 0)
		{
			
			bHeaderBegin = FALSE;
			bHeaderEnd = TRUE;
			continue;
		}
		else if (strLineHeader.Compare(STR_GLASS_BEGIN) == 0)	// glass info
		{
			
			m_pItemGlass = new CDataGlass_CPJT;
			
			bHeaderEnd = FALSE;
			bGlassBegin = TRUE;
			continue;
		}
		else if (strLineHeader.Compare(STR_GLASS_END) == 0)
		{
			bGlassBegin = FALSE;
			bGlassEnd = TRUE;
			continue;
		}
		else if (strLineHeader.Compare(STR_EQPGLASS_BEGIN) == 0)	// eqp glass info
		{
			m_pItemEqpGlass = new CDataEqpGlass_CPJT;
			
			bGlassEnd = FALSE;
			bEqpGlassBegin = TRUE;
			continue;
		}
		else if (strLineHeader.Compare(STR_EQPGLASS_END) == 0)
		{
		
			bEqpGlassBegin = FALSE;
			bEqpGlassEnd = TRUE;
			continue;
		}
		else if (strLineHeader.Compare(STR_BLOCK_BEGIN) == 0)	// block info
		{
			m_pItemBlock = new CDataBlock_CPJT;
		
			bEqpGlassEnd = FALSE;
			bBlockBegin = TRUE;
			continue;
		}
		else if (strLineHeader.Compare(STR_BLOCK_END) == 0)
		{
			bBlockBegin = FALSE;
			bBlockEnd = TRUE;
			continue;
		}
		else if (strLineHeader.Compare(STR_PANEL_BEGIN) == 0)	// panel info
		{
			m_pItemCell =new CDataCell_CPJT;
			
			bBlockEnd = FALSE;
			bPanelBegin = TRUE;
			continue;
		}
		else if (strLineHeader.Compare(STR_PANEL_END) == 0)
		{

			bPanelBegin = FALSE;
			bPanelEnd = TRUE;
			continue;
		}
		else if (strLineHeader.Compare(STR_DEFECT_BEGIN) == 0)	// defect info
		{

			m_pItemDefect = new CDataDefect_CPJT;

			bPanelEnd = FALSE;
			bDefectBegin = TRUE;
			continue;
		}
		else if (strLineHeader.Compare(STR_DEFECT_END) == 0)
		{
			bDefectBegin = FALSE;
			bDefectEnd = TRUE;
			continue;
		}

		if (bHeaderBegin)	// header info
		{ 
			strTemp = strtok_s(strLine, " ",&strType);
			if (strTemp == NULL)
				continue;

			
			pDataHeader->m_nLineIdx = m_nLineCount;
			pDataHeader->m_vecDataHeader[nHeaderCnt].SetLength(strlen(strTemp));
			pDataHeader->m_vecDataHeader[nHeaderCnt].SetData(strTemp);
			

			if(nHeaderCnt==4){
				m_vecDataHeader.push_back(pDataHeader);
			}

			m_nHeaderCount=nHeaderCnt++;

			
		    
		}
		else if (bGlassBegin)
		{
			nIdx = 0;
			
			if (nGlassCnt==0)		// glass item
			{
				m_pItemGlass->m_nLineIdx = m_nLineCount;
				for (int i = 0; i < CPJT_RAW_ITEMGLASSINFO_COUNT; i++)
				{
					
					strTemp = strtok_s(strLineTemp, " ",&strType);
					if (strTemp == NULL)
						continue;
					m_pItemGlass->m_vecDataGlass[i].SetLength(strlen(strTemp));
					m_pItemGlass->m_vecDataGlass[i].SetData(strTemp);
					
					for(int j=0; j<STR_LINE_SIZE; j++){
						if(strType != " "){
							strLineTemp[j]= strType[j];
						}
					
					}

				}
			}
			else					// glass data
			{
				pDataGlass = new CDataGlass_CPJT;

				pDataGlass->m_nLineIdx = m_nLineCount;

				for (int i = 0; i < CPJT_RAW_ITEMGLASSINFO_COUNT; i++)
				{
					strTemp = strtok_s(strLineTemp, " ",&strType);
					if (strTemp == NULL)
						continue;
					pDataGlass->m_vecDataGlass[i].SetLength(strlen(strTemp));
					pDataGlass->m_vecDataGlass[i].SetData(strTemp);

					for(int j=0; j<STR_LINE_SIZE; j++){
						if(strType != " "){
							strLineTemp[j]= strType[j];
						}
					}
				}
				m_vecDataGlass.push_back(pDataGlass);

			}
			m_nGlassCount=nGlassCnt++;
		}	

		else if (bEqpGlassBegin)
		{

			if (nEqpGlassCnt==0)		// glass item
			{
				
				for (int i = 0; i < CPJT_RAW_ITEMEQPGLASSINFO_COUNT; i++)
				{
					strTemp = strtok_s(strLineTemp, " ",&strType);
					if (strTemp == NULL)
						continue;
					m_pItemEqpGlass->m_vecDataGlass[i].SetLength(strlen(strTemp));
					m_pItemEqpGlass->m_vecDataGlass[i].SetData(strTemp);

					for(int j=0; j<STR_LINE_SIZE; j++){
						if(strType != " "){
							strLineTemp[j]= strType[j];
						}
					
					}
				}
			}
			else{

				pDataEQPGlass = new CDataEqpGlass_CPJT;
				pDataEQPGlass->m_nLineIdx = m_nLineCount;
				
				for (int i = 0; i < CPJT_RAW_ITEMEQPGLASSINFO_COUNT; i++)
				{
					strTemp = strtok_s(strLineTemp, " ",&strType);
					if (strTemp == NULL)
						continue;

					pDataEQPGlass->m_vecDataGlass[i].SetLength(strlen(strTemp));
					pDataEQPGlass->m_vecDataGlass[i].SetData(strTemp);

					for(int j=0; j<STR_LINE_SIZE; j++){
						if(strType != " "){
							strLineTemp[j]= strType[j];
						}
					}
				}
				m_vecDataEqpGlass.push_back(pDataEQPGlass);
			}
			m_nEqpGlassCount= nEqpGlassCnt++;
		}

		else if (bBlockBegin)
		{


			if (nBlockCnt==0)		// glass item
			{

				
				for (int i = 0; i < CPJT_RAW_ITEMBLOCKINFO_COUNT; i++)
				{
					strTemp = strtok_s(strLineTemp, " ",&strType);
					if (strTemp == NULL)
						continue;
			    m_pItemBlock->m_vecDataBlock[i].SetLength(strlen(strTemp));
					m_pItemBlock->m_vecDataBlock[i].SetData(strTemp);

					for(int j=0; j<STR_LINE_SIZE; j++){
						if(strType != " "){
							strLineTemp[j]= strType[j];
						}
					
					}
				}
			}
			else					// glass data
			{
				 pDataBock = new CDataBlock_CPJT;

				pDataBock->m_nLineIdx = m_nLineCount;

				for (int i = 0; i < CPJT_RAW_ITEMBLOCKINFO_COUNT; i++)
				{
					strTemp = strtok_s(strLineTemp, " ",&strType);
					if (strTemp == NULL)
						continue;

					pDataBock->m_vecDataBlock[i].SetLength(strlen(strTemp));
					pDataBock->m_vecDataBlock[i].SetData(strTemp);

					for(int j=0; j<STR_LINE_SIZE; j++){
						if(strType != " "){
							strLineTemp[j]= strType[j];
						}
						
					}
				}
				m_vecDataBlock.push_back(pDataBock);

			}
			m_nBlockCount=nBlockCnt++;
		}

		else if (bPanelBegin)
		{

			if (nPanelCnt==0)		// glass item
			{
				
				for (int i = 0; i < CPJT_RAW_ITEMPANELINFO_COUNT; i++)
				{
					strTemp = strtok_s(strLineTemp, " ",&strType);
					if (strTemp == NULL)
						continue;

					m_pItemCell->m_vecDataCell[i].SetLength(strlen(strTemp));
					m_pItemCell->m_vecDataCell[i].SetData(strTemp);

					for(int j=0; j<STR_LINE_SIZE; j++){
						if(strType != " "){
							strLineTemp[j]= strType[j];
						}
					
					}
				}
			}
			else					// glass data
			{
					pDataCell = new CDataCell_CPJT;
				pDataCell->m_nLineIdx = m_nLineCount;

				for (int i = 0; i < CPJT_RAW_ITEMPANELINFO_COUNT; i++)
				{
					strTemp = strtok_s(strLineTemp, " ",&strType);
					if (strTemp == NULL)
						continue;

				
					pDataCell->m_vecDataCell[i].SetLength(strlen(strTemp));
					pDataCell->m_vecDataCell[i].SetData(strTemp);

					for(int j=0; j<STR_LINE_SIZE; j++){
						if(strType != " "){
							strLineTemp[j]= strType[j];
						}
					
					}
					
				}
				
				m_vecDataCell.push_back(pDataCell);
			
			}
			m_nCellCount= nPanelCnt++;
				
		}
		else if (bDefectBegin)
		{

			if (nDefectCnt==0)		
			{
				
				for (int i = 0; i < CPJT_RAW_ITEMDEFECTINFO_COUNT; i++)
				{
					strTemp = strtok_s(strLineTemp, " ",&strType);
					if (strTemp == NULL)
						continue;
					m_pItemDefect->m_vecDataDefect[i].SetLength(strlen(strTemp));
				m_pItemDefect->m_vecDataDefect[i].SetData(strTemp);

				for(int j=0; j<STR_LINE_SIZE; j++){
					if(strType != " "){
						strLineTemp[j]= strType[j];
					}
				
				}
				}
			}
			else					
			{

				pDataDefect = new CDataDefect_CPJT;
				pDataDefect->m_nLineIdx = m_nLineCount;

				for (int i = 0; i < CPJT_RAW_ITEMDEFECTINFO_COUNT; i++)
				{
					strTemp = strtok_s(strLineTemp, " ",&strType);
					if (strTemp == NULL)
						continue;

					pDataDefect->m_vecDataDefect[i].SetLength(strlen(strTemp));
					pDataDefect->m_vecDataDefect[i].SetData(strTemp);
					for(int j=0; j<STR_LINE_SIZE; j++){
						if(strType != " "){
							strLineTemp[j]= strType[j];
						}
					
					}
	              
				}
				m_vecDataDefect.push_back(pDataDefect);

			}
		m_nDefectCount =nDefectCnt++;

		}
		else
		{

		}

		m_nLineCount++;

	} while(!FileRaw.eof()); // End of file±îÁö Àд´Ù. 	

	FileRaw.close();

	//Size Setting
	//for(i = 0; i < eCPJTRaw_Count; i++)
	//	m_nCSOTRawCount[i] = (int)m_vecCSOTRaw[i].size();

	return TRUE;
}

BOOL CResultFileManager_CPJT::MakeReviewInfoData( int nTotalCnt, int nUserCnt )
{
	return TRUE;
}


BOOL CResultFileManager_CPJT::WriteAOIRaw(CString strFilePath)
{
	BOOL bRet = TRUE;
	int nSize=0, nLineCount=0, nIdx=0;
	char* strTemp = NULL;
	CFile rawFile;

	if(m_nLineCount == 0)
		return FALSE;	

#ifdef _UNICODE
	nSize = WideCharToMultiByte(CP_ACP, 0, strFilePath.GetBuffer(), -1, NULL, 0, NULL,NULL); 
	strTemp = new char[nSize]; 
	WideCharToMultiByte(CP_ACP, 0, strFilePath.GetBuffer(), -1, strTemp, nSize, NULL, NULL); 
#else
	nSize = strFilePath.GetLength();
	strTemp = new char[nSize+1]; 
	memcpy(strTemp, strFilePath.GetBuffer(), sizeof(char)*nSize);
	strTemp[nSize] = NULL;
#endif

	return TRUE;
}

BOOL CResultFileManager_CPJT::WriteMeasureRaw(CString strFilePath)
{
	return TRUE;
}

BOOL CResultFileManager_CPJT::WriteMeasureRawITEM(FILE *fp, int nItemIdx/*=-1*/)
{
	return TRUE;
}

BOOL CResultFileManager_CPJT::WriteMeasureRawData(FILE *fp, int nItemIdx/*=-1*/)
{
	return TRUE;
}

BOOL CResultFileManager_CPJT::WriteAOIRawITEM( FILE *fp, int nItemIdx/*=-1*/ )
{
	BOOL bReturn = TRUE;

	if(fp == NULL)
		return FALSE;

	int i;

	switch (nItemIdx)
	{
	case RAW_IDX_HEADER:
		// header
		fprintf(fp, "HEADER_BEGIN");
		fprintf(fp, "%c%c", 0x0d, 0x0a);
		break;

	case RAW_IDX_GLASS:
		// glass header
		fprintf(fp, "GLASS_DATA_BEGIN");
		fprintf(fp, "%c%c", 0x0d, 0x0a);

		for (i = 0; i < CPJT_RAW_ITEMGLASSINFO_COUNT; i++)
		{
			m_pItemGlass->m_vecDataGlass[i].WriteToFileData(fp);
			if (i < CPJT_RAW_ITEMGLASSINFO_COUNT - 1)
				fprintf(fp, " ");
		}
		fprintf(fp, "%c%c", 0x0d, 0x0a);
		break;

	case RAW_IDX_EQPGLASS:
		// eqp glass header
		break;

	case RAW_IDX_BLOCK:
		// block header
		break;

	case RAW_IDX_PANEL:
		// panel header
		break;

	case RAW_IDX_DEFECT:
		// defect header
		break;

	default:
		bReturn = FALSE;
		break;
	}

	return bReturn;
}

BOOL CResultFileManager_CPJT::WriteAOIRawData( FILE *fp, int nItemIdx/*=-1*/ )
{
	BOOL bReturn = TRUE;

	if(fp == NULL)
		return FALSE;

	int i;

	switch (nItemIdx)
	{
	case RAW_IDX_HEADER:
		// header data
		for (VectorDataHeaderIt it=m_vecDataHeader.begin(); it!=m_vecDataHeader.end(); it++)
		{
			CDataHeader* pDataHeader = (*it);
			pDataHeader->m_vecDataHeader[0].WriteToFileData(fp);
			fprintf(fp, "%c%c", 0x0d, 0x0a);
		}
		fprintf(fp, "%c%c", 0x0d, 0x0a);
		break;

	case RAW_IDX_GLASS:
		// glass data
		for (VectorDataGlassIt it=m_vecDataGlass.begin(); it!=m_vecDataGlass.end(); it++)
		{
			CDataGlass* pDataGlass = (*it);
			for (i = 0; i < CPJT_RAW_ITEMGLASSINFO_COUNT; i++)
			{
				pDataGlass->m_vecDataGlass[i].WriteToFileData(fp);
				if (i < CPJT_RAW_ITEMGLASSINFO_COUNT - 1)
					fprintf(fp, " ");
			}
			fprintf(fp, "%c%c", 0x0d, 0x0a);
		}
		break;

	case RAW_IDX_EQPGLASS:
		// eqp glass data
		break;

	case RAW_IDX_BLOCK:
		// block data
		break;

	case RAW_IDX_PANEL:
		// panel data
		break;

	case RAW_IDX_DEFECT:
		// Defect Data
		break;

	default:
		bReturn = FALSE;
		break;
	}

	return bReturn;
}

BOOL CResultFileManager_CPJT::SetHeaderData( int nLineIdx, int nDataIdx, char* strData )
{
	return TRUE;
}

BOOL CResultFileManager_CPJT::SetHeaderData( int nLineIdx, int nDataIdx, int nData )
{
	return TRUE;
}

BOOL CResultFileManager_CPJT::SetHeaderData( int nLineIdx, int nDataIdx, double dData )
{
	return TRUE;
}

char* CResultFileManager_CPJT::GetHeaderData( int nLineIdx, int nDataIdx )
{
	return m_vecDataHeader[nLineIdx]->m_vecDataHeader[nDataIdx].GetData();
}

BOOL CResultFileManager_CPJT::SetGlassData(int nLineIdx, int nDataIdx, char* strData)
{
	if (nLineIdx < 0 || nLineIdx >= m_nGlassCount || nLineIdx >= int(m_vecDataGlass.size()))
		return FALSE;

	if (nDataIdx < 0 || nDataIdx >= CPJT_RAW_ITEMGLASSINFO_COUNT)
		return FALSE;

	if(m_vecDataGlass[nLineIdx] == NULL)
		return FALSE;

	m_vecDataGlass[nLineIdx]->m_vecDataGlass[nDataIdx].ResetString();
	m_vecDataGlass[nLineIdx]->m_vecDataGlass[nDataIdx].SetData(strData);

	return TRUE;
}

BOOL CResultFileManager_CPJT::SetGlassData(int nLineIdx, int nDataIdx, int nData)
{
	if (nLineIdx < 0 || nLineIdx >= m_nGlassCount || nLineIdx >= int(m_vecDataGlass.size()))
		return FALSE;

	if (nDataIdx < 0 || nDataIdx >= CPJT_RAW_ITEMGLASSINFO_COUNT)
		return FALSE;

	if(m_vecDataGlass[nLineIdx] == NULL)
		return FALSE;

	m_vecDataGlass[nLineIdx]->m_vecDataGlass[nDataIdx].SetData(nData);

	return TRUE;
}

BOOL CResultFileManager_CPJT::SetGlassData(int nLineIdx, int nDataIdx, double dData)
{
	if (nLineIdx < 0 || nLineIdx >= m_nGlassCount || nLineIdx >= int(m_vecDataGlass.size()))
		return FALSE;

	if (nDataIdx < 0 || nDataIdx >= CPJT_RAW_ITEMGLASSINFO_COUNT)
		return FALSE;

	if(m_vecDataGlass[nLineIdx] == NULL)
		return FALSE;

	m_vecDataGlass[nLineIdx]->m_vecDataGlass[nDataIdx].SetData(dData);

	return TRUE;
}

char* CResultFileManager_CPJT::GetGlassData(int nLineIdx, int nDataIdx)
{
	if (nLineIdx < 0 || nLineIdx >= m_nGlassCount || nLineIdx >= int(m_vecDataGlass.size()))
		return NULL;

	if (nDataIdx < 0 || nDataIdx >= CPJT_RAW_ITEMGLASSINFO_COUNT)
		return NULL;

	if(m_vecDataGlass[nLineIdx] == NULL)
		return NULL;

	return m_vecDataGlass[nLineIdx]->m_vecDataGlass[nDataIdx].GetData();
}

BOOL CResultFileManager_CPJT::SetEqpGlassData( int nLineIdx, int nDataIdx, char* strData )
{
	return TRUE;
}

BOOL CResultFileManager_CPJT::SetEqpGlassData( int nLineIdx, int nDataIdx, int nData )
{
	return TRUE;
}

BOOL CResultFileManager_CPJT::SetEqpGlassData( int nLineIdx, int nDataIdx, double dData )
{
	return TRUE;
}

char* CResultFileManager_CPJT::GetEqpGlassData( int nLineIdx, int nDataIdx )
{
	return NULL;
}

BOOL CResultFileManager_CPJT::SetBlockData( int nLineIdx, int nDataIdx, char* strData )
{
	return TRUE;
}

BOOL CResultFileManager_CPJT::SetBlockData( int nLineIdx, int nDataIdx, int nData )
{
	return TRUE;
}

BOOL CResultFileManager_CPJT::SetBlockData( int nLineIdx, int nDataIdx, double dData )
{
	return TRUE;
}

char* CResultFileManager_CPJT::GetBlockData( int nLineIdx, int nDataIdx )
{
	return NULL;
}

BOOL CResultFileManager_CPJT::SetCellData(int nLineIdx, int nDataIdx, char* strData)
{
	if (nLineIdx < 0 || nLineIdx >= m_nCellCount || nLineIdx >= int(m_vecDataCell.size()))
		return FALSE;

	if (nDataIdx < 0 || nDataIdx >= CPJT_RAW_ITEMPANELINFO_COUNT)
		return FALSE;

	if(m_vecDataCell[nLineIdx] == NULL)
		return FALSE;

	m_vecDataCell[nLineIdx]->m_vecDataCell[nDataIdx].ResetString();
	m_vecDataCell[nLineIdx]->m_vecDataCell[nDataIdx].SetData(strData);

	return TRUE;
}

BOOL CResultFileManager_CPJT::SetCellData(int nLineIdx, int nDataIdx, int nData)
{
	if (nLineIdx < 0 || nLineIdx >= m_nCellCount || nLineIdx >= int(m_vecDataCell.size()))
		return FALSE;

	if (nDataIdx < 0 || nDataIdx >= CPJT_RAW_ITEMPANELINFO_COUNT)
		return FALSE;

	if(m_vecDataCell[nLineIdx] == NULL)
		return FALSE;

	m_vecDataCell[nLineIdx]->m_vecDataCell[nDataIdx].SetData(nData);

	return TRUE;
}

BOOL CResultFileManager_CPJT::SetCellData(int nLineIdx, int nDataIdx, double dData)
{
	if (nLineIdx < 0 || nLineIdx >= m_nCellCount || nLineIdx >= int(m_vecDataCell.size()))
		return FALSE;

	if (nDataIdx < 0 || nDataIdx >= CPJT_RAW_ITEMPANELINFO_COUNT)
		return FALSE;

	if(m_vecDataCell[nLineIdx] == NULL)
		return FALSE;

	m_vecDataCell[nLineIdx]->m_vecDataCell[nDataIdx].SetData(dData);

	return TRUE;
}

char* CResultFileManager_CPJT::GetCellData(int nLineIdx, int nDataIdx)
{
	;
	if (nLineIdx < 0 || nLineIdx >= m_nCellCount || nLineIdx >= int(m_vecDataCell.size()))
	return NULL;

	if (nDataIdx < 0 || nDataIdx >= CPJT_RAW_ITEMPANELINFO_COUNT)
	return NULL;

	if(m_vecDataCell[nLineIdx] == NULL)
	return NULL;

	
	return m_vecDataCell[nLineIdx]->m_vecDataCell[nDataIdx].GetData();

}


BOOL CResultFileManager_CPJT::SetDefectData(int nLineIdx, int nDataIdx, char* strData)
{
	if (nLineIdx < 0 || nLineIdx >= m_nDefectCount || nLineIdx >= int(m_vecDataDefect.size()))
		return FALSE;

	if (nDataIdx < 0 || nDataIdx >= CPJT_RAW_ITEMDEFECTINFO_COUNT)
		return FALSE;

	if(m_vecDataDefect[nLineIdx] == NULL)
		return FALSE;

	m_vecDataDefect[nLineIdx]->m_vecDataDefect[nDataIdx].ResetString();
	m_vecDataDefect[nLineIdx]->m_vecDataDefect[nDataIdx].SetData(strData);

	return TRUE;
}

BOOL CResultFileManager_CPJT::SetDefectData(int nLineIdx, int nDataIdx, int nData)
{
	if (nLineIdx < 0 || nLineIdx >= m_nDefectCount || nLineIdx >= int(m_vecDataDefect.size()))
		return FALSE;

	if (nDataIdx < 0 || nDataIdx >= CPJT_RAW_ITEMDEFECTINFO_COUNT)
		return FALSE;

	if(m_vecDataDefect[nLineIdx] == NULL)
		return FALSE;

	m_vecDataDefect[nLineIdx]->m_vecDataDefect[nDataIdx].SetData(nData);

	return TRUE;
}

BOOL CResultFileManager_CPJT::SetDefectData(int nLineIdx, int nDataIdx, double dData)
{
	if (nLineIdx < 0 || nLineIdx >= m_nDefectCount || nLineIdx >= int(m_vecDataDefect.size()))
		return FALSE;

	if (nDataIdx < 0 || nDataIdx >= CPJT_RAW_ITEMDEFECTINFO_COUNT)
		return FALSE;

	if(m_vecDataDefect[nLineIdx] == NULL)
		return FALSE;

	m_vecDataDefect[nLineIdx]->m_vecDataDefect[nDataIdx].SetData(dData);

	return TRUE;
}

char* CResultFileManager_CPJT::GetDefectData(int nLineIdx, int nDataIdx)
{
	if (nLineIdx < 0 || nLineIdx >= m_nDefectCount || nLineIdx >= int(m_vecDataDefect.size()))
		return NULL;

	if (nDataIdx < 0 || nDataIdx >= CPJT_RAW_ITEMDEFECTINFO_COUNT)
		return NULL;

	if(m_vecDataDefect[nLineIdx] == NULL)
		return NULL;

	return m_vecDataDefect[nLineIdx]->m_vecDataDefect[nDataIdx].GetData();
}

void CResultFileManager_CPJT::AddWsiReflowDefectData( int nWsiReflowDefectCount )
{
	//int nIdx = 0;
	//////////////////////////////////////////////////////////////////////////
	//for (int nCnt = 0; nCnt < nWsiReflowDefectCount; nCnt++)
	//{
	//	CDataDefect* pReflowDataDefect = new CDataDefect_B11E_IJP;
	//	nIdx = 0;		  
	//	for (int v =0; v< B11ERAW_ITEMDEFECTINFO_COUNT-1; v++)
	//	{
	//		switch (v)
	//		{
	//		case 2:	//3. DEFECT_CODE
	//			pReflowDataDefect->m_vecDataDefect[v].SetData("OF");
	//			break;
	//		case 3://4. DEFECT_NAME
	//			pReflowDataDefect->m_vecDataDefect[v].SetData("DAM1");
	//			break;
	//		case 22://23. DEFECT_TYPE_1
	//			pReflowDataDefect->m_vecDataDefect[v].SetData("A");
	//			break;
	//		case 23://24. DEFECT_TYPE_2
	//			pReflowDataDefect->m_vecDataDefect[v].SetData("O");
	//			break;

	//		default:
	//			pReflowDataDefect->m_vecDataDefect[v].SetData("***");
	//			break;
	//		}


	//	}
	//	pReflowDataDefect->m_vecDataDefect[nIdx].SetData("DFT_INF_DATA");		// Separator

	//}
	//int nPanelCount = (int)m_vecB11Raw[5].size();
	//nPanelCount;
	////	m_vecB7PH2Raw[4].resize(nPanelCount);
	////	m_vecB7PH2Raw[5].resize(nPanelCount);
	////	m_vecB7PH2Raw[6].resize(nPanelCount);
	////	m_vecB7PH2Raw[7].resize(nPanelCount);

	//if (nWsiReflowDefectCount>0)
	//{
	//	CDataPanelIInfo_B11E* pPanelInfo = new CDataPanelIInfo_B11E;
	//	pPanelInfo->m_vecData[nIdx]->SetData("PNL_INF");
	//	pPanelInfo->m_nLineIdx = m_nLineCount++;
	//	for (int u = 1; u<B11ERAW_ITEMPANELINFO_COUNT; u++)
	//	{
	//		pPanelInfo->m_vecData[u]->SetData(m_vecB11Raw[eB11ERaw_PanelInfoItem][m_vecB11Raw[eB11ERaw_PanelInfoItem].size()-1]->m_vecData[u]->GetData()); ;
	//	}

	//	m_vecB11Raw[eB11ERaw_PanelInfoItem].push_back(pPanelInfo);
	//	m_nB11RawCount[eB11ERaw_PanelInfoItem]++;

	//	CDataPanelIInfo_B11E* pPanelInfoData = new CDataPanelIInfo_B11E;
	//	pPanelInfoData->m_vecData[nIdx]->SetData("PNL_INF_DATA");
	//	pPanelInfoData->m_nLineIdx = m_nLineCount++;
	//	for (int u = 1; u<B11ERAW_ITEMPANELINFO_COUNT; u++)
	//	{
	//		pPanelInfoData->m_vecData[u]->SetData(m_vecB11Raw[eB11ERaw_PanelInfoData][m_vecB11Raw[eB11ERaw_PanelInfoData].size()-1]->m_vecData[u]->GetData());
	//	}
	//	m_vecB11Raw[eB11ERaw_PanelInfoData].push_back(pPanelInfoData);
	//	m_nB11RawCount[eB11ERaw_PanelInfoData]++;

	//	CDataPanelSum_B11E* pPanelSum = new CDataPanelSum_B11E;
	//	pPanelSum->m_vecData[nIdx]->SetData("PNL_SUM");
	//	pPanelSum->m_nLineIdx = m_nLineCount++;
	//	for (int u = 1; u<B11ERAW_ITEMPANELSUM_COUNT; u++)
	//	{
	//		pPanelSum->m_vecData[u]->SetData(m_vecB11Raw[eB11ERaw_PanelSumItem][m_vecB11Raw[eB11ERaw_PanelSumItem].size()-1]->m_vecData[u]->GetData());
	//	}
	//	m_vecB11Raw[eB11ERaw_PanelSumItem].push_back(pPanelSum);
	//	m_nB11RawCount[eB11ERaw_PanelSumItem]++;

	//	CDataPanelSum_B11E* pPanelSumData = new CDataPanelSum_B11E;
	//	pPanelSumData->m_vecData[nIdx]->SetData("PNL_SUM_DATA");
	//	pPanelSumData->m_nLineIdx = m_nLineCount++;
	//	for (int u = 1; u<B11ERAW_ITEMPANELSUM_COUNT; u++)
	//	{
	//		pPanelSumData->m_vecData[u]->SetData(m_vecB11Raw[eB11ERaw_PanelSumData][m_vecB11Raw[eB11ERaw_PanelSumData].size()-1]->m_vecData[u]->GetData());
	//	}
	//	m_vecB11Raw[eB11ERaw_PanelSumData].push_back(pPanelSumData);
	//	m_nB11RawCount[eB11ERaw_PanelSumData]++;

	//	CDataDefectIInfo_B11E* pPanelDefect = new CDataDefectIInfo_B11E;
	//	pPanelDefect->m_vecData[nIdx]->SetData("DFT_INF");
	//	pPanelDefect->m_nLineIdx = m_nLineCount++;
	//	if (m_vecB11Raw[eB11ERaw_DefectInfoItem].size() == 0)
	//	{
	//		int u = 1;
	//		//			pPanelDefect->m_vecData[u]->SetData("PNL_DFT");
	//		pPanelDefect->m_vecData[u++]->SetData("FIELD_COUNT");
	//		pPanelDefect->m_vecData[u++]->SetData("POINT_NO");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_CODE");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_NAME");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_TYPE");
	//		pPanelDefect->m_vecData[u++]->SetData("PR_COOR_X");
	//		pPanelDefect->m_vecData[u++]->SetData("PR_COOR_Y");
	//		pPanelDefect->m_vecData[u++]->SetData("SE_COOR_X");
	//		pPanelDefect->m_vecData[u++]->SetData("SE_COOR_Y");
	//		pPanelDefect->m_vecData[u++]->SetData("PNL_ID");
	//		pPanelDefect->m_vecData[u++]->SetData("PNL_COOR_X");
	//		pPanelDefect->m_vecData[u++]->SetData("PNL_COOR_Y");
	//		pPanelDefect->m_vecData[u++]->SetData("TE_COOR_X");
	//		pPanelDefect->m_vecData[u++]->SetData("TE_COOR_Y");
	//		pPanelDefect->m_vecData[u++]->SetData("MARK_TYPE");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_HEIGHT");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_LAYER");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_LAYER_DESC");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_SIZE_TYPE");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_SIZE_X");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_SIZE_Y");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_LENGTH");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_AREA");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_PEEK");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_TYPE_1");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_TYPE_2");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_ZONE");
	//		pPanelDefect->m_vecData[u++]->SetData("REPEAT_DFT");
	//		pPanelDefect->m_vecData[u++]->SetData("ME_CODE");
	//		pPanelDefect->m_vecData[u++]->SetData("A_RATION");
	//		pPanelDefect->m_vecData[u++]->SetData("MASK_DFT");
	//		pPanelDefect->m_vecData[u++]->SetData("CAMERA_NO");
	//		pPanelDefect->m_vecData[u++]->SetData("IMAGE_DATA");
	//		pPanelDefect->m_vecData[u++]->SetData("STACK_FLAG ");
	//		pPanelDefect->m_vecData[u++]->SetData("STACK_STEP_CNT");
	//		pPanelDefect->m_vecData[u++]->SetData("STACK_STEP_LIST");
	//	}
	//	else
	//	{
	//		for (int u = 1; u<B11ERAW_ITEMDEFECTINFO_COUNT; u++)
	//		{
	//			pPanelDefect->m_vecData[u]->SetData(m_vecB11Raw[eB11ERaw_DefectInfoItem][m_vecB11Raw[eB11ERaw_DefectInfoItem].size()-1]->m_vecData[u]->GetData());
	//		}
	//	}
	//	m_vecB11Raw[eB11ERaw_DefectInfoItem].push_back(pPanelDefect);
	//	m_nB11RawCount[eB11ERaw_DefectInfoItem]++;
	//}
	//////////////////////////////////////////////// <

	//for (int i = 0; i < nWsiReflowDefectCount;i++)
	//{
	//	nIdx = 0;
	//	CDataDefectIInfo_B11E* pPanelDefectData = new CDataDefectIInfo_B11E;
	//	pPanelDefectData->m_nLineIdx = m_nLineCount++;
	//	pPanelDefectData->m_vecData[nIdx]->SetData("DFT_INF_DATA");

	//	for (int u = 1; u<B11ERAW_ITEMDEFECTINFO_COUNT-1; u++)
	//	{
	//		pPanelDefectData->m_vecData[u]->SetData("");
	//	}
	//	m_vecB11Raw[eB11ERaw_DefectInfoData].push_back(pPanelDefectData);
	//	m_nB11RawCount[eB11ERaw_DefectInfoData]++;
	//}
}

void CResultFileManager_CPJT::AddReflowDefectData( int nReflowDefectCount )
{
	//int nIdx = 0;
	//////////////////////////////////////////////////////////////////////////
	//for (int nCnt = 0; nCnt < nReflowDefectCount; nCnt++)
	//{
	//	CDataDefect* pReflowDataDefect = new CDataDefect_B11E_IJP;
	//	nIdx = 0;		  
	//	for (int v =0; v< B11ERAW_ITEMDEFECTINFO_COUNT-1; v++)
	//	{
	//		switch (v)
	//		{
	//		case 2:	//3. DEFECT_CODE
	//			pReflowDataDefect->m_vecDataDefect[v].SetData("OF");
	//			break;
	//		case 3://4. DEFECT_NAME
	//			pReflowDataDefect->m_vecDataDefect[v].SetData("DAM1");
	//			break;
	//		case 22://23. DEFECT_TYPE_1
	//			pReflowDataDefect->m_vecDataDefect[v].SetData("A");
	//			break;
	//		case 23://24. DEFECT_TYPE_2
	//			pReflowDataDefect->m_vecDataDefect[v].SetData("O");
	//			break;

	//		default:
	//			pReflowDataDefect->m_vecDataDefect[v].SetData("***");
	//			break;
	//		}


	//	}
	//	pReflowDataDefect->m_vecDataDefect[nIdx].SetData("DFT_INF_DATA");		// Separator

	//}
	//int nPanelCount = (int)m_vecB11Raw[5].size();
	//nPanelCount;
	////	m_vecB7PH2Raw[4].resize(nPanelCount);
	////	m_vecB7PH2Raw[5].resize(nPanelCount);
	////	m_vecB7PH2Raw[6].resize(nPanelCount);
	////	m_vecB7PH2Raw[7].resize(nPanelCount);

	////VectorB7Raw* tempRaw;
	//// 20180315 Reflow Ãß°¡·Î ÀÎÇÑ °á°úÆÄÀÏ bug fix <
	//if (nReflowDefectCount>0)
	//{
	//	CDataPanelIInfo_B11E* pPanelInfo = new CDataPanelIInfo_B11E;
	//	pPanelInfo->m_vecData[nIdx]->SetData("PNL_INF");
	//	pPanelInfo->m_nLineIdx = m_nLineCount++;
	//	for (int u = 1; u<B11ERAW_ITEMPANELINFO_COUNT; u++)
	//	{
	//		pPanelInfo->m_vecData[u]->SetData(m_vecB11Raw[eB11ERaw_PanelInfoItem][m_vecB11Raw[eB11ERaw_PanelInfoItem].size()-1]->m_vecData[u]->GetData()); ;
	//	}

	//	m_vecB11Raw[eB11ERaw_PanelInfoItem].push_back(pPanelInfo);
	//	m_nB11RawCount[eB11ERaw_PanelInfoItem]++;

	//	CDataPanelIInfo_B11E* pPanelInfoData = new CDataPanelIInfo_B11E;
	//	pPanelInfoData->m_vecData[nIdx]->SetData("PNL_INF_DATA");
	//	pPanelInfoData->m_nLineIdx = m_nLineCount++;
	//	for (int u = 1; u<B11ERAW_ITEMPANELINFO_COUNT; u++)
	//	{
	//		pPanelInfoData->m_vecData[u]->SetData(m_vecB11Raw[eB11ERaw_PanelInfoData][m_vecB11Raw[eB11ERaw_PanelInfoData].size()-1]->m_vecData[u]->GetData());
	//	}
	//	m_vecB11Raw[eB11ERaw_PanelInfoData].push_back(pPanelInfoData);
	//	m_nB11RawCount[eB11ERaw_PanelInfoData]++;

	//	CDataPanelSum_B11E* pPanelSum = new CDataPanelSum_B11E;
	//	pPanelSum->m_vecData[nIdx]->SetData("PNL_SUM");
	//	pPanelSum->m_nLineIdx = m_nLineCount++;
	//	for (int u = 1; u<B11ERAW_ITEMPANELSUM_COUNT; u++)
	//	{
	//		pPanelSum->m_vecData[u]->SetData(m_vecB11Raw[eB11ERaw_PanelSumItem][m_vecB11Raw[eB11ERaw_PanelSumItem].size()-1]->m_vecData[u]->GetData());
	//	}
	//	m_vecB11Raw[eB11ERaw_PanelSumItem].push_back(pPanelSum);
	//	m_nB11RawCount[eB11ERaw_PanelSumItem]++;

	//	CDataPanelSum_B11E* pPanelSumData = new CDataPanelSum_B11E;
	//	pPanelSumData->m_vecData[nIdx]->SetData("PNL_SUM_DATA");
	//	pPanelSumData->m_nLineIdx = m_nLineCount++;
	//	for (int u = 1; u<B11ERAW_ITEMPANELSUM_COUNT; u++)
	//	{
	//		pPanelSumData->m_vecData[u]->SetData(m_vecB11Raw[eB11ERaw_PanelSumData][m_vecB11Raw[eB11ERaw_PanelSumData].size()-1]->m_vecData[u]->GetData());
	//	}
	//	m_vecB11Raw[eB11ERaw_PanelSumData].push_back(pPanelSumData);
	//	m_nB11RawCount[eB11ERaw_PanelSumData]++;

	//	CDataDefectIInfo_B11E* pPanelDefect = new CDataDefectIInfo_B11E;
	//	pPanelDefect->m_vecData[nIdx]->SetData("DFT_INF");
	//	pPanelDefect->m_nLineIdx = m_nLineCount++;
	//	if (m_vecB11Raw[eB11ERaw_DefectInfoItem].size() == 0)
	//	{
	//		int u = 1;
	//		//			pPanelDefect->m_vecData[u]->SetData("PNL_DFT");
	//		pPanelDefect->m_vecData[u++]->SetData("FIELD_COUNT");
	//		pPanelDefect->m_vecData[u++]->SetData("POINT_NO");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_CODE");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_NAME");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_TYPE");
	//		pPanelDefect->m_vecData[u++]->SetData("PR_COOR_X");
	//		pPanelDefect->m_vecData[u++]->SetData("PR_COOR_Y");
	//		pPanelDefect->m_vecData[u++]->SetData("SE_COOR_X");
	//		pPanelDefect->m_vecData[u++]->SetData("SE_COOR_Y");
	//		pPanelDefect->m_vecData[u++]->SetData("PNL_ID");
	//		pPanelDefect->m_vecData[u++]->SetData("PNL_COOR_X");
	//		pPanelDefect->m_vecData[u++]->SetData("PNL_COOR_Y");
	//		pPanelDefect->m_vecData[u++]->SetData("TE_COOR_X");
	//		pPanelDefect->m_vecData[u++]->SetData("TE_COOR_Y");
	//		pPanelDefect->m_vecData[u++]->SetData("MARK_TYPE");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_HEIGHT");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_LAYER");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_LAYER_DESC");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_SIZE_TYPE");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_SIZE_X");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_SIZE_Y");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_LENGTH");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_AREA");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_PEEK");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_TYPE_1");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_TYPE_2");
	//		pPanelDefect->m_vecData[u++]->SetData("DFT_ZONE");
	//		pPanelDefect->m_vecData[u++]->SetData("REPEAT_DFT");
	//		pPanelDefect->m_vecData[u++]->SetData("ME_CODE");
	//		pPanelDefect->m_vecData[u++]->SetData("A_RATION");
	//		pPanelDefect->m_vecData[u++]->SetData("MASK_DFT");
	//		pPanelDefect->m_vecData[u++]->SetData("CAMERA_NO");
	//		pPanelDefect->m_vecData[u++]->SetData("IMAGE_DATA");
	//		pPanelDefect->m_vecData[u++]->SetData("STACK_FLAG ");
	//		pPanelDefect->m_vecData[u++]->SetData("STACK_STEP_CNT");
	//		pPanelDefect->m_vecData[u++]->SetData("STACK_STEP_LIST");
	//	}
	//	else
	//	{
	//		for (int u = 1; u<B11ERAW_ITEMDEFECTINFO_COUNT; u++)
	//		{
	//			pPanelDefect->m_vecData[u]->SetData(m_vecB11Raw[eB11ERaw_DefectInfoItem][m_vecB11Raw[eB11ERaw_DefectInfoItem].size()-1]->m_vecData[u]->GetData());
	//		}
	//	}
	//	m_vecB11Raw[eB11ERaw_DefectInfoItem].push_back(pPanelDefect);
	//	m_nB11RawCount[eB11ERaw_DefectInfoItem]++;
	//}
	//////////////////////////////////////////////// <

	//for (int i = 0; i < nReflowDefectCount;i++)
	//{
	//	nIdx = 0;
	//	CDataDefectIInfo_B11E* pPanelDefectData = new CDataDefectIInfo_B11E;
	//	pPanelDefectData->m_nLineIdx = m_nLineCount++;
	//	pPanelDefectData->m_vecData[nIdx]->SetData("DFT_INF_DATA");

	//	for (int u = 1; u<B11ERAW_ITEMDEFECTINFO_COUNT-1; u++)
	//	{
	//		pPanelDefectData->m_vecData[u]->SetData("");
	//	}
	//	m_vecB11Raw[eB11ERaw_DefectInfoData].push_back(pPanelDefectData);
	//	m_nB11RawCount[eB11ERaw_DefectInfoData]++;
	//}
}