OTS/OTSCPP/OTSClrInterface/ReportCalculateClr/PropParamClr.cpp

#include "stdafx.h"
#include "PropParamClr.h"
#include <COTSUtilityDllFunExport.h>
#include "OTSParticleClr.h"

namespace OTSCLRINTERFACE {
	using namespace OTSCLRINTERFACE;
	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;
	}



	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;
	}

	


	// 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;
	}

	
	//获取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;
	}

	

	//获取相关属性值
	//	输入：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;
	}

	
	// 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;
	}



}