#include "stdafx.h"
#include "PropParamClr.h"


namespace OTSINTERFACE {

	CPropParamClr::CPropParamClr(int a_nType)
	{
		
			switch (a_nType)
			{
			case (int)DISPLAY_PICTURE_TYPE::IMAGE:
				m_LpPropParam = new CPropParamPtr(new CPropParamImage());
				m_LpPropParam ->get()->SetType((DISPLAY_PICTURE_TYPE)a_nType);
				break;
			case (int)DISPLAY_PICTURE_TYPE::CHART:
				m_LpPropParam = new CPropParamPtr(new CPropParamChart());
				m_LpPropParam->get()->SetType((DISPLAY_PICTURE_TYPE)a_nType);
				break;
			case (int)DISPLAY_PICTURE_TYPE::TABLE:
				m_LpPropParam = new CPropParamPtr(new CPropParamGrid());
				m_LpPropParam->get()->SetType((DISPLAY_PICTURE_TYPE)a_nType);
				break;
			}
	}	

	CPropParamClr::CPropParamClr(CPropParamPtr a_poSource)
	{
		ASSERT(a_poSource);
		if(!a_poSource)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CPropParamClr: invalid pointer."));
			return;
		}

			m_LpPropParam = new CPropParamPtr(a_poSource);
		

	}

	CPropParamClr::~CPropParamClr()
	{
		if (m_LpPropParam != nullptr)
		{
			delete m_LpPropParam;
			m_LpPropParam = nullptr;
		}
	}
	CPropParamClr::!CPropParamClr()
	{
		if (m_LpPropParam != nullptr)
		{
			delete m_LpPropParam;
			m_LpPropParam = nullptr;
		}
	}

	CPropParamPtr CPropParamClr::GetPropParamPtr()
	{
		return *m_LpPropParam;
	}

	int CPropParamClr::GetType()
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetType: invalid pointer."));
			return -1;
		}

		CPropParamPtr pPropParam = GetPropParamPtr();
		ASSERT(pPropParam);
		if (!pPropParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetType: invalid pointer."));
			return -1;
		}

		DISPLAY_PICTURE_TYPE nType = pPropParam->GetType();

		return (int)nType;
	}
	void CPropParamClr::SetType(int a_nType)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetType: invalid pointer."));
			return;
		}

		CPropParamPtr pPropParam = GetPropParamPtr();
		ASSERT(pPropParam);
		if (!pPropParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetType: invalid pointer."));
			return;
		}

		pPropParam->SetType((DISPLAY_PICTURE_TYPE)a_nType);
	}
	// property items list
	List<CPropItemClr^>^ CPropParamClr::GetPropItemsList()
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPropItemsList: invalid pointer."));
			return nullptr;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPropItemsList: invalid pointer."));
			return nullptr;
		}

		List<CPropItemClr^>^ ItemsListClr = gcnew List<CPropItemClr^>();
		CPropItemsList ItemsList = PropParamPtr->GetPropItemsList();
		for (auto pItem : ItemsList)
		{
			CPropItemClr^ ItemClr = gcnew CPropItemClr(pItem);
			ItemsListClr->Add(ItemClr);
		}

		return ItemsListClr;
	}
	bool CPropParamClr::SetPropertyItems()
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPropItemsList: invalid pointer."));
			return false;
		}
		CPropParamPtr PropParamPtr = *m_LpPropParam;
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPropItemsList: invalid pointer."));
			return false;
		}
		
		
		PropParamPtr->SetPropertyItems();

		return true;
	}
	List<String^>^ CPropParamClr::GetDataSourceList()
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetDataSourceList: invalid pointer."));
			return nullptr;
		}

		CPropParamPtr pPropParam = GetPropParamPtr();
		ASSERT(pPropParam);
		if (!pPropParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetDataSourceList: invalid pointer."));
			return nullptr;
		}

		std::vector<CString> listDataSource = pPropParam->GetDataSourceList();
		List<String^>^ listDataSourceClr = gcnew List<String^>();
		for (auto sDataSource : listDataSource)
		{
			String^ DataSourceClr = gcnew String(sDataSource);
			listDataSourceClr->Add(DataSourceClr);
		}

		return listDataSourceClr;
	}
	// data source id
	bool CPropParamClr::SetDataSourceList(List<String^>^ a_listDataSource)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetDataSourceList: invalid pointer."));
			return false;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetDataSourceList: invalid pointer."));
			return false;
		}


		std::vector<CString> VString;

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

		bool bRet = PropParamPtr->SetDataSourceList(VString);

		return bRet;	
		
	}

	int CPropParamClr::GetDataSourceId()
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetDataSourceId: invalid pointer."));
			return -1;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetDataSourceId: invalid pointer."));
			return -1;
		}
		return PropParamPtr->GetDataSourceId();
	}

	bool CPropParamClr::SetDataSourceId(int a_nDataSourceId)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetDataSourceId: invalid pointer."));
			return false;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetDataSourceId: invalid pointer."));
			return false;
		}
		if (!PropParamPtr->SetDataSourceId(a_nDataSourceId))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(SetDataSourceId )SetDataSourceId(a_nDataSourceI = %d) = false "), a_nDataSourceId);
			return false;
		}
		
		return true;
	}

	int CPropParamClr::GetDataSourceType()
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetDataSourceType: invalid pointer."));
			return (int)DATA_SOURCE_TYPE::INVALID;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetDataSourceType: invalid pointer."));
			return (int)DATA_SOURCE_TYPE::INVALID;
		}
		
		return (int)PropParamPtr->GetDataSourceType();
	}

	// data source type
	bool CPropParamClr::SetDataSourceType(int a_nDataSourceType)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetDataSourceType: invalid pointer."));
			return false;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetDataSourceType: invalid pointer."));
			return false;
		}
		if (!PropParamPtr->SetDataSourceType((DATA_SOURCE_TYPE)a_nDataSourceType))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(SetDataSourceType )SetDataSourceType(a_nDataSourceType = %d) = false "), a_nDataSourceType);
			return false;
		}

		return true;
	}

	COTSParticleListClr^ CPropParamClr::GetSelectParticle()
	{
		COTSParticleListClr^ listSelectParticleClr = gcnew COTSParticleListClr();
		if (m_LpPropParam != nullptr)
		{
			COTSParticleList listSelectParticle = m_LpPropParam->get()->GetSelectParticle();
			for (auto pParticle : listSelectParticle)
			{
				COTSParticleClr^ ParticleClr = gcnew COTSParticleClr(pParticle);
				listSelectParticleClr->Add(ParticleClr);
			}
		}

		return listSelectParticleClr;

	}

	bool CPropParamClr::SetSelectParticle(COTSParticleListClr^ a_listSelectParticle)
	{
		ASSERT(a_listSelectParticle);
		if (!a_listSelectParticle)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSelectParticle: invalid SelectParticle pointer."));
			return false;
		}

		bool bResult = false;

		if (m_LpPropParam != nullptr)
		{
			std::vector<COTSParticlePtr> listSelectParticle;
			for (int i = 0; i < (int)a_listSelectParticle->Count; i++)
			{
				listSelectParticle.push_back(a_listSelectParticle[i]->GetOTSParticlePtr());
			}

			m_LpPropParam->get()->SetSelectParticle(listSelectParticle);

			bResult = true;
		}

		return bResult;
	}

	int CPropParamClr::GetImageType()
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetImageType: invalid pointer."));
			return (int)IMAGE_TYPE::INVALID;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetImageType: invalid pointer."));
			return (int)IMAGE_TYPE::INVALID;
		}

		return (int)PropParamPtr->GetImageType();
	}

	// image type
	bool CPropParamClr::SetImageType(int a_nImageType)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageType: invalid pointer."));
			return false;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageType: invalid pointer."));
			return false;
		}
		if (!PropParamPtr->SetImageType((IMAGE_TYPE)a_nImageType))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(SetImageType )SetImageType(a_nImageType = %d) = false "), a_nImageType);
			return false;
		}

		return true;
	}

	int CPropParamClr::GetImageDisplayType()
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetImageDisplayType: invalid pointer."));
			return (int)IMAGE_DISPLAY_TYPE::INVALID;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetImageDisplayType: invalid pointer."));
			return (int)IMAGE_DISPLAY_TYPE::INVALID;
		}

		return (int)PropParamPtr->GetImageDisplayType();
	}

	// image display type
	bool CPropParamClr::SetImageDisplayType(int a_nImageDisplayType)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageDisplayType: invalid pointer."));
			return false;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageDisplayType: invalid pointer."));
			return false;
		}
		if (!PropParamPtr->SetImageDisplayType((IMAGE_DISPLAY_TYPE)a_nImageDisplayType))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(SetImageDisplayType )SetImageDisplayType(a_nImageDisplayType = %d) = false "), a_nImageDisplayType);
			return false;
		}

		return true;
		
	}

	int CPropParamClr::GetMeasureDataType()
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetMeasureDataType: invalid pointer."));
			return (int)MEASURE_DATA_TYPE::INVALID;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetMeasureDataType: invalid pointer."));
			return (int)MEASURE_DATA_TYPE::INVALID;
		}

		return (int)PropParamPtr->GetMeasureDataType();
	}

	// measure data type
	bool CPropParamClr::SetMeasureDataType(int a_nMeasureDataType)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetMeasureDataType: invalid pointer."));
			return false;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetMeasureDataType: invalid pointer."));
			return false;
		}
		if (!PropParamPtr->SetMeasureDataType((MEASURE_DATA_TYPE)a_nMeasureDataType))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(SetMeasureDataType )SetMeasureDataType(a_nMeasureDataType = %d) = false "), a_nMeasureDataType);
			return false;
		}
				
		return true;
	}

	int CPropParamClr::GetCalTableType()
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetCalTableType: invalid pointer."));
			return (int)CALCULATE_TABLE_TYPE::INVALID;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetCalTableType: invalid pointer."));
			return (int)CALCULATE_TABLE_TYPE::INVALID;
		}

		return (int)PropParamPtr->GetCalTableType();
	}

	// calculate table type
	bool CPropParamClr::SetCalTableType(int a_nCalTableType)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetCalTableType: invalid pointer."));
			return false;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetCalTableType: invalid pointer."));
			return false;
		}
		if (!PropParamPtr->SetCalTableType((CALCULATE_TABLE_TYPE)a_nCalTableType))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(SetCalTableType )SetCalTableType(a_nCalTableType = %d) = false "), a_nCalTableType);
			return false;
		}
		return true;
	}

	int CPropParamClr::GetCalChartType()
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetCalChartType: invalid pointer."));
			return (int)CALCULATE_CHART_TYPE::INVALID;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetCalChartType: invalid pointer."));
			return (int)CALCULATE_CHART_TYPE::INVALID;
		}

		return (int)PropParamPtr->GetCalChartType();
	}

	// calculate chart type
	bool CPropParamClr::SetCalChartType(int a_nCalChartType)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetCalChartType: invalid pointer."));
			return false;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetCalChartType: invalid pointer."));
			return false;
		}
		if (!PropParamPtr->SetCalChartType((CALCULATE_CHART_TYPE)a_nCalChartType))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(SetCalChartType )SetCalChartType(a_nCalChartType = %d) = false "), a_nCalChartType);
			return false;
		}
		return true;
	}

	int CPropParamClr::GetPartType()
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartType: invalid pointer."));
			return (int)PARTICLE_TYPE::INVALID;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartType: invalid pointer."));
			return (int)PARTICLE_TYPE::INVALID;
		}

		return (int)PropParamPtr->GetPartType();
	}

	// particle type
	bool CPropParamClr::SetPartType(int a_nPartType)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPartType: invalid pointer."));
			return false;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPartType: invalid pointer."));
			return false;
		}
		if (!PropParamPtr->SetPartType((PARTICLE_TYPE)a_nPartType))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(SetPartType )SetPartType(a_nPartType = %d) = false "), a_nPartType);
			return false;
		}
		return true;
	}

	CPartSTDDataClr^ CPropParamClr::GetWorkingSTDLib()
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetWorkingSTDLib: invalid pointer."));
			return nullptr;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetWorkingSTDLib: invalid pointer."));
			return nullptr;
		}
		CPartSTDDataPtr PSTDDataPtr = PropParamPtr->GetWorkingSTDLib();
		if (!PSTDDataPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(GetWorkingSTDLib ) PSTDDataPtr = NUll"));
			return nullptr;
		}

		CPartSTDDataClr^ PSTDDataPtrClr = gcnew CPartSTDDataClr(PSTDDataPtr);
		return PSTDDataPtrClr;
	}

	// STD index
	bool CPropParamClr::SetWorkingSTDLib(CPartSTDDataClr^ a_pWorkingSTDLib)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetWorkingSTDLib: invalid pointer."));
			return false;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetWorkingSTDLib: invalid pointer."));
			return false;
		}
		CPartSTDDataPtr PSTDDataPtr = a_pWorkingSTDLib->GetPartSTDDataPtr();
		if (!PSTDDataPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(SetWorkingSTDLib ) PSTDDataPtr = NUll"));
			return false;
		}

		PropParamPtr->SetWorkingSTDLib(PSTDDataPtr);
		return true;
	}

	int CPropParamClr::GetSTDId()
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSTDId: invalid pointer."));
			return -1;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSTDId: invalid pointer."));
			return -1;
		}

		return PropParamPtr->GetSTDId();
	}

	bool CPropParamClr::SetSTDId(int a_nSTDId)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSTDId: invalid pointer."));
			return false;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSTDId: invalid pointer."));
			return false;
		}
		if (!PropParamPtr->SetSTDId(a_nSTDId))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(SetSTDId )SetSTDId(a_nSTDId = %d) = false "), a_nSTDId);
			return false;
		}
		return true;
	}
	bool CPropParamClr::GetPartSizeFileList(int % a_nPos, List<String^>^ % a_listPartSizeName)
	{
		
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		

		

		int nPos;
		std::vector<CString> listPartSizeName;
		auto pList=PropParamPtr->GetSizeFileList();
		/*if (!PropParamPtr->GetPartSizeFileList(nPos, listPartSizeName))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSizeFileList: failed to call function."));
			return false;
		}

		a_nPos = nPos;*/

		a_listPartSizeName->Clear();

		for (auto PartSize : pList)
		{
			String^ sPartSizeNameClr = gcnew String(PartSize->GetName ());
			a_listPartSizeName->Add(sPartSizeNameClr);
		}

		return true;
	}
	CPartSizeFileClr^ CPropParamClr::GetWorkingSizeClass()
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetWorkingSizeClass: invalid pointer."));
			return nullptr;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetWorkingSizeClass: invalid pointer."));
			return nullptr;
		}
		CPartSizeFilePtr PartSizeFile = PropParamPtr->GetWorkingSizeFile();
		if (!PartSizeFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetWorkingSizeClass: invalid pointer."));
			return nullptr;
		}

		CPartSizeFileClr^ PPartSizeFileClr = gcnew CPartSizeFileClr(PartSizeFile);
		return PPartSizeFileClr;
	}

	bool CPropParamClr::SetWorkingSizeClass(CPartSizeFileClr^ a_pWorkingSizeClass)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetWorkingSizeClass: invalid pointer."));
			return false;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetWorkingSizeClass: invalid pointer."));
			return false;
		}
		CPartSizeFilePtr PSizeClasPtr = a_pWorkingSizeClass->GetPartSizeFilePtr();
		if (!PSizeClasPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(SetWorkingSizeClass )  PSizeClasPtr = null"));
			return false;
		}

		if (!PropParamPtr->SetWorkingSizeFile(PSizeClasPtr))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(SetWorkingSizeClass )SetWorkingSizeClass(PSizeClasPtr) = false "));
			return false;
		}
		return true;		
	}

	int CPropParamClr::GetSizeClassId()
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSizeClassId: invalid pointer."));
			return -1;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSizeClassId: invalid pointer."));
			return -1;
		}

		return PropParamPtr->GetSizeItemId();
	}

	bool CPropParamClr::SetSizeClassId(int a_nSizeClassId)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSizeClassId: invalid pointer."));
			return false;
		}
		CPropParamPtr pPropParam = GetPropParamPtr();
		ASSERT(pPropParam);
		if (!pPropParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSizeClassId: invalid pointer."));
			return false;
		}
		if (!pPropParam->SetSizeItemId(a_nSizeClassId))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(SetSizeClassId )SetSizeClassId(SetSizeClassId = %d) = false "), a_nSizeClassId);
			return false;
		}
		return true;
	}

	double CPropParamClr::GetGrainSizeMin()
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetGrainSizeMin: invalid pointer."));
			return 0.0;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetGrainSizeMin: invalid pointer."));
			return 0.0;
		}

		return PropParamPtr->GetGrainSizeMin();
	}

	// grain size min
	bool CPropParamClr::SetGrainSizeMin(double a_dGrainSizeMin)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetGrainSizeMin: invalid pointer."));
			return false;
		}	
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetGrainSizeMin: invalid pointer."));
			return false;
		}
		if (!PropParamPtr->SetGrainSizeMin(a_dGrainSizeMin))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(SetGrainSizeMin )SetSizeClassTableId(a_dGrainSizeMin = %d) = false "), a_dGrainSizeMin);
			return false;
		}
		return true;
	}

	double CPropParamClr::GetGrainSizeMax()
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetGrainSizeMax: invalid pointer."));
			return 0.0;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetGrainSizeMax: invalid pointer."));
			return 0.0;
		}

		return PropParamPtr->GetGrainSizeMax();
	}

	// grain size max
	bool CPropParamClr::SetGrainSizeMax(double a_dGrainSizeMax)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetGrainSizeMax: invalid pointer."));
			return false;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetGrainSizeMax: invalid pointer."));
			return false;
		}
		if (!PropParamPtr->SetGrainSizeMax(a_dGrainSizeMax))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(SetGrainSizeMax )SetSizeClassTableId(a_dGrainSizeMax = %d) = false "), a_dGrainSizeMax);
			return false;
		}
		return true;
	}

	int CPropParamClr::GetSizeCalMethodType()
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSizeCalMethodType: invalid pointer."));
			return (int)SIZE_CAL_METHOD_TYPE::INVALID;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSizeCalMethodType: invalid pointer."));
			return (int)SIZE_CAL_METHOD_TYPE::INVALID;
		}

		return (int)PropParamPtr->GetSizeCalMethodType();
	}

	// size calculation method type
	bool CPropParamClr::SetSizeCalMethodType(int a_nSizeCalMethodType)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSizeCalMethodType: invalid pointer."));
			return false;
		}		
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetSizeCalMethodType: invalid pointer."));
			return false;
		}
		if (!PropParamPtr->SetSizeCalMethodType((SIZE_CAL_METHOD_TYPE)a_nSizeCalMethodType))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(SetSizeCalMethodType )SetSizeCalMethodType(a_dGrainSizeMax = %d) = false "), a_nSizeCalMethodType);
			return false;
		}
		return true;
	}

	String^ CPropParamClr::GetTrioChartName()
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetTrioChartName: invalid pointer."));
			return nullptr;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetTrioChartName: invalid pointer."));
			return nullptr;
		}

		CString sName = PropParamPtr->GetTrioChartName();
		String^ sNameClr = gcnew String(sName);

		return sNameClr;
	}

	// trio chart name
	bool CPropParamClr::SetTrioChartName(String^ a_strTrioChartName)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetTrioChartName: invalid pointer."));
			return false;
		}
		CPropParamPtr PropParamPtr = this->GetPropParamPtr();
		ASSERT(PropParamPtr);
		if (!PropParamPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetTrioChartName: invalid pointer."));
			return false;
		}
		if (!PropParamPtr->SetTrioChartName(a_strTrioChartName))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(SetTrioChartName )SetTrioChartName(a_strTrioChartName = %s) = false "), a_strTrioChartName);
			return false;
		}
		return true;
	}

	BOOL CPropParamClr::SetTrioChartType(int a_TrioChartType)
	{
		CPropParamPtr PropParamPtr = GetPropParamPtr();
		PropParamPtr->SetTrioChartType(a_TrioChartType);
		return true;
	}

	int CPropParamClr::GetTrioChartType()
	{
		CPropParamPtr PropParamPtr = GetPropParamPtr();
		int nType;
		nType=PropParamPtr->GetTrioChartType();
		return nType;
	}


	// combo data
	//获取Combo类型的数值
	//	输入：int :属性在属性组内id  Combo 返回的获取值
	//	输出： 获取结果， bool， true：成功，false：失败
	bool CPropParamClr::GetPropComboData(int a_nId, int% a_nValue)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPropComboData: invalid pointer."));
			return false;
		}
		bool bRet;
		int bResult;
		CPropParamPtr PropParamPtr = GetPropParamPtr();
		if (PropParamPtr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPropComboData: invalide pointer."));
			return false;
		}

		bRet = PropParamPtr->GetPropComboData((OTS_RETORT_PROP_GRID_ITEMS)a_nId, bResult);
		a_nValue = bResult;
		return bRet;
	}

	//设定属性值
	//	输入：int，属性id ；string，需要设定的值
	//	输出：bool，设定结果，true，成功，false， 失败
	bool CPropParamClr::SetPropComboData(int a_nId, int a_nValue)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPropComboData: invalid pointer."));
			return false;
		}
		bool bRet = false;

		CPropParamPtr PropParamPtr = GetPropParamPtr();
		if (PropParamPtr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPropComboData: invalide pointer."));
			return false;
		}

		bRet = PropParamPtr->SetPropComboData((OTS_RETORT_PROP_GRID_ITEMS)a_nId, a_nValue);

		return bRet;
	}

	//获取Combo字符串类型
	//	输入：int，属性id，List<string> 返回的字符串
	//	输出：bool，设定结果，true，成功，false， 失败
	bool CPropParamClr::GetPropComboStrings(int a_nId, CStringListClr^% a_listComboStrings)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPropComboStrings: invalid pointer."));
			return false;
		}
		a_listComboStrings->Clear();
		bool bRet;
		CPropParamPtr PropParamPtr = GetPropParamPtr();
		if (PropParamPtr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPropComboStrings: invalide pointer."));
			return false;
		}

		std::vector<CString> bResult;
		bResult.clear();
		bRet = PropParamPtr->GetPropComboStrings((OTS_RETORT_PROP_GRID_ITEMS)a_nId, bResult);


		for (auto pString : bResult)
		{
			String^ str = gcnew String(pString);
			a_listComboStrings->Add(str);
		}
		return bRet;
	}

	// double data 
	// double data (4)
	//获取double类型的数值
	//	输入：int :属性在属性组内id  double 返回的获取值
	//	输出： 获取结果， bool， true：成功，false：失败
	bool CPropParamClr::GetPropDoubleData(int a_nId, double% a_dValue)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPropDoubleData: invalid pointer."));
			return false;
		}
		bool bRet;
		double bResult;

		CPropParamPtr PropParamPtr = GetPropParamPtr();
		if (PropParamPtr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPropDoubleData: invalide pointer."));
			return false;
		}

		bRet = PropParamPtr->GetPropDoubleData((OTS_RETORT_PROP_GRID_ITEMS)a_nId, bResult);

		a_dValue = bResult;

		return bRet;
	}

	//设定属性值
	//	输入：int，属性id ；double，需要设定的值
	//	输出：bool，设定结果，true，成功，false， 失败
	bool CPropParamClr::SetPropDoubleData(int a_nId, double a_dValue)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPropDoubleData: invalid pointer."));
			return false;
		}
		bool bRet = FALSE;

		CPropParamPtr PropParamPtr = GetPropParamPtr();
		if (PropParamPtr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPropDoubleData: invalide pointer."));
			return false;
		}

		bRet = PropParamPtr->SetPropDoubleData((OTS_RETORT_PROP_GRID_ITEMS)a_nId, a_dValue);

		return bRet;
	}

	// string data (7)
	//获取string类型的数值
	//	输入：int :属性在属性组内id  string 返回的获取值
	//	输出： 获取结果， bool， true：成功，false：失败
	bool CPropParamClr::GetPropStringData(int a_nId, String^% a_strValue)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPropStringData: invalid pointer."));
			return false;
		}
		bool bRet;
		CString bResult;

		CPropParamPtr PropParamPtr = GetPropParamPtr();
		if (PropParamPtr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPropStringData: invalide pointer."));
			return false;
		}

		bRet = PropParamPtr->GetPropStringData((OTS_RETORT_PROP_GRID_ITEMS)a_nId, bResult);
		a_strValue = gcnew String(bResult);
		return bRet;
	}

	//设定属性值
	//	输入：int，属性id ；string，需要设定的值
	//	输出：bool，设定结果，true，成功，false， 失败
	bool CPropParamClr::SetPropStringData(int a_nId, String^ a_strValue)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPropStringData: invalid pointer."));
			return false;
		}
		bool bRet = false;

		if (a_strValue == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPropStringData: invalide pointer."));
			return false;
		}

		CPropParamPtr PropParamPtr = GetPropParamPtr();
		if (PropParamPtr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPropStringData: invalide pointer."));
			return false;
		}
		CString str = a_strValue;
		bRet = PropParamPtr->SetPropStringData((OTS_RETORT_PROP_GRID_ITEMS)a_nId, str);

		return bRet;
	}

	//获取相关属性值
	//	输入：int，属性id， int，返回相关属性值
	//	输出：bool，设定结果，true，成功，false，失败
	// get related property item
	bool CPropParamClr::GetRelatedPropItem(int a_nId, int% a_nRelatedPropId)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetRelatedPropItem: invalid pointer."));
			return false;
		}
		bool bRet;
		OTS_RETORT_PROP_GRID_ITEMS bResult;
		CPropParamPtr PropParamPtr = GetPropParamPtr();
		if (PropParamPtr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetRelatedPropItem: invalide pointer."));
			return false;
		}

		bRet = PropParamPtr->GetRelatedPropItem((OTS_RETORT_PROP_GRID_ITEMS)a_nId, bResult);
		a_nRelatedPropId = (int)bResult;

		return bRet;
	}

	// get related property item
	bool CPropParamClr::UpdateAll(int a_nId)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("UpdateAll: invalid pointer."));
			return false;
		}
		bool bRet;
		
		CPropParamPtr PropParamPtr = GetPropParamPtr();
		if (PropParamPtr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("UpdateAll: invalide pointer."));
			return false;
		}

		bRet = PropParamPtr->UpdateAll((OTS_RETORT_PROP_GRID_ITEMS)a_nId);
		return bRet;
	}

	String^ CPropParamClr::GetItemCurrentValueStr(OTS_RETORT_PROP_GRID_ITEMS a_nId)
	{
		if (m_LpPropParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetItemValueStr: invalid pointer."));
			return nullptr;
		}
		
		CPropParamPtr PropParamPtr = GetPropParamPtr();
		if (PropParamPtr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetItemValueStr: invalide pointer."));
			return nullptr;
		}

		CString sVal = PropParamPtr->GetItemValueStr(a_nId);
		return gcnew String(sVal);
	}
	// Get Top Name
	CString CPropParamClr::GetTopName()
	{
		CString nTopName = "";

		if (m_LpPropParam != nullptr)
		{
			nTopName = m_LpPropParam->get()->GetTopName();
		}

		return nTopName;
	}

	// set Top Name
	BOOL CPropParamClr::SetTopName(String^ a_TopName)
	{
		if (m_LpPropParam != nullptr)
		{
			return m_LpPropParam->get()->SetTopName(a_TopName);
		}
		return TRUE;
	}
	// Get Left Name
	CString CPropParamClr::GetLeftName()
	{
		CString nLeftName = "";

		if (m_LpPropParam != nullptr)
		{
			nLeftName = m_LpPropParam->get()->GetLeftName();
		}

		return nLeftName;
	}
	// set Left Name
	BOOL CPropParamClr::SetLeftName(String^ a_LeftName)
	{
		if (m_LpPropParam != nullptr)
		{
			return m_LpPropParam->get()->SetLeftName(a_LeftName);
		}
		return TRUE;
	}
	// Get Right Name
	CString CPropParamClr::GetRightName()
	{
		CString nRgihtName = "";

		if (m_LpPropParam != nullptr)
		{
			nRgihtName = m_LpPropParam->get()->GetRightName();
		}

		return nRgihtName;
	}
	// set Right Name
	BOOL CPropParamClr::SetRightName(String^ a_RightName)
	{
		if (m_LpPropParam != nullptr)
		{
			return m_LpPropParam->get()->SetRightName(a_RightName);
		}
		return TRUE;
	}

	System::Collections::Generic::List<String^>^ CPropParamClr::GetTopElementName()
	{
		System::Collections::Generic::List<String^>^ listTopElementName = gcnew System::Collections::Generic::List<String^>();
		if (m_LpPropParam != nullptr)
		{
			std::vector<CString>& listElementTable = m_LpPropParam->get()->GetTopElementName();
			for (auto strElementName : listElementTable)
			{
				String^ strElementNameClr = gcnew String(strElementName);
				listTopElementName->Add(strElementNameClr);
			}
		}
		return listTopElementName;
	}
	BOOL CPropParamClr::SetTopElementName(System::Collections::Generic::List<String^>^ a_listTopElementName)
	{
		ASSERT(a_listTopElementName);
		if (!a_listTopElementName)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetTopElementName: invalid SetTopElementName list pointer."));
			return false;
		}
		bool bResult = false;

		if (m_LpPropParam != nullptr)
		{
			std::vector<CString> listElementNameTables;
			for (int i = 0; i < (int)a_listTopElementName->Count; i++)
			{
				listElementNameTables.push_back(a_listTopElementName[i]);
			}

			bResult = m_LpPropParam->get()->SetTopElementName(listElementNameTables);
		}

		return bResult;
	}

	System::Collections::Generic::List<String^>^ CPropParamClr::GetLeftElementName()
	{
		System::Collections::Generic::List<String^>^ listLeftElementName = gcnew System::Collections::Generic::List<String^>();
		if (m_LpPropParam != nullptr)
		{
			std::vector<CString>& listElementTable = m_LpPropParam->get()->GetLeftElementName();
			for (auto strElementName : listElementTable)
			{
				String^ strElementNameClr = gcnew String(strElementName);
				listLeftElementName->Add(strElementNameClr);
			}
		}
		return listLeftElementName;
	}
	BOOL CPropParamClr::SetLeftElementName(System::Collections::Generic::List<String^>^ a_listLeftElementName)
	{
		ASSERT(a_listLeftElementName);
		if (!a_listLeftElementName)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetLeftElementName: invalid SetLeftElementName list pointer."));
			return false;
		}
		bool bResult = false;

		if (m_LpPropParam != nullptr)
		{
			std::vector<CString> listElementNameTables;
			for (int i = 0; i < (int)a_listLeftElementName->Count; i++)
			{
				listElementNameTables.push_back(a_listLeftElementName[i]);
			}

			bResult = m_LpPropParam->get()->SetLeftElementName(listElementNameTables);
		}

		return bResult;
	}

	System::Collections::Generic::List<String^>^ CPropParamClr::GetRightElementName()
	{
		System::Collections::Generic::List<String^>^ listRightElementName = gcnew System::Collections::Generic::List<String^>();
		if (m_LpPropParam != nullptr)
		{
			std::vector<CString>& listElementTable = m_LpPropParam->get()->GetRightElementName();
			for (auto strElementName : listElementTable)
			{
				String^ strElementNameClr = gcnew String(strElementName);
				listRightElementName->Add(strElementNameClr);
			}
		}
		return listRightElementName;
	}
	BOOL CPropParamClr::SetRightElementName(System::Collections::Generic::List<String^>^ a_listRightElementName)
	{
		ASSERT(a_listRightElementName);
		if (!a_listRightElementName)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetRightElementName: invalid SetRightElementName list pointer."));
			return false;
		}
		bool bResult = false;

		if (m_LpPropParam != nullptr)
		{
			std::vector<CString> listElementNameTables;
			for (int i = 0; i < (int)a_listRightElementName->Count; i++)
			{
				listElementNameTables.push_back(a_listRightElementName[i]);
			}

			bResult = m_LpPropParam->get()->SetRightElementName(listElementNameTables);
		}

		return bResult;
	}
