#include "StdAfx.h"
#include "HardwareSettings.h"

//////////////////////////////////////////////////////////////////////////
// PLC Settings
CPLCSettings::CPLCSettings(void)
{
	Reset();
}

CPLCSettings::~CPLCSettings(void)
{

}

CPLCSettings& CPLCSettings::operator=(CPLCSettings& rhs)
{
	if(this != &rhs)
	{
		m_nPLCLoopTime = rhs.m_nPLCLoopTime;
	}
	return *this;
}

void CPLCSettings::Reset()
{
	m_nPLCLoopTime = 50;
}

CString CPLCSettings::GetFileString(void *pValue)
{
	CString		str = _T("");

	if((void *)&m_nPLCLoopTime == pValue)
		str.Format(_T("PLC_LOOPTIME"));

	return str;
}

BOOL CPLCSettings::ReadHardwareSettingsFile(CConfig *pFile)
{
	if(pFile == NULL)
		return FALSE;

	CString			str;	

	str = GetFileString((void *)&m_nPLCLoopTime);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nPLCLoopTime);

	return TRUE;
}

BOOL CPLCSettings::ReadHardwareSettingsRegistry(CConfig *pFile)
{
	if(pFile == NULL)
		return FALSE;

	CString			str;

	str = GetFileString((void *)&m_nPLCLoopTime);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nPLCLoopTime);

	return TRUE;
}

BOOL CPLCSettings::WriteHardwareSettingsFile(CConfig *pFile)
{
	if(pFile == NULL)
		return FALSE;

	CString			str;

	str = GetFileString((void *)&m_nPLCLoopTime);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nPLCLoopTime);

	return TRUE;
}

BOOL CPLCSettings::WriteHardwareSettingsRegistry(CConfig *pFile)
{
	if(pFile == NULL)
		return FALSE;

	CString			str;

	str = GetFileString((void *)&m_nPLCLoopTime);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nPLCLoopTime);

	return TRUE;
}


//////////////////////////////////////////////////////////////////////////
// Soft Settings
CSoftSettings::CSoftSettings(void)
{
	Reset();
}

CSoftSettings::~CSoftSettings(void)
{

}

CSoftSettings& CSoftSettings::operator=(CSoftSettings& rhs)
{
	if(this != &rhs)
	{
		int			i;

		m_bUseLightImageSave = rhs.m_bUseLightImageSave;		
		for(i=0;i<MAX_INS_PC;i++)
		{
			m_bInsPCUse[i] = rhs.m_bInsPCUse[i];
		}
		m_bUseVcrReadFail  = rhs.m_bUseVcrReadFail;
	}
	return *this;
}

void CSoftSettings::Reset()
{
	int			i;

	m_bUseLightImageSave = FALSE;

	for(i=0;i<MAX_INS_PC;i++)
	{
		m_bInsPCUse[i] = FALSE;
	}

	m_bUseVcrReadFail = FALSE;
}

CString CSoftSettings::GetFileString(void *pValue)
{
	CString		str = _T("");

	if((void *)&m_bUseVcrReadFail == pValue)
		str.Format(_T("SOFT_USE_VCR_READ_FAIL"));

	return str;
}

BOOL CSoftSettings::ReadHardwareSettingsFile(CConfig *pFile)
{
	if(pFile == NULL)
		return FALSE;

	CString			str;
	int				i;

	str = GetFileString((void *)&m_bUseLightImageSave);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_bUseLightImageSave);

	for(i=0;i<MAX_INS_PC;i++)
	{
		str.Format(_T("INSPECTOR_PC_USE_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_bInsPCUse[i]);	
	}	

	str = GetFileString((void *)&m_bUseVcrReadFail);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_bUseVcrReadFail);

	return TRUE;
}

BOOL CSoftSettings::ReadHardwareSettingsRegistry(CConfig *pFile)
{
	if(pFile == NULL)
		return FALSE;

	CString			str;
	int				i;

	str = GetFileString((void *)&m_bUseLightImageSave);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_bUseLightImageSave);

	for(i=0;i<MAX_INS_PC;i++)
	{
		str.Format(_T("INSPECTOR_PC_USE_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_bInsPCUse[i]);	
	}

	str = GetFileString((void *)&m_bUseVcrReadFail);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_bUseVcrReadFail);

	return TRUE;
}

BOOL CSoftSettings::WriteHardwareSettingsFile(CConfig *pFile)
{
	if(pFile == NULL)
		return FALSE;

	CString			str;
	int				i;

	str = GetFileString((void *)&m_bUseLightImageSave);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_bUseLightImageSave);

	for(i=0;i<MAX_INS_PC;i++)
	{
		str.Format(_T("INSPECTOR_PC_USE_%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_bInsPCUse[i]);	
	}

	str = GetFileString((void *)&m_bUseVcrReadFail);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_bUseVcrReadFail);

	return TRUE;
}

BOOL CSoftSettings::WriteHardwareSettingsRegistry(CConfig *pFile)
{
	if(pFile == NULL)
		return FALSE;

	CString			str;
	int				i;

	str = GetFileString((void *)&m_bUseLightImageSave);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_bUseLightImageSave);

	for(i=0;i<MAX_INS_PC;i++)
	{
		str.Format(_T("INSPECTOR_PC_USE_%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_bInsPCUse[i]);	
	}

	str = GetFileString((void *)&m_bUseVcrReadFail);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_bUseVcrReadFail);

	return TRUE;
}

//////////////////////////////////////////////////////////////////////////
// Light Settings
CHardwareLightSettings::CHardwareLightSettings(void)
{
	Reset();
}

CHardwareLightSettings::~CHardwareLightSettings(void)
{

}

CHardwareLightSettings& CHardwareLightSettings::operator=(CHardwareLightSettings& rhs)
{
	if(this != &rhs)
	{
		m_nIndex = rhs.m_nIndex;
		m_nPort = rhs.m_nPort;
		m_emType = rhs.m_emType;
		m_emMaker = rhs.m_emMaker;
	}
	return *this;
}

void CHardwareLightSettings::Reset()
{
	m_nIndex = -1;
	m_nPort = -1;
	m_emType = LIGHT_TYPE_NONE;
	m_emMaker = MAKER_NONE;
}

CString CHardwareLightSettings::GetFileString(void *pValue)
{
	CString		str = _T("");

	if((void *)&m_nPort == pValue)
		str.Format(_T("LIGHT_[%d]_PORT"),m_nIndex);
	else if((void *)&m_emType == pValue)
		str.Format(_T("LIGHT_[%d]_TYPE"),m_nIndex);
	else if((void *)&m_emMaker == pValue)
		str.Format(_T("LIGHT_[%d]_MAKER"),m_nIndex);
	else if((void *)&m_nIndex == pValue)
		str.Format(_T("LIGHT_[%d]_ID"),m_nIndex);

	return str;
}

