#include "stdafx.h"
#include "SEMStageDataClr.h"
#include "ProjMgrClr.h"

namespace OTSINTERFACE {

	CProjMgrClr::CProjMgrClr()										// constructor
	{
		m_LpProjMgr = new COTSProjMgrFilePtr(new COTSProjMgrFile());
	}
	CProjMgrClr::CProjMgrClr(COTSProjMgrFile* a_pSource)				// copy constructor
	{
		//Init();
		if (a_pSource == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CProjMgrClr:invalid pointer"));
			return;
		}
		m_LpProjMgr = new COTSProjMgrFilePtr(new COTSProjMgrFile(a_pSource));
	}
	CProjMgrClr::CProjMgrClr(COTSProjMgrFilePtr pProjMgrFile)						// copy constructor
	{
		if (pProjMgrFile == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CProjMgrClr:invalid pointer"));
			return;
		}

		
			m_LpProjMgr = new COTSProjMgrFilePtr(pProjMgrFile);
	

	}
	CProjMgrClr::~CProjMgrClr()
	{
		if (m_LpProjMgr != nullptr)
		{
			delete m_LpProjMgr;
			m_LpProjMgr = nullptr;
		}
	}
	CProjMgrClr::!CProjMgrClr()
	{

		if (m_LpProjMgr != nullptr)
		{
			delete m_LpProjMgr;
			m_LpProjMgr = nullptr;
		}
	}
	COTSProjMgrFilePtr CProjMgrClr::GetCProjMgrPtr()
	{
		return *m_LpProjMgr;		
	}
		