//////////////////////////////////////////////////////////////////////////////////
////
////	CPropParamImageClr
//////////////////////////////////////////////////////////////////////////////////
//	CPropParamImageClr::CPropParamImageClr()
//	{
//		m_LpPropParamImage = new CPropParamImagePtr(new CPropParamImage());
//	}
//
//	CPropParamImageClr::CPropParamImageClr(CPropParamClr^ a_poSource)
//	{
//		if (a_poSource == nullptr)
//		{
//			LogErrorTrace(__FILE__, __LINE__, _T("CPropParamImageClr: invalid hole"));
//			return;
//		}
//
//		CPropParamPtr pPropParam = a_poSource->GetPropParamPtr();
//		ASSERT(pPropParam);
//		if (!pPropParam)
//		{
//			LogErrorTrace(__FILE__, __LINE__, _T("CPropParamImageClr: invalid hole"));
//			return;
//		}
//
//		m_LpPropParamImage = new CPropParamImagePtr(new CPropParamImage());
//		
//	}
//
//	CPropParamImageClr::CPropParamImageClr(CPropParamImage* a_poSource)
//	{
//		if (a_poSource == nullptr)
//		{
//			LogErrorTrace(__FILE__, __LINE__, _T("CHoleClr: invalid hole"));
//			return;
//		}
//
//		m_LpPropParamImage = new CPropParamImagePtr(new CPropParamImage(a_poSource));
//	}
//
//	CPropParamImageClr::CPropParamImageClr(CPropParamImagePtr a_poSource)
//	{
//		if (a_poSource == nullptr)
//		{
//			LogErrorTrace(__FILE__, __LINE__, _T("CHoleClr: invalid hole"));
//			return;
//		}
//
//		m_LpPropParamImage = new CPropParamImagePtr(new CPropParamImage(a_poSource.get()));
//	}
//
//	CPropParamImageClr::!CPropParamImageClr()
//	{
//		if (m_LpPropParamImage != nullptr)
//		{
//			delete m_LpPropParamImage;
//			m_LpPropParamImage = nullptr;
//		}
//	}
//
//	CPropParamImageClr::~CPropParamImageClr()
//	{
//		if (m_LpPropParamImage != nullptr)
//		{
//			delete m_LpPropParamImage;
//			m_LpPropParamImage = nullptr;
//		}
//	}
//
//	CPropParamImagePtr CPropParamImageClr::GetCPropParamImagePtr()
//	{			
//		return *m_LpPropParamImage;
//	}
//
//	bool  CPropParamImageClr::SetPropertyItems()
//	{
//		if (m_LpPropParamImage == nullptr)
//		{
//			LogErrorTrace(__FILE__, __LINE__, _T("SetPropertyItems: invalid pointer."));
//			return false;
//		}
//		CPropParamImagePtr pPropParam = GetCPropParamImagePtr();
//		ASSERT(pPropParam);
//		if (!pPropParam)
//		{
//			LogErrorTrace(__FILE__, __LINE__, _T("(SetPropertyItems)PropParamPtr = null"));
//			return false;
//		}
//
//		pPropParam->SetPropertyItems();
//
//		return true;
//
//	}
//
//
//
//	////////////////////////////////////////////////////////////////////////////////
//	//
//	//	CPropParamGridClr
//	////////////////////////////////////////////////////////////////////////////////
//	CPropParamGridClr::CPropParamGridClr()
//	{
//		m_LpPropParamGrid = new CPropParamGridPtr(new CPropParamGrid());
//	}
//
//	CPropParamGridClr::CPropParamGridClr(CPropParamClr^ a_poSource)
//	{
//		if (a_poSource == nullptr)
//		{
//			LogErrorTrace(__FILE__, __LINE__, _T("CPropParamGridClr: invalid hole"));
//			return;
//		}
//
//		CPropParamPtr pPropParam = a_poSource->GetPropParamPtr();
//		ASSERT(pPropParam);
//		if (!pPropParam)
//		{
//			LogErrorTrace(__FILE__, __LINE__, _T("CPropParamGridClr: invalid hole"));
//			return;
//		}
//
//		m_LpPropParamGrid = new CPropParamGridPtr(new CPropParamGrid());
//	}
//
//	CPropParamGridClr::CPropParamGridClr(CPropParamGrid* a_poSource)
//	{
//		if (a_poSource == nullptr)
//		{
//			LogErrorTrace(__FILE__, __LINE__, _T("CPropParamGridClr: invalid hole"));
//			return;
//		}
//
//		m_LpPropParamGrid = new CPropParamGridPtr(new CPropParamGrid(a_poSource));
//	}
//
//	CPropParamGridClr::CPropParamGridClr(CPropParamGridPtr a_poSource)
//	{
//		if (a_poSource == nullptr)
//		{
//			LogErrorTrace(__FILE__, __LINE__, _T("CPropParamGridClr: invalid hole"));
//			return;
//		}
//
//		m_LpPropParamGrid = new CPropParamGridPtr(new CPropParamGrid(a_poSource.get()));
//	}
//
//	CPropParamGridClr::~CPropParamGridClr()
//	{
//		if (m_LpPropParamGrid != nullptr)
//		{
//			delete m_LpPropParamGrid;
//			m_LpPropParamGrid = nullptr;
//		}
//	}
//
//	CPropParamGridClr::!CPropParamGridClr()
//	{
//		if (m_LpPropParamGrid != nullptr)
//		{
//			delete m_LpPropParamGrid;
//			m_LpPropParamGrid = nullptr;
//		}
//	}
//
//	CPropParamGridPtr CPropParamGridClr::GetCPropParamGridPtr()
//	{
//		return *m_LpPropParamGrid;
//	}
//	bool  CPropParamGridClr::SetPropertyItems()
//	{
//
//		if (m_LpPropParamGrid == nullptr)
//		{
//			LogErrorTrace(__FILE__, __LINE__, _T("SetPropertyItems: invalid pointer."));
//			return false;
//		}
//		CPropParamGridPtr pPropParamGrid = GetCPropParamGridPtr();
//		ASSERT(pPropParamGrid);
//		if (!pPropParamGrid)
//		{
//			LogErrorTrace(__FILE__, __LINE__, _T("(SetPropertyItems)PropParamPtr = null"));
//			return false;
//		}
//
//		pPropParamGrid->SetPropertyItems();
//
//		return true;
//
//	}
//
//
//
//	////////////////////////////////////////////////////////////////////////////////
//	//
//	//	CPropParamChartClr
//
//	////////////////////////////////////////////////////////////////////////////////
//	CPropParamChartClr::CPropParamChartClr()
//	{
//		m_LpPropParamChart = new CPropParamChartPtr(new CPropParamChart());
//	}
//	CPropParamChartClr::CPropParamChartClr(CPropParamClr^ a_poSource)
//	{
//		if (a_poSource == nullptr)
//		{
//			LogErrorTrace(__FILE__, __LINE__, _T("CPropParamChartClr: invalid hole"));
//			return;
//		}
//
//		CPropParamPtr pPropParam = a_poSource->GetPropParamPtr();
//		ASSERT(pPropParam);
//		if (!pPropParam)
//		{
//			LogErrorTrace(__FILE__, __LINE__, _T("CPropParamChartClr: invalid hole"));
//			return;
//		}
//
//		m_LpPropParamChart = new CPropParamChartPtr(new CPropParamChart());
//
//
//	}
//	CPropParamChartClr::CPropParamChartClr(CPropParamChart* a_poSource)
//	{
//		if (a_poSource == nullptr)
//		{
//			LogErrorTrace(__FILE__, __LINE__, _T("CPropParamChartClr: invalid hole"));
//			return;
//		}
//
//		m_LpPropParamChart = new CPropParamChartPtr(new CPropParamChart(a_poSource));
//	}
//
//	CPropParamChartClr::CPropParamChartClr(CPropParamChartPtr a_poSource)
//	{
//		if (a_poSource == nullptr)
//		{
//			LogErrorTrace(__FILE__, __LINE__, _T("CPropParamChartClr: invalid hole"));
//			return;
//		}
//
//		m_LpPropParamChart = new CPropParamChartPtr(new CPropParamChart(a_poSource.get()));
//	}
//
//	CPropParamChartClr::~CPropParamChartClr()
//	{
//		if (m_LpPropParamChart != nullptr)
//		{
//			delete m_LpPropParamChart;
//			m_LpPropParamChart = nullptr;
//		}
//	}
//
//	CPropParamChartClr::!CPropParamChartClr()
//	{
//		if (m_LpPropParamChart != nullptr)
//		{
//			delete m_LpPropParamChart;
//			m_LpPropParamChart = nullptr;
//		}
//	}
//	
//	CPropParamChartPtr CPropParamChartClr::GetCPropParamChartPtr()
//	{
//		return *m_LpPropParamChart;
//	}
//
//	bool  CPropParamChartClr::SetPropertyItems()
//	{
//
//		if (m_LpPropParamChart == nullptr)
//		{
//			LogErrorTrace(__FILE__, __LINE__, _T("SetPropertyItems: invalid pointer."));
//			return false;
//		}
//		CPropParamChartPtr pPropParam = GetCPropParamChartPtr();
//		ASSERT(pPropParam);
//		if (!pPropParam)
//		{
//			LogErrorTrace(__FILE__, __LINE__, _T("(SetPropertyItems)pPropParam = null"));
//			return false;
//		}
//
//		pPropParam->SetPropertyItems();
//		
//		return true;
//
//	}
//


}