BOOL CHardwareLightSettings::ReadHardwareSettingsFile(CConfig *pFile)
{
	if(pFile == NULL)
		return FALSE;

	CString			str;
	int				nValue;

	str = GetFileString((void *)&m_nIndex);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nIndex);

	str = GetFileString((void *)&m_nPort);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nPort);

	str = GetFileString((void *)&m_emType);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
	m_emType = (LIGHT_TYPE)nValue;

	str = GetFileString((void *)&m_emMaker);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
	m_emMaker = (LIGHT_MAKER)nValue;	

	return TRUE;
}

BOOL CHardwareLightSettings::ReadHardwareSettingsRegistry(CConfig *pFile)
{
	if(pFile == NULL)
		return FALSE;

	CString			str;
	int				nValue;

	str = GetFileString((void *)&m_nIndex);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nIndex);

	str = GetFileString((void *)&m_nPort);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nPort);

	str = GetFileString((void *)&m_emType);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
	m_emType = (LIGHT_TYPE)nValue;

	str = GetFileString((void *)&m_emMaker);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
	m_emMaker = (LIGHT_MAKER)nValue;	

	return TRUE;
}

BOOL CHardwareLightSettings::WriteHardwareSettingsFile(CConfig *pFile)
{
	if(pFile == NULL)
		return FALSE;

	CString			str;
	int				nValue;

	str = GetFileString((void *)&m_nIndex);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nIndex);

	str = GetFileString((void *)&m_nPort);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nPort);

	str = GetFileString((void *)&m_emType);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	nValue = (int)m_emType;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);	

	str = GetFileString((void *)&m_emMaker);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	nValue = (int)m_emMaker;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);	

	return TRUE;
}

BOOL CHardwareLightSettings::WriteHardwareSettingsRegistry(CConfig *pFile)
{
	if(pFile == NULL)
		return FALSE;

	CString			str;
	int				nValue;

	str = GetFileString((void *)&m_nIndex);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nIndex);

	str = GetFileString((void *)&m_nPort);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nPort);

	str = GetFileString((void *)&m_emType);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	nValue = (int)m_emType;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);	

	str = GetFileString((void *)&m_emMaker);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	nValue = (int)m_emMaker;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);	

	return TRUE;
}

//////////////////////////////////////////////////////////////////////////
// Camera Settings
CCameraSettings::CCameraSettings(void)
{	
	Reset();
}

CCameraSettings::~CCameraSettings(void)
{

}

CCameraSettings& CCameraSettings::operator=(CCameraSettings& rhs)
{
	if(this != &rhs)
	{
		m_iCamera = rhs.m_iCamera;
		m_iScan = rhs.m_iScan;		
		m_nMarginLeft = rhs.m_nMarginLeft;
		m_nMarginRight = rhs.m_nMarginRight;
		for(int i=0;i<MAX_STAGE_HAND_COUNT;i++)
		{
			m_dConvResolution[i] = rhs.m_dConvResolution[i];
			m_dScanResolution[i] = rhs.m_dScanResolution[i];
		}
		m_nLightIdx_R = rhs.m_nLightIdx_R;
		m_nLightIdx_T = rhs.m_nLightIdx_T;
		m_nLightIdx_T_Ch = rhs.m_nLightIdx_T_Ch;
		m_nLightIdx_R_Ch = rhs.m_nLightIdx_R_Ch;
		m_enCamDir = rhs.m_enCamDir;
		m_nGrabFrameCount = rhs.m_nGrabFrameCount;		
		m_FrameSize = rhs.m_FrameSize;		
		m_enInspectDir = rhs.m_enInspectDir;
		m_eDimension = rhs.m_eDimension;
		m_eScanDir = rhs.m_eScanDir;
		m_nImgFlipx = rhs.m_nImgFlipx;
	}
	return *this;
}

void CCameraSettings::Reset()
{	
	m_iCamera = -1;
	m_iScan = -1;	
	m_nMarginLeft = m_nMarginRight = 0;
	for(int i=0;i<MAX_STAGE_HAND_COUNT;i++)
	{
		m_dConvResolution[i] = m_dScanResolution[i] = 0;
	}
	m_nLightIdx_R = m_nLightIdx_T = -1;
	m_nLightIdx_T_Ch = m_nLightIdx_R_Ch = -1;
	m_enCamDir = CAMDIR_TOP;	
	m_nGrabFrameCount = 0;	
	m_FrameSize = CSize(0,0);
	m_enInspectDir = INSPECTDIR_FORWARD;
	m_eDimension = DIMENSION_NONE;
	m_eScanDir = SCANGLASS_X;
	m_nImgFlipx = FALSE;
}

CString CCameraSettings::GetFileString(void *pValue)
{
	CString		str = _T("");

	if((void *)&m_nMarginLeft == pValue)
		str.Format(_T("CAM_[%d][%d]_MARGIN_LEFT"),m_iCamera,m_iScan);
	else if((void *)&m_nMarginRight == pValue)
		str.Format(_T("CAM_[%d][%d]_MARGIN_RIGHT"),m_iCamera,m_iScan);
	else if((void *)&m_dConvResolution[0] == pValue)
		str.Format(_T("CAM_[%d][%d]_CONVRES"),m_iCamera,m_iScan);
	else if((void *)&m_dScanResolution[0] == pValue)
		str.Format(_T("CAM_[%d][%d]_SCANRES"),m_iCamera,m_iScan);
	else if((void *)&m_dConvResolution[1] == pValue)
		str.Format(_T("CAM_[%d][%d]_CONVRES_1"),m_iCamera,m_iScan);
	else if((void *)&m_dScanResolution[1] == pValue)
		str.Format(_T("CAM_[%d][%d]_SCANRES_1"),m_iCamera,m_iScan);
	else if((void *)&m_nLightIdx_R == pValue)
		str.Format(_T("CAM_[%d][%d]_LIGHTIDX_R"),m_iCamera,m_iScan);
	else if((void *)&m_nLightIdx_T == pValue)
		str.Format(_T("CAM_[%d][%d]_LIGHTIDX_T"),m_iCamera,m_iScan);
	else if((void *)&m_nLightIdx_T_Ch == pValue)
		str.Format(_T("CAM_[%d][%d]_LIGHTIDX_T_CHANNEL"),m_iCamera,m_iScan);
	else if((void *)&m_nLightIdx_R_Ch == pValue)
		str.Format(_T("CAM_[%d][%d]_LIGHTIDX_R_CHANNEL"),m_iCamera,m_iScan);
	else if((void *)&m_enCamDir == pValue)
		str.Format(_T("CAM_[%d][%d]_CAMDIR"),m_iCamera,m_iScan);
	else if((void *)&m_nGrabFrameCount == pValue)
		str.Format(_T("CAM_[%d][%d]_GRABFRAMECOUNT"),m_iCamera,m_iScan);	
	else if((void *)&m_FrameSize.cx == pValue)
		str.Format(_T("CAM_[%d][%d]_FRAME_CX"),m_iCamera,m_iScan);
	else if((void *)&m_FrameSize.cy == pValue)
		str.Format(_T("CAM_[%d][%d]_FRAME_CY"),m_iCamera,m_iScan);	
	else if((void *)&m_enInspectDir == pValue)
		str.Format(_T("CAM_[%d][%d]_INSPECT_DIR"),m_iCamera,m_iScan);
	else if((void *)&m_eDimension == pValue)
		str.Format(_T("CAM_[%d][%d]_DIMENSION"),m_iCamera,m_iScan);
	else if((void *)&m_eScanDir == pValue)
		str.Format(_T("CAM_[%d][%d]_SCANDIR"),m_iCamera,m_iScan);
	else if((void *)&m_nImgFlipx == pValue)
		str.Format(_T("CAM_[%d][%d]_IMAGEFLIPX"),m_iCamera,m_iScan);


	return str;
}