	// file 
	bool CProjMgrClr::NewFile()
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("NewFile: invalid pointer."));
			return false;
		}

		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("NewFile: failed to create pointer."));
			return false;
		}

		bool bRet = false;
		bRet = pProjMgrFile->NewFile();
		
		return bRet;
	}
	bool CProjMgrClr::Load()
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Load: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Load: failed to create pointer."));
			return false;
		}

		bool bRet = false;
		bRet = pProjMgrFile->Load();

		return bRet;
	}
	bool CProjMgrClr::Save()
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Save: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Save: failed to create pointer."));
			return false;
		}

		bool bRet = false;
		bRet = pProjMgrFile->Save();

		return bRet;
	}
	bool CProjMgrClr::SaveAs()
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SaveAs: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SaveAs: failed to create pointer."));
			return false;
		}

		bool bRet = false;
		bRet = pProjMgrFile->SaveAs();

		return bRet;
	}
	bool CProjMgrClr::IsValid()
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("IsValid: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("IsValid: failed to create pointer."));
			return false;
		}

		bool bRet = false;
		bRet = pProjMgrFile->IsValid();

		return bRet;
	}

	CSEMStageDataClr^ CProjMgrClr::GetSEMStageData()
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSEMStageData: invalid pointer."));
			return nullptr;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSEMStageData: failed to create pointer."));
			return nullptr;
		}

		CSEMStageDataPtr pSEMStageData = pProjMgrFile->GetSEMStageData();
		ASSERT(pSEMStageData);
		if (!pSEMStageData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSEMStageData: invalid pointer."));
			return nullptr;
		}

		CSEMStageDataClr^ pSEMStageDataClr = gcnew CSEMStageDataClr(pSEMStageData);
		return pSEMStageDataClr;
	}
	// SEM stage data
	void CProjMgrClr::SetSEMStageData(CSEMStageDataClr^ a_pSEMStageData)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSEMStageData: invalid pointer."));
			return;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSEMStageData: failed to create pointer."));
			return;
		}
		ASSERT(a_pSEMStageData);
		if (a_pSEMStageData == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSEMStageData::invalid pointer"));
			return;
		}
		CSEMStageDataPtr pSEMStageData = a_pSEMStageData->GetCSEMStageData();
		ASSERT(pSEMStageData);
		if (pSEMStageData == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSEMStageData::invalid pointer"));
			return;
		}

		pProjMgrFile->SetSEMStageData(pSEMStageData);
	}
	
	CStageClr^ CProjMgrClr::GetStage()
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetStage: invalid pointer."));
			return nullptr;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetStage: failed to create pointer."));
			return nullptr;
		}

		CStagePtr pStage = pProjMgrFile->GetStage();
		ASSERT(pStage);
		if (!pStage)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetStage: invalid pointer."));
			return nullptr;
		}

		CStageClr^ pStageClr = gcnew CStageClr(pStage);
		return pStageClr;
	}
	// stage
	void CProjMgrClr::SetStage(CStageClr^ a_pStage)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetStage: invalid pointer."));
			return;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetStage: failed to create pointer."));
			return;
		}
		ASSERT(a_pStage);
		if (a_pStage == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetStage::invalid pointer"));
			return;
		}
		CStagePtr pStage = a_pStage->GetStagePtr();
		ASSERT(pStage);
		if (pStage == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetStage::invalid pointer"));
			return;
		}
		pProjMgrFile->SetStage(pStage);
	}

	COTSSamplesListClr^ CProjMgrClr::GetSampleList()
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSampleList: invalid pointer."));
			return nullptr;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSampleList: failed to create pointer."));
			return nullptr;
		}
		auto lstSmpl= gcnew COTSSamplesListClr(); 
		auto smpls = pProjMgrFile->GetSampleList();
		for each(auto s in smpls)
		{
			lstSmpl->Add(gcnew COTSSampleClr(s));
		}
		return lstSmpl;
		// TODO: insert return statement here
	}
	// samples list
	bool CProjMgrClr::SetSampleList(COTSSamplesListClr^ a_listSample, bool a_bClear)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSampleList: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__,__LINE__, _T("SetSampleList: failed to create pointer."));
			return false;
		}
		ASSERT(a_listSample);
		if (!a_listSample)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSampleList: invalid list pointer."));
			return false;
		}

		COTSSamplesList listSample;
		listSample.clear();

		for (int i = 0; i < a_listSample->Count; i++)
		{
			COTSSamplePtr pSample = a_listSample[i]->GetSamplePtr();
			
			ASSERT(pSample);
			if (!pSample)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("SetSampleList: invalid list pointer."));
				return false;
			}
			listSample.push_back(pSample);
		}
		
		pProjMgrFile->SetSampleList(listSample, a_bClear);
		return true;
	}
	COTSSampleClr^ CProjMgrClr::GetSampleByIndex(int a_nIndex)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSampleByIndex: invalid pointer."));
			return nullptr;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSampleByIndex: failed to create pointer."));
			return nullptr;
		}
		COTSSamplePtr pSample = pProjMgrFile->GetSampleByIndex(a_nIndex);
		
		ASSERT(pSample);
		if (!pSample)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSampleByIndex: failed to create pointer."));
		}

		COTSSampleClr^ pSampleClr = gcnew COTSSampleClr(pSample);
		return pSampleClr;
	}
	COTSSampleClr^ CProjMgrClr::GetSampleByName(String^ a_strSampleName)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSampleList: invalid pointer."));
			return nullptr;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSampleList: failed to create pointer."));
			return nullptr;
		}
		COTSSamplePtr pSample = pProjMgrFile->GetSampleByName(a_strSampleName);

		ASSERT(pSample);
		if (!pSample)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSampleByName: failed to create pointer."));
		}

		COTSSampleClr^ pSampleClr = gcnew COTSSampleClr(pSample);
		return pSampleClr;
	}
	COTSSampleClr^ CProjMgrClr::AddSample(String^ a_strHoleName)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("AddSample: invalid pointer."));
			return nullptr;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		
			

		COTSSamplePtr pSample = pProjMgrFile->AddSample(a_strHoleName);
		ASSERT(pSample);
		if (!pSample)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("AddSample: failed to create pointer."));
		}
	

		COTSSampleClr^ pSampleClr = gcnew COTSSampleClr(pSample);
		return pSampleClr;
	}
	bool CProjMgrClr::DeleteSampleByIndex(int a_nIndex)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("DeleteSampleByIndex: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("DeleteSampleByIndex: failed to create pointer."));
			return false;
		}

		bool bRet = false;
		bRet = pProjMgrFile->DeleteSampleByIndex(a_nIndex);

		return bRet;
	}
	bool CProjMgrClr::DeleteSampleByName(String^ a_strSampleName)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("DeleteSampleByName: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("DeleteSampleByName: failed to create pointer."));
			return false;
		}

		bool bRet = false;
		bRet = pProjMgrFile->DeleteSampleByName(a_strSampleName);

		return bRet;
	}
	bool CProjMgrClr::SameNameInList(String^ a_strSampleName, int a_nExclude)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SameNameInList: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SameNameInList: failed to create pointer."));
			return false;
		}

		bool bRet = false;
		bRet = pProjMgrFile->SameNameInList(a_strSampleName, a_nExclude);
		return bRet;
	}
	bool CProjMgrClr::ResetSamplesListOrder(System::Collections::Generic::List<String^>^ a_listSampleNames)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("ResetSamplesListOrder: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("ResetSamplesListOrder: failed to create pointer."));
			return false;
		}

		ASSERT(a_listSampleNames);
		if (!a_listSampleNames)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("ResetSamplesListOrder: invalid list pointer."));
			return false;
		}

		std::vector<CString> listSampleNames;
		listSampleNames.clear();

		for (int i = 0; i < a_listSampleNames->Count; i++)
		{
			listSampleNames.push_back(a_listSampleNames[i]);
		}

		bool bRet = false;
		bRet = pProjMgrFile->ResetSamplesListOrder(listSampleNames);
		return bRet;
	}
	bool CProjMgrClr::InsrtSample(COTSSampleClr^ a_pSample, int a_nIndex)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("InsrtSample: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("InsrtSample: failed to create pointer."));
			return false;
		}

		ASSERT(a_pSample);
		if (!a_pSample)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("InsrtSample: failed to create pointer."));
			return false;
		}

		COTSSamplePtr pSample = a_pSample->GetSamplePtr();
		
		ASSERT(pSample);
		if (!pSample)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("InsrtSample: failed to create pointer."));
			return false;
		}

		bool bRet = false;
		bRet = pProjMgrFile->InsrtSample(pSample, a_nIndex);

		return bRet;
	}
	bool CProjMgrClr::ChangeSamplePosition(int a_nIndexFrom, int a_nIndexTo)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("ChangeSamplePosition: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("ChangeSamplePosition: failed to create pointer."));
			return false;
		}

		bool bRet = false;
		bRet = pProjMgrFile->ChangeSamplePosition(a_nIndexFrom, a_nIndexTo);

		return bRet;
	}
	bool CProjMgrClr::MoveSamplePosition(COTSSampleClr^ a_pTargetSample, COTSSampleClr^ a_RefpSample, bool a_bBefore)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("MoveSamplePosition: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("MoveSamplePosition: failed to create pointer."));
			return false;
		}
		ASSERT(a_pTargetSample);
		if (!a_pTargetSample)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("MoveSamplePosition: failed to create pointer."));
			return false;
		}

		COTSSamplePtr pTargetSample = a_pTargetSample->GetSamplePtr();

		ASSERT(pTargetSample);
		if (!pTargetSample)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("MoveSamplePosition: failed to create pointer."));
			return false;
		}
		
		
		ASSERT(a_RefpSample);
		if (!a_RefpSample)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("MoveSamplePosition: failed to create pointer."));
			return false;
		}		

		COTSSamplePtr RefpSample = a_RefpSample->GetSamplePtr();

		ASSERT(RefpSample);
		if (!RefpSample)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("MoveSamplePosition: failed to create pointer."));
			return false;
		}

		bool bRet = false;
		bRet = pProjMgrFile->MoveSamplePosition(pTargetSample, RefpSample, a_bBefore);

		return bRet;
	}
	bool CProjMgrClr::MoveSamplePosition(String^ a_strTargetSampleName, String^ a_strRefSampleName, bool a_bBefore)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("MoveSamplePosition: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("MoveSamplePosition: failed to create pointer."));
			return false;
		}

		bool bRet = false;
		bRet = pProjMgrFile->MoveSamplePosition(a_strTargetSampleName, a_strRefSampleName, a_bBefore);

		return bRet;
	}

	// working sample
	COTSSampleClr^ CProjMgrClr::GetWorkingSample()
	{

		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetWorkingSample: invalid pointer."));
			return nullptr;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetWorkingSample: failed to create pointer."));
			return nullptr;
		}
		COTSSamplePtr pSample = pProjMgrFile->GetWorkingSample();
		
		if(!pSample)
		{
			LogTrace(__FILE__, __LINE__, _T("GetWorkingSample: there is no sample in the list."));
			return nullptr;
		}		
		
		COTSSampleClr^ pSampleClr = gcnew COTSSampleClr(pSample);

		return pSampleClr;
	}
	int CProjMgrClr::GetWorkingSampleIndex()
	{

		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetWorkingSampleIndex: invalid pointer."));
			return -1;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetWorkingSampleIndex: failed to create pointer."));
			return -1;
		}
		return pProjMgrFile->GetWorkingSampleIndex();

	}
	bool CProjMgrClr::SetWorkingSampleByIndex(int a_nIndex)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetWorkingSampleByIndex: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetWorkingSampleByIndex: failed to create pointer."));
			return false;
		}

		bool bRet = false;
		bRet = pProjMgrFile->SetWorkingSampleByIndex(a_nIndex);
		
		return bRet;
	}
	bool CProjMgrClr::SetWorkingSampleByName(String^ a_pSampleName)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetWorkingSampleByName: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetWorkingSampleByName: failed to create pointer."));
			return false;
		}

		bool bRet = false;
		bRet = pProjMgrFile->SetWorkingSampleByName(a_pSampleName);

		return bRet;
	}
	bool CProjMgrClr::DeleteWorkingSample()
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("DeleteWorkingSample: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("DeleteWorkingSample: failed to create pointer."));
			return false;
		}

		bool bRet = false;
		bRet = pProjMgrFile->DeleteWorkingSample();

		return bRet;
	}

	CHoleBSEImgsListClr ^ CProjMgrClr::GetHoleBESImgList()
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetHoleBESImgList: invalid pointer."));
			return nullptr;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetHoleBESImgList: failed to create pointer."));
			return nullptr;
		}
		auto imgList= pProjMgrFile->GetHoleBESImgList();
		auto imgs = gcnew CHoleBSEImgsListClr();
		for each(auto i in imgList)
		{
			imgs->Add(gcnew CHoleBSEImgClr(i));
		}
		return imgs;
	}

	// Sample hole BSE image list
	bool CProjMgrClr::SetHoleBESImgList(CHoleBSEImgsListClr^ a_listHoleBSEImg, bool a_bClear)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetHoleBESImgList: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetHoleBESImgList: failed to create pointer."));
			return false;
		}
		ASSERT(a_listHoleBSEImg);
		if (!a_listHoleBSEImg)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetHoleBESImgList: invalid list pointer."));
			return false;
		}

		CHoleBSEImgsList listHoleBSEImg;
		listHoleBSEImg.clear();

		for (int i = 0; i < a_listHoleBSEImg->Count; i++)
		{
			CHoleBSEImgPtr pHoleBSEImg = a_listHoleBSEImg[i]->GetHoleBSEImgPtr();

			ASSERT(pHoleBSEImg);
			if (!pHoleBSEImg)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("SetHoleBESImgList: invalid list pointer."));
				return false;
			}
			listHoleBSEImg.push_back(pHoleBSEImg);
		}
		pProjMgrFile->SetHoleBESImgList(listHoleBSEImg, a_bClear);
		return true;

	}

	CSTDItemsListClr ^ CProjMgrClr::GetSysSTDItemList()
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSysSTDItemList: invalid pointer."));
			return nullptr;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSysSTDItemList: failed to create pointer."));
			return nullptr;
		}
		auto stdList= pProjMgrFile->GetSysSTDItem();
		auto stds = gcnew CSTDItemsListClr();
		for each (auto s in stdList)
		{
			stds->Add(gcnew CSTDItemClr(s));
		}
		return stds;
	}

	bool CProjMgrClr::SetSTDItemList(CSTDItemsListClr^ a_listSysSTDItem, bool a_bClear)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSTDItemList: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSTDItemList: failed to create pointer."));
			return false;
		}
		ASSERT(a_listSysSTDItem);
		if (!a_listSysSTDItem)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSTDItemList: invalid list pointer."));
			return false;
		}

		CSTDItemsList listSTDItem;
		listSTDItem.clear();

		for (int i = 0; i < a_listSysSTDItem->Count; i++)
		{
			CSTDItemPtr pSTDItem = a_listSysSTDItem[i]->GetSTDItemPtr();

			ASSERT(pSTDItem);
			if (!pSTDItem)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("SetSTDItemList: invalid list pointer."));
				return false;
			}
			listSTDItem.push_back(pSTDItem);
		}

		return pProjMgrFile->SetSysSTDItem(listSTDItem, a_bClear);

	}
	CGenParamClr^ CProjMgrClr::GetGenParam()
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetGenParam: invalid pointer."));
			return nullptr;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetGenParam: failed to create pointer."));
			return nullptr;
		}

		COTSGeneralParametersPtr pGenParam = pProjMgrFile->GetGenParam();
		ASSERT(pGenParam);
		if (!pGenParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetGenParam: failed to create pointer."));
			return nullptr;
		}

		CGenParamClr^ pGenParamClr = gcnew CGenParamClr(pGenParam);
		return pGenParamClr;
	}

	// set general parameter
	void CProjMgrClr::SetGenParam(CGenParamClr^ a_pGenParam)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetGenParam: invalid pointer."));
			return;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetGenParam: failed to create pointer."));
			return;
		}
		ASSERT(a_pGenParam);
		if (!a_pGenParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetGenParam: invalid general param pointer."));
			return;
		}

		pProjMgrFile->SetGenParam ( a_pGenParam->GetCOTSGeneralParametersPtr ());
	}
	COTSImgScanPrmClr^ CProjMgrClr::GetImageScanParam()
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetImageScanParam: invalid pointer."));
			return nullptr;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetImageScanParam: failed to create pointer."));
			return nullptr;
		}

		auto p = pProjMgrFile->GetImageScanParam();
		ASSERT(p);
		if (!p)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetImageScanParam: failed to create pointer."));
			return nullptr;
		}
		COTSImgScanPrmClr^ pClr = gcnew COTSImgScanPrmClr(p);
		return pClr;

	}


	// set image scan parameter
	void CProjMgrClr::SetImageScanParam(COTSImgScanPrmClr^ a_pImageScanParam)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageScanParam: invalid pointer."));
			return;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageScanParam: failed to create pointer."));
			return;
		}
		ASSERT(a_pImageScanParam);
		if (!a_pImageScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageScanParam: invalid image scan pointer."));
			return;
		}

		pProjMgrFile->SetImageScanParam( a_pImageScanParam->GetImgScanPrmPtr());
	}
	COTSImgProcPrmClr^ CProjMgrClr::GetImageProcParam()
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetImageProcParam: invalid pointer."));
			return nullptr;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetImageProcParam: failed to create pointer."));
			return nullptr;
		}

		auto p = pProjMgrFile->GetImageProcParam();
		ASSERT(p);
		if (!p)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetImageProcParam: failed to create pointer."));
			return nullptr;
		}
		COTSImgProcPrmClr^ pClr = gcnew COTSImgProcPrmClr(p);
		return pClr;
	}
	// set image process parameter
	void CProjMgrClr::SetImageProcParam(COTSImgProcPrmClr^ a_pImageProcParam)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageProcParam: invalid pointer."));
			return;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageProcParam: failed to create pointer."));
			return;
		}
		ASSERT(a_pImageProcParam);
		if (!a_pImageProcParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageProcParam: invalid image process pointer."));
			return;
		}

		pProjMgrFile->SetImageProcParam( a_pImageProcParam->GetImgPrcPrmPtr());
	}

	COTSXRayPrmClr^ CProjMgrClr::GetXRayParam()
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetXRayParam: invalid pointer."));
			return nullptr;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetXRayParam: failed to create pointer."));
			return nullptr;
		}

		auto p = pProjMgrFile->GetXRayParam();
		ASSERT(p);
		if (!p)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetXRayParam: failed to create pointer."));
			return nullptr;
		}
		COTSXRayPrmClr^ pClr = gcnew COTSXRayPrmClr(p);
		return pClr;
	}

	// set XRay parameter
	void CProjMgrClr::SetXRayParam(COTSXRayPrmClr^ a_pXRayParam)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetXRayParam: invalid pointer."));
			return;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetXRayParam: failed to create pointer."));
			return;
		}
		ASSERT(a_pXRayParam);
		if (!a_pXRayParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetXRayParam: invalid x ray param pointer."));
			return;
		}

		pProjMgrFile->SetXRayParam ( a_pXRayParam->GetCOTSXRayPrmPtr());
	}

	// get modify flag
	bool CProjMgrClr::IsModified()
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSysSTDItemList: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSysSTDItemList: failed to create pointer."));
			return false;
		}

		return pProjMgrFile->IsModified();
	}
	// set modify flag
	void CProjMgrClr::SetModify(bool a_bModify)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetModify: invalid pointer."));
			return;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetModify: failed to create pointer."));
			return;
		}
		pProjMgrFile->SetModify(a_bModify);
	}

	// set path name
	String^ CProjMgrClr::GetPathName()
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPathName: invalid pointer."));
			return nullptr;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPathName: failed to create pointer."));
			return nullptr;
		}
		CString sPathName = pProjMgrFile->GetPathName();
		String^ PathNameClr = gcnew String(sPathName);
		return PathNameClr;

	}
	void CProjMgrClr::SetPathName(String^ a_strPathName)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPathName: invalid pointer."));
			return;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPathName: failed to create pointer."));
			return;
		}
		pProjMgrFile->SetPathName(a_strPathName);
	}

	String^ CProjMgrClr::GetFileName()
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetFileName: invalid pointer."));
			return nullptr;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetFileName: failed to create pointer."));
			return nullptr;
		}
		CString sName = pProjMgrFile->GetFileName();

		String^ sNameClr = gcnew String(sName);

		return sNameClr;

	}

	bool CProjMgrClr::IsValidSampleName(String^ a_sName)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("IsValidSampleName: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("IsValidSampleName: failed to create pointer."));
			return false;
		}
		ASSERT(a_sName);
		if (!a_sName)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("IsValidSampleName: invalid pointer."));
			return false;
		}		

		bool bRet = pProjMgrFile->IsValidSampleName(a_sName);

		return bRet;
	}

	//get param file name
	bool CProjMgrClr::GetParamFileList(int% a_nPos, System::Collections::Generic::List<String^>^% a_listParamName)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetParamFileList: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetParamFileList: failed to create pointer."));
			return false;
		}
		ASSERT(a_listParamName);
		if (!a_listParamName)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetParamFileList: invalid list pointer."));
			return false;
		}

		int nPos;
		std::vector<CString> listSTDLibName;

		bool bRet = pProjMgrFile->GetParamFileList(nPos, listSTDLibName);
		a_nPos = nPos;

		for (auto sParamName : listSTDLibName)
		{
			String^ sParamNameClr = gcnew String(sParamName);
			a_listParamName->Add(sParamNameClr);
		}

		return bRet;
	}
	// change STD
	bool CProjMgrClr::ChangeParamFromList(int a_nPos)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("ChangeParamFromList: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("ChangeParamFromList: failed to create pointer."));
			return false;
		}
		bool bRet = pProjMgrFile->ChangeParamFromList(a_nPos);
		return bRet;
	}

	// get STD file list
	bool CProjMgrClr::GetSTDFileList(int% a_nPos, System::Collections::Generic::List<String^>^ % a_listSTDLibName)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSTDFileList: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSTDFileList: failed to create pointer."));
			return false;
		}
		ASSERT(a_listSTDLibName);
		if (!a_listSTDLibName)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSTDFileList: invalid list pointer."));
			return false;
		}	

		int nPos;
		std::vector<CString> listSTDLibName;

		bool bRet = pProjMgrFile->GetSTDFileList(nPos, listSTDLibName);

		a_nPos = nPos;

		for (auto sSTDName : listSTDLibName)
		{
			String^ sSTDNameClr = gcnew String(sSTDName);
			a_listSTDLibName->Add(sSTDNameClr);
		}

		return bRet;
	}
	// change STD
	bool CProjMgrClr::ChangeSTDFromList(int a_nPos)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSysSTDItemList: invalid pointer."));
			return false;
		}
		
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("ChangeSTDFromList: failed to create pointer."));
			return false;
		}

		bool bRet = pProjMgrFile->ChangeSTDFromList(a_nPos);
		return bRet;
	}

	// get sample measured list
	bool CProjMgrClr::GetMsredSampleList(COTSSamplesListClr^ % a_listMsredSample)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetMsredSampleList: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetMsredSampleList: failed to create pointer."));
			return false;
		}
		ASSERT(a_listMsredSample);
		if (!a_listMsredSample)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetMsredSampleList: invalid list pointer."));
			return false;
		}

		COTSSamplesList listMsrdSample;

		bool bRet = pProjMgrFile->GetMsredSampleList(listMsrdSample);

		for (auto pSample : listMsrdSample)
		{
			COTSSampleClr^ pSampleClr = gcnew COTSSampleClr(pSample);
			a_listMsredSample->Add(pSampleClr);
		}

		return bRet;
	}

	CDomainClr^ CProjMgrClr::CalculateMsrArea(CHoleClr^ a_pHole)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CalculateMsrArea: invalid pointer."));
			return nullptr;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CalculateMsrArea: failed to create pointer."));
			return nullptr;
		}
		ASSERT(a_pHole);
		if (!a_pHole)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CalculateMsrArea: invalid hole pointer."));
			return nullptr;
		}


		CHolePtr pHole = a_pHole->GetHolePtr();

		ASSERT(pHole);
		if (!pHole)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CalculateMsrArea: invalid hole pointer."));
			return nullptr;
		}

		CDomainPtr pDomain = pProjMgrFile->CalculateMsrArea(pHole);

		CDomainClr^ DomainClr = gcnew CDomainClr(pDomain);

		return DomainClr;
	}

	bool CProjMgrClr::RemoveBackGround(CBSEImgClr^ a_pImgIn, COTSImgProcPrmClr^ a_pImgProcessParam, CBSEImgClr^ % a_pImgOut)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("RemoveBackGround: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("RemoveBackGround: failed to create pointer."));
			return false;
		}
		ASSERT(a_pImgIn);
		if (!a_pImgIn)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("RemoveBackGround: invalid pointer."));
			return false;
		}
		CBSEImgPtr pImgIn = a_pImgIn->GetBSEImgPtr();
		ASSERT(pImgIn);
		if (!pImgIn)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("RemoveBackGround: can't generate image in pointer."));
			return false;
		}

		ASSERT(a_pImgProcessParam);
		if (!a_pImgProcessParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("RemoveBackGround: invalid pointer."));
			return false;
		}
		COTSImageProcessParamPtr pImageProcessParam = a_pImgProcessParam->GetImgPrcPrmPtr();
		ASSERT(pImageProcessParam);
		if (!pImageProcessParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("RemoveBackGround: can't generate image."));
			return false;
		}

		CBSEImgPtr pImgOut = CBSEImgPtr(new CBSEImg());

		bool bRet = pProjMgrFile->RemoveBackGround(pImgIn, pImageProcessParam, pImgOut);

		if (!bRet)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("RemoveBackGround: remove background failed."));
			return false;
		}

		a_pImgOut = gcnew CBSEImgClr(pImgOut);

		ASSERT(a_pImgOut);
		if (!a_pImgOut)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("RemoveBackGround: remove background image invalid."));
			return false;
		}

		return bRet;
	}
	
	bool CProjMgrClr::GetSystemSTDLib(int a_nPacketId)
	{
		if (m_LpProjMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSystemSTDLib: invalid pointer."));
			return false;
		}
		COTSProjMgrFilePtr pProjMgrFile = GetCProjMgrPtr();
		ASSERT(pProjMgrFile);
		if (!pProjMgrFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSystemSTDLib: failed to create pointer."));
			return false;
		}
		bool bRet = pProjMgrFile->GetSystemSTDLib((OTS_SOFT_PACKAGE_ID)a_nPacketId);

		if (!bRet)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSystemSTDLib: remove background failed."));
			return false;
		}


		return bRet;
	}
		
}