BOOL CCameraSettings::ReadHardwareSettingsFile(CConfig *pFile)
{
	if(pFile == NULL)
		return FALSE;

	CString			str;
	int				nValue;

	str = GetFileString((void *)&m_nMarginLeft);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nMarginLeft);

	str = GetFileString((void *)&m_nMarginRight);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nMarginRight);

	str = GetFileString((void *)&m_dConvResolution[0]);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_dConvResolution[0]);

	str = GetFileString((void *)&m_dScanResolution[0]);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_dScanResolution[0]);

	str = GetFileString((void *)&m_dConvResolution[1]);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_dConvResolution[1]);

	str = GetFileString((void *)&m_dScanResolution[1]);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_dScanResolution[1]);

	str = GetFileString((void *)&m_nLightIdx_R);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nLightIdx_R);

	str = GetFileString((void *)&m_nLightIdx_T);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nLightIdx_T);

	str = GetFileString((void *)&m_nLightIdx_T_Ch);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nLightIdx_T_Ch);

	str = GetFileString((void *)&m_nLightIdx_R_Ch);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nLightIdx_R_Ch);

	str = GetFileString((void *)&m_enCamDir);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
	m_enCamDir = (CAMERA_DIR)nValue;	

	str = GetFileString((void *)&m_nGrabFrameCount);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nGrabFrameCount);	

	str = GetFileString((void *)&m_FrameSize.cx);
	if(str.IsEmpty() == TRUE)
		return FALSE;	
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
	m_FrameSize.cx = nValue;

	str = GetFileString((void *)&m_FrameSize.cy);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
	m_FrameSize.cy = nValue;

	str = GetFileString((void *)&m_enInspectDir);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
	m_enInspectDir = (CAMERA_INSPECTION_DIR)nValue;

	str = GetFileString((void *)&m_eDimension);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
	m_eDimension = (DimensionDir)nValue;

	str = GetFileString((void *)&m_eScanDir);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
	m_eScanDir = (CAMERA_SCANDIR)nValue;

	str = GetFileString((void *)&m_nImgFlipx);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
	m_nImgFlipx = (CAMERA_SCANDIR)nValue;


	return TRUE;
}

BOOL CCameraSettings::ReadHardwareSettingsRegistry(CConfig *pFile)
{
	if(pFile == NULL)
		return FALSE;

	CString			str;
	int				nValue;

	str = GetFileString((void *)&m_nMarginLeft);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nMarginLeft);

	str = GetFileString((void *)&m_nMarginRight);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nMarginRight);

	str = GetFileString((void *)&m_dConvResolution[0]);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_dConvResolution[0]);

	str = GetFileString((void *)&m_dScanResolution[0]);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_dScanResolution[0]);

	str = GetFileString((void *)&m_dConvResolution[1]);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_dConvResolution[1]);

	str = GetFileString((void *)&m_dScanResolution[1]);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_dScanResolution[1]);

	str = GetFileString((void *)&m_nLightIdx_R);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nLightIdx_R);

	str = GetFileString((void *)&m_nLightIdx_T);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nLightIdx_T);

	str = GetFileString((void *)&m_nLightIdx_T_Ch);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nLightIdx_T_Ch);

	str = GetFileString((void *)&m_nLightIdx_R_Ch);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nLightIdx_R_Ch);

	str = GetFileString((void *)&m_enCamDir);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
	m_enCamDir = (CAMERA_DIR)nValue;	

	str = GetFileString((void *)&m_nGrabFrameCount);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nGrabFrameCount);	

	str = GetFileString((void *)&m_FrameSize.cx);
	if(str.IsEmpty() == TRUE)
		return FALSE;	
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);	
	m_FrameSize.cx = nValue;

	str = GetFileString((void *)&m_FrameSize.cy);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);	
	m_FrameSize.cy = nValue;

	str = GetFileString((void *)&m_enInspectDir);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
	m_enInspectDir = (CAMERA_INSPECTION_DIR)nValue;

	str = GetFileString((void *)&m_eDimension);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
	m_eDimension = (DimensionDir)nValue;

	str = GetFileString((void *)&m_eScanDir);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
	m_eScanDir = (CAMERA_SCANDIR)nValue;

	str = GetFileString((void *)&m_nImgFlipx);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
	m_nImgFlipx = (CAMERA_SCANDIR)nValue;


	return TRUE;
}

BOOL CCameraSettings::WriteHardwareSettingsFile(CConfig *pFile)
{
	if(pFile == NULL)
		return FALSE;

	CString			str;
	int				nValue;

	str = GetFileString((void *)&m_nMarginLeft);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nMarginLeft);

	str = GetFileString((void *)&m_nMarginRight);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nMarginRight);

	str = GetFileString((void *)&m_dConvResolution[0]);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_dConvResolution[0]);

	str = GetFileString((void *)&m_dScanResolution[0]);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_dScanResolution[0]);

	str = GetFileString((void *)&m_dConvResolution[1]);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_dConvResolution[1]);

	str = GetFileString((void *)&m_dScanResolution[1]);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_dScanResolution[1]);

	str = GetFileString((void *)&m_nLightIdx_R);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nLightIdx_R);

	str = GetFileString((void *)&m_nLightIdx_T);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nLightIdx_T);

	str = GetFileString((void *)&m_nLightIdx_T_Ch);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nLightIdx_T_Ch);

	str = GetFileString((void *)&m_nLightIdx_R_Ch);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nLightIdx_R_Ch);

	str = GetFileString((void *)&m_enCamDir);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	nValue = (int)m_enCamDir;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);

	str = GetFileString((void *)&m_nGrabFrameCount);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nGrabFrameCount);	

	str = GetFileString((void *)&m_FrameSize.cx);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_FrameSize.cx);

	str = GetFileString((void *)&m_FrameSize.cy);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_FrameSize.cy);

	str = GetFileString((void *)&m_enInspectDir);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	nValue = (int)m_enInspectDir;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);

	str = GetFileString((void *)&m_eDimension);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	nValue = (int)m_eDimension;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);	

	str = GetFileString((void *)&m_eScanDir);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	nValue = (int)m_eScanDir;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);	

	str = GetFileString((void *)&m_nImgFlipx);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	nValue = (int)m_nImgFlipx;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);	

	return TRUE;
}

BOOL CCameraSettings::WriteHardwareSettingsRegistry(CConfig *pFile)
{
	if(pFile == NULL)
		return FALSE;

	CString			str;
	int				nValue;

	str = GetFileString((void *)&m_nMarginLeft);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nMarginLeft);

	str = GetFileString((void *)&m_nMarginRight);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nMarginRight);

	str = GetFileString((void *)&m_dConvResolution[0]);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_dConvResolution[0]);

	str = GetFileString((void *)&m_dScanResolution[0]);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_dScanResolution[0]);

	str = GetFileString((void *)&m_dConvResolution[1]);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_dConvResolution[1]);

	str = GetFileString((void *)&m_dScanResolution[1]);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_dScanResolution[1]);

	str = GetFileString((void *)&m_nLightIdx_R);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nLightIdx_R);

	str = GetFileString((void *)&m_nLightIdx_T);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nLightIdx_T);

	str = GetFileString((void *)&m_nLightIdx_T_Ch);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nLightIdx_T_Ch);

	str = GetFileString((void *)&m_nLightIdx_R_Ch);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nLightIdx_R_Ch);

	str = GetFileString((void *)&m_enCamDir);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	nValue = (int)m_enCamDir;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);

	str = GetFileString((void *)&m_nGrabFrameCount);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nGrabFrameCount);	

	str = GetFileString((void *)&m_FrameSize.cx);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_FrameSize.cx);

	str = GetFileString((void *)&m_FrameSize.cy);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_FrameSize.cy);

	str = GetFileString((void *)&m_enInspectDir);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	nValue = (int)m_enInspectDir;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);

	str = GetFileString((void *)&m_eDimension);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	nValue = (int)m_eDimension;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);

	str = GetFileString((void *)&m_eScanDir);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	nValue = (int)m_eScanDir;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);	

	str = GetFileString((void *)&m_nImgFlipx);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	nValue = (int)m_nImgFlipx;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);	

	return TRUE;
}

//////////////////////////////////////////////////////////////////////////
// hardwareSettins
CHardwareSettings::CHardwareSettings(void)
{
	m_pLightSettings = NULL;
	m_pCameraSettings = NULL;
	Reset();
}

CHardwareSettings::~CHardwareSettings(void)
{
	Reset();
}

CHardwareSettings& CHardwareSettings::operator=(CHardwareSettings& rhs)
{
	if(this != &rhs)
	{
		int				iLoop;

		Reset();
		m_nLightCount_Trans = rhs.m_nLightCount_Trans;
		m_nLightCount_Reflect = rhs.m_nLightCount_Reflect;
		SetLightCount(m_nLightCount_Trans,m_nLightCount_Reflect);
		for(iLoop=0;iLoop<m_nLightCount_Trans+m_nLightCount_Reflect;iLoop++)
			m_pLightSettings[iLoop] = rhs.m_pLightSettings[iLoop];

		m_nBoardType = rhs.m_nBoardType;
		m_nCameraCount = rhs.m_nCameraCount;
		m_nScanCount = rhs.m_nScanCount;
		SetCameraCount(m_nCameraCount,m_nScanCount);
		for(iLoop=0;iLoop<m_nCameraCount*m_nScanCount;iLoop++)
			m_pCameraSettings[iLoop] = rhs.m_pCameraSettings[iLoop];

		m_strMachineName = rhs.m_strMachineName;
		m_strLineID = rhs.m_strLineID;
		m_nPLCSignalRetry = rhs.m_nPLCSignalRetry;		
		m_nSaveImageQuality = rhs.m_nSaveImageQuality;

		//		m_dOneScanTime = rhs.m_dOneScanTime;
		m_nFolderRemoveDay = rhs.m_nFolderRemoveDay;

		m_PLCSettings = rhs.m_PLCSettings;

		m_SoftWareSettings = rhs.m_SoftWareSettings;				

		m_bInsDirReverse = rhs.m_bInsDirReverse;
		m_bUseColorVisual = rhs.m_bUseColorVisual;

		m_bUseFreerun = rhs.m_bUseFreerun;
		m_nFreerunPeriod = rhs.m_nFreerunPeriod;
		m_nFreerunExposureTime = rhs.m_nFreerunExposureTime;

		m_bUse_MvsolTriggerControl = rhs.m_bUse_MvsolTriggerControl;
		m_nPort_MvsolTriggerControl = rhs.m_nPort_MvsolTriggerControl;

		m_bUse_SaveDebugImage = rhs.m_bUse_SaveDebugImage;

		// ly,2025.07.10
		m_bSaveResultByHour = rhs.m_bSaveResultByHour;

		// ly,2025.07.07
		m_bEnableAutoCopy = rhs.m_bEnableAutoCopy;
		m_strCopyToolExePath = rhs.m_strCopyToolExePath;
		m_strCopyToolConfigPath = rhs.m_strCopyToolConfigPath;
		m_bEnableAutoDelete = rhs.m_bEnableAutoDelete;
		m_strDeleteToolExePath = rhs.m_strDeleteToolExePath;
		m_strDeleteToolConfigPath = rhs.m_strDeleteToolConfigPath;

		// lwq,2025.08.04
		m_bUse_SaveDLDefectImage = rhs.m_bUse_SaveDLDefectImage;
		
	}
	return *this;
}

void CHardwareSettings::Reset()
{		
	//	m_dOneScanTime = 0.;
	m_nLightCount_Trans = 0;	
	m_nLightCount_Reflect = 0;	
	m_nCameraCount = 0;
	m_nScanCount = 0;
	m_nFolderRemoveDay = 0;
	m_nPLCSignalRetry = 0;
	m_nSaveImageQuality = 30;
	m_strMachineName = _T("");
	m_strLineID = _T("");
	m_nBoardType = GRAB_LINK_BOARD;
	if(m_pLightSettings != NULL)
		delete[] m_pLightSettings, m_pLightSettings=NULL;
	if(m_pCameraSettings != NULL)
		delete[] m_pCameraSettings, m_pCameraSettings=NULL;
	m_PLCSettings.Reset();
	m_SoftWareSettings.Reset();	
	m_bInsDirReverse = FALSE;
	m_bUseColorVisual = TRUE;
}

void CHardwareSettings::SetLightCount(int nCountTrans,int nCountReflect)
{
	int		iLoop,nBackCount=0;
	CHardwareLightSettings *pTmpSet = NULL;

	if(m_pLightSettings != NULL)
	{
		if(m_nLightCount_Trans+m_nLightCount_Reflect > 0)
		{
			pTmpSet = new CHardwareLightSettings[m_nLightCount_Trans+m_nLightCount_Reflect];
			for(iLoop=0;iLoop<m_nLightCount_Trans+m_nLightCount_Reflect;iLoop++)
				pTmpSet[iLoop] = m_pLightSettings[iLoop];
			nBackCount = m_nLightCount_Trans+m_nLightCount_Reflect;
		}
		delete[] m_pLightSettings, m_pLightSettings=NULL;
	}

	m_nLightCount_Trans = nCountTrans;	
	m_nLightCount_Reflect = nCountReflect;
	if(m_nLightCount_Trans+m_nLightCount_Reflect <= 0)
		return;

	m_pLightSettings = new CHardwareLightSettings[m_nLightCount_Trans+m_nLightCount_Reflect];

	for(iLoop=0;iLoop<m_nLightCount_Trans+m_nLightCount_Reflect;iLoop++)
		m_pLightSettings[iLoop].m_nIndex = iLoop;

	if(pTmpSet != NULL)
	{
		for(iLoop=0;iLoop<nBackCount;iLoop++)
		{
			SetLightSettings(&pTmpSet[iLoop]);			
		}
		delete[] pTmpSet, pTmpSet = NULL;
	}
}

CHardwareLightSettings *CHardwareSettings::GetLightSettings(int iLight)
{
	if(iLight < 0 || iLight >= m_nLightCount_Trans+m_nLightCount_Reflect)
		return NULL;

	for(int iLoop=0;iLoop<m_nLightCount_Trans+m_nLightCount_Reflect;iLoop++)
	{
		if(m_pLightSettings[iLoop].m_nIndex == iLight)
			return &m_pLightSettings[iLoop];
	}

	return NULL;
}

BOOL CHardwareSettings::SetLightSettings(CHardwareLightSettings *pLight)
{
	if(pLight == NULL || m_nLightCount_Trans+m_nLightCount_Reflect <= 0 || m_pLightSettings == NULL)
		return FALSE;

	for(int iLoop=0;iLoop<m_nLightCount_Trans+m_nLightCount_Reflect;iLoop++)
	{
		if(m_pLightSettings[iLoop].m_nIndex == pLight->m_nIndex)
		{
			m_pLightSettings[iLoop] = *pLight;
			return TRUE;
		}
	}

	return FALSE;
}

BOOL CHardwareSettings::SetCameraCount(int nCameraCount,int nScanCount)
{
	CCameraSettings *ptmpSet = NULL;
	int				nBackCamCnt = 0,nBackScanCnt = 0;
	int				iLoop;

	if(m_pCameraSettings != NULL)
	{
		if((m_nCameraCount*m_nScanCount) > 0)
		{
			ptmpSet = new CCameraSettings[m_nCameraCount*m_nScanCount];

			for(iLoop=0;iLoop<m_nCameraCount*m_nScanCount;iLoop++)
			{
				ptmpSet[iLoop] = m_pCameraSettings[iLoop];
			}
			nBackCamCnt = m_nCameraCount;
			nBackScanCnt = m_nScanCount;
		}
		delete[] m_pCameraSettings, m_pCameraSettings=NULL;		
	}

	m_nCameraCount = nCameraCount;
	m_nScanCount = nScanCount;			

	if(m_nCameraCount <= 0 || m_nScanCount <= 0)
		return FALSE;

	m_pCameraSettings = new CCameraSettings[m_nCameraCount*m_nScanCount];

	int			iCam,iScan;

	iLoop=0;
	for(iCam=0;iCam<m_nCameraCount;iCam++)
	{		
		for(iScan=0;iScan<m_nScanCount;iScan++)
		{
			m_pCameraSettings[iLoop].m_iCamera = iCam;
			m_pCameraSettings[iLoop].m_iScan = iScan;			
			iLoop++;
		}
	}

	if(ptmpSet != NULL)
	{
		for(iLoop=0;iLoop<nBackCamCnt*nBackScanCnt;iLoop++)
		{
			SetCameraSettings(&ptmpSet[iLoop]);			
		}	
		delete[] ptmpSet, ptmpSet=NULL;
	}

	return TRUE;
}

CCameraSettings	*CHardwareSettings::GetCameraSettings(int iCamera,int iScan)
{
	if(iCamera >= m_nCameraCount || iScan >= m_nScanCount 
		|| m_nCameraCount <= 0 || m_nScanCount <= 0)
		return NULL;

	for(int iLoop=0;iLoop<m_nCameraCount*m_nScanCount;iLoop++)
	{
		if(m_pCameraSettings[iLoop].m_iCamera == iCamera && m_pCameraSettings[iLoop].m_iScan == iScan)
			return &m_pCameraSettings[iLoop];
	}

	return NULL;
}

BOOL CHardwareSettings::SetCameraSettings(CCameraSettings *pCamera)
{
	if(pCamera == NULL || m_nCameraCount <= 0 || m_nScanCount <= 0)
		return FALSE;

	CCameraSettings	*pOrgCam = GetCameraSettings(pCamera->m_iCamera,pCamera->m_iScan);
	if(pOrgCam == NULL)
		return FALSE;

	*pOrgCam = *pCamera;

	return TRUE;
}

CString CHardwareSettings::GetFileString(void *pValue)
{
	CString		str = _T("");

	if((void *)&m_nCameraCount == pValue)
		str = _T("CAMERA_COUNT");
	else if((void *)&m_nScanCount == pValue)
		str = _T("SCAN_COUNT");
	else if((void *)&m_nBoardType == pValue)
		str = _T("BOARD_TYPE");
	else if((void *)&m_nLightCount_Trans == pValue)
		str = _T("LIGHT_COUNT_TRANS");
	else if((void *)&m_nLightCount_Reflect == pValue)
		str = _T("LIGHT_COUNT_REFLECT");	
	// 	else if((void *)&m_dOneScanTime == pValue)
	// 		str = "ONE_SCAN_TIME";	
	
	
	else if((void *)&m_strMachineName == pValue)
		str = _T("MACHINE_NAME");
	else if((void *)&m_strLineID == pValue)
		str = _T("LINE_ID");	
	else if((void *)&m_nPLCSignalRetry == pValue)
		str = _T("PLCSIGNAL_RETRY_COUNT");		
	else if((void *)&m_bInsDirReverse == pValue)
		str = _T("INSPECTOR_DIR_REVERSE");
	else if((void *)&m_nFolderRemoveDay == pValue)
		str = _T("FOLERREMOVEDAY");
	else if((void *)&m_bUseColorVisual == pValue)
		str = _T("USECOLORVISUAL");
	else if((void *)&m_bUseFreerun == pValue)
		str = _T("USE_FREERUN");
	else if((void *)&m_nFreerunPeriod == pValue)
		str = _T("FREERUN_PERIOD");
	else if((void *)&m_nFreerunExposureTime == pValue)
		str = _T("FREERUN_EXPOSURE");
	else if((void *)&m_bUse_MvsolTriggerControl == pValue)
		str = _T("USE_MVSOL_TRIGGER_CONTROL");
	else if((void *)&m_nPort_MvsolTriggerControl == pValue)
		str = _T("PORT_MVSOL_TRIGGER_CONTROL");
	else if((void *)&m_bUse_SaveDebugImage == pValue)
		str = _T("SAVE_DEBUG_IMAGE");
	else if((void *)&m_nSaveImageQuality == pValue)
		str = _T("SAVEIMAGE_QUALITY");

	// ly,2025.07.10
	else if ((void*)&m_bSaveResultByHour == pValue)
		str = _T("SAVE_RESULT_BY_HOUR");

	// ly,2025.07.07
	else if ((void*)&m_bEnableAutoCopy == pValue)
		str = _T("ENABLE_AUTOCOPY");
	else if ((void*)&m_strCopyToolExePath == pValue)
		str = _T("COPYTOOL_EXE_PATH");
	else if ((void*)&m_strCopyToolConfigPath == pValue)
		str = _T("COPYTOOL_CONFIG_PATH");
	else if ((void*)&m_bEnableAutoDelete == pValue)
		str = _T("ENABLE_AUTODELETE");
	else if ((void*)&m_strDeleteToolExePath == pValue)
		str = _T("DELETETOOL_EXE_PATH");
	else if ((void*)&m_strDeleteToolConfigPath == pValue)
		str = _T("DELETETOOL_CONFIG_PATH");
	// lwq,2025.08.04
    	else if ((void*)&m_bUse_SaveDLDefectImage == pValue)
		str = _T("SAVE_DLDEFECT_IMAGE");
	return str;
}

BOOL CHardwareSettings::ReadHardwareSettingsFile(CString strFilePath)
{
	CConfig		BasicInfoFile;
	CString				str;
	int					iCam,iScan,iLight,iLoop;	

	if (!BasicInfoFile.SetRegiConfig(NULL, NULL, (TCHAR*)(LPCTSTR) strFilePath, FileMap_Mode))
		return FALSE;

	str = GetFileString((void *)&m_nCameraCount);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str,m_nCameraCount);

#if OFFLINE_KEY == 1
	if (m_nCameraCount <= 0)
	{
		m_nCameraCount = 4;
	}
#endif

	str = GetFileString((void *)&m_nScanCount);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str,m_nScanCount,5);	

#if OFFLINE_KEY == 1
	if (m_nScanCount <= 0)
	{
		m_nScanCount = 2;
	}
#endif

	str = GetFileString((void *)&m_nBoardType);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	int		nType;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str,nType,0);		
	m_nBoardType = (BOARD_TYPE)nType;

	// 	str = GetFileString((void *)&m_dOneScanTime);
	// 	if(str.IsEmpty() == TRUE)
	// 		return FALSE;
	// 	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str,m_dOneScanTime);	

	str = GetFileString((void *)&m_strMachineName);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str,m_strMachineName);	

	str = GetFileString((void *)&m_strLineID);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str,m_strLineID);		

	str = GetFileString((void *)&m_nPLCSignalRetry);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str,m_nPLCSignalRetry);			

	str = GetFileString((void *)&m_bInsDirReverse);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str,m_bInsDirReverse);

	str = GetFileString((void *)&m_bUseColorVisual);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str,m_bUseColorVisual);

	str = GetFileString((void *)&m_nSaveImageQuality);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str,m_nSaveImageQuality,30);	
	

	SetCameraCount(m_nCameraCount,m_nScanCount);
	iLoop = 0;
	for(iCam=0;iCam<m_nCameraCount;iCam++)
	{
		for(iScan=0;iScan<m_nScanCount;iScan++)
		{
			m_pCameraSettings[iLoop].ReadHardwareSettingsFile(&BasicInfoFile);		
			iLoop++;
		}
	}

	str = GetFileString((void *)&m_nLightCount_Trans);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str,m_nLightCount_Trans);	

	str = GetFileString((void *)&m_nLightCount_Reflect);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str,m_nLightCount_Reflect);

	str = GetFileString((void *)&m_nFolderRemoveDay);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str,m_nFolderRemoveDay);


	SetLightCount(m_nLightCount_Trans,m_nLightCount_Reflect);
	for(iLight=0;iLight<m_nLightCount_Trans+m_nLightCount_Reflect;iLight++)
	{
		m_pLightSettings[iLight].ReadHardwareSettingsFile(&BasicInfoFile);
	}

	m_PLCSettings.ReadHardwareSettingsFile(&BasicInfoFile);

	m_SoftWareSettings.ReadHardwareSettingsFile(&BasicInfoFile);

	str = GetFileString((void *)&m_bUseFreerun);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	int nTemp = 0;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str,nTemp);
	m_bUseFreerun = (BOOL) nTemp;

	str = GetFileString((void *)&m_nFreerunPeriod);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str,m_nFreerunPeriod);

	str = GetFileString((void *)&m_nFreerunExposureTime);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str,m_nFreerunExposureTime);

	str = GetFileString((void *)&m_bUse_MvsolTriggerControl);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str,nTemp);
	m_bUse_MvsolTriggerControl = (BOOL) nTemp;

	str = GetFileString((void *)&m_nPort_MvsolTriggerControl);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str,m_nPort_MvsolTriggerControl);

	str = GetFileString((void *)&m_bUse_SaveDebugImage);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str,nTemp);
	m_bUse_SaveDebugImage = (BOOL) nTemp;

	// ly,2025.07.10
	str = GetFileString((void*)&m_bSaveResultByHour);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str, m_bSaveResultByHour, FALSE);

	// ly,2025.07.07
	str = GetFileString((void*)&m_bEnableAutoCopy);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str, m_bEnableAutoCopy, FALSE);
	str = GetFileString((void*)&m_strCopyToolExePath);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str, m_strCopyToolExePath, _T(""));
	str = GetFileString((void*)&m_strCopyToolConfigPath);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str, m_strCopyToolConfigPath, _T(""));
	str = GetFileString((void*)&m_bEnableAutoDelete);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str, m_bEnableAutoDelete, FALSE);
	str = GetFileString((void*)&m_strDeleteToolExePath);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str, m_strDeleteToolExePath, _T(""));
	str = GetFileString((void*)&m_strDeleteToolConfigPath);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str, m_strDeleteToolConfigPath, _T(""));

	// ly,2025.08.04
	str = GetFileString((void*)&m_bUse_SaveDLDefectImage);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.GetItemValue((TCHAR*)(LPCTSTR)str, m_bUse_SaveDLDefectImage, FALSE);
	return TRUE;
}

BOOL CHardwareSettings::ReadHardwareSettingsRegistry()
{
	CString				str;
	int					iCam,iScan,iLight,iLoop;	
	CConfig		Register;

	Register.SetRegiConfig(SHCU, KEY_BASIC, NULL, Registery_mode);


	str = GetFileString((void *)&m_nCameraCount);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str,m_nCameraCount);

#if OFFLINE_KEY == 1
	if (m_nCameraCount <= 0)
	{
		m_nCameraCount = 4;
	}
#endif

	str = GetFileString((void *)&m_nScanCount);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str,m_nScanCount);	

#if OFFLINE_KEY == 1
	if (m_nScanCount <= 0)
	{
		m_nScanCount = 2;
	}
#endif

	str = GetFileString((void *)&m_nBoardType);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	int		nType;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str,nType,0);		
	m_nBoardType = (BOARD_TYPE)nType;
	
	// 	str = GetFileString((void *)&m_dOneScanTime);
	// 	if(str.IsEmpty() == TRUE)
	// 		return FALSE;
	// 	Register.GetItemValue((TCHAR*)(LPCTSTR)str,m_dOneScanTime);	

	str = GetFileString((void *)&m_strMachineName);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str,m_strMachineName);

	str = GetFileString((void *)&m_strLineID);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str,m_strLineID);	

	str = GetFileString((void *)&m_nPLCSignalRetry);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str,m_nPLCSignalRetry);		

	str = GetFileString((void *)&m_bInsDirReverse);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str,m_bInsDirReverse);

	str = GetFileString((void *)&m_bUseColorVisual);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str,m_bUseColorVisual);

	str = GetFileString((void *)&m_nSaveImageQuality);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str,m_nSaveImageQuality,30);	

	SetCameraCount(m_nCameraCount,m_nScanCount);
	iLoop = 0;
	for(iCam=0;iCam<m_nCameraCount;iCam++)
	{
		for(iScan=0;iScan<m_nScanCount;iScan++)
		{
			m_pCameraSettings[iLoop].ReadHardwareSettingsRegistry(&Register);	
			iLoop++;
		}
	}

	str = GetFileString((void *)&m_nLightCount_Trans);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str,m_nLightCount_Trans);	

	str = GetFileString((void *)&m_nLightCount_Reflect);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str,m_nLightCount_Reflect);

	str = GetFileString((void *)&m_nFolderRemoveDay);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str,m_nFolderRemoveDay);

	SetLightCount(m_nLightCount_Trans,m_nLightCount_Reflect);
	for(iLight=0;iLight<m_nLightCount_Trans+m_nLightCount_Reflect;iLight++)
	{
		m_pLightSettings[iLight].ReadHardwareSettingsRegistry(&Register);
	}

	m_PLCSettings.ReadHardwareSettingsRegistry(&Register);

	m_SoftWareSettings.ReadHardwareSettingsRegistry(&Register);

	str = GetFileString((void *)&m_bUseFreerun);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	int nTemp = 0;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str,nTemp);
	m_bUseFreerun = (BOOL) nTemp;

	str = GetFileString((void *)&m_nFreerunPeriod);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str,m_nFreerunPeriod);

	str = GetFileString((void *)&m_nFreerunExposureTime);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str,m_nFreerunExposureTime);

	str = GetFileString((void *)&m_bUse_MvsolTriggerControl);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str,nTemp);
	m_bUse_MvsolTriggerControl = (BOOL) nTemp;

	str = GetFileString((void *)&m_nPort_MvsolTriggerControl);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str,m_nPort_MvsolTriggerControl);

	str = GetFileString((void *)&m_bUse_SaveDebugImage);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str,nTemp);
	m_bUse_SaveDebugImage = (BOOL) nTemp;

	// ly,2025.07.10
	str = GetFileString((void*)&m_bSaveResultByHour);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str, m_bSaveResultByHour, FALSE);

	// ly,2025.07.07
	str = GetFileString((void*)&m_bEnableAutoCopy);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str, m_bEnableAutoCopy, FALSE);
	str = GetFileString((void*)&m_strCopyToolExePath);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str, m_strCopyToolExePath, _T(""));
	str = GetFileString((void*)&m_strCopyToolConfigPath);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str, m_strCopyToolConfigPath, _T(""));
	str = GetFileString((void*)&m_bEnableAutoDelete);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str, m_bEnableAutoDelete, FALSE);
	str = GetFileString((void*)&m_strDeleteToolExePath);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str, m_strDeleteToolExePath, _T(""));
	str = GetFileString((void*)&m_strDeleteToolConfigPath);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str, m_strDeleteToolConfigPath, _T(""));

	// lwq,2025.08.04
	str = GetFileString((void*)&m_bUse_SaveDLDefectImage);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	Register.GetItemValue((TCHAR*)(LPCTSTR)str, m_bUse_SaveDLDefectImage, FALSE);

	return TRUE;
}

BOOL CHardwareSettings::WriteHardwareSettingsRegistry()
{
	CString				str;
	int					iCam,iScan,iLight,iLoop;	
	CConfig		Register;

	Register.SetRegiConfig(SHCU, KEY_BASIC, NULL, Registery_mode);

	str = GetFileString((void *)&m_nCameraCount);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str,m_nCameraCount);

	str = GetFileString((void *)&m_nScanCount);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str,m_nScanCount);	

	str = GetFileString((void *)&m_nBoardType);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str,m_nBoardType);		

	// 	str = GetFileString((void *)&m_dOneScanTime);
	// 	if(str.IsEmpty() == TRUE)
	// 		return FALSE;
	// 	Register.SetItemValue((TCHAR*)(LPCTSTR)str,m_dOneScanTime);	

	str = GetFileString((void *)&m_strMachineName);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str,(TCHAR*)(LPCTSTR)m_strMachineName);	

	str = GetFileString((void *)&m_strLineID);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str,(TCHAR*)(LPCTSTR)m_strLineID);	

	str = GetFileString((void *)&m_nPLCSignalRetry);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str,m_nPLCSignalRetry);	

	str = GetFileString((void *)&m_bInsDirReverse);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str,m_bInsDirReverse);

	str = GetFileString((void *)&m_bUseColorVisual);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str,m_bUseColorVisual);

	str = GetFileString((void *)&m_nSaveImageQuality);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str,m_nSaveImageQuality);

	if(m_pCameraSettings != NULL)
	{
		iLoop = 0;
		for(iCam=0;iCam<m_nCameraCount;iCam++)
		{
			for(iScan=0;iScan<m_nScanCount;iScan++)
			{
				m_pCameraSettings[iLoop].WriteHardwareSettingsRegistry(&Register);	
				iLoop++;
			}
		}
	}

	str = GetFileString((void *)&m_nLightCount_Trans);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str,m_nLightCount_Trans);	

	str = GetFileString((void *)&m_nLightCount_Reflect);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str,m_nLightCount_Reflect);

	str = GetFileString((void *)&m_nFolderRemoveDay);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str,m_nFolderRemoveDay);

	if(m_pLightSettings != NULL)
	{		
		for(iLight=0;iLight<m_nLightCount_Trans+m_nLightCount_Reflect;iLight++)
		{
			m_pLightSettings[iLight].WriteHardwareSettingsRegistry(&Register);
		}		
	}

	m_PLCSettings.WriteHardwareSettingsRegistry(&Register);	

	m_SoftWareSettings.WriteHardwareSettingsRegistry(&Register);

	str = GetFileString((void *)&m_bUseFreerun);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str,(int) m_bUseFreerun);

	str = GetFileString((void *)&m_nFreerunPeriod);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str,m_nFreerunPeriod);

	str = GetFileString((void *)&m_nFreerunExposureTime);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str,m_nFreerunExposureTime);

	str = GetFileString((void *)&m_bUse_MvsolTriggerControl);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str,(int) m_bUse_MvsolTriggerControl);

	str = GetFileString((void *)&m_nPort_MvsolTriggerControl);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str,m_nPort_MvsolTriggerControl);

	str = GetFileString((void *)&m_bUse_SaveDebugImage);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str,(int) m_bUse_SaveDebugImage);

	// ly,2025.07.10
	str = GetFileString((void*)&m_bSaveResultByHour);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str, (int)m_bSaveResultByHour);

	// ly,2025.07.07
	str = GetFileString((void*)&m_bEnableAutoCopy);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str, (int)m_bEnableAutoCopy);
	str = GetFileString((void*)&m_strCopyToolExePath);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str, m_strCopyToolExePath);
	str = GetFileString((void*)&m_strCopyToolConfigPath);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str, m_strCopyToolConfigPath);
	str = GetFileString((void*)&m_bEnableAutoDelete);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str, (int)m_bEnableAutoDelete);
	str = GetFileString((void*)&m_strDeleteToolExePath);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str, m_strDeleteToolExePath);
	str = GetFileString((void*)&m_strDeleteToolConfigPath);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str, m_strDeleteToolConfigPath);

	//lwq2025.08.04
	str = GetFileString((void*)&m_bUse_SaveDLDefectImage);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	Register.SetItemValue((TCHAR*)(LPCTSTR)str, (int)m_bUse_SaveDLDefectImage);

	return TRUE;
}

BOOL CHardwareSettings::WriteHardwareSettingsFile(CString strFilePath)
{
	CConfig		BasicInfoFile;
	CString				str;
	int					iCam,iScan,iLight,iLoop;	

	if(BasicInfoFile.SetRegiConfig(NULL, NULL, (TCHAR*)(LPCTSTR)strFilePath, FileMap_Mode) == FALSE)
	{
		CFile File;
		if (!File.Open((TCHAR*)(LPCTSTR)strFilePath, CFile::modeCreate))
		{			
			return FALSE;
		}
		File.Close();
	}

	str = GetFileString((void *)&m_nCameraCount);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str,m_nCameraCount);

	str = GetFileString((void *)&m_nScanCount);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str,m_nScanCount);	

	str = GetFileString((void *)&m_nBoardType);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str,m_nBoardType);	
	
	// 	str = GetFileString((void *)&m_dOneScanTime);
	// 	if(str.IsEmpty() == TRUE)
	// 		return FALSE;
	// 	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str,m_dOneScanTime);	

	str = GetFileString((void *)&m_strMachineName);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str,(TCHAR*)(LPCTSTR)m_strMachineName);	

	str = GetFileString((void *)&m_strLineID);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str,(TCHAR*)(LPCTSTR)m_strLineID);	

	str = GetFileString((void *)&m_nPLCSignalRetry);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str,m_nPLCSignalRetry);	

	str = GetFileString((void *)&m_bInsDirReverse);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str,m_bInsDirReverse);

	str = GetFileString((void *)&m_bUseColorVisual);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str,m_bUseColorVisual);

	str = GetFileString((void *)&m_nSaveImageQuality);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str,m_nSaveImageQuality);	

	if(m_pCameraSettings != NULL)
	{
		iLoop = 0;
		for(iCam=0;iCam<m_nCameraCount;iCam++)
		{
			for(iScan=0;iScan<m_nScanCount;iScan++)
			{
				m_pCameraSettings[iLoop].WriteHardwareSettingsFile(&BasicInfoFile);	
				iLoop++;
			}
		}
	}

	str = GetFileString((void *)&m_nLightCount_Trans);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str,m_nLightCount_Trans);	

	str = GetFileString((void *)&m_nLightCount_Reflect);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str,m_nLightCount_Reflect);

	str = GetFileString((void *)&m_nFolderRemoveDay);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str,m_nFolderRemoveDay);

	if(m_pLightSettings != NULL)
	{		
		for(iLight=0;iLight<m_nLightCount_Trans+m_nLightCount_Reflect;iLight++)
		{
			m_pLightSettings[iLight].WriteHardwareSettingsFile(&BasicInfoFile);
		}		
	}

	m_PLCSettings.WriteHardwareSettingsFile(&BasicInfoFile);

	m_SoftWareSettings.WriteHardwareSettingsFile(&BasicInfoFile);


	str = GetFileString((void *)&m_bUseFreerun);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str,(int) m_bUseFreerun);

	str = GetFileString((void *)&m_nFreerunPeriod);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str,m_nFreerunPeriod);

	str = GetFileString((void *)&m_nFreerunExposureTime);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str,m_nFreerunExposureTime);

	str = GetFileString((void *)&m_bUse_MvsolTriggerControl);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str,m_bUse_MvsolTriggerControl);

	str = GetFileString((void *)&m_nPort_MvsolTriggerControl);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str,m_nPort_MvsolTriggerControl);

	str = GetFileString((void *)&m_bUse_SaveDebugImage);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str,m_bUse_SaveDebugImage);

	// ly,2025.07.10
	str = GetFileString((void*)&m_bSaveResultByHour);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str, (int)m_bSaveResultByHour);
	
	// ly,2025.07.07
	str = GetFileString((void*)&m_bEnableAutoCopy);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str, (int)m_bEnableAutoCopy);
	str = GetFileString((void*)&m_strCopyToolExePath);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str, m_strCopyToolExePath);
	str = GetFileString((void*)&m_strCopyToolConfigPath);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str, m_strCopyToolConfigPath);
	str = GetFileString((void*)&m_bEnableAutoDelete);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str, (int)m_bEnableAutoDelete);
	str = GetFileString((void*)&m_strDeleteToolExePath);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str, m_strDeleteToolExePath);
	str = GetFileString((void*)&m_strDeleteToolConfigPath);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str, m_strDeleteToolConfigPath);


	//lwq,2025.08.04
	str = GetFileString((void*)&m_bUse_SaveDLDefectImage);
	if (str.IsEmpty() == TRUE)
		return FALSE;
	BasicInfoFile.SetItemValue((TCHAR*)(LPCTSTR)str, m_bUse_SaveDLDefectImage);

	BasicInfoFile.WriteToFile();

	return TRUE;
}


int CHardwareSettings::GetScanToDimension(DimensionDir eDir)
{
	int			iScan,iFindScan;
	int			iCam;
	CCameraSettings *pCamera;

	iFindScan = -1;
	for(iCam=0;iCam<GetCameraCount();iCam++)
	{
		for(iScan=0;iScan<GetScanCount();iScan++)
		{
			pCamera = GetCameraSettings(iCam,iScan);
			if(pCamera == NULL)
				continue;

			if(pCamera->m_eDimension == eDir)
			{
				iFindScan = iScan;
				break;
			}
		}

		if(iFindScan != -1)
			break;
	}
	return iFindScan;
}

CAMERA_SCANDIR CHardwareSettings::GetScanToScanDir(int iCam,int iScan)
{
	CCameraSettings *pCamera;

	pCamera = GetCameraSettings(iCam,iScan);
	if(pCamera == NULL)
		return SCANGLASS_NONE;

	return pCamera->m_eScanDir;
}

int	CHardwareSettings::GetCameraIndexToDimension(DimensionDir eDir)
{
	CCameraSettings *pCamera;
	int			iCam,iScan;

	for(iCam=0;iCam<GetCameraCount();iCam++)
	{
		for(iScan=0;iScan<GetScanCount();iScan++)
		{
			pCamera = GetCameraSettings(iCam,iScan);
			if(pCamera == NULL)
				continue;

			if(pCamera->m_eDimension == eDir)
			{
				return iCam;
			}
		}
	}

	return -1;
}